cmem-cmemc 25.6.0__py3-none-any.whl → 26.1.0rc1__py3-none-any.whl

cmem_cmemc/commands/graph.py

@@ -14,7 +14,8 @@ from xml.etree.ElementTree import (  # nosec
 )
 
 import click
-from click import ClickException, Context, UsageError
+from click import Context, UsageError
+from click.shell_completion import CompletionItem
 from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.dp.authorization import refresh
 from cmem.cmempy.dp.proxy import graph as graph_api
@@ -30,9 +31,17 @@ 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
+from cmem_cmemc.context import ApplicationContext, build_caption
+from cmem_cmemc.exceptions import CmemcError
+from cmem_cmemc.object_list import (
+    DirectMultiValuePropertyFilter,
+    DirectValuePropertyFilter,
+    Filter,
+    ObjectList,
+)
 from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.smart_path import SmartPath
+from cmem_cmemc.string_processor import GraphLink
 from cmem_cmemc.utils import (
     RdfGraphData,
     convert_uri_to_filename,
@@ -44,6 +53,70 @@ from cmem_cmemc.utils import (
 )
 
 
+def compare_access_value(ctx: Filter, object_value: str, filter_value: str) -> bool:  # noqa: ARG001
+    """Compare access values - writeable property is boolean string."""
+    if filter_value == "writeable":
+        return object_value == "True"
+    if filter_value == "readonly":
+        return object_value == "False"
+    raise UsageError(f"Invalid access filter value: {filter_value}")
+
+
+def compare_imported_by(ctx: Filter, object_iri: str, importing_graph_iri: str) -> bool:  # noqa: ARG001
+    """Check if object_iri is imported by importing_graph_iri."""
+    if importing_graph_iri not in get_graphs_as_dict():
+        raise CmemcError(UNKNOWN_GRAPH_ERROR.format(importing_graph_iri))
+    imported_graphs = get_graph_imports(importing_graph_iri)
+    return object_iri in imported_graphs
+
+
+def get_graphs_for_list(ctx: Context) -> list[dict]:  # noqa: ARG001
+    """Get graphs for object list."""
+    return get_graphs()
+
+
+# Common filters used by both list and delete commands
+_graph_common_filters = [
+    DirectValuePropertyFilter(
+        name="imported-by",
+        description="Filter graphs imported by the specified graph IRI.",
+        property_key="iri",
+        compare=compare_imported_by,
+        completion_method="values",
+    ),
+    DirectMultiValuePropertyFilter(
+        name="iris",
+        description="Internal filter for multiple graph IRIs.",
+        property_key="iri",
+    ),
+]
+
+# Access filter only for list command (not applicable for delete)
+_graph_access_filter = DirectValuePropertyFilter(
+    name="access",
+    description="Filter graphs by access condition (readonly or writeable).",
+    property_key="writeable",
+    compare=compare_access_value,
+    fixed_completion=[
+        CompletionItem("readonly", help="Graphs which are NOT writeable by current user."),
+        CompletionItem("writeable", help="Graphs which ARE writeable by current user."),
+    ],
+    fixed_completion_only=True,
+)
+
+graph_list_obj = ObjectList(
+    name="graphs",
+    get_objects=get_graphs_for_list,
+    filters=[_graph_access_filter, *_graph_common_filters],
+)
+
+graph_delete_obj = ObjectList(
+    name="graphs",
+    get_objects=get_graphs_for_list,
+    filters=[*_graph_common_filters],
+)
+
+
 def count_graph(graph_iri: str) -> int:
     """Count triples in a graph and return integer."""
     query = "SELECT (COUNT(*) AS ?triples) " + " FROM <" + graph_iri + "> WHERE { ?s ?p ?o }"  # noqa: S608
@@ -129,45 +202,13 @@ def _get_export_names(
         _name_created = f"{Template(template).render(template_data)}{file_extension}"
         _names[iri] = _name_created
     if len(_names.values()) != len(set(_names.values())):
-        raise ClickException(
+        raise CmemcError(
             "The given template string produces a naming clash. "
             "Please use a different template to produce unique names."
         )
     return _names
 
 
-def _get_graphs_filtered(filter_name: str, filter_value: str) -> list[dict]:
-    """Get graphs but filtered according to name and value."""
-    # not filtered means all graphs
-    graphs: list[dict]
-    if filter_name is None:
-        return get_graphs()
-    # check for correct filter names
-    possible_filter_names = ("access", "imported-by")
-    if filter_name not in possible_filter_names:
-        raise ClickException(
-            f"{filter_name} is an unknown filter name. " f"Use one of {possible_filter_names}."
-        )
-    # filter by access condition
-    if filter_name == "access":
-        if filter_value == "writeable":
-            graphs = get_graphs(writeable=True, readonly=False)
-        elif filter_value == "readonly":
-            graphs = get_graphs(writeable=False, readonly=True)
-        else:
-            raise ClickException("Filter access is either 'readonly' or 'writeable'.")
-    else:
-        # default is all graphs
-        graphs = get_graphs()
-    # filter by imported-by
-    if filter_name == "imported-by":
-        if filter_value not in get_graphs_as_dict():
-            raise ClickException(UNKNOWN_GRAPH_ERROR.format(filter_value))
-        imported_graphs = get_graph_imports(filter_value)
-        graphs = [_ for _ in graphs if _["iri"] in imported_graphs]
-    return graphs
-
-
 def _add_imported_graphs(iris: list[str], all_graphs: dict) -> list[str]:
     """Get a list of graph IRIs extended with the imported graphs.
 
@@ -190,6 +231,49 @@ def _add_imported_graphs(iris: list[str], all_graphs: dict) -> list[str]:
     return list(set(extended_list))
 
 
+def _validate_graph_iris(iris: tuple[str, ...]) -> None:
+    """Validate that all provided graph IRIs exist."""
+    if not iris:
+        return
+    all_graphs = get_graphs_as_dict()
+    for iri in iris:
+        if iri not in all_graphs:
+            raise CmemcError(UNKNOWN_GRAPH_ERROR.format(iri))
+
+
+def _get_graphs_to_delete(
+    ctx: Context,
+    iris: tuple[str, ...],
+    all_: bool,
+    filter_: tuple[tuple[str, str], ...],
+) -> list[dict]:
+    """Get the list of graphs to delete based on selection method."""
+    if all_:
+        return get_graphs(writeable=True, readonly=False)
+
+    # Validate provided IRIs exist before proceeding
+    _validate_graph_iris(iris)
+
+    # Build filter list
+    filter_to_apply = list(filter_) if filter_ else []
+
+    # Add IRIs if provided (using internal multi-value filter)
+    if iris:
+        filter_to_apply.append(("iris", ",".join(iris)))
+
+    # Apply filters to writeable graphs only
+    writeable_graphs = get_graphs(writeable=True, readonly=False)
+    graphs = graph_delete_obj.apply_filters(
+        ctx=ctx, filter_=filter_to_apply, objects=writeable_graphs
+    )
+
+    # Validation: ensure we found graphs
+    if not graphs:
+        raise CmemcError("No graphs found matching the provided criteria.")
+
+    return graphs
+
+
 def _check_and_extend_exported_graphs(
     iris: list[str], all_flag: bool, imported_flag: bool, all_graphs: dict
 ) -> list[str]:
@@ -220,7 +304,7 @@ def _check_and_extend_exported_graphs(
         )
     for iri in iris:
         if iri not in all_graphs:
-            raise ClickException(UNKNOWN_GRAPH_ERROR.format(iri))
+            raise CmemcError(UNKNOWN_GRAPH_ERROR.format(iri))
     if all_flag:
         # in case --all is given,
         # list of graphs is filled with all available graph IRIs
@@ -301,22 +385,16 @@ def tree_command(ctx: Context, all_: bool, raw: bool, id_only: bool, iris: list[
 @click.option(
     "--filter",
     "filter_",
-    type=click.Tuple([click.Choice(["access", "imported-by"]), str]),
-    shell_complete=completion.graph_list_filter,
-    default=[None] * 2,
-    help="Filter graphs based on effective access conditions or import "
-    "closure. "
-    "First parameter CHOICE can be 'access' or 'imported-by'. "
-    "The second parameter can be 'readonly' or 'writeable' in case "
-    "of 'access' or any readable graph in case of 'imported-by'.",
+    multiple=True,
+    type=(str, str),
+    shell_complete=graph_list_obj.complete_values,
+    help=graph_list_obj.get_filter_help_text(),
 )
-@click.pass_obj
-def list_command(
-    app: ApplicationContext, raw: bool, id_only: bool, filter_: tuple[str, str]
-) -> None:
+@click.pass_context
+def list_command(ctx: Context, raw: bool, id_only: bool, filter_: tuple[tuple[str, str]]) -> None:
     """List accessible graphs."""
-    filter_name, filter_value = filter_
-    graphs = _get_graphs_filtered(filter_name, filter_value)
+    app: ApplicationContext = ctx.obj
+    graphs = graph_list_obj.apply_filters(ctx=ctx, filter_=filter_)
 
     if raw:
         app.echo_info_json(graphs)
@@ -336,15 +414,19 @@ def list_command(
         row = [
             _["iri"],
             graph_class,
-            _["label"]["title"],
+            _["iri"],
         ]
         table.append(row)
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
         headers=["Graph IRI", "Type", "Label"],
         sort_column=2,
-        empty_table_message="No graphs found. "
-        "Use the `graph import` command to import a graph from a file, or "
+        cell_processing={2: GraphLink()},
+        caption=build_caption(len(table), "graph", filtered=filtered),
+        empty_table_message="No graphs found for these filters."
+        if filtered
+        else "No graphs found. Use the `graph import` command to import a graph from a file, or "
         "use the `admin store bootstrap` command to import the default graphs.",
     )
 
@@ -371,7 +453,6 @@ def _write_graph_imports(ctx: Context, filename: str, iri: str) -> None:
         imports_file.close()
 
 
-# pylint: disable=too-many-arguments,too-many-locals
 @click.command(cls=CmemcCommand, name="export")
 @click.option("-a", "--all", "all_", is_flag=True, help="Export all readable graphs.")
 @click.option(
@@ -475,7 +556,7 @@ def export_command(  # noqa: C901, 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
-        extension = mimetypes.guess_extension(mime_type)
+        extension = _get_file_extension_for_mime_type(mime_type)
         _names = _get_export_names(
             app, iris, template, f"{extension}.gz" if compress else f"{extension}"
         )
@@ -551,7 +632,7 @@ def validate_input_path(input_path: str) -> None:
     conflicting_files = [f for f in gz_files if f in files]
 
     if conflicting_files:
-        raise ClickException(
+        raise CmemcError(
             f"The following RDF files (.ttl/.nt) have corresponding '.gz' files,"
             f" which is not allowed: {', '.join(conflicting_files)}"
         )
@@ -566,6 +647,26 @@ def _get_graph_supported_formats() -> dict[str, str]:
     }
 
 
+def _get_file_extension_for_mime_type(mime_type: str) -> str:
+    """Get file extension for a MIME type with fallback mappings.
+
+    mimetypes.guess_extension() can return None on some systems (especially Windows)
+    for certain RDF MIME types. This function provides fallback extensions.
+    """
+    # Try to use the system's mimetypes registry first
+    extension = mimetypes.guess_extension(mime_type, strict=False)
+    if extension is not None:
+        return extension
+
+    # Fallback mappings for RDF MIME types
+    mime_to_extension = {
+        "application/n-triples": ".nt",
+        "text/turtle": ".ttl",
+        "application/rdf+xml": ".rdf",
+    }
+    return mime_to_extension.get(mime_type, ".ttl")
+
+
 def _get_buffer_and_content_type(
     triple_file: str, app: ApplicationContext
 ) -> tuple[io.BytesIO, str, None | str]:
@@ -633,7 +734,7 @@ def _process_input_directory(input_path: str, iri: str) -> list[RdfGraphData]:
         # in case a directory is the source AND IRI is given
         graphs = []
         for _ in _get_graph_supported_formats():
-            extension = mimetypes.guess_extension(_)
+            extension = _get_file_extension_for_mime_type(_)
             graphs += [
                 RdfGraphData(str(file), iri, [])
                 for file in SmartPath(input_path).glob(f"*{extension}")
@@ -775,6 +876,12 @@ def import_command(  # noqa: PLR0913
 
 
 @click.command(cls=CmemcCommand, name="delete")
+@click.argument(
+    "iris",
+    nargs=-1,
+    type=click.STRING,
+    shell_complete=completion.writable_graph_uris,
+)
 @click.option("-a", "--all", "all_", is_flag=True, help="Delete all writeable graphs.")
 @click.option(
     "--include-imports",
@@ -785,35 +892,56 @@ def import_command(  # noqa: PLR0913
 @click.option(
     "--include-import-statements", is_flag=True, help="Delete import reference of deleted graphs"
 )
-@click.argument(
-    "iris",
-    nargs=-1,
-    type=click.STRING,
-    shell_complete=completion.writable_graph_uris,
-    callback=tuple_to_list,
+@click.option(
+    "--filter",
+    "filter_",
+    multiple=True,
+    type=(str, str),
+    shell_complete=graph_delete_obj.complete_values,
+    help=graph_delete_obj.get_filter_help_text(),
 )
 @click.pass_context
-def delete_command(
+def delete_command(  # noqa: PLR0913
     ctx: Context,
+    iris: tuple[str, ...],
     all_: bool,
     include_imports: bool,
     include_import_statements: bool,
-    iris: list[str],
+    filter_: tuple[tuple[str, str], ...],
 ) -> None:
     """Delete graph(s) from the store."""
     app: ApplicationContext = ctx.obj
-    graphs = get_graphs_as_dict(writeable=True, readonly=False)
-    iris = _check_and_extend_exported_graphs(iris, all_, include_imports, graphs)
+
+    # Validation: require at least one selection method
+    if not iris and not all_ and not filter_:
+        raise UsageError(
+            "Either specify at least one graph IRI or use the --all or "
+            "--filter options to specify graphs for deletion."
+        )
+
+    # Get base list of graphs to delete using ObjectList filtering
+    graphs_to_delete = _get_graphs_to_delete(ctx, iris, all_, filter_)
+    iris_to_delete = [g["iri"] for g in graphs_to_delete]
+
+    # Handle --include-imports flag
+    if include_imports:
+        all_graphs = get_graphs_as_dict(writeable=True, readonly=False)
+        iris_to_delete = _add_imported_graphs(iris_to_delete, all_graphs)
+
+    # Remove duplicates and sort
+    iris_to_delete = sorted(set(iris_to_delete))
+
     imports_to_be_deleted = []
-    count: int = len(iris)
-    for current, iri in enumerate(iris, start=1):
+    count: int = len(iris_to_delete)
+    for current, iri in enumerate(iris_to_delete, start=1):
+        current_string = str(current).zfill(len(str(count)))
         imports_to_be_deleted += graph_imports_list.apply_filters(
             ctx=ctx, filter_=[("to-graph", iri)]
         )
 
-        app.echo_info(f"Drop graph {current}/{count}: {iri} ... ", nl=False)
+        app.echo_info(f"Delete graph {current_string}/{count}: {iri} ... ", nl=False)
         graph_api.delete(iri)
-        app.echo_success("done")
+        app.echo_success("deleted")
         # refresh access conditions in case of dropped AC graph
         if iri == refresh.AUTHORIZATION_GRAPH_URI:
             refresh.get()
@@ -823,7 +951,7 @@ def delete_command(
         imports_cmd = graph.commands["imports"]
         delete_cmd = imports_cmd.commands["delete"]  # type: ignore[attr-defined]
         for _ in imports_to_be_deleted:
-            if _["from_graph"] not in iris:
+            if _["from_graph"] not in iris_to_delete:
                 ctx.invoke(delete_cmd, from_graph=_["from_graph"], to_graph=_["to_graph"])
 
 

cmem_cmemc/commands/graph_imports.py

@@ -3,7 +3,7 @@
 import os
 
 import click
-from click import Argument, ClickException, Context, UsageError
+from click import Argument, Context, UsageError
 from click.shell_completion import CompletionItem
 from cmem.cmempy.dp.proxy.graph import get_graph_import_tree
 from cmem.cmempy.queries import SparqlQuery
@@ -12,8 +12,10 @@ 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 suppress_completion_errors
 from cmem_cmemc.constants import UNKNOWN_GRAPH_ERROR
-from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.context import ApplicationContext, build_caption
+from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.object_list import DirectValuePropertyFilter, ObjectList
 from cmem_cmemc.string_processor import GraphLink
 from cmem_cmemc.title_helper import TitleHelper
@@ -183,7 +185,7 @@ def tree_command(
 
     for iri in iris:
         if iri not in graphs:
-            raise ClickException(UNKNOWN_GRAPH_ERROR.format(iri))
+            raise CmemcError(UNKNOWN_GRAPH_ERROR.format(iri))
 
     iris = sorted(iris, key=lambda x: graphs[x]["label"]["title"].lower())
 
@@ -276,13 +278,16 @@ def list_command(ctx: Context, raw: bool, filter_: tuple[str, str]) -> None:
             to_graph = rf"\[missing: {to_graph}]"
         table.append([from_graph, to_graph])
 
+    filtered = len(filters_to_apply) > 0
     app.echo_info_table(
         table,
         headers=["From graph", "To graph"],
         sort_column=0,
+        caption=build_caption(len(table), "import", filtered=filtered),
         cell_processing={0: GraphLink(), 1: GraphLink()},
-        empty_table_message="No imports found. "
-        "You can use the `graph imports create` command to create a graph import.",
+        empty_table_message="No imports found for these filters."
+        if filtered
+        else "No imports found. Use the `graph imports create` command to create a graph import.",
     )
 
 
@@ -295,6 +300,7 @@ def _validate_graphs(from_graph: str | None, to_graph: str | None) -> None:
         raise click.UsageError(f"To graph {to_graph} not found.")
 
 
+@suppress_completion_errors
 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)
@@ -306,6 +312,7 @@ def _from_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[Com
     ]
 
 
+@suppress_completion_errors
 def _to_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Provide auto completion items for create/delete command to-graph argument"""
     from_graph = ctx.params["from_graph"]

cmem_cmemc/commands/graph_insights.py

@@ -11,11 +11,17 @@ 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.context import ApplicationContext
+from cmem_cmemc.completion import (
+    NOT_SORTED,
+    finalize_completion,
+    graph_uris,
+    suppress_completion_errors,
+)
+from cmem_cmemc.context import ApplicationContext, build_caption
 from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.object_list import (
     DirectListPropertyFilter,
+    DirectMultiValuePropertyFilter,
     DirectValuePropertyFilter,
     ObjectList,
     transform_lower,
@@ -66,10 +72,10 @@ def is_available() -> bool:
 
 def check_availability(ctx: click.Context) -> None:
     """Check availability of graph insights endpoints or raise an exception"""
+    _ = ctx
     if is_available():
         return
-    app: ApplicationContext = ctx.obj
-    raise CmemcError(app, "Graph Insights is not available.")
+    raise CmemcError("Graph Insights is not available.")
 
 
 def get_snapshots(ctx: click.Context) -> list[dict[str, str | bool | list[str]]]:
@@ -81,6 +87,7 @@ def get_snapshots(ctx: click.Context) -> list[dict[str, str | bool | list[str]]]
     return data
 
 
+@suppress_completion_errors
 def complete_snapshot_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:  # noqa: ARG001
     """Provide auto-completion for snapshot Ids"""
     ApplicationContext.set_connection_from_params(ctx.find_root().params)
@@ -131,6 +138,11 @@ snapshot_list = ObjectList(
             property_key="isValid",
             transform=transform_lower,
         ),
+        DirectMultiValuePropertyFilter(
+            name="ids",
+            description="Internal filter for multiple snapshot IDs.",
+            property_key="databaseId",
+        ),
     ],
 )
 
@@ -181,17 +193,21 @@ def list_command(ctx: Context, filter_: tuple[tuple[str, str]], id_only: bool, r
             main_graph = rf"\[missing: {main_graph}]"
         table.append([id_, main_graph, updated, status, is_valid])
 
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
         headers=["ID", "Main Graph", "Updated", "Status", "Valid"],
         sort_column=0,
         cell_processing={1: GraphLink(), 2: TimeAgo()},
-        empty_table_message="No graph insight snapshots found.",
+        caption=build_caption(len(table), "graph insight snapshot", filtered=filtered),
+        empty_table_message="No graph insight snapshots found for these filters."
+        if filtered
+        else "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.argument("snapshot_ids", nargs=-1, type=click.STRING, shell_complete=complete_snapshot_ids)
 @click.option(
     "--filter",
     "filter_",
@@ -203,41 +219,61 @@ def list_command(ctx: Context, filter_: tuple[tuple[str, str]], id_only: bool, r
 @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
+    ctx: Context, snapshot_ids: tuple[str], filter_: tuple[tuple[str, str]], all_: bool
 ) -> None:
-    """Delete a graph insight snapshot.
+    """Delete 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.
+
+    Warning: Snapshots will be deleted without prompting.
+
+    Note: Snapshots can be listed by using the `graph insights list` command.
     """
     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.")
+
+    # Validation: require at least one selection method
+    if not snapshot_ids and not filter_ and not all_:
+        raise click.UsageError(
+            "Either provide at least one snapshot ID, "
+            "use a --filter option, or use the --all flag."
+        )
+
+    if snapshot_ids and (all_ or filter_):
+        raise click.UsageError("Either specify snapshot IDs OR use a --filter or the --all option.")
 
     if all_:
         app.echo_info("Deleting all snapshots ... ", nl=False)
         request(method="DELETE", uri=get_api_url("/snapshot"))
-        app.echo_success("done")
+        app.echo_success("deleted")
         return
 
+    # Get snapshots to delete based on selection method
     filter_to_apply = list(filter_) if filter_ else []
-    if snapshot_id:
-        filter_to_apply.append(("id", snapshot_id))
+    if snapshot_ids:
+        # Use internal multi-value filter for multiple IDs
+        filter_to_apply.append(("ids", ",".join(snapshot_ids)))
     snapshots_to_delete = snapshot_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
 
-    if not snapshots_to_delete and snapshot_id:
-        raise click.ClickException(f"Snapshot ID '{snapshot_id}' does not exist.")
+    if not snapshots_to_delete and snapshot_ids:
+        raise CmemcError(
+            f"Snapshot ID(s) {', '.join(snapshot_ids)} not found. "
+            "Use the 'graph insights list' command to get a list of existing snapshots."
+        )
+
+    if not snapshots_to_delete and not snapshot_ids:
+        raise CmemcError("No snapshots found to delete.")
 
-    if not snapshots_to_delete and not snapshot_id:
-        raise click.ClickException("No snapshots found to delete.")
+    # Avoid double removal as well as sort IDs
+    ids_to_delete = sorted({_["databaseId"] for _ in snapshots_to_delete}, key=lambda v: v.lower())
+    count = len(ids_to_delete)
 
-    for _ in snapshots_to_delete:
-        id_to_delete = _["databaseId"]
-        app.echo_info(f"Deleting snapshot {id_to_delete} ... ", nl=False)
+    # Delete each snapshot
+    for current, id_to_delete in enumerate(ids_to_delete, start=1):
+        current_string = str(current).zfill(len(str(count)))
+        app.echo_info(f"Delete snapshot {current_string}/{count}: {id_to_delete} ... ", nl=False)
         request(method="DELETE", uri=get_api_url(f"/snapshot/{id_to_delete}"))
-        app.echo_success("done")
+        app.echo_success("deleted")
 
 
 def wait_for_snapshot(snapshot_id: str, polling_interval: int) -> None:
@@ -331,10 +367,10 @@ def update_command(  # noqa: PLR0913
         snapshots_to_update = get_snapshots(ctx)
 
     if not snapshots_to_update and snapshot_id:
-        raise click.ClickException(f"Snapshot ID '{snapshot_id}' does not exist.")
+        raise CmemcError(f"Snapshot ID '{snapshot_id}' does not exist.")
 
     if not snapshots_to_update and not snapshot_id:
-        raise click.ClickException("No snapshots found to update.")
+        raise CmemcError("No snapshots found to update.")
 
     for _ in snapshots_to_update:
         id_to_update = _["databaseId"]