Update app.py

app.py

@@ -5,11 +5,10 @@ import base64
 import os
 import uuid
 import shutil
-import yt_dlp
-import socket 
+from pytube import YouTube
+import socket
 
-# 🚨 THE FIX: Force IPv4 globally for this Python process
-# This prevents the "[Errno -5] No address associated with hostname" error
+# Force IPv4 to prevent DNS errors on cloud hosting
 orig_getaddrinfo = socket.getaddrinfo
 def hooked_getaddrinfo(*args, **kwargs):
     res = orig_getaddrinfo(*args, **kwargs)
@@ -20,11 +19,11 @@ app = FastAPI()
 
 @app.get("/")
 def greet_json():
-    return {"status": "online", "message": "Viral Cat Media Server 1.6 - IPv4 Forced"}
+    return {"status": "online", "engine": "PyTube + FFmpeg"}
 
 class VideoRequest(BaseModel):
     url: str
-    platform: str
+    platform: str # Note: PyTube will ignore this and assume YouTube
     is_pro: bool = False
     fps: int = 2
 
@@ -38,38 +37,24 @@ def process_video(req: VideoRequest):
     work_dir = f"/tmp/viralcat_{job_id}"
     os.makedirs(work_dir, exist_ok=True)
     
-    video_path = f"{work_dir}/video.mp4"
-    audio_path = f"{work_dir}/audio.mp3"
+    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 Video
-        # We use a very light config to avoid triggering YouTube's bot detection
-        ydl_opts = {
-            'format': 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480][ext=mp4]/best',
-            'outtmpl': video_path,
-            'quiet': True,
-            'no_warnings': True,
-            # Bypasses cloud IP blocking
-            'extractor_args': {'youtube': ['player_client=android,ios']},
-            'nocheckcertificate': True,
-            'cachedir': False
-        }
-        
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([req.url])
-            
-        # Find the downloaded file (in case extension changed)
-        downloaded_files = [f for f in os.listdir(work_dir) if os.path.isfile(os.path.join(work_dir, f))]
-        if not downloaded_files:
-            raise ValueError("File not found after download attempt.")
+        # 1. Download using PyTube
+        print(f"[PYTUBE] Downloading: {req.url}")
+        yt = YouTube(req.url)
         
-        actual_video_path = os.path.join(work_dir, downloaded_files[0])
-        
-        # 2. Extract Duration
+        # 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", 
-            actual_video_path
+            video_path
         ], capture_output=True, text=True, check=True)
         
         duration = float(probe.stdout.strip() or 0)
@@ -77,42 +62,43 @@ def process_video(req: VideoRequest):
         if duration > 120 and not req.is_pro:
             raise ValueError(f"Video is {duration:.1f}s. Max 120s for free users.")
 
-        # 3. Extract Frames (2fps)
+        # 3. Extract Frames (FPS based)
+        # Using -q:v 2 for high quality frames so AI sees clearly
         subprocess.run([
-            "ffmpeg", "-y", "-i", actual_video_path, 
+            "ffmpeg", "-y", "-i", video_path, 
             "-vf", f"fps={req.fps}", 
-            "-q:v", "4", # Slightly lower quality (4) to keep base64 payload size reasonable
-            f"{work_dir}/frame_%04d.jpg"
+            "-q:v", "2", f"{work_dir}/frame_%04d.jpg"
         ], check=True, capture_output=True)
 
-        # 4. Extract Audio
+        # 4. Extract Audio (64k mono mp3 for small payload)
         subprocess.run([
-            "ffmpeg", "-y", "-i", actual_video_path, 
+            "ffmpeg", "-y", "-i", video_path, 
             "-q:a", "0", "-map", "a", "-ac", "1", "-b:a", "64k", audio_path
         ], check=True, capture_output=True)
 
-        # 5. Gather frames and convert
+        # 5. Convert to Base64
         frame_files = sorted([f for f in os.listdir(work_dir) if f.startswith("frame_") and f.endswith(".jpg")])
         
-        # AI limits: If there are too many frames, the AI payload will crash. 
-        # We cap it at 50 frames max for this request.
-        if len(frame_files) > 50:
-            frame_files = frame_files[:50]
+        # 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]
+        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,
             "total_frames": len(frames_b64),
+            "duration": duration,
             "frames": frames_b64,
             "audio": audio_b64
         }
 
     except Exception as e:
+        print(f"[ERROR] {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
         
     finally:
-        # 🚨 GARBAGE COLLECTION: Wipe the folder immediately
+        # CLEANUP
         if os.path.exists(work_dir):
             shutil.rmtree(work_dir, ignore_errors=True)