cmem-cmemc 25.3.0__tar.gz → 25.5.0rc1__tar.gz

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: cmem-cmemc
-Version: 25.3.0
+Version: 25.5.0rc1
 Summary: Command line client for eccenca Corporate Memory
 License: Apache-2.0
+License-File: LICENSE
 Author: eccenca
 Author-email: cmempy-developer@eccenca.com
 Requires-Python: >=3.10,<4.0
@@ -21,16 +22,17 @@ 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.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Utilities
 Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
 Requires-Dist: certifi (>=2024.2.2)
-Requires-Dist: click (>=8.1.8,<8.2.0)
+Requires-Dist: click (>=8.3.0,<9.0.0)
 Requires-Dist: click-didyoumean (>=0.3.1,<0.4.0)
 Requires-Dist: click-help-colors (>=0.9.4,<0.10.0)
-Requires-Dist: cmem-cmempy (==25.2.0)
+Requires-Dist: cmem-cmempy (==25.4.0)
 Requires-Dist: configparser (>=7.2.0,<8.0.0)
 Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
 Requires-Dist: junit-xml (>=1.9,<2.0)

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/command_group.py

@@ -66,6 +66,7 @@ class CmemcGroup(HelpColorsGroup, DYMGroup):
                 "migrate": self.color_for_writing_commands,
                 "migrations": self.color_for_command_groups,
                 "imports": self.color_for_command_groups,
+                "insights": self.color_for_command_groups,
             },
         )
         super().__init__(*args, **kwargs)

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/acl.py

@@ -35,6 +35,21 @@ HELP_TEXTS = {
     "read_graph": "Grants read access to a graph.",
     "write_graph": "Grants write access to a graph (includes read access).",
     "action": "Grants usage permissions to an action / functionality.",
+    "read_graph_pattern": (
+        "Grants management of conditions granting read access on graphs matching the defined "
+        "pattern. A pattern consists of a constant string and a wildcard ('*') at the end of "
+        "the pattern or the wildcard alone."
+    ),
+    "write_graph_pattern": (
+        "Grants management of conditions granting write access on graphs matching the defined "
+        "pattern. A pattern consists of a constant string and a wildcard ('*') at the end of "
+        "the pattern or the wildcard alone."
+    ),
+    "action_pattern": (
+        "Grants management of conditions granting action allowance for actions matching the "
+        "defined pattern. A pattern consists of a constant string and a wildcard ('*') at the "
+        "end of the pattern or the wildcard alone."
+    ),
     "query": "Dynamic access condition query (file or the query catalog IRI).",
 }
 
@@ -194,6 +209,27 @@ def inspect_command(app: ApplicationContext, access_condition_id: str, raw: bool
     shell_complete=completion.acl_actions,
     help=HELP_TEXTS["action"],
 )
+@click.option(
+    "--read-graph-pattern",
+    "read_graph_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["read_graph_pattern"],
+)
+@click.option(
+    "--write-graph-pattern",
+    "write_graph_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["write_graph_pattern"],
+)
+@click.option(
+    "--action-pattern",
+    "action_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["action_pattern"],
+)
 @click.option(
     "--query",
     "query",
@@ -231,6 +267,9 @@ def create_command(  # noqa: PLR0913
     read_graphs: tuple[str],
     write_graphs: tuple[str],
     actions: tuple[str],
+    read_graph_patterns: tuple[str],
+    write_graph_patterns: tuple[str],
+    action_patterns: tuple[str],
     query: str,
 ) -> None:
     """Create an access condition.
@@ -254,10 +293,19 @@ def create_command(  # noqa: PLR0913
 
     Example: cmemc admin acl create --group local-users --write-graph https://example.org/
     """
-    if not read_graphs and not write_graphs and not actions and not query:
+    if (
+        not read_graphs
+        and not write_graphs
+        and not actions
+        and not read_graph_patterns
+        and not write_graph_patterns
+        and not action_patterns
+        and not query
+    ):
         raise click.UsageError(
             "Missing access / usage grant. Use at least one of the following options: "
-            "--read-graph, --write-graph, --action or --query."
+            "--read-graph, --write-graph, --action, --read-graph-pattern, "
+            "--write-graph-pattern, --action-pattern or --query."
         )
     query_str = None
     if query:
@@ -286,6 +334,9 @@ def create_command(  # noqa: PLR0913
         read_graphs=list(read_graphs),
         write_graphs=list(write_graphs),
         actions=[convert_qname_to_iri(qname=_, default_ns=NS_ACTION) for _ in actions],
+        read_graph_patterns=list(read_graph_patterns),
+        write_graph_patterns=list(write_graph_patterns),
+        action_patterns=list(action_patterns),
         query=query_str,
     )
     app.echo_success("done")
@@ -351,6 +402,27 @@ def create_command(  # noqa: PLR0913
     shell_complete=completion.acl_actions,
     help=HELP_TEXTS["action"],
 )
+@click.option(
+    "--read-graph-pattern",
+    "read_graph_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["read_graph_pattern"],
+)
+@click.option(
+    "--write-graph-pattern",
+    "write_graph_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["write_graph_pattern"],
+)
+@click.option(
+    "--action-pattern",
+    "action_patterns",
+    type=click.STRING,
+    multiple=True,
+    help=HELP_TEXTS["action_pattern"],
+)
 @click.option(
     "--query",
     "query",
@@ -370,6 +442,9 @@ def update_command(  # noqa: PLR0913
     read_graphs: tuple[str],
     write_graphs: tuple[str],
     actions: tuple[str],
+    read_graph_patterns: tuple[str],
+    write_graph_patterns: tuple[str],
+    action_patterns: tuple[str],
     query: str,
 ) -> None:
     """Update an access condition.
@@ -396,6 +471,9 @@ def update_command(  # noqa: PLR0913
         read_graphs=read_graphs,
         write_graphs=write_graphs,
         actions=[convert_qname_to_iri(qname=_, default_ns=NS_ACTION) for _ in actions],
+        read_graph_patterns=read_graph_patterns,
+        write_graph_patterns=write_graph_patterns,
+        action_patterns=action_patterns,
         query=query_str,
     )
     app.echo_success("done")

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/admin.py

@@ -4,6 +4,7 @@ from datetime import datetime, timezone
 
 import click
 import jwt
+import timeago
 from click import ClickException
 from cmem.cmempy.api import get_access_token, get_token
 from cmem.cmempy.config import get_cmem_base_uri
@@ -185,8 +186,14 @@ def status_command(  # noqa: C901, PLR0912
     help="Decode the access token and outputs the raw JSON. Note that the "
     "access token is only decoded and esp. not validated.",
 )
+@click.option(
+    "--ttl",
+    is_flag=True,
+    help="Output information about the lifetime of the access token. "
+    "In combination with --raw, it outputs the TTL in seconds.",
+)
 @click.pass_obj
-def token_command(app: ApplicationContext, raw: bool, decode: bool) -> None:
+def token_command(app: ApplicationContext, raw: bool, decode: bool, ttl: bool) -> None:
     """Fetch and output an access token.
 
     This command can be used to check for correct authentication as well as
@@ -202,9 +209,30 @@ def token_command(app: ApplicationContext, raw: bool, decode: bool) -> None:
     # - get_access_token returns the token string which is maybe from conf
     # - get_token fetches a new token incl. envelope from keycloak
 
+    token = get_access_token()
+    decoded_token = jwt.decode(token, options={"verify_signature": False})
+    if ttl:
+        app.echo_debug(token)
+        iat_ts = decoded_token["iat"]
+        exp_ts = decoded_token["exp"]
+        ttl_in_seconds = exp_ts - iat_ts
+        if raw:
+            app.echo_info_json(ttl_in_seconds)
+            return
+        exp_time = datetime.fromtimestamp(exp_ts, tz=timezone.utc)
+        now_time = datetime.now(tz=timezone.utc)
+        ttl_delta = timeago.format(exp_time, now_time)
+        if ttl_delta.startswith("in"):
+            app.echo_info(
+                f"The provided access token will expire {ttl_delta} "
+                f"(TTL is {ttl_in_seconds} seconds)."
+            )
+        else:
+            app.echo_info(
+                f"The provided access token expired {ttl_delta} (TTL was {ttl_in_seconds} seconds)."
+            )
+        return
     if decode:
-        token = get_access_token()
-        decoded_token = jwt.decode(token, options={"verify_signature": False})
         if raw:
             app.echo_info_json(decoded_token)
             return
@@ -214,7 +242,6 @@ def token_command(app: ApplicationContext, raw: bool, decode: bool) -> None:
     if raw:
         app.echo_info_json(get_token())
         return
-    token = get_access_token()
     app.echo_info(token)
 
 

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/graph.py

@@ -27,6 +27,7 @@ from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
 from cmem_cmemc.commands.graph_imports import graph_imports_list, imports_group
+from cmem_cmemc.commands.graph_insights import insights_group
 from cmem_cmemc.commands.validation import validation_group
 from cmem_cmemc.constants import UNKNOWN_GRAPH_ERROR
 from cmem_cmemc.context import ApplicationContext
@@ -567,10 +568,11 @@ def _get_graph_supported_formats() -> dict[str, str]:
 
 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"""
+) -> tuple[io.BytesIO, str, None | str]:
+    """Get the io.BytesIO buffer, the content type and the content encoding of a triple_file"""
     smart_file = SmartPath(triple_file)
     content_type, encoding = mimetypes.guess_type(triple_file)
+    content_encoding = "gzip" if smart_file.name.endswith(".gz") else None
     if content_type is None:
         content_type = "text/turtle"
         for supported_type, supported_suffix in _get_graph_supported_formats().items():
@@ -596,7 +598,7 @@ def _get_buffer_and_content_type(
     with ClickSmartPath.open(triple_file, transport_params=transport_params) as file_obj:
         buffer.write(file_obj.read())
     buffer.seek(0)
-    return buffer, content_type
+    return buffer, content_type, content_encoding
 
 
 def _create_graph_imports(ctx: Context, graphs: list[RdfGraphData]) -> None:
@@ -748,9 +750,13 @@ def import_command(  # noqa: PLR0913
             continue
         # prevents re-replacing of graphs in a single run
         _replace = False if graph_iri in processed_graphs else replace
-        _buffer, content_type = _get_buffer_and_content_type(triple_file, app)
+        _buffer, content_type, content_encoding = _get_buffer_and_content_type(triple_file, app)
         response = graph_api.post_streamed(
-            graph_iri, _buffer, replace=_replace, content_type=content_type
+            graph_iri,
+            _buffer,
+            replace=_replace,
+            content_type=content_type,
+            content_encoding=content_encoding,
         )
         request_headers = response.request.headers
         request_headers.pop("Authorization")
@@ -886,3 +892,4 @@ graph.add_command(import_command)
 graph.add_command(open_command)
 graph.add_command(validation_group)
 graph.add_command(imports_group)
+graph.add_command(insights_group)

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/graph_imports.py

@@ -12,7 +12,6 @@ from treelib import Tree
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-from cmem_cmemc.completion import escape_colon
 from cmem_cmemc.constants import UNKNOWN_GRAPH_ERROR
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.object_list import DirectValuePropertyFilter, ObjectList
@@ -299,7 +298,7 @@ def _validate_graphs(from_graph: str | None, to_graph: str | None) -> None:
 def _from_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Provide auto completion items for delete command from-graph argument"""
     imports = get_imports_list(ctx)
-    from_graphs = {escape_colon(_["from_graph"]) for _ in imports}
+    from_graphs = {_["from_graph"] for _ in imports}
     return [
         _
         for _ in completion.graph_uris(ctx=ctx, param=param, incomplete=incomplete)
@@ -311,15 +310,13 @@ def _to_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[Compl
     """Provide auto completion items for create/delete command to-graph argument"""
     from_graph = ctx.params["from_graph"]
     imports = graph_imports_list.apply_filters(ctx=ctx, filter_=[("from-graph", from_graph)])
-    to_graphs = {escape_colon(_["to_graph"]) for _ in imports}
+    to_graphs = {_["to_graph"] for _ in imports}
     command = ctx.command.name
     return [
         _
         for _ in completion.graph_uris(ctx=ctx, param=param, incomplete=incomplete)
         if (command == "delete" and _.value in to_graphs)
-        or (
-            command == "create" and _.value not in to_graphs and _.value != escape_colon(from_graph)
-        )
+        or (command == "create" and _.value not in to_graphs and _.value != from_graph)
     ]
 
 

cmem_cmemc-25.5.0rc1/cmem_cmemc/commands/graph_insights.py

@@ -0,0 +1,314 @@
+"""Graph Insights command group"""
+
+from typing import TYPE_CHECKING
+
+import click
+from click import Argument, Context
+from click.shell_completion import CompletionItem
+from cmem.cmempy.api import get_json, request
+from cmem.cmempy.config import get_dp_api_endpoint
+from requests import HTTPError
+
+from cmem_cmemc.command import CmemcCommand
+from cmem_cmemc.command_group import CmemcGroup
+from cmem_cmemc.completion import NOT_SORTED, finalize_completion, graph_uris
+from cmem_cmemc.exceptions import CmemcError
+from cmem_cmemc.object_list import (
+    DirectListPropertyFilter,
+    DirectValuePropertyFilter,
+    ObjectList,
+    transform_lower,
+)
+from cmem_cmemc.string_processor import GraphLink, TimeAgo
+from cmem_cmemc.utils import get_graphs_as_dict, struct_to_table
+
+if TYPE_CHECKING:
+    from cmem_cmemc.context import ApplicationContext
+
+
+API_BASE = get_dp_api_endpoint() + "/api/ext/semspect"
+
+
+def is_available() -> bool:
+    """Check availability of graph insights endpoints
+
+    {
+     "isActive": true,
+     "isUserAllowed": true
+    }
+    """
+    try:
+        data: dict[str, bool] = get_json(API_BASE)
+    except HTTPError:
+        return False
+    return bool(data["isActive"] is True and data["isUserAllowed"] is True)
+
+
+def check_availability(ctx: click.Context) -> None:
+    """Check availability of graph insights endpoints or raise an exception"""
+    if is_available():
+        return
+    app: ApplicationContext = ctx.obj
+    raise CmemcError(app, "Graph Insights is not available.")
+
+
+def get_snapshots(ctx: click.Context) -> list[dict[str, str | bool | list[str]]]:
+    """Get the snapshot list (all snapshots)"""
+    check_availability(ctx)
+    data: list[dict[str, str | bool | list[str]]] = get_json(
+        API_BASE + "/snapshot/status", params={"includeManagementOnly": True}
+    )
+    return data
+
+
+def complete_snapshot_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:  # noqa: ARG001
+    """Provide auto-completion for snapshot Ids"""
+    snapshots = get_snapshots(ctx)
+    snapshots = sorted(
+        snapshots, key=lambda snapshot: snapshot["updateInfoTimestamp"], reverse=True
+    )
+    options = [
+        (
+            snapshot["databaseId"],
+            f"{snapshot['mainGraphSynced']} ({snapshot['updateInfoTimestamp']})",
+        )
+        for snapshot in snapshots
+    ]
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=NOT_SORTED)
+
+
+snapshot_list = ObjectList(
+    name="insight snapshots",
+    get_objects=get_snapshots,
+    filters=[
+        DirectValuePropertyFilter(
+            name="id",
+            description="Snapshots with a specific id.",
+            property_key="databaseId",
+            transform=transform_lower,
+        ),
+        DirectValuePropertyFilter(
+            name="main-graph",
+            description="Snapshots with a specific main graph.",
+            property_key="mainGraphSynced",
+        ),
+        DirectValuePropertyFilter(
+            name="status",
+            description="Snapshots with a specific status.",
+            property_key="status",
+        ),
+        DirectListPropertyFilter(
+            name="affected-graph",
+            description="Snapshots with a specific affected graph (main or sub-graphs).",
+            property_key="allGraphsSynced",
+        ),
+    ],
+)
+
+
+@click.command(cls=CmemcCommand, name="list")
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    help=snapshot_list.get_filter_help_text(),
+    shell_complete=snapshot_list.complete_values,
+    multiple=True,
+)
+@click.option("--raw", is_flag=True, help="Outputs raw JSON response.")
+@click.option(
+    "--id-only",
+    is_flag=True,
+    help="Return the snapshot IDs only. This is useful for piping the IDs into other commands.",
+)
+@click.pass_context
+def list_command(ctx: Context, filter_: tuple[tuple[str, str]], id_only: bool, raw: bool) -> None:
+    """List graph insight snapshots.
+
+    Graph Insights Snapshots are identified by an ID.
+    """
+    check_availability(ctx)
+    app: ApplicationContext = ctx.obj
+    snapshots = snapshot_list.apply_filters(ctx=ctx, filter_=filter_)
+
+    if id_only:
+        for _ in snapshots:
+            click.echo(_["databaseId"])
+        return
+
+    if raw:
+        app.echo_info_json(snapshots)
+        return
+
+    graphs = get_graphs_as_dict()
+    table = []
+    for _ in snapshots:
+        id_ = _["databaseId"]
+        main_graph = _["mainGraphSynced"]
+        updated = _["updateInfoTimestamp"]
+        status = _["status"]
+        if main_graph not in graphs:
+            main_graph = rf"\[missing: {main_graph}]"
+        table.append([id_, main_graph, updated, status])
+
+    app.echo_info_table(
+        table,
+        headers=["ID", "Main Graph", "Updated", "Status"],
+        sort_column=0,
+        cell_processing={1: GraphLink(), 2: TimeAgo()},
+        empty_table_message="No graph insight snapshots found.",
+    )
+
+
+@click.command(cls=CmemcCommand, name="delete")
+@click.argument("SNAPSHOT_ID", type=str, shell_complete=complete_snapshot_ids, required=False)
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    help=snapshot_list.get_filter_help_text(),
+    shell_complete=snapshot_list.complete_values,
+    multiple=True,
+)
+@click.option("-a", "--all", "all_", is_flag=True, help="Delete all snapshots.")
+@click.pass_context
+def delete_command(
+    ctx: Context, snapshot_id: str | None, filter_: tuple[tuple[str, str]], all_: bool
+) -> None:
+    """Delete a graph insight snapshot.
+
+    Graph Insight Snapshots are identified by an ID.
+    To get a list of existing snapshots,
+    execute the `graph insights list` command or use tab-completion.
+    """
+    check_availability(ctx)
+    app: ApplicationContext = ctx.obj
+    if snapshot_id is None and not filter_ and not all_:
+        raise click.UsageError("Either provide a snapshot ID or a filter, or use the --all flag.")
+
+    if all_:
+        app.echo_info("Deleting all snapshots ... ", nl=False)
+        request(method="DELETE", uri=f"{API_BASE}/snapshot")
+        app.echo_success("done")
+        return
+
+    all_snapshots = get_snapshots(ctx)
+    all_snapshot_ids = [_["databaseId"] for _ in all_snapshots]
+    filter_to_apply = list(filter_) if filter_ else []
+    if snapshot_id:
+        filter_to_apply.append(("id", snapshot_id))
+    snapshots_to_delete = snapshot_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
+    if not snapshots_to_delete:
+        raise click.UsageError("No snapshots found to delete.")
+
+    for _ in snapshots_to_delete:
+        id_to_delete = _["databaseId"]
+        if id_to_delete not in all_snapshot_ids:
+            raise click.UsageError(f"Snapshot ID '{id_to_delete}' does not exist.")
+    for _ in snapshots_to_delete:
+        id_to_delete = _["databaseId"]
+        app.echo_info(f"Deleting snapshot {id_to_delete} ... ", nl=False)
+        request(method="DELETE", uri=f"{API_BASE}/snapshot/{id_to_delete}")
+        app.echo_success("done")
+
+
+@click.command(cls=CmemcCommand, name="create")
+@click.argument("iri", type=click.STRING, shell_complete=graph_uris)
+@click.pass_context
+def create_command(ctx: Context, iri: str) -> None:
+    """Create or update a graph insight snapshot.
+
+    Create a graph insight snapshot for a given graph.
+    If the snapshot already exists, it is hot-swapped after re-creation.
+    The snapshot contains only the (imported) graphs the requesting user can read.
+    """
+    check_availability(ctx)
+    app: ApplicationContext = ctx.obj
+    app.echo_info(f"Create / Update graph snapshot for graph {iri} ... ", nl=False)
+    request(method="POST", uri=f"{API_BASE}/snapshot", params={"contextGraph": iri})
+    app.echo_success("started")
+
+
+@click.command(cls=CmemcCommand, name="update")
+@click.argument("SNAPSHOT_ID", type=str, shell_complete=complete_snapshot_ids, required=False)
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    help=snapshot_list.get_filter_help_text(),
+    shell_complete=snapshot_list.complete_values,
+    multiple=True,
+)
+@click.option("-a", "--all", "all_", is_flag=True, help="Delete all snapshots.")
+@click.pass_context
+def update_command(
+    ctx: Context, snapshot_id: str | None, filter_: tuple[tuple[str, str]], all_: bool
+) -> None:
+    """Update a graph insight snapshot.
+
+    Update a graph insight snapshot.
+    After the update, the snapshot is hot-swapped.
+    """
+    check_availability(ctx)
+    app: ApplicationContext = ctx.obj
+    if snapshot_id is None and not filter_ and not all_:
+        raise click.UsageError("Either provide a snapshot ID or a filter, or use the --all flag.")
+
+    filter_to_apply = list(filter_) if filter_ else []
+    if snapshot_id:
+        filter_to_apply.append(("id", snapshot_id))
+    snapshots_to_update = snapshot_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
+
+    all_snapshots = get_snapshots(ctx)
+    all_snapshot_ids = [_["databaseId"] for _ in all_snapshots]
+
+    if all_:
+        snapshots_to_update = get_snapshots(ctx)
+
+    if not snapshots_to_update:
+        raise click.UsageError("No snapshots found to delete.")
+
+    for _ in snapshots_to_update:
+        id_to_update = _["databaseId"]
+        if id_to_update not in all_snapshot_ids:
+            raise click.UsageError(f"Snapshot ID '{id_to_update}' does not exist.")
+    for _ in snapshots_to_update:
+        id_to_update = _["databaseId"]
+        app.echo_info(f"Update snapshot {id_to_update} ... ", nl=False)
+        request(method="PUT", uri=f"{API_BASE}/snapshot/{snapshot_id}")
+        app.echo_success("started")
+
+
+@click.command(cls=CmemcCommand, name="inspect")
+@click.argument("SNAPSHOT_ID", type=str, shell_complete=complete_snapshot_ids)
+@click.option("--raw", is_flag=True, help="Outputs raw JSON.")
+@click.pass_context
+def inspect_command(ctx: Context, snapshot_id: str, raw: bool) -> None:
+    """Inspect the metadata of a graph insight snapshot."""
+    check_availability(ctx)
+    app: ApplicationContext = ctx.obj
+    snapshot: dict[str, str | bool | list[str]] = get_json(
+        f"{API_BASE}/snapshot/status/{snapshot_id}"
+    )
+    if raw:
+        app.echo_info_json(snapshot)
+    else:
+        table = struct_to_table(snapshot)
+        app.echo_info_table(table, headers=["Key", "Value"], sort_column=0)
+
+
+@click.group(cls=CmemcGroup, name="insights")
+def insights_group() -> CmemcGroup:  # type: ignore[empty-body]
+    """List, create, delete and inspect graph insight snapshots.
+
+    Graph Insight Snapshots are identified by an ID.
+    To get a list of existing snapshots,
+    execute the `graph insights list` command or use tab-completion.
+    """
+
+
+insights_group.add_command(list_command)
+insights_group.add_command(delete_command)
+insights_group.add_command(create_command)
+insights_group.add_command(update_command)
+insights_group.add_command(inspect_command)

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/query.py

@@ -10,8 +10,8 @@ from time import sleep, time
 from uuid import uuid4
 
 import click
-from click import ClickException, UsageError
 from click.shell_completion import CompletionItem
+from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.queries import (
     QueryCatalog,
     SparqlQuery,
@@ -91,12 +91,12 @@ class ReplayStatistics:
                 iri = query_["iri"]
                 catalog_entry = self.catalog.get_query(iri)
                 if catalog_entry is None:
-                    raise ClickException(f"measure_query - query {iri} is not in catalog.")
+                    raise click.ClickException(f"measure_query - query {iri} is not in catalog.")
                 return catalog_entry
             query_string = query_["queryString"]
             return SparqlQuery(text=query_string)
         except KeyError as error:
-            raise ClickException(
+            raise click.ClickException(
                 "measure_query - given input dict has no queryString key."
             ) from error
 
@@ -289,15 +289,15 @@ query_status_list = ObjectList(
             compare=compare_regex,
             fixed_completion=[
                 CompletionItem(
-                    r"http\:\/\/schema.org",
+                    r"http://schema.org",
                     help="List only queries which somehow use the schema.org namespace.",
                 ),
                 CompletionItem(
-                    r"http\:\/\/www.w3.org\/2000\/01\/rdf-schema\#",
+                    r"http://www.w3.org/2000/01/rdf-schema#",
                     help="List only queries which somehow use the RDF schema namespace.",
                 ),
                 CompletionItem(
-                    r"\\\?value",
+                    r"?value",
                     help="List only queries which are using the ?value projection variable.",
                 ),
                 CompletionItem(
@@ -330,6 +330,13 @@ def _output_query_status_details(app: ApplicationContext, status_dict: dict) ->
 
 
 @click.command(cls=CmemcCommand, name="list")
+@click.option(
+    "--catalog-graph",
+    default="https://ns.eccenca.com/data/queries/",
+    show_default=True,
+    shell_complete=completion.graph_uris,
+    help="The used query catalog graph.",
+)
 @click.option(
     "--id-only",
     is_flag=True,
@@ -337,13 +344,13 @@ def _output_query_status_details(app: ApplicationContext, status_dict: dict) ->
     "This is useful for piping the ids into other cmemc commands.",
 )
 @click.pass_obj
-def list_command(app: ApplicationContext, id_only: bool) -> None:
+def list_command(app: ApplicationContext, catalog_graph: str, id_only: bool) -> None:
     """List available queries from the catalog.
 
     Outputs a list of query URIs which can be used as reference for
     the query execute command.
     """
-    queries = QueryCatalog().get_queries().items()
+    queries = QueryCatalog(graph=catalog_graph).get_queries().items()
     if id_only:
         # sort dict by short_url - https://docs.python.org/3/howto/sorting.html
         for _, sparql_query in sorted(queries, key=lambda k: k[1].short_url.lower()):
@@ -359,7 +366,12 @@ def list_command(app: ApplicationContext, id_only: bool) -> None:
             ]
             table.append(row)
         app.echo_info_table(
-            table, headers=["Query URI", "Type", "Placeholder", "Label"], sort_column=3
+            table,
+            headers=["Query URI", "Type", "Placeholder", "Label"],
+            sort_column=3,
+            empty_table_message="There are no query available in the "
+            f"selected catalog ({catalog_graph}).",
+            caption=f"Queries from {catalog_graph} ({get_cmem_base_uri()})",
         )
 
 
@@ -367,6 +379,13 @@ def list_command(app: ApplicationContext, id_only: bool) -> None:
 @click.argument(
     "QUERIES", nargs=-1, required=True, shell_complete=completion.remote_queries_and_sparql_files
 )
+@click.option(
+    "--catalog-graph",
+    default="https://ns.eccenca.com/data/queries/",
+    show_default=True,
+    shell_complete=completion.graph_uris,
+    help="The used query catalog graph.",
+)
 @click.option(
     "--accept",
     default="default",
@@ -420,6 +439,7 @@ def list_command(app: ApplicationContext, id_only: bool) -> None:
 def execute_command(  # noqa: PLR0913
     app: ApplicationContext,
     queries: tuple[str, ...],
+    catalog_graph: str,
     accept: str,
     no_imports: bool,
     base64: bool,
@@ -453,9 +473,14 @@ def execute_command(  # noqa: PLR0913
     app.echo_debug("Parameter: " + str(placeholder))
     for file_or_uri in queries:
         app.echo_debug(f"Start of execution: {file_or_uri} with " f"placeholder {placeholder}")
-        executed_query: SparqlQuery = QueryCatalog().get_query(file_or_uri, placeholder=placeholder)
+        executed_query: SparqlQuery = QueryCatalog(graph=catalog_graph).get_query(
+            file_or_uri, placeholder=placeholder
+        )
         if executed_query is None:
-            raise ClickException(f"{file_or_uri} is neither a (readable) file nor a query URI.")
+            raise click.UsageError(
+                f"{file_or_uri} is neither a (readable) file nor "
+                f"a query URI in the catalog graph {catalog_graph}"
+            )
         app.echo_debug(
             f"Execute ({executed_query.query_type}): "
             f"{executed_query.label} < {executed_query.url}"
@@ -499,8 +524,15 @@ def execute_command(  # noqa: PLR0913
 @click.argument(
     "QUERIES", nargs=-1, required=True, shell_complete=completion.remote_queries_and_sparql_files
 )
+@click.option(
+    "--catalog-graph",
+    default="https://ns.eccenca.com/data/queries/",
+    show_default=True,
+    shell_complete=completion.graph_uris,
+    help="The used query catalog graph.",
+)
 @click.pass_obj
-def open_command(app: ApplicationContext, queries: tuple[str, ...]) -> None:
+def open_command(app: ApplicationContext, queries: tuple[str, ...], catalog_graph: str) -> None:
     """Open queries in the editor of the query catalog in your browser.
 
     With this command, you can open (remote) queries from the query catalog in
@@ -512,10 +544,13 @@ def open_command(app: ApplicationContext, queries: tuple[str, ...]) -> None:
     opening multiple browser tabs.
     """
     for file_or_uri in queries:
-        opened_query = QueryCatalog().get_query(file_or_uri)
+        opened_query = QueryCatalog(graph=catalog_graph).get_query(file_or_uri)
         if opened_query is None:
-            raise ClickException(f"{file_or_uri} is neither a (readable) file nor a query URI.")
-        open_query_uri = opened_query.get_editor_url()
+            raise click.UsageError(
+                f"{file_or_uri} is neither a (readable) file nor "
+                f"a query URI in the catalog graph {catalog_graph}"
+            )
+        open_query_uri = opened_query.get_editor_url(graph=catalog_graph)
         app.echo_debug(f"Open {file_or_uri}: {open_query_uri}")
         click.launch(open_query_uri)
 
@@ -571,7 +606,7 @@ def status_command(
         queries = query_status_list.apply_filters(ctx=ctx, filter_=filter_)
 
     if query_id and len(queries) == 0:
-        raise UsageError(f"Query with ID '{query_id}' does not exist (anymore).")
+        raise click.UsageError(f"Query with ID '{query_id}' does not exist (anymore).")
 
     if raw:
         app.echo_info_json(queries)
@@ -666,14 +701,14 @@ def replay_command(  # noqa: PLR0913
     other data.
     """
     if loops <= 0:
-        raise UsageError("Please set a positive loops integer value (>=1).")
+        raise click.UsageError("Please set a positive loops integer value (>=1).")
     try:
         with Path(replay_file).open(encoding="utf8") as _:
             input_queries = load(_)
     except JSONDecodeError as error:
-        raise ClickException(f"File {replay_file} is not a valid JSON document.") from error
+        raise click.ClickException(f"File {replay_file} is not a valid JSON document.") from error
     if len(input_queries) == 0:
-        raise ClickException(f"File {replay_file} contains no queries.")
+        raise click.ClickException(f"File {replay_file} contains no queries.")
     app.echo_debug(f"File {replay_file} contains {len(input_queries)} queries.")
 
     statistic = ReplayStatistics(app=app, label=run_label)

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/store.py

@@ -10,6 +10,7 @@ from cmem.cmempy.dp.admin import create_showcase_data, delete_bootstrap_data, im
 from cmem.cmempy.dp.admin.backup import get_zip, post_zip
 from cmem.cmempy.dp.workspace import migrate_workspaces
 from cmem.cmempy.health import get_dp_info
+from cmem.cmempy.workspace import reload_workspace
 from jinja2 import Template
 
 from cmem_cmemc.command import CmemcCommand
@@ -53,7 +54,7 @@ def bootstrap_command(app: ApplicationContext, import_: bool, remove: bool) -> N
 
     Note: The import part of this command is equivalent to the 'bootstrap-data' migration recipe
     """
-    if import_ and remove or not import_ and not remove:
+    if (import_ and remove) or (not import_ and not remove):
         raise UsageError("Either use the --import or the --remove option.")
     if import_:
         app.echo_info("Update or import bootstrap data ... ", nl=False)
@@ -99,12 +100,15 @@ def showcase_command(app: ApplicationContext, scale: int, create: bool, delete:
         raise UsageError("Either use the --create or the --delete flag.")
     if delete:
         raise NotImplementedError(
-            "This feature is not implemented yet. " "Please delete the graphs manually."
+            "This feature is not implemented yet. Please delete the graphs manually."
         )
     if create:
         app.echo_info(f"Create showcase data with scale factor {scale} ... ", nl=False)
         create_showcase_data(scale_factor=scale)
         app.echo_success("done")
+        app.echo_info("Reload workspace  ... ", nl=False)
+        reload_workspace()
+        app.echo_success("done")
 
 
 @click.command(cls=CmemcCommand, name="export")

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/validation.py

@@ -766,11 +766,13 @@ def export_command(
         f" to {output_file} ... ",
         nl=False,
     )
-    with Path(output_file, mode="w", encoding="utf-8") as file:
+    output_path = Path(output_file)
+
+    with output_path.open("w", encoding="utf-8") as file:
         if format_ == "XML":
-            file.write_text(_reports_to_junit(reports))
+            file.write(_reports_to_junit(reports))
         if format_ == "JSON":
-            file.write_text(json.dumps(reports, indent=2))
+            json.dump(reports, file, indent=2)
     app.echo_success("done")
     if exit_1 == "error" and overall_violations > 0:
         app.echo_error(

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/workflow.py

@@ -53,6 +53,7 @@ FILE_EXTENSIONS_TO_PLUGIN_ID = {
     ".txt": "text",
     ".md": "text",
     ".xlsx": "excel",
+    ".xls": "excel",
     ".zip": "multiCsv",
     ".pdf": "binaryFile",
     ".png": "binaryFile",

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/completion.py

@@ -53,11 +53,6 @@ SORT_BY_KEY = 0
 SORT_BY_DESC = 1
 
 
-def escape_colon(value: str) -> str:
-    """Escape colons in the input string by prefixing them with a backslash."""
-    return value.replace(":", r"\:")
-
-
 def finalize_completion(
     candidates: list,
     incomplete: str = "",
@@ -130,10 +125,7 @@ def finalize_completion(
                 key=lambda x: (str(x[sort_by]).casefold(), str(x[sort_by])),
                 reverse=reverse,
             )
-        return [
-            CompletionItem(value=escape_colon(element[0]), help=element[1])
-            for element in sorted_list
-        ]
+        return [CompletionItem(value=element[0], help=element[1]) for element in sorted_list]
 
     raise ClickException(
         "Candidates should be a list of strings or a list of tuples." f" Got {candidates}"
@@ -199,7 +191,10 @@ def acl_actions(ctx: Context, param: Argument, incomplete: str) -> list[Completi
         if check_option_in_params(iri, ctx.params.get(str(param.name))):
             continue
         options.append((qname, name))
-    options.append(("urn:elds-backend-all-actions", "All Actions (until 24.2.x, now deprecated)"))
+    if not check_option_in_params("urn:elds-backend-all-actions", ctx.params.get(str(param.name))):
+        options.append(
+            ("urn:elds-backend-all-actions", "All Actions (until 24.2.x, now deprecated)")
+        )
     return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
@@ -359,10 +354,10 @@ def dataset_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[
         ("type", "Filter by dataset type."),
     ]
     filter_regex = [
-        (r"^Final\:", "Example: Dataset label starts with 'Final:'."),
+        ("^Final:", "Example: Dataset label starts with 'Final:'."),
         (
             r"[12][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]",
-            "Example: Dataset label contains a data-like string.",
+            "Example: Dataset label contains a date-like string.",
         ),
     ]
     options = []
@@ -526,6 +521,7 @@ def get_dataset_file_mapping() -> dict[str, dict[str, str]]:
     return {
         ".csv": {"description": "CSV Dataset resource", "type": "csv"},
         ".csv.zip": {"description": "CSV Dataset resource (zipped)", "type": "csv"},
+        ".xls": {"description": "Excel Dataset resource", "type": "excel"},
         ".xlsx": {"description": "Excel Dataset resource", "type": "excel"},
         ".xml": {"description": "XML Dataset resource", "type": "xml"},
         ".xml.zip": {"description": "XML Dataset resource (zipped)", "type": "xml"},
@@ -643,10 +639,11 @@ def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     args = get_completion_args(incomplete)
     # setup configuration
     ApplicationContext.set_connection_from_params(ctx.find_root().params)
+    catalog_graph = ctx.params.get("catalog_graph")
     # extract placeholder from given queries in the command line
     options = []
     placeholders: dict[str, QueryPlaceholder] = {}
-    catalog = QueryCatalog()  # fetch all queries
+    catalog = QueryCatalog(graph=catalog_graph) if catalog_graph else QueryCatalog()
     for _, arg in enumerate(args):
         query = catalog.get_query(arg)
         if query is not None:
@@ -654,7 +651,7 @@ def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[Completi
             placeholders = placeholders | get_placeholders_for_query(iri=query.url)
             # collect all placeholder keys
             options.extend(list(query.get_placeholder_keys()))
-    # look if cursor is in value position of the -p option and
+    # look if the cursor is in value position of the -p option and
     # use placeholder value completion, in case it is
     if args[len(args) - 2] in ("-p", "--parameter"):
         key = args[len(args) - 1]
@@ -676,8 +673,10 @@ def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[Completi
 def remote_queries(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of query URIs."""
     ApplicationContext.set_connection_from_params(ctx.find_root().params)
+    catalog_graph = ctx.params.get("catalog_graph")
+    catalog = QueryCatalog(graph=catalog_graph) if catalog_graph else QueryCatalog()
     options = []
-    for query in QueryCatalog().get_queries().values():
+    for query in catalog.get_queries().values():
         url = query.short_url
         label = query.label
         options.append((url, label))
@@ -798,11 +797,11 @@ def graph_uris_with_all_graph_uri(
     options = graph_uris(ctx, param, incomplete, writeable=True, readonly=True)
     options.append(
         CompletionItem(
-            value=r"urn\:elds-backend-all-graphs", help="All Graphs (until 24.2.x, now deprecated)"
+            value=r"urn:elds-backend-all-graphs", help="All Graphs (until 24.2.x, now deprecated)"
         )
     )
     options.append(
-        CompletionItem(value=r"https\://vocab.eccenca.com/auth/AllGraphs", help="All Graphs")
+        CompletionItem(value=r"https://vocab.eccenca.com/auth/AllGraphs", help="All Graphs")
     )
     return options
 
@@ -958,7 +957,7 @@ def workflow_list_filter(ctx: Context, param: Argument, incomplete: str) -> list
         ("input-output", "List only workflows with a variable input and output dataset."),
     ]
     filter_regex = [
-        (r"^Final\:", "Example: Workflow label starts with 'Final:'."),
+        (r"^Final:", "Example: Workflow label starts with 'Final:'."),
         (
             r"[12][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]",
             "Example: Workflow label contains a data-like string.",

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/context.py

@@ -29,9 +29,9 @@ from cmem_cmemc.exceptions import InvalidConfigurationError
 from cmem_cmemc.string_processor import StringProcessor, process_row
 from cmem_cmemc.utils import is_enabled, str_to_bool
 
-DI_TARGET_VERSION = "v25.1.0"
+DI_TARGET_VERSION = "v25.2.0"
 
-EXPLORE_TARGET_VERSION = "v25.1.0"
+EXPLORE_TARGET_VERSION = "v25.2.0"
 
 KNOWN_CONFIG_KEYS = {
     "CMEM_BASE_URI": cmempy_config.get_cmem_base_uri,

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/manual_helper/multi_page.py

@@ -31,6 +31,7 @@ def get_icon_for_command_group(full_name: str) -> str:
         "project variable": "material/variable-box",
         "query": "eccenca/application-queries",
         "graph": "eccenca/artefact-dataset-eccencadataplatform",
+        "graph imports": "material/family-tree",
         "graph validation": "octicons/verified-16",
         "vocabulary": "eccenca/application-vocabularies",
         "vocabulary cache": "eccenca/application-vocabularies",
@@ -58,6 +59,7 @@ def get_tags_for_command_group(full_name: str) -> str:
         "project variable": ["Variables", "cmemc"],
         "query": ["SPARQL", "cmemc"],
         "graph": ["KnowledgeGraph", "cmemc"],
+        "graph imports": ["KnowledgeGraph", "cmemc"],
         "graph validation": ["KnowledgeGraph", "Validation", "cmemc"],
         "vocabulary": ["Vocabulary", "cmemc"],
         "vocabulary cache": ["Vocabulary", "cmemc"],

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/string_processor.py

@@ -20,18 +20,23 @@ class StringProcessor(ABC):
 
 
 class TimeAgo(StringProcessor):
-    """Create a string similar to 'x minutes ago' from a timestamp"""
+    """Create a string similar to 'x minutes ago' from a timestamp or iso-formated string."""
 
     def process(self, text: str) -> str:
         """Process a single string content and output the processed string."""
         if text is None:
             return ""
+        try:
+            stamp = datetime.fromisoformat(str(text))
+            return str(timeago.format(stamp, datetime.now(tz=timezone.utc)))
+        except (ValueError, TypeError):
+            pass
         try:
             text_as_int = int(text)
+            stamp = datetime.fromtimestamp(text_as_int / 1000, tz=timezone.utc)
+            return str(timeago.format(stamp, datetime.now(tz=timezone.utc)))
         except ValueError:
             return text
-        stamp = datetime.fromtimestamp(text_as_int / 1000, tz=timezone.utc)
-        return str(timeago.format(stamp, datetime.now(tz=timezone.utc)))
 
 
 class GraphLink(StringProcessor):

{cmem_cmemc-25.3.0 → cmem_cmemc-25.5.0rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cmem-cmemc"
-version = "25.3.0"
+version = "25.5.0rc1"
 description = "Command line client for eccenca Corporate Memory"
 license = "Apache-2.0"
 classifiers = [
@@ -31,11 +31,10 @@ readme = "README-public.md"
 python = "^3.10"
 beautifulsoup4 = "^4.13.3"
 certifi = ">=2024.2.2"
-# https://github.com/pallets/click/issues/2906
-click = "^8.1.8, <8.2.0"
+click = "^8.3.0"
 click-didyoumean = "^0.3.1"
 click-help-colors = "^0.9.4"
-cmem-cmempy = "==25.2.0"
+cmem-cmempy = "==25.4.0"
 # cmem-cmempy = { path = "cmempy", develop = true }
 configparser = "^7.2.0"
 jinja2 = "^3.1.6"
@@ -66,9 +65,11 @@ pytest-cov = "^6.0.0"
 pytest-dotenv = "^0.5.2"
 pytest-html = "^4.1.1"
 pytest-memray = { version = "^1.7.0",  markers = "platform_system != 'Windows'" }
+pytest-mock = "^3.14.1"
 requests-mock = "^1.12.1"
 ruff = "^0.7.4"
 safety = "^1.10.3"
+semver = "^3.0.4"
 types-python-dateutil = "^2.9.0.20240316"
 types-requests = "^2.32.0.20241016"
 types-six = "^1.16.21.20240425"