cmem-cmemc 25.5.0rc1__py3-none-any.whl → 26.1.0rc1__py3-none-any.whl

cmem_cmemc/commands/project.py

@@ -1,4 +1,4 @@
-"""Build (DataIntegration) project commands for the cmem command line interface."""
+"""Enhanced project.py with filtering capabilities."""
 
 import os
 import pathlib
@@ -7,7 +7,7 @@ import tempfile
 from zipfile import ZipFile
 
 import click
-from click import ClickException, UsageError
+from click import Context, UsageError
 from cmem.cmempy.config import get_di_api_endpoint
 from cmem.cmempy.plugins.marshalling import (
     get_extension_by_plugin,
@@ -32,10 +32,83 @@ from jinja2 import Template
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
+from cmem_cmemc.commands.file import file
 from cmem_cmemc.commands.variable import variable
-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 (
+    DirectListPropertyFilter,
+    DirectValuePropertyFilter,
+    Filter,
+    MultiFieldPropertyFilter,
+    ObjectList,
+)
 from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.smart_path import SmartPath as Path
+from cmem_cmemc.string_processor import ProjectLink, TimeAgo
+
+
+def get_projects_for_list(ctx: Context) -> list[dict]:
+    """Get projects for object list, transforming structure for filtering."""
+    _ = ctx
+    # Transform the project structure to flatten metadata for easier filtering
+    transformed = []
+    for _ in get_projects():
+        transformed_project = {
+            "name": _["name"],
+            "label": _["metaData"].get("label", ""),
+            "description": _["metaData"].get("description", ""),
+            "tags": _["metaData"].get("tags", []),
+            "modified": _["metaData"].get("modified", ""),
+            "lastModifiedByUser": _["metaData"].get("lastModifiedByUser", ""),
+            # Keep original for reference
+            "_original": _,
+        }
+        transformed.append(transformed_project)
+    return transformed
+
+
+def transform_tag_uris_to_labels(ctx: Filter, value: list) -> list:
+    """Transform tag URIs to their label equivalents for filtering.
+
+    Extracts the label portion from URIs like 'urn:silkframework:tag:mytag'
+    """
+    import urllib.parse
+
+    _ = ctx
+    labels = []
+    for tag_uri in value:
+        if isinstance(tag_uri, str) and ":" in tag_uri:
+            label = tag_uri.split(":")[-1]
+            label = urllib.parse.unquote(label)
+            labels.append(label)
+    return labels
+
+
+# Create the project list object with filters
+project_list = ObjectList(
+    name="projects",
+    get_objects=get_projects_for_list,
+    filters=[
+        DirectValuePropertyFilter(
+            name="id",
+            description="Filter by project ID (name).",
+            property_key="name",
+            completion_method="values",
+        ),
+        MultiFieldPropertyFilter(
+            name="regex",
+            description="Filter by regex matching project name, label, or description.",
+            property_keys=["name", "label", "description"],
+        ),
+        DirectListPropertyFilter(
+            name="tag",
+            description="Filter by tag label.",
+            property_key="tags",
+            transform=transform_tag_uris_to_labels,
+        ),
+    ],
+)
 
 
 def _validate_projects_to_process(project_ids: tuple[str], all_flag: bool) -> list[str]:
@@ -59,7 +132,7 @@ def _validate_projects_to_process(project_ids: tuple[str], all_flag: bool) -> li
     # test if one of the projects does NOT exist
     for _ in projects_to_process:
         if _ not in all_projects:
-            raise ClickException(f"Project {_} does not exist.")
+            raise CmemcError(f"Project {_} does not exist.")
     return projects_to_process
 
 
@@ -104,13 +177,21 @@ def open_command(app: ApplicationContext, project_ids: tuple[str]) -> None:
     projects = get_projects()
     for _ in project_ids:
         if _ not in (p["name"] for p in projects):
-            raise ClickException(f"Project '{_}' not found.")
+            raise CmemcError(f"Project '{_}' not found.")
         open_project_uri = f"{get_di_api_endpoint()}/workbench/projects/{_}"
         app.echo_debug(f"Open {_}: {open_project_uri}")
         click.launch(open_project_uri)
 
 
 @click.command(cls=CmemcCommand, name="list")
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    multiple=True,
+    shell_complete=project_list.complete_values,
+    help=project_list.get_filter_help_text(),
+)
 @click.option("--raw", is_flag=True, help="Outputs raw JSON.")
 @click.option(
     "--id-only",
@@ -118,14 +199,21 @@ def open_command(app: ApplicationContext, project_ids: tuple[str]) -> None:
     help="Lists only project identifier and no labels or other "
     "metadata. This is useful for piping the IDs into other commands.",
 )
-@click.pass_obj
-def list_command(app: ApplicationContext, raw: bool, id_only: bool) -> None:
+@click.pass_context
+def list_command(ctx: Context, filter_: tuple[tuple[str, str]], raw: bool, id_only: bool) -> None:
     """List available projects.
 
     Outputs a list of project IDs which can be used as reference for
     the project create, delete, export and import commands.
     """
-    projects = get_projects()
+    app = ctx.obj
+
+    # Apply filters
+    filtered_projects = project_list.apply_filters(ctx=ctx, filter_=filter_)
+
+    # Extract original project data for output
+    projects = [p["_original"] for p in filtered_projects]
+
     if raw:
         app.echo_info_json(projects)
         return
@@ -133,20 +221,33 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool) -> None:
         for _ in sorted(projects, key=lambda k: k["name"].lower()):
             app.echo_result(_["name"])
         return
+
     # output a user table
+    # Create a dict mapping project names to project data for the ProjectLink processor
+    projects_dict = {_["name"]: _ for _ in projects}
     table = []
     for _ in projects:
+        # Extract modified timestamp from nested metaData
+        metadata = _.get("metaData", {})
+        modified = metadata.get("modified", "")
+
         row = [
             _["name"],
-            _["metaData"]["label"],
+            modified,
+            _["name"],  # Pass project ID to be processed by ProjectLink
         ]
         table.append(row)
+
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
-        headers=["Project ID", "Label"],
+        headers=["Project ID", "Modified", "Label"],
         sort_column=1,
-        empty_table_message="No projects found. "
-        "Use the `project create` command to create a new project.",
+        caption=build_caption(len(table), "project", filtered=filtered),
+        empty_table_message="No projects found for these filters."
+        if filtered
+        else "No projects found. Use the `project create` command to create a new project.",
+        cell_processing={1: TimeAgo(), 2: ProjectLink(projects=projects_dict)},
     )
 
 
@@ -158,9 +259,22 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool) -> None:
     is_flag=True,
     help="Delete all projects. " "This is a dangerous option, so use it with care.",
 )
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    multiple=True,
+    shell_complete=project_list.complete_values,
+    help=project_list.get_filter_help_text(),
+)
 @click.argument("project_ids", nargs=-1, type=click.STRING, shell_complete=completion.project_ids)
-@click.pass_obj
-def delete_command(app: ApplicationContext, all_: bool, project_ids: tuple[str]) -> None:
+@click.pass_context
+def delete_command(
+    ctx: Context,
+    all_: bool,
+    filter_: tuple[tuple[str, str]],
+    project_ids: tuple[str],
+) -> None:
     """Delete projects.
 
     This command deletes existing data integration projects from Corporate
@@ -170,12 +284,33 @@ def delete_command(app: ApplicationContext, all_: bool, project_ids: tuple[str])
 
     Note: Projects can be listed with the `project list` command.
     """
-    projects_to_delete = _validate_projects_to_process(project_ids=project_ids, all_flag=all_)
+    app = ctx.obj
+
+    if project_ids == () and not all_ and not filter_:
+        raise UsageError(
+            "Either specify at least one project ID"
+            " or use a --filter option,"
+            " or use the --all option to delete all projects."
+        )
+
+    if project_ids and (all_ or filter_):
+        raise UsageError("Either specify a project ID OR use a --filter or the --all option.")
+
+    if all_ or filter_:
+        # in case --all or --filter is given, a list of projects is fetched
+        project_ids = []
+        filtered_projects = project_list.apply_filters(ctx=ctx, filter_=filter_)
+        for _ in filtered_projects:
+            project_ids.append(_["name"])
+
+    # Avoid double removal as well as sort project IDs
+    projects_to_delete = sorted(set(project_ids), key=lambda v: v.lower())
     count = len(projects_to_delete)
     for current, project_id in enumerate(projects_to_delete, start=1):
-        app.echo_info(f"Delete project {current}/{count}: {project_id} ... ", nl=False)
+        current_string = str(current).zfill(len(str(count)))
+        app.echo_info(f"Delete project {current_string}/{count}: {project_id} ... ", nl=False)
         delete_project(project_id)
-        app.echo_success("done")
+        app.echo_success("deleted")
 
 
 @click.command(cls=CmemcCommand, name="create")
@@ -229,7 +364,7 @@ def create_command(
     all_projects = [_["name"] for _ in get_projects()]
     for project_id in project_ids:
         if project_id in all_projects:
-            raise ClickException(f"Project {project_id} already exists.")
+            raise CmemcError(f"Project {project_id} already exists.")
 
     if from_transformation:
         transformation_parts = from_transformation.split(":")
@@ -280,7 +415,6 @@ def create_command(
         current = current + 1
 
 
-# pylint: disable=too-many-arguments,too-many-locals
 @click.command(cls=CmemcCommand, name="export")
 @click.option(
     "-a",
@@ -480,12 +614,12 @@ def import_command(
 
     all_projects = get_projects()
     if project_id and not replace and project_id in ([_["name"] for _ in all_projects]):
-        raise ClickException(f"Project {project_id} is already there.")
+        raise CmemcError(f"Project {project_id} is already there.")
 
     if Path(path).is_dir():
         if not (Path(path) / "config.xml").is_file():
             # fail early if directory is not an export
-            raise ClickException(f"Directory {path} seems not to be a export directory.")
+            raise CmemcError(f"Directory {path} seems not to be a export directory.")
 
         app.echo_info(f"Import directory {path} to project {project_id} ... ", nl=False)
         # in case of a directory, we zip it to a temp file
@@ -512,7 +646,7 @@ def import_command(
     # Remove the temporary file
     pathlib.Path.unlink(pathlib.Path(uploaded_file))
     if "errorMessage" in validation_response:
-        raise ClickException(validation_response["errorMessage"])
+        raise CmemcError(validation_response["errorMessage"])
     import_id = validation_response["projectImportId"]
 
     # get project_id from response if not given as parameter
@@ -584,3 +718,4 @@ project.add_command(delete_command)
 project.add_command(create_command)
 project.add_command(reload_command)
 project.add_command(variable)
+project.add_command(file)

cmem_cmemc/commands/python.py

@@ -5,7 +5,7 @@ from dataclasses import asdict
 from re import match
 
 import click
-from click import ClickException, UsageError
+from click import UsageError
 from cmem.cmempy.workspace.python import (
     install_package_by_file,
     install_package_by_name,
@@ -18,7 +18,8 @@ from cmem.cmempy.workspace.python import (
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.context import ApplicationContext, build_caption
+from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.utils import get_published_packages
 
@@ -60,7 +61,7 @@ def install_command(app: ApplicationContext, package: str) -> None:
         install_response = install_package_by_file(package_file=package)
     except FileNotFoundError as not_found_error:
         if not _looks_like_a_package(package):
-            raise ClickException(
+            raise CmemcError(
                 f"{package} does not look like a package name or requirement "
                 "string, and a file with this name also does not exists."
             ) from not_found_error
@@ -187,6 +188,7 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool, available: b
             table_published,
             headers=["Name", "Version", "Published", "Description"],
             sort_column=0,
+            caption=build_caption(len(table_published), "available python package"),
             empty_table_message="No available python packages found.",
         )
         return
@@ -206,7 +208,8 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool, available: b
         table_installed,
         headers=["Name", "Version"],
         sort_column=0,
-        empty_table_message="No installed python packages found."
+        caption=build_caption(len(table_installed), "installed python package"),
+        empty_table_message="No installed python packages found. "
         "Most likely, this is due to a wrong deployment.",
     )
 
@@ -267,7 +270,8 @@ def list_plugins_command(
         table,
         headers=["ID", "Package ID", "Type", "Label"],
         sort_column=0,
-        empty_table_message="No plugin plugins found. "
+        caption=build_caption(len(table), "python plugin"),
+        empty_table_message="No plugins found. "
         "Use the `admin workspace python install` command to install python packages with plugins.",
     )
     if "error" in raw_output:

cmem_cmemc/commands/query.py

@@ -11,7 +11,6 @@ from uuid import uuid4
 
 import click
 from click.shell_completion import CompletionItem
-from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.queries import (
     QueryCatalog,
     SparqlQuery,
@@ -23,17 +22,20 @@ from requests import HTTPError
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-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 (
     DirectListPropertyFilter,
     DirectValuePropertyFilter,
     Filter,
+    MultiFieldPropertyFilter,
     ObjectList,
     compare_int_greater_than,
     compare_regex,
 )
 from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.smart_path import SmartPath as Path
+from cmem_cmemc.string_processor import QueryLink
 from cmem_cmemc.utils import extract_error_message, struct_to_table
 
 QUERY_FILTER_TYPES = sorted(["graph", "status", "slower-than", "type", "regex", "trace-id", "user"])
@@ -48,7 +50,6 @@ QUERY_FILTER_HELP_TEXT = (
 class ReplayStatistics:
     """Capture and calculate statistics of a query replay command run."""
 
-    # pylint: disable=too-many-instance-attributes
     run_id: str
     query_minimum: int | None
     query_maximum: int | None
@@ -91,14 +92,12 @@ class ReplayStatistics:
                 iri = query_["iri"]
                 catalog_entry = self.catalog.get_query(iri)
                 if catalog_entry is None:
-                    raise click.ClickException(f"measure_query - query {iri} is not in catalog.")
+                    raise CmemcError(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 click.ClickException(
-                "measure_query - given input dict has no queryString key."
-            ) from error
+            raise CmemcError("measure_query - given input dict has no queryString key.") from error
 
     def _update_statistic_on_success(self, duration: int) -> None:
         """Update statistics and counters."""
@@ -310,6 +309,70 @@ query_status_list = ObjectList(
 )
 
 
+def get_catalog_queries(ctx: click.Context) -> list[dict]:
+    """Get queries from catalog for object list filtering.
+
+    Converts SparqlQuery objects to dictionaries with standardized keys.
+    Requires 'catalog_graph' parameter in context.
+    """
+    catalog_graph = ctx.params.get("catalog_graph", "https://ns.eccenca.com/data/queries/")
+    queries_items = QueryCatalog(graph=catalog_graph).get_queries().items()
+
+    result = []
+    for _, sparql_query in queries_items:
+        query_dict = {
+            "id": sparql_query.short_url,
+            "url": sparql_query.url,
+            "short_url": sparql_query.short_url,
+            "type": sparql_query.query_type,
+            "label": sparql_query.label,
+            "text": sparql_query.text,
+            "placeholders": list(sparql_query.get_placeholder_keys()),
+        }
+        result.append(query_dict)
+
+    return result
+
+
+query_catalog_list = ObjectList(
+    name="catalog queries",
+    get_objects=get_catalog_queries,
+    filters=[
+        DirectValuePropertyFilter(
+            name="id",
+            description="Filter queries by ID/URI pattern (regex match on short_url).",
+            property_key="short_url",
+            compare=compare_regex,
+            completion_method="values",
+        ),
+        DirectValuePropertyFilter(
+            name="type",
+            description="Filter queries by type (e.g., SELECT, CONSTRUCT, UPDATE).",
+            property_key="type",
+            fixed_completion=[
+                CompletionItem("SELECT", help="List only SELECT queries."),
+                CompletionItem("CONSTRUCT", help="List only CONSTRUCT queries."),
+                CompletionItem("ASK", help="List only ASK queries."),
+                CompletionItem("DESCRIBE", help="List only DESCRIBE queries."),
+                CompletionItem("UPDATE", help="List only UPDATE queries."),
+            ],
+        ),
+        DirectListPropertyFilter(
+            name="placeholder",
+            description="Filter queries that contain a specific placeholder key.",
+            property_key="placeholders",
+        ),
+        MultiFieldPropertyFilter(
+            name="regex",
+            description="Filter queries by regex pattern (searches in text and label).",
+            property_keys=["text", "label"],
+            compare=compare_regex,
+            match_mode="any",
+        ),
+    ],
+)
+
+
 def _output_query_status_details(app: ApplicationContext, status_dict: dict) -> None:
     """Output key/value table as well as query string of a query.
 
@@ -343,35 +406,59 @@ def _output_query_status_details(app: ApplicationContext, status_dict: dict) ->
     help="Lists only query identifier and no labels or other metadata. "
     "This is useful for piping the ids into other cmemc commands.",
 )
-@click.pass_obj
-def list_command(app: ApplicationContext, catalog_graph: str, id_only: bool) -> None:
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    multiple=True,
+    help=query_catalog_list.get_filter_help_text(),
+    shell_complete=query_catalog_list.complete_values,
+)
+@click.pass_context
+def list_command(
+    ctx: click.Context, catalog_graph: str, id_only: bool, filter_: tuple[tuple[str, str]]
+) -> None:
     """List available queries from the catalog.
 
     Outputs a list of query URIs which can be used as reference for
     the query execute command.
+
+    You can filter queries based on ID, type, placeholder, or regex pattern.
     """
-    queries = QueryCatalog(graph=catalog_graph).get_queries().items()
+    app: ApplicationContext = ctx.obj
+
+    # Apply filters to get query dictionaries
+    query_dicts = query_catalog_list.apply_filters(ctx=ctx, filter_=filter_)
+
     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()):
-            app.echo_info(sparql_query.short_url)
+        # Sort and output only IDs
+        for query_dict in sorted(query_dicts, key=lambda k: k["short_url"].lower()):
+            app.echo_info(query_dict["short_url"])
     else:
+        # Create a dict for QueryLink processor - need to fetch all queries for link processing
+        all_queries_items = QueryCatalog(graph=catalog_graph).get_queries().items()
+        queries_dict = {sparql_query.url: sparql_query for _, sparql_query in all_queries_items}
+
         table = []
-        for _, sparql_query in queries:
+        for query_dict in query_dicts:
             row = [
-                sparql_query.short_url,
-                sparql_query.query_type,
-                ",".join(sparql_query.get_placeholder_keys()),
-                sparql_query.label,
+                query_dict["short_url"],
+                query_dict["type"],
+                ",".join(query_dict["placeholders"]),
+                query_dict["url"],  # Use URL instead of label for processing
             ]
             table.append(row)
+
+        filtered = len(filter_) > 0
         app.echo_info_table(
             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()})",
+            cell_processing={3: QueryLink(catalog_graph=catalog_graph, queries=queries_dict)},
+            caption=build_caption(len(table), "query", filtered=filtered, plural="queries"),
+            empty_table_message="No queries found for these filters."
+            if filtered
+            else f"There are no query available in the selected catalog ({catalog_graph}).",
         )
 
 
@@ -462,7 +549,6 @@ def execute_command(  # noqa: PLR0913
     parameters for each query in a chain, run cmemc multiple times and use
     the logical operators && and || of your shell instead.
     """
-    # pylint: disable=too-many-arguments
     placeholder = {}
     for key, value in parameter:
         if key in placeholder:
@@ -629,7 +715,15 @@ def status_command(
             query_string = query_string[0:max_query_string_width] + "…"
         row = [query_id, query_execution_time, query_string]
         table.append(row)
-    app.echo_info_table(table, headers=["Query ID", "Time", "Query String"])
+    filtered = len(filter_) > 0
+    app.echo_info_table(
+        table,
+        headers=["Query ID", "Time", "Query String"],
+        caption=build_caption(len(table), "query", filtered=filtered, plural="queries"),
+        empty_table_message="No queries found for these filters."
+        if filtered
+        else "No queries found.",
+    )
 
 
 @click.command(cls=CmemcCommand, name="replay")
@@ -706,9 +800,9 @@ def replay_command(  # noqa: PLR0913
         with Path(replay_file).open(encoding="utf8") as _:
             input_queries = load(_)
     except JSONDecodeError as error:
-        raise click.ClickException(f"File {replay_file} is not a valid JSON document.") from error
+        raise CmemcError(f"File {replay_file} is not a valid JSON document.") from error
     if len(input_queries) == 0:
-        raise click.ClickException(f"File {replay_file} contains no queries.")
+        raise CmemcError(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/commands/scheduler.py

@@ -3,7 +3,7 @@
 from typing import Any
 
 import click
-from click import Argument, ClickException, UsageError
+from click import Argument, UsageError
 from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.workflow.workflow import get_workflow_editor_uri
 from cmem.cmempy.workspace.search import list_items
@@ -12,7 +12,8 @@ from cmem.cmempy.workspace.tasks import get_task, patch_parameter
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.context import ApplicationContext, build_caption
+from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.utils import split_task_id, struct_to_table
 
 
@@ -68,7 +69,7 @@ def open_command(app: ApplicationContext, scheduler_ids: tuple[str, ...], workfl
     all_scheduler_ids = [s["projectId"] + ":" + s["id"] for s in schedulers]
     for scheduler_id in scheduler_ids:
         if scheduler_id not in all_scheduler_ids:
-            raise ClickException(f"Scheduler '{scheduler_id}' not found.")
+            raise CmemcError(f"Scheduler '{scheduler_id}' not found.")
     for scheduler_id in scheduler_ids:
         for _ in schedulers:
             current_id = _["projectId"] + ":" + _["id"]
@@ -120,7 +121,8 @@ def list_command(app: ApplicationContext, raw: bool, id_only: bool) -> None:
         table,
         headers=headers,
         sort_column=1,
-        empty_table_message="Now workflow scheduler found. "
+        caption=build_caption(len(table), "workflow scheduler"),
+        empty_table_message="No workflow scheduler found. "
         "Open a project in the web interface and create a new workflow scheduler there.",
     )
 

cmem_cmemc/commands/store.py

@@ -15,13 +15,14 @@ from jinja2 import Template
 
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-from cmem_cmemc.completion import file_list
+from cmem_cmemc.completion import file_list, suppress_completion_errors
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.smart_path import SmartPath as Path
 from cmem_cmemc.utils import validate_zipfile
 
 
+@suppress_completion_errors
 def complete_store_backup_files(
     ctx: Context,  # noqa: ARG001
     param: Argument,  # noqa: ARG001