iolanta 2.1.4__py3-none-any.whl → 2.1.7__py3-none-any.whl

iolanta/cli/main.py

@@ -11,7 +11,7 @@ from rdflib import Literal, URIRef
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.table import Table
-from typer import Argument, Exit, Option, Typer
+from typer import Argument, Exit, Option, Typer, Context
 from yarl import URL
 
 from iolanta.cli.models import LogLevel
@@ -24,9 +24,7 @@ DEFAULT_LANGUAGE = locale.getlocale()[0].split('_')[0]
 console = Console()
 
 
-app = Typer(
-    no_args_is_help=True,
-)
+app = Typer(no_args_is_help=True)
 
 
 def string_to_node(name: str) -> NotLiteralNode:
@@ -52,19 +50,10 @@ def decode_datatype(datatype: str) -> URIRef:
     return URIRef(f'https://iolanta.tech/datatypes/{datatype}')
 
 
-@app.command(name='browse')
-def render_command(   # noqa: WPS231, WPS238, WPS210, C901
-    url: Annotated[str, Argument()],
-    as_datatype: Annotated[
-        str, Option(
-            '--as',
-        ),
-    ] = 'https://iolanta.tech/cli/interactive',
-    language: Annotated[
-        str, Option(
-            help='Data language to prefer.',
-        ),
-    ] = DEFAULT_LANGUAGE,
+def render_and_return(
+    url: str,
+    as_datatype: str,
+    language: str = DEFAULT_LANGUAGE,
     log_level: LogLevel = LogLevel.ERROR,
 ):
     """Render a given URL."""
@@ -124,13 +113,38 @@ def render_command(   # noqa: WPS231, WPS238, WPS210, C901
             project_root=path,
         )
 
-    try:
-        renderable = iolanta.render(
-            node=URIRef(node),
-            as_datatype=decode_datatype(as_datatype),
-        )
+    return iolanta.render(
+        node=URIRef(node),
+        as_datatype=decode_datatype(as_datatype),
+    )
+
 
+@app.command(name='render')
+def render_command(   # noqa: WPS231, WPS238, WPS210, C901
+    url: Annotated[str, Argument()],
+    as_datatype: Annotated[
+        str, Option(
+            '--as',
+        ),
+    ] = 'https://iolanta.tech/cli/interactive',
+    language: Annotated[
+        str, Option(
+            help='Data language to prefer.',
+        ),
+    ] = DEFAULT_LANGUAGE,
+    log_level: LogLevel = LogLevel.ERROR,
+):
+    """Render a given URL."""
+    try:
+        renderable = render_and_return(url, as_datatype, language, log_level)
     except DocumentedError as documented_error:
+        level = {
+            LogLevel.DEBUG: logging.DEBUG,
+            LogLevel.INFO: logging.INFO,
+            LogLevel.WARNING: logging.WARNING,
+            LogLevel.ERROR: logging.ERROR,
+        }[log_level]
+        
         if level in {logging.DEBUG, logging.INFO}:
             raise
 
@@ -143,12 +157,18 @@ def render_command(   # noqa: WPS231, WPS238, WPS210, C901
         raise Exit(1)
 
     except Exception as err:
-        if iolanta.logger.level in {logging.DEBUG, logging.INFO}:
+        level = {
+            LogLevel.DEBUG: logging.DEBUG,
+            LogLevel.INFO: logging.INFO,
+            LogLevel.WARNING: logging.WARNING,
+            LogLevel.ERROR: logging.ERROR,
+        }[log_level]
+        
+        if level in {logging.DEBUG, logging.INFO}:
             raise
 
         console.print(str(err))
         raise Exit(1)
-
     else:
         # FIXME: An intermediary Literal can be used to dispatch rendering.
         match renderable:

iolanta/data/context.yaml

@@ -1,5 +1,5 @@
 "@context":
-  rdfs: "https://www.w3.org/2000/01/rdf-schema#"
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
   iolanta: https://iolanta.tech/
   owl: https://www.w3.org/2002/07/owl#

iolanta/data/iolanta.yaml

@@ -4,7 +4,7 @@
   foaf: https://xmlns.com/foaf/0.1/
   owl: https://www.w3.org/2002/07/owl#
   iolanta: https://iolanta.tech/
-  rdfs: "https://www.w3.org/2000/01/rdf-schema#"
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
 
 $included:

iolanta/data/textual-browser.yaml

@@ -4,7 +4,7 @@
   foaf: https://xmlns.com/foaf/0.1/
   owl: https://www.w3.org/2002/07/owl#
   iolanta: https://iolanta.tech/
-  rdfs: "https://www.w3.org/2000/01/rdf-schema#"
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
   np: https://www.nanopub.org/nschema#
   dcterms: https://purl.org/dc/terms/
@@ -88,12 +88,6 @@
     iolanta:hasDefaultFacet:
       $id: pkg:pypi/iolanta#textual-link
 
-  - $id: https://wikiba.se/ontology#Statement
-    iolanta:hasInstanceFacet:
-      $id: pkg:pypi/iolanta#wikibase-statement-title
-      $: Title
-      →: https://iolanta.tech/datatypes/title
-
   - $id: rdfs:Class
     iolanta:hasInstanceFacet:
       $id: pkg:pypi/iolanta#textual-class

iolanta/declension/data/declension.yamlld

@@ -4,7 +4,7 @@
   foaf: https://xmlns.com/foaf/0.1/
   owl: https://www.w3.org/2002/07/owl#
   iolanta: https://iolanta.tech/
-  rdfs: "https://www.w3.org/2000/01/rdf-schema#"
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
   dcterms: https://purl.org/dc/terms/
   dcam: https://purl.org/dc/dcam/

iolanta/facets/locator/sparql/get-query-to-facet.sparql

@@ -0,0 +1,5 @@
+SELECT ?facet ?match WHERE {
+    ?facet
+        iolanta:matches ?match ;
+        iolanta:outputs $as_datatype .
+}

iolanta/facets/locator.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from functools import cached_property
 from graphlib import TopologicalSorter
+from pathlib import Path
 from typing import Iterable, List, TypedDict
 
 import funcy
@@ -18,13 +19,9 @@ class FoundRow(TypedDict):
     output_datatype: NotLiteralNode
 
 
-GET_QUERY_TO_FACET = """
-SELECT ?facet ?match WHERE {
-    ?facet
-        iolanta:matches ?match ;
-        iolanta:outputs $as_datatype .
-}
-"""
+GET_QUERY_TO_FACET = (
+    Path(__file__).parent / 'locator' / 'sparql' / 'get-query-to-facet.sparql'
+).read_text()
 
 
 def reorder_rows_by_facet_preferences(   # noqa: WPS214, WPS210

iolanta/facets/mkdocs_material_insiders_markdown/__init__.py

@@ -0,0 +1,4 @@
+from iolanta.facets.mkdocs_material_insiders_markdown.facet import MkDocsMaterialInsidersMarkdownFacet
+
+__all__ = ['MkDocsMaterialInsidersMarkdownFacet']
+

iolanta/facets/mkdocs_material_insiders_markdown/data/mkdocs_material_insiders_markdown.yamlld

@@ -0,0 +1,20 @@
+"@context":
+  "@import": https://json-ld.org/contexts/dollar-convenience.jsonld
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
+  rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
+  iolanta: https://iolanta.tech/
+
+  $: rdfs:label
+
+  →:
+    "@type": "@id"
+    "@id": iolanta:outputs
+
+  ↦: iolanta:matches
+
+$id: pkg:pypi/iolanta#mkdocs-material-insiders-markdown-datatype
+$: OutputDatatype (mkdocs-material-insiders-markdown)
+
+→: https://iolanta.tech/datatypes/mkdocs-material-insiders-markdown
+
+↦: ASK WHERE { $this a iolanta:OutputDatatype }

iolanta/facets/mkdocs_material_insiders_markdown/facet.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+from rdflib import URIRef
+
+from iolanta.facets.facet import Facet
+from iolanta.namespaces import DATATYPES, IOLANTA, RDF, RDFS
+
+
+class MkDocsMaterialInsidersMarkdownFacet(Facet[str]):
+    """Render rdfs:Datatype nodes as mkdocs-material-insiders-markdown."""
+    
+    META = Path(__file__).parent / 'data' / 'mkdocs_material_insiders_markdown.yamlld'
+    """Render rdfs:Datatype nodes as mkdocs-material-insiders-markdown."""
+
+    @property
+    def _template_env(self) -> Environment:
+        """Jinja2 template environment."""
+        template_path = Path(__file__).parent / 'templates'
+        return Environment(
+            loader=FileSystemLoader(str(template_path)),
+            autoescape=False,
+        )
+
+    def show(self) -> str:
+        """Render the datatype as markdown."""
+        # Get the label using title facet
+        label = self.render(
+            self.this,
+            as_datatype=DATATYPES.title,
+        )
+
+        # Get the comment/description
+        comment_rows = self.query(
+            """
+            SELECT ?comment WHERE {
+                $this rdfs:comment ?comment .
+            }
+            LIMIT 1
+            """,
+            this=self.this,
+        )
+        comment = str(comment_rows[0]['comment']) if comment_rows else None
+
+        # Get all types (rdf:type)
+        type_rows = self.query(
+            """
+            SELECT ?type WHERE {
+                $this rdf:type ?type .
+            }
+            """,
+            this=self.this,
+        )
+        types = [
+            {
+                'uri': row['type'],
+                'title': self.render(row['type'], as_datatype=DATATYPES.title),
+            }
+            for row in type_rows
+        ]
+
+        # Get all superclasses (rdfs:subClassOf)
+        superclass_rows = self.query(
+            """
+            SELECT ?superclass WHERE {
+                $this rdfs:subClassOf ?superclass .
+            }
+            """,
+            this=self.this,
+        )
+        superclasses = [
+            {
+                'uri': row['superclass'],
+                'title': self.render(row['superclass'], as_datatype=DATATYPES.title),
+            }
+            for row in superclass_rows
+        ]
+
+        template = self._template_env.get_template('datatype.jinja2.md')
+        return template.render(
+            label=label,
+            comment=comment,
+            types=types,
+            superclasses=superclasses,
+        )
+

iolanta/facets/mkdocs_material_insiders_markdown/templates/datatype.jinja2.md

@@ -0,0 +1,24 @@
+# {{ label }}
+
+<table>
+<thead>
+</thead>
+<tbody>
+{% if types %}
+<tr>
+<td>∈ Instance Of</td>
+<td>{% for type in types %}<code><a href="{{ type.uri }}">{{ type.title }}</a></code>{% if not loop.last %}, {% endif %}{% endfor %}</td>
+</tr>
+{% endif %}
+{% if superclasses %}
+<tr>
+<td>⊊ Subclass Of</td>
+<td>{% for superclass in superclasses %}<code><a href="{{ superclass.uri }}">{{ superclass.title }}</a></code>{% if not loop.last %}, {% endif %}{% endfor %}</td>
+</tr>
+{% endif %}
+</tbody>
+</table>
+
+{% if comment %}
+{{ comment | safe }}
+{% endif %}

iolanta/facets/textual_browser/page_switcher.py

@@ -323,7 +323,7 @@ class DevConsole(RichLog):
 
     def __init__(self):
         """Set default props for console."""
-        super().__init__(highlight=True, markup=True, id='console')
+        super().__init__(highlight=False, markup=False, id='console')
 
     def action_close(self):
         """Close the dev console."""

iolanta/facets/textual_graphs/__init__.py

@@ -0,0 +1,6 @@
+"""Facet to render named graphs."""
+
+from iolanta.facets.textual_graphs.facets import Graphs
+
+__all__ = ['Graphs']
+

iolanta/facets/textual_graphs/data/textual_graphs.yamlld

@@ -0,0 +1,23 @@
+"@context":
+  "@import": https://json-ld.org/contexts/dollar-convenience.jsonld
+  iolanta: https://iolanta.tech/
+  rdfs: http://www.w3.org/2000/01/rdf-schema#
+  rdfg: http://www.w3.org/2009/rdfg#
+
+  $: rdfs:label
+  iolanta:is-preferred-over:
+    "@type": "@id"
+  
+  iolanta:outputs:
+    "@type": "@id"
+
+$id: rdfg:Graph
+iolanta:facet:
+  $id: pkg:pypi/iolanta#textual-graphs
+  $: Named Graphs
+
+  iolanta:outputs: https://iolanta.tech/cli/textual
+
+  iolanta:is-preferred-over:
+    - pkg:pypi/iolanta#textual-properties
+    - pkg:pypi/iolanta#textual-graph-triples

iolanta/facets/textual_graphs/facets.py

@@ -0,0 +1,138 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import Iterable, NamedTuple
+
+import funcy
+from rdflib import Literal, Node
+from textual.containers import Vertical
+from textual.coordinate import Coordinate
+from textual.widgets import DataTable
+
+from iolanta.facets.facet import Facet
+from iolanta.facets.page_title import PageTitle
+from iolanta.models import NotLiteralNode
+from iolanta.namespaces import DATATYPES
+from iolanta.widgets.mixin import IolantaWidgetMixin
+
+
+class GraphRow(NamedTuple):
+    """A row in the graphs table."""
+
+    graph: NotLiteralNode
+    count: int
+
+
+class GraphsTable(IolantaWidgetMixin, DataTable):
+    """Render graphs as a table with graph URI and triple count."""
+
+    BINDINGS = [
+        ('enter', 'goto', 'Goto'),
+    ]
+
+    def __init__(self, rows: Iterable[GraphRow]):
+        """Construct."""
+        super().__init__(show_header=True, cell_padding=1)
+        self.graph_rows = list(rows)
+
+    def render_human_readable_cells(self):
+        """Replace the cells with their human readable titles."""
+        terms_and_coordinates = sorted(
+            self.node_to_coordinates.items(),
+            key=lambda node_and_coordinates_pair: len(
+                node_and_coordinates_pair[1],
+            ),
+            reverse=True,
+        )
+
+        for term, coordinates in terms_and_coordinates:
+            title = str(self.iolanta.render(term, as_datatype=DATATYPES.title))
+            for coordinate in coordinates:
+                self.app.call_from_thread(
+                    self.update_cell_at,
+                    coordinate,
+                    value=title,
+                    update_width=False,
+                )
+
+    @funcy.cached_property
+    @funcy.post_processing(dict)
+    def coordinate_to_node(self):
+        """Return a mapping of coordinates to their corresponding nodes."""
+        for row_number, (graph, _count) in enumerate(self.graph_rows):
+            yield Coordinate(row_number, 0), graph
+
+    @funcy.cached_property
+    def node_to_coordinates(self) -> defaultdict[Node, list[Coordinate]]:
+        """Map node to coordinates where it appears."""
+        node_to_coordinate = [
+            (node, coordinate)
+            for coordinate, node in self.coordinate_to_node.items()
+        ]
+        return funcy.group_values(node_to_coordinate)
+
+    def format_as_loading(self, node: Node) -> str:
+        """Intermediate version of a value while it is loading."""
+        if isinstance(node, Literal):
+            node_text = f'⌛ {node}'
+        else:
+            node_text = self.iolanta.node_as_qname(node)
+            node_text = f'⌛ {node_text}'
+
+        return node_text
+
+    def on_mount(self):
+        """Fill the table and start rendering."""
+        self.add_columns('Graph', 'Triples Count')
+        self.cell_padding = 1
+
+        for graph, count in self.graph_rows:
+            self.add_row(
+                self.format_as_loading(graph),
+                str(count),
+            )
+
+        self.run_worker(
+            self.render_human_readable_cells,
+            thread=True,
+        )
+
+    def action_goto(self):
+        """Navigate to the selected graph."""
+        if self.cursor_coordinate:
+            node = self.coordinate_to_node.get(self.cursor_coordinate)
+            if node is not None:
+                self.app.action_goto(node)
+
+
+class GraphsBody(Vertical):
+    """Container for graphs table."""
+
+    DEFAULT_CSS = """
+    GraphsBody {
+        height: auto;
+        max-height: 100%;
+    }
+    """
+
+
+class Graphs(Facet):
+    """Render named graphs as a table."""
+
+    META = Path(__file__).parent / 'data' / 'textual_graphs.yamlld'
+
+    def show(self):
+        """Construct the table."""
+        rows = self.stored_query('graphs.sparql')
+
+        return GraphsBody(
+            PageTitle(self.this),
+            GraphsTable(
+                [
+                    GraphRow(
+                        graph=row['graph'],
+                        count=int(row['count'].value),
+                    )
+                    for row in rows
+                ],
+            ),
+        )

iolanta/facets/textual_graphs/sparql/graphs.sparql

@@ -0,0 +1,5 @@
+SELECT ?graph (COUNT(?s) AS ?count) WHERE {
+    GRAPH ?graph {
+        ?s ?p ?o .
+    }
+} GROUP BY ?graph ORDER BY DESC(?count) ?graph

iolanta/iolanta.py

@@ -119,7 +119,7 @@ class Iolanta:   # noqa: WPS214
                 processor='sparqlspace',
                 initBindings=kwargs,
             )
-        except ParseException as err:
+        except SyntaxError as err:
             raise SPARQLParseException(
                 error=err,
                 query=query_text,
@@ -171,8 +171,9 @@ class Iolanta:   # noqa: WPS214
                 self.logger.error(f'{source} | {parser_not_found}')
                 continue
             except YAMLLDError as yaml_ld_error:
-                self.logger.error(f'{source} | {yaml_ld_error}')
-                continue
+                # .add() only processes local files, so errors should be raised
+                self.logger.error(f'{source_file} | {yaml_ld_error}')
+                raise
             except ValueError as value_error:
                 self.logger.error(f'{source} | {value_error}')
                 continue

iolanta/labeled_triple_set/data/labeled_triple_set.yamlld

@@ -4,7 +4,7 @@
   foaf: https://xmlns.com/foaf/0.1/
   owl: https://www.w3.org/2002/07/owl#
   iolanta: https://iolanta.tech/
-  rdfs: "https://www.w3.org/2000/01/rdf-schema#"
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
   dcterms: https://purl.org/dc/terms/
   dcam: https://purl.org/dc/dcam/

iolanta/mcp/cli.py

@@ -0,0 +1,39 @@
+from typing import Annotated
+from fastmcp import FastMCP
+from pathlib import Path
+
+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/mcp/prompts/nanopublication_assertion_authoring_rules.md

@@ -0,0 +1,63 @@
+# 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.