Update app.py

app.py

@@ -2,96 +2,101 @@ import gradio as gr
 import subprocess
 import os
 import uuid
+import json
 
 def initialize_env():
     if not os.path.exists("node_modules"):
-        print("Installing node_modules...")
         subprocess.run(["npm", "install"], check=True)
 
 initialize_env()
 
-def process_video(query, start_time, end_time):
+def get_video_dimensions(url):
+    """Uses ffprobe to check if video is Portrait or Landscape"""
+    try:
+        cmd = [
+            "ffprobe", "-v", "error", "-select_streams", "v:0",
+            "-show_entries", "stream=width,height", "-of", "json", url
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        data = json.loads(result.stdout)
+        width = data['streams'][0]['width']
+        height = data['streams'][0]['height']
+        return width, height
+    except:
+        return 0, 0
+
+def process_video(query, orientation, start_time, end_time):
     if not query:
         return None, "⚠️ Please enter a keyword."
     
-    # 1. Scrape the URL using Node.js
     search_query = query if "video" in query.lower() else f"{query} video"
+    
     try:
+        # 1. Get multiple potential URLs from Node
+        # I modified the scraper to return multiple links separated by commas
         result = subprocess.run(
             ["node", "scraper.js", search_query],
             capture_output=True, text=True, timeout=90
         )
         
-        stdout = result.stdout.strip()
-        lines = stdout.split('\n')
-        video_url = None
-        for line in lines:
-            if line.strip().startswith("http"):
-                video_url = line.strip()
-                break
+        all_urls = [line.strip() for line in result.stdout.split('\n') if line.strip().startswith("http")]
         
-        if not video_url:
-            return None, f"❌ No video found. Logs: {result.stderr[:100]}"
+        if not all_urls:
+            return None, "❌ No videos found at all."
 
-        # 2. Trim the video using FFmpeg
-        # We create a unique filename for the trimmed video
-        output_filename = f"trimmed_{uuid.uuid4().hex[:8]}.mp4"
-        
-        print(f"Trimming video: {start_time}s to {end_time}s")
-        
-        # FFmpeg Command Explanation:
-        # -ss: Start time
-        # -to: End time
-        # -i: Input URL (FFmpeg can stream directly from the URL)
-        # -c:v libx264: Re-encode to ensure precision for decimals like 3.79
+        # 2. Filter by Orientation
+        selected_url = None
+        for url in all_urls:
+            if orientation == "Any":
+                selected_url = url
+                break
+            
+            w, h = get_video_dimensions(url)
+            if orientation == "Portrait" and h > w:
+                selected_url = url
+                break
+            if orientation == "Landscape" and w > h:
+                selected_url = url
+                break
         
+        if not selected_url:
+            return None, f"❌ Found videos, but none were {orientation}. Try another search."
+
+        # 3. Trim the selected video
+        output_filename = f"final_{uuid.uuid4().hex[:8]}.mp4"
         ffmpeg_cmd = [
-            "ffmpeg",
-            "-ss", str(start_time),
-            "-to", str(end_time),
-            "-i", video_url,
-            "-c:v", "libx264",
-            "-c:a", "aac",
-            "-strict", "experimental",
-            "-y", # Overwrite if exists
-            output_filename
+            "ffmpeg", "-ss", str(start_time), "-to", str(end_time),
+            "-i", selected_url, "-c:v", "libx264", "-c:a", "aac", "-y", output_filename
         ]
         
-        # If end_time is 0, we assume the user wants the whole video from the start_time
         if end_time <= 0:
-            ffmpeg_cmd.pop(3) # Remove "-to"
-            ffmpeg_cmd.pop(3) # Remove the end_time value
+            ffmpeg_cmd.pop(3); ffmpeg_cmd.pop(3)
 
         subprocess.run(ffmpeg_cmd, check=True)
+        return output_filename, f"✅ Match found! ({orientation})"
 
-        return output_filename, f"✅ Success! Trimmed from {start_time}s to {end_time}s"
-
-    except subprocess.CalledProcessError as e:
-        return None, f"❌ FFmpeg Error: Maybe the start/end time is longer than the video?"
     except Exception as e:
-        return None, f"❌ System Error: {str(e)}"
+        return None, f"❌ Error: {str(e)}"
 
 # --- Gradio UI ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📌 Pinterest Video Search & Trim")
+    gr.Markdown("# 📌 Pinterest Search + Orientation Filter")
     
     with gr.Row():
         with gr.Column():
-            query_input = gr.Textbox(label="Search Query", placeholder="e.g. Minecraft Gameplay")
+            query_input = gr.Textbox(label="Search Query", placeholder="Minecraft, Nature, etc.")
+            filter_input = gr.Dropdown(choices=["Any", "Portrait", "Landscape"], value="Any", label="Orientation Filter")
+            
             with gr.Row():
-                start_input = gr.Number(label="Start Second (e.g. 1.5)", value=0)
-                end_input = gr.Number(label="End Second (0 = Full video)", value=0)
-            btn = gr.Button("🚀 Search & Trim", variant="primary")
+                start_input = gr.Number(label="Start (sec)", value=0)
+                end_input = gr.Number(label="End (sec, 0=full)", value=0)
+            
+            btn = gr.Button("🚀 Find & Process", variant="primary")
         
         with gr.Column():
-            video_output = gr.Video(label="Trimmed Result")
+            video_output = gr.Video(label="Result")
             status_output = gr.Textbox(label="Status")
 
-    btn.click(
-        fn=process_video, 
-        inputs=[query_input, start_input, end_input], 
-        outputs=[video_output, status_output]
-    )
+    btn.click(process_video, [query_input, filter_input, start_input, end_input], [video_output, status_output])
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()