iolanta 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

iolanta/__init__.py

@@ -1,4 +1,3 @@
 from iolanta.base_plugin import IolantaBase
 from iolanta.facets import Facet
 from iolanta.plugin import Plugin
-from iolanta.shortcuts import as_document

iolanta/facets/facet.py

@@ -85,13 +85,6 @@ class Facet(Generic[FacetOutput]):
         """Preferred language for Iolanta output."""
         return self.iolanta.language
 
-    def find_triple(
-        self,
-        triple: TripleTemplate,
-    ) -> Triple | None:
-        """Lightweight procedure to find a triple by template."""
-        return self.iolanta.find_triple(triple_template=triple)
-
     @cached_property
     def logger(self):
         """Logger."""

iolanta/facets/textual_default/widgets.py

@@ -291,7 +291,7 @@ class LiteralPropertyValue(Widget, can_focus=True, inherit_bindings=False):
         self.property_iri = property_iri
         super().__init__()
         self.renderable = Text(   # noqa: WPS601
-            str(property_value.value),
+            str(property_value),
             style='#696969',
         )
 

iolanta/facets/textual_no_facet_found.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 
+import funcy
 from rich.markdown import Markdown
 from textual.containers import Vertical
 from yarl import URL
@@ -15,6 +16,7 @@ TEXT = """
 * Or, no edges might exist which involve it;
 * Or maybe Iolanta does not know of such edges.
 {content}
+{subgraphs}
 **What can you do?**
 
 * If you feel this might indicate a bug 🐛, please do let us know at GitHub
@@ -29,6 +31,12 @@ CONTENT_TEMPLATE = """
 ```
 """
 
+SUBGRAPHS_TEMPLATE = """
+**Subgraphs**
+
+{formatted_subgraphs}
+"""
+
 
 class TextualNoFacetFound(Facet):
     """Facet to handle the case when no facet is found."""
@@ -55,14 +63,38 @@ class TextualNoFacetFound(Facet):
             content=file_content,
             type={
                 '.yamlld': 'yaml',
+                '.jsonld': 'json',
             }.get(path.suffix, ''),
         )
 
+    @property
+    def subgraphs_description(self) -> str:
+        """Return a formatted description of subgraphs, if any exist."""
+        rows = self.query(
+            'SELECT ?subgraph WHERE { $this iolanta:has-sub-graph ?subgraph }',
+            this=self.this,
+        )
+        subgraphs = funcy.lpluck('subgraph', rows)
+        if subgraphs:
+            return SUBGRAPHS_TEMPLATE.format(
+                formatted_subgraphs='\n'.join([
+                    f'- {subgraph}'
+                    for subgraph in subgraphs
+                ]),
+            )
+
+        return ''
+
     def show(self):
         """Compose the page."""
         return Vertical(
             PageTitle(self.this),
             Description(
-                Markdown(TEXT.format(content=self.raw_content or '')),
+                Markdown(
+                    TEXT.format(
+                        content=self.raw_content or '',
+                        subgraphs=self.subgraphs_description or '',
+                    ),
+                ),
             ),
         )

iolanta/facets/title/facets.py

@@ -9,6 +9,7 @@ PRIORITIES = [   # noqa: WPS407
     'schema_name',
     'rdfs_label',
     'foaf_name',
+    'literal_form',
 ]
 
 

iolanta/facets/title/sparql/title.sparql

@@ -23,4 +23,9 @@ SELECT * WHERE {
         $iri <https://xmlns.com/foaf/0.1/name> ?foaf_name .
         FILTER (!lang(?foaf_name) || lang(?foaf_name) = $language)
     }
-}
+
+    OPTIONAL {
+        $iri <https://www.w3.org/2008/05/skos-xl#literalForm> ?literal_form .
+        FILTER (!lang(?literal_form) || lang(?literal_form) = $language)
+    }
+}

iolanta/iolanta.py

@@ -4,22 +4,19 @@ from pathlib import Path
 from typing import (  # noqa: WPS235
     Annotated,
     Any,
-    Dict,
     Iterable,
     List,
     Mapping,
     Optional,
     Protocol,
     Set,
-    Tuple,
     Type,
 )
 
-import funcy
 import loguru
 import yaml_ld
 from pyparsing import ParseException
-from rdflib import ConjunctiveGraph, Graph, Literal, Namespace, URIRef
+from rdflib import ConjunctiveGraph, Graph, Literal, URIRef
 from rdflib.namespace import NamespaceManager
 from rdflib.plugins.sparql.processor import SPARQLResult
 from rdflib.term import Node
@@ -32,18 +29,9 @@ from iolanta.errors import UnresolvedIRI
 from iolanta.facets.errors import FacetError
 from iolanta.facets.facet import Facet
 from iolanta.facets.locator import FacetFinder
-from iolanta.loaders.base import SourceType
-from iolanta.loaders.local_directory import merge_contexts
-from iolanta.models import (
-    ComputedQName,
-    LDContext,
-    NotLiteralNode,
-    Triple,
-    TripleTemplate,
-)
+from iolanta.models import ComputedQName, LDContext, NotLiteralNode
 from iolanta.node_to_qname import node_to_qname
 from iolanta.parse_quads import parse_quads
-from iolanta.parsers.yaml import YAML
 from iolanta.plugin import Plugin
 from iolanta.query_result import (
     QueryResult,
@@ -103,12 +91,6 @@ class Iolanta:   # noqa: WPS214
 
     logger: LoggerProtocol = loguru.logger
 
-    sources_added_not_yet_inferred: list[SourceType] = field(
-        default_factory=list,
-        init=False,
-        repr=False,
-    )
-
     could_not_retrieve_nodes: Set[Node] = field(
         default_factory=set,
         init=False,
@@ -182,23 +164,6 @@ class Iolanta:   # noqa: WPS214
 
         return format_query_bindings(sparql_result.bindings)
 
-    @functools.cached_property
-    def namespaces_to_bind(self) -> Dict[str, Namespace]:
-        """
-        Namespaces globally specified for the graph.
-
-        FIXME: Probably get rid of this, I do not know.
-        """
-        return {
-            key: Namespace(value)
-            for key, value in self.default_context['@context'].items()  # noqa
-            if (
-                isinstance(value, str)
-                and not value.startswith('@')   # noqa: W503
-                and not key.startswith('@')   # noqa: W503
-            )
-        }
-
     def reset(self):
         """Reset Iolanta graph."""
         self.graph = _create_default_graph()   # noqa: WPS601
@@ -212,7 +177,6 @@ class Iolanta:   # noqa: WPS214
     ) -> 'Iolanta':
         """Parse & load information from given URL into the graph."""
         self.logger.info(f'Adding to graph: {source}')
-        self.sources_added_not_yet_inferred.append(source)
 
         if not isinstance(source, Path):
             source = Path(source)
@@ -262,17 +226,7 @@ class Iolanta:   # noqa: WPS214
                 self.logger.info(f'{source_file} | No data found')
                 continue
 
-            quad_tuples = [
-                tuple([
-                    normalize_term(term) for term in replace(
-                        quad,
-                        graph=graph,
-                    ).as_tuple()
-                ])
-                for quad in quads
-            ]
-
-            self.graph.addN(quad_tuples)
+            self.graph.addN(quads)
 
         return self
 
@@ -317,20 +271,6 @@ class Iolanta:   # noqa: WPS214
             if path := plugin.context_path:
                 yield path
 
-    @functools.cached_property
-    def default_context(self) -> LDContext:
-        """Construct default context from plugins."""
-        context_documents = [
-            YAML().as_jsonld_document(path.open('r'))
-            for path in self.context_paths
-        ]
-
-        for context in context_documents:
-            if isinstance(context, list):
-                raise ValueError('Context cannot be a list: %s', context)
-
-        return merge_contexts(*context_documents)   # type: ignore
-
     def add_files_from_plugins(self):
         """
         Load files from plugins.
@@ -434,44 +374,6 @@ class Iolanta:   # noqa: WPS214
                     error=err,
                 ) from err
 
-    def retrieve_triple(self, triple_template: TripleTemplate) -> Triple:
-        """Retrieve remote data to project directory."""
-        for plugin in self.plugins:
-            # FIXME Parallelization?
-            plugin.retrieve_triple(triple_template)
-
-        if not downloaded_files:
-            self.could_not_retrieve_nodes.add(node)
-
-        for path in downloaded_files:
-            self.add(path)
-
-        return self
-
-    def maybe_infer(self):
-        """
-        Apply inference lazily.
-
-        Only run inference if there are new files added after last inference.
-        """
-        if self.sources_added_not_yet_inferred:
-            self.infer()
-
-    def find_triple(
-        self,
-        triple_template: TripleTemplate,
-    ) -> Triple | None:
-        """Lightweight procedure to find a triple by template."""
-        triples = self.graph.triples(
-            (triple_template.subject, triple_template.predicate, triple_template.object),
-        )
-
-        raw_triple = funcy.first(triples)
-        if raw_triple:
-            return Triple(*raw_triple)
-
-        return self.retrieve_triple(triple_template)
-
     def node_as_qname(self, node: Node):
         """
         Render node as a QName if possible.

iolanta/models.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+import re
 from enum import Enum
 from typing import Any, Dict, List, NamedTuple, Union
 
@@ -82,8 +82,14 @@ class TripleTemplate(NamedTuple):
     object: Node | None
 
 
-@dataclass
-class Quad:
+def _normalize_term(term: Node):
+    if isinstance(term, URIRef) and term.startswith('http://'):
+        return URIRef(re.sub('^http', 'https', term))
+
+    return term
+
+
+class Quad(NamedTuple):
     """Triple assigned to a named graph."""
 
     subject: Node
@@ -107,6 +113,19 @@ class Quad:
             f'{rendered_graph})'  # noqa: WPS326
         )
 
-    def as_tuple(self):
-        """Represent quad as a tuple which `Graph.addN()` would understand."""
-        return self.subject, self.predicate, self.object, self.graph
+    def replace(self, mapping: dict[Node, URIRef]):
+        """Replace variables in the quad."""
+        terms = [
+            mapping.get(term, term)
+            for term in self
+        ]
+
+        return Quad(*terms)
+
+    def normalize(self) -> 'Quad':
+        """Normalize the quad by applying normalization to all its terms."""
+        terms = [
+            _normalize_term(term)
+            for term in self
+        ]
+        return Quad(*terms)

iolanta/namespaces.py

@@ -8,6 +8,8 @@ NP = rdflib.Namespace('https://www.nanopub.org/nschema#')
 RDFG = rdflib.Namespace('https://www.w3.org/2004/03/trix/rdfg-1/')
 SDO = rdflib.SDO
 
+META = rdflib.URIRef('iolanta://_meta')
+
 
 class DC(rdflib.DC):
     _NS = rdflib.Namespace('https://purl.org/dc/elements/1.1/')

iolanta/parse_quads.py

@@ -1,14 +1,21 @@
 import dataclasses
 import hashlib
-from typing import Iterable
+from types import MappingProxyType
+from typing import Iterable, Optional
+from urllib.parse import unquote
 
+from documented import DocumentedError
 from rdflib import BNode, Literal, URIRef
 from rdflib.term import Node
 
 from iolanta.errors import UnresolvedIRI
 from iolanta.models import Quad
-from iolanta.namespaces import IOLANTA, RDF
-from iolanta.parsers.errors import SpaceInProperty
+from iolanta.namespaces import IOLANTA, META
+
+NORMALIZE_TERMS_MAP = MappingProxyType({
+    URIRef(_url := 'https://www.w3.org/2002/07/owl'): URIRef(f'{_url}#'),
+    URIRef(_url := 'https://www.w3.org/2000/01/rdf-schema'): URIRef(f'{_url}#'),
+})
 
 
 def parse_term(   # noqa: C901
@@ -23,7 +30,7 @@ def parse_term(   # noqa: C901
     term_value = term['value']
 
     if term_type == 'IRI':
-        return URIRef(term_value)
+        return URIRef(unquote(term_value))
 
     if term_type == 'literal':
         language = term.get('language')
@@ -48,6 +55,40 @@ def parse_term(   # noqa: C901
     raise ValueError(f'Unknown term: {term}')
 
 
+def construct_subgraph_name(subgraph_name: str, graph: URIRef) -> URIRef:
+    """
+    Construct a proper subgraph name URI from a base name and graph.
+
+    If the subgraph name already starts with the graph URI, return it as is.
+    Otherwise, append the name as a fragment to the graph URI.
+    """
+    if subgraph_name.startswith(str(graph)):
+        return URIRef(subgraph_name)
+
+    return URIRef(f'{graph}#{subgraph_name}')
+
+
+def _parse_quads_per_subgraph(
+    raw_quads,
+    blank_node_prefix: str,
+    graph: URIRef,
+    subgraph: URIRef,
+) -> Iterable[Quad]:
+    for quad in raw_quads:
+        try:
+            yield Quad(
+                subject=parse_term(quad['subject'], blank_node_prefix),
+                predicate=parse_term(quad['predicate'], blank_node_prefix),
+                object=parse_term(quad['object'], blank_node_prefix),
+                graph=subgraph,
+            )
+        except SpaceInProperty as err:
+            raise dataclasses.replace(
+                err,
+                iri=graph,
+            )
+
+
 def parse_quads(
     quads_document,
     graph: URIRef,
@@ -59,33 +100,44 @@ def parse_quads(
     ).hexdigest()
     blank_node_prefix = f'_:{blank_node_prefix}'
 
-    for graph_name, quads in quads_document.items():
-        if graph_name == '@default':
-            graph_name = graph   # noqa: WPS440
+    subgraph_names = {
+        URIRef(subgraph_name): construct_subgraph_name(
+            subgraph_name,
+            graph=graph,
+        )
+        for subgraph_name in quads_document.keys()
+        if subgraph_name != '@default'
+    }
+    subgraph_names[graph] = graph
+
+    for subgraph, quads in quads_document.items():
+        if subgraph == '@default':
+            subgraph = graph   # noqa: WPS440
 
         else:
-            graph_name = URIRef(graph_name)
+            subgraph = URIRef(subgraph)
 
             yield Quad(
                 graph,
                 IOLANTA['has-sub-graph'],
-                graph_name,
-                graph,
+                subgraph_names[subgraph],
+                META,
             )
 
-        for quad in quads:
-            try:
-                yield Quad(
-                    subject=parse_term(quad['subject'], blank_node_prefix),
-                    predicate=parse_term(quad['predicate'], blank_node_prefix),
-                    object=parse_term(quad['object'], blank_node_prefix),
-                    graph=graph_name,
-                )
-            except SpaceInProperty as err:
-                raise dataclasses.replace(
-                    err,
-                    iri=graph,
-                )
+        quads = _parse_quads_per_subgraph(
+            quads,
+            blank_node_prefix=blank_node_prefix,
+            graph=subgraph,
+            subgraph=subgraph_names[subgraph],
+        )
+
+        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()
 
 
 def raise_if_term_is_qname(term_value: str):
@@ -102,3 +154,19 @@ def raise_if_term_is_qname(term_value: str):
         iri=term_value,
         prefix=prefix,
     )
+
+
+@dataclasses.dataclass
+class SpaceInProperty(DocumentedError):
+    """
+    Space in property.
+
+    That impedes JSON-LD parsing.
+
+    Please do not use spaces in property names in JSON or YAML data; use `title`
+    or other methods instead.
+
+    Document IRI: {self.iri}
+    """
+
+    iri: Optional[URIRef] = None

iolanta/sparqlspace/processor.py

@@ -24,8 +24,7 @@ from rdflib.plugins.sparql.parserutils import CompValue
 from rdflib.plugins.sparql.sparql import Query
 from rdflib.query import Processor
 from rdflib.term import BNode, Literal, Node
-from requests import HTTPError
-from requests.exceptions import ConnectionError
+from requests.exceptions import ConnectionError, InvalidSchema
 from yaml_ld.document_loaders.content_types import ParserNotFound
 from yaml_ld.errors import NotFound, YAMLLDError
 from yarl import URL
@@ -36,19 +35,14 @@ from iolanta.namespaces import (  # noqa: WPS235
     DCTERMS,
     FOAF,
     IOLANTA,
+    META,
     OWL,
     PROV,
     RDF,
     RDFS,
     VANN,
 )
-from iolanta.parse_quads import parse_quads
-
-NORMALIZE_TERMS_MAP = MappingProxyType({
-    URIRef(_url := 'https://www.w3.org/2002/07/owl'): URIRef(f'{_url}#'),
-    URIRef(_url := 'https://www.w3.org/2000/01/rdf-schema'): URIRef(f'{_url}#'),
-})
-
+from iolanta.parse_quads import NORMALIZE_TERMS_MAP, parse_quads
 
 REASONING_ENABLED = True
 OWL_REASONING_ENABLED = False
@@ -78,6 +72,10 @@ REDIRECTS = MappingProxyType({
         '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',
 })
 
 
@@ -94,9 +92,7 @@ def find_retractions_for(nanopublication: URIRef) -> set[URIRef]:
     # context of this dirty hack.
     use_server = 'http://grlc.nanopubs.lod.labs.vu.nl/api/local/local/'
 
-    client = NanopubClient(
-        use_server=use_server,
-    )
+    client = NanopubClient(use_server=use_server)
     client.grlc_urls = [use_server]
 
     http_url = str(nanopublication).replace(
@@ -106,7 +102,7 @@ def find_retractions_for(nanopublication: URIRef) -> set[URIRef]:
 
     try:
         retractions = client.find_retractions_of(http_url)
-    except HTTPError:
+    except (requests.HTTPError, InvalidSchema):
         return set()
 
     return {URIRef(retraction) for retraction in retractions}
@@ -289,11 +285,30 @@ def _extract_nanopublication_uris(
             )
 
 
-def apply_redirect(source: URIRef) -> URIRef:
-    """Rewrite the URL."""
+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():
-        if source.startswith(pattern):
-            return destination
+        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
 
@@ -331,7 +346,7 @@ class NanopubQueryPlugin:
             if potential_type == original_RDF.type:
                 yield potential_class
 
-    @funcy.retry(errors=HTTPError, tries=3, timeout=3)
+    @funcy.retry(errors=requests.HTTPError, tries=3, timeout=3)
     def _load_instances(self, class_uri: URIRef):
         """
         Load instances from Nanopub Registry.
@@ -537,7 +552,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
                 uri,
                 IOLANTA['last-loaded-time'],
                 None,
-                URIRef('iolanta://_meta'),
+                META,
             )),
         ) is not None
 
@@ -546,7 +561,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             uri,
             IOLANTA['last-loaded-time'],
             Literal(datetime.datetime.now()),
-            URIRef('iolanta://_meta'),
+            META,
         ))
 
     def _follow_is_visualized_with_links(self, uri: URIRef):
@@ -692,14 +707,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             self.logger.info('{source} | No data found', source=source)
             return Loaded()
 
-        quad_tuples = [
-            tuple([
-                normalize_term(term) for term in quad.as_tuple()
-            ])
-            for quad in quads
-        ]
-
-        self.graph.addN(quad_tuples)
+        self.graph.addN(quads)
         self.graph.last_not_inferred_source = source
 
         into_graphs = ', '.join({

iolanta/widgets/description.py

@@ -1,12 +1,31 @@
+from rich.markdown import Markdown
+from textual.containers import VerticalScroll
 from textual.widgets import Label
 
 
-class Description(Label):
+class Description(VerticalScroll):
     """Free form textual description."""
 
     DEFAULT_CSS = """
     Description {
-      padding: 1;
-      padding-left: 4;
+      padding: 4;
+      padding-top: 1;
+      padding-bottom: 1;
+      max-height: 100%;
     }
     """  # noqa: WPS115
+
+    def __init__(self, renderable: str | Markdown):
+        """
+        Initialize a Description widget with a renderable content.
+
+        Args:
+            renderable: Content to display, either as a string or
+                Markdown object
+        """
+        self.renderable = renderable
+        super().__init__()
+
+    def compose(self):
+        """Build and return the widget's component structure."""
+        yield Label(self.renderable)