Create app.py

app.py

@@ -0,0 +1,177 @@
+import httpx
+import json
+import logging
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel
+
+# --- Configuration ---
+# The base URL of your existing TypeScript/Node API (Vega Providers)
+VEGA_API_BASE = "https://sanch1tx-vega-providers.hf.space"
+# The URL for the provider list
+MODFLIX_JSON_URL = "https://raw.githubusercontent.com/himanshu8443/providers/main/modflix.json"
+
+# Fallback providers in case GitHub is down or inaccessible
+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},
+]
+
+# --- FastAPI App Setup ---
+app = FastAPI(title="Vega Providers Gateway", description="A Python bridge for Vega Providers")
+
+# Enable CORS for your frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all origins for now (adjust for production)
+    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):
+    name: str
+    baseUrl: str
+    isActive: bool
+
+# --- Helper Functions ---
+
+async def fetch_providers_list():
+    """Fetches the provider list from GitHub with fallback."""
+    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
+                
+            return normalized
+
+        except Exception as e:
+            logger.error(f"Failed to fetch providers: {e}. Using fallback.")
+            return FALLBACK_PROVIDERS
+
+# --- Endpoints ---
+
+@app.get("/", tags=["Health"])
+async def root():
+    return {"status": "ok", "message": "Vega Python Gateway is running"}
+
+@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()
+
+@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."""
+    url = f"{VEGA_API_BASE}/{provider}/posts"
+    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 [] 
+        except Exception as e:
+            logger.error(f"Error fetching posts for {provider}: {e}")
+            return []
+
+@app.get("/{provider}/meta", tags=["Provider"])
+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))
+
+@app.get("/{provider}/episodes", tags=["Provider"])
+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 []
+
+@app.get("/{provider}/stream", tags=["Provider"])
+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 []