Update routers/search.py

routers/search.py

@@ -12,415 +12,409 @@ import struct
 from typing import Optional, Tuple, List, Dict
 import base64
 from functools import lru_cache
+import aiofiles
+from concurrent.futures import ThreadPoolExecutor
 import time
-from concurrent.futures import ProcessPoolExecutor
-import multiprocessing
-
-# Use uvloop se disponível para melhor performance async
-try:
-    import uvloop
-    uvloop.install()
-except ImportError:
-    pass
-
-def _init_worker():
-    """Inicializa worker do processo filho"""
-    # Configurações específicas do worker se necessário
-    import signal
-    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 router = APIRouter()
 
-# Pool de processos para thumbnails (mais eficiente que threads para CPU-bound)
-_process_pool = ProcessPoolExecutor(
-    max_workers=min(multiprocessing.cpu_count(), 8),
-    initializer=_init_worker
+# Pool de threads otimizado para operações CPU-intensivas (thumbnail)
+thumbnail_executor = ThreadPoolExecutor(
+    max_workers=min(32, (os.cpu_count() or 1) + 4),
+    thread_name_prefix="thumbnail_"
 )
 
-# Cache otimizado com TTL implícito
+# Cache em memória para URLs já processadas
 _url_cache = {}
-_cache_timestamps = {}
-_cache_max_size = 2000
-_cache_ttl = 3600  # 1 hora
+_cache_max_size = 1000
 
-@lru_cache(maxsize=1000)
-def _clean_wikimedia_url(url: str) -> str:
-    """Cache LRU para limpeza de URLs Wikimedia"""
-    if 'wikimedia.org' not in url or '/thumb/' not in url:
-        return url
+@router.get("/search")
+async def search(
+    q: str = Query(..., description="Termo de pesquisa para imagens"),
+    min_width: int = Query(1200, description="Largura mínima das imagens (padrão: 1200px)"),
+    include_thumbnails: bool = Query(True, description="Incluir miniaturas base64 nas respostas")
+):
+    """
+    Busca imagens no Google Imagens com máxima performance
+    """
+    start_time = time.time()
+    
+    # URL do Google Imagens com parâmetros para imagens grandes
+    google_images_url = "http://www.google.com/search"
+    
+    params = {
+        "tbm": "isch",
+        "q": q,
+        "start": 0,
+        "sa": "N",
+        "asearch": "arc",
+        "cs": "1",
+        "tbs": "isz:l",
+        "async": f"arc_id:srp_GgSMaOPQOtL_5OUPvbSTOQ_110,ffilt:all,ve_name:MoreResultsContainer,inf:1,_id:arc-srp_GgSMaOPQOtL_5OUPvbSTOQ_110,_pms:s,_fmt:pc"
+    }
+    
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "pt-BR,pt;q=0.8,en-US;q=0.5,en;q=0.3",
+        "Accept-Encoding": "gzip, deflate",
+        "Connection": "keep-alive",
+        "Referer": "https://www.google.com/"
+    }
     
     try:
-        idx = url.find('/thumb/')
-        if idx == -1:
-            return url
+        # Busca no Google (rápida)
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(google_images_url, params=params, headers=headers)
         
-        before_thumb = url[:idx]
-        after_thumb = url[idx + 6:]
-        slash_count = 0
-        end_idx = 0
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail="Erro ao buscar no Google Imagens")
         
-        for i, char in enumerate(after_thumb):
-            if char == '/':
-                slash_count += 1
-                if slash_count == 3:
-                    end_idx = i
-                    break
+        # Extração otimizada
+        images = extract_images_from_response_optimized(response.text)
         
-        if slash_count >= 3:
-            original_path = after_thumb[:end_idx]
-            return f"{before_thumb}/{original_path}"
-    except:
-        pass
-    
+        # Processamento paralelo massivo
+        enriched_images = await enrich_images_ultra_fast(images, include_thumbnails)
+        
+        # Filtragem rápida
+        valid_images = [
+            img for img in enriched_images 
+            if img.get('width', 0) >= min_width and img.get('height', 0) > 0
+        ]
+        
+        # Se poucos resultados, busca adicional em paralelo
+        if len(valid_images) < 20:
+            params["tbs"] = "isz:lt,islt:4mp"
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response2 = await client.get(google_images_url, params=params, headers=headers)
+            
+            if response2.status_code == 200:
+                additional_images = extract_images_from_response_optimized(response2.text)
+                additional_enriched = await enrich_images_ultra_fast(additional_images, include_thumbnails)
+                
+                # Merge rápido com set para deduplicação
+                seen_urls = {img.get('url') for img in valid_images}
+                for img in additional_enriched:
+                    if (img.get('url') not in seen_urls 
+                        and img.get('width', 0) >= min_width 
+                        and img.get('height', 0) > 0):
+                        valid_images.append(img)
+                        seen_urls.add(img.get('url'))
+        
+        # Ordenação e limitação
+        valid_images.sort(key=lambda x: x.get('width', 0), reverse=True)
+        final_images = valid_images[:50]
+        
+        total_time = time.time() - start_time
+        
+        return JSONResponse(content={
+            "query": q,
+            "min_width_filter": min_width,
+            "total_found": len(final_images),
+            "thumbnails_included": include_thumbnails,
+            "processing_time": round(total_time, 2),
+            "images": final_images
+        })
+        
+    except httpx.TimeoutException:
+        raise HTTPException(status_code=408, detail="Timeout na requisição ao Google")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao executar a busca: {str(e)}")
+
+
+@lru_cache(maxsize=500)
+def clean_wikimedia_url_cached(url: str) -> str:
+    """
+    Versão cached da limpeza de URLs do Wikimedia
+    """
+    if 'wikimedia.org' in url and '/thumb/' in url:
+        try:
+            parts = url.split('/thumb/')
+            if len(parts) == 2:
+                before_thumb = parts[0]
+                after_thumb = parts[1]
+                path_parts = after_thumb.split('/')
+                
+                if len(path_parts) >= 3:
+                    original_path = '/'.join(path_parts[:3])
+                    return f"{before_thumb}/{original_path}"
+        except:
+            pass
     return url
 
-# Regex pré-compilado para máxima performance
-_IMAGE_PATTERN = re.compile(
-    r'https?://[^\s"\'<>]+?\.(?:jpg|png|webp|jpeg)(?:\?[^\s"\'<>]*)?',
-    re.IGNORECASE | re.MULTILINE
-)
 
-def _extract_images_vectorized(response_text: str) -> List[str]:
-    """Extração vetorizada ultra-rápida"""
-    # Encontra todas as URLs
-    raw_urls = _IMAGE_PATTERN.findall(response_text)
+def extract_images_from_response_optimized(response_text: str) -> List[Dict]:
+    """
+    Extração ultra-otimizada usando regex compilado e processamento em lote
+    """
+    # Regex compilado (mais rápido)
+    pattern = re.compile(r'https?://[^\s"\'<>]+?\.(?:jpg|png|webp|jpeg)\b', re.IGNORECASE)
     
-    # Deduplicação com set comprehension
-    seen = set()
-    unique_urls = []
+    # Extração em uma única passada
+    image_urls = pattern.findall(response_text)
     
-    for url in raw_urls[:100]:  # Limita para 100 URLs máximo
-        cleaned = _clean_wikimedia_url(url)
-        if cleaned not in seen and len(cleaned) > 20:  # URLs válidas são maiores
-            seen.add(cleaned)
-            unique_urls.append(cleaned)
-            
-            if len(unique_urls) >= 80:  # Para cedo se já temos suficientes
-                break
+    # Deduplicação com set (O(1) lookup)
+    seen_urls = set()
+    images = []
     
-    return unique_urls
+    # Processa URLs em lote
+    for url in image_urls[:200]:  # Aumentado para compensar filtragem
+        cleaned_url = clean_wikimedia_url_cached(url)
+        if cleaned_url not in seen_urls:
+            seen_urls.add(cleaned_url)
+            images.append({"url": cleaned_url, "width": None, "height": None})
+    
+    return images
 
-# Estruturas de dados otimizadas para parsing
-_JPEG_MARKERS = frozenset([b'\xff\xc0', b'\xff\xc1', b'\xff\xc2', b'\xff\xc3'])
-_PNG_SIGNATURE = b'\x89PNG\r\n\x1a\n'
-_WEBP_SIGNATURE = b'RIFF'
 
-def _get_image_dimensions_lightning(data: bytes) -> Optional[Tuple[int, int]]:
-    """Parser de dimensões ultra-otimizado"""
+def get_image_size_super_fast(data: bytes) -> Optional[Tuple[int, int]]:
+    """
+    Parsing ultra-otimizado - apenas formatos mais comuns primeiro
+    """
     if len(data) < 24:
         return None
     
-    # JPEG - busca otimizada
-    if data[0:2] == b'\xff\xd8':
-        # Busca vetorizada por markers
-        for i in range(2, min(len(data) - 8, 800)):
-            if data[i:i+2] in _JPEG_MARKERS:
-                try:
-                    h = (data[i+5] << 8) | data[i+6]
-                    w = (data[i+7] << 8) | data[i+8]
-                    if 50 < w < 50000 and 50 < h < 50000:  # Sanity check
-                        return w, h
-                except IndexError:
-                    break
-    
-    # PNG - acesso direto otimizado
-    elif data[:8] == _PNG_SIGNATURE:
-        try:
-            w = struct.unpack('>I', data[16:20])[0]
-            h = struct.unpack('>I', data[20:24])[0]
-            if 50 < w < 50000 and 50 < h < 50000:
-                return w, h
-        except (struct.error, IndexError):
-            pass
-    
-    # WebP - parsing simplificado
-    elif data[:4] == _WEBP_SIGNATURE and len(data) >= 30:
-        try:
+    try:
+        # JPEG (mais comum) - otimizado
+        if data[:2] == b'\xff\xd8':
+            # Busca mais eficiente pelos markers
+            for i in range(2, min(len(data) - 8, 1000)):  # Limita busca
+                if data[i:i+2] in (b'\xff\xc0', b'\xff\xc2'):
+                    if i + 9 <= len(data):
+                        height = struct.unpack('>H', data[i+5:i+7])[0]
+                        width = struct.unpack('>H', data[i+7:i+9])[0]
+                        if width > 0 and height > 0:
+                            return width, height
+        
+        # PNG (segundo mais comum)
+        elif data[:8] == b'\x89PNG\r\n\x1a\n' and len(data) >= 24:
+            width = struct.unpack('>I', data[16:20])[0]
+            height = struct.unpack('>I', data[20:24])[0]
+            if width > 0 and height > 0:
+                return width, height
+        
+        # WebP (crescimento)
+        elif data[:12] == b'RIFF' + data[4:8] + b'WEBP' and len(data) >= 30:
             if data[12:16] == b'VP8 ':
-                w = struct.unpack('<H', data[26:28])[0] & 0x3fff
-                h = struct.unpack('<H', data[28:30])[0] & 0x3fff
-                if 50 < w < 50000 and 50 < h < 50000:
-                    return w, h
-        except (struct.error, IndexError):
-            pass
+                width = struct.unpack('<H', data[26:28])[0] & 0x3fff
+                height = struct.unpack('<H', data[28:30])[0] & 0x3fff
+                if width > 0 and height > 0:
+                    return width, height
+    except:
+        pass
     
     return None
 
-def _create_thumbnail_process(image_data: bytes, max_size: int = 150) -> Optional[str]:
-    """Função para processamento em processo separado"""
+
+def create_thumbnail_cpu_optimized(image_data: bytes, max_size: int = 200) -> Optional[str]:
+    """
+    Versão CPU-otimizada para threading
+    """
     if not image_data or len(image_data) < 100:
         return None
         
     try:
-        # PIL otimizado
-        image = Image.open(io.BytesIO(image_data))
-        
-        # Conversão ultra-rápida
-        if image.mode not in ('RGB', 'L'):
-            if image.mode in ('RGBA', 'LA', 'P'):
-                # Background branco mais eficiente
-                bg = Image.new('RGB', image.size, (255, 255, 255))
-                if image.mode == 'P':
-                    image = image.convert('RGBA')
-                bg.paste(image, mask=image.split()[-1] if 'A' in image.mode else None)
-                image = bg
-            else:
-                image = image.convert('RGB')
-        
-        # Cálculo de proporções com operações inteiras
-        w, h = image.size
-        if w <= max_size and h <= max_size:
-            thumbnail = image  # Não redimensiona se já é pequena
-        else:
-            # Proporções com divisão inteira otimizada
+        # Abre imagem (rápido)
+        with Image.open(io.BytesIO(image_data)) as image:
+            # Conversão rápida para RGB
+            if image.mode != 'RGB':
+                if image.mode in ('RGBA', 'LA'):
+                    # Background branco para transparências
+                    bg = Image.new('RGB', image.size, (255, 255, 255))
+                    bg.paste(image, mask=image.split()[-1] if 'A' in image.mode else None)
+                    image = bg
+                else:
+                    image = image.convert('RGB')
+            
+            # Cálculo otimizado de proporções
+            w, h = image.size
             if w > h:
-                new_h = (h * max_size) // w
-                new_w = max_size if new_h > 0 else max_size
-                new_h = max(1, new_h)
+                new_w, new_h = max_size, max(1, (h * max_size) // w)
             else:
-                new_w = (w * max_size) // h  
-                new_h = max_size if new_w > 0 else max_size
-                new_w = max(1, new_w)
+                new_w, new_h = max(1, (w * max_size) // h), max_size
             
-            # Resize com filtro mais rápido
-            thumbnail = image.resize((new_w, new_h), Image.Resampling.NEAREST)
-        
-        # Compressão otimizada
-        buffer = io.BytesIO()
-        thumbnail.save(buffer, 
-                      format='JPEG',
-                      quality=75,
-                      optimize=False,
-                      progressive=False)
-        
-        return base64.b64encode(buffer.getvalue()).decode('ascii')
-        
-    except Exception:
+            # Resize com filtro mais rápido para thumbnails
+            thumbnail = image.resize((new_w, new_h), Image.Resampling.BILINEAR)
+            
+            # Salva com configurações otimizadas
+            buffer = io.BytesIO()
+            thumbnail.save(buffer, format='JPEG', quality=80, optimize=False)  # optimize=False é mais rápido
+            
+            return f"data:image/jpeg;base64,{base64.b64encode(buffer.getvalue()).decode('utf-8')}"
+            
+    except Exception as e:
         return None
 
-def _is_cache_valid(key: str) -> bool:
-    """Verifica se cache ainda é válido"""
-    if key not in _cache_timestamps:
-        return False
-    return (time.time() - _cache_timestamps[key]) < _cache_ttl
 
-def _clean_cache():
-    """Limpeza inteligente do cache"""
-    if len(_url_cache) <= _cache_max_size:
-        return
+async def download_and_process_image(session: httpx.AsyncClient, url: str, include_thumbnail: bool) -> Dict:
+    """
+    Download e processamento otimizado de uma única imagem
+    """
+    # Verifica cache primeiro
+    cache_key = f"{url}_{include_thumbnail}"
+    if cache_key in _url_cache:
+        return _url_cache[cache_key].copy()
     
-    current_time = time.time()
-    expired_keys = [
-        key for key, timestamp in _cache_timestamps.items()
-        if (current_time - timestamp) > _cache_ttl
-    ]
+    clean_url = url.replace('\\u003d', '=').replace('\\u0026', '&').replace('\\\\', '').replace('\\/', '/')
     
-    for key in expired_keys:
-        _url_cache.pop(key, None)
-        _cache_timestamps.pop(key, None)
-
-# Cliente HTTP reutilizável com configurações otimizadas
-_http_client = None
-
-async def _get_http_client():
-    """Cliente HTTP singleton otimizado"""
-    global _http_client
-    if _http_client is None:
-        _http_client = httpx.AsyncClient(
-            timeout=httpx.Timeout(8.0, connect=3.0),
-            limits=httpx.Limits(
-                max_keepalive_connections=50,
-                max_connections=80,
-                keepalive_expiry=30.0
-            ),
-            http2=False,
-            headers={
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-                'Accept': 'image/*,*/*;q=0.8',
-                'Accept-Encoding': 'gzip, deflate',
-                'Connection': 'keep-alive'
-            }
-        )
-    return _http_client
-
-async def _process_image_ultra_fast(url: str, include_thumbnail: bool, semaphore: asyncio.Semaphore) -> Dict:
-    """Processamento ultra-otimizado de uma imagem"""
-    async with semaphore:
-        # Cache check
-        cache_key = f"{url}_{include_thumbnail}"
-        if _is_cache_valid(cache_key):
-            return _url_cache[cache_key].copy()
-        
-        client = await _get_http_client()
-        clean_url = url.replace('\\u003d', '=').replace('\\u0026', '&').replace('\\\\', '').replace('\\/', '/')
-        
-        width, height, thumbnail_b64 = None, None, None
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Accept': 'image/*',
+        'Connection': 'close'
+    }
+    
+    width, height, thumbnail_b64 = None, None, None
+    
+    try:
+        # Estratégia otimizada: tamanhos incrementais
+        ranges = ['0-8192', '0-32768', '0-131072'] if include_thumbnail else ['0-2048']
         
-        try:
-            # Estratégia de range otimizada
-            range_size = 16384 if include_thumbnail else 4096
-            headers = {'Range': f'bytes=0-{range_size}'}
-            
-            response = await client.get(clean_url, headers=headers, timeout=5.0)
-            
-            if response.status_code in (200, 206) and len(response.content) > 200:
-                data = response.content
-                
-                # Parsing de dimensões
-                dimensions = _get_image_dimensions_lightning(data)
-                if dimensions:
-                    width, height = dimensions
-                
-                # Thumbnail em processo separado se necessário
-                if include_thumbnail and len(data) > 1000:
-                    loop = asyncio.get_event_loop()
-                    thumbnail_b64 = await loop.run_in_executor(
-                        _process_pool,
-                        _create_thumbnail_process,
-                        data
-                    )
+        for range_header in ranges:
+            headers['Range'] = f'bytes={range_header}'
             
-            # Se não conseguiu dimensões, tenta download maior
-            if not width and response.status_code == 206:
-                try:
-                    response = await client.get(clean_url, timeout=6.0)
-                    if response.status_code == 200 and len(response.content) < 1500000:
-                        dimensions = _get_image_dimensions_lightning(response.content[:50000])
+            try:
+                response = await session.get(clean_url, headers=headers, timeout=6.0)
+                if response.status_code in [200, 206] and len(response.content) > 100:
+                    
+                    # Parsing rápido de dimensões
+                    if not width or not height:
+                        dimensions = get_image_size_super_fast(response.content)
                         if dimensions:
                             width, height = dimensions
+                    
+                    # Thumbnail em thread separada se necessário
+                    if include_thumbnail and not thumbnail_b64:
+                        loop = asyncio.get_event_loop()
+                        thumbnail_b64 = await loop.run_in_executor(
+                            thumbnail_executor, 
+                            create_thumbnail_cpu_optimized, 
+                            response.content
+                        )
+                    
+                    # Se conseguiu tudo o que precisava, para por aqui
+                    if width and height and (not include_thumbnail or thumbnail_b64):
+                        break
                         
-                        if include_thumbnail and not thumbnail_b64:
-                            loop = asyncio.get_event_loop()
-                            thumbnail_b64 = await loop.run_in_executor(
-                                _process_pool,
-                                _create_thumbnail_process,
-                                response.content
-                            )
-                except:
-                    pass
+            except:
+                continue  # Tenta próximo range
         
-        except Exception:
-            pass
-        
-        # Resultado
-        result = {"url": clean_url, "width": width, "height": height}
-        if include_thumbnail:
-            result["thumbnail"] = f"data:image/jpeg;base64,{thumbnail_b64}" if thumbnail_b64 else None
-        
-        # Cache result
-        if width and height:
-            _clean_cache()
-            if len(_url_cache) < _cache_max_size:
-                _url_cache[cache_key] = result.copy()
-                _cache_timestamps[cache_key] = time.time()
-        
-        return result
-
-@router.get("/search")
-async def search(
-    q: str = Query(..., description="Termo de pesquisa para imagens"),
-    min_width: int = Query(1200, description="Largura mínima das imagens"),
-    include_thumbnails: bool = Query(True, description="Incluir miniaturas base64")
-):
-    """Busca imagens com performance máxima"""
+        # Fallback final: download completo se necessário
+        if (not width or not height or (include_thumbnail and not thumbnail_b64)):
+            try:
+                del headers['Range']
+                response = await session.get(clean_url, headers=headers, timeout=8.0)
+                if response.status_code == 200 and len(response.content) < 2000000:  # Max 2MB
+                    
+                    if not width or not height:
+                        try:
+                            with Image.open(io.BytesIO(response.content)) as img:
+                                width, height = img.size
+                        except:
+                            pass
+                    
+                    if include_thumbnail and not thumbnail_b64:
+                        loop = asyncio.get_event_loop()
+                        thumbnail_b64 = await loop.run_in_executor(
+                            thumbnail_executor, 
+                            create_thumbnail_cpu_optimized, 
+                            response.content
+                        )
+            except:
+                pass
     
-    # Google Images URL otimizada
-    params = {
-        "tbm": "isch",
-        "q": q,
-        "tbs": "isz:l,iar:w",  # Imagens grandes, formato wide
-        "safe": "off"
-    }
+    except Exception as e:
+        pass
     
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.5",
-        "Accept-Encoding": "gzip, deflate",
-        "Referer": "https://www.google.com/"
+    result = {
+        "url": clean_url,
+        "width": width,
+        "height": height
     }
     
+    if include_thumbnail:
+        result["thumbnail"] = thumbnail_b64
+    
+    # Cache do resultado (limita tamanho do cache)
+    if len(_url_cache) < _cache_max_size:
+        _url_cache[cache_key] = result.copy()
+    
+    return result
+
+
+async def enrich_images_ultra_fast(images: List[Dict], include_thumbnails: bool = True) -> List[Dict]:
+    """
+    Processamento ultra-paralelo com todas as otimizações modernas
+    """
+    if not images:
+        return []
+    
+    # Configuração HTTP2 otimizada para máxima concorrência
+    connector = httpx.AsyncClient(
+        timeout=httpx.Timeout(10.0),
+        limits=httpx.Limits(
+            max_keepalive_connections=100,  # Muito mais conexões
+            max_connections=150,            # Pool maior
+            keepalive_expiry=30.0          # Mantém conexões por mais tempo
+        ),
+        http2=False  # HTTP/1.1 ainda é mais rápido para muitas conexões pequenas
+    )
+    
+    # Semáforo mais agressivo
+    semaphore = asyncio.Semaphore(30)  # Muito mais concorrência
+    
+    async def process_single_image(image_data):
+        async with semaphore:
+            return await download_and_process_image(connector, image_data["url"], include_thumbnails)
+    
     try:
-        # Busca no Google
-        client = await _get_http_client()
-        response = await client.get(
-            "https://www.google.com/search",
-            params=params,
-            headers=headers
-        )
-        
-        if response.status_code != 200:
-            raise HTTPException(status_code=response.status_code, detail="Erro na busca")
-        
-        # Extração ultra-rápida
-        image_urls = _extract_images_vectorized(response.text)
-        
-        if not image_urls:
-            return JSONResponse(content={
-                "query": q,
-                "total_found": 0,
-                "images": []
-            })
+        # Cria todas as tasks de uma vez
+        tasks = [process_single_image(img) for img in images]
         
-        # Processamento paralelo com semáforo otimizado
-        semaphore = asyncio.Semaphore(25)  # Concorrência controlada
-        
-        # Cria tasks limitadas a 50 imagens máximo
-        tasks = [
-            _process_image_ultra_fast(url, include_thumbnails, semaphore)
-            for url in image_urls[:60]  # Processa um pouco mais para compensar falhas
-        ]
-        
-        # Processa tudo em paralelo
+        # Processa tudo em paralelo com gather otimizado
         results = await asyncio.gather(*tasks, return_exceptions=True)
         
-        # Filtra resultados válidos
-        valid_images = [
-            result for result in results
-            if (not isinstance(result, Exception) and 
-                result.get('width', 0) >= min_width and 
-                result.get('height', 0) > 0)
-        ]
+        # Filtragem rápida
+        valid_results = []
+        for result in results:
+            if not isinstance(result, Exception) and result.get('width') and result.get('height'):
+                valid_results.append(result)
         
-        # Ordena por área (width * height) e limita a 50
-        valid_images.sort(key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True)
-        final_images = valid_images[:50]
+        return valid_results
         
-        return JSONResponse(content={
-            "query": q,
-            "min_width_filter": min_width,
-            "total_found": len(final_images),
-            "thumbnails_included": include_thumbnails,
-            "images": final_images
-        })
-        
-    except httpx.TimeoutException:
-        raise HTTPException(status_code=408, detail="Timeout na requisição")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erro: {str(e)}")
+        return []
+    finally:
+        await connector.aclose()
+
 
+# Endpoint adicional otimizado
 @router.get("/thumbnail")
 async def get_thumbnail_fast(
-    url: str = Query(..., description="URL da imagem"),
-    size: int = Query(150, description="Tamanho da miniatura")
+    url: str = Query(..., description="URL da imagem para gerar miniatura"),
+    size: int = Query(200, description="Tamanho máximo da miniatura em pixels")
 ):
-    """Gera miniatura ultra-rápida"""
+    """
+    Obtém miniatura ultra-rápida de uma imagem específica
+    """
     try:
-        semaphore = asyncio.Semaphore(1)
-        result = await _process_image_ultra_fast(url, True, semaphore)
-        
-        if result.get('thumbnail'):
-            return JSONResponse(content={
-                "url": result['url'],
-                "thumbnail": result['thumbnail'],
-                "dimensions": f"{result.get('width', 0)}x{result.get('height', 0)}"
-            })
-        else:
-            raise HTTPException(status_code=500, detail="Erro ao criar miniatura")
+        async with httpx.AsyncClient(timeout=8.0) as client:
+            result = await download_and_process_image(client, url, True)
             
+            if result.get('thumbnail'):
+                return JSONResponse(content={
+                    "url": result['url'],
+                    "thumbnail": result['thumbnail'],
+                    "dimensions": f"{result.get('width', 0)}x{result.get('height', 0)}",
+                    "size": size
+                })
+            else:
+                raise HTTPException(status_code=500, detail="Erro ao criar miniatura")
+                
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erro: {str(e)}")
 
-# Cleanup
+
+# Cleanup do executor na finalização
 import atexit
-atexit.register(lambda: _process_pool.shutdown(wait=False) if _process_pool else None)
+atexit.register(lambda: thumbnail_executor.shutdown(wait=False))