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

cmem_cmemc/commands/user.py

@@ -4,7 +4,6 @@ import sys
 from getpass import getpass
 
 import click
-from click import ClickException
 from cmem.cmempy.config import get_keycloak_base_uri, get_keycloak_realm_id
 from cmem.cmempy.keycloak.group import list_groups
 from cmem.cmempy.keycloak.user import (
@@ -23,8 +22,10 @@ from cmem.cmempy.keycloak.user 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,
@@ -71,10 +72,61 @@ user_list = ObjectList(
             compare=compare_regex,
             fixed_completion=[],
         ),
+        DirectMultiValuePropertyFilter(
+            name="usernames",
+            description="Internal filter for multiple usernames.",
+            property_key="username",
+        ),
     ],
 )
 
 
+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(
@@ -117,33 +169,81 @@ def list_command(
         )
         for usr in users
     ]
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
         headers=["Username", "First Name", "Last Name", "Email"],
         sort_column=0,
-        empty_table_message="No user accounts found. "
-        "Use the `admin user create` command to create an account.",
+        caption=build_caption(len(table), "user", filtered=filtered),
+        empty_table_message="No user accounts found for these filters."
+        if filtered
+        else "No user accounts found. Use the `admin user create` command to create an account.",
     )
 
 
 @click.command(cls=CmemcCommand, name="delete")
-@click.argument("username", shell_complete=completion.user_ids)
-@click.pass_obj
-def delete_command(app: ApplicationContext, username: str) -> None:
-    """Delete a user account.
+@click.option(
+    "-a",
+    "--all",
+    "all_",
+    is_flag=True,
+    help="Delete all user accounts. This is a dangerous option, so use it with care.",
+)
+@click.option(
+    "--filter",
+    "filter_",
+    type=(str, str),
+    multiple=True,
+    shell_complete=user_list.complete_values,
+    help=user_list.get_filter_help_text(),
+)
+@click.argument("usernames", nargs=-1, type=click.STRING, shell_complete=completion.user_ids)
+@click.pass_context
+def delete_command(
+    ctx: click.Context,
+    all_: bool,
+    filter_: tuple[tuple[str, str]],
+    usernames: tuple[str],
+) -> None:
+    """Delete user accounts.
+
+    This command deletes user accounts from a realm.
 
-    This command deletes a user account from a realm.
+    Warning: User accounts will be deleted without prompting.
 
-    Note: The deletion of a user account does not delete the assigned groups of
-    this account, only the assignments to these groups.
+    Note: The deletion of user accounts does not delete the assigned groups,
+    only the assignments to these groups. User accounts can be listed by using
+    the `admin user list` command.
     """
-    app.echo_info(f"Deleting user {username} ... ", nl=False)
-    users = get_user_by_username(username)
-    if not users:
-        raise ClickException(NO_USER_ERROR.format(username))
+    app = ctx.obj
+
+    # Validation: require at least one selection method
+    if not usernames and not all_ and not filter_:
+        raise click.UsageError(
+            "Either specify at least one username"
+            " or use a --filter option,"
+            " or use the --all option to delete all user accounts."
+        )
+
+    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_)
+
+    # Avoid double removal as well as sort usernames
+    processed_usernames = sorted(set(users_to_delete), key=lambda v: v.lower())
+    count = len(processed_usernames)
 
-    delete_user(users[0]["id"])
-    app.echo_success("deleted")
+    # Delete each user
+    for current, username in enumerate(processed_usernames, start=1):
+        current_string = str(current).zfill(len(str(count)))
+        app.echo_info(f"Delete user {current_string}/{count}: {username} ... ", nl=False)
+        users = get_user_by_username(username)
+        if not users:
+            raise CmemcError(NO_USER_ERROR.format(username))
+        delete_user(users[0]["id"])
+        app.echo_success("deleted")
 
 
 @click.command(cls=CmemcCommand, name="create")
@@ -161,7 +261,7 @@ def create_command(app: ApplicationContext, username: str) -> None:
     app.echo_info(f"Creating user {username} ... ", nl=False)
     users = get_user_by_username(username)
     if users:
-        raise ClickException(EXISTING_USER_ERROR.format(username))
+        raise CmemcError(EXISTING_USER_ERROR.format(username))
 
     create_user(username=username)
     app.echo_success("done")
@@ -215,14 +315,14 @@ def update_command(  # noqa: PLR0913
     app.echo_info(f"Updating user {username} ... ", nl=False)
     users = get_user_by_username(username)
     if not users:
-        raise ClickException(NO_USER_ERROR.format(username))
+        raise CmemcError(NO_USER_ERROR.format(username))
     user_id = users[0]["id"]
     all_groups = {group["name"]: group["id"] for group in list_groups()}
     invalid_groups = [group for group in assign_group if group not in all_groups]
     existing_user_groups = {group["name"] for group in user_groups(user_id)}
 
     if invalid_groups:
-        raise ClickException(
+        raise CmemcError(
             NO_GROUP_ERROR.format(
                 ", ".join(invalid_groups), ", ".join(all_groups.keys() - set(existing_user_groups))
             )
@@ -232,7 +332,7 @@ def update_command(  # noqa: PLR0913
         group for group in unassign_group if group not in existing_user_groups
     ]
     if invalid_unassign_groups:
-        raise ClickException(
+        raise CmemcError(
             INVALID_UNASSIGN_GROUP_ERROR.format(
                 ", ".join(invalid_unassign_groups), ", ".join(existing_user_groups)
             )
@@ -287,7 +387,7 @@ def password_command(
     app.echo_info(f"Changing password for account {username} ... ", nl=False)
     users = get_user_by_username(username)
     if not users:
-        raise ClickException(NO_USER_ERROR.format(username))
+        raise CmemcError(NO_USER_ERROR.format(username))
     if not value and not request_change:
         app.echo_info("\nNew password: ", nl=False)
         value = getpass(prompt="")
@@ -300,7 +400,7 @@ def password_command(
     if value:
         reset_password(user_id=users[0]["id"], value=value, temporary=temporary)
     if request_change and not users[0].get("email", None):
-        raise ClickException(NO_EMAIL_ERROR.format(username))
+        raise CmemcError(NO_EMAIL_ERROR.format(username))
     if request_change:
         request_password_change(users[0]["id"])
     app.echo_success("done")
@@ -331,7 +431,7 @@ def open_command(app: ApplicationContext, usernames: str) -> None:
         user_name_id_map = {u["username"]: u["id"] for u in users}
         for _ in usernames:
             if _ not in user_name_id_map:
-                raise ClickException(NO_USER_ERROR.format(_))
+                raise CmemcError(NO_USER_ERROR.format(_))
             user_id = user_name_id_map[_]
             open_user_uri = f"{open_user_base_uri}/{user_id}/settings"
 

cmem_cmemc/commands/validation.py

@@ -8,19 +8,18 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 import click
-import timeago
 from click import Context, UsageError
 from click.shell_completion import CompletionItem
-from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.dp.shacl import validation
+from humanize import naturaltime
 from junit_xml import TestCase, TestSuite, to_xml_report_string
 from rich.progress import Progress, SpinnerColumn, TaskID, TimeElapsedColumn
 
 from cmem_cmemc import completion
 from cmem_cmemc.command import CmemcCommand
 from cmem_cmemc.command_group import CmemcGroup
-from cmem_cmemc.completion import finalize_completion
-from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.completion import finalize_completion, suppress_completion_errors
+from cmem_cmemc.context import ApplicationContext, build_caption
 from cmem_cmemc.exceptions import ServerError
 from cmem_cmemc.object_list import (
     DirectListPropertyFilter,
@@ -213,7 +212,7 @@ def _get_batch_validation_option(validation_: dict) -> tuple[str, str]:
     state = validation_["state"]
     graph = validation_["contextGraphIri"]
     stamp = datetime.fromtimestamp(validation_["executionStarted"] / 1000, tz=timezone.utc)
-    time_ago = timeago.format(stamp, datetime.now(tz=timezone.utc))
+    time_ago = naturaltime(stamp, when=datetime.now(tz=timezone.utc))
     resources = _get_resource_count(validation_)
     violations = _get_violation_count(validation_)
     return (
@@ -222,6 +221,7 @@ def _get_batch_validation_option(validation_: dict) -> tuple[str, str]:
     )
 
 
+@suppress_completion_errors
 def _complete_all_batch_validations(
     ctx: click.Context,  # noqa: ARG001
     param: click.Argument,  # noqa: ARG001
@@ -232,6 +232,7 @@ def _complete_all_batch_validations(
     return finalize_completion(candidates=options, incomplete=incomplete)
 
 
+@suppress_completion_errors
 def _complete_running_batch_validations(
     ctx: click.Context,  # noqa: ARG001
     param: click.Argument,  # noqa: ARG001
@@ -246,6 +247,7 @@ def _complete_running_batch_validations(
     return finalize_completion(candidates=options, incomplete=incomplete)
 
 
+@suppress_completion_errors
 def _complete_finished_batch_validations(
     ctx: click.Context,  # noqa: ARG001
     param: click.Argument,  # noqa: ARG001
@@ -330,10 +332,10 @@ def _wait_for_process_completion(
         progress.stop()
         progress.__exit__(None, None, None)
     if state.status == validation.STATUS_CANCELLED:
-        raise ServerError(app, "Process was cancelled.")
+        raise ServerError("Process was cancelled.")
     if state.status == validation.STATUS_ERROR:
         error_message = state.data.get("error", "")
-        raise ServerError(app, f"Process ended with error: {error_message}")
+        raise ServerError(f"Process ended with error: {error_message}")
     return state.status
 
 
@@ -579,13 +581,16 @@ def list_command(ctx: Context, filter_: tuple[tuple[str, str]], id_only: bool, r
             _get_violation_count(_),
         ]
         table.append(row)
+    filtered = len(filter_) > 0
     app.echo_info_table(
         table,
         headers=["ID", "Status", "Started", "Graph", "Resources", "Violations"],
-        caption=f"Validation Processes of {get_cmem_base_uri()}",
+        caption=build_caption(len(table), "validation process", filtered=filtered),
         cell_processing={2: TimeAgo(), 3: GraphLink()},
-        empty_table_message="No validation processes found. "
-        "Use `graph validation execute` to start a new validation process.",
+        empty_table_message="No validation processes found for these filters."
+        if filtered
+        else "No validation processes found."
+        " Use `graph validation execute` to start a new validation process.",
     )