ellf-cli 14.0.0__tar.gz → 17.0.4__tar.gz

{ellf_cli-14.0.0/ellf_cli.egg-info → ellf_cli-17.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ellf-cli
-Version: 14.0.0
+Version: 17.0.4
 Summary: Ellf Command Line Interface
 Home-page: https://prodi.gy
 Author: ExplosionAI GmbH

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/README.md

@@ -297,7 +297,7 @@ Create an asset on the cluster and register it with Ellf. Assets point to files
 | Argument | Type | Description | Default |
 | --- | --- | --- | --- |
 | `name` | `str` | Name of the asset |  |
-| `--kind` | `str` | Kind of the asset. Generally one of: ['Input', 'Model', 'Patterns] |  |
+| `--kind` | `str` | Kind of the asset. Generally one of: ['input', 'model', 'patterns'] |  |
 | `path` | `str` | Path of the asset |  |
 | `--version` | `str` | Version of the asset | `'0.0.0'` |
 | `--meta` | `str` | Asset meta, formatted as a JSON string | `'{}'` |
@@ -1290,6 +1290,93 @@ Fetch a batch of questions from a running annotation task. Mirrors the web app:
 | `--cluster` | `str` | Name, slug, or ID of the cluster to search for task name (or the last cluster if not set) | `None` |
 | `--json` | `bool` | Output the result as JSON | `False` |
 
+### `ellf users`
+
+View and manage users and invitations in your organization
+
+#### `ellf users list`
+
+List all users in the organization
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `--select` | `list[str]` | Comma-separated fields to select and show in output. Available: ['id', 'created', 'updated', 'name', 'org_id', 'org_name', 'person_id', 'email', 'avatar_url', 'locale', 'is_org_admin', 'is_org_developer', 'last_cluster_id', 'last_project_id', 'role'] | `['id', 'name', 'email', 'role']` |
+| `--role` | `str` | Filter by role | `None` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users info`
+
+Get detailed info for a user
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `email_name_or_id` | `Union[str, UUID]` | Email, name, or ID of the user |  |
+| `--select` | `list[str]` | Comma-separated fields to select and show in output. Available: ['id', 'created', 'updated', 'name', 'org_id', 'org_name', 'person_id', 'email', 'avatar_url', 'locale', 'is_org_admin', 'is_org_developer', 'last_cluster_id', 'last_project_id', 'groups', 'tags'] | `None` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users whoami`
+
+Show the currently authenticated user
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `--select` | `list[str]` | Comma-separated fields to select and show in output. Available: ['id', 'created', 'updated', 'name', 'org_id', 'org_name', 'person_id', 'email', 'avatar_url', 'locale', 'is_org_admin', 'is_org_developer', 'last_cluster_id', 'last_project_id', 'groups', 'tags'] | `None` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users update`
+
+Update a user's role, name, email, locale, or tags
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `email_name_or_id` | `Union[str, UUID]` | Email, name, or ID of the user |  |
+| `--name` | `str` | New name of the user | `None` |
+| `--email` | `str` | Email of the user | `None` |
+| `--locale` | `str` | Locale of the user (e.g. 'en') | `None` |
+| `--role` | `str` | Role of the user. One of: ['admin', 'developer', 'annotator'] | `None` |
+| `--tags` | `list[str]` | Comma-separated tags to set on the user (replaces existing tags) | `None` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users delete`
+
+Remove a user from the organization
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `email_name_or_id` | `Union[str, UUID]` | Email, name, or ID of the user |  |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users invite`
+
+Invite a new user to the organization by email
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `email` | `str` | Email address to invite to the organization |  |
+| `--role` | `str` | Role of the user. One of: ['admin', 'developer', 'annotator'] | `'annotator'` |
+| `--no-email` | `bool` | Create the invitation without sending the invitation email | `False` |
+| `--resend` | `bool` | Re-send the invitation email for an existing unclaimed invitation | `False` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users invitations`
+
+List pending invitations
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `--select` | `list[str]` | Comma-separated fields to select and show in output. Available: ['id', 'created', 'updated', 'org_id', 'email', 'claimed', 'vars', 'role'] | `['id', 'email', 'role', 'claimed']` |
+| `--all` | `bool` | Also include invitations that have already been claimed | `False` |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
+#### `ellf users uninvite`
+
+Revoke a pending invitation
+
+| Argument | Type | Description | Default |
+| --- | --- | --- | --- |
+| `email_or_id` | `Union[str, UUID]` | Email or ID of the invitation |  |
+| `--json` | `bool` | Output the result as JSON | `False` |
+
 ### `ellf publish`
 
 Publish
@@ -1315,7 +1402,7 @@ Transfer data to the cluster, and advertise it to Ellf. These steps can also be
 | `dest` | `str` | Destination path to copy the data to | `None` |
 | `--name` | `str` | Name of the asset | `None` |
 | `--version` | `str` | Version of the asset | `None` |
-| `--kind` | `str` | Kind of the asset. Generally one of: ['Input', 'Model', 'Patterns] |  |
+| `--kind` | `str` | Kind of the asset. Generally one of: ['input', 'model', 'patterns'] |  |
 | `--loader` | `str` | Loader to convert data for Prodigy | `None` |
 | `--meta` | `str` | Asset meta, formatted as a JSON string | `'{}'` |
 | `--exists-ok` | `bool` | Don't raise an error if it already exists | `False` |

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/about.json

@@ -1,7 +1,7 @@
 {
   "title": "Ellf CLI",
   "name": "ellf-cli",
-  "version": "14.0.0",
+  "version": "17.0.4",
   "summary": "Ellf Command Line Interface",
   "uri": "https://prodi.gy",
   "prog": "ellf",

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/cli.py

@@ -123,6 +123,7 @@ cli.placeholder("secrets", description=Messages.doc_secrets)
 cli.placeholder("services", description=Messages.doc_services)
 cli.placeholder("support", description=Messages.doc_support)
 cli.placeholder("tasks", description=Messages.doc_tasks)
+cli.placeholder("users", description=Messages.doc_users)
 cli.placeholder("publish", description="Publish")
 
 

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/commands/__init__.py

@@ -23,6 +23,7 @@ from . import (
     support,
     tasks,
     todos,
+    users,
 )
 from ._state import (
     cli_context,
@@ -54,6 +55,7 @@ __all__ = [
     "services",
     "secrets",
     "support",
+    "users",
     "general",
     "import_export",
     "plans",

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/commands/actions.py

@@ -194,8 +194,8 @@ def info(
     try:
         status = auth.broker_client.jobs.get_status(res.id)
         msg.text(f"State: {status.state}", icon="info")
-    except (BrokerError, *HTTPXErrors):
-        pass
+    except (BrokerError, *HTTPXErrors) as e:
+        msg.warn(f"Could not fetch live status from the cluster: {e}")
     print_info_table(res, exclude=["plan"], as_json=as_json, select=select)
     return res
 

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/commands/agents.py

@@ -227,8 +227,8 @@ def info(
     try:
         status = auth.broker_client.jobs.get_status(res.id)
         msg.text(f"State: {status.state.value}", icon="info")
-    except (BrokerError, *HTTPXErrors):
-        pass
+    except (BrokerError, *HTTPXErrors) as e:
+        msg.warn(f"Could not fetch live status from the cluster: {e}")
     print_info_table(res, exclude=["plan"], as_json=as_json, select=select)
     return res
 

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/commands/services.py

@@ -195,8 +195,8 @@ def info(
     try:
         status = auth.broker_client.jobs.get_status(res.id)
         msg.text(f"State: {status.state.value}", icon="info")
-    except (BrokerError, *HTTPXErrors):
-        pass
+    except (BrokerError, *HTTPXErrors) as e:
+        msg.warn(f"Could not fetch live status from the cluster: {e}")
     print_info_table(res, exclude=["plan"], as_json=as_json, select=select)
     return res
 

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/commands/tasks.py

@@ -200,8 +200,8 @@ def info(
     try:
         status = auth.broker_client.jobs.get_status(res.id)
         msg.text(f"State: {status.state.value}", icon="info")
-    except (BrokerError, *HTTPXErrors):
-        pass
+    except (BrokerError, *HTTPXErrors) as e:
+        msg.warn(f"Could not fetch live status from the cluster: {e}")
     print_info_table(res, exclude=["plan"], as_json=as_json, select=select)
     return res
 

ellf_cli-17.0.4/ellf_cli/commands/users.py

@@ -0,0 +1,369 @@
+import builtins
+from collections.abc import Sequence
+from datetime import datetime, timezone
+from typing import Literal, Optional, Union
+from uuid import UUID
+
+from radicli import Arg
+from wasabi import msg
+
+from ellf_pam_sdk import Client as PamClient
+from ellf_pam_sdk.errors import EllfError
+from ellf_pam_sdk.models import (
+    InvitationDetail,
+    InvitationReading,
+    InvitationSummary,
+    InvitationUpdating,
+    UserDetail,
+    UserReading,
+    UserSummary,
+    UserUpdating,
+)
+
+from ..cli import cli
+from ..errors import CLIError, EllfErrors, HTTPXErrors
+from ..messages import Messages
+from ..query import _try_uuid
+from ..ui import print_info_table, print_mutation_result, print_table_with_select
+from ._state import get_auth_state
+
+# Mirrors the role model of the web app's members page: a user is an
+# admin if is_org_admin is set, a developer if only is_org_developer is
+# set, and an annotator if neither is. Agent users are system users and
+# never listed by the API, so they don't appear here.
+UserRoleName = Literal["admin", "developer", "annotator"]
+
+
+def _role_of(user: Union[UserSummary, UserDetail]) -> str:
+    if user.is_org_admin:
+        return "admin"
+    if user.is_org_developer:
+        return "developer"
+    return "annotator"
+
+
+def _role_flags(role: UserRoleName) -> dict[str, bool]:
+    """Exclusive flag assignment for updates, as the web app does it."""
+    return {
+        "is_org_admin": role == "admin",
+        "is_org_developer": role == "developer",
+    }
+
+
+def _role_query(role: UserRoleName) -> UserReading:
+    """Server-side filter matching how _role_of classifies users."""
+    if role == "admin":
+        return UserReading(is_org_admin=True)
+    if role == "developer":
+        return UserReading(is_org_admin=False, is_org_developer=True)
+    return UserReading(is_org_admin=False, is_org_developer=False)
+
+
+def _resolve_user(email_name_or_id: Union[str, UUID]) -> UserDetail:
+    """Resolve a user by UUID, email, or display name.
+
+    Users have no slug and their Reading schema only filters on IDs and
+    role flags, so the generic slug/name resolver in query.py can't be
+    used here (an unknown field would fall through to an empty query,
+    which the API answers with the *current* user). Emails are unique
+    per org; names aren't, so ambiguous name matches are an error.
+    """
+    auth = get_auth_state()
+    record_id = _try_uuid(email_name_or_id)
+    if record_id is not None:
+        try:
+            return auth.client.user.read(id=record_id)
+        except EllfErrors.UserNotFound:
+            raise CLIError(
+                Messages.E038.format(noun="user", name_or_id=email_name_or_id)
+            )
+    value = str(email_name_or_id)
+    users = builtins.list(auth.client.user.all())
+    matches = [u for u in users if u.email.lower() == value.lower()]
+    if not matches:
+        matches = [u for u in users if u.name == value]
+    if len(matches) > 1:
+        ids = ", ".join(str(u.id) for u in matches)
+        raise CLIError(Messages.E061.format(name_or_id=value, ids=ids))
+    if not matches:
+        raise CLIError(Messages.E038.format(noun="user", name_or_id=value))
+    return auth.client.user.read(id=matches[0].id)
+
+
+@cli.subcommand(
+    "users",
+    "list",
+    # fmt: off
+    select=Arg(
+        "--select",
+        help=Messages.select.format(
+            opts=builtins.list(UserSummary.model_fields) + ["role"]
+        ),
+    ),
+    role=Arg("--role", help=Messages.filter_by.format(filter="role")),
+    as_json=Arg("--json", help=Messages.as_json),
+    # fmt: on
+)
+def list(
+    select: builtins.list[str] = ["id", "name", "email", "role"],
+    role: Optional[UserRoleName] = None,
+    as_json: bool = False,
+) -> Sequence[UserSummary]:
+    """List all users in the organization"""
+    client = get_auth_state().client
+    query = _role_query(role) if role is not None else None
+    items = builtins.list(client.user.all(query))
+    rows = [{**u.model_dump(), "role": _role_of(u)} for u in items]
+    print_table_with_select(rows, select=select, as_json=as_json)
+    return items
+
+
+@cli.subcommand(
+    "users",
+    "info",
+    email_name_or_id=Arg(help=Messages.user_email_name_or_id),
+    select=Arg(
+        "--select",
+        help=Messages.select.format(opts=builtins.list(UserDetail.model_fields)),
+    ),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def info(
+    email_name_or_id: Union[str, UUID],
+    select: Optional[builtins.list[str]] = None,
+    as_json: bool = False,
+) -> UserDetail:
+    """Get detailed info for a user"""
+    res = _resolve_user(email_name_or_id)
+    print_info_table(res, as_json=as_json, select=select)
+    return res
+
+
+@cli.subcommand(
+    "users",
+    "whoami",
+    select=Arg(
+        "--select",
+        help=Messages.select.format(opts=builtins.list(UserDetail.model_fields)),
+    ),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def whoami(
+    select: Optional[builtins.list[str]] = None,
+    as_json: bool = False,
+) -> UserDetail:
+    """Show the currently authenticated user"""
+    auth = get_auth_state()
+    res = auth.client.user.read(id=auth.user_id)
+    print_info_table(res, as_json=as_json, select=select)
+    return res
+
+
+@cli.subcommand(
+    "users",
+    "update",
+    email_name_or_id=Arg(help=Messages.user_email_name_or_id),
+    name=Arg("--name", help=Messages.new_name.format(noun="user")),
+    email=Arg("--email", help=Messages.email.format(noun="user")),
+    locale=Arg("--locale", help=Messages.user_locale),
+    role=Arg("--role", help=Messages.user_role),
+    tags=Arg("--tags", help=Messages.user_tags),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def update(
+    email_name_or_id: Union[str, UUID],
+    name: Optional[str] = None,
+    email: Optional[str] = None,
+    locale: Optional[str] = None,
+    role: Optional[UserRoleName] = None,
+    tags: Optional[builtins.list[str]] = None,
+    as_json: bool = False,
+) -> UserDetail:
+    """Update a user's role, name, email, locale, or tags"""
+    auth = get_auth_state()
+    user = _resolve_user(email_name_or_id)
+    if role is not None and user.id == auth.user_id:
+        raise CLIError(Messages.E062.format(name=user.email))
+    extra: dict = _role_flags(role) if role is not None else {}
+    if tags is not None:
+        # Only pass tags when given: the Updating schema's default ([])
+        # is dropped server-side, but an explicit None would null the
+        # column.
+        extra["tags"] = tags
+    body = UserUpdating(
+        id=user.id,
+        name=name,
+        email=email,
+        locale=locale,
+        **extra,
+    )
+    res = auth.client.user.update(body)
+    print_mutation_result(
+        {
+            "id": str(res.id),
+            "name": res.name,
+            "email": res.email,
+            "role": _role_of(res),
+        },
+        Messages.T051.format(noun="user", name=res.email),
+        as_json=as_json,
+    )
+    if not as_json:
+        print_info_table(res)
+    return res
+
+
+@cli.subcommand(
+    "users",
+    "delete",
+    email_name_or_id=Arg(help=Messages.user_email_name_or_id),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def delete(email_name_or_id: Union[str, UUID], as_json: bool = False) -> UUID:
+    """Remove a user from the organization"""
+    auth = get_auth_state()
+    user = _resolve_user(email_name_or_id)
+    try:
+        auth.client.user.delete(id=user.id)
+    except (EllfErrors.UserForbiddenDelete, EllfErrors.UserNotFound):
+        raise CLIError(Messages.E006.format(noun="user", name=email_name_or_id))
+    print_mutation_result(
+        {"id": str(user.id), "email": user.email, "deleted": True},
+        Messages.T003.format(noun="user", name=user.email),
+        as_json=as_json,
+    )
+    return user.id
+
+
+@cli.subcommand(
+    "users",
+    "invite",
+    email=Arg(help=Messages.invite_email),
+    role=Arg("--role", help=Messages.user_role),
+    no_email=Arg("--no-email", help=Messages.invite_no_email),
+    resend=Arg("--resend", help=Messages.invite_resend),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def invite(
+    email: str,
+    role: UserRoleName = "annotator",
+    no_email: bool = False,
+    resend: bool = False,
+    as_json: bool = False,
+) -> InvitationDetail:
+    """Invite a new user to the organization by email"""
+    client = get_auth_state().client
+    if resend:
+        invitation = client.invitation.exists(email=email, claimed=False)
+        if invitation is None:
+            raise CLIError(Messages.E038.format(noun="invitation", name_or_id=email))
+    else:
+        try:
+            invitation = client.invitation.create(email=email, vars={"role": role})
+        except EllfErrors.InvitationExists:
+            raise CLIError(Messages.E002.format(noun="invitation", name=email))
+        except EllfErrors.InvitationInvalid:
+            raise CLIError(Messages.E004.format(noun="invitation", name=email))
+    if not no_email:
+        _send_invitation_email(client, invitation)
+        msg.info(Messages.T052.format(email=email))
+    print_mutation_result(
+        {
+            "id": str(invitation.id),
+            "email": invitation.email,
+            "role": invitation.vars.get("role", role),
+        },
+        Messages.T002.format(noun="invitation", name=email),
+        as_json=as_json,
+    )
+    return invitation
+
+
+def _send_invitation_email(client: PamClient, invitation: InvitationDetail) -> None:
+    """Send the invitation email, mirroring the web app's bookkeeping:
+    stamp ``email_sent`` in the invitation vars on success and
+    ``email_failed`` on failure, so both surfaces report send status the
+    same way.
+    """
+    vars = dict(invitation.vars)
+    vars.pop("email_failed", None)
+    error: CLIError | None = None
+    try:
+        results = client.invitation.send(id=invitation.id)
+    except (EllfError, *HTTPXErrors) as e:
+        vars["email_failed"] = str(e)
+        error = CLIError(Messages.E063.format(email=invitation.email), str(e))
+    else:
+        result = results[0] if results else None
+        if result is None or result.status in ("rejected", "invalid"):
+            reason = (
+                result.reject_reason
+                if result is not None
+                else "Email service returned an empty response"
+            )
+            vars["email_failed"] = reason or "Failed sending invitation email"
+            error = CLIError(Messages.E063.format(email=invitation.email), reason)
+        else:
+            vars["email_sent"] = datetime.now(timezone.utc).isoformat()
+    client.invitation.update(InvitationUpdating(id=invitation.id, vars=vars))
+    if error is not None:
+        raise error
+
+
+@cli.subcommand(
+    "users",
+    "invitations",
+    # fmt: off
+    select=Arg(
+        "--select",
+        help=Messages.select.format(
+            opts=builtins.list(InvitationSummary.model_fields) + ["role"]
+        ),
+    ),
+    all_=Arg("--all", help=Messages.invitations_all),
+    as_json=Arg("--json", help=Messages.as_json),
+    # fmt: on
+)
+def invitations(
+    select: builtins.list[str] = ["id", "email", "role", "claimed"],
+    all_: bool = False,
+    as_json: bool = False,
+) -> Sequence[InvitationSummary]:
+    """List pending invitations"""
+    client = get_auth_state().client
+    query = None if all_ else InvitationReading(claimed=False)
+    items = builtins.list(client.invitation.all(query))
+    rows = [
+        {**inv.model_dump(), "role": inv.vars.get("role", "annotator")} for inv in items
+    ]
+    print_table_with_select(rows, select=select, as_json=as_json)
+    return items
+
+
+@cli.subcommand(
+    "users",
+    "uninvite",
+    email_or_id=Arg(help=Messages.invitation_email_or_id),
+    as_json=Arg("--json", help=Messages.as_json),
+)
+def uninvite(email_or_id: Union[str, UUID], as_json: bool = False) -> UUID:
+    """Revoke a pending invitation"""
+    client = get_auth_state().client
+    record_id = _try_uuid(email_or_id)
+    if record_id is None:
+        invitation = client.invitation.exists(email=str(email_or_id))
+        if invitation is None:
+            raise CLIError(
+                Messages.E038.format(noun="invitation", name_or_id=email_or_id)
+            )
+        record_id = invitation.id
+    try:
+        client.invitation.delete(id=record_id)
+    except (EllfErrors.InvitationNotFound, EllfErrors.InvitationForbiddenDelete):
+        raise CLIError(Messages.E006.format(noun="invitation", name=email_or_id))
+    print_mutation_result(
+        {"id": str(record_id), "deleted": True},
+        Messages.T003.format(noun="invitation", name=email_or_id),
+        as_json=as_json,
+    )
+    return record_id

{ellf_cli-14.0.0 → ellf_cli-17.0.4}/ellf_cli/config.py

@@ -5,8 +5,10 @@ from pathlib import Path
 from typing import Literal, overload
 from uuid import UUID
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
+from .errors import CLIError
+from .messages import Messages
 from .ty import JSONableDict
 from .util import APP_NAME, get_app_dir
 
@@ -68,6 +70,8 @@ class SavedSettings(BaseModel):
                 return cls.blank()
             else:
                 raise
+        except ValidationError as e:
+            raise CLIError(Messages.E187.format(path=path), e)
 
     def reset_defaults(self) -> None:
         """Reset defaut project/task/action/agent/service, e.g. on host changes."""