added more logs

core/ai_pipeline.py

@@ -90,7 +90,7 @@ class MonsterGenerationPipeline:
                         audio_input: Optional[str] = None,
                         text_input: Optional[str] = None,
                         reference_images: Optional[List] = None,
-                        user_id: str = None) -> Dict[str, Any]:
+                        user_id: Optional[str] = None) -> Dict[str, Any]:
         """Main monster generation pipeline"""
         
         generation_log = {
@@ -98,51 +98,62 @@ class MonsterGenerationPipeline:
             'timestamp': datetime.now().isoformat(),
             'stages_completed': [],
             'fallbacks_used': [],
-            'success': False
+            'success': False,
+            'errors': []
         }
         
         try:
+            print("🚀 Starting monster generation pipeline...")
+            
             # Stage 1: Speech to Text (if audio provided)
             description = ""
             if audio_input and os.path.exists(audio_input):
                 try:
+                    print("🎤 Processing audio input...")
                     stt_model = self._lazy_load_model('stt')
                     if stt_model:
                         description = stt_model.transcribe(audio_input)
                         generation_log['stages_completed'].append('stt')
+                        print(f"✅ STT completed: {description[:100]}...")
                     else:
                         raise Exception("STT model failed to load")
                 except Exception as e:
-                    print(f"STT failed: {e}")
+                    print(f"❌ STT failed: {e}")
                     description = text_input or "Create a friendly digital monster"
                     generation_log['fallbacks_used'].append('stt')
+                    generation_log['errors'].append(f"STT error: {str(e)}")
                 finally:
                     # Unload STT to free memory
                     self._unload_model('stt')
             else:
                 description = text_input or "Create a friendly digital monster"
+                print(f"📝 Using text input: {description}")
             
             # Stage 2: Generate monster characteristics
             monster_traits = {}
             monster_dialogue = ""
             try:
+                print("🧠 Generating monster traits and dialogue...")
                 text_gen = self._lazy_load_model('text_gen')
                 if text_gen:
                     monster_traits = text_gen.generate_traits(description)
                     monster_dialogue = text_gen.generate_dialogue(monster_traits)
                     generation_log['stages_completed'].append('text_gen')
+                    print(f"✅ Text generation completed: {monster_traits.get('name', 'Unknown')}")
                 else:
                     raise Exception("Text generation model failed to load")
             except Exception as e:
-                print(f"Text generation failed: {e}")
+                print(f"❌ Text generation failed: {e}")
                 monster_traits, monster_dialogue = self.fallback_manager.handle_text_gen_failure(description)
                 generation_log['fallbacks_used'].append('text_gen')
+                generation_log['errors'].append(f"Text generation error: {str(e)}")
             finally:
                 self._unload_model('text_gen')
             
             # Stage 3: Generate monster image
             monster_image = None
             try:
+                print("🎨 Generating monster image...")
                 image_gen = self._lazy_load_model('image_gen')
                 if image_gen:
                     # Create enhanced prompt from traits
@@ -154,12 +165,14 @@ class MonsterGenerationPipeline:
                         height=512
                     )
                     generation_log['stages_completed'].append('image_gen')
+                    print("✅ Image generation completed")
                 else:
                     raise Exception("Image generation model failed to load")
             except Exception as e:
-                print(f"Image generation failed: {e}")
+                print(f"❌ Image generation failed: {e}")
                 monster_image = self.fallback_manager.handle_image_gen_failure(description)
                 generation_log['fallbacks_used'].append('image_gen')
+                generation_log['errors'].append(f"Image generation error: {str(e)}")
             finally:
                 self._unload_model('image_gen')
             
@@ -167,18 +180,21 @@ class MonsterGenerationPipeline:
             model_3d = None
             model_3d_path = None
             try:
+                print("🔲 Converting to 3D model...")
                 model_3d_gen = self._lazy_load_model('3d_gen')
                 if model_3d_gen and monster_image:
                     model_3d = model_3d_gen.image_to_3d(monster_image)
                     # Save 3D model
                     model_3d_path = self._save_3d_model(model_3d, user_id)
                     generation_log['stages_completed'].append('3d_gen')
+                    print("✅ 3D generation completed")
                 else:
-                    raise Exception("3D generation failed")
+                    raise Exception("3D generation failed - no model or image")
             except Exception as e:
-                print(f"3D generation failed: {e}")
+                print(f"❌ 3D generation failed: {e}")
                 model_3d = self.fallback_manager.handle_3d_gen_failure(monster_image)
                 generation_log['fallbacks_used'].append('3d_gen')
+                generation_log['errors'].append(f"3D generation error: {str(e)}")
             finally:
                 self._unload_model('3d_gen')
             
@@ -186,13 +202,16 @@ class MonsterGenerationPipeline:
             rigged_model = model_3d
             if model_3d and self.config.get('enable_rigging', False):
                 try:
+                    print("🦴 Adding rigging...")
                     rigging_proc = self._lazy_load_model('rigging')
                     if rigging_proc:
                         rigged_model = rigging_proc.rig_mesh(model_3d)
                         generation_log['stages_completed'].append('rigging')
+                        print("✅ Rigging completed")
                 except Exception as e:
-                    print(f"Rigging failed: {e}")
+                    print(f"❌ Rigging failed: {e}")
                     generation_log['fallbacks_used'].append('rigging')
+                    generation_log['errors'].append(f"Rigging error: {str(e)}")
                 finally:
                     self._unload_model('rigging')
             
@@ -204,6 +223,7 @@ class MonsterGenerationPipeline:
             )
             
             generation_log['success'] = True
+            print("🎉 Monster generation pipeline completed successfully!")
             
             return {
                 'description': description,
@@ -217,8 +237,9 @@ class MonsterGenerationPipeline:
             }
             
         except Exception as e:
+            print(f"💥 Pipeline error: {e}")
             generation_log['error'] = str(e)
-            print(f"Pipeline error: {e}")
+            generation_log['errors'].append(f"Pipeline error: {str(e)}")
             return self.fallback_generation(description or "digital monster", generation_log)
     
     def _create_image_prompt(self, base_description: str, traits: Dict) -> str:
@@ -243,13 +264,14 @@ class MonsterGenerationPipeline:
         
         return ", ".join(prompt_parts)
     
-    def _save_3d_model(self, model_3d, user_id: str) -> str:
+    def _save_3d_model(self, model_3d, user_id: Optional[str]) -> Optional[str]:
         """Save 3D model to persistent storage"""
         if not model_3d:
             return None
             
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"monster_{user_id}_{timestamp}.glb"
+        user_id_str = user_id or "anonymous"
+        filename = f"monster_{user_id_str}_{timestamp}.glb"
         
         # Use HuggingFace Spaces persistent storage
         if os.path.exists("/data"):
@@ -270,30 +292,31 @@ class MonsterGenerationPipeline:
         
         return filepath
     
-    def _prepare_download_files(self, model_3d, image, user_id: str) -> List[str]:
+    def _prepare_download_files(self, model_3d, image, user_id: Optional[str]) -> List[str]:
         """Prepare downloadable files for user"""
         files = []
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        user_id_str = user_id or "anonymous"
         
         # Save image
         if image:
             if isinstance(image, Image.Image):
-                image_path = f"/tmp/monster_{user_id}_{timestamp}.png"
+                image_path = f"/tmp/monster_{user_id_str}_{timestamp}.png"
                 image.save(image_path)
                 files.append(image_path)
             elif isinstance(image, np.ndarray):
-                image_path = f"/tmp/monster_{user_id}_{timestamp}.png"
+                image_path = f"/tmp/monster_{user_id_str}_{timestamp}.png"
                 Image.fromarray(image).save(image_path)
                 files.append(image_path)
         
         # Save 3D model in multiple formats if available
         if model_3d:
             # GLB format
-            glb_path = f"/tmp/monster_{user_id}_{timestamp}.glb"
+            glb_path = f"/tmp/monster_{user_id_str}_{timestamp}.glb"
             files.append(glb_path)
             
             # OBJ format (optional)
-            obj_path = f"/tmp/monster_{user_id}_{timestamp}.obj"
+            obj_path = f"/tmp/monster_{user_id_str}_{timestamp}.obj"
             files.append(obj_path)
         
         return files

models/model_3d_generator.py

@@ -100,6 +100,7 @@ class Hunyuan3DGenerator:
                 # Safe device movement
                 logger.info(f"📦 Moving model to device: {self.device}")
                 try:
+                    # Check if model is a meta tensor
                     if hasattr(self.model, 'to_empty'):
                         # Use to_empty for meta tensors
                         logger.info("📦 Using to_empty() for safe device movement...")
@@ -115,14 +116,24 @@ class Hunyuan3DGenerator:
                     if "meta tensor" in str(device_error):
                         logger.info("🔄 Attempting CPU fallback for meta tensor issue...")
                         self.device = "cpu"
-                        self.model = self.model.to("cpu")
-                        logger.info("✅ Fallback to CPU successful")
+                        try:
+                            if hasattr(self.model, 'to_empty'):
+                                self.model = self.model.to_empty(device="cpu", dtype=torch_dtype)
+                            else:
+                                self.model = self.model.to("cpu", dtype=torch_dtype)
+                            logger.info("✅ Fallback to CPU successful")
+                        except Exception as cpu_error:
+                            logger.error(f"❌ CPU fallback also failed: {cpu_error}")
+                            logger.info("🔄 Using fallback mode...")
+                            self.model = "fallback"
                     else:
-                        raise device_error
+                        logger.error(f"❌ Non-meta tensor device error: {device_error}")
+                        logger.info("🔄 Using fallback mode...")
+                        self.model = "fallback"
                 
                 # Enable optimizations safely
                 logger.info("📦 Applying model optimizations...")
-                if hasattr(self.model, 'enable_attention_slicing'):
+                if self.model != "fallback" and hasattr(self.model, 'enable_attention_slicing'):
                     self.model.enable_attention_slicing()
                     logger.info("✅ Attention slicing enabled")
                 else:

test_pipeline_fix.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the pipeline fixes work correctly
+"""
+
+import sys
+import os
+import traceback
+from typing import Dict, Any
+
+# Add the project root to the path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+def test_pipeline_fixes():
+    """Test the pipeline with improved error handling"""
+    
+    print("🧪 Testing Monster Generation Pipeline Fixes")
+    print("=" * 50)
+    
+    try:
+        # Import the pipeline
+        from core.ai_pipeline import MonsterGenerationPipeline
+        print("✅ Successfully imported MonsterGenerationPipeline")
+        
+        # Initialize pipeline
+        print("🔧 Initializing pipeline...")
+        pipeline = MonsterGenerationPipeline(device="cpu")  # Use CPU for testing
+        print("✅ Pipeline initialized successfully")
+        
+        # Test with a simple text input
+        print("\n🚀 Testing monster generation...")
+        test_input = "Create a friendly fire monster with wings"
+        
+        result = pipeline.generate_monster(
+            text_input=test_input,
+            user_id="test_user"
+        )
+        
+        print(f"\n📊 Generation Result:")
+        print(f"Status: {result.get('status', 'unknown')}")
+        print(f"Success: {result.get('generation_log', {}).get('success', False)}")
+        print(f"Stages completed: {result.get('generation_log', {}).get('stages_completed', [])}")
+        print(f"Fallbacks used: {result.get('generation_log', {}).get('fallbacks_used', [])}")
+        print(f"Errors: {result.get('generation_log', {}).get('errors', [])}")
+        
+        if result.get('traits'):
+            print(f"Monster name: {result.get('traits', {}).get('name', 'Unknown')}")
+            print(f"Monster element: {result.get('traits', {}).get('element', 'Unknown')}")
+        
+        if result.get('dialogue'):
+            print(f"Monster dialogue: {result.get('dialogue', '')}")
+        
+        print(f"Download files: {result.get('download_files', [])}")
+        
+        # Clean up
+        pipeline.cleanup()
+        print("\n🧹 Pipeline cleaned up successfully")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed with error: {e}")
+        print(f"Error type: {type(e).__name__}")
+        print("Full traceback:")
+        traceback.print_exc()
+        return False
+
+def test_fallback_manager():
+    """Test the fallback manager"""
+    
+    print("\n🧪 Testing Fallback Manager")
+    print("=" * 30)
+    
+    try:
+        from utils.fallbacks import FallbackManager
+        
+        fallback = FallbackManager()
+        
+        # Test text generation fallback
+        print("📝 Testing text generation fallback...")
+        traits, dialogue = fallback.handle_text_gen_failure("Create a water monster")
+        print(f"✅ Generated traits: {traits.get('name', 'Unknown')}")
+        print(f"✅ Generated dialogue: {dialogue}")
+        
+        # Test image generation fallback
+        print("🎨 Testing image generation fallback...")
+        image = fallback.handle_image_gen_failure("Create a fire monster")
+        print(f"✅ Generated image: {type(image)}")
+        
+        # Test 3D generation fallback
+        print("🔲 Testing 3D generation fallback...")
+        model_3d = fallback.handle_3d_gen_failure(image)
+        print(f"✅ Generated 3D model: {type(model_3d)}")
+        
+        print("✅ All fallback tests passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Fallback test failed: {e}")
+        traceback.print_exc()
+        return False
+
+def main():
+    """Main test function"""
+    
+    print("🔍 Starting Pipeline Fix Verification")
+    print("=" * 50)
+    
+    # Test fallback manager first (doesn't require heavy models)
+    fallback_success = test_fallback_manager()
+    
+    # Test full pipeline (may fail due to missing models, but should show better error handling)
+    pipeline_success = test_pipeline_fixes()
+    
+    print("\n" + "=" * 50)
+    print("📋 Test Results Summary:")
+    print(f"Fallback Manager: {'✅ PASSED' if fallback_success else '❌ FAILED'}")
+    print(f"Pipeline: {'✅ PASSED' if pipeline_success else '❌ FAILED'}")
+    
+    if fallback_success and pipeline_success:
+        print("\n🎉 All tests passed! Pipeline fixes are working correctly.")
+    elif fallback_success:
+        print("\n⚠️ Fallback manager works, but pipeline may need model dependencies.")
+        print("This is expected if models aren't installed.")
+    else:
+        print("\n❌ Some tests failed. Check the error messages above.")
+    
+    return fallback_success and pipeline_success
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

utils/fallbacks.py

@@ -148,18 +148,32 @@ class FallbackManager:
     def complete_fallback_generation(self, description: str, generation_log: Dict) -> Dict[str, Any]:
         """Complete fallback generation when entire pipeline fails"""
         
+        print("🔄 Starting complete fallback generation...")
+        
         # Generate all components using fallbacks
+        print("📝 Generating fallback text...")
         traits, dialogue = self.handle_text_gen_failure(description)
+        print(f"✅ Fallback text generated: {traits.get('name', 'Unknown')}")
+        
+        print("🎨 Generating fallback image...")
         image = self.handle_image_gen_failure(description)
+        print("✅ Fallback image generated")
+        
+        print("🔲 Generating fallback 3D model...")
         model_3d = self.handle_3d_gen_failure(image)
+        print("✅ Fallback 3D model generated")
         
         # Save fallback results
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         image_path = f"/tmp/fallback_monster_{timestamp}.png"
         model_path = f"/tmp/fallback_monster_{timestamp}.glb"
         
+        print(f"💾 Saving fallback files...")
         image.save(image_path)
         model_3d.export(model_path)
+        print(f"✅ Fallback files saved: {image_path}, {model_path}")
+        
+        print("🎉 Complete fallback generation finished!")
         
         return {
             'description': description,