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

{cmem_cmemc-25.4.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.4.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.3.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.4.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.4.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.4.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.4.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.4.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.4.0 → cmem_cmemc-25.5.0rc1}/cmem_cmemc/commands/query.py

@@ -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(

{cmem_cmemc-25.4.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.4.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.4.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"},
@@ -801,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
 
@@ -961,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.4.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.4.0 → cmem_cmemc-25.5.0rc1}/pyproject.toml

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