cmem-cmemc 26.1.0rc2__py3-none-any.whl → 26.1.0rc4__py3-none-any.whl

cmem_cmemc/cli.py

@@ -68,7 +68,21 @@ CONTEXT_SETTINGS = {"auto_envvar_prefix": "CMEMC", "help_option_names": ["-h", "
 )
 @click.option("-q", "--quiet", is_flag=True, help="Suppress any non-error info messages.")
 @click.option(
-    "-d", "--debug", is_flag=True, help="Output debug messages and stack traces after errors."
+    "-d",
+    "--debug",
+    is_flag=True,
+    help="Output debug messages and stack traces after errors. The log level "
+    "can be set in the config via the CMEMC_LOG_LEVEL environment variable. "
+    "Options are: 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'"
+    "  [default: DEBUG]",
+)
+@click.option(
+    "--log-level",
+    type=click.Choice(
+        ["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], case_sensitive=False
+    ),
+    help="Set the log level when --debug is enabled. "
+    "Can also be set via CMEMC_LOG_LEVEL environment variable.",
 )
 @click.option(
     "--external-http-timeout",
@@ -89,6 +103,7 @@ def cli(  # noqa: PLR0913
     config_file: str,
     connection: str,
     external_http_timeout: int,
+    log_level: str,
 ) -> None:
     """Eccenca Corporate Memory Control (cmemc).
 
@@ -111,7 +126,7 @@ def cli(  # noqa: PLR0913
 
     cmemc is © 2026 eccenca GmbH, licensed under the Apache License 2.0.
     """
-    _ = connection, debug, quiet, config_file, external_http_timeout
+    _ = connection, debug, quiet, config_file, external_http_timeout, log_level
     if " ".join(sys.argv).find("config edit") != -1:
         app = ApplicationContext(config_file=config_file, debug=debug, quiet=quiet)
     else:

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,6 +8,7 @@ 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,
@@ -92,6 +93,20 @@ def _complete_installed_package_ids(
     return completion.finalize_completion(candidates=candidates, incomplete=incomplete)
 
 
+@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}") for _ in marketplace.get_available_packages()]
+    return completion.finalize_completion(candidates=candidates, incomplete=incomplete)
+
+
 @click.command(cls=CmemcCommand, name="inspect")
 @click.argument(
     "PACKAGE_PATH",
@@ -199,6 +214,7 @@ def list_command(
     "PACKAGE_ID",
     required=False,
     type=click.STRING,
+    shell_complete=_complete_marketplace_package_ids,
 )
 @click.option(
     "--input",
@@ -418,7 +434,7 @@ def build_command(
 
     if version_str.endswith("dirty"):
         app.echo_warning(
-            "Dirty Repository: Your version string ends with 'dirty'."
+            "Dirty Repository: Your version string ends with 'dirty'. "
             "This indicates an unclean repository."
         )
     if version_str == "0.0.0":
@@ -483,6 +499,58 @@ def publish_command(app: ApplicationContext, package_archive: str, marketplace_u
     app.echo_success("done")
 
 
+@click.command(cls=CmemcCommand, name="search")
+@click.argument(
+    "SEARCH_TERMS",
+    nargs=-1,
+    type=click.STRING,
+)
+@click.option("--raw", is_flag=True, help="Outputs raw JSON.")
+@click.pass_obj
+def search_command(app: ApplicationContext, search_terms: tuple[str], raw: bool) -> None:
+    """Search for available packages with a given search text."""
+    packages = app.client.marketplace.get_available_packages()
+
+    available_packages = []
+    search_terms_lower = [term.lower() for term in search_terms]
+
+    if search_terms == "":
+        available_packages = packages
+    else:
+        for package in packages:
+            searchable_text = (
+                f"{package.id.lower()} {package.name.lower()} "
+                f"{package.description.lower()} {package.type.value.lower()}"
+            )
+            if all(term in searchable_text for term in search_terms_lower):
+                available_packages.append(package)
+
+    if raw:
+        package_data = [
+            json.loads(metadata.model_dump_json(indent=2)) for metadata in available_packages
+        ]
+        app.echo_info_json(package_data)
+        return
+
+    table = [
+        (
+            _.id,
+            _.name,
+            _.description,
+            _.type.value,
+        )
+        for _ in available_packages
+    ]
+    app.echo_info_table(
+        table,
+        headers=["ID", "Name", "Description", "Type"],
+        sort_column=0,
+        empty_table_message="No available packages found.",
+        caption=f"{len(available_packages)} package{'' if len(available_packages) == 1 else "s" } "
+        f"found on marketplace.eccenca.dev",
+    )
+
+
 @click.group(cls=CmemcGroup)
 def package_group() -> CmemcGroup:  # type: ignore[empty-body]
     """List, (un)install, export, create, or inspect packages."""
@@ -495,3 +563,4 @@ package_group.add_command(uninstall_command)
 package_group.add_command(export_command)
 package_group.add_command(build_command)
 package_group.add_command(publish_command)
+package_group.add_command(search_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/context.py

@@ -3,6 +3,7 @@
 import ast
 import configparser
 import json
+import logging
 import os
 import re
 import subprocess  # nosec
@@ -57,6 +58,19 @@ KNOWN_SECRET_KEYS = ("OAUTH_PASSWORD", "OAUTH_CLIENT_SECRET", "OAUTH_ACCESS_TOKE
 SSL_VERIFY_WARNING = "SSL verification is disabled (SSL_VERIFY=False)."
 
 
+class ClickHandler(logging.Handler):
+    """Custom logging handler that outputs using click.secho with dimming."""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Emit a log record using click.secho."""
+        try:
+            now = datetime.now(tz=timezone.utc)
+            msg = self.format(record)
+            click.secho(f"[{now!s}] {msg}", err=True, dim=True)
+        except Exception:  # noqa: BLE001
+            self.handleError(record)
+
+
 def build_caption(
     count: int,
     item_name: str,
@@ -101,12 +115,14 @@ class ApplicationContext:
     connection: str | None
     console: Console
     console_width: int | None = None
+    log_level: str | None = None
 
     def __init__(
         self,
         config_file: str,
         connection: str | None = None,
         debug: bool = False,
+        log_level: str | None = None,
         quiet: bool = False,
     ):
         """Initialize main context."""
@@ -114,6 +130,7 @@ class ApplicationContext:
         self.app_name = "cmemc"
         self.set_debug(debug)
         self.set_quiet(quiet)
+        self.log_level = log_level
         self.ensure_app_config_dir()
         self.set_connection(connection)
         self.set_external_http_timeout(self.DEFAULT_EXTERNAL_HTTP_TIMEOUT)
@@ -123,7 +140,18 @@ class ApplicationContext:
     @property
     def client(self) -> Client:
         """The cmem_client Client object."""
-        return Client.from_cmempy()
+        client = Client.from_cmempy()
+        if self.debug:
+            level = self.log_level or "DEBUG"
+            handler = ClickHandler()
+            formatter = logging.Formatter("%(name)s - [%(levelname)s] - %(message)s")
+            handler.setFormatter(formatter)
+            client.configure_client_logger(
+                level=level,
+                format_string="%(name)s - [%(levelname)s] - %(message)s",
+                handlers=[handler],
+            )
+        return client
 
     @staticmethod
     def from_params(params: dict) -> "ApplicationContext":
@@ -134,6 +162,7 @@ class ApplicationContext:
         config_file = params.get("config_file")
         debug = str_to_bool(str(params.get("debug")))
         quiet = str_to_bool(str(params.get("quiet")))
+        log_level = str(params.get("log_level")) if params.get("log_level") else None
         external_http_timeout = (
             int(str(params.get("external_http_timeout")))
             if "external_http_timeout" in params
@@ -143,7 +172,11 @@ class ApplicationContext:
         if not config_file:
             raise ValueError("Missing required key: 'config_file' in config dictionary")
         app = ApplicationContext(
-            config_file=config_file, connection=connection, debug=debug, quiet=quiet
+            config_file=config_file,
+            connection=connection,
+            debug=debug,
+            quiet=quiet,
+            log_level=log_level,
         )
         app.set_external_http_timeout(external_http_timeout)
         if not app.debug:
@@ -184,6 +217,10 @@ class ApplicationContext:
         """Set debug state"""
         self.debug = debug
 
+    def set_log_level(self, log_level: str) -> None:
+        """Set log level"""
+        self.log_level = log_level
+
     def set_quiet(self, quiet: bool = False) -> None:
         """Set quiets state"""
         self.quiet = quiet
@@ -247,6 +284,9 @@ class ApplicationContext:
         for key, value in config.items():
             if key == "CMEMC_DEBUG":
                 self.set_debug(str_to_bool(value))
+            elif key == "CMEMC_LOG_LEVEL":
+                self.set_log_level(value)
+                self.echo_debug(f"set log level to {value}")
             elif key == "CMEMC_QUIET":
                 self.set_quiet(str_to_bool(value))
             elif key == "CMEMC_CONNECTION":

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.0rc2.dist-info → cmem_cmemc-26.1.0rc4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmem-cmemc
-Version: 26.1.0rc2
+Version: 26.1.0rc4
 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.6.0)
+Requires-Dist: cmem-client (==0.8.0)
 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.0rc2.dist-info → cmem_cmemc-26.1.0rc4.dist-info}/RECORD

@@ -1,37 +1,37 @@
 cmem_cmemc/__init__.py,sha256=-RPEVweA-fcmEAynszDDMKwArJgxZpGW61UBiV7O4Og,24
 cmem_cmemc/_cmemc.zsh,sha256=fmkrBHIQxus8cp2AgO1tzZ5mNZdGL_83cYz3a9uAdsg,1326
-cmem_cmemc/cli.py,sha256=VGfHqSIPPTvYpPHrjwbnLYLB6O0u8kwiJDXeXMlI1xU,4855
+cmem_cmemc/cli.py,sha256=V0BUSN-N7HzGtNBZOZ8N6C_8FaofCTD13uuuuW9f79k,5368
 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=IV1eRT_fRdjRqbybByDT7wyBmhWnn81N_bzqDQE7Hqw,16122
-cmem_cmemc/commands/project.py,sha256=ovn9zre7L0EzthMITQHGF9dffiP44UQUWNjG8Is6l8k,24938
+cmem_cmemc/commands/package.py,sha256=m5IBnSZdwroewHBTyxDIjQrF0NSixmMdffL1OeszyQM,18480
+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
 cmem_cmemc/completion.py,sha256=JbMZmTLjgu_nrIS9NuuFHqfqAFwHE1dCvFNk0g2c6d0,44805
 cmem_cmemc/config_parser.py,sha256=NduwOT-BB_uAk3pz1Y-ex18RQJW-jjHzkQKCEUUK6Hc,1276
 cmem_cmemc/constants.py,sha256=pzZYbSaTDUiWmE-VOAHB20oivHew5_FP9UTejySsVK4,550
-cmem_cmemc/context.py,sha256=oCcd6dFl6BdYqKsueVqzQhSEwTNW7b1MjrE4CRznxt8,23220
+cmem_cmemc/context.py,sha256=miYUlpJ9QwEPoh8U8_sekBQXw3MVe9kR5wGOWCzb0Yo,24683
 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
@@ -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.0rc2.dist-info/METADATA,sha256=Rg88KKC27XU_vxDlRbs2waFVWBv2lGrZWN8_HZQQbpY,5754
-cmem_cmemc-26.1.0rc2.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-cmem_cmemc-26.1.0rc2.dist-info/entry_points.txt,sha256=2G0AWAyz501EHpFTjIxccdlCTsHt80NT0pdUGP1QkPA,45
-cmem_cmemc-26.1.0rc2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-cmem_cmemc-26.1.0rc2.dist-info/RECORD,,
+cmem_cmemc/utils.py,sha256=rs3qf5UZeiTQO0USUpFQq6upQnG_S43CW7YYUrCwmzk,18240
+cmem_cmemc-26.1.0rc4.dist-info/METADATA,sha256=ViY7R6xoIspCb6bu7it8j94FJDu7ks-6t_1iotPLDw8,5754
+cmem_cmemc-26.1.0rc4.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+cmem_cmemc-26.1.0rc4.dist-info/entry_points.txt,sha256=2G0AWAyz501EHpFTjIxccdlCTsHt80NT0pdUGP1QkPA,45
+cmem_cmemc-26.1.0rc4.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+cmem_cmemc-26.1.0rc4.dist-info/RECORD,,

{cmem_cmemc-26.1.0rc2.dist-info → cmem_cmemc-26.1.0rc4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any