gpyou 0.1.0__tar.gz

gpyou-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.5
+Name: gpyou
+Version: 0.1.0
+Summary: Command-line client for GPYou: prepaid GPUs for fine-tuning and serving open models
+Project-URL: Homepage, https://app.gpyou.ai
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.12
+Requires-Dist: authlib<2,>=1.4
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: keyring<26,>=25
+Requires-Dist: pyjwt[crypto]<3,>=2.15
+Requires-Dist: qrcode<9,>=8
+Requires-Dist: typer<1,>=0.15
+Description-Content-Type: text/markdown
+
+# gpyou
+
+Command-line client for [GPYou](https://app.gpyou.ai): prepaid GPUs for fine-tuning and serving open models.
+
+```sh
+uv tool install gpyou     # or: pipx install gpyou
+gpyou signup              # or: gpyou login
+gpyou                     # interactive menu
+```
+
+The CLI talks to `https://app.gpyou.ai`. Set `GPYOU_API_URL` to use another GPYou service, such as a development server.

gpyou-0.1.0/README.md

@@ -0,0 +1,11 @@
+# gpyou
+
+Command-line client for [GPYou](https://app.gpyou.ai): prepaid GPUs for fine-tuning and serving open models.
+
+```sh
+uv tool install gpyou     # or: pipx install gpyou
+gpyou signup              # or: gpyou login
+gpyou                     # interactive menu
+```
+
+The CLI talks to `https://app.gpyou.ai`. Set `GPYOU_API_URL` to use another GPYou service, such as a development server.

gpyou-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+# The stand-alone `gpyou` CLI published to PyPI. scripts/build_cli.py copies the CLI modules next to this file and
+# builds it; the platform itself (pyproject.toml at the repository root) is never published.
+[project]
+name = "gpyou"
+version = "0.1.0"
+description = "Command-line client for GPYou: prepaid GPUs for fine-tuning and serving open models"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "LicenseRef-Proprietary"
+dependencies = [
+  "httpx>=0.28,<1",
+  "typer>=0.15,<1",
+  "keyring>=25,<26",
+  "authlib>=1.4,<2",
+  "pyjwt[crypto]>=2.15,<3",
+  "qrcode>=8,<9",
+]
+
+[project.urls]
+Homepage = "https://app.gpyou.ai"
+
+[project.scripts]
+gpyou = "gpyou.cli:app"
+docker-credential-gpyou = "gpyou.client:docker_helper"
+
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gpyou"]

gpyou-0.1.0/src/gpyou/__init__.py

@@ -0,0 +1 @@
+"""GPYou control plane and client."""

gpyou-0.1.0/src/gpyou/agent/cli.py

@@ -0,0 +1,134 @@
+"""gpyou agent: a conversational console. Plain commands stay one '!' away; exit returns to the shell."""
+import json
+import secrets
+import shlex
+import sys
+from contextlib import closing
+from pathlib import Path
+
+import httpx
+import typer
+
+from gpyou.client import Client
+from gpyou.menu import Spinner, explain, interactive, say, wait_operation
+
+ALLOWED = {("POST", "/v1/finetunes"), ("POST", "/v1/endpoints"), ("POST", "/v1/instances"), ("POST", "/v1/checkout")}
+DELETABLE = ("/v1/instances/", "/v1/endpoints/")
+
+
+def execute(client, proposal):
+    """Run a confirmed proposal with the customer's own session; only known platform actions are accepted."""
+    if proposal["action"] == "upload":
+        return client.upload(proposal["bucket_id"], Path(proposal["path"]).expanduser())
+    method, path = proposal["method"], proposal["path"]
+    if (method, path) not in ALLOWED and not (method == "DELETE" and path.startswith(DELETABLE) and "/" not in path[14:]):
+        raise ValueError("The assistant proposed an action this CLI does not run")
+    result = client.request(method, path, json=proposal.get("body"), key=secrets.token_hex(16) if method == "POST" else None)
+    if interactive() and proposal["action"] in ("finetune_start", "instance_launch"):
+        until = "done" if proposal["action"] == "finetune_start" else "ready"
+        result = {**result, "waited": wait_operation(client, result["id"], until=until)}
+    return result
+
+
+def confirm(proposal):
+    say("\nProposed: " + proposal["summary"])
+    return typer.confirm("Run it?", default=False, err=True)
+
+
+WINDOW = 40  # messages sent per turn; the endpoint accepts 60, older ones are summarised in one line
+
+
+def window(transcript):
+    """The recent transcript, with a one-line note standing in for what was dropped, always starting at a user turn."""
+    if len(transcript) <= WINDOW:
+        return list(transcript)
+    recent = transcript[-WINDOW:]
+    while recent and recent[0]["role"] != "user":
+        recent = recent[1:]
+    dropped = len(transcript) - len(recent)
+    return [{"role": "user", "content": f"(Earlier in this session we exchanged {dropped} messages that are no longer shown.)"},
+            {"role": "assistant", "content": "Understood; I will ask if I need something from earlier."}, *recent]
+
+
+def turn(client, transcript, content, decide=confirm):
+    """One exchange. Confirmed proposals run and their result is fed back as the next user message."""
+    transcript.append({"role": "user", "content": content})
+    reply, proposals, spinner = [], [], Spinner()
+    spinner.start("Thinking...")
+    try:
+        for event in client.stream_agent(window(transcript)):
+            if event["type"] == "text":
+                if not reply and not event["delta"].strip():
+                    continue  # reasoning models often open with blank lines
+                spinner.stop()
+                reply.append(event["delta"])
+                if interactive():
+                    typer.echo(event["delta"], nl=False, err=True)
+            elif event["type"] == "tool":
+                spinner.stop()
+                if interactive() and reply and not reply[-1].endswith("\n"):
+                    say("")  # the tool line goes under the text streamed so far, not after it
+                say(f"  · {event['name']}")
+                spinner.start("Working...")
+            elif event["type"] == "proposal":
+                proposals.append(event)
+            elif event["type"] == "error":
+                raise RuntimeError(event["message"])
+    finally:
+        spinner.stop()
+    if interactive():
+        say("")
+    transcript.append({"role": "assistant", "content": "".join(reply) or "(no reply)"})
+    for proposal in proposals:
+        if decide(proposal):
+            result = execute(client, proposal)
+            if proposal["action"] == "credit_add" and result.get("url"):
+                from gpyou.cli import open_browser
+                say("Complete the payment in your browser." if open_browser(result["url"]) else "Open this link to pay: " + result["url"])
+            return turn(client, transcript, f"I confirmed and ran: {proposal['summary']}. Result: {json.dumps(result, default=str)}", decide)
+        transcript.append({"role": "user", "content": "I declined: " + proposal["summary"]})
+        transcript.append({"role": "assistant", "content": "Understood, not doing that."})
+    return "".join(reply), proposals
+
+
+def command(line):
+    """Run a plain gpyou command in-process, e.g. '!credits balance'."""
+    from gpyou.cli import app
+    try:
+        typer.main.get_command(app).main(shlex.split(line), prog_name="gpyou", standalone_mode=False)
+    except typer.Exit:
+        pass
+    except (typer.exceptions.TyperException, ValueError) as exc:  # usage errors and bad parameters
+        say(str(exc))
+
+
+def repl(client):
+    import readline  # noqa: F401  (line editing and history for the prompt)
+    say("GPYou assistant. Ask about your account, datasets, fine-tuning or serving. "
+        "Type exit to leave; !<command> runs a gpyou command, e.g. !credits balance.")
+    transcript = []
+    while True:
+        try:
+            line = typer.prompt("you", err=True, prompt_suffix="> ").strip()
+        except typer.Abort:
+            return
+        if line in ("exit", "quit"):
+            return
+        if line.startswith("!"):
+            command(line[1:])
+        elif line:
+            try:
+                turn(client, transcript, line)
+            except (httpx.HTTPError, RuntimeError) as exc:
+                say(explain(exc))
+
+
+def run(prompt=None):
+    with closing(Client()) as client:
+        if prompt is None and interactive():
+            return repl(client)
+        if prompt is None:
+            prompt = sys.stdin.read().strip()
+        reply, proposals = turn(client, [], prompt, decide=confirm if interactive() else lambda p: False)
+        if not interactive():
+            typer.echo(json.dumps({"reply": reply, "proposals": proposals}, indent=2))

gpyou-0.1.0/src/gpyou/cli.py

@@ -0,0 +1,437 @@
+import json
+import os
+import secrets
+import tempfile
+from contextlib import closing
+from decimal import Decimal
+from enum import StrEnum
+from pathlib import Path
+from typing import Annotated
+
+import httpx
+import typer
+from keyring.errors import KeyringError
+from typer.core import TyperGroup
+
+from gpyou.client import Client, api_url, error_text
+from gpyou.onboarding import Method
+from gpyou.units import micros
+
+
+class CLIGroup(TyperGroup):
+    def invoke(self, ctx):
+        try:
+            return super().invoke(ctx)
+        except (typer.Exit, typer.Abort):
+            raise
+        except httpx.HTTPStatusError as exc:
+            typer.echo(error_text(exc.response), err=True)
+            raise typer.Exit(1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo("Network request failed. Check the service URL and connection.", err=True)
+            raise typer.Exit(1) from exc
+        except (OSError, RuntimeError, ValueError, KeyringError) as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(1) from exc
+
+
+app = typer.Typer(cls=CLIGroup, help="gpyou_: prepaid GPU jobs, model development, and persistent storage.", no_args_is_help=True)
+groups = {name: typer.Typer(no_args_is_help=True) for name in (
+    "credits", "billing", "identities", "instances", "finetune", "endpoints", "buckets", "storage", "registry", "images", "security")}
+for name, group in groups.items():
+    app.add_typer(group, name=name)
+
+
+@app.callback()
+def main(ctx: typer.Context, json_output: bool = typer.Option(False, "--json", help="Emit machine-readable JSON (all commands).")):
+    """Before, `--json` was accepted and ignored, so a terminal still got text."""
+    from gpyou import menu
+    menu.FORCE_JSON = json_output
+    ctx.call_on_close(lambda: setattr(menu, 'FORCE_JSON', False))  # never leaks into the next command
+
+
+def output(value):
+    typer.echo(json.dumps(value, indent=2, default=str))
+
+
+def open_browser(url):
+    import webbrowser
+    try:
+        return webbrowser.open(url)
+    except webbrowser.Error:
+        return False
+
+
+def cents(amount):
+    value = Decimal(str(amount)) * 100
+    if not value.is_finite() or value != value.to_integral_value():
+        raise typer.BadParameter("USD payment amounts must be finite and contain no fractional cents")
+    return int(value)
+
+
+def call(method, path, *, body=None, key=None, params=None):
+    with closing(Client()) as client:
+        result = client.request(method, path, json=body, key=key, params=params)
+        output(result)
+        return result
+
+
+@app.command()
+def signup(browser: bool = False, method: Method | None = None):
+    """Verify email in the CLI; after approval, choose passkey or authenticator setup."""
+    if not browser:
+        from gpyou.onboarding import run
+        return run('signup', method)
+    try:
+        url = api_url() + "/signup"
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+    opened = open_browser(url)
+    output({"signup_url": url, "browser_opened": opened,
+            "next_step": "Create your account in the browser and confirm your email. "
+                         "Then run gpyou login, or add a passkey under Security first."})
+
+
+@app.command()
+def login(method: Method | None = None):
+    """Sign in. Without --method a terminal asks: email code (default) or passkey."""
+    from gpyou.onboarding import run
+    run('login', method)
+
+
+@groups['security'].command('setup')
+def security_setup(method: Method, login_method: Method = Method.passkey):
+    """Sign in freshly, then add a passkey or authenticator app."""
+    from gpyou.onboarding import run
+    run('setup', method, login_method)
+
+
+@app.command()
+def status():
+    """Which API this terminal is signed in to, its mode, providers, schema and your account in one look."""
+    from gpyou.menu import dollars, interactive, say
+    with closing(Client()) as client:
+        info = client.request("GET", "/v1/status")
+    if not interactive():
+        return output({"api_url": client.url, **info})
+    say(f"API: {client.url}   mode: {info['mode']}   providers: {', '.join(info['providers']) or 'none'}   "
+        f"schema: {info['schema_revision'] or 'unknown'}   assistant: {'on' if info['assistant'] else 'off'}")
+    say(f"Account {info['tenant_id']} ({info['role']}): {dollars(info['available_micro_usd'])} available, "
+        f"up to {info['instance_limit']} GPUs at once.")
+    if info["mode"] == "simulation":
+        say("Simulation: offers are made up and nothing is rented; endpoints answer with a fixed sentence.")
+
+
+@app.command()
+def logout():
+    with closing(Client()) as client:
+        client.logout()
+    output({"signed_out": True})
+
+
+@groups["credits"].command("balance")
+def balance():
+    """Available, total and reserved credit: a sentence on a terminal, JSON when piped."""
+    from gpyou.menu import interactive, show_balance
+    with closing(Client()) as client:
+        if interactive():
+            return show_balance(client)
+        output(client.request("GET", "/v1/credits"))
+
+
+@groups["credits"].command("usage")
+def credit_usage():
+    call("GET", "/v1/usage")
+
+
+@groups["credits"].command("add")
+def add_credit(amount: Annotated[float, typer.Argument(min=10, max=1000)],
+               save_for_topup: bool = False, request_id: str | None = None, browser: bool = True):
+    result = call("POST", "/v1/checkout", body={"amount_cents": cents(amount),
+                  "save_for_topup": save_for_topup}, key=request_id or secrets.token_hex(16))
+    if browser and result.get("url"):
+        open_browser(result["url"])
+
+
+@groups["billing"].command("auto-topup")
+def auto_topup(threshold: float, amount: float, monthly_limit: float, enabled: bool = True):
+    call("PUT", "/v1/billing/auto-topup", body={"enabled": enabled,
+        "threshold_cents": cents(threshold), "amount_cents": cents(amount),
+        "monthly_limit_cents": cents(monthly_limit)})
+
+
+@groups["billing"].command("payments")
+def payments():
+    call("GET", "/v1/billing/payments")
+
+
+@groups["billing"].command("recover")
+def recover_payment(payment_id: str, request_id: str | None = None, browser: bool = True):
+    """Open a manual replacement purchase; automatic top-ups stay paused."""
+    result = call("POST", f"/v1/billing/payments/{payment_id}/recover",
+                  key=request_id or secrets.token_hex(16))
+    if browser and result.get("url"):
+        open_browser(result["url"])
+
+
+@groups["identities"].command("list")
+def identities():
+    call("GET", "/v1/identities")
+
+
+@groups["identities"].command("trust")
+def trust(subject: str, repository_id: str, repository_owner_id: str, read_only: bool = False):
+    call("POST", "/v1/identities", body={"subject": subject, "repository_id": repository_id, "repository_owner_id": repository_owner_id,
+        "scopes": ["resources:read"] if read_only else ["resources:read", "resources:write", "inference"]})
+
+
+@groups["identities"].command("revoke")
+def revoke(identity_id: str):
+    call("DELETE", "/v1/identities/" + identity_id)
+
+
+class Provider(StrEnum):
+    runpod = "runpod"
+    vast = "vast"
+    verda = "verda"
+
+
+def container_request(image, gpu, count, max_price, country, max_transfer, disk, max_duration, registry_id, provider=None):
+    return {"image": image, "gpu": gpu, "count": count, "max_hourly_micro_usd": micros(max_price),
+            "country": country, "max_transfer_micro_usd_gb": micros(max_transfer),
+            "disk_gb": disk, "max_duration_seconds": max_duration, "registry_id": registry_id, "provider": provider}
+
+
+@app.command()
+def offers(image: str, max_price: float, gpu: str = "RTX 4090", count: int = 1,
+           country: str | None = None, max_transfer: float = 0, disk: int = 40, provider: Provider | None = None):
+    from gpyou.cli_tables import show_offers
+    with closing(Client()) as client:
+        show_offers(client.request("POST", "/v1/quotes",
+                                   json=container_request(image, gpu, count, max_price, country, max_transfer, disk, None, None, provider)))
+
+
+@app.command()
+def gpus(country: str | None = None, provider: Provider | None = None):
+    """Live GPU offers, cheapest per model. On a terminal: pick one, then choose what to run on it."""
+    from gpyou.guide import all_offers, start_from_gpu
+    from gpyou.menu import interactive
+    with closing(Client()) as client:
+        rows = all_offers(client, country, provider)
+        if not interactive():
+            return output([offer for _, offer in rows])
+        start_from_gpu(client, rows, provider)
+
+
+@app.command()
+def launch(image: Annotated[str | None, typer.Argument()] = None,
+           max_price: Annotated[float | None, typer.Argument()] = None, gpu: str = "RTX 4090", count: int = 1,
+           country: str | None = None, max_transfer: float = 0, disk: int = 40,
+           max_duration: int | None = None, registry_id: str | None = None,
+           yes: bool = typer.Option(False, "--yes", "-y"), request_id: str | None = None,
+           spec: Path | None = None, quote_id: str | None = None, provider: Provider | None = None):
+    if not (spec or quote_id) and (image is None or max_price is None):
+        raise typer.BadParameter("Supply IMAGE MAX_PRICE, --spec, or --quote-id")
+    body = (json.loads(spec.read_text()) if spec else container_request(image, gpu, count, max_price,
+            country, max_transfer, disk, max_duration, registry_id, provider)) if not quote_id else None
+    with closing(Client()) as client:
+        quote = client.request("GET", "/v1/quotes/" + quote_id) if quote_id else client.request("POST", "/v1/quotes", json=body)
+    typer.echo(json.dumps(quote, indent=2), err=True)
+    if not quote["offers"]:
+        raise typer.Exit(1)
+    if not yes:
+        typer.confirm("Launch at these rates? GPU disk is temporary; transfer is charged separately.", abort=True, err=True)
+    key = request_id or secrets.token_hex(16)
+    typer.echo("Request ID: " + key, err=True)
+    call("POST", "/v1/instances", body={"quote_id": quote["id"]}, key=key)
+
+
+@groups["instances"].command("list")
+def instances():
+    call("GET", "/v1/instances")
+
+
+@groups["instances"].command("get")
+def instance_get(operation_id: str):
+    call("GET", "/v1/operations/" + operation_id)
+
+
+@app.command()
+def logs(operation_id: str):
+    """Recent output of a container, training job or endpoint: plain text on a terminal, JSON when piped."""
+    from gpyou.menu import interactive
+    with closing(Client()) as client:
+        result = client.request("GET", f"/v1/instances/{operation_id}/logs")
+    if not interactive():
+        return output(result)
+    typer.echo(result.get("logs") or "No log output yet.", nl=not (result.get("logs") or "").endswith("\n"))
+
+
+def local_time(timestamp):
+    """The terminal's local time with its zone: notices showed a bare "18:27", unclear to anyone reading them elsewhere."""
+    from datetime import datetime
+    return datetime.fromtimestamp(timestamp).astimezone().strftime("%Y-%m-%d %H:%M %Z")
+
+
+@app.command()
+def notifications():
+    """Job and account updates, newest first: plain text on a terminal, JSON when piped. The same notices are emailed."""
+    from gpyou.menu import interactive
+    with closing(Client()) as client:
+        items = client.request("GET", "/v1/notifications")
+    if not interactive():
+        return output(items)
+    for item in items or [{"message": "No notifications yet."}]:
+        typer.echo(f"{local_time(item['created_at'])}  {item['message']}" if item.get("created_at") else item["message"])
+
+
+@app.command()
+def terminate(operation_id: str):
+    call("DELETE", "/v1/instances/" + operation_id)
+
+
+@groups["buckets"].command("create")
+def bucket_create(name: str):
+    call("POST", "/v1/buckets", body={"name": name})
+
+
+@groups["buckets"].command("list")
+def buckets():
+    call("GET", "/v1/buckets")
+
+
+@groups["buckets"].command("delete")
+def bucket_delete(bucket_id: str):
+    call("DELETE", "/v1/buckets/" + bucket_id)
+
+
+@groups["storage"].command("upload")
+def upload(bucket_id: str, source: Path, key: str | None = None, upload_id: str | None = None):
+    with closing(Client()) as client:
+        output(client.upload(bucket_id, source, key, upload_id))
+
+
+@groups["storage"].command("download")
+def download(object_id: str, destination: Path):
+    with closing(Client()) as client:
+        output(client.download(object_id, destination))
+
+
+@groups["storage"].command("list")
+def objects(bucket_id: str):
+    call("GET", f"/v1/buckets/{bucket_id}/objects")
+
+
+@groups["storage"].command("delete")
+def object_delete(object_id: str):
+    call("DELETE", "/v1/objects/" + object_id)
+
+
+@groups["storage"].command("abort")
+def upload_abort(upload_id: str):
+    """Cancel an incomplete upload and release its reserved storage."""
+    call("DELETE", "/v1/uploads/" + upload_id)
+
+
+@groups["registry"].command("add")
+def registry_add(server: str, username: str):
+    password = typer.prompt("Registry password or pull token", hide_input=True, err=True)
+    call("POST", "/v1/registries", body={"server": server, "username": username, "password": password})
+
+
+@groups["registry"].command("list")
+def registry_list():
+    call("GET", "/v1/registries")
+
+
+@groups["registry"].command("remove")
+def registry_remove(registry_id: str):
+    call("DELETE", "/v1/registries/" + registry_id)
+
+
+@groups["registry"].command("login")
+def registry_login():
+    with closing(Client()) as client:
+        result = client.request("GET", "/v1/registry/config")
+    if not result["server"]:
+        raise typer.BadParameter("Registry is not configured")
+    path = Path(os.environ.get("DOCKER_CONFIG", str(Path.home() / ".docker"))) / "config.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = json.loads(path.read_text()) if path.exists() else {}
+    if not isinstance(data, dict) or not isinstance(data.get("credHelpers", {}), dict):
+        raise ValueError("Docker config and credHelpers must be JSON objects")
+    data.setdefault("credHelpers", {})[result["server"]] = "gpyou"
+    with tempfile.NamedTemporaryFile(mode="w", dir=path.parent, delete=False) as file:
+        temporary = Path(file.name)
+        try:
+            file.write(json.dumps(data, indent=2) + "\n")
+            file.flush()
+            temporary.replace(path)
+        finally:
+            temporary.unlink(missing_ok=True)
+    output(result)
+
+
+@groups["images"].command("list")
+def images():
+    call("GET", "/v1/images")
+
+
+@groups["images"].command("delete")
+def image_delete(image_id: str):
+    call("DELETE", "/v1/images/" + image_id)
+
+
+@groups["finetune"].command("wait")
+def finetune_wait(operation_id: str, timeout: int = 3600):
+    """Follow a training job with live feedback until it completes or fails."""
+    from gpyou.menu import wait_operation
+    with closing(Client()) as client:
+        report_wait(wait_operation(client, operation_id, until="done", timeout=timeout))
+
+
+@groups["instances"].command("wait")
+def instance_wait(operation_id: str, timeout: int = 1800):
+    """Follow a launch with live feedback until the GPU container is running."""
+    from gpyou.menu import wait_operation
+    with closing(Client()) as client:
+        report_wait(wait_operation(client, operation_id, until="ready", timeout=timeout))
+
+
+def report_wait(op):
+    """The state lines were already printed while waiting; scripts get the final operation as JSON."""
+    from gpyou.menu import interactive
+    if not interactive():
+        output(op)
+
+
+@groups["identities"].command("sessions")
+def sessions():
+    call("GET", "/v1/sessions")
+
+
+@groups["identities"].command("revoke-session")
+def revoke_session(session_id: str):
+    call("DELETE", "/v1/sessions/" + session_id)
+
+
+@app.command()
+def agent(prompt: Annotated[str | None, typer.Argument()] = None):
+    """Chat with the GPYou assistant about your account, datasets, fine-tuning, and serving."""
+    from gpyou.agent.cli import run
+    run(prompt)
+
+
+@app.command()
+def demo():
+    """Run the complete simulated lifecycle in-process without accounts or GPU charges."""
+    import asyncio
+
+    try:
+        from gpyou.demo import run
+    except ModuleNotFoundError as exc:  # the published CLI package leaves the server, and so the demo, out
+        raise typer.BadParameter("The demo runs the whole platform locally; use a checkout of the GPYou repository") from exc
+    output(asyncio.run(run()))
+
+
+import gpyou.cli_models  # noqa: E402,F401 - registers the fine-tune, serving and endpoint commands