Update

handler.py

@@ -24,14 +24,15 @@ def refine_foreground(image, mask, r=90):
     return image_masked
 
 def FB_blur_fusion_foreground_estimator_2(image, alpha, r=90):
-    # Thanks to the source: https://github.com/Photoroom/fast-foreground-estimation
     alpha = alpha[:, :, None]
     F, blur_B = FB_blur_fusion_foreground_estimator(image, image, image, alpha, r)
     return FB_blur_fusion_foreground_estimator(image, F, blur_B, alpha, r=6)[0]
 
 def FB_blur_fusion_foreground_estimator(image, F, B, alpha, r=90):
-    if isinstance(image, Image.Image):
+    # Detección segura para helpers internos
+    if hasattr(image, 'size') or isinstance(image, Image.Image):
         image = np.array(image) / 255.0
+    
     blurred_alpha = cv2.blur(alpha, (r, r))[:, :, None]
     blurred_FA = cv2.blur(F * alpha, (r, r))
     blurred_F = blurred_FA / (blurred_alpha + 1e-5)
@@ -69,19 +70,8 @@ usage_to_weights_file = {
     'General-legacy': 'BiRefNet-legacy'
 }
 
-# Choose the version of BiRefNet here.
 usage = 'General'
-
-# Set resolution
-if usage in ['General-Lite-2K']:
-    resolution = (2560, 1440)
-elif usage in ['General-reso_512']:
-    resolution = (512, 512)
-elif usage in ['General-HR', 'Matting-HR']:
-    resolution = (2048, 2048)
-else:
-    resolution = (1024, 1024) 
-
+resolution = (1024, 1024)
 half_precision = True
 
 class EndpointHandler():
@@ -95,21 +85,15 @@ class EndpointHandler():
             self.birefnet.half()
 
     def __call__(self, data: Dict[str, Any]):
-        """
-        data args:
-            inputs (:obj: `str`)
-            date (:obj: `str`)
-        Return:
-            A :obj:`list` | `dict`: will be serialized and returned
-        """
-        print('data["inputs"] = ', data["inputs"])
+        print('data["inputs"] type:', type(data["inputs"])) # Log para debug
         image_src = data["inputs"]
 
-        # ------------------------------------------------------------------
-        # MODIFICACION REPUESTOS MOM: Soporte para imágenes directas (Bytes/PIL)
-        # ------------------------------------------------------------------
-        if isinstance(image_src, Image.Image):
+        # --- LOGICA BLINDADA ---
+        # 1. Si ya es una imagen (tiene atributo 'size' o 'convert'), úsala directo.
+        if hasattr(image_src, 'convert') or isinstance(image_src, Image.Image):
             image_ori = image_src
+        
+        # 2. Si es una ruta de archivo o URL (String)
         elif isinstance(image_src, str):
             if os.path.isfile(image_src):
                 image_ori = Image.open(image_src)
@@ -117,32 +101,31 @@ class EndpointHandler():
                 response = requests.get(image_src)
                 image_data = BytesIO(response.content)
                 image_ori = Image.open(image_data)
+        
+        # 3. Último recurso: Bytes crudos o Arrays
         else:
             try:
-                # Intento leer como array (comportamiento original)
-                image_ori = Image.fromarray(image_src)
+                # Intenta abrirlo como bytes (lo más común si falla el paso 1)
+                image_ori = Image.open(BytesIO(image_src))
             except Exception:
-                # Fallback: Intento leer como bytes crudos (para Odoo)
                 try:
-                    image_ori = Image.open(BytesIO(image_src))
-                except Exception:
-                    # Si falla, intentamos array de nuevo como último recurso
+                    # Intenta como array de numpy
                     image_ori = Image.fromarray(image_src)
-        # ------------------------------------------------------------------
-        
+                except Exception:
+                    # Si falla todo, asume que YA es una imagen que falló la detección
+                    image_ori = image_src
+        # -----------------------
+
         image = image_ori.convert('RGB')
         
-        # Preprocess the image
         image_preprocessor = ImagePreprocessor(resolution=tuple(resolution))
         image_proc = image_preprocessor.proc(image)
         image_proc = image_proc.unsqueeze(0)
         
-        # Prediction
         with torch.no_grad():
             preds = self.birefnet(image_proc.to(device).half() if half_precision else image_proc.to(device))[-1].sigmoid().cpu()
         pred = preds[0].squeeze()
         
-        # Show Results
         pred_pil = transforms.ToPILImage()(pred)
         image_masked = refine_foreground(image, pred_pil)
         image_masked.putalpha(pred_pil.resize(image.size))