Update handler.py

handler.py

@@ -1,79 +1,53 @@
-from typing import Dict, List, Any
-import os
-import requests
+from typing import Dict, Any
+from PIL import Image, ImageDraw
 from io import BytesIO
-from PIL import Image
-import torch
-from torchvision import transforms
-from transformers import AutoModelForImageSegmentation
-
-# --- Configuración ---
-torch.set_float32_matmul_precision(["high", "highest"][0])
-device = "cuda" if torch.cuda.is_available() else "cpu"
+import requests
+import os
 
 class EndpointHandler():
     def __init__(self, path=''):
-        # Cargamos BiRefNet (General)
-        self.model = AutoModelForImageSegmentation.from_pretrained(
-            'zhengpeng7/BiRefNet', 
-            trust_remote_code=True
-        )
-        self.model.to(device)
-        self.model.eval()
-        self.model.half() # Usamos media precisión para velocidad
+        # No cargamos ningún modelo pesado para esta prueba
+        pass
 
     def __call__(self, data: Dict[str, Any]):
-        # 1. RECIBIR IMAGEN (Entrada Blindada)
+        # 1. Intentar leer la imagen de todas las formas posibles
         image_src = data["inputs"]
         image = None
         
-        # Detectar si es Bytes, URL o PIL Image
-        if isinstance(image_src, Image.Image):
-            image = image_src
-        elif isinstance(image_src, str):
-            if os.path.exists(image_src):
-                image = Image.open(image_src)
-            elif image_src.startswith('http'):
-                image = Image.open(BytesIO(requests.get(image_src).content))
-        else:
-            # Asumimos bytes
-            try:
+        try:
+            # Caso A: Hugging Face ya la decodificó como Objeto Imagen
+            if isinstance(image_src, Image.Image):
+                image = image_src
+            # Caso B: Es una URL o Ruta
+            elif isinstance(image_src, str):
+                if image_src.startswith('http'):
+                    image = Image.open(BytesIO(requests.get(image_src).content))
+                elif os.path.exists(image_src):
+                    image = Image.open(image_src)
+                else:
+                    # Es una cadena de bytes (base64 decodeada string?)
+                    pass 
+            # Caso C: Son bytes crudos
+            else:
                 image = Image.open(BytesIO(image_src))
-            except:
-                # Fallback final
-                image = Image.fromarray(image_src)
+        except Exception as e:
+            # Si falla la lectura, creamos una imagen de ERROR con texto
+            img_err = Image.new('RGB', (500, 500), color='yellow')
+            return img_err
+
+        if not image:
+            # Si no se pudo cargar, devolvemos imagen AZUL (Diagnóstico)
+            return Image.new('RGB', (500, 500), color='blue')
 
-        # 2. LIMPIEZA DE COLOR (CRUCIAL)
-        # Convertimos a RGB puro para eliminar cualquier rareza del archivo original
+        # 2. Si la imagen se leyó bien, la convertimos a RGB
         image = image.convert("RGB")
-        
-        # Guardamos el tamaño original para luego
-        orig_size = image.size
-        
-        # 3. PROCESAMIENTO IA
-        # Transformación estándar para BiRefNet (1024x1024)
-        transform = transforms.Compose([
-            transforms.Resize((1024, 1024)),
-            transforms.ToTensor(),
-            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-        ])
-        
-        input_tensor = transform(image).unsqueeze(0).to(device).half()
-        
-        with torch.no_grad():
-            # Predicción
-            preds = self.model(input_tensor)[-1].sigmoid().cpu()
-        
-        # 4. MÁSCARA (Sin Numpy, Solo PIL)
-        pred = preds[0].squeeze()
-        mask_pil = transforms.ToPILImage()(pred)
-        
-        # Redimensionamos la máscara al tamaño EXACTO de la imagen original
-        mask_pil = mask_pil.resize(orig_size, resample=Image.Resampling.LANCZOS)
-        
-        # 5. APLICACIÓN FINAL
-        # Tomamos la imagen RGB original y le "inyectamos" la máscara en el canal Alfa.
-        # NO tocamos los colores. Solo decimos qué es transparente.
-        image.putalpha(mask_pil)
-        
+
+        # 3. DIBUJAR UN CUADRO ROJO EN EL CENTRO
+        # Esto nos confirma que el servidor manipuló la imagen
+        draw = ImageDraw.Draw(image)
+        w, h = image.size
+        # Cuadro rojo de 100x100 en el centro
+        draw.rectangle([w//2 - 50, h//2 - 50, w//2 + 50, h//2 + 50], fill="red", outline="white")
+        
+        # Devolvemos la imagen original pintada
         return image