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

iolanta/mcp/cli.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Annotated
 
 from fastmcp import FastMCP
@@ -14,22 +13,7 @@ def render_uri(
     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()
+    return str(render_and_return(uri, as_format))
 
 
 def app():

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/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/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.dist-info → iolanta-2.1.11.dist-info}/METADATA

@@ -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.10.dist-info → iolanta-2.1.11.dist-info}/RECORD

@@ -115,9 +115,7 @@ iolanta/labeled_triple_set/data/labeled_triple_set.yamlld,sha256=P3oAPSPsirpbcRX
 iolanta/labeled_triple_set/labeled_triple_set.py,sha256=o4IgvTvPd0mzBtpgHYd4n1xpujYdAvWBr6gIYwp5vnA,4061
 iolanta/labeled_triple_set/sparql/triples.sparql,sha256=VsCmYN5AX7jSIiFm-SqLcRcOvUVj8yyZI4PSzKROtQw,82
 iolanta/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iolanta/mcp/cli.py,sha256=wmtJgeTijIoDe0C-3uGekVfYlhj2jqL30p_u_NuJzR0,1116
-iolanta/mcp/prompts/nanopublication_assertion_authoring_rules.md,sha256=Z5YL9YwcLHCqA4zQK2ziSQYgyR4SlhUO9LV_zHGf0JQ,2643
-iolanta/mcp/prompts/rules.md,sha256=LddpoNfUACfvWBNJ_ArAyJfP2zlQstlXS2QA6GCl9QI,4651
+iolanta/mcp/cli.py,sha256=wlDandYo_VoMIg9oDGPJsIsMmiPo4j4-RBytIKWDtEI,484
 iolanta/mermaid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iolanta/mermaid/facet.py,sha256=8mLOBrzlY84jiWhtJNY5BkXPDpRhL2OB1LUwwwNS1X0,4065
 iolanta/mermaid/mermaid.yamlld,sha256=G_8lqNfs6S7pz9koDC8xAaic4EaHsYnFLgexDVyMuCU,552
@@ -128,7 +126,7 @@ iolanta/mermaid/sparql/subgraphs.sparql,sha256=VuoOYr_ZtKXXRrBpAEJek0mBRzR9EV-Kn
 iolanta/models.py,sha256=2VrJGQE1YXbbVB1K5McCXe2CLAlzOUhA8FvbRI10nCc,3131
 iolanta/namespaces.py,sha256=S4fSjWrL33jylItDf6y2_CIJ4B-RQXDhBsZkB-SV9mw,1107
 iolanta/node_to_qname.py,sha256=a82_qpgT87cbekY_76tTkl4Z-6Rz6am4UGIQChUf9Y0,794
-iolanta/parse_quads.py,sha256=X-3hQAFzRD9U8KCuZMQTVOAapJR4OHkPoRbgJYiVbnk,4539
+iolanta/parse_quads.py,sha256=ZYohKUh4WN3emq5xr6Sgf5gIw3_NFoUgYTZ3DOL-rQY,4876
 iolanta/plugin.py,sha256=MSxpuOIx93AgBahfS8bYh31MEgcwtUSQhj4Js7fgdSI,1096
 iolanta/query_result.py,sha256=VLLBkewUEymtzfB0jeIeRE3Np6pAgo959RPgNsEmiq8,1545
 iolanta/reformat_blank_nodes.py,sha256=MAVcXusUioKzAoTEHAMume5Gt9vBEpxJGrngqFzmkJI,712
@@ -141,12 +139,13 @@ iolanta/sparqlspace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 iolanta/sparqlspace/cli.py,sha256=pb6q03lzrU8OaZ4A3QAQEmaFYcQ_-sHUrPhRs6GE88w,1590
 iolanta/sparqlspace/inference/wikidata-prop-label.sparql,sha256=JYLAs28Z3a77cMcv44aZplwwrdqB-yshZn1dDZmRFAU,250
 iolanta/sparqlspace/inference/wikidata-statement-label.sparql,sha256=_Dp9jKCpCp2pLk0uacNUhUvvQ2Hov-WiMFprtuYTRyY,759
-iolanta/sparqlspace/processor.py,sha256=IsN6jc9HAE1B2TgZ-Wkq05WZMPmAvqajxu4peGGQwqo,25554
+iolanta/sparqlspace/processor.py,sha256=Iwh2ISniYkQnVQ5ALYtGI8PXdIKNOHjvwCf8azHETZo,23929
+iolanta/sparqlspace/redirects.py,sha256=ZYLb8rsjk9JG-mT5OQAzELer7okev34Le2VnACwpYzM,2657
 iolanta/sparqlspace/sparqlspace.py,sha256=Y8_ZPXwuGEXbEes6XQjaQWA2Zv9y8SWxMPDFdqVBGFo,796
 iolanta/widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iolanta/widgets/description.py,sha256=98Qd3FwT9r8sYqKjl9ZEptaVX9jJ2ULWf0uy3j52p5o,800
 iolanta/widgets/mixin.py,sha256=nDRCOc-gizCf1a5DAcYs4hW8eZEd6pHBPFsfm0ncv7E,251
-iolanta-2.1.10.dist-info/METADATA,sha256=6WI92t1Tf07VRH37C_S7Q-iB_PrDEyfxfik2ESuxBJI,2317
-iolanta-2.1.10.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-iolanta-2.1.10.dist-info/entry_points.txt,sha256=Vu0W4D6H74HsTICvD8CDB1wYs6XNSyu55EZVXMo4H84,1718
-iolanta-2.1.10.dist-info/RECORD,,
+iolanta-2.1.11.dist-info/METADATA,sha256=rq_HcxuelqK4s0REGfDy9_MaFfAfK5Lt5XTf_iWcc2s,2317
+iolanta-2.1.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+iolanta-2.1.11.dist-info/entry_points.txt,sha256=Vu0W4D6H74HsTICvD8CDB1wYs6XNSyu55EZVXMo4H84,1718
+iolanta-2.1.11.dist-info/RECORD,,

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.

iolanta/mcp/prompts/rules.md

@@ -1,83 +0,0 @@
-# How to author Linked Data with Iolanta
-
-**R00.** Follow this YAML-LD authoring workflow:
-- Draft YAML-LD from user text
-- Use the Iolanta MCP `render_uri` tool with `as_format: labeled-triple-set` to validate and get feedback
-- Address the feedback, correct the YAML-LD document appropriately
-- **After each change to the YAML-LD file, re-run the validation to check for new feedback**
-
-**R01.** Acceptance Criteria:
-
-- The document fits the original statement the user wanted to express;
-- No negative feedback is received.
-
-**R02.** Use YAML-LD format, which is JSON-LD in YAML syntax, for writing Linked Data.
-
-**R03.** Always quote the @ character in YAML since it's reserved. Use `"@id":` instead of `@id:`.
-
-**R04.** Prefer YAML-LD Convenience Context which maps @-keywords to $-keywords that don't need quoting: `"@type"` → `$type`, `"@id"` → `$id`, `"@graph"` → `$graph`.
-
-**R05.** Use the dollar-convenience context with `@import` syntax instead of array syntax. This provides cleaner, more readable YAML-LD documents.
-
-Example:
-```yaml
-"@context":
-  "@import": "https://json-ld.org/contexts/dollar-convenience.jsonld"
-  
-  schema: "https://schema.org/"
-  wd: "https://www.wikidata.org/entity/"
-  
-  author:
-    "@id": "https://schema.org/author"
-    "@type": "@id"
-```
-
-Instead of:
-```yaml
-"@context":
-  - "https://json-ld.org/contexts/dollar-convenience.jsonld"
-  - schema: "https://schema.org/"
-  - wd: "https://www.wikidata.org/entity/"
-  - author:
-      "@id": "https://schema.org/author"
-      "@type": "@id"
-```
-
-**R06.** Reduce quoting when not required by YAML syntax rules.
-
-**R07.** Do not use mock URLs like `https://example.org`. Use resolvable URLs that preferably point to Linked Data.
-
-**R08.** Use URIs that convey meaning and are renderable with Linked Data visualization tools. Search for appropriate URIs from sources like DBPedia or Wikidata.
-
-**R09.** Use the Iolanta MCP `render_uri` tool with `as_format: mermaid` to generate Mermaid graph visualizations of Linked Data. If the user asks, you can save them to `.mmd` files for preview and documentation purposes.
-
-**R10.** For language tags, use YAML-LD syntax: `rdfs:label: { $value: "text", $language: "lang" }` instead of Turtle syntax `"text"@lang`.
-
-**R11.** Do not attach labels to external URIs that are expected to return Linked Data. Iolanta will fetch those URIs and render labels from the fetched data.
-
-**R12.** Use `"@type": "@id"` in the context to coerce properties to IRIs instead of using `$id` wrappers in the document body.
-
-**R13.** For software packages, use `schema:SoftwareApplication` as the main type rather than `codemeta:SoftwareSourceCode`.
-
-**R14.** Use Wikidata entities for programming languages (e.g., `https://www.wikidata.org/entity/Q28865` for Python) instead of string literals.
-
-**R15.** Use proper ORCID URIs for authors (e.g., `https://orcid.org/0009-0001-8740-4213`) and coerce them to IRIs in the context.
-
-**R16.** For tools that provide both library and CLI functionality, classify as `schema:Tool` with `schema:applicationSubCategory: Command-line tool`.
-
-**R17.** Use real, resolvable repository URLs (e.g., `https://github.com/iolanta-tech/python-yaml-ld`) instead of placeholder URLs.
-
-**R18.** Include comprehensive metadata: name, description, author, license, programming language, version, repository links, and application category.
-
-**R19.** Use standard vocabularies: schema.org, RDFS, RDF, DCTerms, FOAF, and CodeMeta when appropriate.
-
-**R20.** Validate Linked Data using the Iolanta MCP `render_uri` tool with `as_format: labeled-triple-set` to check for URL-as-literal issues and proper IRI handling.
-
-**R21.** Do not add `rdfs:label` to external URIs that are expected to return Linked Data. If a URI does not exist or cannot be resolved, do not mask this fact by adding labels. Instead, use a different, existing URI or document the issue with a comment.
-
-**R22.** Define URI coercion in the context using `"@type": "@id"` rather than using `$id` wrappers in the document body. This keeps the document body clean and readable while ensuring proper URI handling.
-
-**R23.** When defining local shortcuts for URIs in the context, use dashed-case (e.g., `appears-in`, `named-after`) instead of camelCase (e.g., `appearsIn`, `namedAfter`). This improves readability and follows common YAML conventions.
-
-**R24.** Do not rely upon `owl:sameAs` or `schema:sameAs` to express identity relationships. This necessitates OWL inference at the side of the reader, which is performance-taxing and tends to create conflicts. Instead, use direct URIs for entities without relying on sameAs statements for identity.
-