Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends ffmpeg && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY main.py .
+
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,8 @@
 ---
 title: Media Processor
-emoji: 🌖
-colorFrom: green
-colorTo: blue
+emoji: 🎬
+colorFrom: blue
+colorTo: purple
 sdk: docker
-pinned: false
+app_port: 7860
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

main.py

@@ -0,0 +1,173 @@
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+import httpx
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+app = FastAPI(title="Media Processor")
+
+
+class ProcessRequest(BaseModel):
+    asset_id: str
+    video_url: str
+    api_url: str
+    api_key: str
+
+
+@app.get("/health")
+async def health():
+    ffmpeg_ok = subprocess.run(
+        ["ffmpeg", "-version"], capture_output=True
+    ).returncode == 0
+    return {"status": "ok", "ffmpeg": ffmpeg_ok}
+
+
+@app.post("/process")
+async def process_video(req: ProcessRequest):
+    tmp_dir = tempfile.mkdtemp()
+    video_path = Path(tmp_dir) / f"{req.asset_id}.mp4"
+    cover_path = Path(tmp_dir) / f"{req.asset_id}_cover.jpg"
+
+    try:
+        # 1. Download video
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream("GET", req.video_url) as resp:
+                if resp.status_code != 200:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Failed to download video: {resp.status_code}",
+                    )
+                with open(video_path, "wb") as f:
+                    async for chunk in resp.aiter_bytes(chunk_size=65536):
+                        f.write(chunk)
+
+        # 2. Extract metadata with ffprobe
+        probe_result = subprocess.run(
+            [
+                "ffprobe", "-v", "quiet",
+                "-print_format", "json",
+                "-show_format", "-show_streams",
+                str(video_path),
+            ],
+            capture_output=True, text=True,
+        )
+        if probe_result.returncode != 0:
+            raise HTTPException(status_code=500, detail="ffprobe failed")
+
+        probe_data = json.loads(probe_result.stdout)
+        video_stream = next(
+            (s for s in probe_data.get("streams", []) if s.get("codec_type") == "video"),
+            None,
+        )
+        audio_stream = next(
+            (s for s in probe_data.get("streams", []) if s.get("codec_type") == "audio"),
+            None,
+        )
+        fmt = probe_data.get("format", {})
+
+        duration = float(fmt.get("duration", 0))
+        width = int(video_stream.get("width", 0)) if video_stream else 0
+        height = int(video_stream.get("height", 0)) if video_stream else 0
+
+        # Parse fps from r_frame_rate (e.g. "30/1")
+        fps = 0.0
+        if video_stream and video_stream.get("r_frame_rate"):
+            parts = video_stream["r_frame_rate"].split("/")
+            if len(parts) == 2 and int(parts[1]) != 0:
+                fps = round(int(parts[0]) / int(parts[1]), 2)
+
+        media_info = {
+            "format": fmt.get("format_name", ""),
+            "video_codec": video_stream.get("codec_name", "") if video_stream else "",
+            "audio_codec": audio_stream.get("codec_name", "") if audio_stream else "",
+            "bitrate": int(fmt.get("bit_rate", 0)),
+            "fps": fps,
+        }
+
+        # 3. Extract cover frame
+        seek_time = "1" if duration > 1 else "0"
+        ffmpeg_result = subprocess.run(
+            [
+                "ffmpeg", "-ss", seek_time,
+                "-i", str(video_path),
+                "-frames:v", "1", "-q:v", "2",
+                str(cover_path),
+            ],
+            capture_output=True,
+        )
+        if ffmpeg_result.returncode != 0:
+            # Fallback to 0s
+            subprocess.run(
+                [
+                    "ffmpeg", "-ss", "0",
+                    "-i", str(video_path),
+                    "-frames:v", "1", "-q:v", "2",
+                    str(cover_path),
+                ],
+                capture_output=True,
+            )
+
+        cover_url = None
+        if cover_path.exists():
+            # 4. Upload cover to asset-service
+            async with httpx.AsyncClient(timeout=60) as client:
+                with open(cover_path, "rb") as f:
+                    upload_resp = await client.post(
+                        f"{req.api_url}/api/assets/upload",
+                        headers={"Authorization": f"Bearer {req.api_key}"},
+                        files={"file": (f"{req.asset_id}_cover.jpg", f, "image/jpeg")},
+                        data={
+                            "type": "image",
+                            "title": f"{req.asset_id}_cover",
+                            "app": "media_processor",
+                        },
+                    )
+                if upload_resp.status_code in (200, 201):
+                    cover_asset = upload_resp.json().get("asset", {})
+                    cover_id = cover_asset.get("id")
+                    if cover_id:
+                        cover_url = f"{req.api_url}/api/assets/{cover_id}/file"
+
+        # 5. Update original asset with metadata
+        async with httpx.AsyncClient(timeout=30) as client:
+            update_body = {
+                "asset_details": {
+                    "cover_url": cover_url,
+                    "duration": duration,
+                    "width": width,
+                    "height": height,
+                    "media_info": json.dumps(media_info),
+                }
+            }
+            await client.put(
+                f"{req.api_url}/api/assets/{req.asset_id}",
+                headers={
+                    "Authorization": f"Bearer {req.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=update_body,
+            )
+
+        return {
+            "success": True,
+            "cover_url": cover_url,
+            "duration": duration,
+            "width": width,
+            "height": height,
+            "media_info": media_info,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+    finally:
+        # 6. Cleanup
+        for p in (video_path, cover_path):
+            if p.exists():
+                p.unlink()
+        Path(tmp_dir).rmdir() if Path(tmp_dir).exists() else None

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.0
+uvicorn==0.32.0
+httpx==0.28.0
+python-multipart==0.0.18