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

cmem_cmemc/commands/file.py

@@ -1,10 +1,8 @@
 """Build project file commands for cmemc."""
 
-import re
-
 import click
-from click import ClickException, Context, UsageError
-from cmem.cmempy.config import get_cmem_base_uri
+from click import Context, UsageError
+from click.shell_completion import CompletionItem
 from cmem.cmempy.workspace.projects.resources import get_all_resources
 from cmem.cmempy.workspace.projects.resources.resource import (
     create_resource,
@@ -18,20 +16,56 @@ from cmem.cmempy.workspace.projects.resources.resource 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.object_list import (
+    DirectMultiValuePropertyFilter,
+    DirectValuePropertyFilter,
+    ObjectList,
+    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 FileSize, TimeAgo
 from cmem_cmemc.utils import check_or_select_project, split_task_id, struct_to_table
 
-RESOURCE_FILTER_TYPES = ["project", "regex"]
-RESOURCE_FILTER_TYPES_HIDDEN = ["ids"]
-RESOURCE_FILTER_TEXT = (
-    "Filter file resources based on metadata. "
-    f"First parameter CHOICE can be one of {RESOURCE_FILTER_TYPES!s}"
-    ". The second parameter is based on CHOICE, e.g. a project "
-    "ID or a regular expression string."
+
+def get_resources(ctx: Context) -> list[dict]:  # noqa: ARG001
+    """Get file resources for object list."""
+    _: list[dict] = get_all_resources()
+    return _
+
+
+resource_list = ObjectList(
+    name="file resources",
+    get_objects=get_resources,
+    filters=[
+        DirectValuePropertyFilter(
+            name="project",
+            description="Filter file resources by project ID.",
+            property_key="project",
+            completion_method="values",
+        ),
+        DirectValuePropertyFilter(
+            name="regex",
+            description="Filter by regex matching the resource name.",
+            property_key="name",
+            compare=compare_regex,
+            fixed_completion=[
+                CompletionItem("csv$", help="File resources which name ends with .csv"),
+                CompletionItem(
+                    "2021-10-[0-9][0-9]",
+                    help="File resources which name has a date from 2021-10 in it",
+                ),
+            ],
+            fixed_completion_only=False,
+        ),
+        DirectMultiValuePropertyFilter(
+            name="ids",
+            description="Internal filter for multiple resource IDs.",
+            property_key="id",
+        ),
+    ],
 )
 
 
@@ -60,7 +94,6 @@ def _upload_file_resource(
     exist = resource_exist(project_name=project_id, resource_name=remote_file_name)
     if exist and not replace:
         raise CmemcError(
-            app,
             f"A file resource with the name '{remote_file_name}' already "
             "exists in this project. \n"
             "Please rename the file or use the '--replace' "
@@ -87,25 +120,45 @@ def _upload_file_resource(
     app.echo_success("done")
 
 
-def _get_resources_filtered(
-    resources: list[dict], filter_name: str, filter_value: str | tuple[str, ...]
+def _validate_resource_ids(resource_ids: tuple[str, ...]) -> None:
+    """Validate that all provided resource IDs exist."""
+    if not resource_ids:
+        return
+    all_resources = get_all_resources()
+    all_resource_ids = [_["id"] for _ in all_resources]
+    for resource_id in resource_ids:
+        if resource_id not in all_resource_ids:
+            raise CmemcError(f"Resource {resource_id} not available.")
+
+
+def _get_resources_to_delete(
+    ctx: Context,
+    resource_ids: tuple[str, ...],
+    all_: bool,
+    filter_: tuple[tuple[str, str], ...],
 ) -> list[dict]:
-    """Get file resources but filtered according to name and value."""
-    # check for correct filter names (filter ids is used internally only)
-    if filter_name not in RESOURCE_FILTER_TYPES + RESOURCE_FILTER_TYPES_HIDDEN:
-        raise UsageError(
-            f"{filter_name} is an unknown filter name. " f"Use one of {RESOURCE_FILTER_TYPES}."
-        )
-    # filter by ID list
-    if filter_name == "ids":
-        return [_ for _ in resources if _["id"] in filter_value]
-    # filter by project
-    if filter_name == "project":
-        return [_ for _ in resources if _["project"] == str(filter_value)]
-    # filter by regex
-    if filter_name == "regex":
-        return [_ for _ in resources if re.search(str(filter_value), _["name"])]
-    # return unfiltered list
+    """Get the list of resources to delete based on selection method."""
+    if all_:
+        _: list[dict] = get_all_resources()
+        return _
+
+    # Validate provided IDs exist before proceeding
+    _validate_resource_ids(resource_ids)
+
+    # Build filter list
+    filter_to_apply = list(filter_) if filter_ else []
+
+    # Add IDs if provided (using internal multi-value filter)
+    if resource_ids:
+        filter_to_apply.append(("ids", ",".join(resource_ids)))
+
+    # Apply filters
+    resources = resource_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
+
+    # Validation: ensure we found resources
+    if not resources and not resource_ids:
+        raise CmemcError("No resources found matching the provided filters.")
+
     return resources
 
 
@@ -119,24 +172,21 @@ def _get_resources_filtered(
 )
 @click.option(
     "--filter",
-    "filters_",
+    "filter_",
     multiple=True,
     type=(str, str),
-    shell_complete=completion.resource_list_filter,
-    help=RESOURCE_FILTER_TEXT,
+    shell_complete=resource_list.complete_values,
+    help=resource_list.get_filter_help_text(),
 )
-@click.pass_obj
-def list_command(
-    app: ApplicationContext, raw: bool, id_only: bool, filters_: tuple[tuple[str, str], ...]
-) -> None:
+@click.pass_context
+def list_command(ctx: Context, raw: bool, id_only: bool, filter_: tuple[tuple[str, str]]) -> None:
     """List available file resources.
 
     Outputs a table or a list of file resources.
     """
-    resources = get_all_resources()
-    for _ in filters_:
-        filter_name, filter_value = _
-        resources = _get_resources_filtered(resources, filter_name, filter_value)
+    app: ApplicationContext = ctx.obj
+    resources = resource_list.apply_filters(ctx=ctx, filter_=filter_)
+
     if raw:
         app.echo_info_json(resources)
         return
@@ -155,21 +205,17 @@ def list_command(
         ]
         table.append(row)
 
-    caption = f"{len(table)} files of {get_cmem_base_uri()}"
-    empty_note = "No resources found."
-    if len(filters_) > 0:
-        caption += " (filtered)"
-        empty_note = "No resources found for these filters."
-
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
         headers=headers,
         sort_column=0,
         cell_processing={1: TimeAgo(), 2: FileSize()},
-        caption=caption,
-        empty_table_message=f"{empty_note} "
-        "Use the `dataset create` command to create a new file-based dataset, or "
-        "the `project file upload` command to create only a file resource.",
+        caption=build_caption(len(table), "file resource", filtered=filtered),
+        empty_table_message="No resources found for these filters."
+        if filtered
+        else "No resources found. Use the `dataset create` command to create a new "
+        "file-based dataset, or the `project file upload` command to create only a file resource.",
     )
 
 
@@ -181,23 +227,23 @@ def list_command(
     "--all",
     "all_",
     is_flag=True,
-    help="Delete all resources. " "This is a dangerous option, so use it with care.",
+    help="Delete all resources. This is a dangerous option, so use it with care.",
 )
 @click.option(
     "--filter",
-    "filters_",
+    "filter_",
     multiple=True,
     type=(str, str),
-    shell_complete=completion.resource_list_filter,
-    help=RESOURCE_FILTER_TEXT,
+    shell_complete=resource_list.complete_values,
+    help=resource_list.get_filter_help_text(),
 )
-@click.pass_obj
+@click.pass_context
 def delete_command(
-    app: ApplicationContext,
+    ctx: Context,
     resource_ids: tuple[str, ...],
     force: bool,
     all_: bool,
-    filters_: tuple[tuple[str, str], ...],
+    filter_: tuple[tuple[str, str], ...],
 ) -> None:
     """Delete file resources.
 
@@ -206,25 +252,23 @@ def delete_command(
     on the filter type and value will be deleted; by using --all, which will
     delete all resources.
     """
-    if resource_ids == () and not all_ and filters_ == ():
+    app: ApplicationContext = ctx.obj
+
+    # Validation: require at least one selection method
+    if not resource_ids and not all_ and not filter_:
         raise UsageError(
             "Either specify at least one resource ID or use the --all or "
             "--filter options to specify resources for deletion."
         )
 
-    resources = get_all_resources()
-    if len(resource_ids) > 0:
-        for resource_id in resource_ids:
-            if resource_id not in [_["id"] for _ in resources]:
-                raise ClickException(f"Resource {resource_id} not available.")
-        # "filter" by id
-        resources = _get_resources_filtered(resources, "ids", resource_ids)
-    for _ in filters_:
-        resources = _get_resources_filtered(resources, _[0], _[1])
-
-    # avoid double removal as well as sort IDs
-    processed_ids = sorted({_["id"] for _ in resources}, key=lambda v: v.lower())
+    # Get resources to delete based on selection method
+    resources_to_delete = _get_resources_to_delete(ctx, resource_ids, all_, filter_)
+
+    # Avoid double removal as well as sort IDs
+    processed_ids = sorted({_["id"] for _ in resources_to_delete}, key=lambda v: v.lower())
     count = len(processed_ids)
+
+    # Delete each resource
     for current, resource_id in enumerate(processed_ids, start=1):
         current_string = str(current).zfill(len(str(count)))
         app.echo_info(f"Delete resource {current_string}/{count}: {resource_id} ... ", nl=False)
@@ -310,7 +354,7 @@ def download_command(
                 for chunk in response.iter_content(chunk_size=8192):
                     resource_file.write(chunk)
             app.echo_success("done")
-        except (OSError, ClickException) as error:
+        except (OSError, CmemcError) as error:
             app.echo_error(f"failed: {error!s}")
             continue