cmem-cmemc 24.3.0rc2__tar.gz → 24.3.3__tar.gz

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: cmem-cmemc
-Version: 24.3.0rc2
+Version: 24.3.3
 Summary: Command line client for eccenca Corporate Memory
-Home-page: https://eccenca.com/go/cmemc
 License: Apache-2.0
 Author: eccenca
 Author-email: cmempy-developer@eccenca.com
@@ -21,6 +20,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Testing
@@ -36,7 +36,6 @@ Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: junit-xml (>=1.9,<2.0)
 Requires-Dist: natsort (>=8.4.0,<9.0.0)
 Requires-Dist: packaging (>=24.2,<25.0)
-Requires-Dist: pip (>=24.3.1,<25.0.0)
 Requires-Dist: prometheus-client (>=0.21.0,<0.22.0)
 Requires-Dist: pygments (>=2.18.0,<3.0.0)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
@@ -48,6 +47,7 @@ Requires-Dist: smart-open (>=7.0.5,<8.0.0)
 Requires-Dist: timeago (>=1.0.16,<2.0.0)
 Requires-Dist: treelib (>=1.7.0,<2.0.0)
 Requires-Dist: urllib3 (>=2.2.3,<3.0.0)
+Project-URL: Homepage, https://eccenca.com/go/cmemc
 Description-Content-Type: text/markdown
 
 # cmemc

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/__init__.py

@@ -95,7 +95,7 @@ def cli(
 
                         https://eccenca.com/go/cmemc
 
-    cmemc is © 2024 eccenca GmbH, licensed under the Apache License 2.0.
+    cmemc is © 2025 eccenca GmbH, licensed under the Apache License 2.0.
     """
     ctx.obj = CONTEXT
     # hidden feature: 'CMEMC_MANUAL=true cmemc -q config list' will output

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/commands/graph.py

@@ -6,14 +6,12 @@ import io
 import json
 import mimetypes
 import os
-from json import JSONDecodeError
 from xml.dom import minidom  # nosec
 from xml.etree.ElementTree import (  # nosec
     Element,
     SubElement,
     tostring,
 )
-from xml.sax import SAXParseException
 
 import click
 from click import Argument
@@ -23,9 +21,6 @@ from cmem.cmempy.dp.proxy import graph as graph_api
 from cmem.cmempy.dp.proxy.graph import get_graph_import_tree, get_graph_imports
 from cmem.cmempy.dp.proxy.sparql import get as sparql_api
 from jinja2 import Template
-from rdflib import Graph
-from rdflib.exceptions import ParserError
-from rdflib.plugins.parsers.notation3 import BadSyntax
 from six.moves.urllib.parse import quote
 from treelib import Tree
 
@@ -35,7 +30,7 @@ from cmem_cmemc.command_group import CmemcGroup
 from cmem_cmemc.commands.validation import validation_group
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.parameter_types.path import ClickSmartPath
-from cmem_cmemc.smart_path import SmartPath as Path
+from cmem_cmemc.smart_path import SmartPath
 from cmem_cmemc.utils import (
     convert_uri_to_filename,
     get_graphs,
@@ -75,7 +70,7 @@ def _get_graph_to_file(  # noqa: PLR0913
 
     numbers is a tuple of current and count (for output only).
     """
-    if Path(file_path).exists():
+    if SmartPath(file_path).exists():
         if overwrite is True:
             app.echo_warning(f"Output file {file_path} does exist: will overwrite it.")
         else:
@@ -309,7 +304,7 @@ def _create_xml_catalog_file(app: ApplicationContext, names: dict, output_dir: s
         output_dir: path where to create the XML file
 
     """
-    file_name = Path(output_dir) / "catalog-v001.xml"
+    file_name = SmartPath(output_dir) / "catalog-v001.xml"
     catalog = Element("catalog")
     catalog.set("prefer", "public")
     catalog.set("xmlns", "urn:oasis:names:tc:entity:xmlns:xml:catalog")
@@ -601,16 +596,16 @@ def export_command(  # noqa: PLR0913
         )
         _graph_file_names = _get_export_names(app, iris, template, f"{extension}.graph")
         # create directory
-        if not Path(output_dir).exists():
+        if not SmartPath(output_dir).exists():
             app.echo_warning("Output directory does not exist: " + "will create it.")
-            Path(output_dir).mkdir(parents=True)
+            SmartPath(output_dir).mkdir(parents=True)
         # one .graph, one .ttl file per named graph
         for current, iri in enumerate(iris, start=1):
             # join with given output directory and normalize full path
-            triple_file_name = os.path.normpath(Path(output_dir) / _names[iri])
-            graph_file_name = os.path.normpath(Path(output_dir) / _graph_file_names[iri])
+            triple_file_name = os.path.normpath(SmartPath(output_dir) / _names[iri])
+            graph_file_name = os.path.normpath(SmartPath(output_dir) / _graph_file_names[iri])
             # output directory is created lazy
-            Path(triple_file_name).parent.mkdir(parents=True, exist_ok=True)
+            SmartPath(triple_file_name).parent.mkdir(parents=True, exist_ok=True)
             # create and write the .ttl.graph metadata file
             graph_file = click.open_file(graph_file_name, "w")
             graph_file.write(iri + "\n")
@@ -673,50 +668,42 @@ def validate_input_path(input_path: str) -> None:
 def _get_graph_supported_formats() -> dict[str, str]:
     return {
         "application/rdf+xml": "xml",
-        "application/ld+json": "json-ld",
+        "application/ld+json": "jsonld",
         "text/turtle": "turtle",
         "application/n-triples": "nt",
     }
 
 
-def _guess_rdf_mime_type(content: str) -> str:
-    formats = _get_graph_supported_formats()
-    for mime_type, rdf_format in formats.items():
-        try:
-            g = Graph()
-            g.parse(data=content, format=rdf_format)
-        except (SAXParseException, JSONDecodeError, BadSyntax, ParserError):
-            continue
-        else:
-            return mime_type
-    raise ValueError("Unknown format")
-
+def _get_buffer_and_content_type(
+    triple_file: str, app: ApplicationContext
+) -> tuple[io.BytesIO, str]:
+    """Get the io.BytesIO buffer and the content type of triple_file"""
+    smart_file = SmartPath(triple_file)
+    content_type, encoding = mimetypes.guess_type(triple_file)
+    if content_type is None:
+        content_type = "text/turtle"
+        for supported_type, supported_suffix in _get_graph_supported_formats().items():
+            if smart_file.name.endswith(f".{supported_suffix}") or smart_file.name.endswith(
+                f".{supported_suffix}.gz"
+            ):
+                content_type = supported_type
+    elif content_type not in _get_graph_supported_formats():
+        app.echo_warning(
+            f"Content type {content_type} of {triple_file} is "
+            f"not one of {', '.join(_get_graph_supported_formats().keys())} "
+            "(but will try to import anyways)."
+        )
 
-def _parse_triple_file(triple_file: str) -> tuple[io.BytesIO, str]:
-    """Parse the content of the triple file."""
-    buffer = io.BytesIO()
     transport_params = {}
-
-    if Path(str(triple_file)).schema in ["http", "https"]:
+    if smart_file.schema in ["http", "https"]:
         transport_params["headers"] = {
             "Accept": "text/turtle; q=1.0, application/x-turtle; q=0.9, text/n3;"
             " q=0.8, application/rdf+xml; q=0.5, text/plain; q=0.1"
         }
 
+    buffer = io.BytesIO()
     with ClickSmartPath.open(triple_file, transport_params=transport_params) as file_obj:
         buffer.write(file_obj.read())
-
-    buffer.seek(0)
-    is_gzip = buffer.read(2) == b"\x1f\x8b"
-    buffer.seek(0)
-
-    if is_gzip:
-        with gzip.GzipFile(fileobj=buffer, mode="rb") as gzip_file:
-            graph_content = gzip_file.read().decode("utf-8")
-    else:
-        graph_content = buffer.read().decode("utf-8")
-
-    content_type = _guess_rdf_mime_type(graph_content)
     buffer.seek(0)
     return buffer, content_type
 
@@ -748,7 +735,7 @@ def import_command(
     input_path: str,
     replace: bool,
     skip_existing: bool,
-    iri: tuple[str, ...],
+    iri: str,
 ) -> None:
     """Import graph(s) to the store.
 
@@ -767,14 +754,14 @@ def import_command(
 
     Note: Directories are scanned on the first level only (not recursively).
     """
-    # is an array of tuples like this [('path/to/triple.file', 'graph IRI')]
     if replace and skip_existing:
         raise ValueError(
             "The options --replace and --skip-existing are mutually "
             "exclusive, so please remove one of them."
         )
-    graphs: list
-    if Path(input_path).is_dir():
+    # is an array of tuples like this [('path/to/triple.file', 'graph IRI')]
+    graphs: list[tuple[str, str]]
+    if SmartPath(input_path).is_dir():
         validate_input_path(input_path)
         if iri is None:
             # in case a directory is the source (and no IRI is given),
@@ -785,10 +772,12 @@ def import_command(
             graphs = []
             for _ in _get_graph_supported_formats():
                 extension = mimetypes.guess_extension(_)
-                graphs += [(file, iri) for file in Path(input_path).glob(f"*{extension}")]
-                graphs += [(file, iri) for file in Path(input_path).glob(f"*{extension}.gz")]
+                graphs += [(str(file), iri) for file in SmartPath(input_path).glob(f"*{extension}")]
+                graphs += [
+                    (str(file), iri) for file in SmartPath(input_path).glob(f"*{extension}.gz")
+                ]
 
-    elif Path(input_path).is_file():
+    elif SmartPath(input_path).is_file():
         if iri is None:
             raise ValueError(
                 "Either specify an input file AND a graph IRI or an input directory ONLY."
@@ -812,7 +801,7 @@ def import_command(
             continue
         # prevents re-replacing of graphs in a single run
         _replace = False if graph_iri in processed_graphs else replace
-        _buffer, content_type = _parse_triple_file(triple_file)
+        _buffer, content_type = _get_buffer_and_content_type(triple_file, app)
         response = graph_api.post_streamed(
             graph_iri, _buffer, replace=_replace, content_type=content_type
         )

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/commands/migration.py

@@ -21,6 +21,7 @@ from cmem_cmemc.migrations.shapes_widget_integrations_243 import (
     TableReportPropertyShapesToWidgetIntegrations,
     WorkflowTriggerPropertyShapesToWidgetIntegrations,
 )
+from cmem_cmemc.migrations.sparql_query_texts_242 import SparqlDatatypesToXsdString
 from cmem_cmemc.migrations.workspace_configurations import MigrateWorkspaceConfiguration
 from cmem_cmemc.object_list import (
     DirectListPropertyFilter,
@@ -56,6 +57,7 @@ def get_migrations(ctx: click.Context) -> list[dict]:  # noqa: ARG001
             ChartsOnPropertyShapesToWidgetIntegrations(),
             WorkflowTriggerPropertyShapesToWidgetIntegrations(),
             TableReportPropertyShapesToWidgetIntegrations(),
+            SparqlDatatypesToXsdString(),
         ]
     ]
     data.sort(key=lambda x: x["first_version"])

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/context.py

@@ -27,9 +27,9 @@ from urllib3.exceptions import InsecureRequestWarning
 from cmem_cmemc.exceptions import InvalidConfigurationError
 from cmem_cmemc.string_processor import StringProcessor, process_row
 
-DI_TARGET_VERSION = "v24.2.0"
+DI_TARGET_VERSION = "v24.3.0"
 
-EXPLORE_TARGET_VERSION = "v24.2.0"
+EXPLORE_TARGET_VERSION = "v24.3.0"
 
 KNOWN_CONFIG_KEYS = {
     "CMEM_BASE_URI": cmempy_config.get_cmem_base_uri,

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/migrations/abc.py

@@ -26,6 +26,7 @@ class MigrationRecipe(ABC):
         "sh": "http://www.w3.org/ns/shacl#",
         "auth": "https://vocab.eccenca.com/auth/",
         "shui": "https://vocab.eccenca.com/shui/",
+        "xsd": "http://www.w3.org/2001/XMLSchema#",
     }
 
     @abstractmethod

cmem_cmemc-24.3.3/cmem_cmemc/migrations/sparql_query_texts_242.py

@@ -0,0 +1,53 @@
+"""Migration: Chart and Workflow Property Shapes to Widget Integration"""
+
+from typing import ClassVar
+
+from cmem_cmemc.migrations.abc import MigrationRecipe, components
+
+
+class SparqlDatatypesToXsdString(MigrationRecipe):
+    """24.2 Migrate shui:sparqlQuery|sparqlUpdate datatype literals to xsd:string literals"""
+
+    id = "sparql-query-datatypes-24.2"
+    description = "Migrate shui SPARQL datatype literals to xsd:string literals"
+    component: components = "explore"
+    first_version = "24.2"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT DISTINCT ?query
+WHERE {
+  GRAPH ?shapeOrQueryGraph {
+    ?query shui:queryText ?text .
+    FILTER ( datatype(?text) IN (shui:sparqlQuery, shui:sparqlUpdate) )
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+DELETE {
+  GRAPH ?shapeOrQueryGraph {
+    ?query shui:queryText ?oldLiteral .
+  }
+}
+INSERT {
+  GRAPH ?shapeOrQueryGraph {
+    ?query shui:queryText ?newLiteral .
+  }
+}
+# SELECT DISTINCT ?query
+WHERE {
+  GRAPH ?shapeOrQueryGraph {
+    ?query shui:queryText ?oldLiteral .
+    FILTER ( datatype(?oldLiteral) IN (shui:sparqlQuery, shui:sparqlUpdate) )
+    BIND (STRDT(STR(?oldLiteral), xsd:string) AS ?newLiteral)
+  }
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        queries_with_old_literals = self._select(self.check_query)
+        return len(queries_with_old_literals) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/cmem_cmemc/utils.py

@@ -21,7 +21,7 @@ from cmem_cmemc.constants import NAMESPACES
 
 if TYPE_CHECKING:
     from cmem_cmemc.context import ApplicationContext
-from cmem_cmemc.smart_path import SmartPath as Path
+from cmem_cmemc.smart_path import SmartPath
 
 
 def get_version() -> str:
@@ -90,13 +90,13 @@ def read_rdf_graph_files(directory_path: str) -> list[tuple[str, str]]:
         for _file in files:
             if _file.endswith(".graph"):
                 continue
-            full_file_path = Path(root) / _file
+            full_file_path = SmartPath(root) / _file
             # Handle compressed files (like .gz)
             if _file.endswith(".gz"):
                 graph_file_name = _file.replace(".gz", ".graph")
             else:
                 graph_file_name = f"{_file}.graph"
-            full_graph_file_name_path = Path(root) / graph_file_name
+            full_graph_file_name_path = SmartPath(root) / graph_file_name
             if full_graph_file_name_path.exists():
                 graph_name = read_file_to_string(str(full_graph_file_name_path)).strip()
                 rdf_graphs.append((str(full_file_path.resolve()), graph_name))
@@ -105,7 +105,7 @@ def read_rdf_graph_files(directory_path: str) -> list[tuple[str, str]]:
 
 def read_file_to_string(file_path: str) -> str:
     """Read file to string."""
-    with Path(file_path).open(mode="rb") as _file:
+    with SmartPath(file_path).open(mode="rb") as _file:
         return str(_file.read().decode("utf-8"))
 
 

{cmem_cmemc-24.3.0rc2 → cmem_cmemc-24.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cmem-cmemc"
-version = "24.3.0rc2"
+version = "24.3.3"
 description = "Command line client for eccenca Corporate Memory"
 license = "Apache-2.0"
 classifiers = [
@@ -39,7 +39,6 @@ configparser = "^6.0.1"
 jinja2 = "^3.1.4"
 junit-xml = "^1.9"
 natsort = "^8.4.0"
-pip = "^24.3.1"
 prometheus-client = "^0.21.0"
 pygments = "^2.18.0"
 pyjwt = "^2.9.0"
@@ -59,6 +58,7 @@ cmemc = 'cmem_cmemc:main'
 [tool.poetry.group.dev.dependencies]
 genbadge = {extras = ["coverage"], version = "^1.1.1"}
 mypy = "^1.13.0"
+pip = "^25"
 pytest = "^8.3.3"
 pytest-cov = "^6.0.0"
 pytest-dotenv = "^0.5.2"