Create app.py

app.py

@@ -0,0 +1,203 @@
+import os
+import logging
+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 PIL import Image
+import io
+import hashlib
+
+# 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"
+)
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("stremio-proxy")
+
+# Configuração CORS para permitir acesso de qualquer origem
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["GET"],
+    allow_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
+
+@app.get("/")
+async def home():
+    """Página inicial com instruções"""
+    return {
+        "message": "Bem-vindo ao Proxy de Imagens para Stremio!",
+        "usage": "GET /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)"
+        },
+        "example": "/proxy-image/?url=https://example.com/poster.jpg&w=300&q=85",
+        "huggingface_space": "https://huggingface.co/spaces",
+        "stremio": "https://www.stremio.com/"
+    }
+
+@app.get("/proxy-image/")
+async def proxy_image(
+    request: Request,
+    url: str,
+    w: int = None,
+    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}/"
+    }
+    
+    try:
+        # Buscar a imagem
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                url,
+                headers=headers,
+                timeout=TIMEOUT,
+                follow_redirects=True
+            )
+            
+            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}"
+                )
+            
+            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"
+                )
+            
+            # Se foram solicitadas dimensões ou qualidade
+            if w or h or q != 85:
+                try:
+                    with Image.open(io.BytesIO(image_data)) 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
+                        if w and not h:
+                            h = int(w * img.height / img.width)
+                        elif h and not w:
+                            w = int(h * img.width / img.height)
+                        
+                        # Redimensionar se necessário
+                        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)
+                        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()
+                        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.info(f"Imagem processada: {len(image_data)} bytes, tipo: {content_type}")
+            
+            # Retornar resposta
+            return StreamingResponse(
+                io.BytesIO(image_data),
+                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))
+                }
+            )
+            
+    except httpx.TimeoutException:
+        logger.error(f"Timeout ao buscar imagem: {url}")
+        raise HTTPException(
+            status_code=504,
+            detail="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)}"
+        )
+    except Exception as e:
+        logger.error(f"Erro interno: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Erro interno: {str(e)}"
+        )
+
+@app.get("/favicon.ico")
+async def favicon():
+    return RedirectResponse(url="https://www.stremio.com/favicon.ico")
+
+# Função para compatibilidade com Hugging Face Spaces
+def get_app():
+    return app