qod-cli 0.3.7__py3-none-any.whl

qod_cli/commands/user.py

@@ -0,0 +1,62 @@
+import typer
+
+from ._run import call
+
+app = typer.Typer(help="User principals.")
+
+
+@app.command("list")
+def list_(ctx: typer.Context, tenant: str = typer.Option(None, "--tenant", help="Omit = all users incl. superusers.")):
+    call(ctx, "GET", "/api/user/list", params={"tenant": tenant})
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    username: str = typer.Option(..., "--username"),
+    tenant: str = typer.Option(None, "--tenant"),
+    superuser: bool = typer.Option(False, "--superuser", help="Create a superuser (no tenant)."),
+    password: str = typer.Option(None, "--password", help="Prompted when omitted."),
+    role: str = typer.Option("user", "--role"),
+):
+    if superuser and tenant:
+        raise typer.BadParameter("--superuser and --tenant are mutually exclusive")
+    if not superuser and not tenant:
+        raise typer.BadParameter("pass --tenant, or --superuser for a tenant-less superuser")
+    if password is None:
+        password = typer.prompt("Password", hide_input=True, confirmation_prompt=True)
+    call(
+        ctx,
+        "POST",
+        "/api/user/create",
+        body={"tenant": None if superuser else tenant, "username": username, "password": password, "role": role},
+    )
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    user_id: str = typer.Argument(..., metavar="ID"),
+    tenant: str = typer.Option(None, "--tenant"),
+    password: str = typer.Option(None, "--password", help="Omit = no rotation."),
+    role: str = typer.Option(None, "--role"),
+):
+    body: dict = {"id": user_id}
+    if tenant is not None:
+        body["tenant"] = tenant
+    if password is not None:
+        body["password"] = password
+    if role is not None:
+        body["role"] = role
+    call(ctx, "POST", "/api/user/update", body=body)
+
+
+@app.command()
+def delete(ctx: typer.Context, user_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/user/delete", body={"id": user_id})
+
+
+@app.command()
+def effective(ctx: typer.Context, user_id: str = typer.Argument(..., metavar="ID")):
+    """Closure of roles, groups, table permissions, and pool grants."""
+    call(ctx, "GET", f"/api/user/{user_id}/effective")

qod_cli/config.py

@@ -0,0 +1,107 @@
+"""Profile file + env + flag precedence.
+
+Resolution order per setting: explicit override (command flag) > QOD_* env
+var > profile file > built-in default. The profile file is TOML at the
+platform config dir (QOD_CONFIG_FILE overrides the full path) and is written
+with mode 0600 because it can hold a session token and an opt-in SQL password.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+import platformdirs
+import tomli_w
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+ENV_VARS = {
+    "manager_url": "QOD_MANAGER_URL",
+    "api_key": "QOD_API_KEY",
+    "token": "QOD_TOKEN",
+    "edge_host": "QOD_HOST",
+    "edge_port": "QOD_PORT",
+    "edge_tls": "QOD_TLS",
+    "edge_tls_verify": "QOD_TLS_VERIFY",
+    "tenant": "QOD_TENANT",
+    "pool": "QOD_POOL",
+    "sql_user": "QOD_USER",
+    "sql_password": "QOD_PASSWORD",
+    "superuser": "QOD_SUPERUSER",
+}
+
+
+@dataclass
+class Settings:
+    manager_url: str = "http://localhost:20900"
+    api_key: str = ""
+    token: str = ""
+    edge_host: str = "localhost"
+    edge_port: int = 31338
+    edge_tls: bool = True
+    edge_tls_verify: bool = False
+    tenant: str = ""
+    pool: str = ""
+    sql_user: str = ""
+    sql_password: str = ""
+    superuser: bool = False
+
+
+def config_path() -> Path:
+    env = os.environ.get("QOD_CONFIG_FILE")
+    if env:
+        return Path(env)
+    return Path(platformdirs.user_config_dir("qod", appauthor=False, roaming=True)) / "config.toml"
+
+
+def _read_file() -> dict:
+    path = config_path()
+    if not path.exists():
+        return {}
+    with path.open("rb") as f:
+        return tomllib.load(f)
+
+
+def _coerce(name: str, kind: type, raw) -> object:
+    if kind is bool:
+        if isinstance(raw, bool):
+            return raw
+        return str(raw).strip().lower() in ("true", "1", "yes")
+    if kind is int:
+        return int(raw)
+    return str(raw)
+
+
+def load_settings(profile: str = "default", overrides: dict | None = None) -> Settings:
+    file_values = _read_file().get("profiles", {}).get(profile, {})
+    overrides = overrides or {}
+    values: dict = {}
+    for f in fields(Settings):
+        if f.name in overrides and overrides[f.name] is not None:
+            raw = overrides[f.name]
+        elif os.environ.get(ENV_VARS[f.name]) is not None:
+            raw = os.environ[ENV_VARS[f.name]]
+        elif f.name in file_values:
+            raw = file_values[f.name]
+        else:
+            continue
+        values[f.name] = _coerce(f.name, f.type if isinstance(f.type, type) else type(f.default), raw)
+    return Settings(**values)
+
+
+def save_profile(profile: str, values: dict) -> None:
+    data = _read_file()
+    profiles = data.setdefault("profiles", {})
+    current = profiles.setdefault(profile, {})
+    current.update({k: v for k, v in values.items() if v is not None})
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("wb") as f:
+        tomli_w.dump(data, f)
+    os.chmod(path, 0o600)

qod_cli/main.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass
+
+import typer
+
+from . import __version__
+from .config import Settings, load_settings
+
+app = typer.Typer(no_args_is_help=True, add_completion=False, help="quack-on-demand CLI")
+
+
+@dataclass
+class AppCtx:
+    settings: Settings
+    json_output: bool
+    profile: str
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"qod {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    profile: str = typer.Option("default", "--profile", envvar="QOD_PROFILE", help="Named profile."),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON responses."),
+    version: bool = typer.Option(
+        False, "--version", callback=_version_callback, is_eager=True, help="Print version and exit."
+    ),
+) -> None:
+    ctx.obj = AppCtx(settings=load_settings(profile), json_output=json_output, profile=profile)
+
+
+@app.command()
+def health(ctx: typer.Context):
+    """Liveness plus pool/node counts (open endpoint)."""
+    from .commands._run import call
+
+    call(ctx, "GET", "/health")
+
+
+from .commands import config_cmd  # noqa: E402
+
+app.add_typer(config_cmd.app, name="config")
+
+from .commands import auth  # noqa: E402
+
+app.command()(auth.login)
+app.command()(auth.logout)
+app.command()(auth.whoami)
+app.add_typer(auth.app, name="auth")
+
+from .commands import database, tenant  # noqa: E402
+
+app.add_typer(tenant.app, name="tenant")
+app.add_typer(database.app, name="database")
+
+from .commands import node, pool  # noqa: E402
+
+app.add_typer(pool.app, name="pool")
+app.add_typer(node.app, name="node")
+app.add_typer(node.statement_app, name="statement")
+
+from .commands import group, membership, role, user  # noqa: E402
+
+app.add_typer(user.app, name="user")
+app.add_typer(role.app, name="role")
+app.add_typer(group.app, name="group")
+app.add_typer(membership.app, name="membership")
+
+from .commands import catalog, tag  # noqa: E402
+
+app.add_typer(catalog.app, name="catalog")
+app.add_typer(tag.app, name="tag")
+
+from .commands import federation, maintenance, manifest  # noqa: E402
+
+app.add_typer(maintenance.app, name="maintenance")
+app.add_typer(manifest.app, name="manifest")
+app.add_typer(federation.app, name="federation")
+
+from .commands import telemetry  # noqa: E402
+
+app.add_typer(telemetry.audit_app, name="audit")
+app.add_typer(telemetry.history_app, name="history")
+app.command()(telemetry.usage)
+
+from .commands import sql_cmd  # noqa: E402
+
+app.command("sql")(sql_cmd.sql)
+
+
+def main() -> None:
+    app()

qod_cli/output.py

@@ -0,0 +1,66 @@
+"""Human-readable Rich rendering, or raw JSON with --json (the stable
+scripting interface)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+_console = Console(soft_wrap=True)
+
+
+def _cell(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, default=str)
+    return str(value)
+
+
+def _render_rows(rows: list[dict]) -> None:
+    columns: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in columns:
+                columns.append(key)
+    table = Table(show_header=True, header_style="bold")
+    for col in columns:
+        table.add_column(col)
+    for row in rows:
+        table.add_row(*(_cell(row.get(col)) for col in columns))
+    _console.print(table)
+
+
+def render(data: Any, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps(data, indent=2, default=str))
+        return
+    if data is None:
+        print("ok")
+        return
+    if isinstance(data, str):
+        print(data)
+        return
+    if isinstance(data, dict) and len(data) == 1:
+        (only_value,) = data.values()
+        if isinstance(only_value, list):
+            data = only_value
+    if isinstance(data, list):
+        if data and all(isinstance(item, dict) for item in data):
+            _render_rows(data)
+        else:
+            for item in data:
+                print(_cell(item))
+        return
+    if isinstance(data, dict):
+        table = Table(show_header=False)
+        table.add_column("key", style="bold")
+        table.add_column("value")
+        for key, value in data.items():
+            table.add_row(key, _cell(value))
+        _console.print(table)
+        return
+    print(_cell(data))

qod_cli/rest.py

@@ -0,0 +1,73 @@
+"""One httpx client for the manager REST plane.
+
+Auth: X-API-Key carries either the static api_key or the session JWT written
+by `qod login` (api_key wins when both are set, matching apiKeyGuard which
+accepts either).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .config import Settings
+
+
+class ApiError(Exception):
+    def __init__(self, status: int, error: str, message: str):
+        self.status = status
+        self.error = error
+        self.message = message
+        super().__init__(f"{status} {error}: {message}")
+
+
+class RestClient:
+    def __init__(self, settings: Settings):
+        self._settings = settings
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: dict | None = None,
+        body: Any | None = None,
+        text: bool = False,
+    ) -> Any:
+        settings = self._settings
+        headers = {}
+        key = settings.api_key or settings.token
+        if key:
+            headers["X-API-Key"] = key
+        query = {}
+        for name, value in (params or {}).items():
+            if value is None:
+                continue
+            query[name] = "true" if value is True else "false" if value is False else str(value)
+        kwargs: dict = {"params": query, "headers": headers, "timeout": 30.0}
+        if isinstance(body, str):
+            kwargs["content"] = body.encode()
+            headers["Content-Type"] = "text/plain"
+        elif body is not None:
+            kwargs["json"] = body
+        try:
+            response = httpx.request(method, settings.manager_url + path, **kwargs)
+        except httpx.HTTPError as exc:
+            raise ApiError(0, "connection_error", f"{settings.manager_url}: {exc}")
+        if response.is_success:
+            if text:
+                return response.text
+            if not response.content:
+                return None
+            return response.json()
+        try:
+            payload = response.json()
+            if isinstance(payload, dict):
+                error, message = payload.get("error", "error"), payload.get("message", response.text)
+            else:
+                error, message = "error", response.text
+        except ValueError:
+            error, message = "error", response.text or response.reason_phrase
+        if response.status_code == 401 and not settings.api_key:
+            message = "session expired or invalid, run qod login"
+        raise ApiError(response.status_code, error, message)

qod_cli/sql.py

@@ -0,0 +1,80 @@
+"""FlightSQL plane over ADBC, adapted from examples/python/client.py.
+
+pyarrow and the ADBC driver import lazily inside functions so `qod tenant
+list` never pays their import cost.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+
+from .config import Settings
+
+
+class SqlClient:
+    def __init__(self, conn):
+        self._conn = conn
+
+    @classmethod
+    def connect(cls, settings: Settings) -> "SqlClient":
+        import adbc_driver_flightsql.dbapi as flight_sql
+        from adbc_driver_flightsql import DatabaseOptions
+
+        scheme = "grpc+tls" if settings.edge_tls else "grpc"
+        uri = f"{scheme}://{settings.edge_host}:{settings.edge_port}"
+        hdr = DatabaseOptions.RPC_CALL_HEADER_PREFIX.value
+        db_kwargs = {
+            "username": settings.sql_user,
+            "password": settings.sql_password,
+            hdr + "tenant": settings.tenant,
+            hdr + "pool": settings.pool,
+        }
+        if settings.superuser:
+            db_kwargs[hdr + "superuser"] = "true"
+        if settings.edge_tls and not settings.edge_tls_verify:
+            db_kwargs[DatabaseOptions.TLS_SKIP_VERIFY.value] = "true"
+        conn = flight_sql.connect(uri=uri, db_kwargs=db_kwargs, autocommit=True)
+        return cls(conn)
+
+    def query(self, sql: str):
+        with self._conn.cursor() as cur:
+            cur.execute(sql)
+            return cur.fetch_arrow_table()
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def __enter__(self) -> "SqlClient":
+        return self
+
+    def __exit__(self, *_exc) -> None:
+        self.close()
+
+
+def _row(table, index: int) -> dict:
+    out: dict = {}
+    for name in table.column_names:
+        value = table.column(name)[index].as_py()
+        out[name] = value if isinstance(value, (int, float, str, bool, type(None))) else str(value)
+    return out
+
+
+def render_table(table, mode: str) -> None:
+    rows = [_row(table, i) for i in range(table.num_rows)]
+    if mode == "json":
+        print(json.dumps(rows, indent=2, default=str))
+        return
+    if mode == "csv":
+        buf = io.StringIO()
+        writer = csv.DictWriter(buf, fieldnames=table.column_names)
+        writer.writeheader()
+        writer.writerows(rows)
+        sys.stdout.write(buf.getvalue())
+        return
+    from .output import render
+
+    render(rows if rows else f"(empty result: {', '.join(table.column_names)})", as_json=False)
+    print(f"-- {table.num_rows} rows", file=sys.stderr)

qod_cli-0.3.7.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: qod-cli
+Version: 0.3.7
+Summary: Command-line client for quack-on-demand: admin REST plane and FlightSQL plane
+Requires-Python: >=3.10
+Requires-Dist: adbc-driver-flightsql>=1.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: pyarrow>=16.0
+Requires-Dist: pyreadline3>=3.4; sys_platform == 'win32'
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'

qod_cli-0.3.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+qod_cli/__init__.py,sha256=J0I0c7-a50EOnWXMryTu_E6xhXSYFBPjVpeYP_a3vRI,22
+qod_cli/config.py,sha256=oiOc8SW3OIyifbdnaA8eOVyZFkS2yrAV4YHzxD32Epk,3067
+qod_cli/main.py,sha256=pC0DfjtZN9Y-JiVkQECgAUkmmYJ1K8nAvvv8na5XqC8,2535
+qod_cli/output.py,sha256=xgOHZFS3AeMyhKaP0ELsMS3uJ2hWGaPQnukEBh4Pt4Y,1800
+qod_cli/rest.py,sha256=YXQ_DTcnYWHE6Vr5eR1rOkq4ItT4Y8jTR2Uol370LAA,2474
+qod_cli/sql.py,sha256=eKdaFUcQp-6B06VsR8CWtGWA8nvQRUv0XDW0s5l5tS4,2479
+qod_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qod_cli/commands/_run.py,sha256=B2yZoHsyebpn3oVoHB1IkAsQZOEPfCLFAiZ8TsAbspw,858
+qod_cli/commands/auth.py,sha256=eVX1ff29qfQdn5zR6-asYQbJWA7pv2WPEd3gvxDOjpQ,2166
+qod_cli/commands/catalog.py,sha256=aXrfbpduR28Ul0PjQ-fmDvnu2-HpDSpcIxX-qfQrS_c,5362
+qod_cli/commands/config_cmd.py,sha256=ZZTmWSrTqodNuVYntoDNi-7iPAZG4USA6IxnZUKeFdg,394
+qod_cli/commands/database.py,sha256=OYptjsKin6QxScYJtWSBQ8EJXvOc6NEpnr7XyiZIMGY,2699
+qod_cli/commands/federation.py,sha256=0lVOtCTpUhieDJXeyiVKW_wCTRONtaOh2HBA_tydP14,2630
+qod_cli/commands/group.py,sha256=iQq7RhDbt5zyXkg2c7JHwEKXIhnkyC1-3WBu32_2u9I,792
+qod_cli/commands/maintenance.py,sha256=UU0KPaiyNIyznMi7FGG_b6zFzsOOsToUfN9rmB0Al5Y,3027
+qod_cli/commands/manifest.py,sha256=Q2zHCjVFi-r8m3Hf2LgEBDCx6i4qfCZPeG_oIeXAqCw,1001
+qod_cli/commands/membership.py,sha256=_JplkBXz3kjnjDjKffP9UyPXqHy8RdE9W_pv8ktWBCg,1983
+qod_cli/commands/node.py,sha256=frmOwQAPMbIkSDxSXvcSCEqQ21uk_nHYrD8BLQN3Y48,1976
+qod_cli/commands/pool.py,sha256=CP9iXu8JcmTstKPLeUu-9EdB5PCfj-bR6oe_PVH6cMA,5143
+qod_cli/commands/role.py,sha256=QAiSg439JU6i1ERCHjV5DzUVyNEpO9Fevq-rQ0VTfmU,5184
+qod_cli/commands/sql_cmd.py,sha256=kOi-F1DULo_Y9uTbur43CYyfe8gYb6vZnmWYiv3OyFc,2939
+qod_cli/commands/tag.py,sha256=5BsXmq0bD-D3CYyu7_o96s7t5fae0dFf75BJf34ak5A,1216
+qod_cli/commands/telemetry.py,sha256=yYq9XqC7h1mg_z3zfpuhNvWesG1I9OiD3IiBbIrfg8o,2945
+qod_cli/commands/tenant.py,sha256=18WhxyDnG_HHJYJeScU7lrv8x6ctqla_EvJrUm7Q994,1752
+qod_cli/commands/user.py,sha256=j3txpbfqoxUn2t1pJOkJ9AHBQI9PaVKpb-7YAfHePCY,2166
+qod_cli-0.3.7.dist-info/METADATA,sha256=5Dnb5aBSj6hF2SwZ94hor5sFDMpDlvL8HHtYOWCkwP0,588
+qod_cli-0.3.7.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+qod_cli-0.3.7.dist-info/entry_points.txt,sha256=OECysrOZGQ_zr-VET7_ceoquEH6yvjeEVFuxq5Udv2s,42
+qod_cli-0.3.7.dist-info/RECORD,,

qod_cli-0.3.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

qod_cli-0.3.7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qod = qod_cli.main:main