Merge pull request #10 from sdsc-ordes/develop

v0.1.0

Author: caviri

.env.dist

@@ -1,4 +1,5 @@
 GRAPHDB_GRAPH=
 GRAPHDB_URL={host}:{port}/repositories/{reponame}
 GRAPHDB_USER=
-GRAPHDB_PASSWORD=
+GRAPHDB_PASSWORD=
+SEARCH_THRESHOLD=75

CHANGELOG.md

@@ -2,9 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.0] - 2025-07-15
+
+### Added
+- New search engine based on Rapidfuzz
+- Performance enhanced
+- Welcome message
+
 ## [0.0.1] - 2025-06-25
 
 ### Added
 - Basic search Based on pyfuzon
 - Dockerfile for containerization.
-- GitHub Actions workflow for automated publishing and releases.
+- GitHub Actions workflow for automated publishing and releases.

pyproject.toml

@@ -6,7 +6,7 @@ authors = [
 description = "A microservice for fetching relevant softwares to a certain search term + filters"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.0.1"
+version = "0.1.0"
 
 dependencies = [
     "fastapi==0.115.11",
@@ -18,6 +18,7 @@ dependencies = [
     "requests==2.32.3",
     "pydantic==2.10.3",
     "pyfuzon==0.4.0",
+    "RapidFuzz==3.13.0"
 ]
 
 [dependency-groups]

src/imaging_plaza_search/config.py

@@ -0,0 +1,11 @@
+from rdflib import URIRef
+
+LABEL_PREDICATES_WEIGHTED = [
+    (URIRef("http://schema.org/name"), 1.0),
+    # (URIRef("http://www.w3.org/2000/01/rdf-schema#label"), 0.9),
+    (URIRef("http://schema.org/description"), 0.5),
+    (URIRef("http://schema.org/featureList"), 0.6),
+    (URIRef("http://schema.org/programmingLanguage"), 0.5),
+    (URIRef("http://schema.org/keywords"), 0.5),
+    (URIRef("https://imaging-plaza.epfl.ch/ontology#relatedToOrganization"), 0.5),
+]

src/imaging_plaza_search/data_fetch.py

@@ -1,116 +1,98 @@
 from typing import List, Optional
 from imaging_plaza_search.models import Filter
-from SPARQLWrapper import SPARQLWrapper, N3
-from urllib.error import HTTPError  # Import HTTPError
+from SPARQLWrapper import SPARQLWrapper, N3, JSON
+from urllib.error import HTTPError
 from rdflib import Graph
 
 
-def get_data_from_graphdb(
-    db_host: str,
-    db_user: str,
-    db_password: str,
-    filters: Optional[List[Filter]],
-    graph: str,
-) -> str:
-    """
-    Constructs and executes a SPARQL CONSTRUCT query against a GraphDB instance,
-    using the provided filters, and returns the result as a UTF-8 decoded string.
-
-    Parameters:
-        db_host (str): The GraphDB endpoint URL.
-        db_user (str): The username for authentication.
-        db_password (str): The password for authentication.
-        filters (Optional[List[Filter]]): A list of filter objects to build the query.
-        graph (str): The graph IRI to query.
-
-    Returns:
-        str: The SPARQL CONSTRUCT query result in N-Triples format as a UTF-8 string.
+def build_filter_conditions(filters: Optional[List[Filter]]) -> str:
+    if not filters:
+        return ""
 
-    Raises:
-        RuntimeError: If an HTTPError occurs during the SPARQL query execution.
-    """
+    conditions = []
+    for filter in filters:
+        values = ", ".join(f'"{val}"' for val in filter.value)
+        condition = (
+            f"?s {filter.schema_key} ?{filter.key}. FILTER(?{filter.key} IN ({values}))"
+        )
+        conditions.append(condition)
+    return " ".join(conditions)
 
-    is_connected = test_connection(db_host, db_user, db_password)
 
-    print(is_connected)
+def execute_query(
+    db_host: str, db_user: str, db_password: str, query: str, return_format: str = "nt"
+) -> str:
+    sparql = SPARQLWrapper(db_host)
+    sparql.setQuery(query)
+    sparql.setCredentials(user=db_user, passwd=db_password)
 
-    if not filters:
-        return ""
+    if return_format == "nt":
+        sparql.setReturnFormat(N3)
+        sparql.addCustomHttpHeader("Accept", "application/n-triples")
+    else:
+        sparql.setReturnFormat(JSON)
 
-    conditions: List[str] = []
-    for filter in filters:
-        if filter.value:
-            values = ", ".join(f'"{val}"' for val in filter.value)
-            condition = (
-                f"?s {filter.schema_key} ?{filter.key}. FILTER(?{filter.key} IN ({values}))"
-            )
-            conditions.append(condition)
+    try:
+        result_bytes = sparql.query().convert()
+        return (
+            result_bytes.decode("utf-8")
+            if isinstance(result_bytes, bytes)
+            else result_bytes
+        )
+    except HTTPError as e:
+        raise RuntimeError(f"HTTPError during SPARQL query: {e}")
 
-    filter_conditions: str = " ".join(conditions)
 
-    query: str = f"""
+def get_literals_query(graph: str, filters: Optional[List[Filter]]) -> str:
+    filter_conditions = build_filter_conditions(filters)
+    return f"""
     PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
     PREFIX schema: <http://schema.org/>
     PREFIX imag: <https://imaging-plaza.epfl.ch/ontology#>
     PREFIX fuzon: <http://example.org/fuzon#>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
 
-    CONSTRUCT 
-    {{
-        ?s fuzon:searchIndexPredicate ?literal .
-        ?s ?p ?o .
-        ?o ?p2 ?o2 .
-        ?o2 ?p3 ?o3 .
+    CONSTRUCT {{
+        ?s ?p ?o
     }}
     WHERE {{
         GRAPH <{graph}> {{
+        ?s ?p ?o .
             ?s rdf:type schema:SoftwareSourceCode ;
-            ?p ?o .
-
-            OPTIONAL {{ 
-                ?o ?p2 ?o2 .
-                OPTIONAL {{ ?o2 ?p3 ?o3 }} 
-            }}
-
+            #    OPTIONAL {{?s rdfs:label ?label; }}
+            #    OPTIONAL {{?s schema:name ?name ; }}
             FILTER(isLiteral(?o))
-
-            BIND(str(?o) as ?literal)
+               .
             {filter_conditions}
         }}
     }}
     """
 
-    sparql = SPARQLWrapper(db_host)
-    sparql.setQuery(query)
-    sparql.setReturnFormat(N3)
-    sparql.setCredentials(user=db_user, passwd=db_password)
-    sparql.addCustomHttpHeader("Accept", "application/n-triples")
 
-    try:
-        result_bytes: bytes = sparql.query().convert()
-        return result_bytes.decode("utf-8")
-    
-    except HTTPError as e:
-        raise RuntimeError(f"HTTPError during SPARQL query: {e}")
+def get_subjects_query(graph: str) -> str:
+    return f"""
+    PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    PREFIX schema: <http://schema.org/>
 
-def test_connection(db_host: str, db_user: str, db_password: str) -> bool:
+    SELECT DISTINCT ?s
+    WHERE {{
+        GRAPH <{graph}> {{
+            ?s rdf:type schema:SoftwareSourceCode .
+        }}
+    }}
     """
-    Tests the connection to the GraphDB instance by executing a simple SPARQL query.
 
-    Parameters:
-        db_host (str): The GraphDB endpoint URL.
-        db_user (str): The username for authentication.
-        db_password (str): The password for authentication.
 
-    Returns:
-        bool: True if the connection is successful, False otherwise.
-    """
+def test_connection(db_host: str, db_user: str, db_password: str) -> bool:
     sparql = SPARQLWrapper(db_host)
     sparql.setCredentials(user=db_user, passwd=db_password)
     sparql.setQuery("SELECT ?s WHERE { ?s ?p ?o } LIMIT 1")
-    sparql.setReturnFormat(N3)
+    sparql.setReturnFormat(JSON)
 
     try:
         sparql.query()
         return True
     except HTTPError as e:
-        raise RuntimeError(f"HTTPError during connection test: {e}. Please check that your GRAPHDB_URL is ended in /repositories/imagingplaza")
+        raise RuntimeError(
+            f"HTTPError during connection test: {e}. Ensure your GRAPHDB_URL ends in /repositories/..."
+        )