meditopia-cli 0.1.0__py3-none-any.whl

meditopia/cli.py

@@ -0,0 +1,413 @@
+"""
+medi — Meditopia CLI
+
+Usage examples:
+  medi login --token mtc_xxxx
+  medi whoami
+  medi add dataset ./my-data --to pedram/projects/radiology/chest-xray --privacy public --modality imaging
+  medi add model   ./my-model --to pedram/projects/radiology/chexnet    --privacy public --task radiology --framework pytorch
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import List, Optional
+
+import typer
+from rich import print as rprint
+from rich.table import Table
+from rich import box
+
+from . import config, client
+from .uploader import collect_files
+
+app = typer.Typer(
+    name="medi",
+    help="Meditopia CLI — push models and datasets from your terminal.",
+    add_completion=False,
+)
+add_app = typer.Typer(help="Upload a model or dataset to Meditopia.")
+download_app = typer.Typer(help="Download a model or dataset from Meditopia.")
+app.add_typer(add_app, name="add")
+app.add_typer(download_app, name="download")
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+
+def _parse_to(to: str) -> tuple[str, str, str]:
+    """
+    Split 'owner/collection/path/name' into (owner, collection_path, slug).
+    The last segment is the slug; everything between owner and slug is collection_path.
+    e.g. 'pedram/projects/radiology/chest-xray'  →  ('pedram', 'projects/radiology', 'chest-xray')
+         'pedram/chest-xray'                      →  ('pedram', '', 'chest-xray')
+    """
+    parts = to.strip("/").split("/")
+    if len(parts) < 2:
+        rprint(f"[red]--to must be at least owner/name, got: {to!r}[/red]")
+        raise typer.Exit(1)
+    owner = parts[0]
+    slug = parts[-1]
+    collection_path = "/".join(parts[1:-1])
+    return owner, collection_path, slug
+
+
+def _abort_if_error(r: dict) -> None:
+    if "detail" in r or "error" in r:
+        rprint(f"[red]API error:[/red] {r.get('detail') or r.get('error')}")
+        raise typer.Exit(1)
+
+
+# ── login ─────────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def login(
+    token: str = typer.Option(..., help="Your Meditopia API token (starts with mtc_)"),
+    api_url: str = typer.Option(config.DEFAULT_API_URL, help="API base URL"),
+):
+    """Save your API token and verify it against the server."""
+    config.set_credentials(token, api_url)
+    try:
+        me = client.whoami()
+    except Exception as exc:
+        rprint(f"[red]Login failed:[/red] {exc}")
+        config.clear()
+        raise typer.Exit(1)
+    rprint(
+        f"[green]✓[/green] Logged in as [bold]{me['username']}[/bold] ({me.get('plan', 'free')} plan)"
+    )
+
+
+# ── whoami ────────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def whoami():
+    """Show the currently authenticated user."""
+    try:
+        me = client.whoami()
+    except RuntimeError as exc:
+        rprint(f"[yellow]{exc}[/yellow]")
+        raise typer.Exit(1)
+    rprint(
+        f"[bold]{me['username']}[/bold]  ·  {me.get('email', '')}  ·  {me.get('plan', 'free')} plan"
+    )
+
+
+# ── add dataset ───────────────────────────────────────────────────────────────
+
+
+@add_app.command("dataset")
+def add_dataset(
+    local_path: str = typer.Argument(..., help="Local file or directory to upload"),
+    to: str = typer.Option(..., help="Destination path: owner[/collection/...]/ name"),
+    privacy: str = typer.Option("public", help="public | private | restricted"),
+    modality: str = typer.Option(
+        ...,
+        help="imaging | ehr | genomics | clinical-notes | waveform | multimodal | other",
+    ),
+    description: str = typer.Option("", help="Short description of the dataset"),
+    license: str = typer.Option(
+        "unknown", help="License identifier, e.g. mit, apache-2.0, cc-by-4.0"
+    ),
+    institution: str = typer.Option("", help="Publishing institution"),
+    dua: bool = typer.Option(False, help="Require a Data Use Agreement"),
+    compliance: Optional[List[str]] = typer.Option(
+        None, help="Compliance badges: hipaa, gdpr, fda-track, ce-mark, fhir"
+    ),
+    tags: Optional[List[str]] = typer.Option(None, help="Free-form tags"),
+    num_patients: Optional[int] = typer.Option(
+        None, help="Number of patients in the dataset"
+    ),
+    num_records: Optional[int] = typer.Option(None, help="Number of records"),
+):
+    """Upload a local dataset (files + metadata) to Meditopia."""
+    owner, collection_path, slug = _parse_to(to)
+
+    rprint(
+        f"[bold]Creating dataset[/bold] [cyan]{owner}/{collection_path}/{slug}[/cyan] …"
+    )
+
+    payload = {
+        "name": slug,
+        "description": description,
+        "modality": modality,
+        "visibility": privacy,
+        "license": license,
+        "institution": institution,
+        "requires_dua": dua,
+        "compliance": compliance or [],
+        "tags": tags or [],
+        "collection_path": collection_path,
+        "num_patients": num_patients,
+        "num_records": num_records,
+    }
+
+    try:
+        ds = client.create_dataset(payload)
+    except Exception as exc:
+        rprint(f"[red]Failed to create dataset:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _abort_if_error(ds)
+    rprint(f"[green]✓[/green] Dataset created: [bold]{ds['full_path']}[/bold]")
+
+    # Upload files
+    rprint(f"Collecting files from [cyan]{local_path}[/cyan] …")
+    try:
+        file_tuples = collect_files(local_path)
+    except FileNotFoundError:
+        rprint(f"[red]Path not found:[/red] {local_path}")
+        raise typer.Exit(1)
+
+    if not file_tuples:
+        rprint("[yellow]No files found — dataset created with no files.[/yellow]")
+        return
+
+    rprint(f"Uploading [bold]{len(file_tuples)}[/bold] file(s) …")
+    try:
+        result = client.upload_dataset_files(owner, ds["slug"], file_tuples)
+    except Exception as exc:
+        rprint(f"[red]Upload failed:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _print_upload_summary(result)
+    rprint(
+        f"\n[green]✓ Done.[/green] View at: {config.get_api_url().replace('/api/v1', '')}/datasets/{ds['full_path']}"
+    )
+
+
+# ── add model ─────────────────────────────────────────────────────────────────
+
+
+@add_app.command("model")
+def add_model(
+    local_path: str = typer.Argument(..., help="Local file or directory to upload"),
+    to: str = typer.Option(..., help="Destination path: owner[/collection/...]/name"),
+    privacy: str = typer.Option("public", help="public | private | restricted"),
+    task: str = typer.Option(
+        ...,
+        help="diagnosis | radiology | pathology | genomics | clinical-nlp | drug-discovery | risk-scoring | cardiology | neurology | dermatology | ophthalmology | other",
+    ),
+    framework: str = typer.Option(
+        ..., help="pytorch | tensorflow | jax | onnx | scikit-learn | other"
+    ),
+    modality: str = typer.Option(
+        "",
+        help="Imaging modality if applicable: CT | MRI | X-ray | PET | Ultrasound | other",
+    ),
+    description: str = typer.Option("", help="Short description of the model"),
+    license: str = typer.Option("unknown", help="License identifier"),
+    institution: str = typer.Option("", help="Publishing institution"),
+    compliance: Optional[List[str]] = typer.Option(None, help="Compliance badges"),
+    tags: Optional[List[str]] = typer.Option(None, help="Free-form tags"),
+    auc: Optional[float] = typer.Option(None, help="Primary AUC metric (0–1)"),
+):
+    """Upload a local model (weights + metadata) to Meditopia."""
+    owner, collection_path, slug = _parse_to(to)
+
+    rprint(
+        f"[bold]Creating model[/bold] [cyan]{owner}/{collection_path}/{slug}[/cyan] …"
+    )
+
+    payload = {
+        "name": slug,
+        "description": description,
+        "task": task,
+        "framework": framework,
+        "modality": modality,
+        "visibility": privacy,
+        "license": license,
+        "institution": institution,
+        "compliance": compliance or [],
+        "tags": tags or [],
+        "collection_path": collection_path,
+        "auc": auc,
+    }
+
+    try:
+        model = client.create_model(payload)
+    except Exception as exc:
+        rprint(f"[red]Failed to create model:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _abort_if_error(model)
+    rprint(f"[green]✓[/green] Model created: [bold]{model['full_path']}[/bold]")
+
+    rprint(f"Collecting files from [cyan]{local_path}[/cyan] …")
+    try:
+        file_tuples = collect_files(local_path)
+    except FileNotFoundError:
+        rprint(f"[red]Path not found:[/red] {local_path}")
+        raise typer.Exit(1)
+
+    if not file_tuples:
+        rprint("[yellow]No files found — model created with no files.[/yellow]")
+        return
+
+    rprint(f"Uploading [bold]{len(file_tuples)}[/bold] file(s) …")
+    try:
+        result = client.upload_model_files(owner, model["slug"], file_tuples)
+    except Exception as exc:
+        rprint(f"[red]Upload failed:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _print_upload_summary(result)
+    rprint(
+        f"\n[green]✓ Done.[/green] View at: {config.get_api_url().replace('/api/v1', '')}/models/{model['full_path']}"
+    )
+
+
+# ── download dataset ──────────────────────────────────────────────────────────
+
+
+@download_app.command("dataset")
+def download_dataset(
+    path: str = typer.Argument(..., help="Dataset path: owner/slug"),
+    to: str = typer.Option(".", help="Directory to save the downloaded ZIP"),
+    extract: bool = typer.Option(
+        False, "--extract/--no-extract", help="Extract the ZIP after downloading"
+    ),
+):
+    """Download all files of a dataset as a ZIP."""
+    owner, slug = _parse_owner_slug(path)
+    dest = _resolve_dest(to, slug)
+
+    rprint(f"Downloading dataset [cyan]{owner}/{slug}[/cyan] → [bold]{dest}[/bold] …")
+    try:
+        total = client.download_dataset(owner, slug, dest)
+    except Exception as exc:
+        rprint(f"[red]Download failed:[/red] {exc}")
+        raise typer.Exit(1)
+
+    rprint(f"[green]✓[/green] {total / 1_048_576:.2f} MB saved to [bold]{dest}[/bold]")
+    if extract:
+        _extract_zip(dest, to)
+
+
+# ── download model ────────────────────────────────────────────────────────────
+
+
+@download_app.command("model")
+def download_model(
+    path: str = typer.Argument(..., help="Model path: owner/slug"),
+    to: str = typer.Option(".", help="Directory to save the downloaded ZIP"),
+    extract: bool = typer.Option(
+        False, "--extract/--no-extract", help="Extract the ZIP after downloading"
+    ),
+):
+    """Download all files of a model as a ZIP."""
+    owner, slug = _parse_owner_slug(path)
+    dest = _resolve_dest(to, slug)
+
+    rprint(f"Downloading model [cyan]{owner}/{slug}[/cyan] → [bold]{dest}[/bold] …")
+    try:
+        total = client.download_model(owner, slug, dest)
+    except Exception as exc:
+        rprint(f"[red]Download failed:[/red] {exc}")
+        raise typer.Exit(1)
+
+    rprint(f"[green]✓[/green] {total / 1_048_576:.2f} MB saved to [bold]{dest}[/bold]")
+    if extract:
+        _extract_zip(dest, to)
+
+
+# ── download function ─────────────────────────────────────────────────────────
+
+_LANG_EXT = {"python": "py", "rust": "rs", "api": "json"}
+
+
+@download_app.command("function")
+def download_function(
+    name: str = typer.Argument(..., help="Function name"),
+    to: str = typer.Option(".", help="Directory to save the function script + metadata"),
+):
+    """Download a function's script (+ a .meta.json sidecar) for use in Airflow DAGs."""
+    import os
+    import json
+
+    rprint(f"Fetching function [cyan]{name}[/cyan] …")
+    try:
+        fn = client.get_function(name)
+    except Exception as exc:
+        rprint(f"[red]Download failed:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _abort_if_error(fn)
+
+    os.makedirs(to, exist_ok=True)
+    ext = _LANG_EXT.get(fn["language"], "txt")
+    script_path = os.path.join(to, f"{name}.{ext}")
+    meta_path = os.path.join(to, f"{name}.meta.json")
+
+    with open(script_path, "w") as f:
+        f.write(fn["script"])
+
+    with open(meta_path, "w") as f:
+        json.dump(
+            {
+                "name": fn["name"],
+                "display_name": fn["display_name"],
+                "description": fn["description"],
+                "language": fn["language"],
+                "tags": fn["tags"],
+                "input_ports": fn["input_ports"],
+                "output_ports": fn["output_ports"],
+            },
+            f,
+            indent=2,
+        )
+
+    rprint(f"[green]✓[/green] Saved [bold]{script_path}[/bold] and [bold]{meta_path}[/bold]")
+    if fn["language"] == "rust":
+        rprint(
+            "[yellow]Note:[/yellow] rust functions are downloaded as source only — "
+            "there is no build/compile step yet, so this script cannot be executed "
+            "via functions/_run.py until that's implemented (known gap, carried over "
+            "from the old pipelines executor)."
+        )
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+
+def _parse_owner_slug(path: str) -> tuple[str, str]:
+    parts = path.strip("/").split("/")
+    if len(parts) < 2:
+        rprint(f"[red]Path must be owner/slug, got: {path!r}[/red]")
+        raise typer.Exit(1)
+    return parts[0], parts[-1]
+
+
+def _resolve_dest(directory: str, slug: str) -> str:
+    import os
+
+    os.makedirs(directory, exist_ok=True)
+    return os.path.join(directory, f"{slug}.zip")
+
+
+def _extract_zip(zip_path: str, dest_dir: str) -> None:
+    import zipfile
+
+    rprint(f"Extracting [bold]{zip_path}[/bold] …")
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(dest_dir)
+    rprint(f"[green]✓[/green] Extracted to [bold]{dest_dir}[/bold]")
+
+
+def _print_upload_summary(result: dict) -> None:
+    table = Table(box=box.SIMPLE, show_header=True, header_style="bold")
+    table.add_column("File")
+    table.add_column("Status", style="green")
+    for f in result.get("files", []):
+        table.add_row(f, "✓ uploaded")
+    rprint(table)
+    mb = result.get("bytes", 0) / 1_048_576
+    rprint(
+        f"Total: [bold]{result.get('uploaded', 0)}[/bold] files · [bold]{mb:.2f} MB[/bold]"
+    )
+
+
+if __name__ == "__main__":
+    app()

meditopia/client.py

@@ -0,0 +1,116 @@
+"""
+HTTP client for the Meditopia API.
+"""
+
+from __future__ import annotations
+
+import httpx
+from typing import Any
+
+from . import config
+
+
+def _headers() -> dict[str, str]:
+    token = config.get_token()
+    if not token:
+        raise RuntimeError("Not authenticated. Run: medi login --token <your-token>")
+    return {"Authorization": f"Bearer {token}"}
+
+
+def _base() -> str:
+    return config.get_api_url().rstrip("/")
+
+
+# ── Auth ──────────────────────────────────────────────────────────────────────
+
+
+def whoami() -> dict[str, Any]:
+    r = httpx.get(f"{_base()}/auth/me", headers=_headers(), timeout=10)
+    r.raise_for_status()
+    return r.json()
+
+
+# ── Datasets ──────────────────────────────────────────────────────────────────
+
+
+def create_dataset(payload: dict[str, Any]) -> dict[str, Any]:
+    r = httpx.post(f"{_base()}/datasets", json=payload, headers=_headers(), timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+
+def upload_dataset_files(
+    owner: str, slug: str, file_tuples: list[tuple]
+) -> dict[str, Any]:
+    """
+    file_tuples: list of (filename, file_bytes, content_type)
+    """
+    files = [("files", (name, data, ct)) for name, data, ct in file_tuples]
+    r = httpx.post(
+        f"{_base()}/datasets/{owner}/{slug}/upload",
+        headers=_headers(),
+        files=files,
+        timeout=300,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+# ── Models ────────────────────────────────────────────────────────────────────
+
+
+def create_model(payload: dict[str, Any]) -> dict[str, Any]:
+    r = httpx.post(f"{_base()}/models", json=payload, headers=_headers(), timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+
+def upload_model_files(
+    owner: str, slug: str, file_tuples: list[tuple]
+) -> dict[str, Any]:
+    files = [("files", (name, data, ct)) for name, data, ct in file_tuples]
+    r = httpx.post(
+        f"{_base()}/models/{owner}/{slug}/upload",
+        headers=_headers(),
+        files=files,
+        timeout=300,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+def download_model(owner: str, slug: str, dest: str) -> int:
+    """Stream the model ZIP to *dest*. Returns bytes written."""
+    return _stream_zip(f"{_base()}/models/{owner}/{slug}/download", dest)
+
+
+# ── Functions ──────────────────────────────────────────────────────────────────
+
+
+def get_function(name: str) -> dict[str, Any]:
+    """Fetch a function's metadata + script by name. Public endpoint, no auth needed."""
+    r = httpx.get(f"{_base()}/functions/{name}", timeout=15)
+    r.raise_for_status()
+    return r.json()
+
+
+# ── Downloads (shared) ────────────────────────────────────────────────────────
+
+
+def download_dataset(owner: str, slug: str, dest: str) -> int:
+    """Stream the dataset ZIP to *dest*. Returns bytes written."""
+    return _stream_zip(f"{_base()}/datasets/{owner}/{slug}/download", dest)
+
+
+def _stream_zip(url: str, dest: str) -> int:
+    """Stream a ZIP from *url* into file *dest*, return total bytes."""
+    with httpx.stream(
+        "GET", url, headers=_headers(), timeout=600, follow_redirects=True
+    ) as r:
+        r.raise_for_status()
+        total = 0
+        with open(dest, "wb") as fh:
+            for chunk in r.iter_bytes(chunk_size=1024 * 256):
+                fh.write(chunk)
+                total += len(chunk)
+    return total

meditopia/config.py

@@ -0,0 +1,42 @@
+"""
+Manages ~/.meditopia/config.json — stores token and API URL.
+"""
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".meditopia"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_API_URL = "http://localhost:8000/api/v1"
+
+
+def load() -> dict:
+    if CONFIG_FILE.exists():
+        return json.loads(CONFIG_FILE.read_text())
+    return {}
+
+
+def save(data: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2))
+
+
+def get_token() -> str | None:
+    return load().get("token")
+
+
+def get_api_url() -> str:
+    return load().get("api_url", DEFAULT_API_URL)
+
+
+def set_credentials(token: str, api_url: str = DEFAULT_API_URL) -> None:
+    cfg = load()
+    cfg["token"] = token
+    cfg["api_url"] = api_url
+    save(cfg)
+
+
+def clear() -> None:
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

meditopia/uploader.py

@@ -0,0 +1,32 @@
+"""
+Walks a local directory and returns file tuples ready for upload.
+"""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+from pathlib import Path
+
+
+def collect_files(local_path: str) -> list[tuple[str, bytes, str]]:
+    """
+    Walk *local_path* (file or directory) and return a list of
+    (relative_filename, file_bytes, mime_type) tuples.
+    """
+    root = Path(local_path).resolve()
+    tuples: list[tuple[str, bytes, str]] = []
+
+    if root.is_file():
+        mime = mimetypes.guess_type(root.name)[0] or "application/octet-stream"
+        tuples.append((root.name, root.read_bytes(), mime))
+        return tuples
+
+    for dirpath, _, filenames in os.walk(root):
+        for fname in filenames:
+            abs_path = Path(dirpath) / fname
+            rel_path = str(abs_path.relative_to(root))
+            mime = mimetypes.guess_type(fname)[0] or "application/octet-stream"
+            tuples.append((rel_path, abs_path.read_bytes(), mime))
+
+    return tuples

meditopia_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: meditopia-cli
+Version: 0.1.0
+Summary: CLI tool for uploading models and datasets to Meditopia
+License: MIT
+Project-URL: Homepage, https://meditopia.io
+Project-URL: Repository, https://github.com/meditopia/meditopia-cli
+Keywords: meditopia,cli,medical-ai,machine-learning
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+
+# meditopia-cli
+
+Official CLI for [MedOpia](https://meditopia.io) — upload and manage clinical AI models and datasets from your terminal.
+
+## Installation
+
+```bash
+pip install meditopia-cli
+```
+
+## Quick start
+
+```bash
+medi login --token <your-api-token>
+medi upload model ./my-model --name "chest-xray-classifier"
+medi upload dataset ./my-dataset --name "mimic-cxr-subset"
+```
+
+## Commands
+
+```
+medi --help
+```
+
+## Getting an API token
+
+1. Log in to [meditopia.io](https://meditopia.io)
+2. Go to **Settings → API Tokens**
+3. Create a new token and copy it
+4. Run `medi login --token <token>`

meditopia_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+meditopia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+meditopia/cli.py,sha256=QAEyw-6VU-wBqv6J8ce5PNob2sYqK0rSQCgrrLaFLyk,15294
+meditopia/client.py,sha256=t5L00JrcxM1ie9f6o7vO-NCVyPtvXre9mOaFlybkDiY,3984
+meditopia/config.py,sha256=P58V4uF1MuyldcKAWDfx6F_1XotK8nfehN_Dmat7t3M,877
+meditopia/uploader.py,sha256=I6wGk9kyRPGVqktGp-48pKfNQh5yEaeN6kttwVv-SPY,984
+meditopia_cli-0.1.0.dist-info/METADATA,sha256=mA-AgRf8-005M-xtTufe3EAT2j1_3HoKIrNZT4QAtgg,1184
+meditopia_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+meditopia_cli-0.1.0.dist-info/entry_points.txt,sha256=3_F6FNHXSSwHq9GnQfFU0Rqw1r70nAION7og6t938g4,43
+meditopia_cli-0.1.0.dist-info/top_level.txt,sha256=YRMv_tbnISbMxeZwdXvMtTuWIz3gdmjrefeU7UcwBOU,10
+meditopia_cli-0.1.0.dist-info/RECORD,,

meditopia_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

meditopia_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+medi = meditopia.cli:app

meditopia_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+meditopia