lumilake-cli 0.1.0.dev1__tar.gz → 0.1.2__tar.gz

{lumilake_cli-0.1.0.dev1/src/lumilake_cli.egg-info → lumilake_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumilake-cli
-Version: 0.1.0.dev1
+Version: 0.1.2
 Summary: Lumilake command-line interface
 Author: Lumilake contributors
 License-Expression: Apache-2.0
@@ -14,12 +14,12 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <3.13,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lumilake-sdk==0.1.0.dev1
+Requires-Dist: lumilake-sdk==0.1.2
 Requires-Dist: flowmesh-sdk==0.1.1
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typer>=0.12.5
 Provides-Extra: deploy
-Requires-Dist: lumilake-deploy==0.1.0.dev1; extra == "deploy"
+Requires-Dist: lumilake-deploy==0.1.2; extra == "deploy"
 Dynamic: license-file
 
 # `lumilake-cli`

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lumilake-cli"
-version = "0.1.0.dev1"
+version = "0.1.2"
 description = "Lumilake command-line interface"
 readme = "README.md"
 requires-python = "<3.13,>=3.12"
@@ -10,7 +10,7 @@ authors = [
     {name = "Lumilake contributors"},
 ]
 dependencies = [
-    "lumilake-sdk==0.1.0.dev1",
+    "lumilake-sdk==0.1.2",
     # Renders ``lumilake trace`` ProfileSummary payloads.
     "flowmesh-sdk==0.1.1",
     "requests>=2.32.3",
@@ -26,7 +26,7 @@ classifiers = [
 
 [project.optional-dependencies]
 # Thin ``pip install lumilake-cli`` (no extra) skips Docker/FlowMesh.
-deploy = ["lumilake-deploy==0.1.0.dev1"]
+deploy = ["lumilake-deploy==0.1.2"]
 
 [project.urls]
 Homepage = "https://github.com/mlsys-io/lumilake_OSS"

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/commands/__init__.py

@@ -51,6 +51,7 @@ else:
         "up",
         "down",
         "clean",
+        "purge",
         "reset",
         "status",
         "restart",

lumilake_cli-0.1.2/src/lumilake_cli/commands/base.py

@@ -0,0 +1,139 @@
+import json
+from pathlib import Path
+
+import typer
+from lumilake._base_client import resolve_config
+from lumilake.config import LumilakeConfig
+from lumilake.errors import ConfigInvalidError, ConfigNotFoundError
+
+from ..core import logging
+from ..core.config import DEFAULT_CONFIG_PATH
+from ..core.http import HttpError, client_from_config
+from ..core.typer import get_typer
+
+app = get_typer()
+
+
+def _redact_api_key(
+    api_key: str | None, prefix: int | None = None, suffix: int | None = None
+) -> str | None:
+    if api_key is None:
+        return None
+    length = len(api_key)
+    if prefix is None and suffix is None:
+        prefix = suffix = 4
+        if length <= prefix + suffix:
+            return "*" * length
+    elif prefix is None or suffix is None:
+        raise ValueError("Both prefix and suffix must be provided together")
+    elif length <= prefix + suffix:
+        raise ValueError(
+            "API key is too short to redact with the given prefix/suffix lengths"
+        )
+    masked = "*" * (length - prefix - suffix)
+    return f"{api_key[:prefix]}{masked}{api_key[-suffix:]}"
+
+
+@app.command()
+def init(
+    url: str = typer.Argument(
+        "http://127.0.0.1:9000",
+        help="Lumilake server URL (e.g. http://127.0.0.1:9000).",
+    ),
+    api_key: str | None = typer.Option(
+        None, "--api-key", help="Bearer presented as Authorization: Bearer …"
+    ),
+    config_path: Path = typer.Option(
+        DEFAULT_CONFIG_PATH, "--config", help="Path to save configuration file."
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing config file without confirmation.",
+        show_default=False,
+    ),
+) -> None:
+    """Initialize configuration for the Lumilake CLI."""
+    if config_path.exists():
+        if force:
+            logging.warning(f"Overwriting existing config at {config_path}")
+        elif not typer.confirm(f"Config file {config_path} already exists. Overwrite?"):
+            raise typer.Exit()
+    LumilakeConfig(base_url=url, api_key=api_key).save(config_path)
+    logging.success(f"Config saved to {config_path}")
+
+
+@app.command()
+def deinit(
+    config_path: Path = typer.Option(
+        DEFAULT_CONFIG_PATH, "--config", help="Path to configuration file."
+    ),
+) -> None:
+    """Delete the saved configuration file."""
+    if config_path.exists():
+        config_path.unlink()
+        logging.success(f"Deleted config file {config_path}")
+    else:
+        logging.warning(f"No config file found at {config_path}")
+
+
+@app.command()
+def config(
+    config_path: Path = typer.Option(
+        DEFAULT_CONFIG_PATH, "--config", help="Path to configuration file."
+    ),
+    source: str = typer.Option(
+        "auto",
+        "--source",
+        help="Configuration source: auto, file, or env.",
+    ),
+    show_api_key: bool = typer.Option(
+        False, "--show-api-key", help="Show api_key in plain text."
+    ),
+) -> None:
+    """Display the resolved Lumilake CLI configuration."""
+    normalized = source.strip().lower()
+    match normalized:
+        case "file":
+            try:
+                cfg = LumilakeConfig.from_file(config_path)
+            except (ConfigNotFoundError, ConfigInvalidError) as exc:
+                logging.error(f"Error loading config from file: {exc}")
+                raise typer.Exit(code=1)
+        case "env":
+            try:
+                cfg = LumilakeConfig.from_env()
+            except ConfigInvalidError as exc:
+                logging.error(f"Error loading config from environment: {exc}")
+                raise typer.Exit(code=1)
+        case "auto":
+            try:
+                cfg = resolve_config(config_path=config_path)
+            except Exception as exc:
+                logging.error(f"Error resolving config: {exc}")
+                raise typer.Exit(code=1)
+        case _:
+            logging.error("Invalid --source value. Expected one of: auto, file, env")
+            raise typer.Exit(code=2)
+
+    cfg.api_key = cfg.api_key if show_api_key else _redact_api_key(cfg.api_key)
+    logging.log(json.dumps(cfg.to_mapping(), indent=2))
+
+
+@app.command()
+def info() -> None:
+    """Query server health status."""
+    client = client_from_config()
+    try:
+        response = client.get("/healthz")
+    except HttpError as exc:
+        logging.error(str(exc))
+        raise typer.Exit(code=1)
+    logging.log(json.dumps(response.json(), indent=2))
+
+
+@app.command()
+def health() -> None:
+    """Check if the Lumilake server is reachable and healthy."""
+    info()

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/commands/deploy.py

@@ -1,13 +1,17 @@
-"""Deploy commands: init, doctor, up, down, clean, restart, reset, logs."""
+"""Deploy commands: init, doctor, up, down, clean, purge, restart, reset, logs."""
 
 import datetime as dt
+import difflib
 import re
 import sys
 from pathlib import Path
 
 import typer
 from flowmesh_cli_stack.stack import stack_env_example
+from lumilake import envs
+from lumilake.errors import ConfigInvalidError, ConfigNotFoundError
 from lumilake_deploy import docker_client
+from lumilake_deploy import purge as purge_mod
 from lumilake_deploy import setup as setup_mod
 from lumilake_deploy import stop as stop_mod
 from lumilake_deploy import update_flowmesh as update_fm_mod
@@ -27,6 +31,7 @@ from lumilake_deploy.setup import (
 )
 
 from ..core import logging
+from ..core.config import DEFAULT_CONFIG_PATH, LumilakeConfig
 from ..core.typer import get_typer
 
 app = get_typer(
@@ -83,9 +88,44 @@ def _run_setup(
         raise typer.Exit(code=1) from exc
 
 
-def _confirm_overwrite(target: Path, *, force: bool) -> bool:
-    """Return True when the target may be written, False to skip."""
-    if not target.exists() or force:
+def _preview_write(target: Path, new_content: str) -> None:
+    if target.exists():
+        old = target.read_text().splitlines(keepends=True)
+        new = new_content.splitlines(keepends=True)
+        diff = "".join(
+            difflib.unified_diff(
+                old,
+                new,
+                fromfile=f"a/{target.name}",
+                tofile=f"b/{target.name}",
+                n=3,
+            )
+        )
+        if diff:
+            logging.info(f"Diff vs existing {target}:")
+            for line in diff.splitlines():
+                logging.info(line)
+        else:
+            logging.info(f"{target} already matches the bundled template.")
+        return
+    logging.info(f"Preview of {target} (first 20 lines):")
+    for line in new_content.splitlines()[:20]:
+        logging.info(line)
+    remaining = max(0, len(new_content.splitlines()) - 20)
+    if remaining:
+        logging.info(f"... and {remaining} more line(s).")
+
+
+def _confirm_overwrite(target: Path, *, force: bool, new_content: str) -> bool:
+    """Return True when the target may be written, False to skip.
+
+    Shows a preview (or diff vs an existing file) before prompting on
+    overwrite. Brand-new writes pass through without prompting.
+    """
+    if force:
+        return True
+    _preview_write(target, new_content)
+    if not target.exists():
         return True
     if typer.confirm(f"{target} already exists. Overwrite?", default=False):
         return True
@@ -156,21 +196,23 @@ def init(
     root = _project_dir(ctx)
     template = env_example_path()
     target = root / ENV_FILE_NAME
+    template_text = template.read_text()
     wrote_env = False
-    if _confirm_overwrite(target, force=force):
-        target.write_text(template.read_text())
+    if _confirm_overwrite(target, force=force, new_content=template_text):
+        target.write_text(template_text)
         logging.success(f"Wrote {target} from packaged {template.name}.")
         wrote_env = True
 
     if flowmesh:
         fm_target = root / FLOWMESH_ENV_FILE_NAME
+        example = stack_env_example()
+        if not example.exists():
+            logging.error(f"FlowMesh env example not found: {example}")
+            raise typer.Exit(code=1)
+        fm_template_text = example.read_text()
         wrote_flowmesh_env = False
-        if _confirm_overwrite(fm_target, force=force):
-            example = stack_env_example()
-            if not example.exists():
-                logging.error(f"FlowMesh env example not found: {example}")
-                raise typer.Exit(code=1)
-            fm_target.write_text(example.read_text())
+        if _confirm_overwrite(fm_target, force=force, new_content=fm_template_text):
+            fm_target.write_text(fm_template_text)
             logging.success(f"Wrote {fm_target} from {example.name}.")
             _patch_flowmesh_env(fm_target)
             wrote_flowmesh_env = True
@@ -240,6 +282,34 @@ def pull(ctx: typer.Context) -> None:
         raise typer.Exit(code=1) from exc
 
 
+def _write_cli_config(root: Path, config_path: Path | None = None) -> None:
+    """Persist the local server URL so subsequent CLI / SDK calls find it.
+
+    Preserves any existing ``api_key`` (written by ``lumilake init``).
+    """
+    if config_path is None:
+        config_path = DEFAULT_CONFIG_PATH
+    setup_mod.load_project_env(root)
+    port = envs.LUMILAKE_SERVER_PORT or 9000
+    base_url = f"http://127.0.0.1:{port}"
+    try:
+        existing = LumilakeConfig.from_file(config_path)
+    except (ConfigNotFoundError, ConfigInvalidError):
+        existing = None
+    if existing is not None and existing.base_url == base_url:
+        logging.info(f"CLI config already points at {base_url}.")
+        return
+    if existing is not None and existing.base_url != base_url:
+        logging.info(f"Updating {config_path}: {existing.base_url} -> {base_url}")
+    api_key = existing.api_key if existing is not None else None
+    try:
+        LumilakeConfig(base_url=base_url, api_key=api_key).save(config_path)
+    except OSError as exc:
+        logging.warning(f"Could not save CLI config to {config_path}: {exc}")
+        return
+    logging.info(f"Saved CLI config to {config_path} (base_url={base_url}).")
+
+
 @app.command()
 def up(ctx: typer.Context) -> None:
     """Start the full Lumilake stack (Docker-backed).
@@ -247,7 +317,9 @@ def up(ctx: typer.Context) -> None:
     The server image must already be present locally — run
     ``lumilake deploy pull`` or ``lumilake deploy build`` first.
     """
-    _run_setup(_project_dir(ctx), background=True)
+    root = _project_dir(ctx)
+    _run_setup(root, background=True)
+    _write_cli_config(root)
 
 
 @app.command()
@@ -266,7 +338,15 @@ def down(
         ),
     ),
 ) -> None:
-    """Stop all services (keep data)."""
+    """Stop the stack but keep data volumes.
+
+    Safe to run between sessions: the archive bucket (job records, run
+    artifacts) and the compute postgres/minio volumes survive, so
+    ``deploy up`` resumes against the same state. ``--wipe-archive`` also
+    removes the compute Postgres and FlowMesh runtime-state volumes, while
+    preserving MinIO corpus data. Use ``deploy reset`` (destructive) to
+    wipe every volume instead.
+    """
     try:
         stop_mod.run_stop(
             _project_dir(ctx),
@@ -288,6 +368,56 @@ def clean(ctx: typer.Context) -> None:
         raise typer.Exit(code=1) from exc
 
 
+@app.command()
+def purge(
+    ctx: typer.Context,
+    image_tag: str = typer.Argument(
+        ...,
+        help="Lumilake server image tag to purge from local Docker.",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="List the image to be purged without deleting it.",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Force image removal even if Docker reports dependent containers.",
+    ),
+) -> None:
+    """Purge one Lumilake server image tag from local Docker."""
+    try:
+        plan = purge_mod.build_server_image_purge_plan(
+            _project_dir(ctx),
+            image_tag=image_tag,
+        )
+    except DeployError as exc:
+        logging.error(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    logging.info(f"Purging Lumilake server image with tag '{image_tag}'...")
+    if not plan.exists:
+        logging.warning(f"Image not found: {plan.image_ref}")
+        logging.info("No images to purge.")
+        return
+
+    if dry_run:
+        logging.info("Images to be purged:")
+        logging.info(f"  {plan.image_ref}")
+        return
+
+    try:
+        result = purge_mod.run_server_image_purge(plan, force=force)
+    except DeployError as exc:
+        logging.error(str(exc))
+        raise typer.Exit(code=1) from exc
+    if result.removed:
+        logging.success(f"Removed image: {result.image_ref}")
+        return
+    logging.warning(f"Image already absent: {result.image_ref}")
+
+
 @app.command()
 def status(ctx: typer.Context) -> None:
     """Show the running state of every Lumilake stack container."""
@@ -354,8 +484,28 @@ def restart(
 
 
 @app.command()
-def reset(ctx: typer.Context) -> None:
-    """Clean reset (stop + purge + up; deletes all data)."""
+def reset(
+    ctx: typer.Context,
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Skip the destructive-action confirmation prompt.",
+    ),
+) -> None:
+    """Wipe the archive and every volume, then start the stack fresh.
+
+    Destructive: removes the compute postgres / minio volumes (job
+    records, run artifacts, demo data) and the FlowMesh runtime state.
+    Use ``deploy down`` if you want to stop the stack but keep its data.
+    """
+    if not yes and not typer.confirm(
+        "deploy reset deletes every Lumilake volume (archive + compute "
+        "data). Continue?",
+        default=False,
+    ):
+        logging.info("Aborted.")
+        raise typer.Exit(code=0)
     root = _project_dir(ctx)
     try:
         stop_mod.run_stop(root, purge=True)

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/commands/job.py

@@ -135,13 +135,30 @@ def submit(
         None, "--batch-size", help="Input batch size"
     ),
     input_values: list[str] | None = typer.Option(
-        None, "--input", help="Input as Name=v1,v2,v3 (repeatable for different names)"
+        None,
+        "--input",
+        help=(
+            "Input as Name=val1,val2,val3 (comma-separated; whitespace around "
+            "values is trimmed). Repeat for different names: "
+            "`--input query=NVDA,TSLA --input year=2024`. A single value "
+            "still uses the same syntax: `--input query=NVDA`."
+        ),
     ),
     input_files: list[str] | None = typer.Option(
-        None, "--input-file", help="Input from file as Name=path.txt (repeatable)"
+        None,
+        "--input-file",
+        help=(
+            "Input from file as Name=path.txt; one value per non-empty line. "
+            "Repeatable: `--input-file tickers=tickers.txt`."
+        ),
     ),
     input_json: Path | None = typer.Option(
-        None, "--input-json", help="JSON file with full inputs object"
+        None,
+        "--input-json",
+        help=(
+            "JSON file with the full inputs object, e.g. "
+            '`{"query": ["NVDA", "TSLA"], "year": ["2024"]}`.'
+        ),
     ),
 ) -> None:
     """Submit a workflow for optimization and execution."""

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/commands/trace.py

@@ -25,6 +25,8 @@ OutputFormat = typer.Option(
     help="Output format: summary | json | mermaid",
 )
 
+_JSON_OPTION_HELP = "Shortcut for ``--format json``."
+
 
 @app.command("list")
 def list_traces(
@@ -46,14 +48,18 @@ def list_traces(
 def get_trace(
     exec_id: str = typer.Argument(..., help="Execution trace identifier"),
     output_format: str = OutputFormat,
+    json_output: bool = typer.Option(False, "--json", help=_JSON_OPTION_HELP),
 ) -> None:
     """Retrieve and render a specific execution trace.
 
     Default ``summary`` shows the FlowMesh ``ProfileSummary`` as
     headline metrics + hardware / network / critical-path tables.
     ``json`` returns the raw payload; ``mermaid`` prints the lineage
-    graph in Mermaid syntax.
+    graph in Mermaid syntax. ``--json`` is a shortcut for
+    ``--format json``.
     """
+    if json_output:
+        output_format = "json"
     client = client_from_config()
     try:
         response = client.get(f"/trace/{exec_id}", version_prefix=True)

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/commands/worker.py

@@ -9,6 +9,10 @@ from ..core.typer import get_typer
 app = get_typer(help="Query runtime workers.")
 
 
+def _emit_json(payload: object) -> None:
+    logging.log(json.dumps(payload, indent=2))
+
+
 @app.command("list")
 def list_workers() -> None:
     """List all available workers."""
@@ -18,7 +22,7 @@ def list_workers() -> None:
     except HttpError as exc:
         logging.error(str(exc))
         raise typer.Exit(code=1)
-    logging.log(json.dumps(response.json(), indent=2))
+    _emit_json(response.json())
 
 
 @app.command("get")
@@ -32,4 +36,4 @@ def get_worker(
     except HttpError as exc:
         logging.error(str(exc))
         raise typer.Exit(code=1)
-    logging.log(json.dumps(response.json(), indent=2))
+    _emit_json(response.json())

lumilake_cli-0.1.2/src/lumilake_cli/core/config.py

@@ -0,0 +1,5 @@
+"""Configuration handling for the Lumilake CLI."""
+
+from lumilake.config import DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_PATH, LumilakeConfig
+
+__all__ = ["DEFAULT_CONFIG_DIR", "DEFAULT_CONFIG_PATH", "LumilakeConfig"]

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli/core/http.py

@@ -3,20 +3,22 @@
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, NoReturn
+from typing import Any
 
 import requests
-import typer
 from lumilake import envs
+from lumilake._base_client import DEFAULT_BASE_URL, resolve_config
+from lumilake.errors import ConfigInvalidError, ConfigNotFoundError
 
-from . import logging
-from .config import DEFAULT_CONFIG_PATH, LumilakeConfig, load_config
+from .config import DEFAULT_CONFIG_PATH, LumilakeConfig
 
 API_VERSION_PREFIX = "/api/v1"
 
 DEFAULT_TIMEOUT: float = 300.0
 """Default request timeout in seconds."""
 
+DEFAULT_LOCAL_BASE_URL = DEFAULT_BASE_URL
+
 
 def _resolve_timeout() -> float:
     """Read timeout from ``LUMILAKE_TIMEOUT`` env var, falling back to default."""
@@ -30,10 +32,14 @@ class HttpError(RuntimeError):
 @dataclass
 class HttpClient:
     base_url: str
+    api_key: str | None = None
     timeout: float = field(default_factory=_resolve_timeout)
 
     def _headers(self) -> Mapping[str, str]:
-        return {"Accept": "application/json"}
+        headers: dict[str, str] = {"Accept": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
 
     def get(
         self, path: str, version_prefix: bool = False, **kwargs: Any
@@ -100,27 +106,26 @@ class HttpClient:
         return response
 
 
-def _require_config(path: Path = DEFAULT_CONFIG_PATH) -> LumilakeConfig:
-    """Load config or exit with a clear message directing the user to login."""
-
-    def _error(msg: str) -> NoReturn:
-        logging.error(msg)
-        raise typer.Exit(code=1)
+def resolve_base_url(
+    config_path: Path = DEFAULT_CONFIG_PATH,
+) -> tuple[str, str]:
+    """Return ``(base_url, source)`` with source in {"env", "config", "default"}.
 
+    Env > config file > local default. Mirrors the SDK's precedence but
+    reports the source so ``lumilake config`` can show where the value
+    came from.
+    """
+    env_url = envs.get_lumilake_base_url()
+    if env_url:
+        return env_url, "env"
     try:
-        config = load_config(path)
-    except FileNotFoundError:
-        _error("Not logged in. Run `lumilake login <url>` first.")
-    except ValueError as exc:
-        _error(f"Invalid config file: {exc}. Please re-login.")
-
-    if not config.base_url:
-        _error("Missing base_url in config. Please re-login.")
-    return config
-
-
-def client_from_config(config: LumilakeConfig | None = None) -> HttpClient:
-    """Build an HttpClient from saved config. Exits if not logged in."""
-    if config is None:
-        config = _require_config()
-    return HttpClient(base_url=config.base_url)
+        cfg = LumilakeConfig.from_file(config_path)
+    except (ConfigNotFoundError, ConfigInvalidError):
+        return DEFAULT_LOCAL_BASE_URL, "default"
+    return cfg.base_url, "config"
+
+
+def client_from_config(config_path: Path = DEFAULT_CONFIG_PATH) -> HttpClient:
+    """Build an HttpClient by resolving base_url + api_key (env > file > default)."""
+    cfg = resolve_config(config_path=config_path)
+    return HttpClient(base_url=cfg.base_url, api_key=cfg.api_key)

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2/src/lumilake_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumilake-cli
-Version: 0.1.0.dev1
+Version: 0.1.2
 Summary: Lumilake command-line interface
 Author: Lumilake contributors
 License-Expression: Apache-2.0
@@ -14,12 +14,12 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <3.13,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lumilake-sdk==0.1.0.dev1
+Requires-Dist: lumilake-sdk==0.1.2
 Requires-Dist: flowmesh-sdk==0.1.1
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typer>=0.12.5
 Provides-Extra: deploy
-Requires-Dist: lumilake-deploy==0.1.0.dev1; extra == "deploy"
+Requires-Dist: lumilake-deploy==0.1.2; extra == "deploy"
 Dynamic: license-file
 
 # `lumilake-cli`

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-../../LICENSE
 src/lumilake_cli/__init__.py
 src/lumilake_cli/cli.py
 src/lumilake_cli.egg-info/PKG-INFO

{lumilake_cli-0.1.0.dev1 → lumilake_cli-0.1.2}/src/lumilake_cli.egg-info/requires.txt

@@ -1,7 +1,7 @@
-lumilake-sdk==0.1.0.dev1
+lumilake-sdk==0.1.2
 flowmesh-sdk==0.1.1
 requests>=2.32.3
 typer>=0.12.5
 
 [deploy]
-lumilake-deploy==0.1.0.dev1
+lumilake-deploy==0.1.2

lumilake_cli-0.1.0.dev1/src/lumilake_cli/commands/base.py

@@ -1,85 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-
-from ..core import logging
-from ..core.config import DEFAULT_CONFIG_PATH, LumilakeConfig, save_config
-from ..core.http import HttpClient, HttpError, client_from_config
-from ..core.typer import get_typer
-
-app = get_typer()
-
-
-@app.command()
-def login(
-    url: str = typer.Argument(
-        ..., help="Lumilake server URL (e.g., http://localhost:9000)"
-    ),
-    config_path: Path = typer.Option(
-        DEFAULT_CONFIG_PATH, "--config", help="Path to save configuration file"
-    ),
-) -> None:
-    """Configure connection to a Lumilake server and save it locally."""
-    client = HttpClient(base_url=url)
-    try:
-        client.get("/healthz")
-    except HttpError as exc:
-        logging.error(str(exc))
-        raise typer.Exit(code=1)
-    save_config(LumilakeConfig(base_url=url), path=config_path)
-    logging.success(f"Login successful. Saved config to {config_path}")
-
-
-@app.command()
-def logout(
-    config_path: Path = typer.Option(
-        DEFAULT_CONFIG_PATH, "--config", help="Path to configuration file to remove"
-    ),
-) -> None:
-    """Delete saved configuration."""
-    config_path.unlink(missing_ok=True)
-    logging.success(f"Logout successful. Removed config {config_path}")
-
-
-@app.command()
-def config(
-    refresh: bool = typer.Option(
-        False, "--refresh", "-r", help="Reload and show the latest configuration"
-    ),
-    config_path: Path = typer.Option(
-        DEFAULT_CONFIG_PATH, "--config", help="Path to configuration file"
-    ),
-) -> None:
-    """Show the current Lumilake CLI configuration."""
-    from ..core.http import _require_config
-
-    cfg = _require_config(config_path)
-    if refresh:
-        client = HttpClient(base_url=cfg.base_url)
-        try:
-            client.get("/healthz")
-        except HttpError as exc:
-            logging.error(str(exc))
-            raise typer.Exit(code=1)
-        save_config(cfg, path=config_path)
-        logging.success(f"Configuration refreshed. Saved to {config_path}")
-    logging.log(json.dumps(cfg.to_mapping(), indent=2))
-
-
-@app.command()
-def info() -> None:
-    """Query server health status."""
-    client = client_from_config()
-    try:
-        response = client.get("/healthz")
-    except HttpError as exc:
-        logging.error(str(exc))
-        raise typer.Exit(code=1)
-    logging.log(json.dumps(response.json(), indent=2))
-
-
-@app.command()
-def health() -> None:
-    """Check if the Lumilake server is reachable and healthy."""
-    info()

lumilake_cli-0.1.0.dev1/src/lumilake_cli/core/config.py

@@ -1,38 +0,0 @@
-"""Configuration handling for the Lumilake CLI."""
-
-import tomllib
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any
-
-DEFAULT_CONFIG_DIR = Path.home() / ".lumilake"
-DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.toml"
-
-
-@dataclass
-class LumilakeConfig:
-    base_url: str
-
-    @classmethod
-    def from_mapping(cls, data: dict[str, Any]) -> "LumilakeConfig":
-        if "base_url" not in data:
-            raise ValueError("Missing config key: base_url")
-        return cls(base_url=data["base_url"])
-
-    def to_mapping(self) -> dict[str, str]:
-        return asdict(self)
-
-
-def load_config(path: Path = DEFAULT_CONFIG_PATH) -> LumilakeConfig:
-    if not path.exists():
-        raise FileNotFoundError(f"Config file not found at {path}")
-    content = tomllib.loads(path.read_text())
-    return LumilakeConfig.from_mapping(content)
-
-
-def save_config(config: LumilakeConfig, path: Path = DEFAULT_CONFIG_PATH) -> None:
-    """Persist config to disk, creating the directory if needed."""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    data = config.to_mapping()
-    lines = [f'{key} = "{value}"' for key, value in data.items()]
-    path.write_text("\n".join(lines) + ("\n" if lines else ""))