ffmpeg_cats

Running

App Files Files Community

Pepguy commited on 21 days ago

Commit

fa37cef

verified ·

1 Parent(s): f87054d

Update app.py

Browse files

Files changed (1) hide show

app.py +118 -31

app.py CHANGED Viewed

@@ -1,14 +1,16 @@
-from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 import subprocess
 import base64
 import os
 import uuid
 import shutil
-from pytube import YouTube
 import socket
-# Force IPv4 to prevent DNS errors on cloud hosting
 orig_getaddrinfo = socket.getaddrinfo
 def hooked_getaddrinfo(*args, **kwargs):
     res = orig_getaddrinfo(*args, **kwargs)
@@ -17,40 +19,128 @@ socket.getaddrinfo = hooked_getaddrinfo
 app = FastAPI()
-@app.get("/")
-def greet_json():
-    return {"status": "online", "engine": "PyTube + FFmpeg"}
 class VideoRequest(BaseModel):
     url: str
-    platform: str # Note: PyTube will ignore this and assume YouTube
     is_pro: bool = False
     fps: int = 2
 def file_to_base64(filepath):
     with open(filepath, "rb") as f:
         return base64.b64encode(f.read()).decode('utf-8')
 @app.post("/process-video")
 def process_video(req: VideoRequest):
     job_id = str(uuid.uuid4())
     work_dir = f"/tmp/viralcat_{job_id}"
     os.makedirs(work_dir, exist_ok=True)
-    video_filename = "video.mp4"
-    video_path = os.path.join(work_dir, video_filename)
     audio_path = os.path.join(work_dir, "audio.mp3")
     try:
-        # 1. Download using PyTube
-        print(f"[PYTUBE] Downloading: {req.url}")
-        yt = YouTube(req.url)
-        # Select the lowest resolution progressive stream to save bandwidth and time
-        stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').first()
-        stream.download(output_path=work_dir, filename=video_filename)
-        # 2. Extract Duration via ffprobe
         probe = subprocess.run([
             "ffprobe", "-v", "error", "-show_entries",
             "format=duration", "-of", "default=noprint_wrappers=1:nokey=1",
@@ -58,33 +148,30 @@ def process_video(req: VideoRequest):
         ], capture_output=True, text=True, check=True)
         duration = float(probe.stdout.strip() or 0)
         if duration > 120 and not req.is_pro:
-            raise ValueError(f"Video is {duration:.1f}s. Max 120s for free users.")
-        # 3. Extract Frames (FPS based)
-        # Using -q:v 2 for high quality frames so AI sees clearly
         subprocess.run([
             "ffmpeg", "-y", "-i", video_path,
             "-vf", f"fps={req.fps}",
-            "-q:v", "2", f"{work_dir}/frame_%04d.jpg"
         ], check=True, capture_output=True)
-        # 4. Extract Audio (64k mono mp3 for small payload)
         subprocess.run([
             "ffmpeg", "-y", "-i", video_path,
             "-q:a", "0", "-map", "a", "-ac", "1", "-b:a", "64k", audio_path
         ], check=True, capture_output=True)
-        # 5. Convert to Base64
         frame_files = sorted([f for f in os.listdir(work_dir) if f.startswith("frame_") and f.endswith(".jpg")])
-        # Safeguard: Limit to 60 frames max to prevent Node.js payload crash
-        if len(frame_files) > 60:
-            frame_files = frame_files[:60]
         frames_b64 = [file_to_base64(os.path.join(work_dir, f)) for f in frame_files]
-        audio_b64 = file_to_base64(audio_path) if os.path.exists(audio_path) else None
         return {
             "success": True,
@@ -95,10 +182,10 @@ def process_video(req: VideoRequest):
         }
     except Exception as e:
-        print(f"[ERROR] {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
     finally:
-        # CLEANUP
         if os.path.exists(work_dir):
             shutil.rmtree(work_dir, ignore_errors=True)

+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
 import subprocess
 import base64
 import os
 import uuid
 import shutil
+import yt_dlp
 import socket
+# ── 1. SOCKET HACK: FORCE IPv4 ──
+# Prevents "[Errno -5] No address associated with hostname" on cloud hosts
 orig_getaddrinfo = socket.getaddrinfo
 def hooked_getaddrinfo(*args, **kwargs):
     res = orig_getaddrinfo(*args, **kwargs)
 app = FastAPI()
 class VideoRequest(BaseModel):
     url: str
+    platform: str # 'tiktok' or 'instagram'
     is_pro: bool = False
     fps: int = 2
 def file_to_base64(filepath):
+    if not os.path.exists(filepath): return None
     with open(filepath, "rb") as f:
         return base64.b64encode(f.read()).decode('utf-8')
+# ── 2. TEST UI ROUTE ──
+@app.get("/", response_class=HTMLResponse)
+def index():
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Viral Cat | Media Worker</title>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <style>
+            body { background: #090A0F; color: white; font-family: sans-serif; }
+            .neon { color: #12D8C3; text-shadow: 0 0 10px rgba(18,216,195,0.5); }
+            input { background: #16181F; border: 1px solid #2D3748; color: white; }
+        </style>
+    </head>
+    <body class="p-10">
+        <div class="max-w-2xl mx-auto bg-[#16181F] p-8 rounded-3xl border border-[#2D3748]">
+            <h1 class="text-3xl font-bold mb-2">Viral Cat <span class="neon">Media Worker</span></h1>
+            <p class="text-gray-400 mb-6">Test TikTok or Instagram links below.</p>
+            <input type="text" id="url" placeholder="Paste link here..." class="w-full p-4 rounded-xl mb-4">
+            <select id="platform" class="w-full p-4 rounded-xl mb-4 bg-[#090A0F] border border-[#2D3748]">
+                <option value="tiktok">TikTok</option>
+                <option value="instagram">Instagram Reel</option>
+            </select>
+            <button onclick="process()" id="btn" class="w-full bg-[#12D8C3] text-black font-bold p-4 rounded-xl">Process Video</button>
+            <div id="status" class="mt-6 text-sm text-gray-400"></div>
+            <div id="results" class="mt-6 grid grid-cols-4 gap-2"></div>
+        </div>
+        <script>
+            async function process() {
+                const btn = document.getElementById('btn');
+                const status = document.getElementById('status');
+                const results = document.getElementById('results');
+                btn.disabled = true;
+                btn.innerText = "Processing... (may take 20s)";
+                status.innerText = "Downloading and extracting frames...";
+                results.innerHTML = "";
+                try {
+                    const res = await fetch('/process-video', {
+                        method: 'POST',
+                        headers: {'Content-Type': 'application/json'},
+                        body: JSON.stringify({
+                            url: document.getElementById('url').value,
+                            platform: document.getElementById('platform').value,
+                            fps: 2
+                        })
+                    });
+                    const data = await res.json();
+                    if(data.success) {
+                        status.innerText = "Success! Extracted " + data.total_frames + " frames.";
+                        data.frames.slice(0, 8).forEach(img => {
+                            results.innerHTML += `<img src="data:image/jpeg;base64,${img}" class="rounded-lg">`;
+                        });
+                    } else {
+                        status.innerText = "Error: " + data.detail;
+                    }
+                } catch(e) {
+                    status.innerText = "Network Error: " + e.message;
+                }
+                btn.disabled = false;
+                btn.innerText = "Process Video";
+            }
+        </script>
+    </body>
+    </html>
+    """
+# ── 3. MEDIA PROCESSING ROUTE ──
 @app.post("/process-video")
 def process_video(req: VideoRequest):
     job_id = str(uuid.uuid4())
     work_dir = f"/tmp/viralcat_{job_id}"
     os.makedirs(work_dir, exist_ok=True)
+    video_path = os.path.join(work_dir, "video.mp4")
     audio_path = os.path.join(work_dir, "audio.mp3")
     try:
+        # TikTok/IG require specific headers to not get 403 Forbidden
+        ydl_opts = {
+            'format': 'bestvideo[height<=720]+bestaudio/best[height<=720]',
+            'outtmpl': video_path,
+            'quiet': True,
+            'no_warnings': True,
+            'nocheckcertificate': True,
+            # Disguise as a standard mobile browser
+            'user_agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
+            'add_header': [
+                'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'Accept-Language: en-us',
+                'Connection: keep-alive',
+            ]
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([req.url])
+        if not os.path.exists(video_path):
+            # Find the actual file if extension differed
+            files = os.listdir(work_dir)
+            if files: video_path = os.path.join(work_dir, files[0])
+            else: raise ValueError("Download failed - No file saved.")
+        # PROBE DURATION
         probe = subprocess.run([
             "ffprobe", "-v", "error", "-show_entries",
             "format=duration", "-of", "default=noprint_wrappers=1:nokey=1",
         ], capture_output=True, text=True, check=True)
         duration = float(probe.stdout.strip() or 0)
         if duration > 120 and not req.is_pro:
+            raise ValueError(f"Video ({duration:.1f}s) exceeds 120s limit.")
+        # EXTRACT FRAMES (2 per second)
         subprocess.run([
             "ffmpeg", "-y", "-i", video_path,
             "-vf", f"fps={req.fps}",
+            "-q:v", "4", f"{work_dir}/frame_%04d.jpg"
         ], check=True, capture_output=True)
+        # EXTRACT AUDIO
         subprocess.run([
             "ffmpeg", "-y", "-i", video_path,
             "-q:a", "0", "-map", "a", "-ac", "1", "-b:a", "64k", audio_path
         ], check=True, capture_output=True)
+        # COLLECT DATA
         frame_files = sorted([f for f in os.listdir(work_dir) if f.startswith("frame_") and f.endswith(".jpg")])
+        # Max limit for AI context windows
+        if len(frame_files) > 80: frame_files = frame_files[:80]
         frames_b64 = [file_to_base64(os.path.join(work_dir, f)) for f in frame_files]
+        audio_b64 = file_to_base64(audio_path)
         return {
             "success": True,
         }
     except Exception as e:
+        print(f"ERROR: {str(e)}")
+        return {"success": False, "error": str(e)}
     finally:
+        # 🚨 GARBAGE COLLECTION
         if os.path.exists(work_dir):
             shutil.rmtree(work_dir, ignore_errors=True)