iolanta 2.1.12__py3-none-any.whl → 2.1.14__py3-none-any.whl

iolanta/facets/query/select_result_csv.py

@@ -0,0 +1,36 @@
+import csv
+import io
+from pathlib import Path
+
+from rdflib import Literal
+
+from iolanta.facets.cli.base import Renderable, RichFacet
+from iolanta.facets.errors import NotALiteral
+
+META = Path(__file__).parent / 'data' / 'query_result.yamlld'
+
+
+class SelectResultCsvFacet(RichFacet):
+    """Render SELECT query results as CSV."""
+
+    META = META
+
+    def show(self) -> Renderable:
+        """Render SelectResult as CSV."""
+        if not isinstance(self.this, Literal):
+            raise NotALiteral(node=self.this)
+
+        query_result = self.this.value
+
+        if not query_result:
+            return ""
+
+        output = io.StringIO()
+        first_row = query_result[0]
+        fieldnames = first_row.keys()
+
+        writer = csv.DictWriter(output, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(query_result)
+
+        return output.getvalue()

iolanta/facets/query/select_result_json.py

@@ -0,0 +1,24 @@
+import json
+from pathlib import Path
+
+from rdflib import Literal
+
+from iolanta.facets.cli.base import Renderable, RichFacet
+from iolanta.facets.errors import NotALiteral
+
+META = Path(__file__).parent / 'data' / 'query_result.yamlld'
+
+
+class SelectResultJsonFacet(RichFacet):
+    """Render SELECT query results as JSON."""
+
+    META = META
+
+    def show(self) -> Renderable:
+        """Render SelectResult as JSON."""
+        if not isinstance(self.this, Literal):
+            raise NotALiteral(node=self.this)
+
+        query_result = self.this.value
+
+        return json.dumps(query_result, indent=2, default=str)

iolanta/facets/query/select_result_table.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+from more_itertools import consume, first
+from rdflib import Literal
+from rich.table import Table
+
+from iolanta.cli.formatters.pretty import pretty_print_value
+from iolanta.facets.cli.base import Renderable, RichFacet
+from iolanta.facets.errors import NotALiteral
+
+META = Path(__file__).parent / 'data' / 'query_result.yamlld'
+
+
+class SelectResultTableFacet(RichFacet):
+    """Render SELECT query results as table."""
+
+    META = META
+
+    def show(self) -> Renderable:
+        """Render SelectResult as table."""
+        if not isinstance(self.this, Literal):
+            raise NotALiteral(node=self.this)
+
+        query_result = self.this.value
+
+        if not query_result:
+            table = Table(show_header=True, header_style="bold magenta")
+            return table
+
+        columns = first(query_result).keys()
+
+        table = Table(
+            *columns,
+            show_header=True,
+            header_style="bold magenta",
+        )
+
+        consume(
+            table.add_row(
+                *[
+                    str(pretty_print_value(value))
+                    for value in row.values()
+                ],
+            )
+            for row in query_result
+        )
+
+        return table

iolanta/facets/textual_browser/page_switcher.py

@@ -45,22 +45,22 @@ 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'),
+        ("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')
+        super().__init__(id="page_switcher", initial="home")
         self.stop_file_watcher_event = threading.Event()
 
     def action_console(self):
         """Open dev console."""
         console_switcher = self.app.query_one(ConsoleSwitcher)
-        console_switcher.current = 'console'
+        console_switcher.current = "console"
         console_switcher.query_one(DevConsole).focus()
 
     @functools.cached_property
@@ -70,7 +70,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
 
     def compose(self):
         """Home is the first page to open."""
-        yield Home(id='home')
+        yield Home(id="home")
 
     def on_mount(self):
         """Navigate to the initial page."""
@@ -86,13 +86,13 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         self.stop_file_watcher_event.set()
 
     def _watch_files(self):
-        for _ in watchfiles.watch(   # noqa: WPS352
+        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
+    def render_iri(  # noqa: WPS210
         self,
         this: NotLiteralNode,
         facet_iri: URIRef | None,
@@ -102,7 +102,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         self.this = this
         iolanta: Iolanta = self.iolanta
 
-        as_datatype = URIRef('https://iolanta.tech/cli/textual')
+        as_datatype = URIRef("https://iolanta.tech/cli/textual")
         choices = FacetFinder(
             iolanta=self.iolanta,
             node=this,
@@ -117,12 +117,10 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
             )
 
         if facet_iri is None:
-            facet_iri = choices[0]['facet']
+            facet_iri = choices[0]["facet"]
 
         other_facets = [
-            choice['facet']
-            for choice in choices
-            if choice['facet'] != facet_iri
+            choice["facet"] for choice in choices if choice["facet"] != facet_iri
         ]
         flip_options = [
             FlipOption(
@@ -141,7 +139,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         facet = facet_class(
             this=self.this,
             iolanta=iolanta,
-            as_datatype=URIRef('https://iolanta.tech/cli/textual'),
+            as_datatype=URIRef("https://iolanta.tech/cli/textual"),
         )
 
         try:
@@ -162,7 +160,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
             is_reload=is_reload,
         )
 
-    def on_worker_state_changed(   # noqa: WPS210
+    def on_worker_state_changed(  # noqa: WPS210
         self,
         event: Worker.StateChanged,
     ):
@@ -173,7 +171,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
 
                 if render_result.is_reload:
                     # We are reloading the current page.
-                    current_page = self.query_one(f'#{self.current}', Page)
+                    current_page = self.query_one(f"#{self.current}", Page)
                     current_page.remove_children()
                     current_page.mount(render_result.renderable)
 
@@ -184,7 +182,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
                 else:
                     # We are navigating to a new page.
                     page_uid = uuid.uuid4().hex
-                    page_id = f'page_{page_uid}'
+                    page_id = f"page_{page_uid}"
                     page = Page(
                         render_result.renderable,
                         iri=render_result.iri,
@@ -210,7 +208,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
     def is_loading(self) -> bool:
         """Determine if the app is presently loading something."""
         for worker in self.workers:
-            if worker.name == 'render_iri':
+            if worker.name == "render_iri":
                 return True
 
         return False
@@ -219,31 +217,31 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         """Reset Iolanta graph and re-render current view."""
         if self.history.current is None:
             return
-        
+
         self.iolanta.reset()
 
         self.run_worker(
             functools.partial(
                 self.render_iri,
                 this=self.history.current.url,
-                facet_iri=self.history.current.facet_iri,
+                facet_iri=None,  # Re-resolve facet after reload so parse errors use TextualNoFacetFound
                 is_reload=True,
             ),
             thread=True,
             exclusive=True,
-            name='render_iri',
+            name="render_iri",
         )
         self.refresh_bindings()
 
     def action_abort(self):
         """Abort loading."""
         self.notify(
-            'Aborted.',
-            severity='warning',
+            "Aborted.",
+            severity="warning",
         )
 
         for worker in self.workers:
-            if worker.name == 'render_iri':
+            if worker.name == "render_iri":
                 worker.cancel()
                 break
 
@@ -252,18 +250,18 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
     def check_action(
         self,
         action: str,
-        parameters: tuple[object, ...],   # noqa: WPS110
+        parameters: tuple[object, ...],  # noqa: WPS110
     ) -> bool | None:
         """Check if action is available."""
         is_loading = self.is_loading
         match action:
-            case 'reload':
+            case "reload":
                 return not is_loading
-            case 'abort':
+            case "abort":
                 return is_loading
-            case 'back':
+            case "back":
                 return bool(self.history.past)
-            case 'forward':
+            case "forward":
                 return bool(self.history.future)
 
         return True
@@ -280,12 +278,12 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
         # Direct calls (like line 77) pass Node objects directly.
         if isinstance(this, str):
             # Check if string represents a blank node (starts with "_:")
-            if this.startswith('_:'):
+            if this.startswith("_:"):
                 # Create a BNode with the full string (including the "_:")
                 this = BNode(this)
             else:
                 this = URIRef(this)
-        
+
         self.run_worker(
             functools.partial(
                 self.render_iri,
@@ -295,7 +293,7 @@ class PageSwitcher(IolantaWidgetMixin, ContentSwitcher):  # noqa: WPS214
             ),
             thread=True,
             exclusive=True,
-            name='render_iri',
+            name="render_iri",
         )
         self.refresh_bindings()
 
@@ -319,8 +317,8 @@ class ConsoleSwitcher(ContentSwitcher):
     def __init__(self):
         """Specify initial params."""
         super().__init__(
-            id='console_switcher',
-            initial='page_switcher',
+            id="console_switcher",
+            initial="page_switcher",
         )
 
     def compose(self):
@@ -333,17 +331,17 @@ class DevConsole(RichLog):
     """Development console."""
 
     BINDINGS = [
-        ('f12,escape', 'close', 'Close Console'),
+        ("f12,escape", "close", "Close Console"),
     ]
 
     def __init__(self):
         """Set default props for console."""
-        super().__init__(highlight=False, markup=False, id='console')
+        super().__init__(highlight=False, markup=False, id="console")
 
     def action_close(self):
         """Close the dev console."""
         console_switcher = self.app.query_one(ConsoleSwitcher)
-        console_switcher.current = 'page_switcher'
+        console_switcher.current = "page_switcher"
 
         page_switcher = console_switcher.query_one(PageSwitcher)
         page_switcher.visible_content.focus()

iolanta/facets/textual_class/sparql/instances.sparql

@@ -1,8 +1,6 @@
-# Remember we are HTTPS-izing all URIs in Iolanta graph
-PREFIX rdf: <https://www.w3.org/1999/02/22-rdf-syntax-ns#>
-
 SELECT ?instance WHERE {
-    ?instance rdf:type $this .
+    ?instance a $this .
 
+    # Overcome what RDFLib does
     FILTER(!isLiteral(?instance)) .
 } ORDER BY ?instance

iolanta/facets/textual_no_facet_found.py

@@ -24,6 +24,14 @@ TEXT = """
 issues: https://github.com/iolanta.tech/iolanta/issues
 """
 
+PARSE_ERROR_TEMPLATE = """
+**Parse error**
+
+```
+{message}
+```
+"""
+
 CONTENT_TEMPLATE = """
 **File content**
 
@@ -46,7 +54,7 @@ class TextualNoFacetFound(Facet):
     def raw_content(self):
         """Content of the file, if applicable."""
         url = URL(self.this)
-        if url.scheme != 'file':
+        if url.scheme != "file":
             return None
 
         path = Path(url.path)
@@ -59,32 +67,50 @@ class TextualNoFacetFound(Facet):
         if path.is_dir():
             return None
 
+        parse_error_msg = self._parse_error_message()
         file_content = path.read_text()
-        return CONTENT_TEMPLATE.format(
+        content = CONTENT_TEMPLATE.format(
             content=file_content,
             type={
-                '.yamlld': 'yaml',
-                '.jsonld': 'json',
-            }.get(path.suffix, ''),
+                ".yamlld": "yaml",
+                ".jsonld": "json",
+                ".ttl": "turtle",
+            }.get(path.suffix, ""),
         )
+        if parse_error_msg:
+            content = PARSE_ERROR_TEMPLATE.format(message=parse_error_msg) + content
+        return content
+
+    def _parse_error_message(self) -> str | None:
+        """Return parse error message for this node if it failed to load."""
+        rows = self.query(
+            """
+            SELECT ?msg WHERE {
+                GRAPH <iolanta://_meta> { $this iolanta:parse-error ?msg }
+            }
+            """,
+            this=self.this,
+        )
+        if row := funcy.first(rows):
+            return str(row["msg"])
+        return None
 
     @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 }',
+            "SELECT ?subgraph WHERE { $this iolanta:has-sub-graph ?subgraph }",
             this=self.this,
         )
-        subgraphs = funcy.lpluck('subgraph', rows)
+        subgraphs = funcy.lpluck("subgraph", rows)
         if subgraphs:
             return SUBGRAPHS_TEMPLATE.format(
-                formatted_subgraphs='\n'.join([
-                    f'- {subgraph}'
-                    for subgraph in subgraphs
-                ]),
+                formatted_subgraphs="\n".join(
+                    [f"- {subgraph}" for subgraph in subgraphs]
+                ),
             )
 
-        return ''
+        return ""
 
     def show(self):
         """Compose the page."""
@@ -93,8 +119,8 @@ class TextualNoFacetFound(Facet):
             Description(
                 Markdown(
                     TEXT.format(
-                        content=self.raw_content or '',
-                        subgraphs=self.subgraphs_description or '',
+                        content=self.raw_content or "",
+                        subgraphs=self.subgraphs_description or "",
                         reference_type=type(self.this).__name__,
                     ),
                 ),

iolanta/iolanta.py

@@ -17,6 +17,7 @@ import yaml_ld
 from pyparsing import ParseException
 from rdflib import ConjunctiveGraph, Graph, Literal, URIRef
 from rdflib.namespace import NamespaceManager
+from rdflib.plugins.parsers.notation3 import BadSyntax
 from rdflib.plugins.sparql.processor import SPARQLResult
 from rdflib.term import Node
 from yaml_ld.document_loaders.content_types import ParserNotFound
@@ -256,10 +257,20 @@ class Iolanta:  # noqa: WPS214, WPS338
             except ParserNotFound as parser_not_found:
                 self.logger.error(f"{source} | {parser_not_found}")
                 continue
-            except YAMLLDError as yaml_ld_error:
-                # .add() only processes local files, so errors should be raised
-                self.logger.error(f"{source_file} | {yaml_ld_error}")
-                raise
+            except (YAMLLDError, BadSyntax) as parse_error:
+                self.logger.warning("%s | parse error: %s", source_file, parse_error)
+                file_iri = path_to_iri(source_file)
+                self.graph.addN(
+                    [
+                        (
+                            file_iri,
+                            namespaces.IOLANTA["parse-error"],
+                            Literal(str(parse_error)),
+                            namespaces.META,
+                        ),
+                    ]
+                )
+                continue
             except ValueError as value_error:
                 self.logger.error(f"{source} | {value_error}")
                 continue
@@ -362,7 +373,6 @@ class Iolanta:  # noqa: WPS214, WPS338
     ) -> Any:
         """Find an Iolanta facet for a node and render it."""
         node = normalize_term(node)
-
         if not as_datatype:
             raise ValueError(
                 f"Please provide the datatype to render {node} as.",

iolanta/mcp/cli.py

@@ -1,6 +1,9 @@
+from pathlib import Path
 from typing import Annotated
 
 from fastmcp import FastMCP
+from rdflib import URIRef
+from yarl import URL
 
 from iolanta.cli.main import render_and_return
 
@@ -9,11 +12,21 @@ mcp = FastMCP("Iolanta MCP Server")
 
 @mcp.tool()
 def render_uri(
-    uri: Annotated[str, 'URL, or file system path, to render'],
-    as_format: Annotated[str, 'Format to render as. Examples: `labeled-triple-set`, `mermaid`'],
+    uri: Annotated[str, "URL, or file system path, to render"],
+    as_format: Annotated[
+        str, "Format to render as. Examples: `labeled-triple-set`, `mermaid`"
+    ],
 ) -> str:
     """Render a URI."""
-    return str(render_and_return(uri, as_format))
+    # Parse string URL to URIRef
+    node_url = URL(uri)
+    if node_url.scheme and node_url.scheme != "file":
+        node = URIRef(uri)
+    else:
+        path = Path(node_url.path).absolute()
+        node = URIRef(f"file://{path}")
+
+    return str(render_and_return(node=node, as_datatype=as_format))
 
 
 def app():

iolanta/mermaid/models.py

@@ -12,7 +12,10 @@ from iolanta.models import NotLiteralNode  # noqa: WPS202
 
 
 def escape_label(label: str) -> str:
-    """Escape a label to prevent Mermaid from interpreting URLs as markdown links and handle quotes.
+    """Escape a label and return it wrapped in appropriate quotes.
+
+    Returns the label with URLs stripped, quotes escaped, and wrapped in quotes.
+    Uses single quotes if label contains double quotes to avoid escaping issues.
 
     Escapes quotes in labels that will be wrapped in quotes in Mermaid syntax.
     """
@@ -20,8 +23,15 @@ def escape_label(label: str) -> str:
     safe_label = (
         label.replace("https://", "").replace("http://", "").replace("www.", "")
     )
-    # Escape quotes for use inside quoted strings in Mermaid
-    return safe_label.replace('"', r'\"')
+    # Use single quotes if label contains double quotes to avoid escaping issues
+    use_single = '"' in safe_label
+    quote_char = "'" if use_single else '"'
+    # Escape the quote character that will be used for wrapping
+    if use_single:
+        escaped_label = safe_label.replace("'", r"\'")
+    else:
+        escaped_label = safe_label.replace('"', r"\"")
+    return f"{quote_char}{escaped_label}{quote_char}"
 
 
 class Direction(enum.StrEnum):
@@ -54,14 +64,13 @@ class MermaidURINode(MermaidScalar, frozen=True):
     def maybe_title(self):
         if not self.title:
             return ""
-        # Escape URLs to prevent Mermaid from interpreting them as markdown links
-        safe_title = escape_label(self.title)
-        return f'("{safe_title}")'
+        quoted_title = escape_label(self.title)
+        return f"({quoted_title})"
 
     @property
     def id(self):
         return re.sub(
-            r"[:\/\.#()]", "_", urllib_parse.unquote(str(self.url)).strip("/")
+            r"[:\/\.#()?=&+]", "_", urllib_parse.unquote(str(self.url)).strip("/")
         )
 
 
@@ -85,7 +94,7 @@ class MermaidLiteral(MermaidScalar, frozen=True):
 
 
 class MermaidBlankNode(MermaidScalar):
-    """{self.id}("{self.escaped_title}")"""
+    """{self.id}({self.escaped_title})"""
 
     node: BNode
     title: str
@@ -102,7 +111,7 @@ class MermaidBlankNode(MermaidScalar):
 
 class MermaidEdge(MermaidScalar):
     """
-    {self.source.id} --- {self.id}(["{self.escaped_title}"])--> {self.target.id}
+    {self.source.id} --- {self.id}([{self.escaped_title}])--> {self.target.id}
     click {self.id} "{self.predicate}"
     class {self.id} predicate
     """
@@ -130,7 +139,7 @@ class MermaidEdge(MermaidScalar):
 
 class MermaidSubgraph(Documented, BaseModel, arbitrary_types_allowed=True, frozen=True):
     """
-    subgraph {self.id}["{self.escaped_title}"]
+    subgraph {self.id}[{self.escaped_title}]
       direction {self.direction}
       {self.formatted_body}
     end

iolanta/sparqlspace/processor.py

@@ -557,15 +557,6 @@ class GlobalSPARQLProcessor(Processor):  # noqa: WPS338, WPS214
                 path=not_found.path,
             )
 
-            self.graph.add(
-                (
-                    source_uri,
-                    RDF.type,
-                    IOLANTA["not-found"],
-                    source_uri,
-                )
-            )
-
             self._mark_as_loaded(source_uri)
 
             return Loaded()