Update app.py

app.py

@@ -1,5 +1,4 @@
 import httpx
-import json
 import logging
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
@@ -7,171 +6,218 @@ from typing import List, Optional, Dict, Any
 from pydantic import BaseModel
 
 # --- Configuration ---
-# The base URL of your existing TypeScript/Node API (Vega Providers)
+# Upstream API where the provider logic (JS/TS) lives
 VEGA_API_BASE = "https://sanch1tx-vega-providers.hf.space"
-# The URL for the provider list
+# List of providers
 MODFLIX_JSON_URL = "https://raw.githubusercontent.com/himanshu8443/providers/main/modflix.json"
 
-# Fallback providers in case GitHub is down or inaccessible
+# --- Hardcoded Fallback Catalogs ---
+# Keys MUST match the 'value' (folder name) of the provider.
+DEFAULT_CATALOGS = {
+    "drive": [
+        {"title": "Latest", "filter": ""},
+        {"title": "Anime", "filter": "category/anime/"},
+        {"title": "Netflix", "filter": "category/netflix/"},
+        {"title": "4K", "filter": "category/2160p-4k/"},
+    ],
+    "movies4u": [
+        {"title": "Featured", "filter": "featured"},
+        {"title": "Movies", "filter": "movies"},
+        {"title": "TV Shows", "filter": "tv-shows"},
+    ],
+    "uhd": [
+        {"title": "Latest", "filter": ""},
+        {"title": "Hindi", "filter": "category/hindi-movies/"},
+        {"title": "Dual Audio", "filter": "category/dual-audio/"},
+    ],
+    "vega": [
+        {"title": "New", "filter": ""},
+        {"title": "Netflix", "filter": "web-series/netflix"},
+        {"title": "Amazon Prime", "filter": "web-series/amazon-prime-video"},
+    ],
+    "flimmo": [
+        {"title": "Home", "filter": "home"},
+        {"title": "Movies", "filter": "movies"},
+        {"title": "TV Series", "filter": "tv-series"},
+    ]
+}
+
+# Generic default if provider specific catalog is missing
+GENERIC_CATALOG = [
+    {"title": "Latest", "filter": ""},
+    {"title": "Trending", "filter": "trending"},
+    {"title": "Movies", "filter": "movies"},
+]
+
+# Fallback providers with correct IDs (value) matching folder names
 FALLBACK_PROVIDERS = [
-    {"name": "vega", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "uhd", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "movies4u", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "flimmo", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "tobias", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "goku", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "kissKh", "baseUrl": VEGA_API_BASE, "isActive": True},
-    {"name": "superVideoExtractor", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "Vega", "value": "vega", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "UHD Movies", "value": "uhd", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "Movies4U", "value": "movies4u", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "Drive", "value": "drive", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "Flimmo", "value": "flimmo", "baseUrl": VEGA_API_BASE, "isActive": True},
+    {"name": "Tobias", "value": "tobias", "baseUrl": VEGA_API_BASE, "isActive": True},
 ]
 
-# --- FastAPI App Setup ---
-app = FastAPI(title="Vega Providers Gateway", description="A Python bridge for Vega Providers")
+app = FastAPI(title="Vega Providers Gateway")
 
-# Enable CORS for your frontend
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allow all origins for now (adjust for production)
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Logger setup
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("vega_gateway")
 
-# --- Data Models ---
-# (Optional, but good for documentation)
-class Provider(BaseModel):
+class ProviderModel(BaseModel):
     name: str
+    value: str  # Critical: The unique ID used for URL routing
     baseUrl: str
     isActive: bool
 
-# --- Helper Functions ---
+@app.get("/")
+async def root():
+    return {"status": "ok", "message": "Vega Python Gateway Active"}
 
-async def fetch_providers_list():
-    """Fetches the provider list from GitHub with fallback."""
+@app.get("/providers", response_model=List[ProviderModel])
+async def get_providers():
     async with httpx.AsyncClient() as client:
         try:
-            logger.info(f"Fetching providers from {MODFLIX_JSON_URL}")
-            response = await client.get(MODFLIX_JSON_URL, timeout=5.0)
-            response.raise_for_status()
-            data = response.json()
-            
-            # Normalize data structure
-            providers = []
-            if isinstance(data, list):
-                providers = data
-            elif isinstance(data, dict) and "providers" in data:
-                providers = data["providers"]
-            elif isinstance(data, dict):
-                providers = list(data.values())
-            
-            # Normalize fields
-            normalized = []
-            for p in providers:
-                if not isinstance(p, dict): continue
-                name = p.get("name") or p.get("value") or p.get("id") or "Unknown"
-                base_url = p.get("baseUrl") or VEGA_API_BASE
-                is_active = p.get("isActive", not p.get("disabled", False))
-                normalized.append({"name": name, "baseUrl": base_url, "isActive": is_active})
-            
-            if not normalized:
-                logger.warning("Fetched data empty, using fallback.")
-                return FALLBACK_PROVIDERS
+            response = await client.get(MODFLIX_JSON_URL, timeout=4.0)
+            if response.status_code == 200:
+                data = response.json()
+                providers = []
                 
-            return normalized
-
+                # Handle different JSON structures (list or object)
+                raw_list = []
+                if isinstance(data, list):
+                    raw_list = data
+                elif isinstance(data, dict):
+                    raw_list = data.get("providers", list(data.values()))
+
+                for p in raw_list:
+                    if isinstance(p, dict):
+                        name = p.get("name") or "Unknown"
+                        
+                        # CRITICAL FIX: 
+                        # We must capture the 'value' or 'id' field if it exists.
+                        # This 'value' typically matches the folder name on the server (e.g. 'drive', 'luxMovies').
+                        # If we just use 'name', we might send 'MoviesDrive' which the server doesn't know.
+                        val = p.get("value") or p.get("id") or name
+                        
+                        # Special handling for known mismatches if JSON is messy or inconsistent
+                        if name.lower() == "moviesdrive": val = "drive"
+                        if name.lower() == "uhdmovies": val = "uhd"
+                        
+                        # Ensure value is URL safe string
+                        val = str(val).strip()
+
+                        if val:
+                            providers.append({
+                                "name": name,
+                                "value": val,
+                                "baseUrl": p.get("baseUrl") or VEGA_API_BASE,
+                                "isActive": True
+                            })
+                
+                if providers:
+                    return providers
+                    
         except Exception as e:
-            logger.error(f"Failed to fetch providers: {e}. Using fallback.")
-            return FALLBACK_PROVIDERS
+            logger.error(f"Provider fetch error: {e}")
+            
+    return FALLBACK_PROVIDERS
 
-# --- Endpoints ---
+@app.get("/{provider}/catalog")
+async def get_catalog(provider: str):
+    """
+    Fetches catalog with strict fallbacks.
+    If the upstream API fails, it returns the hardcoded DEFAULT_CATALOGS for that provider.
+    """
+    url = f"{VEGA_API_BASE}/{provider}/catalog"
+    
+    # 1. Try to fetch from upstream
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(url, timeout=5.0)
+            
+            if resp.status_code == 200:
+                data = resp.json()
+                
+                # Normalize response to { catalog: [...] }
+                # Case A: Response is direct list [ {...}, {...} ]
+                if isinstance(data, list) and len(data) > 0:
+                    return {"catalog": data}
+                # Case B: Response is object { catalog: [...] }
+                if isinstance(data, dict) and "catalog" in data and len(data["catalog"]) > 0:
+                    return data
+            
+            logger.warning(f"Upstream catalog empty/failed for {provider} (Status: {resp.status_code})")
 
-@app.get("/", tags=["Health"])
-async def root():
-    return {"status": "ok", "message": "Vega Python Gateway is running"}
+    except Exception as e:
+        logger.error(f"Error fetching catalog for {provider}: {e}")
 
-@app.get("/providers", response_model=List[Provider], tags=["Core"])
-async def get_providers():
-    """Returns a clean list of active providers."""
-    return await fetch_providers_list()
+    # 2. Fallback: Return hardcoded catalog for this provider
+    # Try exact match, then try default
+    fallback = DEFAULT_CATALOGS.get(provider) or DEFAULT_CATALOGS.get("default") or GENERIC_CATALOG
+    return {"catalog": fallback}
 
-@app.get("/{provider}/catalog", tags=["Provider"])
-async def get_catalog(provider: str):
-    """Fetches the catalog for a specific provider."""
-    url = f"{VEGA_API_BASE}/{provider}/catalog"
-    async with httpx.AsyncClient() as client:
-        try:
-            resp = await client.get(url, timeout=10.0)
-            if resp.status_code != 200:
-                # Return empty catalog instead of erroring out
-                logger.warning(f"Catalog fetch failed for {provider}: {resp.status_code}")
-                return {"catalog": []}
-            return resp.json()
-        except Exception as e:
-            logger.error(f"Error fetching catalog for {provider}: {e}")
-            return {"catalog": []}
-
-@app.get("/{provider}/posts", tags=["Provider"])
-async def get_posts(
-    provider: str, 
-    filter: str = Query(..., description="The filter path from catalog"), 
-    page: int = 1
-):
-    """Fetches posts (movies/series) for a provider and filter."""
+@app.get("/{provider}/posts")
+async def get_posts(provider: str, filter: str = "", page: int = 1):
     url = f"{VEGA_API_BASE}/{provider}/posts"
+    # Some providers fail if filter is empty, default to "latest" or similar if needed
     params = {"filter": filter, "page": page}
+    
     async with httpx.AsyncClient() as client:
         try:
             resp = await client.get(url, params=params, timeout=15.0)
-            data = resp.json()
-            # Ensure it's always a list
-            if isinstance(data, list): return data
-            return [] 
+            if resp.status_code == 200:
+                data = resp.json()
+                if isinstance(data, list): return data
         except Exception as e:
-            logger.error(f"Error fetching posts for {provider}: {e}")
-            return []
+            logger.error(f"Error posts {provider}: {e}")
+            pass
+    return []
 
-@app.get("/{provider}/meta", tags=["Provider"])
+@app.get("/{provider}/meta")
 async def get_meta(provider: str, link: str):
-    """Fetches metadata for a specific item."""
     url = f"{VEGA_API_BASE}/{provider}/meta"
     params = {"link": link}
     async with httpx.AsyncClient() as client:
         try:
             resp = await client.get(url, params=params, timeout=15.0)
-            resp.raise_for_status()
-            return resp.json()
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
+            if resp.status_code == 200:
+                return resp.json()
+        except Exception:
+            pass
+    raise HTTPException(status_code=404, detail="Meta not found")
 
-@app.get("/{provider}/episodes", tags=["Provider"])
+@app.get("/{provider}/episodes")
 async def get_episodes(provider: str, url: str):
-    """Fetches episodes if they require a separate call."""
     api_url = f"{VEGA_API_BASE}/{provider}/episodes"
     params = {"url": url}
     async with httpx.AsyncClient() as client:
         try:
             resp = await client.get(api_url, params=params, timeout=15.0)
-            data = resp.json()
-            if isinstance(data, list): return data
-            return []
-        except Exception as e:
-            logger.error(f"Error fetching episodes: {e}")
-            return []
+            if resp.status_code == 200 and isinstance(resp.json(), list):
+                return resp.json()
+        except:
+            pass
+    return []
 
-@app.get("/{provider}/stream", tags=["Provider"])
+@app.get("/{provider}/stream")
 async def get_stream(provider: str, link: str, type: str = "movie"):
-    """Fetches stream links (runs extractors on the upstream server)."""
     api_url = f"{VEGA_API_BASE}/{provider}/stream"
     params = {"link": link, "type": type}
     async with httpx.AsyncClient() as client:
         try:
-            resp = await client.get(api_url, params=params, timeout=30.0) # Longer timeout for extraction
-            data = resp.json()
-            if isinstance(data, list): return data
-            return []
-        except Exception as e:
-            logger.error(f"Error fetching stream: {e}")
-            return []
+            # Longer timeout for extraction
+            resp = await client.get(api_url, params=params, timeout=45.0)
+            if resp.status_code == 200 and isinstance(resp.json(), list):
+                return resp.json()
+        except:
+            pass
+    return []