Update app.py

app.py

@@ -4,52 +4,71 @@ from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse, RedirectResponse
 from fastapi.middleware.cors import CORSMiddleware
 import httpx
-from urllib.parse import urlparse, quote
-from datetime import datetime, timedelta
+from urllib.parse import urlparse, unquote
 from PIL import Image
 import io
-import hashlib
+import re
 
-# Configuração básica
 app = FastAPI(
-    title="Stremio Image Proxy",
-    description="Proxy de imagens para projetos Stremio hospedado no Hugging Face",
-    version="1.0.0"
+    title="Universal Image Proxy",
+    description="Proxy de imagens para qualquer aplicação com tratamento robusto de erros",
+    version="2.1.0"
 )
 
-# Configurar logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("stremio-proxy")
+# Configuração de logs
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("image-proxy")
 
-# Configuração CORS para permitir acesso de qualquer origem
+# CORS completo para acesso universal
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_methods=["GET"],
     allow_headers=["*"],
+    expose_headers=["*"]
 )
 
 # Configurações otimizadas para Hugging Face Spaces
-CACHE_TIME = 86400  # 1 dia em segundos
-TIMEOUT = 8.0  # Timeout menor para o ambiente do Spaces
-MAX_SIZE = 3 * 1024 * 1024  # 3MB (limite recomendado para Spaces)
-MAX_DIMENSION = 2000  # Dimensão máxima para redimensionamento
+TIMEOUT = 10.0
+MAX_SIZE = 3 * 1024 * 1024  # 3MB
+MAX_DIMENSION = 2000
+MAX_REDIRECTS = 5
+
+# Lista de domínios problemáticos que precisam de tratamento especial
+PROBLEMATIC_DOMAINS = [
+    "static.wikia.nocookie.net",
+    "tmsimg.com",
+    "espncdn.com"
+]
+
+def clean_url(url: str) -> str:
+    """Remove caracteres problemáticos e decodifica URL"""
+    # Decodificar URL codificada
+    cleaned = unquote(url)
+    
+    # Remover parâmetros de cache para alguns domínios
+    if any(domain in cleaned for domain in PROBLEMATIC_DOMAINS):
+        cleaned = re.sub(r'(\?|&)(cb|revision|__cf_chl_[^=]+)=[^&]+', '', cleaned)
+        cleaned = re.sub(r'\?.*', '', cleaned)
+    
+    return cleaned
 
 @app.get("/")
 async def home():
-    """Página inicial com instruções"""
+    """Página inicial com instruções simplificadas"""
     return {
-        "message": "Bem-vindo ao Proxy de Imagens para Stremio!",
-        "usage": "GET /proxy-image/?url=URL_DA_IMAGEM",
+        "service": "Universal Image Proxy",
+        "status": "active",
+        "endpoint": "/proxy-image/?url=URL_DA_IMAGEM",
         "parameters": {
-            "url": "URL da imagem original (obrigatório)",
             "w": "Largura desejada (opcional)",
             "h": "Altura desejada (opcional)",
-            "q": "Qualidade da imagem (1-100, opcional)"
+            "q": "Qualidade (1-100, padrão 85)"
         },
-        "example": "/proxy-image/?url=https://example.com/poster.jpg&w=300&q=85",
-        "huggingface_space": "https://huggingface.co/spaces",
-        "stremio": "https://www.stremio.com/"
+        "example": "/proxy-image/?url=https://example.com/photo.jpg&w=300&q=85"
     }
 
 @app.get("/proxy-image/")
@@ -60,78 +79,63 @@ async def proxy_image(
     h: int = None,
     q: int = 85
 ):
-    """Endpoint principal do proxy de imagens"""
-    logger.info(f"Requisição para: {url}")
-    
-    # Validar parâmetros
-    if not url:
-        raise HTTPException(status_code=400, detail="Parâmetro 'url' é obrigatório")
-    
-    if q and (q < 1 or q > 100):
-        raise HTTPException(status_code=400, detail="Qualidade deve estar entre 1 e 100")
-    
-    # Validar e normalizar URL
-    parsed_url = urlparse(url)
-    if not parsed_url.scheme or not parsed_url.netloc:
-        raise HTTPException(status_code=400, detail="URL inválida")
-    
-    if parsed_url.scheme not in ("http", "https"):
-        raise HTTPException(status_code=400, detail="Protocolo não suportado")
-    
-    # Headers para evitar bloqueio
-    headers = {
-        "User-Agent": "Stremio-Image-Proxy/1.0 (compatible; Stremio/4.0; +https://stremio.com)",
-        "Accept": "image/webp,image/apng,image/*,*/*;q=0.8",
-        "Referer": f"{parsed_url.scheme}://{parsed_url.netloc}/"
-    }
-    
+    """Endpoint principal do proxy de imagens com tratamento robusto de erros"""
     try:
+        # Limpar e validar URL
+        cleaned_url = clean_url(url)
+        parsed = urlparse(cleaned_url)
+        
+        if not parsed.scheme or not parsed.netloc or parsed.scheme not in ("http", "https"):
+            raise HTTPException(400, "URL inválida")
+        
+        # Headers para evitar bloqueio
+        headers = {
+            "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",
+            "Accept": "image/*,*/*;q=0.8",
+            "Referer": f"{parsed.scheme}://{parsed.netloc}/"
+        }
+        
         # Buscar a imagem
-        async with httpx.AsyncClient() as client:
+        async with httpx.AsyncClient(follow_redirects=True, max_redirects=MAX_REDIRECTS) as client:
             response = await client.get(
-                url,
+                cleaned_url,
                 headers=headers,
-                timeout=TIMEOUT,
-                follow_redirects=True
+                timeout=TIMEOUT
             )
             
+            # Tratamento de erros HTTP
             if response.status_code != 200:
-                logger.error(f"Erro ao buscar imagem: {url} - Status: {response.status_code}")
-                raise HTTPException(
-                    status_code=response.status_code,
-                    detail=f"Erro ao buscar imagem: {response.status_code}"
-                )
+                error_msg = f"Origem retornou erro {response.status_code}"
+                logger.warning(f"{error_msg} para: {cleaned_url}")
+                raise HTTPException(response.status_code, error_msg)
             
             content_type = response.headers.get("Content-Type", "")
             if not content_type.startswith("image/"):
-                logger.error(f"Conteúdo não é imagem: {content_type}")
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Tipo de conteúdo não suportado: {content_type}"
-                )
-            
-            # Processar imagem se necessário
-            image_data = response.content
-            
-            # Verificar tamanho máximo
-            if len(image_data) > MAX_SIZE:
-                logger.warning(f"Imagem muito grande: {len(image_data)} bytes")
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Imagem excede o tamanho máximo de {MAX_SIZE} bytes"
-                )
+                error_msg = f"Tipo de conteúdo inválido: {content_type}"
+                logger.warning(f"{error_msg} - URL: {cleaned_url}")
+                raise HTTPException(400, error_msg)
+                
+            # Verificar tamanho
+            if len(response.content) > MAX_SIZE:
+                error_msg = f"Imagem muito grande ({len(response.content)} bytes)"
+                logger.warning(f"{error_msg} - URL: {cleaned_url}")
+                raise HTTPException(400, error_msg)
+                
+            # Processar imagem
+            img_bytes = response.content
+            content_type = response.headers.get("Content-Type", "image/jpeg")
             
-            # Se foram solicitadas dimensões ou qualidade
+            # Aplicar transformações se solicitado
             if w or h or q != 85:
                 try:
-                    with Image.open(io.BytesIO(image_data)) as img:
+                    with Image.open(io.BytesIO(img_bytes)) as img:
                         # Limitar dimensões máximas
                         if w and w > MAX_DIMENSION:
                             w = MAX_DIMENSION
                         if h and h > MAX_DIMENSION:
                             h = MAX_DIMENSION
                             
-                        # Preservar proporções se apenas uma dimensão for fornecida
+                        # Preservar proporções
                         if w and not h:
                             h = int(w * img.height / img.width)
                         elif h and not w:
@@ -141,62 +145,60 @@ async def proxy_image(
                         if w or h:
                             img = img.resize((w or img.width, h or img.height))
                         
-                        # Converter para JPEG para compactação (a menos que seja PNG transparente)
+                        # Converter para JPEG (exceto PNGs com transparência)
                         output_format = "JPEG"
                         if img.format == "PNG" and img.mode == "RGBA":
                             output_format = "PNG"
                         
                         output = io.BytesIO()
-                        img.save(
-                            output, 
-                            format=output_format, 
-                            quality=q,
-                            optimize=True
-                        )
-                        image_data = output.getvalue()
+                        img.save(output, format=output_format, quality=q, optimize=True)
+                        img_bytes = output.getvalue()
                         content_type = f"image/{output_format.lower()}"
                 except Exception as img_error:
-                    logger.error(f"Erro ao processar imagem: {str(img_error)}")
-                    # Se falhar, retorna a imagem original
-                    pass
+                    logger.error(f"Erro no processamento: {str(img_error)} - URL: {cleaned_url}")
+                    # Manter a imagem original se falhar no processamento
             
-            logger.info(f"Imagem processada: {len(image_data)} bytes, tipo: {content_type}")
+            # Headers de resposta
+            headers = {
+                "Cache-Control": "public, max-age=86400",
+                "Access-Control-Allow-Origin": "*",
+                "X-Image-Proxy": "processed" if (w or h or q != 85) else "original",
+                "X-Original-URL": cleaned_url
+            }
             
-            # Retornar resposta
             return StreamingResponse(
-                io.BytesIO(image_data),
+                io.BytesIO(img_bytes),
                 media_type=content_type,
-                headers={
-                    "Cache-Control": f"public, max-age={CACHE_TIME}",
-                    "Content-Length": str(len(image_data)),
-                    "Access-Control-Allow-Origin": "*",
-                    "X-Image-Original-Size": str(len(response.content)),
-                    "X-Image-Processed-Size": str(len(image_data))
-                }
+                headers=headers
             )
             
+    except httpx.HTTPStatusError as e:
+        logger.error(f"Erro HTTP {e.response.status_code} para: {cleaned_url}")
+        raise HTTPException(e.response.status_code, f"Erro na origem: {e.response.status_code}")
+    
     except httpx.TimeoutException:
-        logger.error(f"Timeout ao buscar imagem: {url}")
-        raise HTTPException(
-            status_code=504,
-            detail="Tempo de requisição excedido"
-        )
+        logger.error(f"Timeout para: {cleaned_url}")
+        raise HTTPException(504, "Tempo de requisição excedido")
+    
     except httpx.RequestError as e:
-        logger.error(f"Erro de conexão: {str(e)}")
-        raise HTTPException(
-            status_code=502,
-            detail=f"Erro de conexão: {str(e)}"
-        )
+        logger.error(f"Erro de conexão: {str(e)} - URL: {cleaned_url}")
+        raise HTTPException(502, f"Erro de conexão: {str(e)}")
+    
+    except HTTPException:
+        # Re-lançar exceções HTTP já tratadas
+        raise
+    
     except Exception as e:
-        logger.error(f"Erro interno: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Erro interno: {str(e)}"
-        )
+        logger.exception(f"Erro inesperado: {str(e)} - URL: {cleaned_url}")
+        raise HTTPException(500, f"Erro interno: {str(e)}")
 
 @app.get("/favicon.ico")
 async def favicon():
-    return RedirectResponse(url="https://www.stremio.com/favicon.ico")
+    return RedirectResponse(
+        "https://www.stremio.com/favicon.ico",
+        status_code=301,
+        headers={"Cache-Control": "public, max-age=31536000"}
+    )
 
 # Função para compatibilidade com Hugging Face Spaces
 def get_app():