iolanta 2.1.10__tar.gz → 2.1.11__tar.gz

{iolanta-2.1.10 → iolanta-2.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iolanta
-Version: 2.1.10
+Version: 2.1.11
 Summary: Semantic Web browser
 License: MIT
 Author: Anatoly Scherbakov

iolanta-2.1.11/iolanta/mcp/cli.py

@@ -0,0 +1,24 @@
+from typing import Annotated
+
+from fastmcp import FastMCP
+
+from iolanta.cli.main import render_and_return
+
+mcp = FastMCP("Iolanta MCP Server")
+
+
+@mcp.tool()
+def render_uri(
+    uri: Annotated[str, 'URL, or file system path, to render'],
+    as_format: Annotated[str, 'Format to render as. Examples: `labeled-triple-set`, `mermaid`'],
+) -> str:
+    """Render a URI."""
+    return str(render_and_return(uri, as_format))
+
+
+def app():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    app()

{iolanta-2.1.10 → iolanta-2.1.11}/iolanta/parse_quads.py

@@ -1,6 +1,5 @@
 import dataclasses
 import hashlib
-from types import MappingProxyType
 from typing import Iterable, Optional
 from urllib.parse import unquote
 
@@ -11,11 +10,7 @@ from rdflib.term import Node
 from iolanta.errors import UnresolvedIRI
 from iolanta.models import Quad
 from iolanta.namespaces import IOLANTA, META
-
-NORMALIZE_TERMS_MAP = MappingProxyType({
-    URIRef(_url := 'http://www.w3.org/2002/07/owl'): URIRef(f'{_url}#'),
-    URIRef(_url := 'http://www.w3.org/2000/01/rdf-schema'): URIRef(f'{_url}#'),
-})
+from iolanta.sparqlspace.redirects import apply_redirect
 
 
 def parse_term(   # noqa: C901
@@ -35,8 +30,8 @@ def parse_term(   # noqa: C901
     if term_type == 'literal':
         language = term.get('language')
 
-        if datatype := term.get('datatype'):
-            datatype = URIRef(datatype)
+        datatype_raw = term.get('datatype')
+        datatype = URIRef(datatype_raw) if datatype_raw else None
 
         if language and datatype:
             datatype = None
@@ -89,7 +84,7 @@ def _parse_quads_per_subgraph(
             )
 
 
-def parse_quads(
+def parse_quads(  # noqa: WPS210
     quads_document,
     graph: URIRef,
     blank_node_prefix: str = '',
@@ -132,12 +127,20 @@ def parse_quads(
         )
 
         for quad in quads:   # noqa: WPS526
-            yield quad.replace(
-                subgraph_names | NORMALIZE_TERMS_MAP | {
-                    # To enable nanopub rendering
-                    URIRef('http://purl.org/nanopub/temp/np/'): graph,
-                },
-            ).normalize()
+            # Build replacement map with subgraph names and nanopub temp namespace
+            replacement_map = subgraph_names | {
+                # To enable nanopub rendering
+                URIRef('http://purl.org/nanopub/temp/np/'): graph,
+            }
+            
+            # Apply redirects to all URIRefs in the replacement map
+            normalized_replacement_map = {
+                apply_redirect(key) if isinstance(key, URIRef) else key: 
+                apply_redirect(value_node) if isinstance(value_node, URIRef) else value_node  # noqa: WPS110
+                for key, value_node in replacement_map.items()
+            }
+            
+            yield quad.replace(normalized_replacement_map).normalize()
 
 
 def raise_if_term_is_qname(term_value: str):

{iolanta-2.1.10 → iolanta-2.1.11}/iolanta/sparqlspace/processor.py

@@ -1,17 +1,14 @@
+# 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,55 +32,24 @@ 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 = [
+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(
@@ -116,20 +82,20 @@ def find_retractions_for(nanopublication: URIRef) -> set[URIRef]:
 def _extract_from_mapping(  # noqa: WPS213
     algebra: Mapping[str, Any],
 ) -> Iterable[URIRef | Variable]:
-    match algebra.name:
+    match algebra.name:  # noqa: WPS242
         case 'SelectQuery' | 'AskQuery' | 'Project' | 'Distinct' | 'Slice':
-            yield from extract_mentioned_urls(algebra['p'])
+            yield from extract_mentioned_urls(algebra['p'])  # noqa: WPS226
 
         case 'BGP':
             yield from [   # noqa: WPS353, WPS221
                 term
                 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
+            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'])
@@ -208,7 +174,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(
@@ -258,7 +227,7 @@ 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."""
@@ -293,34 +262,6 @@ def _extract_nanopublication_uris(
             )
 
 
-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):
@@ -419,7 +360,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,
@@ -471,8 +412,9 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
         # 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')
@@ -493,7 +435,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
             for row in bindings:
                 break
-                for _, maybe_iri in row.items():
+                for _, maybe_iri in row.items():  # noqa: WPS427
                     if (
                         isinstance(maybe_iri, URIRef)
                         and isinstance(self.load(maybe_iri), Loaded)
@@ -584,7 +526,7 @@ 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')
             namespaces = [RDF, RDFS, OWL, FOAF, DC, VANN]
@@ -627,15 +569,15 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
             return Loaded()
 
-        if _resolved_source:
-            _resolved_source_uri_ref = URIRef(_resolved_source)
-            if _resolved_source_uri_ref != URIRef(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,
+                    resolved_source_uri_ref,
                 ))
-                source = _resolved_source
+                source = resolved_source
 
         self._mark_as_loaded(source_uri)
 
@@ -700,7 +642,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
         return term
 
-    def _run_inference(self):  # noqa: WPS231
+    def _run_inference(self):  # noqa: WPS231, WPS220, WPS210
         """
         Run inference queries from the inference directory.
 
@@ -720,21 +662,21 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
 
                 # Read and execute the CONSTRUCT query
                 query_text = inference_file.read_text()
-                result = self.graph.query(query_text)
+                query_result = self.graph.query(query_text)  # noqa: WPS110
 
                 # CONSTRUCT queries return a SPARQLResult with a graph attribute
-                result_graph = result.get('graph') if isinstance(result, dict) else result.graph
+                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:
+                if result_graph is not None:  # noqa: WPS504
                     inferred_quads = [
-                        (s, p, o, inference_graph)
-                        for s, p, o in result_graph
+                        (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)
-                        self.logger.info(
+                        self.graph.addN(inferred_quads)  # noqa: WPS220
+                        self.logger.info(  # noqa: WPS220
                             'Inference {filename}: added {count} triples',
                             filename=filename,
                             count=len(inferred_quads),

iolanta-2.1.11/iolanta/sparqlspace/redirects.py

@@ -0,0 +1,79 @@
+import re
+from types import MappingProxyType
+
+from rdflib import URIRef
+
+from iolanta.namespaces import (
+    DC,
+    DCTERMS,
+    FOAF,
+    OWL,
+    PROV,
+    RDF,
+    RDFS,
+    VANN,
+)
+
+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(str(DC)): URIRef(str(DCTERMS)),
+    URIRef(str(RDF)): URIRef(str(RDF)),
+    URIRef(str(RDFS)): URIRef(str(RDFS)),
+    URIRef(str(OWL)): URIRef(str(OWL)),
+
+    # Add # fragment to OWL and RDFS namespace URIs
+    # (fixes bug reported at https://stackoverflow.com/q/78934864/1245471)
+    URIRef('http://www.w3.org/2002/07/owl'): URIRef('http://www.w3.org/2002/07/owl#'),
+    URIRef('http://www.w3.org/2000/01/rdf-schema'): URIRef('http://www.w3.org/2000/01/rdf-schema#'),
+
+    # 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#',
+    ),
+
+    # Convert lexvo.org/id URLs to lexvo.org/data URLs
+    r'http://lexvo\.org/id/(.+)': r'http://lexvo.org/data/\1',
+    r'https://lexvo\.org/id/(.+)': r'http://lexvo.org/data/\1',
+    r'https://www\.lexinfo\.net/(.+)': r'http://www.lexinfo.net/\1',
+    # Convert Wikidata https:// to http:// (Wikidata JSON-LD uses http:// URIs)
+    r'https://www\.wikidata\.org/entity/(.+)': r'http://www.wikidata.org/entity/\1',
+})
+
+
+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

{iolanta-2.1.10 → iolanta-2.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "iolanta"
-version = "2.1.10"
+version = "2.1.11"
 description = "Semantic Web browser"
 authors = ["Anatoly Scherbakov <altaisoft@gmail.com>"]
 license = "MIT"
@@ -70,7 +70,7 @@ labeled-triple-set = "iolanta.labeled_triple_set.labeled_triple_set:LabeledTripl
 sparqlspace = "iolanta.sparqlspace.processor:GlobalSPARQLProcessor"
 
 [tool.poetry.group.dev.dependencies]
-jeeves-yeti-pyproject = ">=0.2.44"
+jeeves-yeti-pyproject = ">=1.0"
 mkdocs-awesome-pages-plugin = ">=2.9.2"
 mkdocs-blogging-plugin = ">=2.2.11"
 mkdocstrings-python = ">=1.8.0"
@@ -85,65 +85,3 @@ all = ["iolanta-tables"]
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
-
-
-[tool.flakeheaven.exceptions."iolanta/facets/**.py"]
-wemake-python-styleguide = [
-    # Upper case constants used in Textual widget classes.
-    "-WPS115",
-
-    # __all__ in __init__.py is ok
-    "-WPS410",
-]
-
-[tool.flakeheaven.exceptions."iolanta/cyberspace/processor.py"]
-wemake-python-styleguide = [
-    # Underscored variables are ok
-    "-WPS121",
-    "-WPS122",
-]
-
-[tool.flakeheaven.exceptions."tests/**.py"]
-wemake-python-styleguide = [
-    # Found outer scope names shadowing
-    # Used for fixtures
-    "-WPS442",
-]
-
-
-[tool.flakeheaven.exceptions."iolanta/facets/textual_browser/history.py"]
-wemake-python-styleguide = [
-    # Save stuff into a dataclass attribute
-    "-WPS601",
-]
-
-
-[tool.flakeheaven.exceptions."**/facets.py"]
-wemake-python-styleguide = [
-    # Found upper-case constant in a class: DEFAULT_CSS
-    "-WPS115",
-]
-
-pycodestyle = [
-    # blank line contains whitespace
-    # This is TCSS, WTF?
-    "-W293"
-]
-
-
-[tool.flakeheaven.exceptions."**/*.md"]
-flake8-eradicate = [
-    # Found commented out code [flake8-eradicate]
-    "-E800",
-]
-
-[tool.flakeheaven.exceptions."iolanta/namespaces.py"]
-wemake-python-styleguide = [
-    # Found upper-case constant in a class: _NS
-    "-WPS115",
-]
-
-flake8-docstrings = [
-    # Missing docstring in public class
-    "-D101",
-]

iolanta-2.1.10/iolanta/mcp/cli.py

@@ -1,40 +0,0 @@
-from pathlib import Path
-from typing import Annotated
-
-from fastmcp import FastMCP
-
-from iolanta.cli.main import render_and_return
-
-mcp = FastMCP("Iolanta MCP Server")
-
-
-@mcp.tool()
-def render_uri(
-    uri: Annotated[str, 'URL, or file system path, to render'],
-    as_format: Annotated[str, 'Format to render as. Examples: `labeled-triple-set`, `mermaid`'],
-) -> str:
-    """Render a URI."""
-    result = render_and_return(uri, as_format)
-    return str(result)
-
-
-@mcp.prompt(description="How to author Linked Data with Iolanta")
-def ld_authoring_rules() -> str:
-    """How to author Linked Data with Iolanta."""
-    rules_path = Path(__file__).parent / 'prompts' / 'rules.md'
-    return rules_path.read_text()
-
-
-@mcp.prompt(description="How to author nanopublication assertions with Iolanta")
-def nanopublication_assertion_authoring_rules() -> str:
-    """How to author nanopublication assertions with Iolanta."""
-    rules_path = Path(__file__).parent / 'prompts' / 'nanopublication_assertion_authoring_rules.md'
-    return rules_path.read_text()
-
-
-def app():
-    mcp.run()
-
-
-if __name__ == "__main__":
-    app()

iolanta-2.1.10/iolanta/mcp/prompts/nanopublication_assertion_authoring_rules.md

@@ -1,63 +0,0 @@
-# How to author Nanopublication Assertions with Iolanta
-
-## What are Nanopublications?
-
-Nanopublications are a special type of Linked Data that contain structured knowledge statements with three main components:
-
-1. **Assertion** - The core knowledge claim or statement
-2. **Provenance** - Information about how the assertion was derived (sources, methods, contributors)
-3. **Publication Info** - Metadata about the nanopublication itself (author, creation date, etc.)
-
-Nanopublications are cryptographically signed and published in the decentralized **Nanopublication Registry**, making them:
-- Irrevocably attributed to the author
-- Protected from tampering
-- Referenceable by unique IDs
-- Machine readable and reusable
-- Decentralized and persistent
-
-## Assertion-Only Workflow
-
-**NP00.** Nanopublication assertion graphs must also satisfy the general rules for Linked Data authoring and workflow. That is provided in the MCP prompt named `ld_authoring_rules`.
-
-**NP01.** We focus only on writing the **assertion graph** of the nanopublication.
-
-**NP02.** Follow the standard YAML-LD authoring rules (R00-R23) for creating the assertion.
-
-**NP03.** The assertion should express a single, clear knowledge claim that can stand alone.
-
-**NP04.** Use proper Linked Data vocabularies and resolvable URIs for all entities and relationships.
-
-**NP05.** After the assertion graph is ready, follow this workflow:
-
-```bash
-# Expand the YAML-LD to JSON-LD
-pyld expand assertion.yamlld > expanded.jsonld
-
-# Create nanopublication from the assertion
-np create from-assertion expanded.jsonld > nanopublication.trig
-
-# Publish the nanopublication (when ready)
-np publish nanopublication.trig
-```
-
-**NP06.** The `pyld expand` command converts YAML-LD to expanded JSON-LD format.
-
-**NP07.** The `np create from-assertion` command automatically generates the provenance and publication info components.
-
-**NP08.** The `np publish` command cryptographically signs and publishes the nanopublication to the registry.
-
-**NP09.** Use the Iolanta MCP `render_uri` tool to validate the assertion before proceeding with the workflow.
-
-**NP10.** Save Mermaid visualizations of the assertion for documentation purposes.
-
-## Best Practices for Assertions
-
-**NP11.** Keep assertions focused on a single, verifiable claim.
-
-**NP12.** Use canonical URIs from established knowledge bases (DBpedia, Wikidata, etc.).
-
-**NP13.** Include sufficient context and metadata to make the assertion meaningful.
-
-**NP14.** Ensure the assertion can be understood independently of external context.
-
-**NP15.** Use standard vocabularies and well-established ontologies for relationships.