iolanta 1.2.6__tar.gz → 1.2.8__tar.gz

{iolanta-1.2.6 → iolanta-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iolanta
-Version: 1.2.6
+Version: 1.2.8
 Summary: Semantic Web browser
 License: MIT
 Author: Anatoly Scherbakov
@@ -32,6 +32,7 @@ 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,<2.0.0)
 Requires-Dist: yaml-ld (>=1.1.3)
 Requires-Dist: yarl (>=1.9.4)
 Description-Content-Type: text/markdown

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/cli/main.py

@@ -1,17 +1,20 @@
 import locale
 import logging
+from pathlib import Path
 from typing import Annotated
 
 import loguru
 import platformdirs
 from documented import DocumentedError
-from rdflib import Literal
+from rdflib import Literal, URIRef
 from rich.console import Console
 from rich.markdown import Markdown
 from typer import Argument, Exit, Option, Typer
+from yarl import URL
 
 from iolanta.cli.models import LogLevel
 from iolanta.iolanta import Iolanta
+from iolanta.models import NotLiteralNode
 
 DEFAULT_LANGUAGE = locale.getlocale()[0].split('_')[0]
 
@@ -38,8 +41,24 @@ def construct_app() -> Typer:
 app = construct_app()
 
 
+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}')
+
+
 @app.command(name='browse')
-def render_command(   # noqa: WPS231, WPS238
+def render_command(   # noqa: WPS231, WPS238, WPS210, C901
     url: Annotated[str, Argument()],
     as_datatype: Annotated[
         str, Option(
@@ -74,17 +93,27 @@ def render_command(   # noqa: WPS231, WPS238
         enqueue=True,
     )
 
-    iolanta: Iolanta = Iolanta(
-        language=Literal(language),
-        logger=logger,
-    )
+    node_url = URL(url)
+    if node_url.scheme:
+        node = URIRef(url)
 
-    node = iolanta.string_to_node(url)
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+        )
+    else:
+        path = Path(url).absolute()
+        node = URIRef(f'file://{path}')
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+            project_root=path,
+        )
 
     try:
         renderable, stack = iolanta.render(
             node=node,
-            as_datatype=iolanta.string_to_node(as_datatype),
+            as_datatype=URIRef(as_datatype),
         )
 
     except DocumentedError as documented_error:

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/cyberspace/processor.py

@@ -131,6 +131,10 @@ def _extract_from_mapping(  # noqa: WPS213
             yield from extract_mentioned_urls(algebra['p2'])
             yield from extract_mentioned_urls(algebra['expr'])
 
+        case 'Join':
+            yield from extract_mentioned_urls(algebra['p1'])
+            yield from extract_mentioned_urls(algebra['p2'])
+
         case 'ConditionalOrExpression' | 'ConditionalAndExpression':
             yield from extract_mentioned_urls(algebra['expr'])
             yield from extract_mentioned_urls(algebra['other'])
@@ -149,10 +153,8 @@ def _extract_from_mapping(  # noqa: WPS213
         case unknown_name:
             formatted_keys = ', '.join(algebra.keys())
             loguru.logger.error(
-                'Unknown SPARQL expression %s(%s): %s',
-                unknown_name,
-                formatted_keys,
-                algebra,
+                'Unknown SPARQL expression '
+                f'{unknown_name}({formatted_keys}): {algebra}',
             )
             return
 
@@ -422,7 +424,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
                         and isinstance(self.load(maybe_iri), Loaded)
                     ):
                         is_anything_loaded = True   # noqa: WPS220
-                        self.logger.warning(   # noqa: WPS220
+                        self.logger.info(   # noqa: WPS220
                             'Newly loaded: {uri}',
                             uri=maybe_iri,
                         )
@@ -463,6 +465,8 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         )
         if existing_triple is not None:
             return Skipped()
+        else:
+            self.logger.info(f'Existing triples not found for {source_uri}')
 
         # FIXME This is definitely inefficient. However, python-yaml-ld caches
         #   the document, so the performance overhead is not super high.
@@ -563,10 +567,10 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
             )
             return Loaded()
         except ParserNotFound as parser_not_found:
-            self.logger.info('%s | %s', source, str(parser_not_found))
+            self.logger.info(f'{source} | {parser_not_found}')
             return Loaded()
         except YAMLLDError as yaml_ld_error:
-            self.logger.error('%s | %s', source, str(yaml_ld_error))
+            self.logger.error(f'{source} | {yaml_ld_error}')
             return Loaded()
 
         try:
@@ -604,32 +608,13 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         self.graph.addN(quad_tuples)
         self.graph.last_not_inferred_source = source
 
-        created_graphs = {
-            normalize_term(quad.graph)
+        into_graphs = ', '.join({
+            quad.graph
             for quad in quads
-            if quad.graph != source_uri
-        }
-        self.graph.addN(
-            itertools.chain.from_iterable(
-                [
-                    (
-                        source_uri,
-                        IOLANTA['has-sub-graph'],
-                        created_graph,
-                        source_uri,
-                    ),
-                    (
-                        created_graph,
-                        RDF.type,
-                        IOLANTA.Graph,
-                        source_uri,
-                    ),
-                ]
-                for created_graph in created_graphs
-            ),
+        })
+        self.logger.info(
+            f'{source} | loaded successfully into graphs: {into_graphs}',
         )
-
-        self.logger.info(f'{source} | loaded successfully.')
         return Loaded()
 
     def resolve_term(self, term: Node, bindings: dict[str, Node]):

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/page_title.py

@@ -22,8 +22,7 @@ class PageTitle(IolantaWidgetMixin, Static):
         """Initialize."""
         self.iri = iri
         self.extra = extra
-        qname = self.iolanta.node_as_qname(iri)
-        super().__init__(qname)
+        super().__init__(iri)
 
     def construct_title(self):
         """Render the title via Iolanta in a thread."""

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_browser/app.py

@@ -4,6 +4,7 @@ from concurrent.futures import ThreadPoolExecutor
 from rdflib.term import Node
 from rich.console import RenderableType
 from textual.app import App, ComposeResult
+from textual.css.query import NoMatches
 from textual.widgets import Footer, Header
 
 from iolanta.facets.textual_browser.page_switcher import (
@@ -13,6 +14,8 @@ from iolanta.facets.textual_browser.page_switcher import (
 )
 from iolanta.iolanta import Iolanta
 
+POPUP_TIMEOUT = 30   # seconds
+
 
 class DevConsoleHandler(logging.Handler):
     """Pipe log output → dev console."""
@@ -28,6 +31,17 @@ class DevConsoleHandler(logging.Handler):
         self.console.write(message)
 
 
+def _log_message_to_dev_console(app: App):
+    """Log a message to the dev console."""
+    def log_message_to_dev_console(message: str):   # noqa: WPS430
+        try:
+            app.query_one(DevConsole).write(message)
+        except NoMatches:
+            return
+
+    return log_message_to_dev_console
+
+
 class IolantaBrowser(App):  # noqa: WPS214, WPS230
     """Browse Linked Data."""
 
@@ -69,11 +83,21 @@ class IolantaBrowser(App):  # noqa: WPS214, WPS230
 
         # Log to the dev console.
         self.iolanta.logger.add(
-            lambda msg: self.query_one(DevConsole).write(msg),
+            _log_message_to_dev_console(self),
             level='INFO',
             format='{time} {level} {message}',
         )
 
+        self.iolanta.logger.add(
+            lambda msg: self.notify(
+                msg,
+                severity='warning',
+                timeout=POPUP_TIMEOUT,
+            ),
+            level='WARNING',
+            format='{message}',
+        )
+
     def action_toggle_dark(self) -> None:
         """Toggle dark mode."""
         self.dark = not self.dark

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_browser/location.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
 
+from rdflib import URIRef
+
 
 @dataclass
 class Location:
@@ -7,3 +9,4 @@ class Location:
 
     page_id: str
     url: str
+    facet_iri: URIRef | None = None

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_browser/page_switcher.py

@@ -1,6 +1,10 @@
 import functools
+import threading
 import uuid
+from dataclasses import dataclass
+from typing import Any
 
+import watchfiles
 from rdflib import BNode, URIRef
 from textual.widgets import ContentSwitcher, RichLog
 from textual.worker import Worker, WorkerState
@@ -18,6 +22,21 @@ from iolanta.namespaces import DATATYPES
 from iolanta.widgets.mixin import IolantaWidgetMixin
 
 
+@dataclass
+class RenderResult:
+    """
+    We asked a thread to render something for us.
+
+    This is what did we get back.
+    """
+
+    iri: NotLiteralNode
+    renderable: Any
+    flip_options: list[FlipOption]
+    facet_iri: URIRef
+    is_reload: bool
+
+
 class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
     """
     Container for open pages.
@@ -28,12 +47,15 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
     BINDINGS = [  # noqa: WPS115
         ('alt+left', 'back', 'Back'),
         ('alt+right', 'forward', 'Fwd'),
+        ('f5', 'reload', '🔄 Reload'),
+        ('escape', 'abort', '🛑 Abort'),
         ('f12', 'console', 'Console'),
     ]
 
     def __init__(self):
         """Set Home as first tab."""
         super().__init__(id='page_switcher', initial='home')
+        self.stop_file_watcher_event = threading.Event()
 
     def action_console(self):
         """Open dev console."""
@@ -53,22 +75,39 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
     def on_mount(self):
         """Navigate to the initial page."""
         self.action_goto(self.app.iri)
+        if self.iolanta.project_root:
+            self.run_worker(
+                self._watch_files,
+                thread=True,
+            )
+
+    def on_unmount(self) -> None:
+        """Stop watching files."""
+        self.stop_file_watcher_event.set()
+
+    def _watch_files(self):
+        for _ in watchfiles.watch(   # noqa: WPS352
+            self.iolanta.project_root,
+            stop_event=self.stop_file_watcher_event,
+        ):
+            self.app.call_from_thread(self.action_reload)
 
     def render_iri(   # noqa: WPS210
-        self, destination: NotLiteralNode, facet_iri: URIRef | None,
-    ):
+        self,
+        destination: NotLiteralNode,
+        facet_iri: URIRef | None,
+        is_reload: bool,
+    ) -> RenderResult:
         """Render an IRI in a thread."""
         self.iri = destination
         iolanta: Iolanta = self.iolanta
 
         as_datatype = URIRef('https://iolanta.tech/cli/textual')
-        choices = self.app.call_from_thread(
-            FacetFinder(
-                iolanta=self.iolanta,
-                node=destination,
-                as_datatype=as_datatype,
-            ).choices,
-        )
+        choices = FacetFinder(
+            iolanta=self.iolanta,
+            node=destination,
+            as_datatype=as_datatype,
+        ).choices()
 
         if not choices:
             raise FacetNotFound(
@@ -106,11 +145,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         )
 
         try:
-            return (
-                destination,
-                self.app.call_from_thread(facet.show),
-                flip_options,
-            )
+            renderable = facet.show()
 
         except Exception as err:
             raise FacetError(
@@ -119,6 +154,14 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
                 error=err,
             ) from err
 
+        return RenderResult(
+            iri=destination,
+            renderable=renderable,
+            flip_options=flip_options,
+            facet_iri=facet_iri,
+            is_reload=is_reload,
+        )
+
     def on_worker_state_changed(   # noqa: WPS210
         self,
         event: Worker.StateChanged,
@@ -126,24 +169,98 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         """Render a page as soon as it is ready."""
         match event.state:
             case WorkerState.SUCCESS:
-                iri, renderable, flip_options = event.worker.result
-                page_uid = uuid.uuid4().hex
-                page_id = f'page_{page_uid}'
-                page = Page(
-                    renderable,
-                    iri=iri,
-                    page_id=page_id,
-                    flip_options=flip_options,
-                )
-                self.mount(page)
-                self.current = page_id
-                page.focus()
-                self.history.goto(Location(page_id, iri))
-                self.app.sub_title = iri
+                render_result: RenderResult = event.worker.result
+
+                if render_result.is_reload:
+                    # We are reloading the current page.
+                    current_page = self.query_one(f'#{self.current}', Page)
+                    current_page.remove_children()
+                    current_page.mount(render_result.renderable)
+
+                    # FIXME: This does not actually change the flip options,
+                    #   but maybe that's okay
+                    current_page.flip_options = render_result.flip_options
+
+                else:
+                    # We are navigating to a new page.
+                    page_uid = uuid.uuid4().hex
+                    page_id = f'page_{page_uid}'
+                    page = Page(
+                        render_result.renderable,
+                        iri=render_result.iri,
+                        page_id=page_id,
+                        flip_options=render_result.flip_options,
+                    )
+                    self.mount(page)
+                    self.current = page_id
+                    page.focus()
+                    self.history.goto(
+                        Location(
+                            page_id,
+                            url=render_result.iri,
+                            facet_iri=render_result.facet_iri,
+                        ),
+                    )
+                    self.app.sub_title = render_result.iri
 
             case WorkerState.ERROR:
                 raise ValueError(event)
 
+    @property
+    def is_loading(self) -> bool:
+        """Determine if the app is presently loading something."""
+        for worker in self.workers:
+            if worker.name == 'render_iri':
+                return True
+
+        return False
+
+    def action_reload(self):
+        """Reset Iolanta graph and re-render current view."""
+        self.iolanta.reset()
+
+        self.run_worker(
+            functools.partial(
+                self.render_iri,
+                destination=self.history.current.url,
+                facet_iri=self.history.current.facet_iri,
+                is_reload=True,
+            ),
+            thread=True,
+            exclusive=True,
+            name='render_iri',
+        )
+        self.refresh_bindings()
+
+    def action_abort(self):
+        """Abort loading."""
+        self.notify(
+            'Aborted.',
+            severity='warning',
+        )
+
+        for worker in self.workers:
+            if worker.name == 'render_iri':
+                worker.cancel()
+                break
+
+        self.refresh_bindings()
+
+    def check_action(
+        self,
+        action: str,
+        parameters: tuple[object, ...],   # noqa: WPS110
+    ) -> bool | None:
+        """Check if action is available."""
+        is_loading = self.is_loading
+        match action:
+            case 'reload':
+                return not is_loading
+            case 'abort':
+                return is_loading
+
+        return True
+
     def action_goto(
         self,
         destination: str,
@@ -158,19 +275,25 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         self.run_worker(
             functools.partial(
                 self.render_iri,
-                iri,
-                facet_iri and URIRef(facet_iri),
+                destination=iri,
+                facet_iri=facet_iri and URIRef(facet_iri),
+                is_reload=False,
             ),
             thread=True,
+            exclusive=True,
+            name='render_iri',
         )
+        self.refresh_bindings()
 
     def action_back(self):
         """Go backward."""
         self.current = self.history.back().page_id
+        self.focus()
 
     def action_forward(self):
         """Go forward."""
         self.current = self.history.forward().page_id
+        self.focus()
 
 
 class ConsoleSwitcher(ContentSwitcher):

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_default/facets.py

@@ -58,6 +58,7 @@ class TextualDefaultFacet(Facet[Widget]):   # noqa: WPS214
         for property_iri, property_values in self.grouped_properties.items():
             property_name = PropertyName(
                 iri=property_iri,
+                qname=self.iolanta.node_as_qname(property_iri),
             )
 
             property_values = [
@@ -69,6 +70,7 @@ class TextualDefaultFacet(Facet[Widget]):   # noqa: WPS214
                     property_value=property_value,
                     subject=self.iri,
                     property_iri=property_iri,
+                    property_qname=self.iolanta.node_as_qname(property_iri),
                 )
                 for property_value in property_values
             ]

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_default/widgets.py

@@ -48,11 +48,11 @@ class PropertyName(Widget, can_focus=True, inherit_bindings=False):
     def __init__(
         self,
         iri: NotLiteralNode,
+        qname: str,
     ):
         """Set the IRI."""
         self.iri = iri
         super().__init__()
-        qname = self.app.iolanta.node_as_qname(iri)
         self.renderable = Text(  # noqa: WPS601
             f'⏳ {qname}',
             style='#696969',
@@ -130,17 +130,15 @@ class PropertyValue(Widget, can_focus=True, inherit_bindings=False):
         property_value: Node,
         subject: NotLiteralNode,
         property_iri: NotLiteralNode,
+        property_qname: str,
     ):
         """Initialize parameters for rendering, navigation, & provenance."""
         self.property_value = property_value
         self.subject = subject
         self.property_iri = property_iri
         super().__init__()
-        qname = self.app.iolanta.node_as_qname(  # noqa: WPS601
-            property_value,
-        )
         self.renderable = Text(  # noqa: WPS601
-            f'⏳ {qname}',
+            f'⏳ {property_qname}',
             style='#696969',
         )
 

{iolanta-1.2.6 → iolanta-1.2.8}/iolanta/facets/textual_provenance/facets.py

@@ -80,18 +80,19 @@ class ProvenanceView(Vertical):
         """Build page structure."""
         yield Title('Provenan©e for a triple')
 
+        # TODO: Calculate QNames somehow.
         yield PropertyRow(
-            PropertyName(RDF.subject),
+            PropertyName(RDF.subject, qname=str(RDF.subject)),
             RDFTermView(self.triple.subject),
         )
 
         yield PropertyRow(
-            PropertyName(RDF.predicate),
+            PropertyName(RDF.predicate, qname=str(RDF.predicate)),
             RDFTermView(self.triple.predicate),
         )
 
         yield PropertyRow(
-            PropertyName(RDF.object),
+            PropertyName(RDF.object, qname=str(RDF.object)),
             RDFTermView(self.triple.object),
         )