cmem-cmemc 24.3.0rc1__tar.gz → 24.3.2__tar.gz

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: cmem-cmemc
-Version: 24.3.0rc1
+Version: 24.3.2
 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.0rc1 → cmem_cmemc-24.3.2}/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.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/commands/graph.py

@@ -4,6 +4,7 @@ import gzip
 import hashlib
 import io
 import json
+import mimetypes
 import os
 from xml.dom import minidom  # nosec
 from xml.etree.ElementTree import (  # nosec
@@ -29,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,
@@ -69,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:
@@ -103,7 +104,7 @@ def _get_graph_to_file(  # noqa: PLR0913
 
 
 def _get_export_names(
-    app: ApplicationContext, iris: list[str], template: str, file_extension: str = "ttl"
+    app: ApplicationContext, iris: list[str], template: str, file_extension: str = ".ttl"
 ) -> dict:
     """Get a dictionary of generated file names based on a template.
 
@@ -131,7 +132,7 @@ def _get_export_names(
             hash=hashlib.sha256(iri.encode("utf-8")).hexdigest(),
             iriname=convert_uri_to_filename(iri),
         )
-        _name_created = f"{Template(template).render(template_data)}.{file_extension}"
+        _name_created = f"{Template(template).render(template_data)}{file_extension}"
         _names[iri] = _name_created
     if len(_names.values()) != len(set(_names.values())):
         raise ValueError(
@@ -303,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")
@@ -542,9 +543,9 @@ def _validate_export_command_input_parameters(
 )
 @click.option(
     "--mime-type",
-    default="application/n-triples",
+    default="text/turtle",
     show_default=True,
-    type=click.Choice(["application/n-triples", "text/turtle"]),
+    type=click.Choice(["application/n-triples", "text/turtle", "application/rdf+xml"]),
     help="Define the requested mime type",
 )
 @click.option(
@@ -589,19 +590,22 @@ def export_command(  # noqa: PLR0913
         app.echo_debug("output is directory")
         # pre-calculate all filenames with the template,
         # in order to output errors on naming clashes as early as possible
-        _names = _get_export_names(app, iris, template, "ttl.gz" if compress else "ttl")
-        _graph_file_names = _get_export_names(app, iris, template, "ttl.graph")
+        extension = mimetypes.guess_extension(mime_type)
+        _names = _get_export_names(
+            app, iris, template, f"{extension}.gz" if compress else f"{extension}"
+        )
+        _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")
@@ -661,6 +665,49 @@ def validate_input_path(input_path: str) -> None:
         )
 
 
+def _get_graph_supported_formats() -> dict[str, str]:
+    return {
+        "application/rdf+xml": "xml",
+        "application/ld+json": "jsonld",
+        "text/turtle": "turtle",
+        "application/n-triples": "nt",
+    }
+
+
+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)."
+        )
+
+    transport_params = {}
+    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)
+    return buffer, content_type
+
+
 @click.command(cls=CmemcCommand, name="import")
 @click.option(
     "--replace",
@@ -688,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.
 
@@ -707,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),
@@ -722,9 +769,15 @@ def import_command(
             graphs = read_rdf_graph_files(input_path)
         else:
             # in case a directory is the source AND IRI is given
-            graphs = [(file, iri) for file in Path(input_path).glob("*.ttl")]
-            graphs += [(file, iri) for file in Path(input_path).glob("*.ttl.gz")]
-    elif Path(input_path).is_file():
+            graphs = []
+            for _ in _get_graph_supported_formats():
+                extension = mimetypes.guess_extension(_)
+                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 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."
@@ -748,17 +801,10 @@ def import_command(
             continue
         # prevents re-replacing of graphs in a single run
         _replace = False if graph_iri in processed_graphs else replace
-        _buffer = io.BytesIO()
-        transport_prams = {}
-        if Path(str(triple_file)).schema in ["http", "https"]:
-            transport_prams["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"
-            }
-        with ClickSmartPath.open(triple_file, transport_params=transport_prams) as _:
-            _buffer.write(_.read())
-        _buffer.seek(0)
-        response = graph_api.post_streamed(graph_iri, _buffer, replace=_replace)
+        _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
+        )
         request_headers = response.request.headers
         request_headers.pop("Authorization")
         app.echo_debug(f"cmemc request headers: {request_headers}")

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/commands/migration.py

@@ -18,6 +18,7 @@ from cmem_cmemc.migrations.bootstrap_data import MigrateBootstrapData
 from cmem_cmemc.migrations.shapes_widget_integrations_243 import (
     ChartsOnNodeShapesToToWidgetIntegrations,
     ChartsOnPropertyShapesToWidgetIntegrations,
+    TableReportPropertyShapesToWidgetIntegrations,
     WorkflowTriggerPropertyShapesToWidgetIntegrations,
 )
 from cmem_cmemc.migrations.workspace_configurations import MigrateWorkspaceConfiguration
@@ -54,6 +55,7 @@ def get_migrations(ctx: click.Context) -> list[dict]:  # noqa: ARG001
             ChartsOnNodeShapesToToWidgetIntegrations(),
             ChartsOnPropertyShapesToWidgetIntegrations(),
             WorkflowTriggerPropertyShapesToWidgetIntegrations(),
+            TableReportPropertyShapesToWidgetIntegrations(),
         ]
     ]
     data.sort(key=lambda x: x["first_version"])

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/commands/python.py

@@ -181,11 +181,11 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool, available: b
             return
 
         table_published = [
-            (_.name, str(_.published)[:10], _.description) for _ in published_packages
+            (_.name, _.version, str(_.published)[:10], _.description) for _ in published_packages
         ]
         app.echo_info_table(
             table_published,
-            headers=["Name", "Published", "Description"],
+            headers=["Name", "Version", "Published", "Description"],
             sort_column=0,
             empty_table_message="No available python packages found.",
         )

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/completion.py

@@ -460,7 +460,7 @@ def installed_package_names(ctx: Context, param: Argument, incomplete: str) -> l
 
 def published_package_names(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """List of plugin packages scraped from pypi.org."""
-    options = [(_.name, f"{_.description}") for _ in get_published_packages()]
+    options = [(_.name, f"{_.version}: {_.description}") for _ in get_published_packages()]
     return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
 
 
@@ -600,13 +600,19 @@ def sparql_files(ctx: Context, param: Argument, incomplete: str) -> list[Complet
 def triple_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of triple files."""
     return (
-        file_list(incomplete=incomplete, suffix=".ttl", description="RDF Turtle file")
-        + file_list(incomplete=incomplete, suffix=".nt", description="RDF NTriples file")
+        file_list(incomplete=incomplete, suffix=".ttl", description="Turtle file")
+        + file_list(incomplete=incomplete, suffix=".nt", description="NTriples file")
+        + file_list(incomplete=incomplete, suffix=".rdf", description="RDF/XML file")
+        + file_list(incomplete=incomplete, suffix=".jsonld", description="JSON-LD file")
+        + file_list(incomplete=incomplete, suffix=".ttl.gz", description="Turtle file (compressed)")
         + file_list(
-            incomplete=incomplete, suffix=".ttl.gz", description="Compressed RDF Turtle file"
+            incomplete=incomplete, suffix=".nt.gz", description="NTriples file (compressed)"
         )
         + file_list(
-            incomplete=incomplete, suffix=".nt.gz", description="Compressed RDF NTriples file"
+            incomplete=incomplete, suffix=".rdf.gz", description="RDF/XML file (compressed)"
+        )
+        + file_list(
+            incomplete=incomplete, suffix=".jsonld.gz", description="JSON-LD file (compressed)"
         )
     )
 

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/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.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/migrations/access_conditions_243.py

@@ -20,6 +20,7 @@ SELECT ?subject
 FROM <urn:elds-backend-access-conditions-graph>
 WHERE {
   ?subject a ?class .
+  FILTER NOT EXISTS { ?subject shui:isSystemResource true }
   FILTER (?class IN (auth:AccessCondition, shui:SparqlQuery) ) .
 }
     """
@@ -31,6 +32,7 @@ WHERE {
     ?s ?p ?o .
     ?s a ?class .
     FILTER (?class IN (auth:AccessCondition, shui:SparqlQuery) ) .
+    FILTER NOT EXISTS { ?s shui:isSystemResource true }
   }
 }
     """
@@ -59,6 +61,7 @@ SELECT DISTINCT ?acl_id
 WHERE {
   GRAPH ?acl_graph {
 	?acl_id a auth:AccessCondition .
+    FILTER NOT EXISTS { ?acl_id shui:isSystemResource true }
     ?acl_id ?property ?old_term .
     FILTER (?old_term in (
         <urn:elds-backend-all-actions>,
@@ -85,6 +88,7 @@ INSERT { GRAPH ?acl_graph { ?s ?p <{{NEW_IRI}}> . } }
 WHERE {
   GRAPH ?acl_graph {
     ?s ?p ?o .
+    FILTER NOT EXISTS { ?s shui:isSystemResource true }
     FILTER (?o = <{{OLD_IRI}}> )
   }
   FILTER (?acl_graph IN (<urn:elds-backend-access-conditions-graph>, <https://ns.eccenca.com/data/ac/>))

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/migrations/bootstrap_data.py

@@ -20,10 +20,8 @@ class MigrateBootstrapData(MigrationRecipe):
     def is_applicable(self) -> bool:
         """Test if the recipe can be applied."""
         status_info = get_complete_status_info()
-        return status_info["shapes"]["version"] not in (
-            status_info["explore"]["version"],
-            "UNKNOWN",
-        )
+        shapes_status = status_info["shapes"]["version"]
+        return bool(shapes_status != status_info["explore"]["version"])
 
     def apply(self) -> None:
         """Apply the recipe to the current version."""

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/migrations/shapes_widget_integrations_243.py

@@ -192,3 +192,83 @@ WHERE {
     def apply(self) -> None:
         """Apply the recipe to the current version."""
         self._update(self.move_query)
+
+
+class TableReportPropertyShapesToWidgetIntegrations(MigrationRecipe):
+    """24.3 Migrate Table Report Property Shapes to Widget Integrations"""
+
+    id = "table-reports-on-pshapes-24.3"
+    description = (
+        "Migrate Table Reports (which use shui:null) on Property Shapes to Widget Integrations"
+    )
+    component: components = "explore"
+    first_version = "24.3"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT ?propertyShape
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:valueQuery ?valueQuery ;
+      sh:path shui:null .
+    FILTER NOT EXISTS { ?propertyShape shui:isSystemResource true }
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+DELETE {
+  GRAPH ?shapeCatalog {
+    ?propertyShape ?p ?o .
+    ?nodeShape sh:property ?propertyShape .
+  }
+}
+INSERT {
+  GRAPH ?shapeCatalog {
+    ?propertyShape a shui:WidgetIntegration ;
+      shui:WidgetIntegration_widget ?newTableReport ;
+      rdfs:label ?name ;
+      rdfs:comment ?description ;
+      sh:order ?order ;
+      shui:WidgetIntegration_group ?group .
+    ?nodeShape shui:WidgetIntegration_integrate ?propertyShape .
+
+    ?newTableReport a shui:TableReport ;
+      rdfs:label ?newTableReportLabel ;
+      shui:TableReport_hideFooter ?hideFooter ;
+      shui:TableReport_hideHeader ?hideHeader ;
+      shui:TableReport_query ?valueQuery .
+  }
+}
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      sh:path shui:null ;
+      shui:valueQuery ?valueQuery .
+    FILTER NOT EXISTS { ?propertyShape shui:isSystemResource true }
+    ?propertyShape ?p ?o .
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape sh:description ?description }
+    OPTIONAL {?propertyShape sh:order ?order }
+    OPTIONAL {?propertyShape sh:group ?group }
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape shui:valueQueryHideHeader ?hideHeaderValue }
+    OPTIONAL {?propertyShape shui:valueQueryHideFooter ?hideFooterValue }
+    OPTIONAL {?nodeShape sh:property ?propertyShape }
+    BIND ( IRI(CONCAT(STR(?propertyShape), "-TableReport")) AS ?newTableReport )
+    BIND ( STRLANG(CONCAT("Table Report: ", ?name), lang(?name)) AS ?newTableReportLabel )
+    BIND ( COALESCE(?hideHeaderValue, false) as ?hideHeader)
+    BIND ( COALESCE(?hideFooterValue, false) as ?hideFooter)
+  }
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        table_report_property_shapes = self._select(self.check_query)
+        return len(table_report_property_shapes) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/string_processor.py

@@ -24,7 +24,13 @@ class TimeAgo(StringProcessor):
 
     def process(self, text: str) -> str:
         """Process a single string content and output the processed string."""
-        stamp = datetime.fromtimestamp(int(text) / 1000, tz=timezone.utc)
+        if text is None:
+            return ""
+        try:
+            text_as_int = int(text)
+        except ValueError:
+            return text
+        stamp = datetime.fromtimestamp(text_as_int / 1000, tz=timezone.utc)
         return str(timeago.format(stamp, datetime.now(tz=timezone.utc)))
 
 

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/cmem_cmemc/utils.py

@@ -12,7 +12,6 @@ from typing import TYPE_CHECKING
 from zipfile import BadZipFile, ZipFile
 
 import requests
-from bs4 import BeautifulSoup
 from cmem.cmempy.dp.proxy.graph import get_graphs_list
 from cmem.cmempy.queries import QueryCatalog
 from cmem.cmempy.workspace.projects.project import get_projects
@@ -22,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:
@@ -91,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))
@@ -106,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"))
 
 
@@ -288,41 +287,30 @@ class PublishedPackage:
     name: str
     description: str
     published: str
+    version: str
 
 
 def get_published_packages() -> list[PublishedPackage]:
     """Get a scraped list of plugin packages scraped from pypi.org."""
-    url_pattern = "https://pypi.org/search/?q=%22cmem-plugin-%22&page={}"
-    packages = []
+    url = "https://download.eccenca.com/cmem-plugin-index/cmem-plugin-index.json"
     package_names = []
-    page = 0
-    while True:
-        page += 1
-        url = url_pattern.format(page)
-        soup = BeautifulSoup(requests.get(url, timeout=5).content, "html.parser")
-        snippets = soup.find_all("a", class_="package-snippet")
-        if len(snippets) == 0:
-            break
-        for _ in snippets:
-            name = _.findChildren(class_="package-snippet__name")[0].getText()
-            if name == "cmem-plugin-base":
-                continue
-            if not name.startswith("cmem-plugin-"):
-                continue
-            try:
-                description = _.findChildren(class_="package-snippet__description")[0].getText()
-            except IndexError:
-                description = "no description"
-            published = _.findChildren(name="time")[0].attrs["datetime"]
-            if name not in package_names:
-                package_names.append(name)
-                packages.append(
-                    PublishedPackage(
-                        name=name,
-                        description=description,
-                        published=published,
-                    )
+    packages = []
+    for _ in requests.get(url, timeout=5).json():
+        name = _["name"]
+        if name == "cmem-plugin-base":
+            continue
+        if not name.startswith("cmem-plugin-"):
+            continue
+        if name not in package_names:
+            package_names.append(name)
+            packages.append(
+                PublishedPackage(
+                    name=name,
+                    description=_["summary"],
+                    published=_["latest_version_time"],
+                    version=_["latest_version"],
                 )
+            )
     return packages
 
 

{cmem_cmemc-24.3.0rc1 → cmem_cmemc-24.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cmem-cmemc"
-version = "24.3.0rc1"
+version = "24.3.2"
 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"