iolanta 2.1.19__tar.gz

iolanta-2.1.19/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: iolanta
+Version: 2.1.19
+Summary: Semantic Web browser
+License: MIT
+Author: Anatoly Scherbakov
+Author-email: altaisoft@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: all
+Requires-Dist: boltons (>=24.0.0)
+Requires-Dist: classes (>=0.4.0)
+Requires-Dist: deepmerge (>=0.1.1)
+Requires-Dist: diskcache (>=5.6.3)
+Requires-Dist: documented (>=0.1.1)
+Requires-Dist: dominate (>=2.6.0)
+Requires-Dist: fastmcp (>=2.12.4,<3.0.0)
+Requires-Dist: funcy (>=2.0)
+Requires-Dist: jinja2 (>=3.1.0)
+Requires-Dist: loguru (>=0.7.3)
+Requires-Dist: more-itertools (>=9.0.0)
+Requires-Dist: nanopub (>=2.1.0,<3.0.0)
+Requires-Dist: owlrl (>=6.0.2)
+Requires-Dist: oxrdflib (>=0.4.0)
+Requires-Dist: packageurl-python (>=0.17.5)
+Requires-Dist: python-frontmatter (>=0.5.0)
+Requires-Dist: rdflib (<8.0)
+Requires-Dist: reasonable (>=0.2.6)
+Requires-Dist: requests (>=2.25.1)
+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.16)
+Requires-Dist: yarl (>=1.9.4)
+Description-Content-Type: text/markdown
+
+# iolanta | Linked Data browser
+
+---
+
+[![Build Status](https://github.com/iolanta-tech/iolanta/workflows/test/badge.svg?branch=master&event=push)](https://github.com/iolanta-tech/iolanta/actions?query=workflow%3Atest)
+[![codecov](https://codecov.io/gh/iolanta-tech/iolanta/branch/master/graph/badge.svg)](https://codecov.io/gh/iolanta-tech/iolanta)
+[![Python Version](https://img.shields.io/pypi/pyversions/iolanta.svg)](https://pypi.org/project/iolanta/)
+[![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)
+
+![Iolanta cover image](docs/assets/cover.webp)
+
+## 📦 Install with `pip`
+
+```shell
+pip install iolanta
+```
+
+## Try it out!
+
+Explore a Nanopublication:
+
+```shell
+iolanta https://w3id.org/np/RA7OYmnx-3ln_AY233lElN01wSDJWDOXPz061Ah93EQ2I
+```
+
+⇒
+
+![](docs/screenshots/w3id.org.np.ra7oymnx-3ln_ay233leln01wsdjwdoxpz061ah93eq2i.svg)
+
+See more [in the docs](https://iolanta.tech).
+

iolanta-2.1.19/README.md

@@ -0,0 +1,30 @@
+# iolanta | Linked Data browser
+
+---
+
+[![Build Status](https://github.com/iolanta-tech/iolanta/workflows/test/badge.svg?branch=master&event=push)](https://github.com/iolanta-tech/iolanta/actions?query=workflow%3Atest)
+[![codecov](https://codecov.io/gh/iolanta-tech/iolanta/branch/master/graph/badge.svg)](https://codecov.io/gh/iolanta-tech/iolanta)
+[![Python Version](https://img.shields.io/pypi/pyversions/iolanta.svg)](https://pypi.org/project/iolanta/)
+[![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)
+
+![Iolanta cover image](docs/assets/cover.webp)
+
+## 📦 Install with `pip`
+
+```shell
+pip install iolanta
+```
+
+## Try it out!
+
+Explore a Nanopublication:
+
+```shell
+iolanta https://w3id.org/np/RA7OYmnx-3ln_AY233lElN01wSDJWDOXPz061Ah93EQ2I
+```
+
+⇒
+
+![](docs/screenshots/w3id.org.np.ra7oymnx-3ln_ay233leln01wsdjwdoxpz061ah93eq2i.svg)
+
+See more [in the docs](https://iolanta.tech).

iolanta-2.1.19/iolanta/__init__.py

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

iolanta-2.1.19/iolanta/base_plugin.py

@@ -0,0 +1,5 @@
+from iolanta.plugin import Plugin
+
+
+class IolantaBase(Plugin):
+    """Base plugin."""

iolanta-2.1.19/iolanta/cli/__init__.py

@@ -0,0 +1,2 @@
+from iolanta.cli.main import app
+from iolanta.iolanta import Iolanta

iolanta-2.1.19/iolanta/cli/formatters/choose.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from rdflib import Graph
+
+from iolanta.cli.formatters.csv import csv_print
+from iolanta.cli.formatters.json import print_json
+from iolanta.cli.formatters.pretty import pretty_print
+from iolanta.models import QueryResultsFormat
+from iolanta.node_to_qname import node_to_qname
+from iolanta.query_result import SelectResult
+
+
+# @cli_print.instance(SelectResult)
+def cli_print(
+    query_result: SelectResult,
+    output_format: QueryResultsFormat,
+    display_iri_as_qname: bool = True,
+    graph: Optional[Graph] = None,
+):
+    if display_iri_as_qname:
+        if graph is None:
+            raise NotImplementedError(
+                'Cannot compute QNames if graph is not provided.',
+            )
+
+        query_result = SelectResult([
+            {
+                key: node_to_qname(node, graph)
+                for key, node in row.items()
+            }
+            for row in query_result
+        ])
+
+    {
+        QueryResultsFormat.CSV: csv_print,
+        QueryResultsFormat.PRETTY: pretty_print,
+        QueryResultsFormat.JSON: print_json,
+    }[output_format](query_result)   # type: ignore

iolanta-2.1.19/iolanta/cli/formatters/csv.py

@@ -0,0 +1,35 @@
+import csv
+import sys
+
+from classes import typeclass
+from rdflib import Graph
+
+from iolanta.query_result import QueryResult, SelectResult
+
+
+@typeclass
+def csv_print(query_result: QueryResult) -> None:
+    """Print as CSV."""
+
+
+@csv_print.instance(SelectResult)
+def _csv_select(select_result: SelectResult):
+    if not select_result:
+        return
+
+    first_row = select_result[0]
+    fieldnames = first_row.keys()
+
+    writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames)
+    writer.writeheader()
+    writer.writerows(select_result)
+
+
+@csv_print.instance(Graph)
+def _construct_print(graph: Graph):
+    if not graph:
+        return
+
+    writer = csv.writer(sys.stdout)
+    writer.writerow(('subject', 'predicate', 'object'))
+    writer.writerows(graph)

iolanta-2.1.19/iolanta/cli/formatters/json.py

@@ -0,0 +1,32 @@
+import json
+import sys
+
+from classes import typeclass
+from rdflib import Graph
+
+from iolanta.query_result import QueryResult, SelectResult
+
+
+@typeclass
+def print_json(query_result: QueryResult) -> None:
+    """Print query result as JSON."""
+
+
+@print_json.instance(SelectResult)
+def _print_select_as_json(select_result: SelectResult):
+    sys.stdout.write(json.dumps(select_result, indent=2, default=str))
+
+
+@print_json.instance(Graph)
+def _print_construct_as_json(graph: Graph):
+    fieldnames = ('subject', 'predicate', 'object')
+    sys.stdout.write(
+        json.dumps(
+            [
+                dict(zip(fieldnames, triple))
+                for triple in graph
+            ],
+            indent=2,
+            default=str,
+        ),
+    )

iolanta-2.1.19/iolanta/cli/formatters/pretty.py

@@ -0,0 +1,126 @@
+import itertools
+from typing import Union
+
+from classes import typeclass
+from more_itertools import consume, first
+from rdflib import BNode, Graph, Literal, URIRef
+from rich.console import Console
+from rich.table import Table
+
+from iolanta.cli.pretty_print import render_literal_value
+from iolanta.models import ComputedQName
+from iolanta.query_result import QueryResult, SelectResult
+
+
+@typeclass
+def pretty_print_value(rdflib_value: Union[URIRef, Literal, BNode]) -> str:
+    """Pretty print a value for a table in CLI."""
+
+
+@pretty_print_value.instance(type(None))
+def _pretty_print_none(none_value):
+    """Format None."""
+    return f'∅ {none_value}'
+
+
+@pretty_print_value.instance(URIRef)
+def _pretty_print_value_uri_ref(uriref: URIRef):
+    """Format URI Ref."""
+    return f'🔗 {uriref}'
+
+
+@pretty_print_value.instance(ComputedQName)
+def _pretty_print_value_uri_ref(qname: ComputedQName):
+    """Format QName."""
+    return (
+        f'🔗 [link={qname.namespace_url}]'
+        f'[blue]{qname.namespace_name}[/blue][/link]:'
+        f'{qname.term}'
+    )
+
+
+@pretty_print_value.instance(Literal)
+def _pretty_print_literal(literal: Literal):
+    """Render a literal."""
+    rendered_value = render_literal_value(literal.toPython())
+
+    if literal.language:
+        formatted_language = {
+            'ru': '🇷🇺',
+            'en': '🇺🇸',
+            'ua': '🇺🇦',
+        }[literal.language]
+
+        return f'{formatted_language} {rendered_value}'
+
+    return rendered_value
+
+
+@pretty_print_value.instance(BNode)
+def _pretty_print_bnode(bnode: BNode):
+    """Print a blank node."""
+    return f'😶 {bnode}'
+
+
+@typeclass
+def pretty_print(query_result: QueryResult):
+    """Pretty print query result."""
+
+
+@pretty_print.instance(SelectResult)
+def _pretty_print_select_result(select_result: SelectResult):
+    """Print a SPARQL query result in style."""
+    if not select_result:
+        return
+
+    columns = first(select_result).keys()
+
+    table = Table(
+        *columns,
+        show_header=True,
+        header_style="bold magenta",
+    )
+
+    consume(
+        itertools.starmap(
+            table.add_row,
+            [
+                map(
+                    pretty_print_value,
+                    row.values(),
+                )
+                for row in select_result
+            ],
+        ),
+    )
+
+    Console().print(table)
+
+
+@pretty_print.instance(Graph)
+def _pretty_construct(graph: Graph):
+    if not graph:
+        return
+
+    table = Table(
+        'Subject',
+        'Predicate',
+        'Object',
+        show_header=True,
+        header_style="bold magenta",
+    )
+
+    consume(
+        itertools.starmap(
+            table.add_row,
+            [
+                map(
+                    pretty_print_value,
+                    triple,
+                )
+                for triple in graph
+            ],
+        ),
+    )
+
+    Console().print(table)

iolanta-2.1.19/iolanta/cli/main.py

@@ -0,0 +1,301 @@
+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://", ""))
+            # Load current directory (like CLI AI agents): use parent if path is a file
+            project_root = path.parent if path.is_file() else path
+            iolanta: Iolanta = Iolanta(
+                language=Literal(language),
+                logger=logger,
+                project_root=project_root,
+            )
+        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.19/iolanta/cli/models.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class LogLevel(str, Enum):
+    """Logging level."""
+
+    DEBUG = 'debug'
+    INFO = 'info'
+    WARNING = 'warning'
+    ERROR = 'error'