Update app.py

app.py

@@ -112,79 +112,87 @@ if chatterbox_available:
             device = "cuda" if torch.cuda.is_available() else "cpu"
             print(f"Using device: {device}")
             
-            # Try different loading methods based on the ChatterboxTTS API
+            # Based on API inspection:
+            # ChatterboxTTS.from_local signature: (ckpt_dir, device) -> 'ChatterboxTTS'
+            # ChatterboxTTS.from_pretrained signature: (device) -> 'ChatterboxTTS'
+            
             try:
-                # Method 1: Try from_local with just the path (let it handle device internally)
-                model = ChatterboxTTS.from_local(LOCAL_MODEL_PATH)
+                # Method 1: Use from_local with correct signature (ckpt_dir, device)
+                model = ChatterboxTTS.from_local(LOCAL_MODEL_PATH, device)
                 print("Chatterbox model loaded successfully using from_local method.")
             except Exception as e1:
                 print(f"from_local attempt failed: {e1}")
                 try:
-                    # Method 2: Try from_pretrained with just the path
-                    model = ChatterboxTTS.from_pretrained(LOCAL_MODEL_PATH)
+                    # Method 2: Use from_pretrained with device only
+                    model = ChatterboxTTS.from_pretrained(device)
                     print("Chatterbox model loaded successfully with from_pretrained.")
                 except Exception as e2:
                     print(f"from_pretrained failed: {e2}")
                     try:
-                        # Method 3: Try with explicit CPU mapping in from_local
+                        # Method 3: Manual loading with correct constructor signature
+                        # ChatterboxTTS.__init__ signature: (self, t3, s3gen, ve, tokenizer, device, conds=None)
                         import pathlib
+                        import json
+                        
                         model_path = pathlib.Path(LOCAL_MODEL_PATH)
                         
-                        # Load model components with explicit CPU mapping
+                        print(f"Manual loading with correct constructor signature...")
+                        
+                        # Load all components
                         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 components with CPU mapping
+                        print(f"  Loading s3gen from: {s3gen_path}")
                         s3gen = torch.load(s3gen_path, map_location=torch.device('cpu'))
+                        
+                        print(f"  Loading ve from: {ve_path}")
                         ve = torch.load(ve_path, map_location=torch.device('cpu'))
+                        
+                        print(f"  Loading t3_cfg from: {t3_cfg_path}")
                         t3_cfg = torch.load(t3_cfg_path, map_location=torch.device('cpu'))
                         
-                        # Load tokenizer
-                        import json
+                        print(f"  Loading tokenizer from: {tokenizer_path}")
                         with open(tokenizer_path, 'r') as f:
-                            tokenizer = json.load(f)
-                        
-                        print("Components loaded, creating ChatterboxTTS instance...")
+                            tokenizer_data = json.load(f)
                         
-                        # Try different constructor signatures
+                        # The tokenizer might need to be instantiated as a proper object
+                        # Let's try to use the ChatterboxTTS internal tokenizer class
                         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
+                            from chatterbox.models.tokenizers.tokenizer import EnTokenizer
+                            tokenizer = EnTokenizer.from_dict(tokenizer_data)
+                            print("  Created EnTokenizer from JSON data")
+                        except Exception as tok_error:
+                            print(f"  Could not create EnTokenizer: {tok_error}")
+                            tokenizer = tokenizer_data  # Use raw data as fallback
+                        
+                        print("  Creating ChatterboxTTS instance with correct signature...")
+                        
+                        # Constructor signature: (self, t3, s3gen, ve, tokenizer, device, conds=None)
+                        model = ChatterboxTTS(
+                            t3=t3_cfg,
+                            s3gen=s3gen, 
+                            ve=ve,
+                            tokenizer=tokenizer,
+                            device=device
+                        )
+                        print("Chatterbox model loaded successfully with manual constructor.")
                         
                     except Exception as e3:
                         print(f"Manual loading failed: {e3}")
-                        raise e3
+                        print(f"Detailed error: {str(e3)}")
+                        
+                        # Last resort: try with different parameter orders
+                        try:
+                            print("Trying alternative parameter order...")
+                            model = ChatterboxTTS(
+                                s3gen, ve, tokenizer, t3_cfg, device
+                            )
+                            print("Chatterbox model loaded with alternative parameter order.")
+                        except Exception as e4:
+                            print(f"Alternative parameter order failed: {e4}")
+                            raise e3
                     
         except Exception as e:
             print(f"ERROR: Failed to load Chatterbox model from local directory: {e}")