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

cmem_cmemc/commands/acl.py

@@ -33,6 +33,7 @@ from cmem_cmemc.smart_path import SmartPath as Path
 from cmem_cmemc.utils import (
     convert_iri_to_qname,
     convert_qname_to_iri,
+    get_objects_to_delete,
     get_query_text,
     struct_to_table,
 )
@@ -172,53 +173,6 @@ acl_list = ObjectList(
 )
 
 
-def _validate_acl_ids(access_condition_ids: tuple[str, ...]) -> None:
-    """Validate that all provided access condition IDs exist."""
-    if not access_condition_ids:
-        return
-    all_acls = fetch_all_acls()
-    all_iris = {acl["iri"] for acl in all_acls}
-    for acl_id in access_condition_ids:
-        iri = convert_qname_to_iri(qname=acl_id, default_ns=NS_ACL)
-        if iri not in all_iris:
-            raise click.ClickException(
-                f"Access condition {acl_id} not available. Use the 'admin acl list' "
-                "command to get a list of existing access conditions."
-            )
-
-
-def _get_acls_to_delete(
-    ctx: Context,
-    access_condition_ids: tuple[str, ...],
-    all_: bool,
-    filter_: tuple[tuple[str, str], ...],
-) -> list[dict]:
-    """Get the list of access conditions to delete based on selection method."""
-    if all_:
-        # Get all access conditions
-        return fetch_all_acls()  # type: ignore[no-any-return]
-
-    # Validate provided IDs exist before proceeding
-    _validate_acl_ids(access_condition_ids)
-
-    # Build filter list
-    filter_to_apply = list(filter_) if filter_ else []
-
-    # Add IDs if provided (using internal multi-value filter)
-    if access_condition_ids:
-        iris = [convert_qname_to_iri(qname=_, default_ns=NS_ACL) for _ in access_condition_ids]
-        filter_to_apply.append(("ids", ",".join(iris)))
-
-    # Apply filters
-    acls = acl_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
-
-    # Validation: ensure we found access conditions
-    if not acls and not access_condition_ids:
-        raise click.ClickException("No access conditions found matching the provided filters.")
-
-    return acls
-
-
 @click.command(cls=CmemcCommand, name="list")
 @click.option("--raw", is_flag=True, help="Outputs raw JSON.")
 @click.option(
@@ -645,8 +599,23 @@ def delete_command(
             "Either specify access condition IDs OR use a --filter or the --all option."
         )
 
+    # Convert qnames to IRIs for filtering
+    iris = [convert_qname_to_iri(qname=_, default_ns=NS_ACL) for _ in access_condition_ids]
+
     # Get access conditions to delete based on selection method
-    acls_to_delete = _get_acls_to_delete(ctx, access_condition_ids, all_, filter_)
+    acls_to_delete = get_objects_to_delete(
+        ctx=ctx,
+        ids=tuple(iris),
+        all_=all_,
+        filter_=filter_,
+        object_list=acl_list,
+        get_all_objects=fetch_all_acls,
+        extract_id=lambda x: x["iri"],
+        error_message_template=(
+            "Access condition {} not available. "
+            "Use the 'admin acl list' command to get a list of existing access conditions."
+        ),
+    )
 
     # Avoid double removal as well as sort IRIs
     iris_to_delete = sorted({acl["iri"] for acl in acls_to_delete}, key=lambda v: v.lower())

cmem_cmemc/commands/dataset.py

@@ -38,18 +38,26 @@ from cmem_cmemc.parameter_types.path import ClickSmartPath
 from cmem_cmemc.smart_path import SmartPath as Path
 from cmem_cmemc.string_processor import DatasetLink, DatasetTypeLink
 from cmem_cmemc.title_helper import DatasetTypeTitleHelper, ProjectTitleHelper
-from cmem_cmemc.utils import check_or_select_project, struct_to_table
+from cmem_cmemc.utils import check_or_select_project, get_objects_to_delete, struct_to_table
 
 
-def get_datasets(ctx: Context) -> list[dict]:
-    """Get datasets for object list."""
+def get_datasets_for_list(ctx: Context) -> list[dict]:
+    """Get datasets for object list, transforming structure for filtering."""
     _ = ctx
-    return list_items(item_type="dataset")["results"]  # type: ignore[no-any-return]
+    # Transform the dataset structure to add combined ID for easier filtering
+    transformed = []
+    for dataset in list_items(item_type="dataset")["results"]:
+        transformed_dataset = {
+            **dataset,  # Keep all original fields
+            "combinedId": f"{dataset['projectId']}:{dataset['id']}",  # Add combined ID
+        }
+        transformed.append(transformed_dataset)
+    return transformed
 
 
 dataset_list = ObjectList(
     name="datasets",
-    get_objects=get_datasets,
+    get_objects=get_datasets_for_list,
     filters=[
         DirectValuePropertyFilter(
             name="project",
@@ -84,6 +92,11 @@ dataset_list = ObjectList(
             description="Internal filter for multiple dataset IDs.",
             property_key="id",
         ),
+        DirectMultiValuePropertyFilter(
+            name="combinedIds",
+            description="Internal filter for multiple combined dataset IDs (projectId:datasetId).",
+            property_key="combinedId",
+        ),
     ],
 )
 
@@ -111,57 +124,6 @@ def _validate_and_split_dataset_id(dataset_id: str) -> tuple[str, str]:
     return project_part, dataset_part
 
 
-def _validate_dataset_ids(dataset_ids: tuple[str, ...]) -> None:
-    """Validate that all provided dataset IDs exist."""
-    if not dataset_ids:
-        return
-    all_datasets = list_items(item_type="dataset")["results"]
-    all_dataset_ids = [_["projectId"] + ":" + _["id"] for _ in all_datasets]
-    for dataset_id in dataset_ids:
-        if dataset_id not in all_dataset_ids:
-            raise CmemcError(
-                f"Dataset {dataset_id} not available. Use the 'dataset list' "
-                "command to get a list of existing datasets."
-            )
-
-
-def _get_datasets_to_delete(
-    ctx: Context,
-    dataset_ids: tuple[str, ...],
-    all_: bool,
-    filter_: tuple[tuple[str, str], ...],
-) -> list[str]:
-    """Get the list of dataset IDs to delete based on selection method."""
-    if all_:
-        # Get all datasets
-        datasets = list_items(item_type="dataset")["results"]
-        return [_["projectId"] + ":" + _["id"] for _ in datasets]
-
-    # Validate provided IDs exist before proceeding
-    _validate_dataset_ids(dataset_ids)
-
-    # Build filter list
-    filter_to_apply = list(filter_) if filter_ else []
-
-    # Add IDs if provided (using internal multi-value filter)
-    if dataset_ids:
-        # Extract just the dataset ID part (after the colon) for filtering
-        dataset_id_parts = [_.split(":")[1] for _ in dataset_ids]
-        filter_to_apply.append(("ids", ",".join(dataset_id_parts)))
-
-    # Apply filters
-    datasets = dataset_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
-
-    # Build full dataset IDs
-    result = [_["projectId"] + ":" + _["id"] for _ in datasets]
-
-    # Validation: ensure we found datasets
-    if not result and not dataset_ids:
-        raise CmemcError("No datasets found matching the provided filters.")
-
-    return result
-
-
 def _post_file_resource(
     app: ApplicationContext,
     project_id: str,
@@ -500,10 +462,23 @@ def delete_command(
         raise UsageError("Either specify a dataset ID OR" " use a --filter or the --all option.")
 
     # Get datasets to delete based on selection method
-    datasets_to_delete = _get_datasets_to_delete(ctx, dataset_ids, all_, filter_)
+    datasets_data = get_objects_to_delete(
+        ctx=ctx,
+        ids=dataset_ids,
+        all_=all_,
+        filter_=filter_,
+        object_list=dataset_list,
+        get_all_objects=lambda: get_datasets_for_list(ctx),
+        extract_id=lambda x: x["combinedId"],
+        error_message_template=(
+            "Dataset {} not available. "
+            "Use the 'dataset list' command to get a list of existing datasets."
+        ),
+        id_filter_name="combinedIds",
+    )
 
     # Avoid double removal as well as sort IDs
-    processed_ids = sorted(set(datasets_to_delete), key=lambda v: v.lower())
+    processed_ids = sorted({_["combinedId"] for _ in datasets_data}, key=lambda v: v.lower())
     count = len(processed_ids)
 
     # Delete each dataset

cmem_cmemc/commands/file.py

@@ -27,7 +27,12 @@ from cmem_cmemc.object_list import (
 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
+from cmem_cmemc.utils import (
+    check_or_select_project,
+    get_objects_to_delete,
+    split_task_id,
+    struct_to_table,
+)
 
 
 def get_resources(ctx: Context) -> list[dict]:  # noqa: ARG001
@@ -120,48 +125,6 @@ def _upload_file_resource(
     app.echo_success("done")
 
 
-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 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
-
-
 @click.command(cls=CmemcCommand, name="list")
 @click.option("--raw", is_flag=True, help="Outputs raw JSON.")
 @click.option(
@@ -261,8 +224,16 @@ def delete_command(
             "--filter options to specify resources for deletion."
         )
 
-    # Get resources to delete based on selection method
-    resources_to_delete = _get_resources_to_delete(ctx, resource_ids, all_, filter_)
+    resources_to_delete = get_objects_to_delete(
+        ctx=ctx,
+        ids=resource_ids,
+        all_=all_,
+        filter_=filter_,
+        object_list=resource_list,
+        get_all_objects=get_all_resources,
+        extract_id=lambda x: x["id"],
+        error_message_template="Resource {} not available.",
+    )
 
     # Avoid double removal as well as sort IDs
     processed_ids = sorted({_["id"] for _ in resources_to_delete}, key=lambda v: v.lower())

cmem_cmemc/commands/graph.py

@@ -47,6 +47,7 @@ from cmem_cmemc.utils import (
     convert_uri_to_filename,
     get_graphs,
     get_graphs_as_dict,
+    get_objects_to_delete,
     iri_to_qname,
     read_rdf_graph_files,
     tuple_to_list,
@@ -231,49 +232,6 @@ 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]:
@@ -919,8 +877,18 @@ def delete_command(  # noqa: PLR0913
             "--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_)
+    # Get base list of graphs to delete (only writeable graphs)
+    graphs_to_delete = get_objects_to_delete(
+        ctx=ctx,
+        ids=iris,
+        all_=all_,
+        filter_=filter_,
+        object_list=graph_delete_obj,
+        get_all_objects=lambda: get_graphs(writeable=True, readonly=False),
+        extract_id=lambda x: x["iri"],
+        error_message_template=UNKNOWN_GRAPH_ERROR,
+        id_filter_name="iris",
+    )
     iris_to_delete = [g["iri"] for g in graphs_to_delete]
 
     # Handle --include-imports flag

cmem_cmemc/commands/graph_insights.py

@@ -27,7 +27,11 @@ from cmem_cmemc.object_list import (
     transform_lower,
 )
 from cmem_cmemc.string_processor import GraphLink, TimeAgo
-from cmem_cmemc.utils import get_graphs_as_dict, struct_to_table
+from cmem_cmemc.utils import (
+    get_graphs_as_dict,
+    get_objects_to_delete,
+    struct_to_table,
+)
 
 
 def get_api_url(path: str = "") -> str:
@@ -242,6 +246,7 @@ def delete_command(
     if snapshot_ids and (all_ or filter_):
         raise click.UsageError("Either specify snapshot IDs OR use a --filter or the --all option.")
 
+    # Special case: --all uses bulk DELETE endpoint
     if all_:
         app.echo_info("Deleting all snapshots ... ", nl=False)
         request(method="DELETE", uri=get_api_url("/snapshot"))
@@ -249,20 +254,19 @@ def delete_command(
         return
 
     # Get snapshots to delete based on selection method
-    filter_to_apply = list(filter_) if filter_ else []
-    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_ids:
-        raise CmemcError(
-            f"Snapshot ID(s) {', '.join(snapshot_ids)} not found. "
+    snapshots_to_delete = get_objects_to_delete(
+        ctx=ctx,
+        ids=snapshot_ids,
+        all_=False,  # Already handled above
+        filter_=filter_,
+        object_list=snapshot_list,
+        get_all_objects=lambda: get_snapshots(ctx),
+        extract_id=lambda x: x["databaseId"],
+        error_message_template=(
+            "Snapshot {} 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.")
+        ),
+    )
 
     # Avoid double removal as well as sort IDs
     ids_to_delete = sorted({_["databaseId"] for _ in snapshots_to_delete}, key=lambda v: v.lower())

cmem_cmemc/commands/package.py

@@ -8,12 +8,12 @@ import click
 import requests
 from click.shell_completion import CompletionItem
 from cmem_client.client import Client
+from cmem_client.components.marketplace import Marketplace
 from cmem_client.repositories.marketplace_packages import (
     MarketplacePackagesExportConfig,
     MarketplacePackagesImportConfig,
     MarketplacePackagesRepository,
 )
-from eccenca_marketplace_client.manifests import AbstractPackageManifest, ManifestMetadata
 from eccenca_marketplace_client.package_version import PackageVersion
 from pydantic_extra_types.semantic_version import SemanticVersion
 
@@ -93,53 +93,18 @@ def _complete_installed_package_ids(
     return completion.finalize_completion(candidates=candidates, incomplete=incomplete)
 
 
-@click.command(cls=CmemcCommand, name="create")
-@click.argument("package_id", required=True)
-@click.option(
-    "--name",
-    type=click.STRING,
-    help=ManifestMetadata.model_fields.get("name").description + " Defaults to package ID.",
-)
-@click.option(
-    "--version",
-    type=click.STRING,
-    default="0.0.1",
-    show_default=True,
-    help=AbstractPackageManifest.model_fields.get("package_version").description,
-)
-@click.option(
-    "--description",
-    type=click.STRING,
-    help=ManifestMetadata.model_fields.get("description").description,
-    default="This is the first version of a wonderful eccenca Corporate Memory package 🤓",
-    show_default=True,
-)
-@click.pass_obj
-def create_command(
-    app: ApplicationContext, package_id: str, version: str, name: str | None, description: str
-) -> None:
-    """Initialize an empty package directory with a minimal manifest."""
-    if Path(package_id).exists():
-        raise click.UsageError(f"Package directory '{package_id}' already exists.")
-    if name is None:
-        name = package_id
-    manifest_src = {
-        "package_id": package_id,
-        "package_type": "project",
-        "package_version": version,
-        "metadata": {
-            "name": name,
-            "description": description,
-        },
-        "files": [],
-    }
-    package_version = PackageVersion.from_json(json.dumps(manifest_src))
-    directory = Path(package_id)
-    app.echo_info(f"Initialize package directory '{directory}' ... ", nl=False)
-    directory.mkdir(parents=True, exist_ok=True)
-    manifest = directory / "manifest.json"
-    manifest.write_text(package_version.manifest.model_dump_json(indent=2))
-    app.echo_success("done")
+@suppress_completion_errors
+def _complete_marketplace_package_ids(
+    ctx: click.Context,
+    param: click.Argument,  # noqa: ARG001
+    incomplete: str,
+) -> list[CompletionItem]:
+    """Prepare a list of IDs of available packages."""
+    ApplicationContext.set_connection_from_params(ctx.find_root().params)
+    client = Client.from_cmempy()
+    marketplace = Marketplace(client=client)
+    candidates = [(_.id, f"{_.name} ({_.type})") for _ in marketplace.get_available_packages()]
+    return completion.finalize_completion(candidates=candidates, incomplete=incomplete)
 
 
 @click.command(cls=CmemcCommand, name="inspect")
@@ -165,7 +130,9 @@ def inspect_command(app: ApplicationContext, package_path: Path, key: str, raw:
     """Inspect the manifest of a package."""
     path = Path(package_path)
     package_version = (
-        PackageVersion.from_directory(path) if path.is_dir() else PackageVersion.from_archive(path)
+        PackageVersion.from_directory(path, validate_files=False)
+        if path.is_dir()
+        else PackageVersion.from_archive(path)
     )
     manifest = package_version.manifest
     manifest_data = json.loads(manifest.model_dump_json(indent=2))
@@ -247,6 +214,7 @@ def list_command(
     "PACKAGE_ID",
     required=False,
     type=click.STRING,
+    shell_complete=_complete_marketplace_package_ids,
 )
 @click.option(
     "--input",
@@ -281,7 +249,7 @@ def install_command(
     if input_path:
         package_path = Path(input_path)
         package_version = (
-            PackageVersion.from_directory(package_path)
+            PackageVersion.from_directory(package_path, validate_files=False)
             if package_path.is_dir()
             else PackageVersion.from_archive(package_path)
         )
@@ -447,7 +415,7 @@ def build_command(
     Package archives can be published to the marketplace using the `package publish` command.
     """
     package_path = Path(package_directory)
-    package_version = PackageVersion.from_directory(package_path)
+    package_version = PackageVersion.from_directory(package_path, validate_files=False)
     if version:
         if version.startswith("v"):
             version = version[1:]
@@ -466,25 +434,32 @@ def build_command(
 
     if version_str.endswith("dirty"):
         app.echo_warning(
-            "Dirty Repository: Your version strings ends with 'dirty'."
+            "Dirty Repository: Your version string ends with 'dirty'. "
             "This indicates an unclean repository."
         )
+    if version_str == "0.0.0":
+        raise CmemcError(
+            "Invalid Version 0.0.0: "
+            "Use the --version option to override this, or change the manifest."
+        )
     if cpa_file.exists() and not replace:
         raise CmemcError(
             f"Package archive `{cpa_file}` already exists. Use `--replace` to overwrite."
         )
     app.echo_info(f"Building package archive `{cpa_file.name}` ... ", nl=False)
+    package_version.validate_text_files(package_version.manifest, package_path)
+    package_version.validate_image_files(package_version.manifest, package_path)
     package_version.build_archive(archive=cpa_file)
     app.echo_success("done")
 
 
 @click.command(cls=CmemcCommand, name="publish")
 @click.argument(
-    "PACKAGE",
+    "PACKAGE_ARCHIVE",
     required=True,
     type=ClickSmartPath(
         allow_dash=False,
-        dir_okay=True,
+        dir_okay=False,
         readable=True,
         exists=True,
         remote_okay=True,
@@ -497,25 +472,16 @@ def build_command(
     default="https://marketplace.eccenca.dev/",
 )
 @click.pass_obj
-def publish_command(app: ApplicationContext, package: str, marketplace_url: str) -> None:
+def publish_command(app: ApplicationContext, package_archive: str, marketplace_url: str) -> None:
     """Publish a package archive to the marketplace server."""
-    package_path = Path(package)
+    package_path = Path(package_archive)
 
-    package_version = (
-        PackageVersion.from_directory(package_path)
-        if package_path.is_dir()
-        else PackageVersion.from_archive(package_path)
-    )
+    package_version = PackageVersion.from_archive(package_path)
     package_id = package_version.manifest.package_id
 
     app.echo_info(f"Publishing package `{package_id}` ... ", nl=False)
-
-    if package_path.is_dir():
-        package_data = b"".join(PackageVersion.create_archive(package_path))
-        filename = f"{package_id}.cpa"
-    else:
-        package_data = package_path.read_bytes()
-        filename = package_path.name
+    package_data = package_path.read_bytes()
+    filename = package_path.name
 
     if marketplace_url.endswith("/"):
         marketplace_url = marketplace_url[:-1]
@@ -538,7 +504,6 @@ def package_group() -> CmemcGroup:  # type: ignore[empty-body]
     """List, (un)install, export, create, or inspect packages."""
 
 
-package_group.add_command(create_command)
 package_group.add_command(inspect_command)
 package_group.add_command(list_command)
 package_group.add_command(install_command)

cmem_cmemc/commands/project.py

@@ -38,7 +38,7 @@ from cmem_cmemc.context import ApplicationContext, build_caption
 from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.object_list import (
     DirectListPropertyFilter,
-    DirectValuePropertyFilter,
+    DirectMultiValuePropertyFilter,
     Filter,
     MultiFieldPropertyFilter,
     ObjectList,
@@ -46,6 +46,7 @@ from cmem_cmemc.object_list import (
 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
+from cmem_cmemc.utils import get_objects_to_delete
 
 
 def get_projects_for_list(ctx: Context) -> list[dict]:
@@ -90,11 +91,10 @@ project_list = ObjectList(
     name="projects",
     get_objects=get_projects_for_list,
     filters=[
-        DirectValuePropertyFilter(
-            name="id",
-            description="Filter by project ID (name).",
+        DirectMultiValuePropertyFilter(
+            name="ids",
+            description="Internal filter for multiple projects.",
             property_key="name",
-            completion_method="values",
         ),
         MultiFieldPropertyFilter(
             name="regex",
@@ -296,15 +296,20 @@ def delete_command(
     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"])
+    # Get projects to delete based on selection method
+    projects_data = get_objects_to_delete(
+        ctx=ctx,
+        ids=project_ids,
+        all_=all_,
+        filter_=filter_,
+        object_list=project_list,
+        get_all_objects=get_projects,
+        extract_id=lambda x: x["name"],
+        error_message_template="Project {} not available.",
+    )
 
     # Avoid double removal as well as sort project IDs
-    projects_to_delete = sorted(set(project_ids), key=lambda v: v.lower())
+    projects_to_delete = sorted({_["name"] for _ in projects_data}, key=lambda v: v.lower())
     count = len(projects_to_delete)
     for current, project_id in enumerate(projects_to_delete, start=1):
         current_string = str(current).zfill(len(str(count)))

cmem_cmemc/commands/user.py

@@ -31,6 +31,7 @@ from cmem_cmemc.object_list import (
     compare_regex,
     transform_lower,
 )
+from cmem_cmemc.utils import get_objects_to_delete
 
 NO_USER_ERROR = (
     "{} is not a valid user account. Use the 'admin user list' command "
@@ -81,52 +82,6 @@ user_list = ObjectList(
 )
 
 
-def _validate_usernames(usernames: tuple[str, ...]) -> None:
-    """Validate that all provided usernames exist."""
-    if not usernames:
-        return
-    all_users = list_users()
-    all_usernames = [user["username"] for user in all_users]
-    for username in usernames:
-        if username not in all_usernames:
-            raise CmemcError(NO_USER_ERROR.format(username))
-
-
-def _get_users_to_delete(
-    ctx: click.Context,
-    usernames: tuple[str, ...],
-    all_: bool,
-    filter_: tuple[tuple[str, str], ...],
-) -> list[str]:
-    """Get the list of usernames to delete based on selection method."""
-    if all_:
-        # Get all users
-        users = list_users()
-        return [user["username"] for user in users]
-
-    # Validate provided usernames exist before proceeding
-    _validate_usernames(usernames)
-
-    # Build filter list
-    filter_to_apply = list(filter_) if filter_ else []
-
-    # Add usernames if provided (using internal multi-value filter)
-    if usernames:
-        filter_to_apply.append(("usernames", ",".join(usernames)))
-
-    # Apply filters
-    users = user_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
-
-    # Build list of usernames
-    result = [user["username"] for user in users]
-
-    # Validation: ensure we found users
-    if not result and not usernames:
-        raise CmemcError("No user accounts found matching the provided filters.")
-
-    return result
-
-
 @click.command(cls=CmemcCommand, name="list")
 @click.option("--raw", is_flag=True, help="Outputs raw JSON.")
 @click.option(
@@ -228,11 +183,20 @@ def delete_command(
     if usernames and (all_ or filter_):
         raise click.UsageError("Either specify a username OR use a --filter or the --all option.")
 
-    # Get users to delete based on selection method
-    users_to_delete = _get_users_to_delete(ctx, usernames, all_, filter_)
+    users_data = get_objects_to_delete(
+        ctx=ctx,
+        ids=usernames,
+        all_=all_,
+        filter_=filter_,
+        object_list=user_list,
+        get_all_objects=list_users,
+        extract_id=lambda x: x["username"],
+        error_message_template=NO_USER_ERROR,
+        id_filter_name="usernames",
+    )
 
     # Avoid double removal as well as sort usernames
-    processed_usernames = sorted(set(users_to_delete), key=lambda v: v.lower())
+    processed_usernames = sorted({user["username"] for user in users_data}, key=lambda v: v.lower())
     count = len(processed_usernames)
 
     # Delete each user

cmem_cmemc/commands/variable.py

@@ -17,7 +17,6 @@ from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
 from cmem_cmemc.context import ApplicationContext, build_caption
-from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.object_list import (
     DirectMultiValuePropertyFilter,
     DirectValuePropertyFilter,
@@ -25,7 +24,11 @@ from cmem_cmemc.object_list import (
     ObjectList,
     compare_regex,
 )
-from cmem_cmemc.utils import check_or_select_project, split_task_id
+from cmem_cmemc.utils import (
+    check_or_select_project,
+    get_objects_to_delete,
+    split_task_id,
+)
 
 
 def get_variables(ctx: Context) -> list[dict]:  # noqa: ARG001
@@ -172,41 +175,6 @@ def _sort_variables_by_dependency(variables: list[dict]) -> list[str]:
     return result
 
 
-def _validate_variable_ids(variable_ids: tuple[str, ...]) -> None:
-    """Validate that provided variable IDs exist."""
-    all_variables = get_all_variables()
-    all_variable_ids = [_["id"] for _ in all_variables]
-    for variable_id in variable_ids:
-        if variable_id not in all_variable_ids:
-            raise CmemcError(f"Variable {variable_id} not available.")
-
-
-def _get_variables_to_delete(
-    ctx: Context,
-    variable_ids: tuple[str, ...],
-    all_: bool,
-    filter_: tuple[tuple[str, str], ...],
-) -> list[dict]:
-    """Get the list of variables to delete based on selection method."""
-    if all_:
-        _: list[dict] = get_all_variables()
-        return _
-
-    _validate_variable_ids(variable_ids)
-
-    filter_to_apply = list(filter_) if filter_ else []
-
-    if variable_ids:
-        filter_to_apply.append(("ids", ",".join(variable_ids)))
-
-    variables = variable_list_obj.apply_filters(ctx=ctx, filter_=filter_to_apply)
-
-    if not variables and not variable_ids:
-        raise CmemcError("No variables found matching the provided filters.")
-
-    return variables
-
-
 @click.command(cls=CmemcCommand, name="list")
 @click.option("--raw", is_flag=True, help="Outputs raw JSON.")
 @click.option(
@@ -340,8 +308,16 @@ def delete_command(
             "--filter options to specify variables for deletion."
         )
 
-    # Get variables to delete based on selection method
-    variables_to_delete = _get_variables_to_delete(ctx, variable_ids, all_, filter_)
+    variables_to_delete = get_objects_to_delete(
+        ctx=ctx,
+        ids=variable_ids,
+        all_=all_,
+        filter_=filter_,
+        object_list=variable_list_obj,
+        get_all_objects=get_all_variables,
+        extract_id=lambda x: x["id"],
+        error_message_template="Variable {} not available.",
+    )
 
     # Remove duplicates while preserving variable objects for dependency analysis
     unique_variables = list({v["id"]: v for v in variables_to_delete}.values())

cmem_cmemc/manual_helper/multi_page.py

@@ -26,6 +26,7 @@ def get_icon_for_command_group(full_name: str) -> str:
         "admin workspace python": "material/language-python",
         "config": "material/cog-outline",
         "dataset": "eccenca/artefact-dataset",
+        "package": "material/shopping",
         "project": "eccenca/artefact-project",
         "project file": "eccenca/artefact-file",
         "project variable": "material/variable-box",
@@ -54,6 +55,7 @@ def get_tags_for_command_group(full_name: str) -> str:
         "admin workspace python": ["Python", "cmemc"],
         "config": ["Configuration", "cmemc"],
         "dataset": ["cmemc"],
+        "package": ["cmemc", "Package"],
         "project": ["Project", "cmemc"],
         "project file": ["Files", "cmemc"],
         "project variable": ["Variables", "cmemc"],

cmem_cmemc/utils.py

@@ -6,11 +6,13 @@ import pathlib
 import re
 import sys
 import unicodedata
+from collections.abc import Callable
 from dataclasses import dataclass
 from importlib.metadata import version as cmemc_version
 from typing import TYPE_CHECKING
 from zipfile import BadZipFile, ZipFile
 
+import click
 import requests
 from click import Argument
 from cmem.cmempy.dp.proxy.graph import get_graphs_list
@@ -24,6 +26,7 @@ from cmem_cmemc.exceptions import CmemcError
 from cmem_cmemc.smart_path import SmartPath
 
 if TYPE_CHECKING:
+    from cmem_cmemc import object_list
     from cmem_cmemc.context import ApplicationContext
 
 
@@ -453,3 +456,113 @@ def tuple_to_list(ctx: type["ApplicationContext"], param: Argument, value: tuple
     Used as callback to have mutable values
     """
     return list(value)
+
+
+def validate_ids(
+    ids: tuple[str, ...],
+    get_all_objects: Callable[[], list[dict]],
+    extract_id: Callable[[dict], str],
+    error_message_template: str,
+) -> None:
+    """Validate that all provided IDs exist.
+
+    This is a reusable validation function for delete commands.
+
+    Args:
+    ----
+        ids: Tuple of identifiers to validate
+        get_all_objects: Callable that returns list of all objects (e.g., list_items, get_graphs)
+        extract_id: Callable that extracts the ID from an object dict (e.g., lambda x: x["iri"])
+        error_message_template: Error message template with {} placeholder for the missing ID
+
+    Raises:
+    ------
+        CmemcError: If any ID is not found
+
+    Example:
+    -------
+        validate_ids(
+            ids=("graph1", "graph2"),
+            get_all_objects=lambda: get_graphs(),
+            extract_id=lambda x: x["iri"],
+            error_message_template="{} is not a valid graph IRI."
+        )
+
+    """
+    if not ids:
+        return
+    all_objects = get_all_objects()
+    all_ids = {extract_id(obj) for obj in all_objects}
+    for id_ in ids:
+        if id_ not in all_ids:
+            raise CmemcError(error_message_template.format(id_))
+
+
+def get_objects_to_delete(  # noqa: PLR0913
+    ctx: click.Context,
+    ids: tuple[str, ...],
+    all_: bool,
+    filter_: tuple[tuple[str, str], ...],
+    object_list: "object_list.ObjectList",
+    get_all_objects: Callable[[], list[dict]],
+    extract_id: Callable[[dict], str],
+    error_message_template: str,
+    id_filter_name: str = "ids",
+) -> list[dict]:
+    """Get the list of objects to delete based on selection method.
+
+    This is a reusable utility for delete commands that encapsulates the common pattern of:
+    1. If --all flag is set, return all objects
+    2. Validate provided IDs exist
+    3. Build filter list with IDs (using internal multi-value filter)
+    4. Apply filters using ObjectList
+    5. Validate that objects were found
+
+    Args:
+    ----
+        ctx: Click context
+        ids: Tuple of specific identifiers to delete
+        all_: Flag to delete all objects
+        filter_: Tuple of filter name/value pairs
+        object_list: ObjectList instance for filtering
+        get_all_objects: Callable that returns list of all objects (for validation)
+        extract_id: Callable that extracts the ID from an object dict
+        error_message_template: Template string for error messages
+        id_filter_name: Name of the internal multi-value filter (default: "ids")
+
+    Returns:
+    -------
+        List of object dictionaries to delete
+
+    Raises:
+    ------
+        CmemcError: If no objects found matching the criteria
+
+    """
+    if all_:
+        return object_list.apply_filters(ctx=ctx, filter_=[])
+
+    # Validate provided IDs exist before proceeding
+    if ids:
+        validate_ids(
+            ids=ids,
+            get_all_objects=get_all_objects,
+            extract_id=extract_id,
+            error_message_template=error_message_template,
+        )
+
+    # Build filter list
+    filter_to_apply = list(filter_) if filter_ else []
+
+    # Add IDs if provided (using internal multi-value filter)
+    if ids:
+        filter_to_apply.append((id_filter_name, ",".join(ids)))
+
+    # Apply filters
+    objects = object_list.apply_filters(ctx=ctx, filter_=filter_to_apply)
+
+    # Validation: ensure we found objects
+    if not objects:
+        raise CmemcError("No objects found matching the provided criteria.")
+
+    return objects

{cmem_cmemc-26.1.0rc1.dist-info → cmem_cmemc-26.1.0rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmem-cmemc
-Version: 26.1.0rc1
+Version: 26.1.0rc3
 Summary: Command line client for eccenca Corporate Memory
 License: Apache-2.0
 License-File: LICENSE
@@ -32,7 +32,7 @@ Requires-Dist: certifi (>=2024.2.2)
 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-client (>=0.5.0,<0.6.0)
+Requires-Dist: cmem-client (==0.7.1)
 Requires-Dist: cmem-cmempy (==25.4.0)
 Requires-Dist: configparser (>=7.2.0,<8.0.0)
 Requires-Dist: humanize (>=4.14.0,<5.0.0)

{cmem_cmemc-26.1.0rc1.dist-info → cmem_cmemc-26.1.0rc3.dist-info}/RECORD

@@ -4,27 +4,27 @@ cmem_cmemc/cli.py,sha256=VGfHqSIPPTvYpPHrjwbnLYLB6O0u8kwiJDXeXMlI1xU,4855
 cmem_cmemc/command.py,sha256=CuaskaqD12soZLhDP1prgXOT4cRFu1CzuJm6LBp4zLM,1949
 cmem_cmemc/command_group.py,sha256=0I2Jg1lCdoozcMg7d0g9sk0zVJ8_LiKvWWwqM6tZGI0,4793
 cmem_cmemc/commands/__init__.py,sha256=NaGM5jOzf0S_-4UIAwlVDOf2AZ3mliGPoRLXQJfTyZs,22
-cmem_cmemc/commands/acl.py,sha256=IHLEmrbz3r9SVEsaEWxpGVRjoT0oXWhYJ4d3y-_402Y,31421
+cmem_cmemc/commands/acl.py,sha256=X7RMwEO66SvOY4gXrlBJvKTUYiUdURf0YLaZx1Feqx8,30238
 cmem_cmemc/commands/admin.py,sha256=XyJVk9CuxLh60GdWNtMkGPpZ3BOftDF4T04M8gRaOQ0,10193
 cmem_cmemc/commands/client.py,sha256=4Ke9Pl6-KQ-6_uSpRbVhB7spAi8tP0r39y99fwFRSWE,5304
 cmem_cmemc/commands/config.py,sha256=tRB7YK6vzkaasmyZVWGLOw1_x0SM2x-coYMBRIJwEJs,8392
-cmem_cmemc/commands/dataset.py,sha256=OCRBcDFVBBpap4bnjSIOfrWgFNRU9m0V_QlSobvObkY,30472
-cmem_cmemc/commands/file.py,sha256=FBmi0D8bZs5NoKcOWEYIuaJM0x9kWQAaIQ2IyL8sFiE,17038
-cmem_cmemc/commands/graph.py,sha256=HzddrKcoxq0w2xWMIhVft5p5Oacq0TSrmhebLngJdMs,36623
+cmem_cmemc/commands/dataset.py,sha256=ZdiKLXWq9ItnJb4xGiP0qaby5W3Kvkyqg8KIaYsHelI,29715
+cmem_cmemc/commands/file.py,sha256=Ds7vzaiWIfnOesxS9KQQuBinlkSjcSqV_02SX1ad_sE,15926
+cmem_cmemc/commands/graph.py,sha256=oUInQQEuL-n6bFEscNUB7qfPUk0yNajEy0H5VFXFPoQ,35667
 cmem_cmemc/commands/graph_imports.py,sha256=VcOisHSvNYJPxMiRb6sHEswYIQHwlIamLwQD1jgr_e0,14368
-cmem_cmemc/commands/graph_insights.py,sha256=sx-Lvv4FWK9-eB8X4R5fDU63lrErAhc8W3a2fEQAjDI,14473
+cmem_cmemc/commands/graph_insights.py,sha256=slQXBUy7azEG-w7M-2r9ybY4J3HgV9TTWbP5Ih3HDu0,14395
 cmem_cmemc/commands/manual.py,sha256=-sZWeFL92Kj8gL3VYsbpKh2ZaVTyM3LgKaUcpNn9u3A,2179
 cmem_cmemc/commands/metrics.py,sha256=t5I6VjBzjp_bQEoGkU9cdqNu_sa_WQwiIeJA3f9KNWc,12385
 cmem_cmemc/commands/migration.py,sha256=FibmYpvZD2mrutjyRBhs7xDAZ-sjPiH9Kn3CI-zUPm0,9861
-cmem_cmemc/commands/package.py,sha256=mJ9vDj34YdGySGK_Nh7Yl3O2tyuT-FhV8p4taRNLU_c,17762
-cmem_cmemc/commands/project.py,sha256=ovn9zre7L0EzthMITQHGF9dffiP44UQUWNjG8Is6l8k,24938
+cmem_cmemc/commands/package.py,sha256=iY543hVwMqTA5t7mQAe2etz9n5sNgxx5y8Y-B53kJRY,16812
+cmem_cmemc/commands/project.py,sha256=HRA4xpOENajyQub1iWLo5voAsXFUzFPt7kJq9sx4sx4,25066
 cmem_cmemc/commands/python.py,sha256=lcbBAYZN5NB37HLSmVPs0SXJV7Ey4xVMYQiSiuyGkvc,12225
 cmem_cmemc/commands/query.py,sha256=1cj1QbvwL98YbBGSCO0Zazbzscts_kiv0A7k75KwJXw,32231
 cmem_cmemc/commands/scheduler.py,sha256=3wk3BF6Z3uRb0e5pphOYBusbXgs7C6Lz-D9wi7Nlohc,8855
 cmem_cmemc/commands/store.py,sha256=zKz8FTtVSvFU6gMm6An7Jja9Bu9dZKbI1GW7UCq034s,10655
-cmem_cmemc/commands/user.py,sha256=F0JSRkrj274Hi0i4nBIUkWFm-ItC40VwuqvLYETJBdM,15844
+cmem_cmemc/commands/user.py,sha256=Uqhqn5gb4Fy4_ZaJbAwVFTRERvRO7A0yYO2ic6Xz1Wc,14707
 cmem_cmemc/commands/validation.py,sha256=v9_cXGzaexemuz6xBA358XY1_vP42SBfOD3PEZLcqbw,29731
-cmem_cmemc/commands/variable.py,sha256=ZcvrQDb0CztWGkFIX-jnvqBTLp3qpQEZ7ZpBmKV16SI,18841
+cmem_cmemc/commands/variable.py,sha256=LRgZ82lubDnY0yh67KBF0se2W1PeE58pYAJuwftbfyE,17926
 cmem_cmemc/commands/vocabulary.py,sha256=sv7hDZOeRPrPlc5RJfpAKzKH5JRyKjB93D-Jl4eLNqI,18359
 cmem_cmemc/commands/workflow.py,sha256=UdKAsY3chxfrIpkjL1K9MqLVyu7jTdFYkOXfGVvJISI,26369
 cmem_cmemc/commands/workspace.py,sha256=IcZgBsvtulLRFofS70qpln6oKQIZunrVLfSAUeiFhCA,4579
@@ -35,7 +35,7 @@ cmem_cmemc/context.py,sha256=oCcd6dFl6BdYqKsueVqzQhSEwTNW7b1MjrE4CRznxt8,23220
 cmem_cmemc/exceptions.py,sha256=c4Z6CKgymu0a7gD8MtHxzK_7WCsb9I2Zl-EgEkwu-YY,760
 cmem_cmemc/manual_helper/__init__.py,sha256=G3Lqw2aPxo8x63Tg7L0aa5VD9BMaRzZDmhrog7IuEPg,43
 cmem_cmemc/manual_helper/graph.py,sha256=dTkFXgU9fgySn54rE93t79v1MjWjQkprKRIfJhc7Jps,3655
-cmem_cmemc/manual_helper/multi_page.py,sha256=I1gTCDETlCli2k-G7Mkdpw_MCqey60HxFl35wTmvYFU,12279
+cmem_cmemc/manual_helper/multi_page.py,sha256=vTW1xHeMqM0BCFYsftoirXZ6RwxEeV0LjiOPwbqBous,12360
 cmem_cmemc/manual_helper/single_page.py,sha256=0mMn_IJwFCe-WPKAmxGEStb8IINLpQRxAx_F1pIxg1E,1526
 cmem_cmemc/migrations/__init__.py,sha256=i6Ri7qN58ou_MwOzm2KibPkXOD7u-1ELky-nUE5LjAA,24
 cmem_cmemc/migrations/abc.py,sha256=UGJzrvMzUFdp2-sosp49ObRI-SrUSzLJqLEhvB4QTzg,3564
@@ -54,9 +54,9 @@ cmem_cmemc/smart_path/clients/__init__.py,sha256=YFOm69BfTCRvAcJjN_CoUmCv3kzEciy
 cmem_cmemc/smart_path/clients/http.py,sha256=3clZu2v4uuOvPY4MY_8SVSy7hIXJDNooahFRBRpy0ok,2347
 cmem_cmemc/string_processor.py,sha256=19YSLUF9PIbfTmsTm2bZslsNhFUAYx0MerWYwC3BVEo,8616
 cmem_cmemc/title_helper.py,sha256=8Cyes2U4lHTQbzYwBSYqCrZbq29_oBg6uibe7xZ6DEg,3486
-cmem_cmemc/utils.py,sha256=jmXjbEQ2MDIz031A81kivGnir7HG5XUkLbOd1OCoV6s,14662
-cmem_cmemc-26.1.0rc1.dist-info/METADATA,sha256=-8H1iGcueln3Y31sViwBpY-g2hBleljk2Vm-YSsRL2Y,5761
-cmem_cmemc-26.1.0rc1.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-cmem_cmemc-26.1.0rc1.dist-info/entry_points.txt,sha256=2G0AWAyz501EHpFTjIxccdlCTsHt80NT0pdUGP1QkPA,45
-cmem_cmemc-26.1.0rc1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-cmem_cmemc-26.1.0rc1.dist-info/RECORD,,
+cmem_cmemc/utils.py,sha256=rs3qf5UZeiTQO0USUpFQq6upQnG_S43CW7YYUrCwmzk,18240
+cmem_cmemc-26.1.0rc3.dist-info/METADATA,sha256=mB1KAv64UgOmwJ_4WbdqxeH7nI6MkVgq6d96hFrBPaE,5754
+cmem_cmemc-26.1.0rc3.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+cmem_cmemc-26.1.0rc3.dist-info/entry_points.txt,sha256=2G0AWAyz501EHpFTjIxccdlCTsHt80NT0pdUGP1QkPA,45
+cmem_cmemc-26.1.0rc3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+cmem_cmemc-26.1.0rc3.dist-info/RECORD,,