black reformat

Author: rmfranken

src/strings2things/app/api/endpoints.py

@@ -4,8 +4,13 @@
 from fastapi.responses import Response
 from rdflib import Graph
 from src.strings2things.app.core.rdf_transformer import RDFTransformer
-from src.strings2things.app.core.ontology_manager import OntologyManager # Assume this exists
-from src.strings2things.app.utils.rdf_utils import parse_rdf, serialize_rdf  # Also assume or create
+from src.strings2things.app.core.ontology_manager import (
+    OntologyManager,
+)  # Assume this exists
+from src.strings2things.app.utils.rdf_utils import (
+    parse_rdf,
+    serialize_rdf,
+)  # Also assume or create
 import logging
 
 router = APIRouter()
@@ -15,10 +20,10 @@
 
 transformer = RDFTransformer(ontology_manager.get_label_map())
 
+
 @router.post("/transform")
 async def transform_rdf(
-    file: UploadFile = File(...),
-    serialization: str = Form("turtle")
+    file: UploadFile = File(...), serialization: str = Form("turtle")
 ) -> Response:
     """
     Accepts an RDF file upload, transforms it using the label map,

src/strings2things/app/core/ontology_manager.py

@@ -6,13 +6,16 @@
 
 settings = Settings()
 
+
 class OntologyManager:
     def __init__(self):
         self.graph = Graph()
         self.label_map: dict[str, str] = {}
 
     def load_ontologies(self):
-        print(f"[INFO] Connecting to SPARQL endpoint: {settings.ONTOLOGY_SPARQL_ENDPOINT}")
+        print(
+            f"[INFO] Connecting to SPARQL endpoint: {settings.ONTOLOGY_SPARQL_ENDPOINT}"
+        )
         for graph_iri in settings.get_graph_iris():
             print(f"[INFO] Loading named graph: {graph_iri}")
             g = self._load_named_graph(settings.ONTOLOGY_SPARQL_ENDPOINT, graph_iri)
@@ -23,12 +26,14 @@ def load_ontologies(self):
     def _load_named_graph(self, endpoint: str, graph_iri: str) -> Graph:
         sparql = SPARQLWrapper(endpoint)
         sparql.setCredentials(settings.GRAPHDB_USERNAME, settings.GRAPHDB_PASSWORD)
-        sparql.setQuery(f"""
+        sparql.setQuery(
+            f"""
             CONSTRUCT {{ ?s ?p ?o }}
             WHERE {{
                 GRAPH <{graph_iri}> {{ ?s ?p ?o }}
             }}
-        """)
+        """
+        )
         sparql.setReturnFormat(TURTLE)
         result = sparql.query().convert()
 
@@ -69,7 +74,9 @@ def _build_label_map(self):
         print(f"[INFO] Label map built with {len(self.label_map)} unambiguous labels.")
 
     def _check_ambiguities(self, seen: dict[str, str | list[str]]) -> dict[str, str]:
-        ambiguous_labels = {label for label, iris in seen.items() if isinstance(iris, list)}
+        ambiguous_labels = {
+            label for label, iris in seen.items() if isinstance(iris, list)
+        }
 
         if ambiguous_labels:
             msg = f"Found ambiguous labels: {', '.join(sorted(ambiguous_labels))} \n Please resolve these in your ontology before proceeding."
@@ -79,7 +86,9 @@ def _check_ambiguities(self, seen: dict[str, str | list[str]]) -> dict[str, str]
                 print(f"[WARNING] {msg}")
 
         # Return only unambiguous labels (those with a single IRI string)
-        return {label: iris for label, iris in seen.items() if not isinstance(iris, list)}
+        return {
+            label: iris for label, iris in seen.items() if not isinstance(iris, list)
+        }
 
     def get_label_map(self) -> dict[str, str]:
         return self.label_map

src/strings2things/app/core/rdf_transformer.py

@@ -28,7 +28,9 @@ def transform(self, input_graph: Graph) -> Graph:
 
                     # Retain original triple (to retain backward compatibility for now)
                     output_graph.add((s, p, o))
-                    output_graph.add((iri, URIRef("http://wwww.example.org/thingOf"), o))
+                    output_graph.add(
+                        (iri, URIRef("http://wwww.example.org/thingOf"), o)
+                    )
 
                     output_graph.add((s, p, iri))
 
@@ -37,18 +39,21 @@ def transform(self, input_graph: Graph) -> Graph:
                         predicate=str(p),
                         original_value=str(o),
                         replacement_iri=str(iri),
-                        reason="unambiguous match"
+                        reason="unambiguous match",
                     )
-                    continue  
+                    continue
 
-            
             output_graph.add((s, p, o))
             self.log.add_entry(
                 subject=str(s),
                 predicate=str(p),
                 original_value=str(o),
                 replacement_iri=None,
-                reason="not a string literal" if not isinstance(o, Literal) else "no match in label map"
+                reason=(
+                    "not a string literal"
+                    if not isinstance(o, Literal)
+                    else "no match in label map"
+                ),
             )
 
         return output_graph

src/strings2things/app/core/transformation_log.py

@@ -3,21 +3,26 @@
 Internal logger for recording transformation events.
 """
 
+
 class TransformationLog:
     def __init__(self):
         self.entries = []
 
-    def add_entry(self, subject, predicate, original_value, replacement_iri, reason: str):
+    def add_entry(
+        self, subject, predicate, original_value, replacement_iri, reason: str
+    ):
         """
         Record a transformation decision.
         """
-        self.entries.append({
-            "subject": subject,
-            "predicate": predicate,
-            "original": original_value,
-            "replacement": replacement_iri,
-            "reason": reason
-        })
+        self.entries.append(
+            {
+                "subject": subject,
+                "predicate": predicate,
+                "original": original_value,
+                "replacement": replacement_iri,
+                "reason": reason,
+            }
+        )
 
     def get_summary(self):
         """

src/strings2things/app/utils/rdf_utils.py

@@ -6,17 +6,18 @@
 from rdflib import Graph
 from rdflib.plugin import PluginException
 
+
 def parse_rdf(data: bytes, format: str | None = None) -> Graph:
     """
     Parses RDF data from bytes. Tries to guess format if not provided.
-    
+
     Args:
         data: RDF content as bytes.
         format: Optional RDF format (e.g., 'turtle', 'xml', 'json-ld').
 
     Returns:
         A parsed RDFLib Graph.
-    
+
     Raises:
         ValueError: If the data cannot be parsed.
     """
@@ -36,15 +37,20 @@ def parse_rdf(data: bytes, format: str | None = None) -> Graph:
 
 from rdflib import Graph
 
+
 def serialize_rdf(graph: Graph, output_format: str = "turtle") -> str:
     """
     Serialize an RDFLib Graph to the specified RDF format.
-    
+
     Args:
         graph (Graph): The RDFLib graph to serialize.
         output_format (str): The desired RDF serialization format (e.g., "turtle", "xml", "nt", "json-ld").
 
     Returns:
         str: The serialized RDF data as a string.
     """
-    return graph.serialize(format=output_format).decode("utf-8") if isinstance(graph.serialize(format=output_format), bytes) else graph.serialize(format=output_format)
+    return (
+        graph.serialize(format=output_format).decode("utf-8")
+        if isinstance(graph.serialize(format=output_format), bytes)
+        else graph.serialize(format=output_format)
+    )

tests/load_and_inspect.py

@@ -6,6 +6,7 @@
 
 from strings2things.app.core.ontology_manager import OntologyManager
 
+
 def main():
     manager = OntologyManager()
     manager.load_ontologies()
@@ -15,5 +16,6 @@ def main():
     for label, iri in sorted(label_map.items()):
         print(f"{label} → {iri}")
 
+
 if __name__ == "__main__":
     main()

tests/test_ambigous.py

@@ -5,20 +5,30 @@
 
 settings = config_module.Settings()  # use the global settings instance your app uses
 
+
 def create_ambiguous_graph():
     g = Graph()
-    g.add((URIRef("http://example.org/resource1"), 
-           URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
-           Literal("ambiguouslabel")))
-    g.add((URIRef("http://example.org/resource2"), 
-           URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
-           Literal("ambiguouslabel")))
+    g.add(
+        (
+            URIRef("http://example.org/resource1"),
+            URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
+            Literal("ambiguouslabel"),
+        )
+    )
+    g.add(
+        (
+            URIRef("http://example.org/resource2"),
+            URIRef("http://www.w3.org/2000/01/rdf-schema#label"),
+            Literal("ambiguouslabel"),
+        )
+    )
     return g
 
+
 def test_ambiguous_labels_detection_fail(monkeypatch):
     monkeypatch.setattr(
-        "strings2things.app.core.ontology_manager.settings.FAIL_ON_AMBIGUOUS_LABELS", 
-        True
+        "strings2things.app.core.ontology_manager.settings.FAIL_ON_AMBIGUOUS_LABELS",
+        True,
     )
 
     manager = OntologyManager()
@@ -28,11 +38,12 @@ def test_ambiguous_labels_detection_fail(monkeypatch):
         manager._build_label_map()
     assert "ambiguouslabel" in str(exc_info.value)
 
+
 def test_ambiguous_labels_detection_no_fail(monkeypatch):
     # Patch the *module-level* settings inside ontology_manager to False
     monkeypatch.setattr(
-        "strings2things.app.core.ontology_manager.settings.FAIL_ON_AMBIGUOUS_LABELS", 
-        False
+        "strings2things.app.core.ontology_manager.settings.FAIL_ON_AMBIGUOUS_LABELS",
+        False,
     )
 
     manager = OntologyManager()

tests/test_rdf_transformer.py

@@ -5,13 +5,15 @@
 
 EX = Namespace("http://example.org/")
 
+
 @pytest.fixture
 def label_map():
     return {
         "geology": "http://example.org/ontology#Geology",
-        "biology": "http://example.org/ontology#Biology"
+        "biology": "http://example.org/ontology#Biology",
     }
 
+
 @pytest.fixture
 def input_graph():
     g = Graph()
@@ -20,6 +22,7 @@ def input_graph():
     g.add((EX.subj3, EX.hasValue, URIRef("http://example.org/someIRI")))
     return g
 
+
 def test_rdf_transformer(label_map, input_graph):
     transformer = RDFTransformer(label_map)
     output_graph = transformer.transform(input_graph)