olive-compute 0.1.1__py3-none-any.whl

olive/__init__.py

@@ -0,0 +1,16 @@
+from .client import (
+    OliveClient, AsyncOliveClient,
+    Job, AsyncJob,
+    OliveError, AuthError, JobError,
+    NotFoundError, RateLimitError, ServerError,
+)
+from .compute import App, Image, Function, ComputeError
+
+__all__ = [
+    "OliveClient", "AsyncOliveClient",
+    "Job", "AsyncJob",
+    "OliveError", "AuthError", "JobError",
+    "NotFoundError", "RateLimitError", "ServerError",
+    "App", "Image", "Function", "ComputeError",
+]
+__version__ = "0.1.1"

olive/cli.py

@@ -0,0 +1,163 @@
+"""olive CLI — `olive deploy script.py`, `olive call`, `olive list`, etc.
+
+Wired up via the [project.scripts] entry point in pyproject.toml.
+
+Reads ``OLIVE_API_KEY`` from the environment (or accepts ``--api-key``).
+Reads ``OLIVE_API_URL`` if overriding the default backend.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from .client import OliveClient
+from .compute import App
+
+
+def _load_module(path: str):
+    """Import a Python file by path. Returns the module (with side effects
+    from any top-level code, including ``@app.function`` registrations)."""
+    p = Path(path).resolve()
+    if not p.exists():
+        sys.exit(f"error: file not found: {path}")
+    spec = importlib.util.spec_from_file_location(p.stem, p)
+    if spec is None or spec.loader is None:
+        sys.exit(f"error: failed to import {path}")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _find_apps(mod) -> list[App]:
+    """Find all module-level App instances."""
+    return [v for v in vars(mod).values() if isinstance(v, App)]
+
+
+def _client_from_args(args) -> OliveClient:
+    api_key = args.api_key or os.environ.get("OLIVE_API_KEY")
+    if not api_key:
+        sys.exit(
+            "error: no API key. Set OLIVE_API_KEY or pass --api-key. "
+            "Get one at https://customer.olivecompute.com"
+        )
+    base = args.api_url or os.environ.get("OLIVE_API_URL") or "https://api.olivecompute.com"
+    return OliveClient(api_key=api_key, base_url=base)
+
+
+# ── Commands ──────────────────────────────────────────────────────────────
+
+
+def cmd_deploy(args):
+    mod = _load_module(args.file)
+    apps = _find_apps(mod)
+    if not apps:
+        sys.exit(
+            f"error: no App found in {args.file}. Define one with "
+            "`from olive import App; app = App('my-app')`."
+        )
+    client = _client_from_args(args)
+    for app in apps:
+        if not app.functions:
+            print(f"⚠  app {app.name!r}: no @app.function decorators found")
+            continue
+        records = app.deploy(client)
+        print(f"✓ app {app.name!r}: deployed {len(records)} function(s)")
+        for fn, r in zip(app.functions, records):
+            print(f"  • {fn.remote_name}  → {r.get('function_id')}")
+            print(f"    image:   {r.get('image_uri')}")
+            print(f"    invoke:  olive call {fn.remote_name} '<json input>'")
+
+
+def cmd_list(args):
+    client = _client_from_args(args)
+    fns = client.list_functions()
+    if not fns:
+        print("no compute functions deployed")
+        return
+    print(f"{'NAME':<40} {'TIER':<8} {'TIMEOUT':<8} {'INVOCATIONS':<12} {'VERSION'}")
+    for f in fns:
+        print(
+            f"{f['name']:<40} {f['compute_tier']:<8} {str(f['timeout_seconds'])+'s':<8} "
+            f"{str(f['invocation_count']):<12} {f['version']}"
+        )
+
+
+def cmd_call(args):
+    client = _client_from_args(args)
+    try:
+        input_value: Any = json.loads(args.input) if args.input else None
+    except json.JSONDecodeError as e:
+        sys.exit(f"error: input is not valid JSON: {e}")
+    result = client.compute_call(args.name, input_value)
+    if isinstance(result, (dict, list)):
+        print(json.dumps(result, indent=2))
+    else:
+        print(result)
+
+
+def cmd_spawn(args):
+    client = _client_from_args(args)
+    try:
+        input_value: Any = json.loads(args.input) if args.input else None
+    except json.JSONDecodeError as e:
+        sys.exit(f"error: input is not valid JSON: {e}")
+    r = client.compute_spawn(args.name, input_value)
+    print(json.dumps(r, indent=2))
+
+
+def cmd_delete(args):
+    client = _client_from_args(args)
+    ok = client.delete_function(args.name)
+    if ok:
+        print(f"✓ deleted: {args.name}")
+    else:
+        sys.exit(f"error: function not found: {args.name}")
+
+
+# ── Top-level parser ──────────────────────────────────────────────────────
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="olive", description="Olive Compute CLI")
+    p.add_argument("--api-key", help="Olive API key (default: $OLIVE_API_KEY)")
+    p.add_argument("--api-url", help="Olive API base URL (default: $OLIVE_API_URL or production)")
+
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    d = sub.add_parser("deploy", help="Deploy compute functions from a Python file")
+    d.add_argument("file", help="Path to script.py containing an App + @app.function decorators")
+    d.set_defaults(func=cmd_deploy)
+
+    l = sub.add_parser("list", help="List your deployed compute functions")
+    l.set_defaults(func=cmd_list)
+
+    c = sub.add_parser("call", help="Synchronously invoke a function")
+    c.add_argument("name", help="Function name (or function_id)")
+    c.add_argument("input", nargs="?", default="", help="JSON input value (optional)")
+    c.set_defaults(func=cmd_call)
+
+    s = sub.add_parser("spawn", help="Async invoke — returns job id immediately")
+    s.add_argument("name", help="Function name (or function_id)")
+    s.add_argument("input", nargs="?", default="", help="JSON input value (optional)")
+    s.set_defaults(func=cmd_spawn)
+
+    rm = sub.add_parser("delete", help="Delete a compute function")
+    rm.add_argument("name", help="Function name (or function_id)")
+    rm.set_defaults(func=cmd_delete)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = build_parser().parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()