Update app.py

app.py

@@ -4,46 +4,59 @@ import os
 import uuid
 import json
 
-# Startup: Install Node modules if missing
 if not os.path.exists("node_modules"):
     subprocess.run(["npm", "install"], check=True)
 
 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 calculate_relevance(query, title, desc):
+    """Counts how many query words appear in the title or description"""
+    score = 0
+    words = query.lower().split()
+    combined_text = (title + " " + desc).lower()
+    for word in words:
+        if word in combined_text:
+            score += 1
+    return score
 
 def process_video(query, orientation, start_time, end_time, mute_audio, progress=gr.Progress()):
-    if not query:
-        return None, "⚠️ Please enter a keyword."
+    if not query: return None, "⚠️ Enter a keyword."
     
-    progress(0, desc="🔍 Searching deep on Pinterest...")
-    search_query = query if "video" in query.lower() else f"{query} video"
+    progress(0, desc="🔍 Searching & Analyzing Data...")
     
     try:
-        # 1. Run Node Scraper
-        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")]
+        result = subprocess.run(["node", "scraper.js", query], capture_output=True, text=True, timeout=240)
+        lines = [line.strip() for line in result.stdout.split('\n') if "|" in line]
         
-        if not all_urls:
-            return None, "❌ No videos found in search."
+        if not lines: return None, "❌ No videos found."
+
+        # Parse the structured data: [URL, Title, Description]
+        candidate_videos = []
+        for line in lines:
+            parts = line.split('|')
+            if len(parts) >= 3:
+                url, title, desc = parts[0], parts[1], parts[2]
+                score = calculate_relevance(query, title, desc)
+                candidate_videos.append({"url": url, "score": score})
 
-        # 2. Filter for orientation match
+        # Sort videos so the ones with the highest relevance score come first
+        candidate_videos = sorted(candidate_videos, key=lambda x: x['score'], reverse=True)
+
+        # 2. Filter for orientation match based on sorted list
         selected_url = None
-        for i, url in enumerate(all_urls):
-            progress((i+1)/len(all_urls), desc=f"Checking video {i+1} for {orientation}...")
+        for i, video in enumerate(candidate_videos):
+            url = video['url']
+            progress((i+1)/len(candidate_videos), desc=f"Matching relevance & orientation...")
+            
             if orientation == "Any":
                 selected_url = url; break
+            
             w, h = get_video_dimensions(url)
             if orientation == "Portrait" and h > w:
                 selected_url = url; break
@@ -51,67 +64,47 @@ def process_video(query, orientation, start_time, end_time, mute_audio, progress
                 selected_url = url; break
         
         if not selected_url:
-            return None, f"❌ Checked {len(all_urls)} videos, but no {orientation} found."
+            return None, f"❌ Found videos, but none matched the {orientation} requirement."
 
-        # 3. ULTRA 4K ENHANCEMENT & AUDIO HANDLING
-        progress(0.8, desc="💎 Upscaling to 4K & Applying Filters...")
-        output_filename = f"final_4k_{uuid.uuid4().hex[:5]}.mp4"
+        # 3. Final Process
+        progress(0.9, desc="⚙️ Finalizing Video...")
+        output_filename = f"smart_result_{uuid.uuid4().hex[:5]}.mp4"
         
-        # Filter chain for 4K 9:16 Portrait + Sharpening
-        filter_complex = (
-            "scale=2160:3840:force_original_aspect_ratio=increase," 
-            "crop=2160:3840,"
-            "unsharp=5:5:1.5:5:5:0.0"
-        )
-
         ffmpeg_cmd = [
-            "ffmpeg",
-            "-ss", str(start_time),
-            "-to", str(end_time) if end_time > 0 else "999",
-            "-i", selected_url,
-            "-vf", filter_complex,
-            "-c:v", "libx264",
-            "-preset", "medium",
-            "-crf", "18",
-            "-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
         ]
-
-        # Audio Logic
-        if mute_audio:
-            ffmpeg_cmd.insert(-1, "-an") # Add Mute flag before output filename
-        else:
-            ffmpeg_cmd.insert(-1, "-c:a")
-            ffmpeg_cmd.insert(-1, "aac") # Keep and re-encode audio
+        
+        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)
-        return output_filename, f"✅ Done! Found {orientation} video and processed with sound={'OFF' if mute_audio else 'ON'}"
+        return output_filename, f"✅ Best Match Found! (Relevance Score: {video['score']})"
 
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
 
-# --- Gradio UI ---
+# --- UI ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📌 Pinterest Ultra-HD 4K Video Tool")
-    gr.Markdown("Search Pinterest, filter orientation, trim exactly, and upscale to **Sharpened 4K 9:16**.")
+    gr.Markdown("# 📌 Smart Pinterest Video Downloader")
+    gr.Markdown("This version reads Pin titles and descriptions to find the most relevant video for your query.")
     
     with gr.Row():
         with gr.Column():
-            q = gr.Textbox(label="Topic", placeholder="e.g. Rainy Mood")
-            o = gr.Dropdown(choices=["Any", "Portrait", "Landscape"], value="Landscape", label="Orientation Filter")
-            
+            q = gr.Textbox(label="Smart Search Query", placeholder="e.g. blue ocean waves")
+            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, 0=Full)", value=5)
-            
-            audio_toggle = gr.Checkbox(label="Mute Audio", value=False)
-            btn = gr.Button("🚀 Deep Search & Process", variant="primary")
+                e = gr.Number(label="End (sec)", value=5)
+            mute = gr.Checkbox(label="Mute Audio", value=False)
+            btn = gr.Button("🚀 Smart Search & Process", variant="primary")
         
         with gr.Column():
-            out_v = gr.Video(label="Enhanced Result")
-            out_s = gr.Textbox(label="Status Log")
+            out_v = gr.Video(label="Result Video")
+            out_s = gr.Textbox(label="Status")
 
-    # Link UI components to the function
-    btn.click(process_video, [q, o, s, e, audio_toggle], [out_v, out_s])
+    btn.click(process_video, [q, o, s, e, mute], [out_v, out_s])
 
 if __name__ == "__main__":
     demo.launch()