urun-cli 0.6.3__tar.gz → 0.7.1__tar.gz

{urun_cli-0.6.3 → urun_cli-0.7.1}/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.7.1
+
+- `urun serve --warm N` — an idle replica floor on a serve deploy (the
+  catalog's `warm` marker for platform-operated shared endpoints; absent =
+  the unchanged scale-to-zero default). Pins `URUN_SERVE_WARM` into the
+  generated shim so the bundled app's `@app.function(warm=...)` reads it.
+- `urun serve --exo-class / --exo-image` — pin a deploy's provider on the EXO rail.
+- Deploy Python and Rust functions in one app release.
+- Compat: bundle the proxy with the queued session identity; stop reporting
+  an unconverged roll as ready and stop dropping the server's error message.
+
 ## 0.6.3
 
 - Bump the vendored `urun-openai` binary pin to `@urun-sh/openai@0.5.0` — the

{urun_cli-0.6.3 → urun_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.6.3
+Version: 0.7.1
 Summary: End-user CLI for deploying apps to urun
 Project-URL: Homepage, https://urun.sh
 Project-URL: Repository, https://github.com/urun-sh/urun-cli
@@ -18,11 +18,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
+Provides-Extra: rust
+Requires-Dist: tree-sitter-rust==0.24.0; extra == 'rust'
+Requires-Dist: tree-sitter==0.25.2; extra == 'rust'
 Description-Content-Type: text/markdown
 
 # urun CLI
 
-Deploy Python apps to urun from your terminal.
+Deploy Python and Rust (native SDK) apps to urun from your terminal.
 
 [![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
 [![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
@@ -35,6 +38,15 @@ uv tool install urun-cli
 pip install urun-cli
 ```
 
+For Rust (native SDK) deploys, install with the `[rust]` extra — see
+[Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
 The package installs the `urun` command:
 
 ```bash
@@ -154,6 +166,100 @@ Override the examples checkout with `--examples-root` or `URUN_EXAMPLES_ROOT`;
 override the session API with `--session-url` or `URUN_SESSION_BASE_URL`; pin
 the function with `--function` and the environment with `--environment`.
 
+## Deploy a Rust app (native SDK)
+
+Rust apps use the native SDK crate `urun` and are declared by an inline module
+owning `#[urun::app(name = "...")]` with nested `#[urun::function]` handlers.
+
+The executable calls `urun::main!(app)` from `fn main()`. Each handler crosses
+the `ctx.self_test(...)` barrier before accessing session state. The runnable
+`native-echo` example below includes the complete lifecycle.
+
+Install the CLI with the Rust parser extra (a plain install stays
+dependency-free; the extra pulls the pinned `tree-sitter`/`tree-sitter-rust`
+wheels used for static declaration extraction — no Rust toolchain needed):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
+Deploy by pointing at the project's `Cargo.toml` (a `src/main.rs` or the
+project directory also work):
+
+```bash
+urun deploy path/to/project/Cargo.toml
+```
+
+- **Vendor the SDK in-root.** The `urun` SDK crate is not published to
+  crates.io and the build environment has no private git credentials, so the
+  crate must ship inside your deploy root: reference it by a relative path
+  dependency (`urun = { path = "vendor/urun" }`) or as a member of the Cargo
+  workspace rooted there. Credential-free registry/git dependencies are fine.
+- **`Cargo.lock` is mandatory.** The builder builds with `--locked`; a missing
+  lock file fails the deploy.
+- The bundle is the full in-root Cargo workspace / path-dependency / resource
+  closure, minus `target/`, `.git`, and `.cargo/credentials{,.toml}`.
+
+A runnable starting point is the SDK checkout's `examples/native-echo` app,
+which vendors the SDK via a path dependency and deploys as-is:
+
+```bash
+git clone git@github.com:urun-sh/urun-rs.git
+urun deploy urun-rs/examples/native-echo
+```
+
+## Deploy a mixed Python + Rust app
+
+ONE app can hold functions implemented in BOTH languages: one identity, one
+release, the full function set replaced atomically on every deploy. Declare
+the sources explicitly in the project's `pyproject.toml` — nothing is scanned
+or inferred, so vendored SDK examples are never pulled into your app:
+
+```toml
+# pyproject.toml
+[tool.urun]
+entrypoints = ["app.py", "native/src/main.rs"]
+```
+
+Python functions register on one `App("mixed-app")`. Rust functions use
+`#[urun::function(...)]` inside `#[urun::app(name = "mixed-app")]`.
+The builder assembles both into one function registry: the language belongs
+to the function, not to a separate app. See the runnable
+[`examples/mixed-app`](https://github.com/urun-sh/urun-rs/tree/main/examples/mixed-app)
+for complete Python and Rust implementations, including self-tests and calls
+in both directions.
+
+Deploy the whole app with any of these — each resolves the ENTIRE declared
+app, so one component invocation never accidentally retires its sibling
+functions:
+
+```bash
+urun deploy .                # the config directory
+urun deploy pyproject.toml   # the declaration itself
+urun deploy app.py           # a declared component
+urun deploy native/src/main.rs
+```
+
+- **One identity across all sources.** Python helpers may import the same
+  `App` object; Rust declarations use the same app-name literal. A different
+  App object, mismatched name, or duplicate function name is a hard error.
+- **Declared paths stay in the config directory** (root-relative, no `..`
+  escapes, every declared file present). The bundle root may widen through
+  ordinary Cargo workspace resolution — e.g. a crate that is a member of a
+  wider workspace ships that whole workspace closure — and every entrypoint
+  and `manifest_path` rebases onto it.
+- **Python dependencies stay Python.** The manifest's `deps` block is
+  resolved from the Python source exactly like a pure Python deploy
+  (`Dependencies(python=...)`, `requirements.txt`, `python_version`); the
+  Rust sources' `apt`/`build_deps` function options fold into the same lists.
+- **Resources ride with their code** in both halves: the Python import/data
+  closure plus each Rust crate's full workspace/path closure and every
+  referenced `Cargo.lock`.
+
+A runnable starting point is the SDK checkout's `examples/mixed-app` app.
+
 ## Serve a model from the catalog
 
 `urun serve` deploys a model straight from the urun model catalog — no app code
@@ -449,6 +555,8 @@ would fire kubectl at a cluster you are not looking at.
 | Entrypoint | Included source |
 | --- | --- |
 | `urun deploy app.py` | `app.py` and local Python files it imports |
+| `urun deploy Cargo.toml` | The in-root Cargo workspace / path-dependency closure (see [Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk)). |
+| `urun deploy .` / `pyproject.toml` | The whole explicitly-declared `[tool.urun]` app — Python + Rust sources, both closures (see [Deploy a mixed Python + Rust app](#deploy-a-mixed-python--rust-app)). A declared component (`app.py`, `native/src/main.rs`) resolves the same entire app. |
 
 Dependencies are declared in your urun app code. Project-level files such as
 `pyproject.toml` and `requirements.txt` are not uploaded as dependency

{urun_cli-0.6.3 → urun_cli-0.7.1}/README.md

@@ -1,6 +1,6 @@
 # urun CLI
 
-Deploy Python apps to urun from your terminal.
+Deploy Python and Rust (native SDK) apps to urun from your terminal.
 
 [![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
 [![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
@@ -13,6 +13,15 @@ uv tool install urun-cli
 pip install urun-cli
 ```
 
+For Rust (native SDK) deploys, install with the `[rust]` extra — see
+[Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
 The package installs the `urun` command:
 
 ```bash
@@ -132,6 +141,100 @@ Override the examples checkout with `--examples-root` or `URUN_EXAMPLES_ROOT`;
 override the session API with `--session-url` or `URUN_SESSION_BASE_URL`; pin
 the function with `--function` and the environment with `--environment`.
 
+## Deploy a Rust app (native SDK)
+
+Rust apps use the native SDK crate `urun` and are declared by an inline module
+owning `#[urun::app(name = "...")]` with nested `#[urun::function]` handlers.
+
+The executable calls `urun::main!(app)` from `fn main()`. Each handler crosses
+the `ctx.self_test(...)` barrier before accessing session state. The runnable
+`native-echo` example below includes the complete lifecycle.
+
+Install the CLI with the Rust parser extra (a plain install stays
+dependency-free; the extra pulls the pinned `tree-sitter`/`tree-sitter-rust`
+wheels used for static declaration extraction — no Rust toolchain needed):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
+Deploy by pointing at the project's `Cargo.toml` (a `src/main.rs` or the
+project directory also work):
+
+```bash
+urun deploy path/to/project/Cargo.toml
+```
+
+- **Vendor the SDK in-root.** The `urun` SDK crate is not published to
+  crates.io and the build environment has no private git credentials, so the
+  crate must ship inside your deploy root: reference it by a relative path
+  dependency (`urun = { path = "vendor/urun" }`) or as a member of the Cargo
+  workspace rooted there. Credential-free registry/git dependencies are fine.
+- **`Cargo.lock` is mandatory.** The builder builds with `--locked`; a missing
+  lock file fails the deploy.
+- The bundle is the full in-root Cargo workspace / path-dependency / resource
+  closure, minus `target/`, `.git`, and `.cargo/credentials{,.toml}`.
+
+A runnable starting point is the SDK checkout's `examples/native-echo` app,
+which vendors the SDK via a path dependency and deploys as-is:
+
+```bash
+git clone git@github.com:urun-sh/urun-rs.git
+urun deploy urun-rs/examples/native-echo
+```
+
+## Deploy a mixed Python + Rust app
+
+ONE app can hold functions implemented in BOTH languages: one identity, one
+release, the full function set replaced atomically on every deploy. Declare
+the sources explicitly in the project's `pyproject.toml` — nothing is scanned
+or inferred, so vendored SDK examples are never pulled into your app:
+
+```toml
+# pyproject.toml
+[tool.urun]
+entrypoints = ["app.py", "native/src/main.rs"]
+```
+
+Python functions register on one `App("mixed-app")`. Rust functions use
+`#[urun::function(...)]` inside `#[urun::app(name = "mixed-app")]`.
+The builder assembles both into one function registry: the language belongs
+to the function, not to a separate app. See the runnable
+[`examples/mixed-app`](https://github.com/urun-sh/urun-rs/tree/main/examples/mixed-app)
+for complete Python and Rust implementations, including self-tests and calls
+in both directions.
+
+Deploy the whole app with any of these — each resolves the ENTIRE declared
+app, so one component invocation never accidentally retires its sibling
+functions:
+
+```bash
+urun deploy .                # the config directory
+urun deploy pyproject.toml   # the declaration itself
+urun deploy app.py           # a declared component
+urun deploy native/src/main.rs
+```
+
+- **One identity across all sources.** Python helpers may import the same
+  `App` object; Rust declarations use the same app-name literal. A different
+  App object, mismatched name, or duplicate function name is a hard error.
+- **Declared paths stay in the config directory** (root-relative, no `..`
+  escapes, every declared file present). The bundle root may widen through
+  ordinary Cargo workspace resolution — e.g. a crate that is a member of a
+  wider workspace ships that whole workspace closure — and every entrypoint
+  and `manifest_path` rebases onto it.
+- **Python dependencies stay Python.** The manifest's `deps` block is
+  resolved from the Python source exactly like a pure Python deploy
+  (`Dependencies(python=...)`, `requirements.txt`, `python_version`); the
+  Rust sources' `apt`/`build_deps` function options fold into the same lists.
+- **Resources ride with their code** in both halves: the Python import/data
+  closure plus each Rust crate's full workspace/path closure and every
+  referenced `Cargo.lock`.
+
+A runnable starting point is the SDK checkout's `examples/mixed-app` app.
+
 ## Serve a model from the catalog
 
 `urun serve` deploys a model straight from the urun model catalog — no app code
@@ -427,6 +530,8 @@ would fire kubectl at a cluster you are not looking at.
 | Entrypoint | Included source |
 | --- | --- |
 | `urun deploy app.py` | `app.py` and local Python files it imports |
+| `urun deploy Cargo.toml` | The in-root Cargo workspace / path-dependency closure (see [Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk)). |
+| `urun deploy .` / `pyproject.toml` | The whole explicitly-declared `[tool.urun]` app — Python + Rust sources, both closures (see [Deploy a mixed Python + Rust app](#deploy-a-mixed-python--rust-app)). A declared component (`app.py`, `native/src/main.rs`) resolves the same entire app. |
 
 Dependencies are declared in your urun app code. Project-level files such as
 `pyproject.toml` and `requirements.txt` are not uploaded as dependency

{urun_cli-0.6.3 → urun_cli-0.7.1}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-# Cut the paused-function recovery fixes merged after v0.6.0.
+# Cut the native Rust SDK deploy path (feature minor on 0.6.x).
 #
 # WHY THIS IS EDITED BY HAND. [tool.semantic_release] below is fully
 # configured -- conventional commit parser, version_toml pointing here, tag
@@ -19,8 +19,8 @@ name = "urun-cli"
 # READS this value and skips publishing when the matching tag already exists,
 # so every merge remains on the already-published version until this value is
 # advanced. Wiring semantic-release into CI remains separate work; this patch
-# bump is the minimal release unblock for the three post-v0.6.0 fixes.
-version = "0.6.3"
+# bump is the minimal release unblock (post-v0.6.3 fixes + the Rust feature minor).
+version = "0.7.1"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -49,6 +49,16 @@ Issues = "https://github.com/urun-sh/urun-cli/issues"
 urun = "urun.cli:main"
 urun-cli = "urun.cli:main"
 
+[project.optional-dependencies]
+# Rust app discovery (urun/rust.py) parses with the pinned native
+# tree-sitter wheels; lazy-imported only for Rust deploys, so the ordinary
+# wheel stays dependency-free. Pin advance = contract native_crate_baselines
+# (tree-sitter 0.25.2 / tree-sitter-rust 0.24.0).
+rust = [
+  "tree-sitter==0.25.2",
+  "tree-sitter-rust==0.24.0",
+]
+
 [dependency-groups]
 dev = [
   # The build backend, present in the dev env so tests can import hatch_build.py

{urun_cli-0.6.3 → urun_cli-0.7.1}/src/urun/catalog.py

@@ -104,6 +104,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
     "echo-speak": [],
     "echo-video": [],
     "echo-video-diffusion": [],
+    "echo-t2av": [],
     "vllm": [
         "vllm==0.24.0",
         "arctic-inference==0.1.1",
@@ -386,6 +387,65 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "huggingface_hub[hf_transfer]>=0.30.0,<1.0.0",
         "sentencepiece",
     ],
+    "t2av": [
+        "remote_pdb>=1.4",
+        "scipy>=1.14.1",
+        "six>=1.16.0",
+        "h5py>=3.12.1",
+        "requests>=2.32.2",
+        "numpy>=1.26,<2",
+        "transformers>=5.0.0",
+        "tokenizers>=0.20.1,<0.23",
+        "sentencepiece>=0.2.0",
+        "timm>=1.0.11",
+        "peft>=0.15.0",
+        "diffusers>=0.38.0",
+        "torch==2.12.0",
+        "torchvision",
+        "torchaudio",
+        "accelerate==1.0.1",
+        "opencv-python>=4.10,<5",
+        "pillow>=10.3.0",
+        "imageio>=2.36.0",
+        "imageio-ffmpeg>=0.5.1",
+        "einops",
+        "loguru",
+        "tqdm",
+        "PyYAML>=6.0.1",
+        "protobuf>=5.28.3",
+        "aiohttp",
+        "huggingface_hub",
+        "cloudpickle",
+        "omegaconf",
+        "gpustat",
+        "ninja",
+        "fastvideo-kernel==0.3.2; sys_platform == 'linux'",
+    ],
+    "ltx-realtime": [
+        "torch~=2.7",
+        "torchaudio",
+        "einops",
+        "numpy",
+        "av",
+        "transformers>=5.8.0,<5.15",
+        "safetensors",
+        "accelerate",
+        "scipy>=1.14",
+        "tqdm",
+        "pillow>=10.0.0",
+        "openimageio",
+        "cloudpickle>=3.1",
+        "huggingface_hub[hf_transfer]>=0.30.0,<1.0.0",
+        "sentencepiece",
+        "nvidia-cuda-nvcc==13.0.88",
+        "nvidia-cuda-crt==13.0.88",
+        "nvidia-cuda-cccl==13.0.85",
+        "nvidia-nvvm==13.0.88",
+        "nvidia-cuda-runtime==13.0.96",
+        "ninja",
+        "pip",
+        "nvidia-cutlass-dsl>=4.6.0.dev0,<5",
+    ],
     "media-transform": [
         "torch==2.6.0",
         "transformers==4.51.3",