Update app.py

app.py

@@ -1,122 +1,267 @@
 import os
+import json
 import re
-from fastapi import FastAPI, Body, HTTPException, Query
-from googleapiclient.discovery import build
+from typing import List, Dict, Any
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from pydantic import BaseModel
 from dotenv import load_dotenv
-from typing import List, Dict, Any, Optional
+from supabase import create_client, Client
+from groq import Groq
+from google import genai
+import uvicorn
+import csv
 
-# Load environment variables from .env file
+# Load environment variables
 load_dotenv()
 
-app = FastAPI()
+app = FastAPI(title="Supabase Data Linker API (Structured Edition)")
 
-# YouTube Data API Key
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+# Configuration
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_ANON_KEY")
+GROQ_API_KEYS = os.getenv("GROQ_API_KEYS", "").split(",")
+GEMINI_API_KEYS = os.getenv("GEMINI_API_KEYS", "").split(",")
 
-def find_relevant_youtube_shorts(movie_title: str, order: str = "relevance", max_results: int = 10) -> List[Dict[str, Any]]:
-    """
-    Finds relevant YouTube Shorts for a given movie title using YouTube Data API v3.
+# Initialize Supabase
+if not SUPABASE_URL or not SUPABASE_KEY:
+    raise ValueError("Missing SUPABASE environment variables")
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-    Args:
-        movie_title (str): The title of the movie or TV series.
-        order (str): The order to sort the search results. Can be "relevance", "viewCount", or "rating".
-        max_results (int): The maximum number of shorts to return.
+class MultiProviderManager:
+    """Manages rotation for both Groq and Gemini keys."""
+    def __init__(self, groq_keys: List[str], gemini_keys: List[str]):
+        self.providers = {
+            "groq": [k.strip() for k in groq_keys if k.strip()],
+            "gemini": [k.strip() for k in gemini_keys if k.strip()]
+        }
+        self.indices = {"groq": 0, "gemini": 0}
+        self.current_provider = "groq" if self.providers["groq"] else "gemini"
 
-    Returns:
-        list: A list of dictionaries, each representing a found YouTube Short
-              with its title, link, video_id, channel, and published_at.
-    """
-    if not GOOGLE_API_KEY:
-        return []
+    def get_session(self):
+        if not self.providers[self.current_provider]:
+            if self.current_provider == "groq" and self.providers["gemini"]:
+                self.current_provider = "gemini"
+                print("🔀 Groq not available, switching to Gemini...")
+                return self.get_session()
+            raise ValueError("No API keys found for the current provider or fallback.")
+
+        key = self.providers[self.current_provider][self.indices[self.current_provider]]
+        
+        if self.current_provider == "groq":
+            return Groq(api_key=key), "groq"
+        else:
+            return genai.Client(api_key=key), "gemini"
 
-    youtube = build("youtube", "v3", developerKey=GOOGLE_API_KEY)
+    def rotate_current(self):
+        """Try next key in current provider, or switch provider."""
+        current_keys = self.providers[self.current_provider]
+        if self.indices[self.current_provider] + 1 < len(current_keys):
+            self.indices[self.current_provider] += 1
+            print(f"🔄 Rotating to {self.current_provider.upper()} Key #{self.indices[self.current_provider] + 1}")
+        else:
+            if self.current_provider == "groq" and self.providers["gemini"]:
+                self.current_provider = "gemini"
+                self.indices["gemini"] = 0
+                print("⚠️ Groq Keys exhausted. Switching to Gemini provider.")
+            else:
+                raise Exception(f"All keys for {self.current_provider} exhausted.")
 
-    # Refined search query: More focused on movie title and direct shorts indicators.
-    # We'll rely more on post-filtering for excluding long-form.
-    # The query now explicitly requests "#shorts" or "YouTube Shorts" alongside the movie title.
-    search_query = f'"{movie_title}" #shorts OR "{movie_title}" "YouTube Shorts"'
+api_manager = MultiProviderManager(GROQ_API_KEYS, GEMINI_API_KEYS)
 
+# --- Helper Functions ---
+
+def fetch_supabase_data(table_name: str):
     try:
-        request = youtube.search().list(
-            q=search_query,
-            part="snippet",
-            type="video",
-            videoDuration="short",  # Filters videos under 4 minutes
-            order=order,
-            maxResults=max_results * 5, # Fetch more to allow for aggressive filtering
-        )
-        response = request.execute()
-
-        potential_shorts = []
-        for item in response.get('items', []):
-            if item['id']['kind'] == 'youtube#video':
-                video_id = item['id']['videoId']
-                snippet = item['snippet']
-
-                potential_shorts.append({
-                    "title": snippet['title'],
-                    "link": f"https://www.youtube.com/watch?v={video_id}",
-                    "video_id": video_id,
-                    "channel_title": snippet['channelTitle'],
-                    "published_at": snippet['publishedAt'],
-                    "description": snippet['description'],
-                    "thumbnails": snippet['thumbnails']['default']['url'],
-                })
-
-        # Stronger post-API filtering
-        final_shorts = []
-        # Indicators that strongly suggest long-form content
-        long_form_indicators = [
-            "full movie", "full episode", "season", "documentary", 
-            "trailer review", "official trailer", "compilation", "movie review",
-            "best scenes", "explained", "summary", "recap", "analysis", "episodes",
-            "movie in 10 minutes", "full story", "watch full"
-        ]
-        # Strong indicators that it is a short video
-        shorts_indicators = ["#shorts", "youtube shorts", "short video", "short clip", "vertical video"]
-
-        movie_title_lower = movie_title.lower()
-
-        for short in potential_shorts:
-            title_lower = short['title'].lower()
-            description_lower = short['description'].lower()
-            
-            # Rule 1: Must contain a strong shorts indicator
-            has_strong_shorts_indicator = any(indicator in title_lower or indicator in description_lower for indicator in shorts_indicators)
-
-            # Rule 2: Ensure movie title (or part of it) is present in title/description for strong relevance
-            # Using split for multi-word titles to check for partial matches too
-            is_relevant_to_movie = movie_title_lower in title_lower or movie_title_lower in description_lower or \
-                                   any(word in title_lower or word in description_lower for word in movie_title_lower.split())
-
-
-            # Rule 3: Must NOT contain strong long-form indicators
-            is_not_long_form = not any(indicator in title_lower or indicator in description_lower for indicator in long_form_indicators)
-            
-            if has_strong_shorts_indicator and is_relevant_to_movie and is_not_long_form:
-                final_shorts.append(short)
-            
-            if len(final_shorts) >= max_results:
-                break
-
-        return final_shorts
+        response = supabase.table(table_name).select("*").execute()
+        return response.data
+    except Exception as e:
+        print(f"Error fetching {table_name}: {e}")
+        return []
 
+def load_existing_links_from_db():
+    try:
+        response = supabase.table("linked_results").select("short_id").execute()
+        return response.data
     except Exception as e:
-        print(f"An error occurred during YouTube Data API search for '{movie_title}': {e}")
+        print(f"Error loading links from DB: {e}")
         return []
 
-@app.get("/get_shorts_for_movie")
-async def get_shorts_for_movie(
-    movie_title: str = Query(..., description="Title of the movie or TV series"),
-    search_order: Optional[str] = Query("relevance", description="Order by relevance, viewCount, or rating"),
-    max_shorts: Optional[int] = Query(10, description="Maximum number of shorts to return")
-):
-    if not movie_title:
-        raise HTTPException(status_code=400, detail="'movie_title' query parameter is required.")
+def save_links_to_db(links: List[Dict[str, Any]]):
+    if not links: return 0
+    try:
+        data = [{
+            "short_id": l["short_id"],
+            "media_id": l["media_id"],
+            "short_title": l["short_title"],
+            "media_title": l["media_title"],
+            "short_link": l["short_link"],
+            "media_link": l["media_link"]
+        } for l in links]
+        response = supabase.table("linked_results").insert(data).execute()
+        return len(response.data)
+    except Exception as e:
+        print(f"❌ DB Save Error: {e}")
+        return 0
+
+# --- Linking Logic ---
+
+def call_ai(session, provider, prompt):
+    if provider == "groq":
+        completion = session.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model="llama-3.3-70b-versatile",
+            response_format={"type": "json_object"}
+        )
+        return json.loads(completion.choices[0].message.content)
+    else:
+        response = session.models.generate_content(
+            model="gemini-3-flash-preview",
+            contents=prompt,
+            config={'response_mime_type': 'application/json'}
+        )
+        return json.loads(response.text)
 
-    if not GOOGLE_API_KEY:
-        raise HTTPException(status_code=500, detail="Google API Key is not configured.")
+def perform_smart_linking(shorts, movies, batch_size=20):
+    all_matches = []
+    
+    # Process media for AI
+    movies_ref = [
+        {
+            "id": m["id"], 
+            "title": m["title"], 
+            "type": m.get("type", "unknown"),
+            "year": str(m.get("releasdate", ""))[:4],
+            "description": m.get("dec", "")[:150],
+            "url": m.get("url") or f"https://flixhq.to/{m.get('id_slug','')}"
+        } for m in movies
+    ]
+
+    # Process shorts for AI (Optimized for structured data)
+    shorts_list = []
+    for s in shorts:
+        shorts_list.append({
+            "id": s.get("id"),
+            "title": s.get("title", s.get("yt_title", "Unknown")),
+            "description": s.get("description", "")[:100], # Pass some description for context
+            "url": s.get("url") or s.get("yt_link", "N/A")
+        })
+
+    for i in range(0, len(shorts_list), batch_size):
+        batch = shorts_list[i : i + batch_size]
+        success = False
+        
+        while not success:
+            try:
+                session, provider = api_manager.get_session()
+                prompt = f"""
+                Match these 'shorts' to their corresponding 'movies/tv series' (media).
+                Reference Media: {json.dumps(movies_ref[:120])}
+                Target Shorts: {json.dumps(batch)}
+                Respond ONLY with JSON: {{"matches": [{{"short_id", "media_id", "short_title", "media_title", "short_link", "media_link"}}]}}
+                """
+                
+                result = call_ai(session, provider, prompt)
+                if "matches" in result:
+                    all_matches.extend(result["matches"])
+                success = True
+            except Exception as e:
+                err = str(e).lower()
+                if any(x in err for x in ["rate_limit", "429", "413"]):
+                    try:
+                        api_manager.rotate_current()
+                    except:
+                        print("🛑 All Keys/Providers exhausted for this batch.")
+                        break
+                else:
+                    print(f"❌ Error in batch {i}: {e}")
+                    break
+    return all_matches
+
+# --- Endpoints ---
+
+@app.get("/")
+def home():
+    return {"status": "online", "message": "Supabase Linked API (Structured Shorts Edition)"}
+
+@app.get("/status")
+def status():
+    existing = load_existing_links_from_db()
+    return {
+        "db_linked_count": len(existing),
+        "groq_keys": len(api_manager.providers["groq"]),
+        "gemini_keys": len(api_manager.providers["gemini"]),
+        "current_provider": api_manager.current_provider
+    }
+
+@app.get("/test-db")
+def test_db():
+    try:
+        test_data = {
+            "short_id": 999999,
+            "media_id": 1,
+            "short_title": "Test DB Access",
+            "media_title": "Test Movie",
+            "short_link": "http://test.com",
+            "media_link": "http://test.com"
+        }
+        supabase.table("linked_results").insert(test_data).execute()
+        supabase.table("linked_results").delete().eq("short_id", 999999).execute()
+        return {"status": "success", "message": "Database is working!"}
+    except Exception as e:
+        return {"status": "failed", "error": str(e)}
+
+@app.get("/test-integration")
+def test_integration():
+    if not api_manager.providers["gemini"]:
+        return {"error": "No Gemini Keys configured"}
+    try:
+        client = genai.Client(api_key=api_manager.providers["gemini"][0])
+        prompt = """Generate one realistic mock linked result JSON."""
+        response = client.models.generate_content(
+            model="gemini-3-flash-preview",
+            contents=prompt,
+            config={'response_mime_type': 'application/json'}
+        )
+        mock_data = json.loads(response.text)
+        # Handle cases where AI returns a list or direct object
+        if isinstance(mock_data, list): mock_data = mock_data[0]
+        
+        # Ensure keys match DB
+        test_entry = {
+            "short_id": mock_data.get("short_id", 888888),
+            "media_id": mock_data.get("media_id", 12345),
+            "short_title": mock_data.get("short_title", "Mock Short"),
+            "media_title": mock_data.get("media_title", "Mock Media"),
+            "short_link": mock_data.get("short_link", "http://yt.com"),
+            "media_link": mock_data.get("media_link", "http://flix.com")
+        }
+        res = supabase.table("linked_results").insert(test_entry).execute()
+        return {"status": "success", "data_generated": test_entry}
+    except Exception as e:
+        return {"status": "failed", "error": str(e)}
 
-    relevant_shorts = find_relevant_youtube_shorts(movie_title, order=search_order, max_results=max_shorts)
+@app.post("/link-data")
+def trigger():
+    shorts = fetch_supabase_data("shorts")
+    media = fetch_supabase_data("media")
+    
+    if not shorts or not media:
+        raise HTTPException(status_code=500, detail="Data missing")
+        
+    existing_ids = {str(l["short_id"]) for l in load_existing_links_from_db()}
+    new_shorts = [s for s in shorts if str(s.get("id")) not in existing_ids]
+    
+    if not new_shorts:
+        return {"message": "All caught up!"}
+        
+    print(f"🚀 Processing {len(new_shorts)} new structured shorts...")
+    matches = perform_smart_linking(new_shorts, media)
+    saved = save_links_to_db(matches)
+    
+    return {
+        "newly_linked": saved,
+        "total_in_db": len(load_existing_links_from_db())
+    }
 
-    return {"movie_title": movie_title, "related_shorts": relevant_shorts}
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)