steve-cli 0.5.2__tar.gz → 0.5.3__tar.gz

{steve_cli-0.5.2 → steve_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steve-cli
-Version: 0.5.2
+Version: 0.5.3
 Summary: A simple CLI tool to run jobs from jobs.yaml with proper environment setup
 Author: Frank
 License: MIT

{steve_cli-0.5.2 → steve_cli-0.5.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "steve-cli"
-version = "0.5.2"
+version = "0.5.3"
 description = "A simple CLI tool to run jobs from jobs.yaml with proper environment setup"
 readme = "README.md"
 license = {text = "MIT"}

steve_cli-0.5.3/steve_cli/auth.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+_CREDENTIALS_FILE = Path.home() / ".steve" / "credentials.json"
+
+
+def load_credentials() -> dict:
+    if _CREDENTIALS_FILE.exists():
+        try:
+            return json.loads(_CREDENTIALS_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_credentials(
+    workspace_id: str,
+    token: str,
+    base_url: Optional[str] = None,
+    workspace_name: Optional[str] = None,
+) -> None:
+    _CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    creds = load_credentials()
+    workspaces = creds.get("workspaces", {})
+    entry: dict = {"token": token}
+    if base_url:
+        entry["base_url"] = base_url.rstrip("/")
+    if workspace_name:
+        entry["workspace_name"] = workspace_name
+    workspaces[workspace_id] = entry
+    creds["workspaces"] = workspaces
+    _CREDENTIALS_FILE.write_text(json.dumps(creds, indent=2))
+    _CREDENTIALS_FILE.chmod(0o600)
+
+
+def clear_credentials(workspace_id: Optional[str] = None) -> None:
+    if workspace_id is None:
+        if _CREDENTIALS_FILE.exists():
+            _CREDENTIALS_FILE.unlink()
+        return
+    creds = load_credentials()
+    workspaces = creds.get("workspaces", {})
+    workspaces.pop(workspace_id, None)
+    creds["workspaces"] = workspaces
+    _CREDENTIALS_FILE.write_text(json.dumps(creds, indent=2))
+    _CREDENTIALS_FILE.chmod(0o600)
+
+
+def _get_workspace_entry(workspace_id: Optional[str]) -> dict:
+    creds = load_credentials()
+    workspaces = creds.get("workspaces", {})
+    if workspace_id and workspace_id in workspaces:
+        return workspaces[workspace_id]
+    if workspaces:
+        return next(iter(workspaces.values()), {})
+    return {}
+
+
+def get_token(workspace_id: Optional[str] = None) -> Optional[str]:
+    env_token = os.getenv("STEVE_TOKEN")
+    if env_token:
+        return env_token
+    return _get_workspace_entry(workspace_id).get("token")
+
+
+def get_service_url(service: str, workspace_id: Optional[str] = None) -> Optional[str]:
+    entry = _get_workspace_entry(workspace_id)
+    base_url = entry.get("base_url")
+    if not base_url or not workspace_id:
+        return None
+    return f"https://{service}-{workspace_id}.{base_url}"

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli/cli.py

@@ -101,9 +101,14 @@ def run_job_command(job: Dict[str, Any]) -> int:
 
 
 @click.group()
-def main():
+@click.option('--trace', is_flag=True, default=False, help='Print timing information for Trino queries.', envvar='STEVE_TRACE')
+@click.pass_context
+def main(ctx: click.Context, trace: bool):
     """Steve CLI - Run jobs and manage environment setup."""
-    pass
+    ctx.ensure_object(dict)
+    ctx.obj['trace'] = trace
+    if trace:
+        os.environ['STEVE_TRINO_TRACE'] = '1'
 
 
 @main.group(invoke_without_command=True)
@@ -803,17 +808,26 @@ def _list_trino_tables(storage_kwargs: dict, label: str) -> tuple:
 @main.command("tables")
 @click.option('--env-file', '-e', type=click.Path(path_type=Path), multiple=True,
               help='Path to .env file(s). Can be specified multiple times. Defaults to .env and .workspaces.env')
-def tables(env_file: tuple):
+@click.option('--schema', '-s', default=None,
+              help='Schema to use, e.g. "default/bronze" or "myworkspace/silver". Skips interactive prompt.')
+@click.option('--table', '-t', default=None,
+              help='Table name to open directly. Skips interactive prompt.')
+@click.option('--output', '-o', default='visidata',
+              type=click.Choice(['visidata', 'table', 'csv', 'json']),
+              help='Output format: visidata (interactive), table, csv, or json.')
+@click.pass_context
+def tables(ctx: click.Context, env_file: tuple, schema: str | None, table: str | None, output: str):
     """List Iceberg tables via Trino and view their contents."""
-    if not os.getenv("TRINO_ENDPOINT"):
-        click.secho("TRINO_ENDPOINT is not set — Trino is not available.", fg="yellow")
-        return
-
     cwd = Path.cwd()
     env_files = [Path(f) for f in env_file] if env_file else [cwd / ".env", cwd / ".workspaces.env"]
     for ef in env_files:
         load_dotenv(ef)
 
+    from steve_cli.auth import get_service_url
+    if not get_service_url("trino", os.getenv("WORKSPACE_ID")):
+        click.secho("Not logged in — run `steve login` to configure credentials.", fg="yellow")
+        return
+
     tiers = ["bronze", "silver", "gold"]
     options: List[Dict[str, Any]] = []
 
@@ -834,42 +848,85 @@ def tables(env_file: tuple):
             })
 
     if not options:
-        click.echo("No Trino storage env variables found (expected: TRINO_ENDPOINT + BRONZE_ACCESS_KEY or {WORKSPACE}_ACCESS_KEY).")
+        click.echo("No Trino storage variables found (expected: BRONZE_ACCESS_KEY or {WORKSPACE}_ACCESS_KEY).")
         return
 
-    choice = questionary.select(
-        "Select a schema to list:",
-        choices=[o["label"] for o in options],
-    ).ask()
-
-    if choice is None:
-        sys.exit(0)
+    if schema:
+        parts = [p.strip() for p in schema.split("/")]
+        if len(parts) == 2:
+            ws_part, tier_part = parts
+            normalized = f"{ws_part} / {tier_part}"
+            selected = next((o for o in options if o["label"].lower() == normalized.lower()), None)
+            if not selected:
+                click.secho(f"Schema '{schema}' not found. Available: {', '.join(o['label'] for o in options)}", fg="red")
+                return
+        else:
+            click.secho("--schema must be in format 'workspace/tier' or 'default/tier'", fg="red")
+            return
+    else:
+        choice = questionary.select(
+            "Select a schema to list:",
+            choices=[o["label"] for o in options],
+        ).ask()
+        if choice is None:
+            sys.exit(0)
+        selected = next(o for o in options if o["label"] == choice)
 
-    selected = next(o for o in options if o["label"] == choice)
     storage, table_names = _list_trino_tables(selected["kwargs"], selected["label"])
 
     if not storage or not table_names:
         return
 
-    table_choice = questionary.select(
-        "View a table (or press Esc to exit):",
-        choices=["(done)"] + table_names,
-    ).ask()
-
-    if not table_choice or table_choice == "(done)":
-        return
+    if table:
+        if table not in table_names:
+            click.secho(f"Table '{table}' not found. Available: {', '.join(table_names)}", fg="red")
+            return
+        table_choice = table
+    else:
+        table_choice = questionary.select(
+            "View a table (or press Esc to exit):",
+            choices=["(done)"] + table_names,
+        ).ask()
+        if not table_choice or table_choice == "(done)":
+            return
 
     click.echo(f"\n📊 {click.style(table_choice, fg='cyan')}\n")
     try:
-        import tempfile
-        data = storage.get_bytes(table_choice)
-        with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp:
-            tmp.write(data)
-            tmp_path = tmp.name
-        if not shutil.which("vd"):
-            click.secho("visidata not found. Install it with: uv pip install 'steve-cli[visidata]'", fg="yellow")
-            return
-        subprocess.call(["vd", tmp_path])
+        if output == 'visidata':
+            import tempfile
+            data = storage.get_bytes(table_choice)
+            with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp:
+                tmp.write(data)
+                tmp_path = tmp.name
+            if not shutil.which("vd"):
+                click.secho("visidata not found. Install it with: uv pip install 'steve-cli[visidata]'", fg="yellow")
+                return
+            subprocess.call(["vd", tmp_path])
+        else:
+            rows = storage._execute(f"SELECT * FROM {storage.catalog}.{storage.schema}.{storage._table_name(table_choice)}")
+            if not rows:
+                click.echo("(no rows)")
+                return
+            if output == 'json':
+                import json
+                click.echo(json.dumps(rows, indent=2, default=str))
+            elif output == 'csv':
+                import csv
+                import io as _io
+                buf = _io.StringIO()
+                writer = csv.DictWriter(buf, fieldnames=list(rows[0].keys()))
+                writer.writeheader()
+                writer.writerows(rows)
+                click.echo(buf.getvalue(), nl=False)
+            elif output == 'table':
+                cols = list(rows[0].keys())
+                widths = [max(len(c), max(len(str(r.get(c, ''))) for r in rows)) for c in cols]
+                header = '  '.join(c.ljust(w) for c, w in zip(cols, widths))
+                sep = '  '.join('-' * w for w in widths)
+                click.echo(header)
+                click.echo(sep)
+                for row in rows:
+                    click.echo('  '.join(str(row.get(c, '')).ljust(w) for c, w in zip(cols, widths)))
     except Exception as e:
         click.secho(f"❌ Could not open table: {e}", fg="red", err=True)
 
@@ -901,6 +958,70 @@ def policies_apply(file: Path | None):
         sys.exit(1)
 
 
+@main.command("login")
+@click.option("--token", default=None, help="Service principal token (stp_...) to save")
+@click.option("--workspace", "workspace_id", default=None, help="Workspace ID (defaults to WORKSPACE_ID from .env)")
+@click.option("--url", "base_url", default=None, help="Platform root host, e.g. jds-dev.internal.jambit.io")
+@click.option("--workspace-name", "workspace_name_opt", default=None, help="Workspace name")
+@click.option('--env-file', '-e', type=click.Path(path_type=Path), multiple=True,
+              help='Path to .env file(s). Defaults to .env and .workspaces.env')
+def login(token: str | None, workspace_id: str | None, base_url: str | None, workspace_name_opt: str | None, env_file: tuple):
+    """Print CLI access URLs or save a service principal token."""
+    cwd = Path.cwd()
+    env_files = [Path(f) for f in env_file] if env_file else [cwd / ".env", cwd / ".workspaces.env"]
+    for ef in env_files:
+        load_dotenv(ef)
+
+    resolved_workspace = workspace_id or os.getenv("WORKSPACE_ID")
+    workspace_name = workspace_name_opt or os.getenv("WORKSPACE_NAME") or resolved_workspace
+
+    if token:
+        from steve_cli.auth import save_credentials
+        if not token.startswith("stp_"):
+            click.secho("Token must start with 'stp_'. Create one in the workspace CLI Access tab.", fg="red", err=True)
+            raise SystemExit(1)
+        if not resolved_workspace:
+            click.secho("Could not resolve workspace ID. Set WORKSPACE_ID in .env or pass --workspace.", fg="red", err=True)
+            raise SystemExit(1)
+        click.echo(f"\nYou are about to log in to workspace {click.style(workspace_name, fg='cyan', bold=True)} ({resolved_workspace})")
+        save_credentials(resolved_workspace, token, base_url=base_url, workspace_name=workspace_name)
+        if base_url:
+            click.echo(f"Platform: {base_url}")
+        click.secho(f"Logged in. Credentials saved to ~/.steve/credentials.json", fg="green")
+        return
+
+    if not resolved_workspace:
+        click.secho("WORKSPACE_ID is not set. Source your .env file or pass --workspace.", fg="yellow")
+        raise SystemExit(1)
+
+    dev_url = f"https://datameshx.jds-dev.internal.jambit.io/workspaces/{resolved_workspace}?tab=cli"
+    prod_url = f"https://datameshx.jds.internal.jambit.io/workspaces/{resolved_workspace}?tab=cli"
+
+    click.echo(f"\nLogging in to workspace {click.style(workspace_name, fg='cyan', bold=True)}:\n")
+    click.echo(f"  Dev:  {click.style(dev_url, fg='blue', underline=True)}")
+    click.echo(f"  Prod: {click.style(prod_url, fg='blue', underline=True)}")
+    click.echo(f"\nOpen the URL, copy the token, then run:")
+    click.echo(f"  {click.style('steve login --token stp_...', fg='green')}\n")
+
+
+@main.command("logout")
+@click.option("--workspace", "workspace_id", default=None, help="Workspace ID to log out of (defaults to all)")
+@click.option('--env-file', '-e', type=click.Path(path_type=Path), multiple=True)
+def logout(workspace_id: str | None, env_file: tuple):
+    """Remove saved CLI credentials."""
+    from steve_cli.auth import clear_credentials
+    cwd = Path.cwd()
+    env_files = [Path(f) for f in env_file] if env_file else [cwd / ".env", cwd / ".workspaces.env"]
+    for ef in env_files:
+        load_dotenv(ef)
+    resolved_workspace = workspace_id or os.getenv("WORKSPACE_ID")
+    clear_credentials(resolved_workspace)
+    if resolved_workspace:
+        click.secho(f"Credentials removed for workspace {resolved_workspace}.", fg="green")
+    else:
+        click.secho("All credentials removed.", fg="green")
+
+
 @main.command("upgrade")
 def upgrade():
     """Upgrade steve-cli to the latest version."""

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli/ontology.py

@@ -421,7 +421,8 @@ def build_cmd(manifest_file: str, base_prefix: str | None, output_dir: Path | No
     if output_dir is None:
         output_dir = Path("vkg_modules") / ".build" / Path(manifest_file).stem
 
-    trino_endpoint = os.getenv("TRINO_ENDPOINT")
+    from steve_cli.auth import get_service_url
+    trino_endpoint = get_service_url("trino", os.getenv("WORKSPACE_ID"))
 
     click.echo(f"Building from {manifest_file} …")
     artifact, tables = _compile_local(manifest, cwd)
@@ -1548,7 +1549,8 @@ def push_cmd(
             click.secho("✓ Lock is current (--frozen)", fg="green")
             return
 
-        trino_endpoint = os.getenv("TRINO_ENDPOINT")
+        from steve_cli.auth import get_service_url
+        trino_endpoint = get_service_url("trino", os.getenv("WORKSPACE_ID"))
         click.echo(f"Pushing workspace from {chosen} …")
         artifact, tables = _compile_local(manifest, cwd)
         snapshots = _capture_snapshots(tables, trino_endpoint) if trino_endpoint and tables else {}
@@ -1578,7 +1580,7 @@ def push_cmd(
 _BIND_OPTIONS = [
     click.option("-f", "--file", "manifest_file", default="ontology.yaml", show_default=True),
     click.option("-b", "--binding", "binding_file", default=None, help="Binding YAML path (default: first entry in manifest bindings:)"),
-    click.option("--trino-endpoint", envvar="TRINO_ENDPOINT", default=None),
+    click.option("--trino-endpoint", default=None),
 ]
 
 

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli/policies/client.py

@@ -15,9 +15,25 @@ class PolicyClient:
         self,
         endpoint: str | None = None,
         token: str | None = None,
+        workspace_id: str | None = None,
     ):
-        self.endpoint = (endpoint or os.environ.get("PCP_ENDPOINT", "http://policy-control-plane:3010")).rstrip("/")
-        self.token = token or os.environ.get("PCP_TOKEN", "")
+        from steve_cli.auth import get_service_url, get_token
+        resolved_via_proxy = False
+        if endpoint is None:
+            pcp_url = get_service_url("pcp", workspace_id)
+            endpoint = (
+                os.environ.get("PCP_ENDPOINT")
+                or pcp_url
+                or "http://policy-control-plane:3010"
+            )
+            resolved_via_proxy = bool(pcp_url and not os.environ.get("PCP_ENDPOINT"))
+        self.endpoint = endpoint.rstrip("/")
+        if token:
+            self.token = token
+        elif resolved_via_proxy:
+            self.token = get_token(workspace_id) or os.environ.get("PCP_TOKEN", "")
+        else:
+            self.token = os.environ.get("PCP_TOKEN", "")
 
     def __trpc(self, method: str, path: str, payload: dict | None = None) -> dict:
         url = f"{self.endpoint}/api/trpc/{path}"
@@ -30,7 +46,8 @@ class PolicyClient:
         data = resp.json()
         if "error" in data:
             raise RuntimeError(f"tRPC error on {path}: {data['error']}")
-        return data.get("result", {}).get("data", data.get("result", {}))
+        result = data.get("result", {})
+        return result.get("data", {}).get("json", result.get("data", result))
 
     def _trpc(self, method: str, path: str, payload: dict | None = None) -> dict:
         try:

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli/storage/trino.py

@@ -22,9 +22,11 @@ def _derive_schema(tier: str, workspace: str | None) -> str | None:
 
 class TrinoStorage:
     def __init__(self, tier: str = "bronze", workspace: str | None = None):
-        trino_endpoint = os.getenv("TRINO_ENDPOINT")
+        from steve_cli.auth import get_service_url
+        self._workspace_id = os.getenv("WORKSPACE_ID")
+        trino_endpoint = get_service_url("trino", self._workspace_id)
         if not trino_endpoint:
-            raise EnvironmentError("TRINO_ENDPOINT is not set — Trino is not available in this environment")
+            raise EnvironmentError("Trino endpoint not found — run `steve login` to configure credentials")
         self.catalog = os.getenv("TRINO_CATALOG", "minio")
         resolved_workspace = workspace or os.getenv("WORKSPACE_NAME")
         self.schema = _derive_schema(tier, resolved_workspace) or os.environ.get("TRINO_SCHEMA", "")
@@ -92,15 +94,26 @@ class TrinoStorage:
         return self.__iceberg_catalog
 
     def _execute(self, sql: str) -> list[dict]:
+        from steve_cli.auth import get_token
+        trace = os.getenv("STEVE_TRINO_TRACE") == "1"
         headers = {
             "X-Trino-User": self.user,
             "X-Trino-Catalog": self.catalog,
             "X-Trino-Schema": self.schema,
         }
+        token = get_token(self._workspace_id)
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        t0 = time.perf_counter()
         resp = requests.post(f"{self._base}/v1/statement", data=sql, headers=headers)
         resp.raise_for_status()
+        if trace:
+            logger.warning("[trino] POST /v1/statement: %.3fs", time.perf_counter() - t0)
+
         data = resp.json()
         rows: list[dict] = []
+        poll = 0
         while True:
             if "data" in data and "columns" in data:
                 col_names = [c["name"] for c in data["columns"]]
@@ -110,9 +123,18 @@ class TrinoStorage:
             if not next_uri:
                 break
             time.sleep(0.1)
+            next_uri = next_uri.replace("http://trino:8080", self._base).replace("https://trino:8080", self._base)
+            t_poll = time.perf_counter()
             resp = requests.get(next_uri, headers=headers)
             resp.raise_for_status()
+            poll += 1
+            if trace:
+                logger.warning("[trino] poll #%d: %.3fs (total %.3fs, %d rows so far)",
+                               poll, time.perf_counter() - t_poll, time.perf_counter() - t0, len(rows))
             data = resp.json()
+
+        if trace:
+            logger.warning("[trino] query done: %.3fs total, %d rows, %d polls", time.perf_counter() - t0, len(rows), poll)
         return rows
 
     @staticmethod

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steve-cli
-Version: 0.5.2
+Version: 0.5.3
 Summary: A simple CLI tool to run jobs from jobs.yaml with proper environment setup
 Author: Frank
 License: MIT

{steve_cli-0.5.2 → steve_cli-0.5.3}/steve_cli.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 steve_cli/__init__.py
+steve_cli/auth.py
 steve_cli/cli.py
 steve_cli/ontology.py
 steve_cli/storage.py