Update controller to test Diffusers

controller.py

@@ -7,6 +7,7 @@ class SimpleSonicDiffusionController:
     def __init__(self):
         self.model_loaded = False
         self.tokenizer_loaded = False
+        self.pipe_loaded = False
         self.device = self._get_device()
         
     def _get_device(self):
@@ -25,38 +26,60 @@ class SimpleSonicDiffusionController:
     
     def load_model(self):
         """Load a simple model to verify libraries are working"""
+        status_messages = []
+        
         try:
+            # Test PyTorch
             import torch
             self.test_tensor = torch.rand(3, 3)
+            status_messages.append("✓ PyTorch loaded successfully")
             
             # Try loading a simple tokenizer from transformers
             try:
                 from transformers import AutoTokenizer
                 self.tokenizer = AutoTokenizer.from_pretrained("gpt2")
                 self.tokenizer_loaded = True
-                message = "Model and tokenizer loaded successfully!"
+                status_messages.append("✓ Transformers tokenizer loaded")
+            except Exception as e:
+                status_messages.append(f"✗ Transformers error: {str(e)}")
+            
+            # Try loading a simple pipeline from diffusers
+            try:
+                from diffusers import DiffusionPipeline
+                # Just check if the class exists, don't actually load a model
+                self.pipe_class = DiffusionPipeline
+                self.pipe_loaded = True
+                status_messages.append("✓ Diffusers available")
             except Exception as e:
-                message = f"PyTorch loaded, but Transformers failed: {str(e)}"
+                status_messages.append(f"✗ Diffusers error: {str(e)}")
             
             self.model_loaded = True
-            return message
+            return "\n".join(status_messages)
             
         except Exception as e:
             return f"Error loading model: {str(e)}"
     
     def generate(self, text_prompt, audio_path=None):
-        """Generate using transformers if available"""
+        """Generate text using available libraries"""
         if not self.model_loaded:
             return "Error: Model not loaded. Please click 'Load Model' first."
         
+        results = []
+        
         try:
+            # Use tokenizer if available
             if self.tokenizer_loaded:
-                # Use the tokenizer to process the text
                 tokens = self.tokenizer(text_prompt, return_tensors="pt")
                 token_count = len(tokens['input_ids'][0])
-                return f"Processed prompt: '{text_prompt}'\nTokenized into {token_count} tokens."
+                results.append(f"Transformers: Tokenized into {token_count} tokens")
+            
+            # Check diffusers status
+            if self.pipe_loaded:
+                results.append("Diffusers is available for pipeline creation")
             else:
-                return f"Tokenizer not available. Simple echo: '{text_prompt}'"
+                results.append("Diffusers is not available")
+                
+            return "\n".join(results)
                 
         except Exception as e:
             return f"Error during generation: {str(e)}"