Update app.py

app.py

@@ -3,10 +3,24 @@ import subprocess
 import os
 import uuid
 import json
-from difflib import SequenceMatcher
+import re
 
-def calculate_similarity(a, b):
-    return SequenceMatcher(None, a.lower(), b.lower()).ratio()
+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:
@@ -19,74 +33,86 @@ def get_video_dimensions(url):
 def process_video(query, orientation, start_time, end_time, mute_audio, progress=gr.Progress()):
     if not query: return None, "⚠️ Enter a keyword."
     
-    progress(0, desc="🔍 Searching and analyzing metadata...")
+    progress(0, desc="🔍 Searching and Reading Metadata...")
     try:
         result = subprocess.run(["node", "scraper.js", query], capture_output=True, text=True, timeout=240)
         
-        candidates = []
-        for line in result.stdout.split('\n'):
-            if "|" in line:
-                url, metadata = line.strip().split("|", 1)
-                candidates.append({"url": url, "metadata": metadata})
+        # 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 candidates: return None, "❌ No videos found."
+        if not video_candidates:
+            return None, "❌ No videos found."
 
-        # Filter by Orientation AND Rank by Metadata Similarity
-        best_match = None
-        highest_score = -1
-        
-        for i, item in enumerate(candidates):
-            progress((i+1)/len(candidates), desc=f"Matching query with video data...")
+        # 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 first
+            # Check orientation
             w, h = get_video_dimensions(item['url'])
-            is_match = False
-            if orientation == "Any": is_match = True
-            elif orientation == "Portrait" and h > w: is_match = True
-            elif orientation == "Landscape" and w > h: is_match = True
+            if orientation == "Portrait" and h <= w: continue
+            if orientation == "Landscape" and w <= h: continue
             
-            if is_match:
-                # Calculate how well the title matches the user's search query
-                score = calculate_similarity(query, item['metadata'])
-                if score > highest_score:
-                    highest_score = score
-                    best_match = item['url']
-        
-        if not best_match:
-            return None, f"❌ Searched {len(candidates)} videos, but no matching orientation found."
+            # 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."
 
-        # 3. Final FFmpeg Process
-        progress(0.9, desc="⚙️ Trimming & Finalizing...")
-        output_filename = f"best_match_{uuid.uuid4().hex[:5]}.mp4"
+        # 2. Pick the HIGHEST scored video
+        best_match = max(scored_candidates, key=lambda x: x['score'])
+        selected_url = best_match['url']
+        
+        # 3. Process Final Video
+        progress(0.9, desc="⚙️ Trimming and Finishing...")
+        output_filename = f"final_{uuid.uuid4().hex[:5]}.mp4"
+        
         ffmpeg_cmd = [
             "ffmpeg", "-ss", str(start_time), "-to", str(end_time) if end_time > 0 else "999",
-            "-i", best_match, "-vf", "unsharp=3:3:1.2:3:3:0.0,format=yuv420p",
+            "-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")
-        else: ffmpeg_cmd.insert(-1, "-c:a"); ffmpeg_cmd.insert(-1, "aac")
+        else:
+            ffmpeg_cmd.insert(-1, "-c:a")
+            ffmpeg_cmd.insert(-1, "aac")
 
         subprocess.run(ffmpeg_cmd, check=True)
-        return output_filename, f"✅ Best Match Found (Score: {int(highest_score*100)}%)"
+        
+        info_msg = f"✅ Match Found! Score: {best_match['score']}\nTitle: {best_match['title'][:50]}..."
+        return output_filename, info_msg
 
-    except Exception as e: return None, f"❌ Error: {str(e)}"
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
 
+# --- UI ---
 with gr.Blocks(theme=gr.themes.Default()) as demo:
-    gr.Markdown("# 📌 Smart Pinterest Search")
+    gr.Markdown("# 📌 Smart Pinterest Matcher")
+    gr.Markdown("Reads video titles & descriptions to find the absolute best match for your query.")
+    
     with gr.Row():
         with gr.Column():
-            q = gr.Textbox(label="Deep Search Query", placeholder="e.g. Sunset Ocean Relaxing")
+            q = gr.Textbox(label="Deep Search Query", placeholder="e.g. Cinematic Rain in Japan")
             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")
+        
         with gr.Column():
-            out_v = gr.Video(label="Result")
-            out_s = gr.Textbox(label="Matching Score")
+            out_v = gr.Video(label="Best Match Result")
+            out_s = gr.Textbox(label="Status / Metadata Match")
 
     btn.click(process_video, [q, o, s, e, mute], [out_v, out_s])
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()