iolanta 2.1.1__py3-none-any.whl → 2.1.6__py3-none-any.whl

iolanta/facets/textual_default/facets.py

@@ -32,7 +32,7 @@ class TextualDefaultFacet(Facet[Widget]):   # noqa: WPS214
         """Properties of current node & their values."""
         property_rows = self.stored_query(
             self.query_file_name,
-            iri=self.iri,
+            iri=self.this,
         )
 
         property_pairs = [
@@ -64,11 +64,11 @@ class TextualDefaultFacet(Facet[Widget]):   # noqa: WPS214
             property_values = [
                 LiteralPropertyValue(
                     property_value=property_value,
-                    subject=self.iri,
+                    subject=self.this,
                     property_iri=property_iri,
                 ) if isinstance(property_value, Literal) else PropertyValue(
                     property_value=property_value,
-                    subject=self.iri,
+                    subject=self.this,
                     property_iri=property_iri,
                     property_qname=self.iolanta.node_as_qname(property_iri),
                 )
@@ -135,7 +135,7 @@ class TextualDefaultFacet(Facet[Widget]):   # noqa: WPS214
     def show(self) -> Widget:
         """Render the content."""
         return VerticalScroll(
-            PageTitle(self.iri),
+            PageTitle(self.this),
             Static(self.description or ''),
             self.properties,
         )
@@ -149,7 +149,7 @@ class InverseProperties(TextualDefaultFacet):
     def show(self) -> Widget:
         """Render the content."""
         return VerticalScroll(
-            PageTitle(self.iri, extra='[i]& its inverse RDF properties[/i]'),
+            PageTitle(self.this, extra='[i]& its inverse RDF properties[/i]'),
             Static(self.description or ''),
             self.properties,
         )

iolanta/facets/textual_default/widgets.py

@@ -138,7 +138,7 @@ class PropertyValue(Widget, can_focus=True, inherit_bindings=False):
         self.property_iri = property_iri
         super().__init__()
         self.renderable = Text(  # noqa: WPS601
-            f'⏳ {property_qname}',
+            f'⏳ {property_value}',
             style='#696969',
         )
 

iolanta/facets/textual_graph/facets.py

@@ -14,17 +14,17 @@ class GraphFacet(Facet[Widget]):
         """Show the widget."""
         triples = [
             Triple(triple['subject'], triple['predicate'], triple['object'])
-            for triple in self.stored_query('triples.sparql', graph=self.iri)
+            for triple in self.stored_query('triples.sparql', graph=self.this)
         ]
 
         triple_count = len(triples)
 
         triples_view = self.iolanta.render(
-            self.iri,
+            self.this,
             as_datatype=DATATYPES['textual-graph-triples'],
         )
 
         return VerticalScroll(
-            PageTitle(self.iri, extra=f'({triple_count} triples)'),
+            PageTitle(self.this, extra=f'({triple_count} triples)'),
             triples_view,
         )

iolanta/facets/textual_graph_triples.py

@@ -138,7 +138,7 @@ class GraphTriplesFacet(Facet[Widget]):
             }
             ORDER BY ?subject ?predicate ?object
             """,
-            graph=self.iri,
+            graph=self.this,
         )
 
         triples = [

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/facets/textual_link/facet.py

@@ -11,13 +11,13 @@ class TextualLinkFacet(Facet[str | Text]):
 
     def show(self) -> str | Text:
         """Render the link, or literal text, whatever."""
-        if isinstance(self.iri, Literal):
-            return f'[b grey37]{self.iri}[/b grey37]'
+        if isinstance(self.this, Literal):
+            return f'[b grey37]{self.this}[/b grey37]'
 
         label = self.render(
-            self.iri,
+            self.this,
             as_datatype=DATATYPES.title,
         )
 
-        invocation = f"app.goto('{self.iri}')"
+        invocation = f"app.goto('{self.this}')"
         return f'[@click="{invocation}"]{label}[/]'

iolanta/facets/textual_nanopublication/facet.py

@@ -11,4 +11,4 @@ class NanopublicationFacet(Facet[Widget]):
 
     def show(self) -> Widget:
         """Render a nanopublication."""
-        return NanopublicationScreen(uri=self.iri)
+        return NanopublicationScreen(uri=self.this)

iolanta/facets/textual_no_facet_found.py

@@ -12,6 +12,7 @@ from iolanta.widgets.description import Description
 TEXT = """
 **😕 Iolanta is unable to visualize this resource**
 
+* The reference type ({reference_type}) might be incorrect;
 * The URI might be incorrect;
 * Or, no edges might exist which involve it;
 * Or maybe Iolanta does not know of such edges.
@@ -44,7 +45,7 @@ class TextualNoFacetFound(Facet):
     @property
     def raw_content(self):
         """Content of the file, if applicable."""
-        url = URL(self.uriref)
+        url = URL(self.this)
         if url.scheme != 'file':
             return None
 
@@ -94,6 +95,7 @@ class TextualNoFacetFound(Facet):
                     TEXT.format(
                         content=self.raw_content or '',
                         subgraphs=self.subgraphs_description or '',
+                        reference_type=type(self.this).__name__,
                     ),
                 ),
             ),

iolanta/facets/textual_ontology/facets.py

@@ -48,7 +48,7 @@ class OntologyFacet(Facet[Widget]):
     @cached_property
     def grouped_terms(self) -> dict[NotLiteralNode | None, list[TermAndStatus]]:
         """Group terms by VANN categories."""
-        rows = self.stored_query('terms.sparql', iri=self.iri)
+        rows = self.stored_query('terms.sparql', iri=self.this)
         grouped = [
             (
                 row.get('group'),
@@ -80,7 +80,7 @@ class OntologyFacet(Facet[Widget]):
 
         vocabs = funcy.lpluck(
             'vocab',
-            self.stored_query('visualization-vocab.sparql', iri=self.iri),
+            self.stored_query('visualization-vocab.sparql', iri=self.this),
         )
 
         for vocab in vocabs:
@@ -94,7 +94,7 @@ class OntologyFacet(Facet[Widget]):
             )
 
         return Vertical(
-            PageTitle(self.iri),
+            PageTitle(self.this),
             TermsContent(
                 Static(
                     Columns(

iolanta/facets/textual_provenance/facets.py

@@ -109,7 +109,7 @@ class TextualProvenanceFacet(Facet[Widget]):
 
     def show(self) -> Widget:
         """Obtain & render provenance info."""
-        uri = TripleURIRef(self.iri)
+        uri = TripleURIRef(self.this)
         triple = uri.as_triple()
 
         graphs = funcy.lpluck(

iolanta/facets/title/facets.py

@@ -31,7 +31,4 @@ class TitleFacet(Facet[str]):
                 if label := row.get(alternative):
                     return str(label)
 
-        return self.render(
-            self.iri,
-            as_datatype=URIRef('https://iolanta.tech/qname'),
-        )
+        return str(self.this)

iolanta/facets/wikibase_statement_title/facets.py

@@ -12,14 +12,14 @@ class WikibaseStatementTitle(Facet[str]):
         """Render the title."""
         rows = self.stored_query(
             'statement-title.sparql',
-            statement=self.iri,
+            statement=self.this,
             language=self.language,
         )
 
         row = funcy.first(rows)
         if not row:
             return self.render(
-                self.iri,
+                self.this,
                 as_datatype=URIRef('https://iolanta.tech/qname'),
             )
 

iolanta/iolanta.py

@@ -292,7 +292,7 @@ class Iolanta:   # noqa: WPS214
         facet_class = self.facet_resolver.resolve(found['facet'])
 
         facet = facet_class(
-            iri=node,
+            this=node,
             iolanta=self,
             as_datatype=found['output_datatype'],
         )
@@ -328,7 +328,7 @@ class Iolanta:   # noqa: WPS214
 
         facet_instances = [
             facet_class(
-                iri=node,
+                this=node,
                 iolanta=self,
                 as_datatype=output_datatype,
             )

iolanta/labeled_triple_set/data/labeled_triple_set.yamlld

@@ -0,0 +1,42 @@
+"@context":
+  "@import": https://json-ld.org/contexts/dollar-convenience.jsonld
+  vann: https://purl.org/vocab/vann/
+  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#"
+  rdf: https://www.w3.org/1999/02/22-rdf-syntax-ns#
+  dcterms: https://purl.org/dc/terms/
+  dcam: https://purl.org/dc/dcam/
+
+  iolanta:outputs:
+    "@type": "@id"
+
+  iolanta:when-no-facet-found:
+    "@type": "@id"
+
+  $: rdfs:label
+  →:
+    "@type": "@id"
+    "@id": iolanta:outputs
+
+  ⊆:
+    "@type": "@id"
+    "@id": rdfs:subClassOf
+
+  ⪯:
+    "@type": "@id"
+    "@id": iolanta:is-preferred-over
+
+  ↦: iolanta:matches
+  iolanta:hasDefaultFacet:
+    "@type": "@id"
+
+$id: pkg:pypi/iolanta#labeled-triple-set
+$: Labeled Triple Set
+→:
+  $id: https://iolanta.tech/datatypes/labeled-triple-set
+  $: Labeled Triple Set
+↦:
+  - ASK WHERE { GRAPH $this { ?s ?p ?o } }
+  - ASK WHERE { $this <https://iolanta.tech/has-sub-graph> ?subgraph }

iolanta/labeled_triple_set/labeled_triple_set.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+from typing import Annotated, Iterable
+from typing import Literal as TypingLiteral
+
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    Field,
+    TypeAdapter,
+    field_serializer,
+    field_validator,
+    validator,
+)
+from rdflib import BNode, Literal, Node, URIRef
+
+from iolanta import Facet
+from iolanta.models import NotLiteralNode
+from iolanta.namespaces import DATATYPES
+
+
+class WithFeedback(BaseModel):
+    feedback: Annotated[list[str], Field(default_factory=list)]
+
+
+class LabeledURI(WithFeedback, BaseModel):
+    type: TypingLiteral['uri'] = 'uri'
+    uri: AnyUrl
+    label: str
+
+    def construct_feedback(self) -> Iterable[str]:
+        if str(self.label) == str(self.uri):
+            yield (
+                'For this URI, the label is the same as the URI. We were '
+                'unable to render that URI.'
+            )
+
+
+class LabeledBlank(WithFeedback, BaseModel):
+    type: TypingLiteral['blank'] = 'blank'
+    identifier: str
+    label: str
+
+
+class LabeledLiteral(WithFeedback, BaseModel):
+    type: TypingLiteral['literal'] = 'literal'
+    value: str
+    language: str | None
+    datatype: str | None
+    label: str
+
+
+class LabeledTriple(BaseModel):
+    subject: LabeledURI | LabeledBlank
+    predicate: LabeledURI
+    object_: LabeledURI | LabeledBlank | LabeledLiteral
+
+
+def construct_uri_feedback(uri: AnyUrl, label: str) -> Iterable[str]:
+    if str(uri) == str(label):
+        yield (
+            'For this URI, the label is the same as the URI. We were '
+            'unable to render that URI.'
+        )
+
+
+def construct_blank_feedback(bnode, label) -> Iterable[str]:
+    if str(bnode) == str(label):
+        yield (
+            'For this blank node, the label is the same as the blank node. '
+            'We were unable to render that blank node.'
+        )
+
+
+def construct_literal_feedback(literal, label):
+    if label.startswith('http'):
+        yield (
+            'This RDF literal seems to be actually a URL. Good chance is '
+            'that it should not be a literal.'
+        )
+    
+    elif ':' in label[:5]:
+        yield (
+            'This RDF literal seems to be actually a QName (prefixed URI). '
+            'Good chance is that it should not be a literal.'
+        )
+
+
+class LabeledTripleSet(Facet[list[LabeledTriple]]):
+    """A set of labeled triples."""
+
+    META = Path(__file__).parent / 'data' / 'labeled_triple_set.yamlld'
+
+    def render_label(self, node: NotLiteralNode) -> str:
+        return self.render(node, as_datatype=DATATYPES.title)
+
+    def parse_term(self, term: Node):
+        match term:
+            case URIRef() as uriref:
+                uri = AnyUrl(uriref)
+                label = self.render_label(uriref)
+
+                return LabeledURI(
+                    uri=uri,
+                    label=label,
+                    feedback=list(construct_uri_feedback(uri=uri, label=label)),
+                )
+
+            case BNode() as bnode:
+                label = self.render_label(bnode)
+                return LabeledBlank(
+                    identifier=bnode,
+                    label=label,
+                    feedback=list(construct_blank_feedback(bnode=bnode, label=label)),
+                )
+
+            case Literal() as literal:
+                label = self.render_label(literal)
+                return LabeledLiteral(
+                    value=literal,
+                    language=literal.language,
+                    datatype=literal.datatype,
+                    label=label,
+                    feedback=list(construct_literal_feedback(literal=literal, label=label)),
+                )
+
+    def show(self):
+        rows = self.stored_query('triples.sparql', graph=self.this)
+        triples = [
+            LabeledTriple(
+                subject=self.parse_term(row['subject']),
+                predicate=self.parse_term(row['predicate']),
+                object_=self.parse_term(row['object']),
+            )
+            for row in rows
+        ]
+
+        return TypeAdapter(list[LabeledTriple]).dump_json(triples, indent=2).decode()

iolanta/labeled_triple_set/sparql/triples.sparql

@@ -0,0 +1,5 @@
+SELECT * WHERE {
+    GRAPH $graph {
+        ?subject ?predicate ?object .
+    }
+}

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()