iolanta 2.1.10__py3-none-any.whl → 2.1.12__py3-none-any.whl

iolanta/sparqlspace/processor.py

@@ -1,17 +1,12 @@
+# noqa: WPS201, WPS202, WPS402
 import dataclasses
 import datetime
-import re
-import time
 from pathlib import Path
 from threading import Lock
-from types import MappingProxyType
 from typing import Any, Iterable, Mapping
 
-import diskcache
 import funcy
 import loguru
-import platformdirs
-import reasonable
 import requests
 import yaml_ld
 from nanopub import NanopubClient
@@ -35,74 +30,36 @@ from iolanta.namespaces import (  # noqa: WPS235
     DCTERMS,
     FOAF,
     IOLANTA,
-    LOCAL,
     META,
     OWL,
-    PROV,
     RDF,
     RDFS,
     VANN,
 )
-from iolanta.parse_quads import NORMALIZE_TERMS_MAP, parse_quads
+from iolanta.parse_quads import parse_quads
+from iolanta.sparqlspace.redirects import apply_redirect
 
 REASONING_ENABLED = True
 OWL_REASONING_ENABLED = False
 
-INFERENCE_DIR = Path(__file__).parent / 'inference'
-INDICES = [
-    URIRef('https://iolanta.tech/visualizations/index.yaml'),
+INFERENCE_DIR = Path(__file__).parent / "inference"
+INDICES = [  # noqa: WPS407
+    URIRef("https://iolanta.tech/visualizations/index.yaml"),
 ]
 
 
-REDIRECTS = MappingProxyType({
-    # FIXME This is presently hardcoded; we need to
-    #   - either find a way to resolve these URLs automatically,
-    #   - or create a repository of those redirects online.
-    'http://purl.org/vocab/vann/': URIRef(
-        'https://vocab.org/vann/vann-vocab-20100607.rdf',
-    ),
-    URIRef(DC): URIRef(DCTERMS),
-    URIRef(RDF): URIRef(RDF),
-    URIRef(RDFS): URIRef(RDFS),
-    URIRef(OWL): URIRef(OWL),
-
-    # Redirect FOAF namespace to GitHub mirror
-    URIRef('https?://xmlns.com/foaf/0.1/.+'): URIRef(
-        'https://raw.githubusercontent.com/foaf/foaf/refs/heads/master/xmlns.com/htdocs/foaf/0.1/index.rdf',
-    ),
-    URIRef('https://www.nanopub.org/nschema'): URIRef(
-        'https://www.nanopub.net/nschema#',
-    ),
-    URIRef('https://nanopub.org/nschema'): URIRef(
-        'https://nanopub.net/nschema#',
-    ),
-    URIRef(PROV): URIRef('https://www.w3.org/ns/prov-o'),
-
-    # Convert lexvo.org/id URLs to lexvo.org/data URLs
-    r'https://lexvo\.org/id/(.+)': r'http://lexvo.org/data/\1',
-    r'https://www\.lexinfo\.net/(.+)': r'http://www.lexinfo.net/\1',
-})
-
-
-@diskcache.Cache(
-    directory=str(
-        platformdirs.user_cache_path(
-            appname='iolanta',
-        ) / 'find_retractions_for',
-    ),
-).memoize(expire=datetime.timedelta(days=8).total_seconds())
 def find_retractions_for(nanopublication: URIRef) -> set[URIRef]:
     """Find nanopublications that retract the given one."""
     # See https://github.com/fair-workflows/nanopub/issues/168 for
     # context of this dirty hack.
-    use_server = 'http://grlc.nanopubs.lod.labs.vu.nl/api/local/local/'
+    use_server = "http://grlc.nanopubs.lod.labs.vu.nl/api/local/local/"
 
     client = NanopubClient(use_server=use_server)
     client.grlc_urls = [use_server]
 
     http_url = str(nanopublication).replace(
-        'https://',
-        'http://',
+        "https://",
+        "http://",
     )
 
     try:
@@ -113,60 +70,72 @@ def find_retractions_for(nanopublication: URIRef) -> set[URIRef]:
     return {URIRef(retraction) for retraction in retractions}
 
 
-def _extract_from_mapping(  # noqa: WPS213
+def _extract_from_mapping(  # noqa: WPS213, WPS231
     algebra: Mapping[str, Any],
 ) -> Iterable[URIRef | Variable]:
-    match algebra.name:
-        case 'SelectQuery' | 'AskQuery' | 'Project' | 'Distinct' | 'Slice':
-            yield from extract_mentioned_urls(algebra['p'])
+    match algebra.name:  # noqa: WPS242
+        case "SelectQuery" | "AskQuery" | "Project" | "Distinct" | "Slice":
+            yield from extract_mentioned_urls(algebra["p"])  # noqa: WPS226
 
-        case 'BGP':
-            yield from [   # noqa: WPS353, WPS221
+        case "BGP":
+            yield from [  # noqa: WPS353, WPS221
                 term
-                for triple in algebra['triples']
+                for triple in algebra["triples"]
                 for term in triple
-                if isinstance(term, URIRef)
+                if isinstance(term, (URIRef, Variable))
             ]
 
-        case 'Filter' | 'UnaryNot' | 'OrderCondition':
-            yield from extract_mentioned_urls(algebra['expr'])   # noqa: WPS204
+        case "Filter" | "UnaryNot" | "OrderCondition":
+            yield from extract_mentioned_urls(algebra["expr"])  # noqa: WPS204, WPS226
 
-        case built_in if built_in.startswith('Builtin_'):
-            yield from extract_mentioned_urls(algebra['arg'])
+        case "Builtin_EXISTS":
+            # Builtin_EXISTS uses 'graph' instead of 'arg'
+            yield from extract_mentioned_urls(algebra["graph"])
 
-        case 'RelationalExpression':
-            yield from extract_mentioned_urls(algebra['expr'])
-            yield from extract_mentioned_urls(algebra['other'])
+        case built_in if built_in.startswith("Builtin_"):
+            # Some built-ins may not have an 'arg' key
+            arg_value = algebra.get("arg")
+            if arg_value is not None:
+                yield from extract_mentioned_urls(arg_value)
 
-        case 'LeftJoin':
-            yield from extract_mentioned_urls(algebra['p1'])
-            yield from extract_mentioned_urls(algebra['p2'])
-            yield from extract_mentioned_urls(algebra['expr'])
+        case "RelationalExpression":
+            yield from extract_mentioned_urls(algebra["expr"])
+            yield from extract_mentioned_urls(algebra["other"])
 
-        case 'Join':
-            yield from extract_mentioned_urls(algebra['p1'])
-            yield from extract_mentioned_urls(algebra['p2'])
+        case "LeftJoin":
+            yield from extract_mentioned_urls(algebra["p1"])
+            yield from extract_mentioned_urls(algebra["p2"])
+            yield from extract_mentioned_urls(algebra["expr"])
 
-        case 'ConditionalOrExpression' | 'ConditionalAndExpression':
-            yield from extract_mentioned_urls(algebra['expr'])
-            yield from extract_mentioned_urls(algebra['other'])
+        case "Join" | "Union":
+            yield from extract_mentioned_urls(algebra["p1"])
+            yield from extract_mentioned_urls(algebra["p2"])
 
-        case 'OrderBy':
-            yield from extract_mentioned_urls(algebra['p'])
-            yield from extract_mentioned_urls(algebra['expr'])
+        case "Extend":
+            # Extend is used for BIND expressions - process pattern and expression
+            yield from extract_mentioned_urls(algebra["p"])
+            yield from extract_mentioned_urls(algebra["expr"])
 
-        case 'TrueFilter':
+        case "ConditionalOrExpression" | "ConditionalAndExpression":
+            yield from extract_mentioned_urls(algebra["expr"])
+            yield from extract_mentioned_urls(algebra["other"])
+
+        case "OrderBy":
+            yield from extract_mentioned_urls(algebra["p"])
+            yield from extract_mentioned_urls(algebra["expr"])
+
+        case "TrueFilter":
             return
 
-        case 'Graph':
-            yield from extract_mentioned_urls(algebra['p'])
-            yield from extract_mentioned_urls(algebra['term'])
+        case "Graph":
+            yield from extract_mentioned_urls(algebra["p"])
+            yield from extract_mentioned_urls(algebra["term"])
 
         case unknown_name:
-            formatted_keys = ', '.join(algebra.keys())
+            formatted_keys = ", ".join(algebra.keys())
             loguru.logger.info(
-                'Unknown SPARQL expression '
-                f'{unknown_name}({formatted_keys}): {algebra}',
+                "Unknown SPARQL expression "
+                f"{unknown_name}({formatted_keys}): {algebra}",
             )
             return
 
@@ -192,7 +161,7 @@ def extract_mentioned_urls(
         case unknown_algebra:
             algebra_type = type(unknown_algebra)
             raise ValueError(
-                f'Algebra of unknown type {algebra_type}: {unknown_algebra}',
+                f"Algebra of unknown type {algebra_type}: {unknown_algebra}",
             )
 
 
@@ -208,7 +177,10 @@ def normalize_term(term: Node) -> Node:
       * A dirty hack;
       * Based on hard code.
     """
-    return NORMALIZE_TERMS_MAP.get(term, term)
+    if isinstance(term, URIRef):
+        return apply_redirect(term)
+
+    return term
 
 
 def resolve_variables(
@@ -223,10 +195,7 @@ def resolve_variables(
 
             case Variable() as query_variable:
                 variable_value = bindings.get(str(query_variable))
-                if (
-                    variable_value is not None
-                    and isinstance(variable_value, URIRef)
-                ):
+                if variable_value is not None and isinstance(variable_value, URIRef):
                     yield variable_value
 
 
@@ -258,74 +227,49 @@ class Skipped:
 LoadResult = Loaded | Skipped
 
 
-def _extract_nanopublication_uris(
+def _extract_nanopublication_uris(  # noqa: WPS231
     algebra: CompValue,
 ) -> Iterable[URIRef]:
     """Extract nanopublications to get retracting information for."""
-    match algebra.name:
-        case 'SelectQuery' | 'AskQuery' | 'Project' | 'Distinct' | 'Graph':
-            yield from _extract_nanopublication_uris(algebra['p'])
-        case 'ConstructQuery':
+    match algebra.name:  # noqa: WPS242
+        case "SelectQuery" | "AskQuery" | "Project" | "Distinct" | "Graph":
+            yield from _extract_nanopublication_uris(algebra["p"])
+        case "ConstructQuery":
             # CONSTRUCT queries don't have nanopublication URIs in bindings
             return
 
-        case 'Slice':
-            yield from _extract_nanopublication_uris(algebra['p'])
+        case "Slice":
+            yield from _extract_nanopublication_uris(algebra["p"])
 
-        case 'BGP':
-            for retractor, retracts, retractee in algebra['triples']:
+        case "BGP":
+            for retractor, retracts, retractee in algebra["triples"]:
                 if retracts == URIRef(
-                    'https://purl.org/nanopub/x/retracts',
+                    "https://purl.org/nanopub/x/retracts",
                 ) and isinstance(retractor, Variable):
                     yield retractee
 
-        case 'LeftJoin' | 'Join':
-            yield from _extract_nanopublication_uris(algebra['p1'])
-            yield from _extract_nanopublication_uris(algebra['p2'])
+        case "LeftJoin" | "Join" | "Union":
+            yield from _extract_nanopublication_uris(algebra["p1"])
+            yield from _extract_nanopublication_uris(algebra["p2"])
+
+        case "Extend":
+            # Extend is used for BIND expressions - process the pattern recursively
+            yield from _extract_nanopublication_uris(algebra["p"])
 
-        case 'Filter' | 'OrderBy':
+        case "Filter" | "OrderBy":
             return
 
         case unknown_name:
             raise ValueError(
-                f'Unknown algebra name: {unknown_name}, '
-                f'content: {algebra}',
+                f"Unknown algebra name: {unknown_name}, content: {algebra}",
             )
 
 
-def apply_redirect(source: URIRef) -> URIRef:   # noqa: WPS210
-    """
-    Rewrite the URL using regex patterns and group substitutions.
-
-    For each pattern in REDIRECTS:
-    - If the pattern matches the source URI
-    - Replace the source with the destination, substituting any regex groups
-    """
-    source_str = str(source)
-
-    for pattern, destination in REDIRECTS.items():
-        pattern_str = str(pattern)
-        destination_str = str(destination)
-
-        match = re.match(pattern_str, source_str)
-        if match:
-            # Replace any group references in the destination
-            # (like \1, \2, etc.)
-            redirected_uri = re.sub(
-                pattern_str,
-                destination_str,
-                source_str,
-            )
-            return URIRef(redirected_uri)
-
-    return source
-
-
 def extract_triples(algebra: CompValue) -> Iterable[tuple[Node, Node, Node]]:
     """Extract triples from a SPARQL query algebra instance."""
     if isinstance(algebra, CompValue):
         for key, value in algebra.items():  # noqa: WPS110
-            if key == 'triples':
+            if key == "triples":
                 yield from value
 
             else:
@@ -361,13 +305,13 @@ class NanopubQueryPlugin:
 
         FIXME: Can we cache this?
         """
-        response = requests.post(   # noqa: S113
-            'https://query.knowledgepixels.com/repo/full',
+        response = requests.post(  # noqa: S113
+            "https://query.knowledgepixels.com/repo/full",
             data={
-                'query': 'CONSTRUCT WHERE { ?instance a <%s> }' % class_uri,
+                "query": "CONSTRUCT WHERE { ?instance a <%s> }" % class_uri,
             },
             headers={
-                'Accept': 'application/ld+json',
+                "Accept": "application/ld+json",
             },
         )
 
@@ -375,21 +319,21 @@ class NanopubQueryPlugin:
 
         self.graph.get_context(BNode()).parse(
             data=response.text,
-            format='json-ld',
+            format="json-ld",
         )
 
     def _is_from_nanopubs(self, class_uri: URIRef) -> bool:
         if not isinstance(class_uri, URIRef):
-            raise ValueError(f'Not a URIRef: {class_uri}')
+            raise ValueError(f"Not a URIRef: {class_uri}")
 
-        return self.graph.query(   # noqa: WPS462
+        return self.graph.query(  # noqa: WPS462
             """
             ASK WHERE {
                 ?_whatever <https://purl.org/nanopub/x/introduces> $class
             }
             """,
             initBindings={
-                'class': class_uri,
+                "class": class_uri,
             },
         ).askAnswer
 
@@ -419,7 +363,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
             self.graph._indices_loaded = True
 
-    def query(   # noqa: WPS211, WPS210, WPS231, C901
+    def query(  # noqa: WPS211, WPS210, WPS231, WPS213, C901
         self,
         strOrQuery,
         initBindings=None,
@@ -436,7 +380,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
         initBindings = initBindings or {}
         initNs = initNs or {}
-        
+
         if isinstance(strOrQuery, Query):
             query = strOrQuery
 
@@ -445,7 +389,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             query = translateQuery(parse_tree, base, initNs)
 
         # Only extract nanopublications from SELECT/ASK queries, not CONSTRUCT
-        if query.algebra.name != 'ConstructQuery':
+        if query.algebra.name != "ConstructQuery":
             self.load_retracting_nanopublications_by_query(
                 query=query,
                 bindings=initBindings,
@@ -461,21 +405,24 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         )
 
         # Filter out inference graph names (they're not URLs to load)
-        urls = {url for url in urls if not str(url).startswith('inference:')}
+        urls = {url for url in urls if not str(url).startswith("inference:")}
 
         for url in urls:
             try:
                 self.load(url)
             except Exception as err:
-                self.logger.exception(f'Failed to load {url}: {err}', url, err)
+                self.logger.exception(f"Failed to load {url}: {err}", url, err)
 
         # Run inference if there's new data since last inference run
         # (after URLs are loaded so inference can use the loaded data)
-        if self.graph.last_not_inferred_source is not None:
-            self.logger.debug(f'Running inference, last_not_inferred_source: {self.graph.last_not_inferred_source}')
+        if self.graph.last_not_inferred_source is not None:  # noqa: WPS504
+            last_source = self.graph.last_not_inferred_source
+            self.logger.debug(
+                f"Running inference, last_not_inferred_source: {last_source}"
+            )  # noqa: WPS237
             self._run_inference()
         else:
-            self.logger.debug('Skipping inference, last_not_inferred_source is None')
+            self.logger.debug("Skipping inference, last_not_inferred_source is None")
 
         NanopubQueryPlugin(graph=self.graph)(query, bindings=initBindings)
 
@@ -486,45 +433,51 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             query_result = evalQuery(self.graph, query, initBindings, base)
 
             try:
-                bindings = list(query_result['bindings'])
+                bindings = list(query_result["bindings"])
             except KeyError:
                 # This was probably an ASK query
                 return query_result
 
             for row in bindings:
                 break
-                for _, maybe_iri in row.items():
-                    if (
-                        isinstance(maybe_iri, URIRef)
-                        and isinstance(self.load(maybe_iri), Loaded)
+                for _, maybe_iri in row.items():  # noqa: WPS427
+                    if isinstance(maybe_iri, URIRef) and isinstance(
+                        self.load(maybe_iri), Loaded
                     ):
-                        is_anything_loaded = True   # noqa: WPS220
-                        self.logger.info(   # noqa: WPS220
-                            'Newly loaded: {uri}',
+                        is_anything_loaded = True  # noqa: WPS220
+                        self.logger.info(  # noqa: WPS220
+                            "Newly loaded: {uri}",
                             uri=maybe_iri,
                         )
 
-        query_result['bindings'] = bindings
+        query_result["bindings"] = bindings
         return query_result
 
     def _is_loaded(self, uri: URIRef) -> bool:
         """Find out if this URI in the graph already."""
-        return funcy.first(
-            self.graph.quads((
-                uri,
-                IOLANTA['last-loaded-time'],
-                None,
-                META,
-            )),
-        ) is not None
+        return (
+            funcy.first(
+                self.graph.quads(
+                    (
+                        uri,
+                        IOLANTA["last-loaded-time"],
+                        None,
+                        META,
+                    )
+                ),
+            )
+            is not None
+        )
 
     def _mark_as_loaded(self, uri: URIRef):
-        self.graph.add((
-            uri,
-            IOLANTA['last-loaded-time'],
-            Literal(datetime.datetime.now()),
-            META,
-        ))
+        self.graph.add(
+            (
+                uri,
+                IOLANTA["last-loaded-time"],
+                Literal(datetime.datetime.now()),
+                META,
+            )
+        )
 
     def _follow_is_visualized_with_links(self, uri: URIRef):
         """Follow `dcterms:isReferencedBy` links."""
@@ -533,7 +486,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             if isinstance(visualization, URIRef):
                 self.load(visualization)
 
-    def load(   # noqa: C901, WPS210, WPS212, WPS213, WPS231
+    def load(  # noqa: C901, WPS210, WPS212, WPS213, WPS231
         self,
         source: URIRef,
     ) -> LoadResult:
@@ -545,15 +498,15 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         # Blank nodes cannot be loaded from URLs
         if isinstance(source, BNode):
             return Skipped()
-        
+
         # Also check if URIRef represents a blank node (can happen if BNode
         # was serialized to string and converted to URIRef)
-        if isinstance(source, URIRef) and str(source).startswith('_:'):
-            raise ValueError('This is actually a blank node but masked as a URIREF')
-        
+        if isinstance(source, URIRef) and str(source).startswith("_:"):
+            raise ValueError("This is actually a blank node but masked as a URIREF")
+
         url = URL(source)
 
-        if url.scheme in {'file', 'python', 'local', 'urn', 'doi'}:
+        if url.scheme in {"file", "python", "local", "urn", "doi"}:
             # FIXME temporary fix. `yaml-ld` doesn't read `context.*` files and
             #   fails.
             return Skipped()
@@ -564,14 +517,14 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             # TODO: It works differently for JSON-LD documents AFAIK. Need to
             #   double check that.
             url = url.with_fragment(None)
-            source = URIRef(str(f'{url}#'))
+            source = URIRef(str(f"{url}#"))
 
         self._follow_is_visualized_with_links(source)
 
         new_source = apply_redirect(source)
         if new_source != source:
             self.logger.info(
-                'Rewriting: {source} → {new_source}',
+                "Rewriting: {source} → {new_source}",
                 source=source,
                 new_source=new_source,
             )
@@ -584,58 +537,64 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         # FIXME This is definitely inefficient. However, python-yaml-ld caches
         #   the document, so the performance overhead is not super high.
         try:
-            _resolved_source = yaml_ld.load_document(source)['documentUrl']
+            resolved_source = yaml_ld.load_document(source)["documentUrl"]
         except NotFound as not_found:
-            self.logger.info(f'{not_found.path} | 404 Not Found')
+            self.logger.info(f"{not_found.path} | 404 Not Found")
             namespaces = [RDF, RDFS, OWL, FOAF, DC, VANN]
 
             for namespace in namespaces:
                 if not_found.path.startswith(str(namespace)):
                     self.load(URIRef(namespace))
                     self.logger.info(
-                        'Redirecting %s → namespace %s',
+                        "Redirecting %s → namespace %s",
                         not_found.path,
                         namespace,
                     )
                     return Loaded()
 
             self.logger.info(
-                '{path} | Cannot find a matching namespace',
+                "{path} | Cannot find a matching namespace",
                 path=not_found.path,
             )
 
-            self.graph.add((
-                source_uri,
-                RDF.type,
-                IOLANTA['not-found'],
-                source_uri,
-            ))
+            self.graph.add(
+                (
+                    source_uri,
+                    RDF.type,
+                    IOLANTA["not-found"],
+                    source_uri,
+                )
+            )
 
             self._mark_as_loaded(source_uri)
 
             return Loaded()
 
         except Exception as err:
-            self.logger.info(f'{source} | Failed: {err}')
-            self.graph.add((
-                URIRef(source),
-                RDF.type,
-                IOLANTA['failed'],
-                source_uri,
-            ))
+            self.logger.info(f"{source} | Failed: {err}")
+            self.graph.add(
+                (
+                    URIRef(source),
+                    RDF.type,
+                    IOLANTA["failed"],
+                    source_uri,
+                )
+            )
             self._mark_as_loaded(source_uri)
 
             return Loaded()
 
-        if _resolved_source:
-            _resolved_source_uri_ref = URIRef(_resolved_source)
-            if _resolved_source_uri_ref != URIRef(source):
-                self.graph.add((
-                    source_uri,
-                    IOLANTA['redirects-to'],
-                    _resolved_source_uri_ref,
-                ))
-                source = _resolved_source
+        if resolved_source:
+            resolved_source_uri_ref = URIRef(resolved_source)
+            if resolved_source_uri_ref != URIRef(source):
+                self.graph.add(
+                    (
+                        source_uri,
+                        IOLANTA["redirects-to"],
+                        resolved_source_uri_ref,
+                    )
+                )
+                source = resolved_source
 
         self._mark_as_loaded(source_uri)
 
@@ -643,19 +602,19 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             ld_rdf = yaml_ld.to_rdf(source)
         except ConnectionError as name_resolution_error:
             self.logger.info(
-                '%s | name resolution error: %s',
+                "%s | name resolution error: %s",
                 source,
                 str(name_resolution_error),
             )
             return Loaded()
         except ParserNotFound as parser_not_found:
-            self.logger.info(f'{source} | {parser_not_found}')
+            self.logger.info(f"{source} | {parser_not_found}")
             return Loaded()
         except YAMLLDError as yaml_ld_error:
-            self.logger.error(f'{source} | {yaml_ld_error}')
+            self.logger.error(f"{source} | {yaml_ld_error}")
             return Loaded()
         except HTTPError as http_error:
-            self.logger.warning(f'{source} | HTTP error: {http_error}')
+            self.logger.warning(f"{source} | HTTP error: {http_error}")
             return Loaded()
 
         try:
@@ -674,18 +633,15 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             )
 
         if not quads:
-            self.logger.info('{source} | No data found', source=source)
+            self.logger.info("{source} | No data found", source=source)
             return Loaded()
 
         self.graph.addN(quads)
         self.graph.last_not_inferred_source = source
 
-        into_graphs = ', '.join({
-            quad.graph
-            for quad in quads
-        })
+        into_graphs = ", ".join({quad.graph for quad in quads})
         self.logger.info(
-            f'{source} | loaded {len(quads)} triples into graphs: {into_graphs}',
+            f"{source} | loaded {len(quads)} triples into graphs: {into_graphs}",
         )
 
         return Loaded()
@@ -700,7 +656,75 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
         return term
 
-    def _run_inference(self):  # noqa: WPS231
+    def _run_inference_from_directory(  # noqa: WPS231, WPS220, WPS210
+        self,
+        inference_dir: Path,
+        graph_prefix: str = "inference",
+    ):
+        """
+        Run inference queries from a given inference directory.
+
+        For each SPARQL file in the inference directory:
+        1. Truncate the named graph `local:{graph_prefix}-{filename}`
+        2. Execute the CONSTRUCT query
+        3. Insert the resulting triples into that graph
+
+        Args:
+            inference_dir: Directory containing inference SPARQL files
+            graph_prefix: Prefix for inference graph names
+            return_count: Whether to return the count of inferred triples
+
+        Returns the total number of triples inferred.
+        """
+        if not inference_dir.exists():
+            return 0
+
+        total_inferred = 0
+        for inference_file in inference_dir.glob("*.sparql"):
+            filename = inference_file.stem  # filename without .sparql extension
+            inference_graph = URIRef(f"{graph_prefix}:{filename}")
+
+            # Truncate the inference graph
+            context = self.graph.get_context(inference_graph)
+            context.remove((None, None, None))
+
+            # Read and execute the CONSTRUCT query
+            query_text = inference_file.read_text()
+            query_result = self.graph.query(query_text)  # noqa: WPS110
+
+            # CONSTRUCT queries return a SPARQLResult with a graph attribute
+            result_graph = (
+                query_result.get("graph")
+                if isinstance(query_result, dict)
+                else query_result.graph
+            )
+            self.logger.debug(
+                f"Inference {filename}: result_graph is {result_graph}, type: {type(result_graph)}"
+            )
+            if result_graph is not None:  # noqa: WPS504
+                inferred_quads = [
+                    (s, p, o, inference_graph)  # noqa: WPS111
+                    for s, p, o in result_graph  # noqa: WPS111
+                ]
+                self.logger.debug(
+                    f"Inference {filename}: generated {len(inferred_quads)} quads"
+                )
+
+                if inferred_quads:
+                    self.graph.addN(inferred_quads)  # noqa: WPS220
+                    inferred_count = len(inferred_quads)
+                    total_inferred += inferred_count
+                    self.logger.info(  # noqa: WPS220
+                        "Inference {filename}: added {count} triples",
+                        filename=filename,
+                        count=inferred_count,
+                    )
+            else:
+                self.logger.debug(f"Inference {filename}: result_graph is None")
+
+        return total_inferred
+
+    def _run_inference(self):  # noqa: WPS231, WPS220, WPS210
         """
         Run inference queries from the inference directory.
 
@@ -710,42 +734,13 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         3. Insert the resulting triples into that graph
         """
         with self.inference_lock:
-            for inference_file in INFERENCE_DIR.glob('*.sparql'):
-                filename = inference_file.stem  # filename without .sparql extension
-                inference_graph = URIRef(f'inference:{filename}')
-
-                # Truncate the inference graph
-                context = self.graph.get_context(inference_graph)
-                context.remove((None, None, None))
-
-                # Read and execute the CONSTRUCT query
-                query_text = inference_file.read_text()
-                result = self.graph.query(query_text)
-
-                # CONSTRUCT queries return a SPARQLResult with a graph attribute
-                result_graph = result.get('graph') if isinstance(result, dict) else result.graph
-                self.logger.debug(f'Inference {filename}: result_graph is {result_graph}, type: {type(result_graph)}')
-                if result_graph is not None:
-                    inferred_quads = [
-                        (s, p, o, inference_graph)
-                        for s, p, o in result_graph
-                    ]
-                    self.logger.debug(f'Inference {filename}: generated {len(inferred_quads)} quads')
-
-                    if inferred_quads:
-                        self.graph.addN(inferred_quads)
-                        self.logger.info(
-                            'Inference {filename}: added {count} triples',
-                            filename=filename,
-                            count=len(inferred_quads),
-                        )
-                else:
-                    self.logger.debug(f'Inference {filename}: result_graph is None')
-        
+            # Run global inference (deprecated, will be removed later)
+            self._run_inference_from_directory(INFERENCE_DIR, graph_prefix="inference")
+
         # Clear the flag after running inference
         self.graph.last_not_inferred_source = None
 
-    def load_retracting_nanopublications_by_query(    # noqa: WPS231
+    def load_retracting_nanopublications_by_query(  # noqa: WPS231
         self,
         query: Query,
         bindings: dict[str, Node],