iolanta 1.2.7__tar.gz → 1.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iolanta
-Version: 1.2.7
+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.7 → iolanta-1.2.8}/iolanta/cli/main.py

@@ -93,18 +93,22 @@ def render_command(   # noqa: WPS231, WPS238, WPS210, C901
         enqueue=True,
     )
 
-    iolanta: Iolanta = Iolanta(
-        language=Literal(language),
-        logger=logger,
-    )
-
     node_url = URL(url)
     if node_url.scheme:
         node = URIRef(url)
+
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+        )
     else:
         path = Path(url).absolute()
         node = URIRef(f'file://{path}')
-        iolanta.add(path)
+        iolanta: Iolanta = Iolanta(
+            language=Literal(language),
+            logger=logger,
+            project_root=path,
+        )
 
     try:
         renderable, stack = iolanta.render(

{iolanta-1.2.7 → 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,
                         )
@@ -464,7 +466,7 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
         if existing_triple is not None:
             return Skipped()
         else:
-            self.logger.warning(f'Existing triples not found for {source_uri}')
+            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.
@@ -565,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:

{iolanta-1.2.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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),
         )
 

{iolanta-1.2.7 → iolanta-1.2.8}/iolanta/iolanta.py

@@ -2,6 +2,7 @@ import functools
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import (  # noqa: WPS235
+    Annotated,
     Any,
     Dict,
     Iterable,
@@ -30,7 +31,6 @@ 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 import Loader
 from iolanta.loaders.base import SourceType
 from iolanta.loaders.local_directory import merge_contexts
 from iolanta.models import (
@@ -45,7 +45,6 @@ from iolanta.parse_quads import parse_quads
 from iolanta.parsers.yaml import YAML
 from iolanta.plugin import Plugin
 from iolanta.resolvers.python_import import PythonImportResolver
-from iolanta.shortcuts import construct_root_loader
 from iolanta.stack import Stack
 from ldflex import LDFlex
 
@@ -72,19 +71,24 @@ class LoggerProtocol(Protocol):
         """Log a WARNING message."""
 
 
+def _create_default_graph():
+    return ConjunctiveGraph(identifier=namespaces.LOCAL.term('_inference'))
+
+
 @dataclass
 class Iolanta:   # noqa: WPS214
     """Iolanta is a Semantic web browser."""
 
     language: Literal = Literal('en')
 
-    retrieval_directory: Optional[Path] = None
-    graph: ConjunctiveGraph = field(
-        default_factory=functools.partial(
-            ConjunctiveGraph,
-            identifier=namespaces.LOCAL.term('_inference'),
+    project_root: Annotated[
+        Path | None,
+        (
+            'File or directory the contents of which '
+            'Iolanta will automatically load into the graph.'
         ),
-    )
+    ] = None
+    graph: ConjunctiveGraph = field(default_factory=_create_default_graph)
     force_plugins: List[Type[Plugin]] = field(default_factory=list)
 
     facet_resolver: Mapping[URIRef, Type[Facet]] = field(
@@ -121,7 +125,7 @@ class Iolanta:   # noqa: WPS214
             for plugin_class in self.plugin_classes
         ]
 
-    @functools.cached_property
+    @property
     def ldflex(self) -> LDFlex:
         """
         Create ldflex instance.
@@ -147,7 +151,12 @@ class Iolanta:   # noqa: WPS214
             )
         }
 
-    def add(  # noqa: C901, WPS231, WPS210
+    def reset(self):
+        """Reset Iolanta graph."""
+        self.graph = _create_default_graph()   # noqa: WPS601
+        self.__post_init__()
+
+    def add(  # noqa: C901, WPS231, WPS210, WPS213
         self,
         source: Path,
         context: Optional[LDContext] = None,
@@ -167,20 +176,20 @@ class Iolanta:   # noqa: WPS214
             try:  # noqa: WPS225
                 ld_rdf = yaml_ld.to_rdf(source_file)
             except ConnectionError as name_resolution_error:
-                self.logger.info(
+                self.logger.warning(
                     '%s | name resolution error: %s',
                     source_file,
                     str(name_resolution_error),
                 )
                 continue
             except ParserNotFound as parser_not_found:
-                self.logger.info(f'{source} | {parser_not_found}')
+                self.logger.error(f'{source} | {parser_not_found}')
                 continue
             except YAMLLDError as yaml_ld_error:
-                self.logger.info(f'{source} | {yaml_ld_error}')
+                self.logger.error(f'{source} | {yaml_ld_error}')
                 continue
             except ValueError as value_error:
-                self.logger.info(f'{source} | {value_error}')
+                self.logger.error(f'{source} | {value_error}')
                 continue
 
             self.logger.info(f'{source_file} is loaded.')
@@ -304,6 +313,8 @@ class Iolanta:   # noqa: WPS214
         """
         self.bind_namespaces()
         self.add_files_from_plugins()
+        if self.project_root:
+            self.add(self.project_root)
 
     def render(
         self,

{iolanta-1.2.7 → iolanta-1.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "iolanta"
-version = "1.2.7"
+version = "1.2.8"
 description = "Semantic Web browser"
 authors = ["Anatoly Scherbakov <altaisoft@gmail.com>"]
 license = "MIT"
@@ -35,6 +35,7 @@ oxrdflib = ">=0.4.0"
 loguru = ">=0.7.3"
 nanopub = ">=2.0.1"
 diskcache = ">=5.6.3"
+watchfiles = "^1.0.4"
 
 [tool.poetry.scripts]
 iolanta = "iolanta.cli:app"