Update app.py

app.py

@@ -3,114 +3,103 @@ import subprocess
 import os
 import uuid
 import json
-import re
 
+# Auto-install Node modules
 if not os.path.exists("node_modules"):
     subprocess.run(["npm", "install"], check=True)
 
-def calculate_relevance(query, title, description):
-    """Simple scoring based on keyword matches in title/description"""
-    score = 0
-    words = re.findall(r'\w+', query.lower())
-    target_text = (title + " " + description).lower()
-    
-    for word in words:
-        if word in target_text:
-            score += 1
-            # Extra points for title matches
-            if word in title.lower():
-                score += 2
-    return score
-
 def get_video_dimensions(url):
     try:
-        cmd = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "json", url]
+        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, timeout=10)
         data = json.loads(result.stdout)
         return data['streams'][0]['width'], data['streams'][0]['height']
-    except: return 0, 0
+    except:
+        return 0, 0
 
 def process_video(query, orientation, start_time, end_time, mute_audio, progress=gr.Progress()):
-    if not query: return None, "⚠️ Enter a keyword."
+    if not query:
+        return None, "⚠️ Enter a keyword."
+    
+    progress(0, desc="🔍 Searching Pinterest...")
+    search_query = query if "video" in query.lower() else f"{query} video"
     
-    progress(0, desc="🔍 Searching and Reading Metadata...")
     try:
-        result = subprocess.run(["node", "scraper.js", query], capture_output=True, text=True, timeout=240)
+        # 1. Scrape
+        result = subprocess.run(
+            ["node", "scraper.js", search_query],
+            capture_output=True, text=True, timeout=240
+        )
+        all_urls = [line.strip() for line in result.stdout.split('\n') if line.strip().startswith("http")]
         
-        # Parse JSON results from Node
-        raw_outputs = [line.strip() for line in result.stdout.split('\n') if line.strip().startswith("{")]
-        video_candidates = []
-        for raw in raw_outputs:
-            try:
-                video_candidates.append(json.loads(raw))
-            except: continue
-
-        if not video_candidates:
+        if not all_urls:
             return None, "❌ No videos found."
 
-        # 1. Filter by Orientation and Calculate Scores
-        scored_candidates = []
-        for i, item in enumerate(video_candidates):
-            progress((i+1)/len(video_candidates), desc=f"Matching relevance for {i+1} videos...")
-            
-            # Check orientation
-            w, h = get_video_dimensions(item['url'])
-            if orientation == "Portrait" and h <= w: continue
-            if orientation == "Landscape" and w <= h: continue
-            
-            # Score this video
-            score = calculate_relevance(query, item['title'], item['description'])
-            item['score'] = score
-            scored_candidates.append(item)
-
-        if not scored_candidates:
-            return None, f"❌ Found videos, but none match the {orientation} filter."
-
-        # 2. Pick the HIGHEST scored video
-        best_match = max(scored_candidates, key=lambda x: x['score'])
-        selected_url = best_match['url']
+        # 2. Orientation Filter
+        selected_url = None
+        for i, url in enumerate(all_urls):
+            progress((i+1)/len(all_urls), desc=f"Filtering {i+1}/{len(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
         
-        # 3. Process Final Video
-        progress(0.9, desc="⚙️ Trimming and Finishing...")
-        output_filename = f"final_{uuid.uuid4().hex[:5]}.mp4"
+        if not selected_url:
+            return None, f"❌ Checked {len(all_urls)} videos, no {orientation} found."
+
+        # 3. Fast Processing (Original Quality)
+        progress(0.8, desc="⚙️ Trimming & Sharpening...")
+        output_filename = f"processed_{uuid.uuid4().hex[:5]}.mp4"
         
+        # We keep original resolution but add a light sharpening filter for clarity
+        # We also ensure the output is yuv420p for maximum compatibility
         ffmpeg_cmd = [
-            "ffmpeg", "-ss", str(start_time), "-to", str(end_time) if end_time > 0 else "999",
-            "-i", selected_url, "-vf", "unsharp=3:3:1.2:3:3:0.0,format=yuv420p",
-            "-c:v", "libx264", "-crf", "18", "-preset", "veryfast", "-y", output_filename
+            "ffmpeg",
+            "-ss", str(start_time),
+            "-to", str(end_time) if end_time > 0 else "999",
+            "-i", selected_url,
+            "-vf", "unsharp=3:3:1.2:3:3:0.0,format=yuv420p",
+            "-c:v", "libx264",
+            "-crf", "18", 
+            "-preset", "veryfast",
+            "-y", output_filename
         ]
-        
-        if mute_audio: ffmpeg_cmd.insert(-1, "-an")
+
+        if mute_audio:
+            ffmpeg_cmd.insert(-1, "-an")
         else:
             ffmpeg_cmd.insert(-1, "-c:a")
             ffmpeg_cmd.insert(-1, "aac")
 
         subprocess.run(ffmpeg_cmd, check=True)
-        
-        info_msg = f"✅ Match Found! Score: {best_match['score']}\nTitle: {best_match['title'][:50]}..."
-        return output_filename, info_msg
+        return output_filename, f"✅ Success! (Checked {i+1} pins)"
 
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
 
 # --- UI ---
 with gr.Blocks(theme=gr.themes.Default()) as demo:
-    gr.Markdown("# 📌 Smart Pinterest Matcher")
-    gr.Markdown("Reads video titles & descriptions to find the absolute best match for your query.")
+    gr.Markdown("# 📌 Pinterest Video Master")
     
     with gr.Row():
         with gr.Column():
-            q = gr.Textbox(label="Deep Search Query", placeholder="e.g. Cinematic Rain in Japan")
+            q = gr.Textbox(label="Topic", placeholder="e.g. Minecraft")
             o = gr.Dropdown(choices=["Any", "Portrait", "Landscape"], value="Any", label="Orientation")
             with gr.Row():
                 s = gr.Number(label="Start (sec)", value=0)
                 e = gr.Number(label="End (sec)", value=5)
             mute = gr.Checkbox(label="Mute Audio", value=False)
-            btn = gr.Button("🚀 Smart Search & Process", variant="primary")
+            btn = gr.Button("🚀 Search & Process", variant="primary")
         
         with gr.Column():
-            out_v = gr.Video(label="Best Match Result")
-            out_s = gr.Textbox(label="Status / Metadata Match")
+            out_v = gr.Video(label="Result Video")
+            out_s = gr.Textbox(label="Status")
 
     btn.click(process_video, [q, o, s, e, mute], [out_v, out_s])