dataplat 0.1.0__py3-none-any.whl

dataplat/__init__.py

@@ -0,0 +1,3 @@
+"""DNA HQ CLI - Command line tools for DNA HQ operations."""
+
+__version__ = "0.1.0"

dataplat/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI command adapters."""

dataplat/cli/_missing.py

@@ -0,0 +1,108 @@
+"""Stub apps and installer flow for areas whose extras are not installed.
+
+When an area's optional dependencies are absent, ``main`` mounts a stub
+group in its place so ``dp <area> ...`` explains what is missing, offers
+to install the extra into dp's own environment, and re-runs the original
+command on success.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from typing import Any, NoReturn
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+from typer.core import TyperGroup
+
+from dataplat.core.deps import (
+    AREAS,
+    install_command,
+    install_spec,
+    manual_hint,
+    missing_modules,
+)
+
+console = Console()
+
+
+def run_install(extras: list[str], *, yes: bool) -> bool:
+    """Install ``extras`` into dp's environment; True on success.
+
+    Always shows the exact command first. Prompts unless ``yes``; in
+    non-interactive sessions it prints the command and declines instead
+    of installing silently.
+    """
+    cmd = install_command(extras)
+    if cmd is None:
+        console.print(f"[yellow]{escape(manual_hint(extras))}[/yellow]")
+        return False
+    console.print(f"[bold]Will run:[/bold] {escape(' '.join(cmd))}")
+    if not yes:
+        if not sys.stdin.isatty():
+            console.print(
+                "[yellow]Non-interactive session; run the command above "
+                "yourself, or pass --yes.[/yellow]"
+            )
+            return False
+        if not typer.confirm("Proceed?", default=True):
+            return False
+    proc = subprocess.run(cmd)
+    if proc.returncode != 0:
+        console.print(f"[red]Install failed (exit {proc.returncode}).[/red]")
+        return False
+    return True
+
+
+def reexec() -> NoReturn:
+    """Re-run the original dp invocation against the updated environment."""
+    os.execvp(sys.argv[0], sys.argv)
+
+
+def build_missing_deps_app(area: str, help_text: str) -> typer.Typer:
+    """A stand-in Typer group for ``area`` while its extra is missing."""
+    spec = AREAS[area]
+
+    def handle() -> None:
+        missing = missing_modules(area)
+        console.print(
+            f"[yellow]`dp {area}` needs {', '.join(missing) or spec.extra} — "
+            f"the '{spec.extra}' extra "
+            f"([bold]{escape(install_spec([spec.extra]))}[/bold]).[/yellow]"
+        )
+        if run_install([spec.extra], yes=False):
+            console.print("[green]Installed. Re-running your command…[/green]")
+            reexec()
+        raise typer.Exit(code=1)
+
+    class MissingDepsGroup(TyperGroup):
+        """Subcommands resolve before the group callback runs, so a plain
+        empty group would die with "No such command" instead of explaining
+        the missing extra. Intercept resolution and run the handler for any
+        subcommand. (No direct click import: typer >= 0.27 vendors click,
+        so we only rely on the TyperGroup surface.)"""
+
+        def list_commands(self, ctx: Any) -> list[str]:
+            return []
+
+        def resolve_command(self, ctx: Any, args: Any) -> Any:
+            handle()
+            raise AssertionError("unreachable: handle() exits or re-execs")
+
+    stub = typer.Typer(
+        name=area,
+        cls=MissingDepsGroup,
+        help=f"{help_text} (needs extra: {spec.extra})",
+        invoke_without_command=True,
+        context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    )
+
+    @stub.callback()
+    def _missing_deps(ctx: typer.Context) -> None:
+        if ctx.invoked_subcommand is None:
+            handle()
+
+    return stub

dataplat/cli/bi/__init__.py

@@ -0,0 +1 @@
+"""BI area — dashboards and analytics front-ends."""

dataplat/cli/bi/app.py

@@ -0,0 +1,14 @@
+"""BI command area."""
+
+from __future__ import annotations
+
+import typer
+
+from dataplat.cli.bi import superset
+
+app = typer.Typer(
+    name="bi",
+    help="Business-intelligence tools (Superset)",
+    no_args_is_help=True,
+)
+app.add_typer(superset.app, name="superset")

dataplat/cli/bi/superset.py

@@ -0,0 +1,558 @@
+"""Superset management commands."""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+
+import httpx
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from dataplat.core.errors import AuthError, ConfigError, ServiceError
+from dataplat.services.superset.client import (
+    create_user as _create_user,
+)
+from dataplat.services.superset.client import (
+    delete_user as _delete_user,
+)
+from dataplat.services.superset.client import (
+    get_auth_config_from_env,
+)
+from dataplat.services.superset.client import (
+    iter_groups as _iter_groups,
+)
+from dataplat.services.superset.client import (
+    iter_roles as _iter_roles,
+)
+from dataplat.services.superset.client import (
+    iter_users as _iter_users,
+)
+from dataplat.services.superset.client import (
+    login as _login,
+)
+from dataplat.services.superset.client import (
+    resolve_group_ids as _resolve_group_ids,
+)
+from dataplat.services.superset.client import (
+    resolve_role_ids as _resolve_role_ids,
+)
+from dataplat.services.superset.client import (
+    update_user as _update_user,
+)
+from dataplat.services.superset.client import (
+    user_group_ids as _user_group_ids,
+)
+from dataplat.services.superset.client import (
+    user_role_ids as _user_role_ids,
+)
+
+app = typer.Typer(
+    name="superset",
+    help="Manage Superset resources",
+    no_args_is_help=True,
+)
+
+users_app = typer.Typer(
+    name="users",
+    help="Manage Superset users",
+    no_args_is_help=True,
+)
+
+roles_app = typer.Typer(
+    name="roles",
+    help="Manage Superset roles",
+    no_args_is_help=True,
+)
+
+groups_app = typer.Typer(
+    name="groups",
+    help="Inspect Superset groups",
+    no_args_is_help=True,
+)
+
+app.add_typer(users_app, name="users")
+app.add_typer(roles_app, name="roles")
+app.add_typer(groups_app, name="groups")
+
+console = Console()
+
+
+class RoleOrder(str, Enum):
+    """Role list ordering options."""
+
+    by_name = "name"
+    by_id = "id"
+
+
+class RoleOrderDir(str, Enum):
+    """Role list ordering direction options."""
+
+    asc = "asc"
+    desc = "desc"
+
+
+class UserRoleMatch(str, Enum):
+    """How to match users by role set."""
+
+    exact = "exact"
+    subset = "subset"
+    any = "any"
+
+
+def _load_auth_context() -> tuple[str, str, str]:
+    try:
+        cfg = get_auth_config_from_env()
+    except ConfigError as exc:
+        console.print(f"[red]Error: {exc}[/red]")
+        raise typer.Exit(code=1)
+    return cfg.base_url, cfg.username, cfg.password
+
+
+@roles_app.command("list")
+def list_roles(
+    order_by: RoleOrder = typer.Option(
+        RoleOrder.by_name,
+        "--order",
+        help="Order roles by name or id",
+    ),
+    order_dir: RoleOrderDir = typer.Option(
+        RoleOrderDir.asc,
+        "--order-dir",
+        help="Sort direction (asc or desc)",
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Emit JSON instead of a table"),
+):
+    """List available Superset roles."""
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+            roles = list(_iter_roles(client, base_url, access_token))
+    except (AuthError, ServiceError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    if as_json:
+        typer.echo(json.dumps(roles, indent=2, ensure_ascii=False))
+        return
+
+    if not roles:
+        console.print("[yellow]No roles found[/yellow]")
+        return
+
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=box.SIMPLE_HEAVY,
+        show_lines=False,
+        expand=True,
+    )
+    table.add_column("ID", style="dim", no_wrap=True)
+    table.add_column("Name", style="cyan")
+
+    def _sort_by_id(role: dict) -> int:
+        return int(role.get("id") or 0)
+
+    def _sort_by_name(role: dict) -> str:
+        return str(role.get("name", ""))
+
+    sort_key = _sort_by_id if order_by == RoleOrder.by_id else _sort_by_name
+    reverse = order_dir == RoleOrderDir.desc
+
+    for role in sorted(roles, key=sort_key, reverse=reverse):
+        role_id = role.get("id")
+        name = role.get("name", "")
+        table.add_row(str(role_id) if role_id is not None else "", str(name))
+
+    console.print(table)
+
+
+@users_app.command("create")
+def create_user(
+    username: str = typer.Argument(..., help="Superset username to create"),
+    password: str = typer.Option(
+        ...,
+        "--password",
+        help="Password for the new user (omit to be prompted without echo).",
+        prompt=True,
+        hide_input=True,
+        confirmation_prompt=True,
+    ),
+    email: str = typer.Option(
+        ..., "--email", "-e", help="Email for the new user"
+    ),
+    first_name: str | None = typer.Option(
+        None, "--first-name", help="First name for the new user"
+    ),
+    last_name: str | None = typer.Option(
+        None, "--last-name", help="Last name for the new user"
+    ),
+    role_name: list[str] | None = typer.Option(
+        None,
+        "--role",
+        "-r",
+        help="Role name to assign (can be repeated). Defaults to Gamma",
+    ),
+    group_name: list[str] | None = typer.Option(
+        None,
+        "--group",
+        "-g",
+        help="Group name to assign (can be repeated)",
+    ),
+    active: bool = typer.Option(True, "--active/--inactive", help="User is active"),
+):
+    """Create a Superset user."""
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    resolved_email = email
+    resolved_first_name = first_name or username
+    resolved_last_name = last_name or "User"
+    role_names = role_name if role_name else ["Gamma"]
+    group_names = group_name if group_name else []
+
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+            role_ids = _resolve_role_ids(client, base_url, access_token, role_names)
+            payload = {
+                "username": username,
+                "first_name": resolved_first_name,
+                "last_name": resolved_last_name,
+                "email": resolved_email,
+                "password": password,
+                "active": active,
+                "roles": role_ids,
+            }
+            if group_names:
+                group_ids = _resolve_group_ids(
+                    client, base_url, access_token, group_names
+                )
+                payload["groups"] = group_ids
+
+            response = _create_user(client, base_url, access_token, payload)
+    except (AuthError, ServiceError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    user_id = response.get("id") or response.get("result", {}).get("id")
+    console.print(
+        "[green]✓ Superset user created[/green] "
+        f"[dim](username={username}, id={user_id})[/dim]"
+    )
+
+
+@users_app.command("update")
+def update_users(
+    user_ids: list[int] | None = typer.Option(
+        None,
+        "--user-id",
+        help="Only update specific user id(s) (repeatable)",
+    ),
+    email: list[str] | None = typer.Option(
+        None,
+        "--email",
+        help="Only update specific user email(s) (repeatable)",
+    ),
+    filter_role: list[str] | None = typer.Option(
+        None,
+        "--filter-role",
+        help="Only update users with these roles (repeatable)",
+    ),
+    match: UserRoleMatch = typer.Option(
+        UserRoleMatch.exact,
+        "--match",
+        help="Role match mode for filtering (exact, subset, any)",
+    ),
+    add_group: list[str] | None = typer.Option(
+        None,
+        "--add-group",
+        help="Group to add (repeatable)",
+    ),
+    remove_group: list[str] | None = typer.Option(
+        None,
+        "--remove-group",
+        help="Group to remove (repeatable)",
+    ),
+    set_group: list[str] | None = typer.Option(
+        None,
+        "--set-group",
+        help="Replace groups with this list (repeatable)",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Preview changes without updating users",
+    ),
+):
+    """Update users in bulk based on role filters and group changes."""
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    if not any([add_group, remove_group, set_group]):
+        console.print("[red]Error: specify at least one group update flag[/red]")
+        raise typer.Exit(code=1)
+
+    if set_group and (add_group or remove_group):
+        console.print(
+            "[red]Error: --set-group cannot be combined with --add-group or --remove-group[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    user_id_set = set(user_ids or [])
+    email_set = {e.lower() for e in (email or [])}
+
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+
+            filter_role_ids = (
+                _resolve_role_ids(client, base_url, access_token, filter_role)
+                if filter_role
+                else []
+            )
+            add_group_ids = (
+                _resolve_group_ids(client, base_url, access_token, add_group)
+                if add_group
+                else []
+            )
+            remove_group_ids = (
+                _resolve_group_ids(client, base_url, access_token, remove_group)
+                if remove_group
+                else []
+            )
+            set_group_ids = (
+                _resolve_group_ids(client, base_url, access_token, set_group)
+                if set_group
+                else []
+            )
+
+            matched = 0
+            updated = 0
+
+            for user in _iter_users(client, base_url, access_token):
+                user_id = user.get("id")
+                if not isinstance(user_id, int):
+                    continue
+
+                if user_id_set and user_id not in user_id_set:
+                    continue
+
+                if email_set:
+                    user_email = user.get("email")
+                    if not isinstance(user_email, str):
+                        continue
+                    if user_email.lower() not in email_set:
+                        continue
+
+                user_roles = _user_role_ids(user)
+                if filter_role_ids:
+                    if not user_roles:
+                        continue
+                    user_roles_set = set(user_roles)
+                    filter_roles_set = set(filter_role_ids)
+                    if match == UserRoleMatch.exact:
+                        if user_roles_set != filter_roles_set:
+                            continue
+                    elif match == UserRoleMatch.subset:
+                        if not user_roles_set.issubset(filter_roles_set):
+                            continue
+                    else:
+                        if not user_roles_set.intersection(filter_roles_set):
+                            continue
+
+                user_groups = _user_group_ids(user)
+                updated_groups = user_groups
+
+                if set_group is not None:
+                    updated_groups = list(set_group_ids)
+                else:
+                    updated_groups = list(set(user_groups).union(add_group_ids))
+                    if remove_group_ids:
+                        updated_groups = [
+                            gid for gid in updated_groups if gid not in remove_group_ids
+                        ]
+
+                if set(updated_groups) == set(user_groups):
+                    continue
+
+                matched += 1
+                if dry_run:
+                    continue
+
+                payload = {
+                    "roles": user_roles,
+                    "groups": updated_groups,
+                }
+                _update_user(client, base_url, access_token, user_id, payload)
+                updated += 1
+    except (AuthError, ServiceError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    if matched == 0:
+        console.print("[yellow]No users matched the criteria[/yellow]")
+        return
+
+    if dry_run:
+        console.print(
+            f"[green]Matched {matched} user(s)[/green] (dry run; no updates applied)"
+        )
+        return
+
+    console.print(f"[green]Updated {updated} user(s)[/green]")
+
+
+@users_app.command("list")
+def list_users(
+    filter_role: list[str] | None = typer.Option(
+        None,
+        "--filter-role",
+        help="Only show users holding this role (repeatable).",
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Emit JSON instead of a table"),
+):
+    """List Superset users."""
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+            users = list(_iter_users(client, base_url, access_token))
+            role_filter_ids: set[int] = set()
+            if filter_role:
+                role_filter_ids = set(
+                    _resolve_role_ids(client, base_url, access_token, filter_role)
+                )
+    except (AuthError, ServiceError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    if role_filter_ids:
+        users = [
+            u for u in users if role_filter_ids & set(_user_role_ids(u))
+        ]
+
+    if as_json:
+        typer.echo(json.dumps(users, indent=2, ensure_ascii=False))
+        return
+
+    if not users:
+        console.print("[yellow]No users found[/yellow]")
+        return
+
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=box.SIMPLE_HEAVY,
+        expand=True,
+    )
+    table.add_column("ID", style="dim", no_wrap=True)
+    table.add_column("Username", style="cyan")
+    table.add_column("Name")
+    table.add_column("Email")
+    table.add_column("Active", justify="center")
+    table.add_column("Roles", style="dim")
+
+    for user in sorted(users, key=lambda u: str(u.get("username", ""))):
+        roles = user.get("roles") or []
+        role_names = ", ".join(
+            str(r.get("name", r)) if isinstance(r, dict) else str(r) for r in roles
+        )
+        full_name = " ".join(
+            part
+            for part in (user.get("first_name"), user.get("last_name"))
+            if part
+        )
+        table.add_row(
+            str(user.get("id", "")),
+            str(user.get("username", "")),
+            full_name,
+            str(user.get("email", "")),
+            "yes" if user.get("active") else "no",
+            role_names,
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]Total: {len(users)} user(s)[/dim]")
+
+
+@users_app.command("delete")
+def delete_users(
+    user_ids: list[int] = typer.Argument(..., help="Superset user ID(s) to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete Superset user(s) by ID."""
+    if not yes:
+        typer.confirm(
+            f"Delete Superset user(s) {', '.join(str(u) for u in user_ids)}?",
+            abort=True,
+        )
+
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    failures = 0
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+            for user_id in user_ids:
+                try:
+                    _delete_user(client, base_url, access_token, user_id)
+                    console.print(f"[green]✓ Deleted user {user_id}[/green]")
+                except ServiceError as exc:
+                    console.print(f"[red]✗ user {user_id}: {exc}[/red]")
+                    failures += 1
+    except (AuthError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    if failures:
+        raise typer.Exit(code=1)
+
+
+@groups_app.command("list")
+def list_groups(
+    as_json: bool = typer.Option(False, "--json", help="Emit JSON instead of a table"),
+):
+    """List Superset groups."""
+    base_url, admin_username, admin_password = _load_auth_context()
+
+    try:
+        with httpx.Client() as client:
+            access_token = _login(client, base_url, admin_username, admin_password)
+            groups = list(_iter_groups(client, base_url, access_token))
+    except (AuthError, ServiceError, ConfigError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1)
+
+    if as_json:
+        typer.echo(json.dumps(groups, indent=2, ensure_ascii=False))
+        return
+
+    if not groups:
+        console.print("[yellow]No groups found[/yellow]")
+        return
+
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=box.SIMPLE_HEAVY,
+        expand=True,
+    )
+    table.add_column("ID", style="dim", no_wrap=True)
+    table.add_column("Name", style="cyan")
+    table.add_column("Label")
+    table.add_column("Description")
+
+    for group in sorted(groups, key=lambda g: str(g.get("name", ""))):
+        table.add_row(
+            str(group.get("id", "")),
+            str(group.get("name", "")),
+            str(group.get("label", "") or ""),
+            str(group.get("description", "") or ""),
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]Total: {len(groups)} group(s)[/dim]")

dataplat/cli/ci/__init__.py

@@ -0,0 +1 @@
+"""CI area — build/runner infrastructure."""