Update app.py

app.py

@@ -1,19 +1,21 @@
 from fastapi import FastAPI, Request, Query
-from fastapi.responses import JSONResponse, RedirectResponse, HTMLResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.middleware.cors import CORSMiddleware
-from datetime import datetime, timedelta
 import requests
 from bs4 import BeautifulSoup
 import os
 import logging
 import time
-from typing import Dict, List, Optional
+from typing import Optional
 
-# App configuration
-app = FastAPI(title="StreamFlix Addon", version="1.1.0")
+# Configuração do app FastAPI
+app = FastAPI(title="StreamFlix Addon", version="1.0.0")
 
-# Middleware
+# Configuração do logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Middleware CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -22,70 +24,38 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Mount static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Constants
-BASE_URL = os.getenv("BASE_URL", "")
-TMDB_API_KEY = os.getenv("TMDB_API_KEY", "")
+# Configurações (usar variáveis de ambiente no Hugging Face)
+BASE_URL = os.getenv("BASE_URL", "https://superflixapi.pw")
+TMDB_API_KEY = os.getenv("TMDB_API_KEY", "84ec49f90ebcffe1e7c61efca1c0a606")
 TMDB_API_URL = "https://api.themoviedb.org/3"
 USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 REQUEST_TIMEOUT = 15
 MAX_RETRIES = 2
 
-# Catalog settings
-CATALOG_PAGE_SIZE = 20
-RECENT_RELEASES_LIMIT = 20
-RECENT_MOVIES_DAYS = 30
-RECENT_TV_DAYS = 14
-TMDB_DISCOVER_CACHE_TIME = 3600
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Manifest with all features
+# Manifesto do Addon (atualizado para Hugging Face)
 MANIFEST = {
     "id": "community.streamflix.hf",
-    "version": "1.1.0",
+    "version": "1.0.0",
     "catalogs": [
         {
             "type": "movie",
             "id": "streamflix_movies",
             "name": "StreamFlix - Filmes",
-            "extra": [
-                {"name": "search", "isRequired": False},
-                {"name": "genre", "isRequired": False}
-            ]
+            "extra": [{"name": "search", "isRequired": False}]
         },
         {
             "type": "series",
             "id": "streamflix_series",
             "name": "StreamFlix - Séries",
-            "extra": [
-                {"name": "search", "isRequired": False},
-                {"name": "genre", "isRequired": False}
-            ]
-        },
-        {
-            "type": "movie",
-            "id": "streamflix_recent_movies",
-            "name": "Lançamentos Recentes - Filmes",
-            "extra": []
-        },
-        {
-            "type": "series",
-            "id": "streamflix_recent_series",
-            "name": "Lançamentos Recentes - Séries",
-            "extra": []
+            "extra": [{"name": "search", "isRequired": False}]
         }
     ],
     "resources": ["catalog", "stream", "meta"],
     "types": ["movie", "series"],
-    "name": "StreamFlix Premium",
-    "description": "O melhor addon para filmes e séries com conteúdo em português!",
-    "logo": "https://i.imgur.com/8t14k1R.png",
-    "background": "https://i.imgur.com/y6fryeO.jpeg",
+    "name": "StreamFlix (HF)",
+    "description": "Addon StreamFlix hospedado no Hugging Face",
+    "logo": "https://huggingface.co/spaces/username/streamflix-addon/raw/main/logo.png",
+    "background": "https://huggingface.co/spaces/username/streamflix-addon/raw/main/background.jpg",
     "idPrefixes": ["tt", "tmdb"],
     "behaviorHints": {"adult": False}
 }
@@ -96,6 +66,7 @@ class VOD:
         self.session = requests.Session()
         self.session.headers.update({"User-Agent": USER_AGENT})
         self.cache = {}
+        self.cache_timeout = 3600  # 1 hora
 
     def _request(self, url, method="get", data=None, referer=None, retry=0):
         headers = {"User-Agent": USER_AGENT}
@@ -206,6 +177,7 @@ class VOD:
             if not options_data or not options_data.get('data') or not options_data['data'].get('options'):
                 return None
 
+            # Find Portuguese option
             selected_option = None
             for option in options_data['data']['options']:
                 title = option.get('title', '').lower()
@@ -251,6 +223,7 @@ class VOD:
             if not player_items:
                 return None
 
+            # Find Portuguese player
             selected_player = None
             for player in player_items:
                 title = player.get_text(strip=True).lower()
@@ -281,167 +254,70 @@ class VOD:
             logger.error(f"Error in movie: {e}", exc_info=True)
             return None
 
-class CatalogManager:
-    def __init__(self):
-        self.cache = {}
-        self.genre_map = {}
-        self.last_genre_update = 0
-        
-    async def initialize_genres(self):
-        if time.time() - self.last_genre_update < 86400:
-            return
-            
-        try:
-            movie_url = f"{TMDB_API_URL}/genre/movie/list"
-            movie_params = {"api_key": TMDB_API_KEY, "language": "pt-BR"}
-            movie_resp = requests.get(movie_url, params=movie_params)
-            movie_genres = {g['id']: g['name'] for g in movie_resp.json().get('genres', [])}
-            
-            tv_url = f"{TMDB_API_URL}/genre/tv/list"
-            tv_params = {"api_key": TMDB_API_KEY, "language": "pt-BR"}
-            tv_resp = requests.get(tv_url, params=tv_params)
-            tv_genres = {g['id']: g['name'] for g in tv_resp.json().get('genres', [])}
-            
-            self.genre_map = {
-                'movie': movie_genres,
-                'tv': tv_genres
-            }
-            self.last_genre_update = time.time()
-        except Exception as e:
-            logger.error(f"Erro ao carregar gêneros: {e}")
+vod_api = VOD()
 
-    async def get_catalog(self, media_type: str, page: int = 1, search: str = None, genre: str = None) -> Dict:
-        cache_key = f"catalog_{media_type}_{page}_{search}_{genre}"
-        
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-            
-        await self.initialize_genres()
+def get_tmdb_media(media_type, page=1, search_query=None):
+    cache_key = f"tmdb_{media_type}_{page}_{search_query}"
+    if cache_key in vod_api.cache:
+        return vod_api.cache[cache_key]
         
-        try:
+    try:
+        if search_query:
+            url = f"{TMDB_API_URL}/search/{media_type}"
             params = {
                 "api_key": TMDB_API_KEY,
-                "language": "pt-BR",
+                "query": search_query,
                 "page": page,
-                "sort_by": "popularity.desc",
-                "include_adult": False,
-                "region": "BR"
+                "language": "pt-BR"
             }
-            
-            if search:
-                url = f"{TMDB_API_URL}/search/{media_type}"
-                params["query"] = search
-            else:
-                url = f"{TMDB_API_URL}/discover/{media_type}"
-                if genre and genre.isdigit():
-                    params["with_genres"] = genre
-            
-            if media_type == "movie":
-                params["primary_release_date.lte"] = datetime.now().strftime("%Y-%m-%d")
-                params["vote_count.gte"] = 100
-            else:
-                params["first_air_date.lte"] = datetime.now().strftime("%Y-%m-%d")
-                params["vote_count.gte"] = 50
-            
-            response = requests.get(url, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            metas = []
-            for item in data.get("results", []):
-                if not item.get("poster_path"):
-                    continue
-                    
-                meta = self._build_meta(media_type, item)
-                metas.append(meta)
-            
-            result = {"metas": metas, "hasMore": page < data.get("total_pages", 1)}
-            self.cache[cache_key] = result
-            return result
-            
-        except Exception as e:
-            logger.error(f"Erro ao buscar catálogo: {e}")
-            return {"metas": [], "hasMore": False}
-
-    async def get_recent_releases(self, media_type: str) -> Dict:
-        cache_key = f"recent_{media_type}"
-        
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-            
-        try:
-            await self.initialize_genres()
-            
+        else:
+            url = f"{TMDB_API_URL}/discover/{media_type}"
             params = {
                 "api_key": TMDB_API_KEY,
-                "language": "pt-BR",
                 "sort_by": "popularity.desc",
-                "include_adult": False,
-                "region": "BR",
-                "vote_count.gte": 50 if media_type == "tv" else 100
+                "page": page,
+                "language": "pt-BR"
             }
-            
-            today = datetime.now().strftime("%Y-%m-%d")
-            if media_type == "movie":
-                start_date = (datetime.now() - timedelta(days=RECENT_MOVIES_DAYS)).strftime("%Y-%m-%d")
-                params["primary_release_date.gte"] = start_date
-                params["primary_release_date.lte"] = today
-            else:
-                start_date = (datetime.now() - timedelta(days=RECENT_TV_DAYS)).strftime("%Y-%m-%d")
-                params["first_air_date.gte"] = start_date
-                params["first_air_date.lte"] = today
-            
-            url = f"{TMDB_API_URL}/discover/{media_type}"
-            response = requests.get(url, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            metas = []
-            for item in data.get("results", [])[:RECENT_RELEASES_LIMIT]:
-                if not item.get("poster_path"):
-                    continue
-                    
-                meta = self._build_meta(media_type, item)
-                metas.append(meta)
-            
-            result = {"metas": metas}
-            self.cache[cache_key] = result
-            return result
-            
-        except Exception as e:
-            logger.error(f"Erro ao buscar lançamentos recentes: {e}")
-            return {"metas": []}
+        
+        response = requests.get(url, params=params, timeout=REQUEST_TIMEOUT)
+        response.raise_for_status()
+        data = response.json()
+        vod_api.cache[cache_key] = data
+        return data
+    except Exception as e:
+        logger.error(f"TMDB request failed: {e}")
+        return None
+
+def extract_tmdb_id(id_str):
+    if id_str.startswith("tmdb:"):
+        return id_str.split(":")[1]
+    if id_str.isdigit():
+        return id_str
+    return None
 
-    def _build_meta(self, media_type: str, item: Dict) -> Dict:
-        genre_ids = item.get("genre_ids", [])
-        genres = [self.genre_map.get(media_type, {}).get(gid, "") for gid in genre_ids[:3]]
-        genres = [g for g in genres if g]
+def convert_tmdb_to_imdb(tmdb_id, media_type="movie"):
+    cache_key = f"tmdb_to_imdb_{media_type}_{tmdb_id}"
+    if cache_key in vod_api.cache:
+        return vod_api.cache[cache_key]
         
-        release_date = item.get("release_date") if media_type == "movie" else item.get("first_air_date")
-        year = release_date[:4] if release_date else "N/A"
+    try:
+        url = f"{TMDB_API_URL}/{media_type}/{tmdb_id}/external_ids"
+        params = {"api_key": TMDB_API_KEY}
         
-        return {
-            "id": f"tmdb:{item['id']}",
-            "type": media_type,
-            "name": item.get("title") if media_type == "movie" else item.get("name"),
-            "genres": genres,
-            "description": item.get("overview", "Descrição não disponível.")[:300],
-            "poster": f"https://image.tmdb.org/t/p/w500{item['poster_path']}",
-            "background": f"https://image.tmdb.org/t/p/original{item['backdrop_path']}" if item.get("backdrop_path") else "",
-            "releaseInfo": year,
-            "imdbRating": round(item.get("vote_average", 0), 1),
-            "popularity": round(item.get("popularity", 0), 1)
-        }
-
-# Initialize services
-vod_api = VOD()
-catalog_manager = CatalogManager()
+        response = requests.get(url, params=params, timeout=REQUEST_TIMEOUT)
+        response.raise_for_status()
+        data = response.json()
+        imdb_id = data.get("imdb_id", "")
+        vod_api.cache[cache_key] = imdb_id
+        return imdb_id
+    except Exception as e:
+        logger.error(f"TMDB conversion failed: {e}")
+        return ""
 
-# Routes
+# Rotas do FastAPI
 @app.get("/")
-async def home():
-    with open("static/index.html") as f:
-        return HTMLResponse(content=f.read(), status_code=200)
+async def root():
+    return RedirectResponse(url="/manifest.json")
 
 @app.get("/manifest.json")
 async def get_manifest():
@@ -452,46 +328,55 @@ async def get_catalog(
     type: str, 
     id: str,
     request: Request,
-    skip: int = Query(0, alias="skip"),
-    search: str = Query(None, alias="search"),
-    genre: str = Query(None, alias="genre")
+    skip: int = Query(0),
+    search: str = Query(None)
 ):
-    logger.info(f"Catalog request - Type: {type}, ID: {id}, Skip: {skip}, Search: {search}, Genre: {genre}")
-    
-    if id in ["streamflix_recent_movies", "streamflix_recent_series"]:
-        media_type = "movie" if id == "streamflix_recent_movies" else "tv"
-        recent_releases = await catalog_manager.get_recent_releases(media_type)
-        return JSONResponse(recent_releases)
+    logger.info(f"Catalog request: {type}/{id}?skip={skip}&search={search}")
     
     if id not in ["streamflix_movies", "streamflix_series"]:
         return JSONResponse({"metas": []})
     
+    page = (skip // 20) + 1
     media_type = "movie" if id == "streamflix_movies" else "tv"
-    page = (skip // CATALOG_PAGE_SIZE) + 1
+    tmdb_data = get_tmdb_media(media_type, page, search)
+    
+    if not tmdb_data or "results" not in tmdb_data:
+        return JSONResponse({"metas": []})
     
-    catalog = await catalog_manager.get_catalog(
-        media_type=media_type,
-        page=page,
-        search=search,
-        genre=genre
-    )
+    metas = []
+    for item in tmdb_data["results"]:
+        if not item.get("poster_path"):
+            continue
+            
+        meta = {
+            "id": f"tmdb:{item['id']}",
+            "type": media_type,
+            "name": item.get("title") if media_type == "movie" else item.get("name"),
+            "genres": [genre["name"] for genre in item.get("genres", [])][:3],
+            "description": item.get("overview", "Sem descrição disponível")[:300],
+            "poster": f"https://image.tmdb.org/t/p/w500{item['poster_path']}",
+            "background": f"https://image.tmdb.org/t/p/original{item['backdrop_path']}" if item.get("backdrop_path") else MANIFEST["background"],
+            "releaseInfo": item.get("release_date", "")[:4] if media_type == "movie" else item.get("first_air_date", "")[:4],
+            "imdbRating": round(item.get("vote_average", 0), 1)
+        }
+        metas.append(meta)
     
-    return JSONResponse(catalog)
+    return JSONResponse({"metas": metas})
 
 @app.get("/meta/{type}/{id}.json")
 async def get_meta(type: str, id: str):
     try:
-        tmdb_id = id.split(":")[-1] if ":" in id else id
+        tmdb_id = extract_tmdb_id(id)
         media_type = "movie" if type == "movie" else "tv"
         
-        if not tmdb_id.isdigit() and type == "movie" and id.startswith("tt"):
+        if not tmdb_id and type == "movie" and id.startswith("tt"):
             imdb_id = id
-        elif tmdb_id.isdigit():
+        elif tmdb_id:
             imdb_id = convert_tmdb_to_imdb(tmdb_id, media_type) if type == "movie" else ""
         else:
             raise ValueError("Invalid ID format")
 
-        if not tmdb_id.isdigit() and type != "movie":
+        if not tmdb_id and type != "movie":
             return JSONResponse({
                 "meta": {
                     "id": id,
@@ -506,28 +391,25 @@ async def get_meta(type: str, id: str):
         params = {
             "api_key": TMDB_API_KEY,
             "language": "pt-BR",
-            "append_to_response": "external_ids,credits"
+            "append_to_response": "external_ids"
         }
         
         response = requests.get(url, params=params, timeout=REQUEST_TIMEOUT)
         response.raise_for_status()
         details = response.json()
         
-        genre_ids = [g["id"] for g in details.get("genres", [])]
-        genres = [catalog_manager.genre_map.get(media_type, {}).get(gid, "") for gid in genre_ids[:3]]
-        
         meta = {
             "id": id,
             "type": type,
             "name": details.get("title") if media_type == "movie" else details.get("name"),
-            "genres": [g for g in genres if g],
+            "genres": [genre["name"] for genre in details.get("genres", [])],
             "description": details.get("overview", "Sem descrição disponível"),
             "poster": f"https://image.tmdb.org/t/p/w500{details['poster_path']}" if details.get("poster_path") else MANIFEST["logo"],
             "background": f"https://image.tmdb.org/t/p/original{details['backdrop_path']}" if details.get("backdrop_path") else MANIFEST["background"],
             "releaseInfo": details.get("release_date", "")[:4] if media_type == "movie" else details.get("first_air_date", "")[:4],
             "imdbRating": round(details.get("vote_average", 0), 1),
             "director": ", ".join(
-                [crew["name"] for crew in details.get("credits", {}).get("crew", []) 
+                [crew["name"] for crew in details.get("crew", []) 
                 if crew.get("job") == "Director"
             ][:2]) if media_type == "movie" else None
         }
@@ -565,7 +447,7 @@ async def get_stream(type: str, id: str):
     try:
         if type == "movie":
             if id.startswith("tmdb:"):
-                tmdb_id = id.split(":")[-1]
+                tmdb_id = extract_tmdb_id(id)
                 imdb_id = convert_tmdb_to_imdb(tmdb_id, "movie")
                 if not imdb_id:
                     logger.warning(f"Failed to convert TMDB to IMDB: {id}")
@@ -612,29 +494,4 @@ async def get_stream(type: str, id: str):
     except Exception as e:
         logger.error(f"Stream request failed: {e}")
     
-    return JSONResponse({"streams": []})
-
-@app.get("/genres/{media_type}.json")
-async def get_genres(media_type: str):
-    await catalog_manager.initialize_genres()
-    genres = catalog_manager.genre_map.get(media_type, {})
-    return JSONResponse({"genres": genres})
-
-def convert_tmdb_to_imdb(tmdb_id, media_type="movie"):
-    cache_key = f"tmdb_to_imdb_{media_type}_{tmdb_id}"
-    if cache_key in vod_api.cache:
-        return vod_api.cache[cache_key]
-        
-    try:
-        url = f"{TMDB_API_URL}/{media_type}/{tmdb_id}/external_ids"
-        params = {"api_key": TMDB_API_KEY}
-        
-        response = requests.get(url, params=params, timeout=REQUEST_TIMEOUT)
-        response.raise_for_status()
-        data = response.json()
-        imdb_id = data.get("imdb_id", "")
-        vod_api.cache[cache_key] = imdb_id
-        return imdb_id
-    except Exception as e:
-        logger.error(f"TMDB conversion failed: {e}")
-        return ""
+    return JSONResponse({"streams": []})