Upload 26 files

renderer/core/config.py

@@ -4,21 +4,26 @@ import os
 from dataclasses import dataclass
 from pathlib import Path
 
+DEFAULT_ROOT = Path.cwd()
+
 
 @dataclass(frozen=True)
 class Settings:
     """Runtime settings tuned for small CPU-only Hugging Face Spaces."""
 
-    base_dir: Path = Path(os.getenv("BASYX_BASE_DIR", "/app"))
-    temp_dir: Path = Path(os.getenv("TEMP_DIR", "/app/temp"))
-    exports_dir: Path = Path(os.getenv("EXPORTS_DIR", "/app/exports"))
-    jobs_dir: Path = Path(os.getenv("JOBS_DIR", "/app/jobs"))
-    metadata_cache: Path = Path(os.getenv("METADATA_CACHE", "/app/temp/metadata_cache.json"))
+    base_dir: Path = Path(os.getenv("BASYX_BASE_DIR", str(DEFAULT_ROOT)))
+    temp_dir: Path = Path(os.getenv("TEMP_DIR", str(DEFAULT_ROOT / "temp")))
+    exports_dir: Path = Path(os.getenv("EXPORTS_DIR", str(DEFAULT_ROOT / "exports")))
+    jobs_dir: Path = Path(os.getenv("JOBS_DIR", str(DEFAULT_ROOT / "jobs")))
+    metadata_cache: Path = Path(os.getenv("METADATA_CACHE", str(DEFAULT_ROOT / "temp" / "metadata_cache.json")))
     font_path: Path = Path(os.getenv("FONT_PATH", "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"))
     output_width: int = int(os.getenv("OUTPUT_WIDTH", "1080"))
     output_height: int = int(os.getenv("OUTPUT_HEIGHT", "1920"))
     output_fps: int = int(os.getenv("OUTPUT_FPS", "30"))
     ffmpeg_timeout_seconds: int = int(os.getenv("FFMPEG_TIMEOUT_SECONDS", "900"))
+    download_timeout_seconds: int = int(os.getenv("DOWNLOAD_TIMEOUT_SECONDS", "60"))
+    max_download_bytes: int = int(os.getenv("MAX_DOWNLOAD_BYTES", str(500 * 1024 * 1024)))
+    allow_private_asset_urls: bool = os.getenv("ALLOW_PRIVATE_ASSET_URLS", "false").lower() == "true"
     max_retries: int = int(os.getenv("MAX_RETRIES", "3"))
     max_workers: int = int(os.getenv("MAX_RENDER_WORKERS", "1"))
     crf: int = int(os.getenv("OUTPUT_CRF", "23"))

renderer/core/ingest.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import ipaddress
+import mimetypes
+import shutil
+import socket
+from dataclasses import replace
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+from urllib.request import Request, urlopen
+
+from renderer.core.config import Settings
+from renderer.core.models import AIReelsRequest, RenderRequest, Scene
+from renderer.core.utils import safe_filename
+
+
+class IngestError(ValueError):
+    pass
+
+
+class AssetIngestor:
+    """Resolve local paths and remote URLs into job-local files."""
+
+    def __init__(self, settings: Settings) -> None:
+        self.settings = settings
+
+    def resolve_render_request(self, request: RenderRequest, workdir: Path) -> RenderRequest:
+        return replace(
+            request,
+            scenes=[
+                replace(scene, media=str(self.resolve(scene.media, workdir / "inputs", f"scene_{idx:03d}")))
+                for idx, scene in enumerate(request.scenes)
+            ],
+            voiceover=self.resolve_optional(request.voiceover, workdir / "inputs", "voiceover"),
+            background_music=self.resolve_optional(request.background_music, workdir / "inputs", "music"),
+        )
+
+    def resolve_ai_reels_request(self, request: AIReelsRequest, workdir: Path) -> AIReelsRequest:
+        return replace(
+            request,
+            voiceover=str(self.resolve(request.voiceover, workdir / "inputs", "voiceover")),
+            assets=[str(self.resolve(asset, workdir / "inputs", f"asset_{idx:03d}")) for idx, asset in enumerate(request.assets)],
+            background_music=self.resolve_optional(request.background_music, workdir / "inputs", "music"),
+        )
+
+    def resolve_optional(self, value: str | None, directory: Path, stem: str) -> str | None:
+        if not value:
+            return None
+        return str(self.resolve(value, directory, stem))
+
+    def resolve(self, value: str, directory: Path, stem: str) -> Path:
+        directory.mkdir(parents=True, exist_ok=True)
+        if is_remote_url(value):
+            return self.download(value, directory, stem)
+        path = Path(value)
+        if not path.exists():
+            raise IngestError(f"Asset does not exist: {value}")
+        return path
+
+    def download(self, url: str, directory: Path, stem: str) -> Path:
+        parsed = urlparse(url)
+        if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+            raise IngestError("Only http and https asset URLs are supported")
+        if not self.settings.allow_private_asset_urls:
+            _reject_private_host(parsed.hostname)
+        request = Request(url, headers={"User-Agent": "basyx-ffmpeg-renderer/1.0"})
+        with urlopen(request, timeout=self.settings.download_timeout_seconds) as response:
+            content_length = response.headers.get("Content-Length")
+            if content_length and int(content_length) > self.settings.max_download_bytes:
+                raise IngestError("Remote asset exceeds MAX_DOWNLOAD_BYTES")
+            suffix = _suffix_from_response(url, response.headers.get("Content-Type"))
+            target = directory / safe_filename(f"{stem}{suffix}")
+            total = 0
+            with target.open("wb") as output:
+                while True:
+                    chunk = response.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    total += len(chunk)
+                    if total > self.settings.max_download_bytes:
+                        target.unlink(missing_ok=True)
+                        raise IngestError("Remote asset exceeds MAX_DOWNLOAD_BYTES")
+                    output.write(chunk)
+        return target
+
+
+def stage_upload(source: Path, uploads_dir: Path, filename: str) -> Path:
+    uploads_dir.mkdir(parents=True, exist_ok=True)
+    target = uploads_dir / safe_filename(filename)
+    if source.resolve() != target.resolve():
+        shutil.copy2(source, target)
+    return target
+
+
+def is_remote_url(value: str) -> bool:
+    return urlparse(value).scheme in {"http", "https"}
+
+
+def _suffix_from_response(url: str, content_type: str | None) -> str:
+    path_suffix = Path(unquote(urlparse(url).path)).suffix
+    if path_suffix:
+        return path_suffix[:16]
+    if content_type:
+        guessed = mimetypes.guess_extension(content_type.split(";", 1)[0].strip())
+        if guessed:
+            return guessed
+    return ".bin"
+
+
+def _reject_private_host(hostname: str) -> None:
+    try:
+        addresses = socket.getaddrinfo(hostname, None)
+    except socket.gaierror as exc:
+        raise IngestError(f"Could not resolve host: {hostname}") from exc
+    for address in addresses:
+        ip = ipaddress.ip_address(address[4][0])
+        if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_multicast:
+            raise IngestError("Private, loopback, link-local, and multicast asset hosts are not allowed")

renderer/core/render_engine.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from renderer.audio import AudioMixer
 from renderer.core.config import Settings
+from renderer.core.ingest import AssetIngestor
 from renderer.core.models import AIReelsRequest, RenderRequest, RenderResult
 from renderer.core.utils import cleanup_directory, temp_workdir
 from renderer.exports import ExportManager
@@ -26,6 +27,7 @@ class RenderEngine:
         self._commands: list[list[str]] = []
         self._logs: list[str] = []
         self.runner = FFmpegRunner(self.settings.ffmpeg_timeout_seconds, log=log, on_command=self._record_command)
+        self.ingest = AssetIngestor(self.settings)
         self.assets = AssetProbe(self.settings.metadata_cache)
         self.normalizer = Normalizer(self.settings, self.runner)
         self.subtitles = SubtitleGenerator()
@@ -40,10 +42,12 @@ class RenderEngine:
         timeline = Timeline(request.scenes)
         with temp_workdir(self.settings.temp_dir, job_id) as work:
             workdir = Path(work)
-            prepared = self._prepare_scene_media(request, workdir)
-            subtitles = self._write_subtitles(request, timeline, workdir)
-            video = self._compose_video(prepared, request, subtitles, workdir)
-            mixed = self.audio.mix(video, request.background_music, request.voiceover, workdir / "mixed.mp4")
+            resolved = self.ingest.resolve_render_request(request, workdir)
+            timeline = Timeline(resolved.scenes)
+            prepared = self._prepare_scene_media(resolved, workdir)
+            subtitles = self._write_subtitles(resolved, timeline, workdir)
+            video = self._compose_video(prepared, resolved, subtitles, workdir)
+            mixed = self.audio.mix(video, resolved.background_music, resolved.voiceover, workdir / "mixed.mp4")
             output = self.exports.save(mixed, job_id, request.output_name)
             cleanup_directory(workdir, keep={mixed})
         metrics = {
@@ -56,31 +60,53 @@ class RenderEngine:
     def ai_reels(self, request: AIReelsRequest, job_id: str) -> RenderResult:
         if not request.voiceover:
             raise ValueError("AI reels v1 requires a provided voiceover path; TTS is pluggable but not bundled.")
-        voice_meta = self.assets.probe(request.voiceover)
-        duration = max(voice_meta.duration, len(request.script.split()) * 0.35, 3.0)
-        per_scene = duration / max(1, len(request.assets))
-        captions = _split_script(request.script, len(request.assets))
-        scenes = [
-            {
-                "start": round(idx * per_scene, 3),
-                "duration": round(per_scene, 3),
-                "media": asset,
-                "caption": captions[idx] if idx < len(captions) else "",
-            }
-            for idx, asset in enumerate(request.assets)
-        ]
-        render_request = RenderRequest(
-            scenes=Timeline.request_from_payload({"scenes": scenes}).scenes,
-            template=request.template,
-            output_name=request.output_name,
-            voiceover=request.voiceover,
-            background_music=request.background_music,
-        )
-        return self.render(render_request, job_id)
+        if not request.assets:
+            raise ValueError("AI reels rendering requires at least one visual asset.")
+        with temp_workdir(self.settings.temp_dir, job_id) as work:
+            workdir = Path(work)
+            resolved = self.ingest.resolve_ai_reels_request(request, workdir)
+            voice_meta = self.assets.probe(resolved.voiceover)
+            duration = max(voice_meta.duration, len(resolved.script.split()) * 0.35, 3.0)
+            per_scene = duration / max(1, len(resolved.assets))
+            captions = _split_script(resolved.script, len(resolved.assets))
+            scenes = [
+                {
+                    "start": round(idx * per_scene, 3),
+                    "duration": round(per_scene, 3),
+                    "media": asset,
+                    "caption": captions[idx] if idx < len(captions) else "",
+                }
+                for idx, asset in enumerate(resolved.assets)
+            ]
+            render_request = RenderRequest(
+                scenes=Timeline.request_from_payload({"scenes": scenes}).scenes,
+                template=resolved.template,
+                output_name=resolved.output_name,
+                voiceover=resolved.voiceover,
+                background_music=resolved.background_music,
+            )
+            return self._render_resolved(render_request, job_id, workdir)
 
     def inspect_asset(self, path: str | Path) -> dict:
         return self.assets.probe(path).__dict__
 
+    def _render_resolved(self, request: RenderRequest, job_id: str, workdir: Path) -> RenderResult:
+        self._commands = []
+        self._logs = []
+        started = time.time()
+        timeline = Timeline(request.scenes)
+        prepared = self._prepare_scene_media(request, workdir)
+        subtitles = self._write_subtitles(request, timeline, workdir)
+        video = self._compose_video(prepared, request, subtitles, workdir)
+        mixed = self.audio.mix(video, request.background_music, request.voiceover, workdir / "mixed.mp4")
+        output = self.exports.save(mixed, job_id, request.output_name)
+        metrics = {
+            "render_time_seconds": round(time.time() - started, 3),
+            "output_size_bytes": output.stat().st_size,
+            "scene_count": len(request.scenes),
+        }
+        return RenderResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
+
     def _prepare_scene_media(self, request: RenderRequest, workdir: Path) -> list[Path]:
         prepared: list[Path] = []
         for idx, scene in enumerate(request.scenes):