qualia-cli 0.1.0__py3-none-any.whl

qualia_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Qualia CLI - Terminal interface for the Qualia VLA fine-tuning platform."""
+
+__version__ = "0.1.0"

qualia_cli/client.py

@@ -0,0 +1,29 @@
+"""Shared client factory."""
+
+from __future__ import annotations
+
+from qualia import AuthenticationError, Qualia
+
+from qualia_cli.config import load_config
+from qualia_cli.output import print_error
+
+
+def get_client() -> Qualia:
+    from qualia_cli.main import _base_url_override, _token_override
+
+    cfg = load_config()
+    kwargs: dict = {}
+    if _token_override:
+        kwargs["api_key"] = _token_override
+    elif cfg.api_key:
+        kwargs["api_key"] = cfg.api_key
+    if _base_url_override:
+        kwargs["base_url"] = _base_url_override
+    elif cfg.base_url:
+        kwargs["base_url"] = cfg.base_url
+    try:
+        return Qualia(**kwargs)
+    except AuthenticationError as e:
+        print_error(str(e))
+        print_error("Set QUALIA_API_KEY or run: qualia auth login --token <KEY>")
+        raise SystemExit(1) from e

qualia_cli/commands/auth.py

@@ -0,0 +1,43 @@
+"""Auth commands."""
+
+from __future__ import annotations
+
+import typer
+
+from qualia_cli.config import load_config, save_config
+from qualia_cli.output import print_error
+
+app = typer.Typer(help="Authentication.")
+
+
+@app.command("login")
+def login(
+    api_key: str = typer.Option(
+        ..., prompt="API key", hide_input=True, help="Your Qualia API key"
+    ),
+    base_url: str | None = typer.Option(
+        None, help="API base URL (e.g. http://localhost:8000)"
+    ),
+) -> None:
+    """Save your API key (and optional base URL) for future use."""
+    try:
+        path = save_config(api_key, base_url)
+        typer.echo(f"Config saved to {path}")
+    except OSError as e:
+        print_error(f"Could not write config: {e}")
+        raise SystemExit(1) from e
+
+
+@app.command("status")
+def status() -> None:
+    """Check current authentication config."""
+    cfg = load_config()
+    if cfg.api_key:
+        typer.echo(f"API key: {cfg.api_key[:8]}...")
+    else:
+        typer.echo("Not authenticated. Run: qualia auth login")
+        raise SystemExit(1)
+    if cfg.base_url:
+        typer.echo(f"Base URL: {cfg.base_url}")
+    else:
+        typer.echo("Base URL: https://api.qualiastudios.dev (default)")

qualia_cli/commands/credits.py

@@ -0,0 +1,21 @@
+"""Credits commands."""
+
+from __future__ import annotations
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import print_json
+
+app = typer.Typer(help="View credit balance.")
+
+
+@app.callback(invoke_without_command=True)
+def credits(json: bool = typer.Option(False, "--json", help="JSON output")) -> None:
+    """Show your current credit balance."""
+    client = get_client()
+    balance = client.credits.get()
+    if json:
+        print_json(balance)
+    else:
+        typer.echo(f"Credits: {balance.balance}")

qualia_cli/commands/datasets.py

@@ -0,0 +1,85 @@
+"""Datasets commands."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import print_json, print_table
+
+app = typer.Typer(help="Dataset utilities.")
+
+
+@app.command("list")
+def list_datasets(
+    limit: int = typer.Option(20, "--limit", "-n", help="Page size (1-100)"),
+    cursor: str = typer.Option(None, "--cursor", help="Pagination cursor"),
+    sort: str = typer.Option(
+        "newest", "--sort", "-s", help="newest|oldest|updated|name"
+    ),
+    search: str = typer.Option(None, "--search", "-q", help="Search dataset path"),
+    subtype: str = typer.Option(
+        None, "--dataset-type", help="lerobot_v3 or sarm_progress"
+    ),
+    flow: str = typer.Option(None, "--flow", help="input or output"),
+    project_id: str = typer.Option(None, "--project", help="Filter by project ID"),
+    job_id: str = typer.Option(None, "--job", help="Filter by job ID"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List datasets (paginated)."""
+    client = get_client()
+    page = client.datasets.list(
+        limit=limit,
+        cursor=cursor,
+        sort=sort,
+        search=search,
+        subtype=subtype,
+        flow=flow,
+        project_id=UUID(project_id) if project_id else None,
+        job_id=UUID(job_id) if job_id else None,
+    )
+    if json:
+        print_json(page)
+    else:
+        rows = [
+            {
+                "id": str(d.artifact_id)[:8],
+                "subtype": d.subtype,
+                "path": d.path,
+                "jobs": len(d.jobs),
+                "created": d.created_at.strftime("%Y-%m-%d"),
+            }
+            for d in page.items
+        ]
+        print_table(
+            rows,
+            [
+                ("id", "Dataset ID"),
+                ("subtype", "Subtype"),
+                ("path", "Path"),
+                ("jobs", "Jobs"),
+                ("created", "Created"),
+            ],
+        )
+        if page.page_info.has_next:
+            typer.echo(f"\nNext page: --cursor {page.page_info.end_cursor}")
+
+
+@app.command("get-image-keys")
+def get_image_keys(
+    dataset_id: str = typer.Argument(help="HuggingFace dataset ID"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Get available image keys for camera mapping."""
+    client = get_client()
+    result = client.datasets.get_image_keys(dataset_id)
+    if json:
+        print_json(result)
+    else:
+        print_table(
+            [{"key": k} for k in result.image_keys],
+            [("key", "Image Key")],
+            title=f"Image keys for {result.dataset_id}",
+        )

qualia_cli/commands/finetune.py

@@ -0,0 +1,200 @@
+"""Job commands."""
+
+from __future__ import annotations
+
+import json as json_mod
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import console, print_error, print_json, print_table
+
+app = typer.Typer(help="Manage fine-tuning jobs.")
+
+
+@app.command("list")
+def list_jobs(
+    limit: int = typer.Option(20, "--limit", "-n", help="Page size (1-100)"),
+    cursor: str = typer.Option(None, "--cursor", help="Pagination cursor"),
+    sort: str = typer.Option("newest", "--sort", "-s", help="newest|oldest|updated"),
+    search: str = typer.Option(None, "--search", "-q", help="Search job description"),
+    project_id: str = typer.Option(None, "--project", help="Filter by project ID"),
+    vla_type: str = typer.Option(None, "--vla-type", help="Filter by VLA type"),
+    job_type: str = typer.Option(None, "--job-type", help="vla|reward|vla_w_reward"),
+    use_json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List fine-tuning jobs (paginated)."""
+    client = get_client()
+    page = client.jobs.list(
+        limit=limit,
+        cursor=cursor,
+        sort=sort,
+        project_id=project_id,
+        vla_type=vla_type,
+        job_type=job_type,
+        search=search,
+    )
+    if use_json:
+        print_json(page)
+    else:
+        rows = [
+            {
+                "job_id": str(j.job_id)[:8],
+                "desc": j.job_desc or "",
+                "phase": j.current_phase or "",
+                "vla": j.vla_type or "",
+                "model": j.model or "",
+                "dataset": j.dataset or "",
+                "created": j.created_at.strftime("%Y-%m-%d") if j.created_at else "",
+            }
+            for j in page.items
+        ]
+        print_table(
+            rows,
+            [
+                ("job_id", "Job ID"),
+                ("desc", "Description"),
+                ("phase", "Phase"),
+                ("vla", "VLA Type"),
+                ("model", "Model"),
+                ("dataset", "Dataset"),
+                ("created", "Created"),
+            ],
+        )
+        if page.page_info.has_next:
+            typer.echo(f"\nNext page: --cursor {page.page_info.end_cursor}")
+
+
+@app.command("launch")
+def launch(
+    project_id: str = typer.Option(..., help="Project ID"),
+    vla_type: str = typer.Option(
+        ..., help="VLA type (act, smolvla, pi0, pi05, gr00t_n1_5)"
+    ),
+    dataset_id: str = typer.Option(..., help="HuggingFace dataset ID"),
+    hours: float = typer.Option(..., help="Training hours"),
+    camera_mappings: str = typer.Option(
+        ...,
+        help='Camera mappings as JSON, e.g. \'{"cam_1": "observation.images.top"}\'',
+    ),
+    model_id: str | None = typer.Option(
+        None, help="HuggingFace model ID (required for smolvla, pi0, pi05)"
+    ),
+    instance_type: str | None = typer.Option(None, help="GPU instance type"),
+    region: str | None = typer.Option(None, help="Cloud region"),
+    batch_size: int = typer.Option(32, help="Training batch size"),
+    name: str | None = typer.Option(None, help="Job name"),
+    hyper_spec: str | None = typer.Option(None, help="Custom hyperparams as JSON"),
+    use_json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Launch a new fine-tuning job."""
+    try:
+        cam_map = json_mod.loads(camera_mappings)
+    except json_mod.JSONDecodeError as e:
+        print_error("Invalid JSON for --camera-mappings")
+        raise SystemExit(1) from e
+
+    kwargs: dict = {
+        "project_id": project_id,
+        "vla_type": vla_type,
+        "dataset_id": dataset_id,
+        "hours": hours,
+        "camera_mappings": cam_map,
+        "batch_size": batch_size,
+    }
+    if model_id:
+        kwargs["model_id"] = model_id
+    if instance_type:
+        kwargs["instance_type"] = instance_type
+    if region:
+        kwargs["region"] = region
+    if name:
+        kwargs["name"] = name
+    if hyper_spec:
+        try:
+            kwargs["vla_hyper_spec"] = json_mod.loads(hyper_spec)
+        except json_mod.JSONDecodeError as e:
+            print_error("Invalid JSON for --hyper-spec")
+            raise SystemExit(1) from e
+
+    client = get_client()
+    job = client.finetune.create(**kwargs)
+    if use_json:
+        print_json(job)
+    else:
+        typer.echo(f"Job launched: {job.job_id} (status: {job.status})")
+
+
+@app.command("get")
+def get_status(
+    job_id: str = typer.Argument(help="Job ID"),
+    use_json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Get job status."""
+    client = get_client()
+    status = client.finetune.get(job_id)
+    if use_json:
+        print_json(status)
+    else:
+        console.print(f"[bold]Job:[/bold] {status.job_id}")
+        console.print(f"[bold]Status:[/bold] {status.status}")
+        console.print(f"[bold]Phase:[/bold] {status.current_phase}")
+        if status.instance_type:
+            console.print(f"[bold]Instance:[/bold] {status.instance_type}")
+        if status.region:
+            console.print(f"[bold]Region:[/bold] {status.region}")
+        if status.phases:
+            console.print()
+            rows = [
+                {
+                    "name": p.name,
+                    "status": p.status,
+                    "started": str(p.started_at or "-"),
+                    "completed": str(p.completed_at or "-"),
+                    "error": p.error or "",
+                }
+                for p in status.phases
+            ]
+            print_table(
+                rows,
+                [
+                    ("name", "Phase"),
+                    ("status", "Status"),
+                    ("started", "Started"),
+                    ("completed", "Completed"),
+                    ("error", "Error"),
+                ],
+            )
+
+
+@app.command("cancel")
+def cancel(
+    job_id: str = typer.Argument(help="Job ID to cancel"),
+    use_json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Cancel a job."""
+    client = get_client()
+    result = client.finetune.cancel(job_id)
+    if use_json:
+        print_json(result)
+    else:
+        if result.cancelled:
+            typer.echo(f"Cancelled job {result.job_id}")
+        else:
+            typer.echo(f"Could not cancel job {result.job_id}: {result.message}")
+
+
+@app.command("hyperparams")
+def hyperparams(
+    vla_type: str = typer.Argument(help="VLA type"),
+    model_id: str | None = typer.Option(
+        None, help="Model ID for type-specific defaults"
+    ),
+) -> None:
+    """Show default hyperparameters for a VLA type."""
+    client = get_client()
+    defaults = client.finetune.get_hyperparams_defaults(
+        vla_type=vla_type,
+        model_id=model_id,
+    )
+    print_json(defaults)

qualia_cli/commands/instances.py

@@ -0,0 +1,42 @@
+"""Instances commands."""
+
+from __future__ import annotations
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import print_json, print_table
+
+app = typer.Typer(help="GPU instance information.")
+
+
+@app.command("list")
+def list_instances(
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List available GPU instance types."""
+    client = get_client()
+    instances = client.instances.list()
+    if json:
+        print_json(instances)
+    else:
+        rows = [
+            {
+                "id": i.id,
+                "name": i.name,
+                "gpu": i.gpu_description,
+                "cost": str(i.credits_per_hour),
+                "regions": str(i.region_count),
+            }
+            for i in instances
+        ]
+        print_table(
+            rows,
+            [
+                ("id", "ID"),
+                ("name", "Name"),
+                ("gpu", "GPU"),
+                ("cost", "Credits/hr"),
+                ("regions", "Regions"),
+            ],
+        )

qualia_cli/commands/models.py

@@ -0,0 +1,95 @@
+"""Models commands."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import print_json, print_table
+
+app = typer.Typer(help="VLA model information.")
+
+
+@app.command("types")
+def list_types(
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List available VLA model types."""
+    client = get_client()
+    models = client.models.types()
+    if json:
+        print_json(models)
+    else:
+        rows = [
+            {
+                "id": m.id,
+                "name": m.name,
+                "base": m.base_model_id or "-",
+                "cameras": ", ".join(m.camera_slots),
+                "custom": "yes" if m.supports_custom_model else "no",
+            }
+            for m in models
+        ]
+        print_table(
+            rows,
+            [
+                ("id", "ID"),
+                ("name", "Name"),
+                ("base", "Base Model"),
+                ("cameras", "Camera Slots"),
+                ("custom", "Custom Model"),
+            ],
+        )
+
+
+@app.command("list")
+def list_models(
+    limit: int = typer.Option(20, "--limit", "-n", help="Page size (1-100)"),
+    cursor: str = typer.Option(None, "--cursor", help="Pagination cursor"),
+    sort: str = typer.Option(
+        "newest", "--sort", "-s", help="newest|oldest|updated|name"
+    ),
+    search: str = typer.Option(None, "--search", "-q", help="Search model path"),
+    subtype: str = typer.Option(None, "--model-type", help="vla_model or reward_model"),
+    project_id: str = typer.Option(None, "--project", help="Filter by project ID"),
+    job_id: str = typer.Option(None, "--job", help="Filter by job ID"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List trained models (paginated)."""
+    client = get_client()
+    page = client.models.list_trained(
+        limit=limit,
+        cursor=cursor,
+        sort=sort,
+        search=search,
+        subtype=subtype,
+        project_id=UUID(project_id) if project_id else None,
+        job_id=UUID(job_id) if job_id else None,
+    )
+    if json:
+        print_json(page)
+    else:
+        rows = [
+            {
+                "id": str(m.artifact_id)[:8],
+                "subtype": m.subtype,
+                "path": m.path,
+                "jobs": len(m.jobs),
+                "created": m.created_at.strftime("%Y-%m-%d"),
+            }
+            for m in page.items
+        ]
+        print_table(
+            rows,
+            [
+                ("id", "Model ID"),
+                ("subtype", "Subtype"),
+                ("path", "Path"),
+                ("jobs", "Jobs"),
+                ("created", "Created"),
+            ],
+        )
+        if page.page_info.has_next:
+            typer.echo(f"\nNext page: --cursor {page.page_info.end_cursor}")

qualia_cli/commands/projects.py

@@ -0,0 +1,82 @@
+"""Projects commands."""
+
+from __future__ import annotations
+
+import typer
+
+from qualia_cli.client import get_client
+from qualia_cli.output import print_json, print_table
+
+app = typer.Typer(help="Manage projects.")
+
+
+@app.command("list")
+def list_projects(
+    limit: int = typer.Option(20, "--limit", "-n", help="Page size (1-100)"),
+    cursor: str = typer.Option(None, "--cursor", help="Pagination cursor"),
+    sort: str = typer.Option(
+        "newest", "--sort", "-s", help="newest|oldest|updated|name"
+    ),
+    search: str = typer.Option(None, "--search", "-q", help="Search project name"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """List projects (paginated)."""
+    client = get_client()
+    page = client.projects.list(
+        limit=limit,
+        cursor=cursor,
+        sort=sort,
+        search=search,
+    )
+    if json:
+        print_json(page)
+    else:
+        rows = [
+            {
+                "id": str(p.project_id)[:8],
+                "name": p.name,
+                "desc": p.description or "",
+                "created": p.created_at.strftime("%Y-%m-%d"),
+            }
+            for p in page.items
+        ]
+        print_table(
+            rows,
+            [
+                ("id", "Project ID"),
+                ("name", "Name"),
+                ("desc", "Description"),
+                ("created", "Created"),
+            ],
+        )
+        if page.page_info.has_next:
+            typer.echo(f"\nNext page: --cursor {page.page_info.end_cursor}")
+
+
+@app.command("create")
+def create_project(
+    name: str = typer.Argument(help="Project name"),
+    description: str = typer.Option(None, "--description", "-d", help="Description"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Create a new project."""
+    client = get_client()
+    result = client.projects.create(name=name, description=description)
+    if json:
+        print_json(result)
+    else:
+        typer.echo(f"Created project {result.project_id}")
+
+
+@app.command("delete")
+def delete_project(
+    project_id: str = typer.Argument(help="Project ID to delete"),
+    json: bool = typer.Option(False, "--json", help="JSON output"),
+) -> None:
+    """Delete a project."""
+    client = get_client()
+    result = client.projects.delete(project_id)
+    if json:
+        print_json(result)
+    else:
+        typer.echo(f"Deleted project {result.project_id}")

qualia_cli/config.py

@@ -0,0 +1,63 @@
+"""Config file loading and writing."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+CONFIG_DIR = Path(click.get_app_dir("qualia"))
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class Config:
+    api_key: str | None = None
+    base_url: str | None = None
+
+
+def _parse_toml_value(line: str, key: str) -> str | None:
+    """Extract value for a key from a simple TOML line."""
+    stripped = line.strip()
+    if stripped.startswith(key):
+        _, _, val = stripped.partition("=")
+        return val.strip().strip('"').strip("'")
+    return None
+
+
+def load_config() -> Config:
+    """Load config from env vars, falling back to config file."""
+    cfg = Config()
+
+    # env vars take precedence
+    cfg.api_key = os.environ.get("QUALIA_API_KEY")
+    cfg.base_url = os.environ.get("QUALIA_BASE_URL")
+
+    if (cfg.api_key and cfg.base_url) or not CONFIG_FILE.exists():
+        return cfg
+
+    for line in CONFIG_FILE.read_text().splitlines():
+        if not cfg.api_key:
+            val = _parse_toml_value(line, "api_key")
+            if val:
+                cfg.api_key = val
+        if not cfg.base_url:
+            val = _parse_toml_value(line, "base_url")
+            if val:
+                cfg.base_url = val
+
+    return cfg
+
+
+def save_config(api_key: str, base_url: str | None = None) -> Path:
+    """Write config to file. Returns the path written."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    lines = [f'api_key = "{api_key}"']
+    if base_url:
+        lines.append(f'base_url = "{base_url}"')
+    CONFIG_FILE.write_text("\n".join(lines) + "\n")
+    if os.name != "nt":
+        CONFIG_FILE.chmod(0o600)
+    return CONFIG_FILE

qualia_cli/main.py

@@ -0,0 +1,76 @@
+"""Qualia CLI - terminal interface for the Qualia VLA fine-tuning platform."""
+
+from __future__ import annotations
+
+import typer
+from qualia import QualiaAPIError, QualiaError
+
+from qualia_cli.commands import (
+    auth,
+    credits,
+    datasets,
+    finetune,
+    instances,
+    models,
+    projects,
+)
+from qualia_cli.output import print_error
+
+app = typer.Typer(
+    name="qualia",
+    help="Qualia CLI - fine-tune Vision-Language-Action models.",
+    no_args_is_help=True,
+)
+
+app.add_typer(auth.app, name="auth")
+app.add_typer(credits.app, name="credit")
+app.add_typer(datasets.app, name="dataset")
+app.add_typer(finetune.app, name="job")
+app.add_typer(instances.app, name="instance")
+app.add_typer(models.app, name="model")
+app.add_typer(projects.app, name="project")
+
+# Global overrides set by the callback, consumed by get_client()
+_token_override: str | None = None
+_base_url_override: str | None = None
+
+
+@app.callback()
+def main(
+    token: str | None = typer.Option(
+        None, "--token", envvar="QUALIA_API_KEY", help="API key (overrides config)"
+    ),
+    base_url: str | None = typer.Option(
+        None, "--base-url", envvar="QUALIA_BASE_URL", help="API base URL"
+    ),
+) -> None:
+    """Qualia CLI - fine-tune Vision-Language-Action models."""
+    global _token_override, _base_url_override
+    _token_override = token
+    _base_url_override = base_url
+
+
+@app.command()
+def version() -> None:
+    """Show CLI and SDK versions."""
+    from qualia import __version__ as sdk_version
+
+    from qualia_cli import __version__ as cli_version
+
+    typer.echo(f"qualia-cli {cli_version}")
+    typer.echo(f"qualia-sdk {sdk_version}")
+
+
+def cli() -> None:
+    try:
+        app()
+    except QualiaAPIError as e:
+        print_error(str(e))
+        raise SystemExit(1) from e
+    except QualiaError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+if __name__ == "__main__":
+    cli()

qualia_cli/output.py

@@ -0,0 +1,42 @@
+"""Output formatting helpers for table and JSON display."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def print_json(data: Any) -> None:
+    """Print data as formatted JSON."""
+    if hasattr(data, "model_dump"):
+        data = data.model_dump(mode="json")
+    elif isinstance(data, list) and data and hasattr(data[0], "model_dump"):
+        data = [d.model_dump(mode="json") for d in data]
+    console.print_json(json.dumps(data, default=str))
+
+
+def print_table(
+    rows: list[dict[str, Any]],
+    columns: list[tuple[str, str]],
+    title: str | None = None,
+) -> None:
+    """Print rows as a rich table.
+
+    columns: list of (key, header_label) tuples.
+    """
+    table = Table(title=title)
+    for _, header in columns:
+        table.add_column(header)
+    for row in rows:
+        table.add_row(*(str(row.get(k, "")) for k, _ in columns))
+    console.print(table)
+
+
+def print_error(msg: str) -> None:
+    err_console.print(f"[red]Error:[/red] {msg}")

qualia_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: qualia-cli
+Version: 0.1.0
+Summary: CLI for the Qualia Studios VLA fine-tuning platform
+Project-URL: Homepage, https://qualiastudios.dev
+Project-URL: Documentation, https://docs.qualiastudios.dev
+Author: Qualia Studios
+License-Expression: MIT
+Keywords: cli,fine-tuning,qualia,robotics,vla
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: qualia-sdk>=0.2.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+# Qualia CLI
+
+Terminal interface for the [Qualia](https://qualiastudios.dev) VLA fine-tuning platform.
+
+## Install
+
+```sh
+pip install qualia-cli
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv tool install qualia-cli
+```
+
+## Quick start
+
+```sh
+# Authenticate (pick one)
+qualia auth login                        # interactive, saves to config
+export QUALIA_API_KEY="your-api-key"     # env var
+qualia --token <KEY> <command>           # inline, for CI/scripts
+
+# List available models
+qualia models list
+
+# List GPU instances
+qualia instances list
+
+# Create a project
+qualia projects create "My Robot"
+
+# Start a fine-tuning job
+qualia finetune create \
+  --project-id <id> \
+  --vla-type smolvla \
+  --model-id lerobot/smolvla_base \
+  --dataset-id lerobot/pusht \
+  --dataset-last-modified "2025-01-15T10:00:00Z" \
+  --model-last-modified "2025-01-15T10:00:00Z" \
+  --hours 2.0 \
+  --camera-mappings '{"cam_1": "observation.images.top"}'
+
+# Check job status
+qualia finetune get <job-id>
+```
+
+## JSON output
+
+All commands support `--json` for machine-readable output:
+
+```sh
+qualia projects list --json
+qualia credits --json
+```

qualia_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+qualia_cli/__init__.py,sha256=xpooCLfcAl2BTsYxuAJzb8lBfskcCi-r7b-HLuGEKKc,102
+qualia_cli/client.py,sha256=yrb2xrfn2OabbBaJYVmTknKPDcvHHPckHko78KcglhI,836
+qualia_cli/config.py,sha256=QD4IZ1tsYbfrRkRUc9BNrfnXHrXGVkNdVNo0JtEEtIw,1725
+qualia_cli/main.py,sha256=mwEncy2S1UomSSyz5SwY0RY4mVTxnEkxu8hpHGrViv0,1920
+qualia_cli/output.py,sha256=bazOtQRA6p0124GfAglha0d-wOFwJsLAHBl2aqr9wiY,1110
+qualia_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qualia_cli/commands/auth.py,sha256=551vEGWPAexEE1WFdx6VIa1SeUmh32X6os395KiCBF4,1209
+qualia_cli/commands/credits.py,sha256=g7SuguSWwai3kTiFh3CMbkfBWesHOl0F9uYtu3VCyQg,541
+qualia_cli/commands/datasets.py,sha256=mlWOxNe8mvBfnrKvyXKD-70-8UlrxEzuEXqqBJGjQhE,2671
+qualia_cli/commands/finetune.py,sha256=xlwkS_ZkAtzclRolyQjxW8aSejBPh8bUt5CQJXIktXo,6710
+qualia_cli/commands/instances.py,sha256=4ozIzvR-MQUBjceZQMUUUtjBjY83nqRJ7vUSkVluRk0,1050
+qualia_cli/commands/models.py,sha256=fl_eKsXSqEhecr1Nh0LC-lGt0JRsuvzhzpcSzx72nPc,2865
+qualia_cli/commands/projects.py,sha256=CmI1tHOZvt84rB4w_SyygoDkse7U3hTzP1ZlBl2Rtw0,2434
+qualia_cli-0.1.0.dist-info/METADATA,sha256=BTpdMBqXTbCtMMJF9hi90HxThgMXLE2q3GwJoRHL3jE,1977
+qualia_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+qualia_cli-0.1.0.dist-info/entry_points.txt,sha256=hjLKGQ8xf2rlxWfPuZFyCvVk8PSDtDNxpXHyz6woUM0,47
+qualia_cli-0.1.0.dist-info/RECORD,,

qualia_cli-0.1.0.dist-info/WHEEL

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

qualia_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qualia = qualia_cli.main:cli