spacepilot 2.8.0__py3-none-any.whl

spacepilot/__init__.py

@@ -0,0 +1,3 @@
+"""SpacePilot — inference orchestration across the machines you can reach."""
+
+__version__ = "2.8.0"

spacepilot/api/__init__.py

@@ -0,0 +1 @@
+"""API layer package."""

spacepilot/api/deps.py

@@ -0,0 +1,50 @@
+"""Shared API dependencies and security gates."""
+
+import time
+import secrets
+from typing import Optional
+from fastapi import Header, HTTPException
+from spacepilot.core.config import get_settings
+
+_last_activity_time = time.time()
+
+
+def update_activity() -> None:
+    """Record activity to reset the idle watchdog timer."""
+    global _last_activity_time
+    _last_activity_time = time.time()
+
+
+def get_last_activity_time() -> float:
+    return _last_activity_time
+
+
+def require_token(
+    x_spacepilot_token: Optional[str] = Header(None, alias="X-SpacePilot-Token"),
+    x_pluto_token: Optional[str] = Header(None, alias="X-Pluto-Token"),
+) -> None:
+    """Security gate accepting the canonical token plus one legacy header.
+
+    If a client sends both spellings, it must send the same credential in each.
+    That makes ambiguous proxy/client configuration fail closed instead of
+    allowing one header to silently override the other.
+    """
+    settings = get_settings()
+    try:
+        if x_spacepilot_token is not None and x_pluto_token is not None:
+            ok = (
+                secrets.compare_digest(x_spacepilot_token, x_pluto_token)
+                and secrets.compare_digest(x_spacepilot_token, settings.studio_token)
+            )
+        else:
+            candidate = x_spacepilot_token if x_spacepilot_token is not None else x_pluto_token
+            ok = bool(candidate) and secrets.compare_digest(candidate, settings.studio_token)
+    except TypeError:
+        # Headers decode as latin-1, and compare_digest rejects non-ASCII str.
+        ok = False
+    if not ok:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing or invalid X-SpacePilot-Token",
+            headers={"WWW-Authenticate": "Token"},
+        )

spacepilot/api/routes/__init__.py

@@ -0,0 +1,37 @@
+"""SpacePilot API Routes."""
+
+from .audio import router as audio_router
+from .billing import billing_router
+from .health import router as health_router
+from .compute import router as compute_router
+from .engines import router as engines_router
+from .storyboard import router as storyboard_router
+from .views import router as views_router
+from .assets import router as assets_router
+from .gpu import router as gpu_router
+from .generate import router as generate_router
+from .checkpoints import router as checkpoints_router
+from .lora import router as lora_router
+from .recipes import router as recipes_router
+from .runtimes import router as runtimes_router
+from .measurements import router as measurements_router
+from .inference import router as inference_router
+
+__all__ = [
+    "audio_router",
+    "billing_router",
+    "health_router",
+    "compute_router",
+    "engines_router",
+    "storyboard_router",
+    "views_router",
+    "assets_router",
+    "gpu_router",
+    "generate_router",
+    "checkpoints_router",
+    "lora_router",
+    "recipes_router",
+    "runtimes_router",
+    "measurements_router",
+    "inference_router",
+]

spacepilot/api/routes/assets.py

@@ -0,0 +1,255 @@
+"""Assets management and file streaming routes."""
+
+import json
+import base64
+import uuid
+import subprocess
+from pathlib import Path
+from typing import Optional
+from fastapi import APIRouter, Request, HTTPException
+from fastapi.responses import FileResponse
+
+from spacepilot.core.config import get_settings
+from spacepilot.core.utils import resolve_output
+from spacepilot.services.image_utils import (
+    MAX_IMAGE_SIZE,
+    ALLOWED_IMAGE_MIMES,
+    sanitize_upload_filename,
+    get_image_info,
+    get_aspect_ratio_str,
+    parse_multipart_form_data,
+)
+
+router = APIRouter(tags=["assets"])
+
+
+@router.get("/api/assets")
+def list_assets():
+    """List all generated videos and 4K masters in outputs library."""
+    settings = get_settings()
+    outputs_dir = settings.outputs_dir
+    assets = []
+    seen_ids = set()
+
+    for f in outputs_dir.glob("*.json"):
+        try:
+            with open(f, "r") as jf:
+                data = json.load(jf)
+                asset_id = data.get("id", f.stem)
+                mp4 = outputs_dir / f"{asset_id}.mp4"
+                if mp4.exists():
+                    data["size_mb"] = round(mp4.stat().st_size / (1024 * 1024), 2)
+                    data["video_url"] = f"/api/media/{asset_id}.mp4"
+                    data["thumb_url"] = f"/api/media/{asset_id}.png"
+                    assets.append(data)
+                    seen_ids.add(asset_id)
+        except Exception:
+            pass
+
+    for mp4 in outputs_dir.glob("*.mp4"):
+        asset_id = mp4.stem
+        if asset_id in seen_ids or asset_id.endswith("_raw"):
+            continue
+        try:
+            size_mb = round(mp4.stat().st_size / (1024 * 1024), 2)
+            is_master = "master" in asset_id or "4k" in asset_id
+            
+            clean_title = asset_id.replace("_", " ").title()
+            if "3blue1brown" in asset_id.lower() or "neural_network" in asset_id.lower():
+                clean_title = "🧠 3Blue1Brown: But what is a Neural Network? (19-Minute 4K Master)"
+            elif "37min" in asset_id.lower() or "welch" in asset_id.lower():
+                clean_title = "🎬 37-Minute Diffusion Physics Master Documentary (Welch Labs 4K)"
+
+            thumb = outputs_dir / f"{asset_id}.png"
+            if not thumb.exists():
+                subprocess.run(
+                    ["ffmpeg", "-y", "-ss", "2.0", "-i", str(mp4), "-vframes", "1", "-q:v", "2", str(thumb)],
+                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+                )
+
+            asset_data = {
+                "id": asset_id,
+                "prompt": clean_title,
+                "width": 3840 if is_master else 1024,
+                "height": 2160 if is_master else 576,
+                "seconds": 2239.94 if "37min" in asset_id else 1119.94,
+                "status": "completed",
+                "is_upscaled": is_master,
+                "is_motionvector_master": is_master,
+                "overlay_title": "4K Mathematical Master",
+                "overlay_formula": r"\nabla_x \log p_t(x)",
+                "size_mb": size_mb,
+                "video_url": f"/api/media/{asset_id}.mp4",
+                "thumb_url": f"/api/media/{asset_id}.png" if thumb.exists() else "/api/media/placeholder.png",
+                "created_at": mp4.stat().st_mtime,
+            }
+            assets.append(asset_data)
+            seen_ids.add(asset_id)
+        except Exception:
+            pass
+
+    assets.sort(key=lambda x: x.get("created_at", 0), reverse=True)
+    return {"assets": assets, "count": len(assets)}
+
+
+@router.api_route("/api/media/{file_path:path}", methods=["GET", "HEAD"])
+def serve_media_file(file_path: str):
+    """Safely stream a media file from the outputs directory."""
+    path = resolve_output(file_path)
+    ext = path.suffix.lower()
+    media_types = {
+        ".mp4": "video/mp4",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".wav": "audio/wav",
+        ".json": "application/json",
+    }
+    return FileResponse(path, media_type=media_types.get(ext, "application/octet-stream"))
+
+
+@router.api_route("/api/assets/{asset_id}/file", methods=["GET", "HEAD"])
+def get_asset_video_file(asset_id: str):
+    """Stream MP4 video file for a specific asset ID."""
+    clean_id = asset_id.replace(".mp4", "")
+    return FileResponse(resolve_output(f"{clean_id}.mp4"), media_type="video/mp4")
+
+
+@router.api_route("/api/assets/{asset_id}/thumbnail", methods=["GET", "HEAD"])
+def get_asset_thumbnail_file(asset_id: str):
+    """Stream thumbnail PNG image for a specific asset ID."""
+    clean_id = asset_id.replace(".png", "").replace(".mp4", "")
+    settings = get_settings()
+    try:
+        file_path = resolve_output(f"{clean_id}.png")
+    except HTTPException:
+        fallback = settings.web_dir / "assets" / "placeholder.png"
+        if fallback.exists():
+            return FileResponse(fallback, media_type="image/png")
+        raise HTTPException(status_code=404, detail=f"Asset thumbnail '{asset_id}' not found")
+    return FileResponse(file_path, media_type="image/png")
+
+
+@router.post("/api/upload-image")
+@router.post("/api/assets/upload-image")
+async def upload_image_api(request: Request):
+    """Upload and validate an image for Image-to-Video generation."""
+    settings = get_settings()
+    uploads_dir = settings.outputs_dir / "uploads"
+    uploads_dir.mkdir(parents=True, exist_ok=True)
+
+    content_type = request.headers.get("content-type", "")
+    content: Optional[bytes] = None
+    raw_filename: str = "upload.png"
+    declared_mime: Optional[str] = None
+
+    if "multipart/form-data" in content_type or "application/x-www-form-urlencoded" in content_type:
+        has_multipart_lib = False
+        try:
+            import multipart
+            has_multipart_lib = True
+        except ImportError:
+            pass
+
+        if has_multipart_lib:
+            try:
+                form = await request.form()
+                upload_file = form.get("file") or form.get("image")
+                if upload_file is None:
+                    for v in form.values():
+                        if hasattr(v, "filename") and hasattr(v, "read"):
+                            upload_file = v
+                            break
+
+                if upload_file is not None and hasattr(upload_file, "filename"):
+                    raw_filename = upload_file.filename or "upload.png"
+                    declared_mime = upload_file.content_type
+                    content = await upload_file.read()
+            except Exception:
+                pass
+
+        if content is None:
+            raw_body = await request.body()
+            content, raw_filename, declared_mime = parse_multipart_form_data(raw_body, content_type)
+
+        if content is None:
+            raise HTTPException(status_code=400, detail="No image file provided in form data")
+
+    elif "application/json" in content_type:
+        try:
+            body = await request.json()
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid JSON body: {e}")
+
+        b64_data = body.get("image_base64") or body.get("image") or body.get("data") or body.get("file")
+        if not b64_data or not isinstance(b64_data, str):
+            raise HTTPException(status_code=400, detail="Missing image base64 data in JSON body")
+
+        raw_filename = body.get("filename", "upload.png")
+        declared_mime = body.get("content_type")
+
+        if "," in b64_data and b64_data.startswith("data:"):
+            header_part, b64_part = b64_data.split(",", 1)
+            if not declared_mime and ";" in header_part:
+                declared_mime = header_part.split(";")[0].replace("data:", "")
+            b64_data = b64_part
+
+        try:
+            content = base64.b64decode(b64_data)
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid base64 payload: {e}")
+
+    elif any(content_type.startswith(m) for m in ALLOWED_IMAGE_MIMES):
+        raw_filename = "upload.png"
+        declared_mime = content_type.split(";")[0]
+        content = await request.body()
+
+    else:
+        raise HTTPException(
+            status_code=400,
+            detail="Unsupported Content-Type. Expected multipart/form-data or application/json",
+        )
+
+    if not content or len(content) == 0:
+        raise HTTPException(status_code=400, detail="Empty image payload")
+
+    if len(content) > MAX_IMAGE_SIZE:
+        raise HTTPException(status_code=413, detail="File size exceeds maximum allowed 25MB")
+
+    width, height, detected_mime = get_image_info(content)
+    effective_mime = detected_mime or declared_mime
+    if effective_mime == "image/jpg":
+        effective_mime = "image/jpeg"
+
+    if not effective_mime or effective_mime not in ALLOWED_IMAGE_MIMES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported image type '{effective_mime}'. Allowed: image/png, image/jpeg, image/webp, image/gif",
+        )
+
+    if not width or not height or width <= 0 or height <= 0:
+        raise HTTPException(status_code=400, detail="Could not determine valid image dimensions")
+
+    mime_to_ext = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/gif": ".gif"}
+    fallback_ext = mime_to_ext.get(effective_mime, ".png")
+    clean_name = sanitize_upload_filename(raw_filename, fallback_ext)
+
+    unique_id = uuid.uuid4().hex[:10]
+    safe_name = f"{unique_id}_{clean_name}"
+    dest_path = (uploads_dir / safe_name).resolve()
+
+    if not dest_path.is_relative_to(uploads_dir.resolve()):
+        raise HTTPException(status_code=400, detail="Invalid target filename")
+
+    dest_path.write_bytes(content)
+    aspect_str = get_aspect_ratio_str(width, height)
+
+    return {
+        "image_path": str(dest_path),
+        "url": f"/api/media/uploads/{safe_name}",
+        "width": width,
+        "height": height,
+        "aspect_ratio": aspect_str,
+        "filename": clean_name,
+    }