Add Docker server deployment

.dockerignore

@@ -0,0 +1,40 @@
+# Version control
+.git/
+.gitignore
+
+# Python caches
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE / editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Local test outputs
+output*.mp4
+*.mp4
+
+# Docs (not needed in image)
+README.md
+LICENSE*
+*.pdf
+*.md
+
+# Example files
+examples/
+
+# OS artifacts
+Thumbs.db
+.DS_Store

.gitignore

@@ -0,0 +1,29 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE / editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Generated videos
+*.mp4
+
+# Local outputs
+outputs/
+
+# OS artifacts
+Thumbs.db
+.DS_Store

Dockerfile

@@ -0,0 +1,50 @@
+FROM nvidia/cuda:12.8.0-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV MODEL_DIR=/app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        python3.10 python3.10-dev python3-pip \
+        ffmpeg gcc libc6-dev \
+    && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.10 1 \
+    && update-alternatives --install /usr/bin/python python /usr/bin/python3.10 1 \
+    && python -m pip install --upgrade pip setuptools wheel \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Model weights
+COPY high_noise_model_bnb_nf4/ /app/high_noise_model_bnb_nf4/
+COPY low_noise_model_bnb_nf4/ /app/low_noise_model_bnb_nf4/
+COPY models_t5_umt5-xxl-enc-bf16.pth /app/models_t5_umt5-xxl-enc-bf16.pth
+COPY Wan2.1_VAE.pth /app/Wan2.1_VAE.pth
+COPY tokenizer/ /app/tokenizer/
+
+# Python packages
+COPY requirements.txt /app/requirements.txt
+
+# Pin PyTorch to 2.7.1+cu128 (must match the flash-attn prebuilt wheel)
+RUN pip install --no-cache-dir \
+        torch==2.7.1+cu128 torchvision torchaudio \
+        --index-url https://download.pytorch.org/whl/cu128
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Prebuilt flash-attn wheel: Python 3.10 / PyTorch 2.7 / CUDA 12 / cxx11abiTRUE
+RUN pip install --no-cache-dir \
+    https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.4.post1/flash_attn-2.7.4.post1+cu12torch2.7cxx11abiTRUE-cp310-cp310-linux_x86_64.whl
+
+# Application source code
+COPY wan/ /app/wan/
+COPY generate_prequant.py /app/generate_prequant.py
+COPY load_prequant.py /app/load_prequant.py
+COPY handler.py /app/handler.py
+
+CMD ["gunicorn", "handler:app", \
+    "--bind", "0.0.0.0:8080", \
+    "--workers", "1", \
+    "--threads", "4", \
+    "--timeout", "0", \
+    "--access-logfile", "-", \
+    "--error-logfile", "-"]

README.md

@@ -11,90 +11,161 @@ tags:
 pipeline_tag: image-to-video
 ---
 
-# LingBot-World NF4 Quantized
+# LingBot-World Base Cam NF4 Quantized Server
 
-Pre-quantized NF4 weights for LingBot-World video generation model. This is a complete, self-contained package - no additional downloads required.
+Docker-ready inference server for [LingBot-World video generation model](https://github.com/robbyant/lingbot-world) with [pre-quantized NF4 weights](https://huggingface.co/cahlen/lingbot-world-base-cam-nf4).
 
 ## Features
 
 - **4-bit NF4 quantization** via bitsandbytes - fits in 32GB VRAM
 - **Pre-quantized weights** - no runtime quantization overhead
-- **Complete package** - includes T5 encoder, VAE, and diffusion models
+- **Docker image with HTTP API** - deploy on any machine with an NVIDIA GPU
+- **Optional cloud upload** - upload finished videos to Cloudflare R2, or download directly via HTTP
+
+## Model Contents
+
+| File | Size | Description |
+|------|------|-------------|
+| `high_noise_model_bnb_nf4/model.safetensors` | ~9.6 GB | NF4 quantized diffusion model (high noise) |
+| `low_noise_model_bnb_nf4/model.safetensors` | ~9.6 GB | NF4 quantized diffusion model (low noise) |
+| `models_t5_umt5-xxl-enc-bf16.pth` | ~10.6 GB | T5-XXL text encoder (bfloat16) |
+| `Wan2.1_VAE.pth` | ~485 MB | VAE encoder/decoder |
+
+**Total: ~30 GB** (vs ~85 GB for full-precision models)
+
+## Requirements
+
+- Python 3.10+
+- CUDA 11.8+ (tested with CUDA 12.x)
+- ~32GB VRAM (RTX 5090, A100, etc)
+- [A lot of RAM](https://huggingface.co/cahlen/lingbot-world-base-cam-nf4/discussions/2) (>64GB)
 
 ## Quick Start
 
-```bash
-# Clone the repo
-git clone https://huggingface.co/cahlen/lingbot-world-base-cam-nf4
-cd lingbot-world-base-cam-nf4
+### Without Docker
 
-# Install dependencies
-pip install -r requirements.txt
+To run this package without Docker, see the Lingbot-World pre-quantized page [here](https://huggingface.co/cahlen/lingbot-world-base-cam-nf4).
 
-# Generate a video
-python generate_prequant.py \
-    --image your_image.jpg \
-    --prompt "A cinematic video of the scene" \
-    --frame_num 81 \
-    --output output.mp4
+### Runpod Template
+
+https://console.runpod.io/deploy?template=j6rpw8zhj2&ref=szjabwfp
+
+## Docker Deployment
+
+The included Dockerfile builds a self-contained image (~35 GB) with all weights baked in. Once built, you can run it on any machine with an NVIDIA GPU.
+
+### Build
+
+```bash
+docker build --platform linux/amd64 -t lingbot-nf4 .
 ```
 
-## Model Contents
+### Run
 
-| File | Size | Description |
-|------|------|-------------|
-| `high_noise_model_bnb_nf4/model.safetensors` | ~9.6GB | NF4 quantized diffusion model (high noise) |
-| `low_noise_model_bnb_nf4/model.safetensors` | ~9.6GB | NF4 quantized diffusion model (low noise) |
-| `models_t5_umt5-xxl-enc-bf16.pth` | ~10.6GB | T5-XXL text encoder |
-| `Wan2.1_VAE.pth` | ~485MB | VAE encoder/decoder |
+```bash
+# Basic — videos saved to /app/outputs/ inside the container
+docker run --gpus all -p 8080:8080 lingbot-nf4
+
+# With a local directory mounted for output
+docker run --gpus all -p 8080:8080 -v ./outputs:/app/outputs lingbot-nf4
+
+# With Cloudflare R2 upload (optional)
+docker run --gpus all -p 8080:8080 \
+    -e R2_ACCOUNT_ID=your_account_id \
+    -e R2_ACCESS_KEY=your_access_key \
+    -e R2_SECRET_KEY=your_secret_key \
+    -e R2_BUCKET=your_bucket_name \
+    lingbot-nf4
+```
 
-**Total size: ~30GB** (vs ~85GB for full precision models)
+The server starts on port 8080 once the model is loaded.
 
-## Usage
+### API
 
-### Basic Generation
+The server exposes an async job queue to handle long-running generation.
+
+#### Using the client script
 
 ```bash
-python generate_prequant.py \
-    --image input.jpg \
-    --prompt "Your prompt here" \
+python caller.py \
+    --url http://localhost:8080 \
+    --image photo.jpg \
+    --prompt "A cinematic shot of the scene" \
     --frame_num 81 \
-    --size "480*832" \
     --output output.mp4
 ```
 
-### Parameters
+#### Without the client script
+
+```
+POST /generate
+Content-Type: application/json
+
+{
+    "image": "<base64-encoded JPEG/PNG>",
+    "prompt": "A cinematic video of the scene",
+    "frame_num": 81,
+    "size": "480*832",
+    "seed": -1,
+    "guide_scale": 5.0,
+    "sampling_steps": 40,
+    "action_poses": "<base64-encoded poses.npy (optional)>",
+    "action_intrinsics": "<base64-encoded intrinsics.npy (optional)>"
+}
+```
+
+Returns immediately with HTTP 202:
 
-| Parameter | Default | Description |
-|-----------|---------|-------------|
-| `--image` | required | Input image path |
-| `--prompt` | required | Text prompt describing the video |
-| `--frame_num` | 81 | Number of frames (81 = ~5 seconds at 16fps) |
-| `--size` | "480*832" | Output resolution (height*width) |
-| `--sampling_steps` | 40 | Diffusion sampling steps |
-| `--guide_scale` | 5.0 | Classifier-free guidance scale |
-| `--seed` | -1 | Random seed (-1 for random) |
-| `--output` | "output.mp4" | Output video path |
+```json
+{"id": "job-uuid", "status": "IN_PROGRESS"}
+```
 
-### With Camera Control
+#### Poll for result
 
-```bash
-python generate_prequant.py \
-    --image input.jpg \
-    --prompt "Your prompt" \
-    --action_path /path/to/camera_poses/ \
-    --frame_num 81
+```
+GET /status/<job-id>
 ```
 
-Camera pose directory should contain:
-- `poses.npy`: Shape `[num_frames, 4, 4]` - camera transformation matrices
-- `intrinsics.npy`: Shape `[num_frames, 4]` - `[fx, fy, cx, cy]`
+Returns:
 
-## Requirements
+```json
+{
+    "id": "job-uuid",
+    "status": "COMPLETED",
+    "output": {
+        "video_url": "https://...",
+        "seed": 42,
+        "duration_sec": 185.3,
+        "frame_num": 81,
+        "size": "480*832"
+    }
+}
+```
 
-- Python 3.10+
-- CUDA 11.8+ (tested with CUDA 12.x)
-- ~32GB VRAM (RTX 4090, RTX 5090, A100, etc.)
+If R2 is not configured, `video_path` is returned instead of `video_url`. The client script (`caller.py`) will automatically download the video via the `/download` endpoint in this case.
+
+#### Download video
+
+When R2 is not configured, you can download completed videos directly:
+
+```
+GET /download/<job-id>
+```
+
+Returns the MP4 file as a download.
+
+#### Health check
+
+```
+GET /health
+```
+
+### Cloud Deployment (eg RunPod)
+
+1. Push the image to a container registry (Docker Hub, etc)
+2. Create a GPU pod/instance with the image
+3. Expose port 8080
+4. Use `caller.py` with the pod's public URL
 
 ## Quantization Details
 
@@ -114,13 +185,3 @@ This achieves ~3.9x compression while maintaining generation quality.
 ## License
 
 This model is based on [LingBot-World](https://github.com/robbyant/lingbot-world) and follows its license terms.
-
-## Citation
-
-```bibtex
-@misc{lingbot-world-nf4,
-  title={LingBot-World NF4 Quantized},
-  year={2025},
-  url={https://huggingface.co/cahlen/lingbot-world-base-cam-nf4}
-}
-```

caller.py

@@ -0,0 +1,151 @@
+"""
+Submit a generation job to a LingBot-World server.
+
+Sends a POST to /generate, then polls /status/<id> until the video is ready.
+
+Usage:
+    python caller.py --url http://localhost:8080 \\
+        --image examples/00/image.jpg \\
+        --prompt "A woman walks forward slowly" \\
+        --action_dir examples/00/
+
+    # Through a RunPod proxy:
+    python caller.py --url https://YOUR-POD-8080.proxy.runpod.net \\
+        --image photo.jpg --prompt "..."
+"""
+
+import argparse
+import base64
+import json
+import sys
+import time
+from pathlib import Path
+
+import requests
+
+
+def encode_file_b64(path: str) -> str:
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+
+def build_payload(args) -> dict:
+    payload = {
+        "image": encode_file_b64(args.image),
+        "prompt": args.prompt,
+        "frame_num": args.frame_num,
+        "size": args.size,
+        "seed": args.seed,
+        "guide_scale": args.guide_scale,
+        "sampling_steps": args.sampling_steps,
+    }
+
+    if args.action_dir:
+        action_dir = Path(args.action_dir)
+        poses_path = action_dir / "poses.npy"
+        intrinsics_path = action_dir / "intrinsics.npy"
+
+        if not poses_path.exists() or not intrinsics_path.exists():
+            print(f"ERROR: Expected poses.npy and intrinsics.npy in {action_dir}")
+            sys.exit(1)
+
+        payload["action_poses"] = encode_file_b64(str(poses_path))
+        payload["action_intrinsics"] = encode_file_b64(str(intrinsics_path))
+        print(f"Camera actions loaded from {action_dir}")
+
+    return payload
+
+
+def submit(url: str, payload: dict, poll_interval: int = 10, output_path: str | None = None):
+    """POST the job, then poll until completion."""
+    submit_url = f"{url.rstrip('/')}/generate"
+
+    print(f"Submitting to {submit_url} ...")
+    resp = requests.post(submit_url, json=payload, timeout=30)
+
+    if resp.status_code not in (200, 202):
+        print(f"ERROR {resp.status_code}: {resp.text[:500]}")
+        sys.exit(1)
+
+    result = resp.json()
+    if "error" in result:
+        print(f"ERROR: {result['error']}")
+        sys.exit(1)
+
+    job_id = result.get("id")
+    print(f"Job accepted — ID: {job_id}")
+    print("Polling for completion ...")
+
+    status_url = f"{url.rstrip('/')}/status/{job_id}"
+    while True:
+        time.sleep(poll_interval)
+        try:
+            resp = requests.get(status_url, timeout=15)
+            data = resp.json()
+        except Exception as e:
+            print(f"  Poll error (will retry): {e}")
+            continue
+
+        status = data.get("status")
+        print(f"  Status: {status}")
+
+        if status == "COMPLETED":
+            output = data.get("output", {})
+            print(f"\nDone!")
+            if output.get("video_url"):
+                print(f"  Video URL : {output['video_url']}")
+            if output.get("video_path"):
+                print(f"  Video path: {output['video_path']}")
+                # Auto-download the video from the server
+                download_url = f"{url.rstrip('/')}/download/{job_id}"
+                dest = output_path or f"{job_id}.mp4"
+                print(f"  Downloading to {dest} ...")
+                try:
+                    dl = requests.get(download_url, stream=True, timeout=300)
+                    dl.raise_for_status()
+                    with open(dest, "wb") as f:
+                        for chunk in dl.iter_content(chunk_size=1024 * 1024):
+                            f.write(chunk)
+                    print(f"  Saved to {dest}")
+                except Exception as e:
+                    print(f"  Download failed: {e}")
+            print(f"  Seed      : {output.get('seed')}")
+            print(f"  Duration  : {output.get('duration_sec', 0):.1f}s")
+            return
+        elif status == "FAILED":
+            output = data.get("output", {})
+            print(f"\nJob failed: {output.get('error', 'Unknown error')}")
+            sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Submit a video generation job to a LingBot-World server"
+    )
+    parser.add_argument("--url", required=True,
+                        help="Server URL (e.g. http://localhost:8080 or https://xyz-8080.proxy.runpod.net)")
+    parser.add_argument("--image", required=True, help="Path to input image (JPEG/PNG)")
+    parser.add_argument("--prompt", required=True, help="Text prompt")
+    parser.add_argument("--action_dir", default=None,
+                        help="Directory containing poses.npy and intrinsics.npy")
+    parser.add_argument("--frame_num", type=int, default=81, help="Number of frames (default: 81)")
+    parser.add_argument("--size", default="480*832", help="Output size: 480*832 or 720*1280")
+    parser.add_argument("--seed", type=int, default=-1, help="RNG seed (-1 for random)")
+    parser.add_argument("--guide_scale", type=float, default=5.0)
+    parser.add_argument("--sampling_steps", type=int, default=40)
+    parser.add_argument("--poll_interval", type=int, default=10,
+                        help="Seconds between status polls (default: 10)")
+    parser.add_argument("--output", default=None,
+                        help="Local path to save downloaded video (default: <job_id>.mp4)")
+
+    args = parser.parse_args()
+
+    print(f"  Prompt: {args.prompt[:80]}...")
+    print(f"  Frames: {args.frame_num}, Size: {args.size}, Steps: {args.sampling_steps}")
+
+    payload = build_payload(args)
+    submit(args.url, payload, poll_interval=args.poll_interval, output_path=args.output)
+
+
+if __name__ == "__main__":
+    main()

generate_prequant.py

@@ -111,6 +111,7 @@ class WanI2V_PreQuant:
                 )
 
         # Load to CPU first, we'll swap to GPU as needed
+        logger.info("Loading models to CPU (swapping to GPU as needed during sampling)...")
         self.low_noise_model = load_quantized_model(low_noise_dir, device="cpu")
         self.high_noise_model = load_quantized_model(high_noise_dir, device="cpu")
 

handler.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+HTTP server for LingBot-World Base Cam NF4.
+
+Runs a Flask server with an async job queue.
+
+Endpoints:
+    POST /generate        Submit a generation job (returns job ID immediately)
+    GET  /status/<id>     Poll for job result
+    GET /download/<id>    Download completed video (if available on server)
+    GET  /health          Liveness check
+
+Video output:
+    If R2_ACCOUNT_ID / R2_ACCESS_KEY / R2_SECRET_KEY / R2_BUCKET env vars are set, the
+    finished video is uploaded to Cloudflare R2 and a presigned URL is returned.
+    Otherwise the video is saved to OUTPUT_DIR (default /app/outputs/) and the
+    response includes a local file path.
+
+Environment variables:
+    MODEL_DIR       Path to model weights       (default: /app)
+    OUTPUT_DIR      Local output directory       (default: /app/outputs)
+    PORT            HTTP listen port             (default: 8080)
+    R2_ACCOUNT_ID   Cloudflare account ID        (optional)
+    R2_ACCESS_KEY   R2 API access key            (optional)
+    R2_SECRET_KEY   R2 API secret key            (optional)
+    R2_BUCKET       R2 bucket name               (default: lingbot-outputs)
+    URL_EXPIRY      Presigned URL lifetime secs  (default: 86400)
+"""
+
+import base64
+import io
+import logging
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import time
+import uuid
+
+import numpy as np
+import torch
+from flask import Flask, jsonify, request, send_file
+from PIL import Image
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_DIR = os.environ.get("MODEL_DIR", "/app")
+OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/app/outputs")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+R2_CONFIGURED = all(
+    os.environ.get(k) for k in ("R2_ACCOUNT_ID", "R2_ACCESS_KEY", "R2_SECRET_KEY")
+)
+
+
+sys.path.insert(0, MODEL_DIR)
+from generate_prequant import WanI2V_PreQuant, save_video
+
+logger.info("Initializing WanI2V_PreQuant pipeline ...")
+_t0 = time.time()
+pipeline = WanI2V_PreQuant(checkpoint_dir=MODEL_DIR, device_id=0, t5_cpu=True)
+logger.info(f"Pipeline ready in {time.time() - _t0:.1f}s")
+
+
+def _get_r2_client():
+    import boto3
+    from botocore.config import Config as BotoConfig
+
+    return boto3.client(
+        "s3",
+        endpoint_url=f"https://{os.environ['R2_ACCOUNT_ID']}.r2.cloudflarestorage.com",
+        aws_access_key_id=os.environ["R2_ACCESS_KEY"],
+        aws_secret_access_key=os.environ["R2_SECRET_KEY"],
+        config=BotoConfig(signature_version="s3v4"),
+        region_name="auto",
+    )
+
+
+def _upload_to_r2(local_path: str, object_key: str) -> str:
+    """Upload *local_path* to R2 and return a presigned download URL."""
+    bucket = os.environ.get("R2_BUCKET", "lingbot-outputs")
+    expiry = int(os.environ.get("URL_EXPIRY", 86400))
+    client = _get_r2_client()
+    client.upload_file(local_path, bucket, object_key, ExtraArgs={"ContentType": "video/mp4"})
+    logger.info(f"Uploaded {object_key} -> R2 bucket '{bucket}'")
+    return client.generate_presigned_url(
+        "get_object", Params={"Bucket": bucket, "Key": object_key}, ExpiresIn=expiry,
+    )
+
+
+VALID_SIZES = {"480*832", "720*1280"}
+
+def _validate(inp: dict) -> str | None:
+    if not inp.get("image"):
+        return "Missing required field: 'image' (base64-encoded JPEG/PNG)"
+    if not inp.get("prompt"):
+        return "Missing required field: 'prompt'"
+    size = inp.get("size", "480*832")
+    if size not in VALID_SIZES:
+        return f"Invalid size '{size}'. Must be one of {VALID_SIZES}"
+    frame_num = inp.get("frame_num", 81)
+    if not isinstance(frame_num, int) or frame_num < 5:
+        return f"frame_num must be an integer >= 5, got {frame_num}"
+    return None
+
+
+def generate_video(job_input: dict, job_id: str | None = None) -> dict:
+    """
+    Run the diffusion pipeline and deliver the result.
+
+    Returns a dict with ``video_url`` (R2) or ``video_path`` (local) on
+    success, or ``error`` on failure.
+    """
+    if job_id is None:
+        job_id = str(uuid.uuid4())
+
+    error = _validate(job_input)
+    if error:
+        return {"error": error}
+
+    # Decode image
+    try:
+        image_bytes = base64.b64decode(job_input["image"])
+        input_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    except Exception as exc:
+        return {"error": f"Failed to decode image: {exc}"}
+
+    # Parameters
+    prompt = job_input["prompt"]
+    frame_num = job_input.get("frame_num", 81)
+    size = job_input.get("size", "480*832")
+    seed = job_input.get("seed", -1)
+    guide_scale = job_input.get("guide_scale", 5.0)
+    sampling_steps = job_input.get("sampling_steps", 40)
+    h, w = map(int, size.split("*"))
+
+    # Optional camera poses
+    action_path = None
+    tmp_action_dir = None
+    if job_input.get("action_poses") and job_input.get("action_intrinsics"):
+        try:
+            tmp_action_dir = tempfile.mkdtemp(prefix="lingbot_actions_")
+            for name, key in [("poses.npy", "action_poses"),
+                              ("intrinsics.npy", "action_intrinsics")]:
+                with open(os.path.join(tmp_action_dir, name), "wb") as f:
+                    f.write(base64.b64decode(job_input[key]))
+            action_path = tmp_action_dir
+        except Exception as exc:
+            return {"error": f"Failed to decode camera actions: {exc}"}
+
+    # Run pipeline
+    logger.info(
+        f"Job {job_id}: prompt='{prompt[:80]}...' frames={frame_num} "
+        f"size={size} seed={seed} steps={sampling_steps}"
+    )
+    t0 = time.time()
+    try:
+        video = pipeline.generate(
+            input_prompt=prompt,
+            img=input_image,
+            action_path=action_path,
+            max_area=h * w,
+            frame_num=frame_num,
+            sampling_steps=sampling_steps,
+            guide_scale=guide_scale,
+            seed=seed,
+        )
+    except torch.cuda.OutOfMemoryError:
+        return {"error": "CUDA out of memory. Try fewer frames or 480*832."}
+    except Exception as exc:
+        return {"error": f"Generation failed: {exc}"}
+    finally:
+        if tmp_action_dir:
+            shutil.rmtree(tmp_action_dir, ignore_errors=True)
+
+    gen_secs = time.time() - t0
+    logger.info(f"Job {job_id}: done in {gen_secs:.1f}s")
+
+    # Save video
+    output_path = os.path.join(OUTPUT_DIR, f"{job_id}.mp4")
+    try:
+        save_video(video, output_path, fps=16)
+    except Exception as exc:
+        return {"error": f"Failed to save video: {exc}"}
+
+    result = {
+        "seed": seed,
+        "duration_sec": round(gen_secs, 1),
+        "frame_num": frame_num,
+        "size": size,
+    }
+
+    # Upload to R2 (if configured) or keep local
+    if R2_CONFIGURED:
+        try:
+            object_key = f"outputs/{job_id}.mp4"
+            result["video_url"] = _upload_to_r2(output_path, object_key)
+            os.remove(output_path)
+        except Exception as exc:
+            logger.warning(f"Job {job_id}: R2 upload failed ({exc}), keeping local file")
+            result["video_path"] = output_path
+    else:
+        result["video_path"] = output_path
+
+    return result
+
+
+app = Flask(__name__)
+
+_jobs: dict[str, dict] = {}
+_jobs_lock = threading.Lock()
+
+
+def _run_job(job_id: str, job_input: dict):
+    """Background thread target."""
+    try:
+        result = generate_video(job_input, job_id)
+    except Exception as exc:
+        result = {"error": f"Unexpected failure: {exc}"}
+    with _jobs_lock:
+        _jobs[job_id]["status"] = "FAILED" if "error" in result else "COMPLETED"
+        _jobs[job_id]["result"] = result
+
+
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"status": "healthy", "gpu": torch.cuda.get_device_name(0)})
+
+
+@app.route("/generate", methods=["POST"])
+def generate():
+    """Accept a job and return immediately with a job ID (HTTP 202)."""
+    body = request.get_json(silent=True)
+    if body is None:
+        return jsonify({"error": "Request body must be JSON"}), 400
+    job_input = body.get("input", body)
+
+    error = _validate(job_input)
+    if error:
+        return jsonify({"error": error}), 400
+
+    job_id = str(uuid.uuid4())
+    with _jobs_lock:
+        _jobs[job_id] = {"status": "IN_PROGRESS", "result": None, "submitted_at": time.time()}
+
+    logger.info(f"Job {job_id}: accepted")
+    threading.Thread(target=_run_job, args=(job_id, job_input), daemon=True).start()
+    return jsonify({"id": job_id, "status": "IN_PROGRESS"}), 202
+
+
+@app.route("/status/<job_id>", methods=["GET"])
+def status(job_id):
+    """Poll for job result."""
+    with _jobs_lock:
+        job = _jobs.get(job_id)
+    if job is None:
+        return jsonify({"error": f"Job {job_id} not found"}), 404
+    resp = {"id": job_id, "status": job["status"]}
+    if job["result"] is not None:
+        resp["output"] = job["result"]
+    return jsonify(resp)
+
+
+@app.route("/download/<job_id>", methods=["GET"])
+def download(job_id):
+    """Download a completed video by job ID."""
+    video_path = os.path.join(OUTPUT_DIR, f"{job_id}.mp4")
+    if not os.path.isfile(video_path):
+        return jsonify({"error": f"Video for job {job_id} not found (may have been uploaded to R2)"}), 404
+    return send_file(video_path, mimetype="video/mp4", as_attachment=True, download_name=f"{job_id}.mp4")
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 8080))
+    logger.info(f"Starting server on port {port} ...")
+    app.run(host="0.0.0.0", port=port)

requirements.txt

@@ -13,3 +13,12 @@ pillow
 numpy
 tqdm
 easydict
+scipy
+flask
+gunicorn
+ftfy
+regex
+requests
+packaging
+peft
+boto3

wan/modules/t5.py

@@ -491,7 +491,7 @@ class T5EncoderModel:
             dtype=dtype,
             device=device).eval().requires_grad_(False)
         logging.info(f'loading {checkpoint_path}')
-        model.load_state_dict(torch.load(checkpoint_path, map_location='cpu'))
+        model.load_state_dict(torch.load(checkpoint_path, map_location='cpu', weights_only=False))
         self.model = model
         if shard_fn is not None:
             self.model = shard_fn(self.model, sync_module_states=False)