Upload folder using huggingface_hub

main.py

@@ -1,5 +1,4 @@
 import json
-import os
 import subprocess
 import tempfile
 from pathlib import Path
@@ -18,6 +17,65 @@ class ProcessRequest(BaseModel):
     api_key: str
 
 
+class ThumbnailRequest(BaseModel):
+    asset_id: str
+    file_url: str
+    api_url: str
+    api_key: str
+
+
+# ── Helpers ──────────────────────────────────────────────
+
+
+async def _download_file(url: str, dest: Path):
+    """Stream-download a file to disk."""
+    async with httpx.AsyncClient(timeout=120) as client:
+        async with client.stream("GET", url) as resp:
+            if resp.status_code != 200:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Failed to download: {resp.status_code}",
+                )
+            with open(dest, "wb") as f:
+                async for chunk in resp.aiter_bytes(chunk_size=65536):
+                    f.write(chunk)
+
+
+def _resize_to_thumbnail(src: Path, dest: Path):
+    """Resize image to width=300, height proportional."""
+    subprocess.run(
+        [
+            "ffmpeg", "-i", str(src),
+            "-vf", "scale=300:-1",
+            "-q:v", "3",
+            str(dest),
+        ],
+        capture_output=True,
+    )
+
+
+async def _upload_image(file_path: Path, filename: str, api_url: str, api_key: str) -> str | None:
+    """Upload an image file to asset-service and return its file URL."""
+    if not file_path.exists():
+        return None
+    async with httpx.AsyncClient(timeout=60) as client:
+        with open(file_path, "rb") as f:
+            resp = await client.post(
+                f"{api_url}/api/assets/upload",
+                headers={"Authorization": f"Bearer {api_key}"},
+                files={"file": (filename, f, "image/jpeg")},
+                data={"type": "image", "title": filename, "app": "media_processor"},
+            )
+        if resp.status_code in (200, 201):
+            asset_id = resp.json().get("asset", {}).get("id")
+            if asset_id:
+                return f"{api_url}/api/assets/{asset_id}/file"
+    return None
+
+
+# ── Endpoints ────────────────────────────────────────────
+
+
 @app.get("/health")
 async def health():
     ffmpeg_ok = subprocess.run(
@@ -26,24 +84,62 @@ async def health():
     return {"status": "ok", "ffmpeg": ffmpeg_ok}
 
 
+@app.post("/thumbnail")
+async def generate_thumbnail(req: ThumbnailRequest):
+    """Generate a 300px-wide thumbnail for an image asset."""
+    tmp_dir = tempfile.mkdtemp()
+    src_path = Path(tmp_dir) / f"{req.asset_id}_src"
+    thumb_path = Path(tmp_dir) / f"{req.asset_id}_thumb.jpg"
+
+    try:
+        # 1. Download image
+        await _download_file(req.file_url, src_path)
+
+        # 2. Resize to 300px width
+        _resize_to_thumbnail(src_path, thumb_path)
+
+        # 3. Upload thumbnail
+        thumbnail_url = await _upload_image(
+            thumb_path, f"{req.asset_id}_thumb.jpg", req.api_url, req.api_key
+        )
+
+        # 4. Update asset with thumbnail_url
+        if thumbnail_url:
+            async with httpx.AsyncClient(timeout=30) as client:
+                await client.put(
+                    f"{req.api_url}/api/assets/{req.asset_id}",
+                    headers={
+                        "Authorization": f"Bearer {req.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json={"asset_details": {"thumbnail_url": thumbnail_url}},
+                )
+
+        return {"success": True, "thumbnail_url": thumbnail_url}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+    finally:
+        for p in (src_path, thumb_path):
+            if p.exists():
+                p.unlink()
+        if Path(tmp_dir).exists():
+            Path(tmp_dir).rmdir()
+
+
 @app.post("/process")
 async def process_video(req: ProcessRequest):
+    """Extract cover + thumbnail + metadata from a video asset."""
     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"
+    thumb_path = Path(tmp_dir) / f"{req.asset_id}_thumb.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)
+        await _download_file(req.video_url, video_path)
 
         # 2. Extract metadata with ffprobe
         probe_result = subprocess.run(
@@ -73,7 +169,6 @@ async def process_video(req: ProcessRequest):
         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("/")
@@ -88,9 +183,9 @@ async def process_video(req: ProcessRequest):
             "fps": fps,
         }
 
-        # 3. Extract cover frame
+        # 3. Extract cover frame (full resolution)
         seek_time = "1" if duration > 1 else "0"
-        ffmpeg_result = subprocess.run(
+        result = subprocess.run(
             [
                 "ffmpeg", "-ss", seek_time,
                 "-i", str(video_path),
@@ -99,8 +194,7 @@ async def process_video(req: ProcessRequest):
             ],
             capture_output=True,
         )
-        if ffmpeg_result.returncode != 0:
-            # Fallback to 0s
+        if result.returncode != 0:
             subprocess.run(
                 [
                     "ffmpeg", "-ss", "0",
@@ -111,50 +205,42 @@ async def process_video(req: ProcessRequest):
                 capture_output=True,
             )
 
-        cover_url = None
+        # 4. Generate 300px thumbnail from cover
         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
+            _resize_to_thumbnail(cover_path, thumb_path)
+
+        # 5. Upload cover + thumbnail
+        cover_url = await _upload_image(
+            cover_path, f"{req.asset_id}_cover.jpg", req.api_url, req.api_key
+        )
+        thumbnail_url = await _upload_image(
+            thumb_path, f"{req.asset_id}_thumb.jpg", req.api_url, req.api_key
+        )
+
+        # 6. Update original asset
         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,
+                json={
+                    "asset_details": {
+                        "cover_url": cover_url,
+                        "thumbnail_url": thumbnail_url,
+                        "duration": duration,
+                        "width": width,
+                        "height": height,
+                        "media_info": json.dumps(media_info),
+                    }
+                },
             )
 
         return {
             "success": True,
             "cover_url": cover_url,
+            "thumbnail_url": thumbnail_url,
             "duration": duration,
             "width": width,
             "height": height,
@@ -166,8 +252,8 @@ async def process_video(req: ProcessRequest):
     except Exception as e:
         return {"success": False, "error": str(e)}
     finally:
-        # 6. Cleanup
-        for p in (video_path, cover_path):
+        for p in (video_path, cover_path, thumb_path):
             if p.exists():
                 p.unlink()
-        Path(tmp_dir).rmdir() if Path(tmp_dir).exists() else None
+        if Path(tmp_dir).exists():
+            Path(tmp_dir).rmdir()