iolanta 2.1.11__tar.gz → 2.1.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iolanta
-Version: 2.1.11
+Version: 2.1.13
 Summary: Semantic Web browser
 License: MIT
 Author: Anatoly Scherbakov
@@ -34,7 +34,7 @@ Requires-Dist: rich (>=13.3.1)
 Requires-Dist: textual (>=0.83.0)
 Requires-Dist: typer (>=0.9.0)
 Requires-Dist: watchfiles (>=1.0.4)
-Requires-Dist: yaml-ld (>=1.1.15)
+Requires-Dist: yaml-ld (>=1.1.16)
 Requires-Dist: yarl (>=1.9.4)
 Description-Content-Type: text/markdown
 

iolanta-2.1.13/iolanta/cli/main.py

@@ -0,0 +1,299 @@
+import locale
+import logging
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import loguru
+import platformdirs
+from documented import DocumentedError
+from rdflib import Graph, 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 yarl import URL
+
+from iolanta.cli.models import LogLevel
+from iolanta.facets.errors import FacetNotFound
+from iolanta.iolanta import Iolanta
+from iolanta.models import NotLiteralNode
+from iolanta.namespaces import DATATYPES
+from iolanta.query_result import (
+    QueryResult,
+    SPARQLParseException,
+    SelectResult,
+)
+
+DEFAULT_LANGUAGE = locale.getlocale()[0].split("_")[0]
+
+
+console = Console()
+
+
+app = Typer(no_args_is_help=True)
+
+
+def string_to_node(name: str) -> NotLiteralNode:
+    """
+    Parse a string into a node identifier.
+
+    String might be:
+      * a URL,
+      * or a local disk path.
+    """
+    url = URL(name)
+    if url.scheme:
+        return URIRef(name)
+
+    path = Path(name).absolute()
+    return URIRef(f"file://{path}")
+
+
+def decode_datatype(datatype: str) -> URIRef:
+    if datatype.startswith("http"):
+        return URIRef(datatype)
+
+    return URIRef(f"https://iolanta.tech/datatypes/{datatype}")
+
+
+def setup_logging(log_level: LogLevel):
+    """Configure and return logger."""
+    level = {
+        LogLevel.DEBUG: logging.DEBUG,
+        LogLevel.INFO: logging.INFO,
+        LogLevel.WARNING: logging.WARNING,
+        LogLevel.ERROR: logging.ERROR,
+    }[log_level]
+
+    log_file_path = (
+        platformdirs.user_log_path(
+            "iolanta",
+            ensure_exists=True,
+        )
+        / "iolanta.log"
+    )
+
+    level_name = {
+        logging.DEBUG: "DEBUG",
+        logging.INFO: "INFO",
+        logging.WARNING: "WARNING",
+        logging.ERROR: "ERROR",
+    }[level]
+
+    loguru.logger.remove()
+    loguru.logger.add(
+        log_file_path,
+        level=level_name,
+        format="{time} {level} {message}",
+        enqueue=True,
+    )
+    loguru.logger.add(
+        sys.stderr,
+        level=level_name,
+        format="{time} | {level:<8} | {name}:{function}:{line} - {message}",
+    )
+    loguru.logger.level(level_name)
+
+    return loguru.logger
+
+
+def handle_error(
+    error: Exception,
+    log_level: LogLevel,
+    use_markdown: bool = True,
+) -> None:
+    """
+    Handle an error by checking log level and printing appropriately.
+
+    If log level is DEBUG or INFO, re-raise the error.
+    Otherwise, print it and exit with code 1.
+    """
+    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 error
+
+    if use_markdown:
+        console.print(
+            Markdown(
+                str(error),
+                justify="left",
+            ),
+        )
+    else:
+        console.print(str(error))
+
+    raise Exit(1)
+
+
+def create_query_node(query_result: QueryResult) -> Literal:
+    """
+    Create a Literal node from a query result.
+
+    Converts QueryResult (SelectResult, Graph, or bool) into a Literal
+    with the appropriate datatype for facet rendering.
+    """
+    match query_result:
+        case SelectResult():
+            return Literal(
+                query_result,
+                datatype=DATATYPES["sparql-select-result"],
+            )
+        case Graph():
+            return Literal(
+                query_result,
+                datatype=DATATYPES["sparql-construct-result"],
+            )
+        case bool():
+            return Literal(
+                query_result,
+                datatype=DATATYPES["sparql-ask-result"],
+            )
+
+
+def render_and_return(
+    node: Literal | URIRef,
+    as_datatype: str,
+    language: str = DEFAULT_LANGUAGE,
+    log_level: LogLevel = LogLevel.ERROR,
+):
+    """
+    Render a node.
+
+    The node must be either a URIRef (for URLs) or a Literal (for query results).
+    """
+    logger = setup_logging(log_level)
+
+    # Determine Iolanta instance based on node type
+    if isinstance(node, Literal):
+        # Literal nodes (e.g., from query results) are used directly
+        # Use current directory as project_root for query results
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+            project_root=Path.cwd(),
+        )
+    elif isinstance(node, URIRef):
+        # URIRef - determine project_root if it's a file:// URI
+        if str(node).startswith("file://"):
+            path = Path(str(node).replace("file://", ""))
+            iolanta: Iolanta = Iolanta(
+                language=Literal(language),
+                logger=logger,
+                project_root=path,
+            )
+        else:
+            iolanta: Iolanta = Iolanta(
+                language=Literal(language),
+                logger=logger,
+            )
+    else:
+        # This should never happen due to type checking, but kept for safety
+        raise TypeError(f"Expected Literal or URIRef, got {type(node)}")
+
+    return iolanta.render(
+        node=node,
+        as_datatype=decode_datatype(as_datatype),
+    )
+
+
+@app.command(name="render")
+def render_command(  # noqa: WPS231, WPS238, WPS210, C901
+    url: Annotated[str | None, Argument()] = None,
+    query: Annotated[
+        str | None,
+        Option(
+            "--query",
+            help="SPARQL query to execute.",
+        ),
+    ] = None,
+    as_datatype: Annotated[
+        str | None,
+        Option(
+            "--as",
+        ),
+    ] = None,
+    language: Annotated[
+        str,
+        Option(
+            help="Data language to prefer.",
+        ),
+    ] = DEFAULT_LANGUAGE,
+    log_level: LogLevel = LogLevel.ERROR,
+):
+    """Render a given URL."""
+    if query is not None:
+        # For queries, default to 'table' format
+        if as_datatype is None:
+            as_datatype = "table"
+
+        # Setup logging and create Iolanta instance (unlikely to raise)
+        logger = setup_logging(log_level)
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+            project_root=Path.cwd(),
+        )
+
+        try:
+            renderable = render_and_return(
+                node=create_query_node(iolanta.query(query)),
+                as_datatype=as_datatype,
+                language=language,
+                log_level=log_level,
+            )
+        except (SPARQLParseException, DocumentedError, FacetNotFound) as error:
+            handle_error(error, log_level, use_markdown=True)
+        except Exception as error:
+            handle_error(error, log_level, use_markdown=False)
+        else:
+            # FIXME: An intermediary Literal can be used to dispatch rendering.
+            match renderable:
+                case Table() as table:
+                    console.print(table)
+
+                case unknown:
+                    console.print(unknown)
+        return
+
+    if url is None:
+        console.print("Error: Either URL or --query must be provided")
+        raise Exit(1)
+
+    # For URLs, default to interactive mode
+    if as_datatype is None:
+        as_datatype = "https://iolanta.tech/cli/interactive"
+
+    # Parse string URL to URIRef (URL() is permissive and won't raise)
+    node_url = URL(url)
+    if node_url.scheme and node_url.scheme != "file":
+        node = URIRef(url)
+    else:
+        path = Path(node_url.path).absolute()
+        node = URIRef(f"file://{path}")
+
+    try:
+        renderable = render_and_return(
+            node=node,
+            as_datatype=as_datatype,
+            language=language,
+            log_level=log_level,
+        )
+    except DocumentedError as error:
+        handle_error(error, log_level, use_markdown=True)
+    except Exception as error:
+        handle_error(error, log_level, use_markdown=False)
+    else:
+        # FIXME: An intermediary Literal can be used to dispatch rendering.
+        match renderable:
+            case Table() as table:
+                console.print(table)
+
+            case unknown:
+                console.print(unknown)

{iolanta-2.1.11 → iolanta-2.1.13}/iolanta/facets/facet.py

@@ -2,32 +2,38 @@ import inspect
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
-from typing import Any, Generic, Iterable, Optional, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar, Union
 
-from rdflib.term import BNode, Literal, Node, URIRef
+from rdflib.term import Literal, Node
 
-from iolanta.models import NotLiteralNode, Triple, TripleTemplate
+from iolanta.models import NotLiteralNode
 from iolanta.query_result import QueryResult, SPARQLQueryArgument
 
-FacetOutput = TypeVar('FacetOutput')
+FacetOutput = TypeVar("FacetOutput")
 
 
 @dataclass
-class Facet(Generic[FacetOutput]):
+class Facet(Generic[FacetOutput]):  # noqa: WPS214
     """Base facet class."""
 
     this: Node
-    iolanta: 'iolanta.Iolanta' = field(repr=False)
+    iolanta: "iolanta.Iolanta" = field(repr=False)
     as_datatype: Optional[NotLiteralNode] = None
 
     def __post_init__(self):
-        if type(self.this) == str:
-            raise ValueError(f'Facet {self.__class__.__name__} received a string as this: {self.this}')
+        if not isinstance(self.this, Node):
+            facet_name = self.__class__.__name__
+            this_type = type(self.this).__name__
+            raise ValueError(
+                f"Facet {facet_name} received a non-Node as this: {self.this} (type: {this_type})"
+            )
 
     @property
     def stored_queries_path(self) -> Path:
         """Construct directory for stored queries for this facet."""
-        return Path(inspect.getfile(self.__class__)).parent / 'sparql'
+        return Path(inspect.getfile(self.__class__)).parent / "sparql"
+
+    inference_path: Optional[Path] = None
 
     def query(
         self,

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/facet.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+from typing import Iterable
+
+from rdflib import BNode, Literal, Node, URIRef
+
+from iolanta import Facet
+from iolanta.mermaid.models import (
+    Diagram,
+    MermaidBlankNode,
+    MermaidEdge,
+    MermaidLiteral,
+    MermaidScalar,
+    MermaidSubgraph,
+    MermaidURINode,
+)
+from iolanta.namespaces import DATATYPES
+from pydantic import AnyUrl
+from rdflib import URIRef as RDFURIRef
+
+
+class TaskNode(MermaidScalar):
+    """A Mermaid node with attached CSS classes."""
+
+    node: MermaidURINode | MermaidBlankNode | MermaidLiteral
+    classes: list[str] = []
+
+    def __str__(self) -> str:
+        """Render the wrapped node."""
+        return str(self.node)
+
+    @property
+    def id(self) -> str:
+        """Get the ID of the wrapped node."""
+        return self.node.id
+
+
+class BlocksEdge(MermaidEdge):
+    """
+    {self.source.id} --> {self.target.id}
+    """
+
+    def __init__(self, source, target):
+        # Initialize with empty title and a dummy predicate
+        super().__init__(
+            source=source,
+            target=target,
+            predicate=RDFURIRef('https://iolanta.tech/roadmap/blocks'),
+            title='',
+        )
+
+    def __str__(self) -> str:
+        # Override to remove intermediate node - just direct arrow
+        return f'{self.source.id} --> {self.target.id}'
+
+
+# Rebuild Pydantic models to resolve forward references
+# Need to rebuild MermaidEdge first so MermaidSubgraph is available
+MermaidEdge.model_rebuild()
+BlocksEdge.model_rebuild()
+
+
+class MermaidRoadmap(Facet[str]):
+    """Mermaid roadmap diagram."""
+
+    META = Path(__file__).parent / 'mermaid_roadmap.yamlld'
+
+    inference_path = Path(__file__).parent / 'inference'
+
+    def show(self) -> str:
+        """Render mermaid roadmap diagram."""
+        children = list(self.construct_mermaid_for_graph(self.this))
+        
+        # Extract class assignments from TaskNode instances
+        tail_parts = ['classDef unblocked fill:#0a5,stroke:#063,stroke-width:2px,color:#fff;']
+        for child in children:
+            if isinstance(child, TaskNode) and child.classes:
+                for class_name in child.classes:
+                    tail_parts.append(f'class {child.id} {class_name}')
+        
+        tail = '\n'.join(tail_parts)
+        
+        return str(Diagram(
+            children=children,
+            tail=tail,
+        ))
+
+    def as_mermaid(self, node: Node):
+        """Convert RDF node to Mermaid node."""
+        match node:
+            case URIRef() as uri:
+                return MermaidURINode(
+                    uri=uri,
+                    url=AnyUrl(uri),
+                    title=self.render(uri, as_datatype=DATATYPES.title),
+                )
+            case Literal() as literal:
+                return MermaidLiteral(literal=literal)
+            case BNode() as bnode:
+                return MermaidBlankNode(
+                    node=bnode,
+                    title=self.render(bnode, as_datatype=DATATYPES.title),
+                )
+            case unknown:
+                unknown_type = type(unknown)
+                raise ValueError(f'Unknown node type: {unknown} ({unknown_type})')
+
+    def construct_mermaid_for_graph(self, graph: URIRef) -> Iterable[MermaidScalar]:
+        """Render graph as mermaid."""
+        # Get nodes
+        node_rows = self.stored_query('nodes.sparql')
+        node_rows_list = list(node_rows)
+        
+        nodes = [
+            TaskNode(
+                node=self.as_mermaid(row['node']),
+                classes=['unblocked'] if row.get('is_unblocked', False) else [],
+            )
+            for row in node_rows_list
+        ]
+
+        # Get edges for roadmap:blocks relationships
+        edge_rows = self.stored_query('edges.sparql')
+        edge_rows_list = list(edge_rows)
+        
+        edges = [
+            BlocksEdge(
+                source=self.as_mermaid(row['source']),
+                target=self.as_mermaid(row['target']),
+            )
+            for row in edge_rows_list
+        ]
+
+        return [*nodes, *edges]

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/inference/blocks.sparql

@@ -0,0 +1,13 @@
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+
+CONSTRUCT {
+  ?a roadmap:blocks ?b .
+}
+WHERE {
+  ?b roadmap:is-blocked-by ?a .
+  
+  # Only infer if the relationship doesn't already exist
+  FILTER NOT EXISTS {
+    ?a roadmap:blocks ?b .
+  }
+}

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/inference/has-task-default-type.sparql

@@ -0,0 +1,16 @@
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+CONSTRUCT {
+  ?item a roadmap:Task .
+}
+WHERE {
+  # Find items that are values of roadmap:has-task property
+  ?container roadmap:has-task ?item .
+  
+  # Only infer if the item isn't already typed as a roadmap type
+  FILTER NOT EXISTS {
+    ?item rdf:type ?type .
+    FILTER(?type IN (roadmap:Task, roadmap:Event, roadmap:Bug))
+  }
+}

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/inference/task.sparql

@@ -0,0 +1,26 @@
+# It is imperative that this query executes after `blocks.sparql` because it relies upon proper `roadmap:blocks` relations.
+
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+CONSTRUCT {
+  ?other a roadmap:Task .
+}
+WHERE {
+  # Match either Task or Event
+  {
+    ?task rdf:type roadmap:Task .
+  } UNION {
+    ?task rdf:type roadmap:Event .
+  }
+  
+  # Find nodes connected via roadmap:blocks chain (in either direction)
+  # ^roadmap:blocks is the inverse (equivalent to roadmap:is-blocked-by)
+  ?task (roadmap:blocks | ^roadmap:blocks)+ ?other .
+  
+  # Only infer if the node isn't already a Task
+  # (to avoid redundant triples, but allow inference even if node has other types)
+  FILTER NOT EXISTS {
+    ?other rdf:type roadmap:Task .
+  }
+}

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/inference/unblocked.sparql

@@ -0,0 +1,21 @@
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+CONSTRUCT {
+  ?task a roadmap:Unblocked .
+}
+WHERE {
+  # Match Task, Event, or Bug instances
+  {
+    ?task a roadmap:Task .
+  } UNION {
+    ?task a roadmap:Event .
+  } UNION {
+    ?task a roadmap:Bug .
+  }
+  
+  # Only infer if there are no incoming blocks links
+  FILTER NOT EXISTS {
+    ?other roadmap:blocks ?task .
+  }
+}

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/mermaid_roadmap.yamlld

@@ -0,0 +1,59 @@
+"@context":
+  "@import": https://json-ld.org/contexts/dollar-convenience.jsonld
+  roadmap: https://roadmap.iolanta.tech/
+  iolanta: https://iolanta.tech/
+  rdfs: http://www.w3.org/2000/01/rdf-schema#
+  prov: http://www.w3.org/ns/prov#
+  owl: http://www.w3.org/2002/07/owl#
+
+  $: rdfs:label
+
+  rdfs:subClassOf:
+    "@type": "@id"
+  
+  rdfs:subPropertyOf:
+    "@type": "@id"
+
+  owl:inverseOf:
+    "@type": "@id"
+
+  →:
+    "@type": "@id"
+    "@id": iolanta:outputs
+
+  ↦:
+    "@id": iolanta:matches
+    "@type": iolanta:SPARQLText
+
+$id: pkg:pypi/iolanta#mermaid-roadmap
+$: Mermaid Roadmap
+
+→:
+  $id: https://iolanta.tech/roadmap/datatypes/mermaid
+  $: Mermaid
+  $type: iolanta:OutputDatatype
+  rdfs:subClassOf: https://iolanta.tech/datatypes/mermaid
+
+↦:
+  - ASK WHERE { GRAPH $this { ?s ?p ?o } }
+
+$included:
+  - $id: roadmap:Task
+    rdfs:subClassOf: prov:Activity
+    $: Task
+  
+  - $id: roadmap:Bug
+    rdfs:subClassOf: roadmap:Task
+    $: Bug
+  
+  - $id: roadmap:Event
+    rdfs:subClassOf: prov:Activity
+    $: Event
+  
+  - $id: roadmap:is-blocked-by
+    rdfs:subPropertyOf: prov:wasInformedBy
+    $: Is blocked by
+  
+  - $id: roadmap:blocks
+    owl:inverseOf: roadmap:is-blocked-by
+    $: Blocks

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/sparql/edges.sparql

@@ -0,0 +1,25 @@
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+
+SELECT DISTINCT ?source ?target WHERE {
+    # Find roadmap:blocks relationships across all graphs (including inferred)
+    ?source roadmap:blocks ?target .
+    
+    # Only include edges where both source and target are Task/Event/Bug nodes
+    # (they will be filtered by the nodes query, but this ensures we only show
+    # relevant edges)
+    {
+        ?source a roadmap:Task .
+    } UNION {
+        ?source a roadmap:Event .
+    } UNION {
+        ?source a roadmap:Bug .
+    }
+    
+    {
+        ?target a roadmap:Task .
+    } UNION {
+        ?target a roadmap:Event .
+    } UNION {
+        ?target a roadmap:Bug .
+    }
+}

iolanta-2.1.13/iolanta/facets/mermaid_roadmap/sparql/nodes.sparql

@@ -0,0 +1,17 @@
+PREFIX roadmap: <https://iolanta.tech/roadmap/>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+SELECT DISTINCT ?node ?is_unblocked WHERE {
+    # Search across all graphs (including inference graphs)
+    # This finds both original types and inferred types
+    {
+        ?node rdf:type roadmap:Task .
+    } UNION {
+        ?node rdf:type roadmap:Event .
+    } UNION {
+        ?node rdf:type roadmap:Bug .
+    }
+    
+    # Check if node is unblocked (has roadmap:Unblocked type)
+    BIND(EXISTS { ?node rdf:type roadmap:Unblocked } AS ?is_unblocked)
+}