Update generator.py

generator.py

@@ -160,15 +160,17 @@ class RetroArtConverter:
                 orig_height = int(orig_height.item() if hasattr(orig_height, 'item') else orig_height)
                 
                 # Resize to dimensions ZoeDetector expects (multiples of 32)
-                target_width = (orig_width // 32) * 32
-                target_height = (orig_height // 32) * 32
+                # CRITICAL: Ensure Python int, not numpy types
+                target_width = int((orig_width // 32) * 32)
+                target_height = int((orig_height // 32) * 32)
                 
                 # Ensure at least 32x32
-                target_width = max(32, target_width)
-                target_height = max(32, target_height)
+                target_width = int(max(32, target_width))
+                target_height = int(max(32, target_height))
                 
                 if target_width != orig_width or target_height != orig_height:
-                    image = image.resize((target_width, target_height), Image.LANCZOS)
+                    # CRITICAL: Pass explicit Python ints to resize
+                    image = image.resize((int(target_width), int(target_height)), Image.LANCZOS)
                     print(f"[DEPTH] Resized for ZoeDetector: {orig_width}x{orig_height} -> {target_width}x{target_height}")
                 
                 # Use Zoe detector - now with safe dimensions
@@ -552,29 +554,47 @@ class RetroArtConverter:
         # Set LORA scale
         if hasattr(self.pipe, 'set_adapters') and self.models_loaded['lora']:
             try:
-                # Try to use 'retroart' adapter, fallback to available adapters
+                # Get list of actually available adapters
+                available_adapters = []
                 if hasattr(self.pipe, 'get_list_adapters'):
-                    available_adapters = self.pipe.get_list_adapters()
-                    if available_adapters:
-                        # Use 'retroart' if available, otherwise use first adapter
-                        adapter_name = "retroart" if "retroart" in available_adapters else available_adapters[0]
-                        self.pipe.set_adapters([adapter_name], adapter_weights=[lora_scale])
-                        print(f"LORA '{adapter_name}' scale: {lora_scale}")
-                    else:
-                        print(f"[WARNING] No LORA adapters found")
+                    try:
+                        available_adapters = self.pipe.get_list_adapters()
+                        print(f"[LORA] Available adapters: {available_adapters}")
+                    except:
+                        pass
+                
+                if available_adapters:
+                    # Use first available adapter (could be 'retroart', 'default_0', etc.)
+                    adapter_name = available_adapters[0]
+                    self.pipe.set_adapters([adapter_name], adapter_weights=[lora_scale])
+                    print(f"[LORA] Using adapter '{adapter_name}' with scale: {lora_scale}")
                 else:
-                    # Fallback for older diffusers versions
-                    self.pipe.set_adapters(["retroart"], adapter_weights=[lora_scale])
-                    print(f"LORA scale: {lora_scale}")
+                    # No get_list_adapters or empty list - try common names
+                    for name in ["retroart", "default", "default_0"]:
+                        try:
+                            self.pipe.set_adapters([name], adapter_weights=[lora_scale])
+                            print(f"[LORA] Using adapter '{name}' with scale: {lora_scale}")
+                            break
+                        except:
+                            continue
+                    else:
+                        print(f"[WARNING] Could not set LORA adapter scale")
+                        
             except Exception as e:
-                print(f"[WARNING] Could not set LORA scale: {e}")
-                # Try simple LORA scale as fallback
+                print(f"[WARNING] LORA set_adapters failed: {e}")
+                # Try alternative method - fuse_lora
                 try:
                     if hasattr(self.pipe, 'fuse_lora'):
                         self.pipe.fuse_lora(lora_scale=lora_scale)
-                        print(f"[OK] LORA fused with scale: {lora_scale}")
-                except:
-                    pass
+                        print(f"[LORA] Fused with scale: {lora_scale}")
+                except Exception as e2:
+                    print(f"[WARNING] LORA fuse also failed: {e2}")
+                    # Last resort - set scale directly if possible
+                    try:
+                        self.pipe.set_lora_scale(lora_scale)
+                        print(f"[LORA] Set scale directly: {lora_scale}")
+                    except:
+                        print(f"[INFO] LORA will use default scale")
         
         # Prepare generation kwargs
         pipe_kwargs = {
@@ -787,4 +807,4 @@ class RetroArtConverter:
         return generated_image
 
 
-print("[OK] Generator class ready")
+print("[OK] Generator class ready")