Update app.py

app.py

@@ -19,6 +19,34 @@ try:
     from chatterbox.tts import ChatterboxTTS
     chatterbox_available = True
     print("Chatterbox TTS imported successfully")
+    
+    # Inspect the ChatterboxTTS class to understand its API
+    import inspect
+    print(f"ChatterboxTTS methods: {[method for method in dir(ChatterboxTTS) if not method.startswith('_')]}")
+    
+    # Check constructor signature
+    try:
+        sig = inspect.signature(ChatterboxTTS.__init__)
+        print(f"ChatterboxTTS.__init__ signature: {sig}")
+    except:
+        pass
+        
+    # Check from_local signature if it exists
+    if hasattr(ChatterboxTTS, 'from_local'):
+        try:
+            sig = inspect.signature(ChatterboxTTS.from_local)
+            print(f"ChatterboxTTS.from_local signature: {sig}")
+        except:
+            pass
+            
+    # Check from_pretrained signature if it exists  
+    if hasattr(ChatterboxTTS, 'from_pretrained'):
+        try:
+            sig = inspect.signature(ChatterboxTTS.from_pretrained)
+            print(f"ChatterboxTTS.from_pretrained signature: {sig}")
+        except:
+            pass
+            
 except ImportError as e:
     print(f"Failed to import ChatterboxTTS: {e}")
     print("Trying alternative import...")
@@ -84,46 +112,76 @@ if chatterbox_available:
             device = "cuda" if torch.cuda.is_available() else "cpu"
             print(f"Using device: {device}")
             
-            # The correct method signature is from_local(model_path, device)
-            # based on the error message showing from_local is called internally
+            # Try different loading methods based on the ChatterboxTTS API
             try:
-                model = ChatterboxTTS.from_local(LOCAL_MODEL_PATH, device)
+                # Method 1: Try from_local with just the path (let it handle device internally)
+                model = ChatterboxTTS.from_local(LOCAL_MODEL_PATH)
                 print("Chatterbox model loaded successfully using from_local method.")
             except Exception as e1:
                 print(f"from_local attempt failed: {e1}")
                 try:
-                    # Try the corrected from_pretrained with proper parameter order
-                    # It seems from_pretrained expects (local_path, device) not (device=device)
-                    model = ChatterboxTTS.from_pretrained(LOCAL_MODEL_PATH, device)
-                    print("Chatterbox model loaded successfully with corrected from_pretrained.")
+                    # Method 2: Try from_pretrained with just the path
+                    model = ChatterboxTTS.from_pretrained(LOCAL_MODEL_PATH)
+                    print("Chatterbox model loaded successfully with from_pretrained.")
                 except Exception as e2:
-                    print(f"Corrected from_pretrained failed: {e2}")
+                    print(f"from_pretrained failed: {e2}")
                     try:
-                        # Try loading individual components manually
-                        import torch
-                        s3gen_path = os.path.join(LOCAL_MODEL_PATH, "s3gen.pt")
-                        ve_path = os.path.join(LOCAL_MODEL_PATH, "ve.pt")
-                        tokenizer_path = os.path.join(LOCAL_MODEL_PATH, "tokenizer.json")
-                        t3_cfg_path = os.path.join(LOCAL_MODEL_PATH, "t3_cfg.pt")
+                        # Method 3: Try with explicit CPU mapping in from_local
+                        import pathlib
+                        model_path = pathlib.Path(LOCAL_MODEL_PATH)
                         
-                        print(f"Loading components manually...")
+                        # Load model components with explicit CPU mapping
+                        s3gen_path = model_path / "s3gen.pt"
+                        ve_path = model_path / "ve.pt"
+                        tokenizer_path = model_path / "tokenizer.json"
+                        t3_cfg_path = model_path / "t3_cfg.pt"
+                        
+                        print(f"Loading components with CPU mapping...")
                         print(f"  s3gen: {s3gen_path}")
                         print(f"  ve: {ve_path}")
                         print(f"  tokenizer: {tokenizer_path}")
                         print(f"  t3_cfg: {t3_cfg_path}")
                         
-                        # Load the components
-                        s3gen = torch.load(s3gen_path, map_location=device)
-                        ve = torch.load(ve_path, map_location=device)
+                        # Load components with CPU mapping
+                        s3gen = torch.load(s3gen_path, map_location=torch.device('cpu'))
+                        ve = torch.load(ve_path, map_location=torch.device('cpu'))
+                        t3_cfg = torch.load(t3_cfg_path, map_location=torch.device('cpu'))
                         
                         # Load tokenizer
                         import json
                         with open(tokenizer_path, 'r') as f:
                             tokenizer = json.load(f)
                         
-                        # Create model instance with loaded components
-                        model = ChatterboxTTS(s3gen, ve, tokenizer, device)
-                        print("Chatterbox model loaded successfully with manual component loading.")
+                        print("Components loaded, creating ChatterboxTTS instance...")
+                        
+                        # Try different constructor signatures
+                        try:
+                            # Try with all components
+                            model = ChatterboxTTS(s3gen, ve, tokenizer, t3_cfg)
+                            print("Chatterbox model loaded with 4-argument constructor.")
+                        except Exception as constructor_error:
+                            print(f"4-arg constructor failed: {constructor_error}")
+                            try:
+                                # Try with device parameter
+                                model = ChatterboxTTS(s3gen, ve, tokenizer, device=device)
+                                print("Chatterbox model loaded with device parameter.")
+                            except Exception as device_error:
+                                print(f"Device constructor failed: {device_error}")
+                                # Try creating with from_pretrained but patch the loading
+                                print("Attempting to patch model loading...")
+                                
+                                # Temporarily patch torch.load to always use CPU
+                                original_load = torch.load
+                                def patched_load(f, map_location=None, *args, **kwargs):
+                                    return original_load(f, map_location=torch.device('cpu'), *args, **kwargs)
+                                
+                                torch.load = patched_load
+                                try:
+                                    model = ChatterboxTTS.from_local(LOCAL_MODEL_PATH)
+                                    print("Chatterbox model loaded with patched torch.load.")
+                                finally:
+                                    torch.load = original_load
+                        
                     except Exception as e3:
                         print(f"Manual loading failed: {e3}")
                         raise e3