olive-compute 0.1.1__tar.gz

olive_compute-0.1.1/.gitignore

@@ -0,0 +1,63 @@
+# Environment
+.env
+.env.local
+
+# Rust
+target/
+*.pdb
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+*.egg-info/
+
+# Node
+node_modules/
+dist/
+build/
+.next/
+
+# Tauri runtime assets are downloaded during app CI builds.
+app/src-tauri/resources/runtime/*
+!app/src-tauri/resources/runtime/README.md
+
+# Catalog staged into job-api build context (source of truth is /config/models.yaml)
+services/job-api/config/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+.DS_Store
+
+# Local data volumes
+postgres_data/
+redis_data/
+grafana_data/
+rabbitmq_data/
+minio_data/
+
+# Generated certs and keys
+*.pem
+*.key
+*.crt
+certs/
+!**/example*.pem
+
+# CDK
+cdk.out/
+infrastructure/node_modules/
+
+# Benchmark outputs
+*.benchmark.json
+reports/
+
+# Internal task orchestrator local state
+.task-orchestrator/
+
+# Local Claude Code project state
+.claude/

olive_compute-0.1.1/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: olive-compute
+Version: 0.1.1
+Summary: Python client for the Olive distributed AI compute platform
+Project-URL: Homepage, https://olivecompute.com
+Project-URL: Documentation, https://olivecompute.com/docs
+Project-URL: Repository, https://github.com/yotammos/olive
+License: MIT
+Keywords: ai,compute,distributed,embeddings,inference
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# Olive Python SDK
+
+Distributed AI compute — embeddings and inference — with one import.
+
+```bash
+pip install olive-compute
+```
+
+## Quickstart
+
+```python
+from olive import OliveClient
+
+client = OliveClient(api_key="olv_...")
+
+# Embed text — uses the default embeddings model
+vectors = client.embeddings(["hello world", "olive compute"])
+print(vectors[0][:4])  # [0.0521, -0.1234, ...]
+
+# Run inference — uses the default chat model
+reply = client.inference("What is a neural network?", max_tokens=128)
+print(reply)
+```
+
+## Choosing a model
+
+Olive supports a catalog of curated open-source models. Browse them at
+[olivecompute.com/models](https://olivecompute.com/models) or programmatically:
+
+```python
+# List all available chat models
+for m in client.list_models(modality="chat"):
+    print(m["id"], "—", m["pricing"]["input_per_1m_tokens_usd"], "/1M tokens")
+
+# Get one model's full record
+m = client.get_model("meta/llama-3.1-8b-instruct")
+print(m["description"])
+```
+
+Pass `model=` to any inference call to pin a specific model:
+
+```python
+reply = client.inference(
+    "Write a Python function to reverse a list.",
+    model="qwen/qwen-2.5-coder-7b",
+)
+
+vectors = client.embeddings(
+    ["semantic search query"],
+    model="baai/bge-large-en-v1.5",
+)
+```
+
+If `model=` is omitted, Olive picks the default (featured) model for the workload.
+
+## Authentication
+
+Get an API key from [provider.olivecompute.com](https://provider.olivecompute.com) → Settings → API Keys.
+
+```python
+# API key (recommended)
+client = OliveClient(api_key="olv_...")
+
+# Email + password (issues a short-lived token automatically)
+client = OliveClient(email="you@example.com", password="...")
+```
+
+## Compute tiers
+
+| Tier | CPU | RAM | Use case |
+|------|-----|-----|----------|
+| `"light"` | 1 core | 2 GB | Embeddings, small inputs |
+| `"medium"` | 2 cores | 4 GB | Standard inference (default) |
+| `"heavy"` | 4 cores | 8 GB | Long context, large batches |
+
+## Async jobs
+
+For long-running workloads, submit and poll separately:
+
+```python
+job = client.submit_job(
+    workload_type="inference",
+    input_data='{"prompt": "Write a haiku", "max_tokens": 64}',
+    model="meta/llama-3.1-8b-instruct",   # optional — default chat model otherwise
+    compute="medium",
+)
+print(job.id)       # e3b2a1c0-...
+print(job.status)   # "running"
+
+result = job.wait(timeout=120)
+print(result["output_data"])
+```
+
+## Error handling
+
+```python
+from olive import OliveClient, AuthError, JobError
+
+try:
+    client = OliveClient(api_key="bad_key")
+    vectors = client.embeddings(["test"])
+except AuthError:
+    print("Check your API key")
+except JobError as e:
+    print(f"Job failed: {e}")
+```
+
+## Context manager
+
+```python
+with OliveClient(api_key="olv_...") as client:
+    vectors = client.embeddings(["hello"])
+```

olive_compute-0.1.1/README.md

@@ -0,0 +1,113 @@
+# Olive Python SDK
+
+Distributed AI compute — embeddings and inference — with one import.
+
+```bash
+pip install olive-compute
+```
+
+## Quickstart
+
+```python
+from olive import OliveClient
+
+client = OliveClient(api_key="olv_...")
+
+# Embed text — uses the default embeddings model
+vectors = client.embeddings(["hello world", "olive compute"])
+print(vectors[0][:4])  # [0.0521, -0.1234, ...]
+
+# Run inference — uses the default chat model
+reply = client.inference("What is a neural network?", max_tokens=128)
+print(reply)
+```
+
+## Choosing a model
+
+Olive supports a catalog of curated open-source models. Browse them at
+[olivecompute.com/models](https://olivecompute.com/models) or programmatically:
+
+```python
+# List all available chat models
+for m in client.list_models(modality="chat"):
+    print(m["id"], "—", m["pricing"]["input_per_1m_tokens_usd"], "/1M tokens")
+
+# Get one model's full record
+m = client.get_model("meta/llama-3.1-8b-instruct")
+print(m["description"])
+```
+
+Pass `model=` to any inference call to pin a specific model:
+
+```python
+reply = client.inference(
+    "Write a Python function to reverse a list.",
+    model="qwen/qwen-2.5-coder-7b",
+)
+
+vectors = client.embeddings(
+    ["semantic search query"],
+    model="baai/bge-large-en-v1.5",
+)
+```
+
+If `model=` is omitted, Olive picks the default (featured) model for the workload.
+
+## Authentication
+
+Get an API key from [provider.olivecompute.com](https://provider.olivecompute.com) → Settings → API Keys.
+
+```python
+# API key (recommended)
+client = OliveClient(api_key="olv_...")
+
+# Email + password (issues a short-lived token automatically)
+client = OliveClient(email="you@example.com", password="...")
+```
+
+## Compute tiers
+
+| Tier | CPU | RAM | Use case |
+|------|-----|-----|----------|
+| `"light"` | 1 core | 2 GB | Embeddings, small inputs |
+| `"medium"` | 2 cores | 4 GB | Standard inference (default) |
+| `"heavy"` | 4 cores | 8 GB | Long context, large batches |
+
+## Async jobs
+
+For long-running workloads, submit and poll separately:
+
+```python
+job = client.submit_job(
+    workload_type="inference",
+    input_data='{"prompt": "Write a haiku", "max_tokens": 64}',
+    model="meta/llama-3.1-8b-instruct",   # optional — default chat model otherwise
+    compute="medium",
+)
+print(job.id)       # e3b2a1c0-...
+print(job.status)   # "running"
+
+result = job.wait(timeout=120)
+print(result["output_data"])
+```
+
+## Error handling
+
+```python
+from olive import OliveClient, AuthError, JobError
+
+try:
+    client = OliveClient(api_key="bad_key")
+    vectors = client.embeddings(["test"])
+except AuthError:
+    print("Check your API key")
+except JobError as e:
+    print(f"Job failed: {e}")
+```
+
+## Context manager
+
+```python
+with OliveClient(api_key="olv_...") as client:
+    vectors = client.embeddings(["hello"])
+```

olive_compute-0.1.1/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_compute-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()