Update stt_factory.py

stt_factory.py

@@ -5,59 +5,100 @@ from typing import Optional
 from stt_interface import STTInterface, STTEngineType, log
 from stt_google import GoogleCloudSTT
 from config_provider import ConfigProvider
+from stt_interface import STTInterface
 
+# Import providers conditionally
+stt_providers = {}
+
+try:
+    from stt_google import GoogleCloudSTT
+    stt_providers['google'] = GoogleCloudSTT
+except ImportError:
+    log("⚠️ Google Cloud STT not available")
+
+try:
+    from stt_azure import AzureSTT
+    stt_providers['azure'] = AzureSTT
+except ImportError:
+    log("⚠️ Azure STT not available")
+
+try:
+    from stt_flicker import FlickerSTT
+    stt_providers['flicker'] = FlickerSTT
+except ImportError:
+    log("⚠️ Flicker STT not available")
+
+class NoSTT(STTInterface):
+    """Dummy STT provider when STT is disabled"""
+    
+    async def start_streaming(self, config) -> None:
+        pass
+    
+    async def stream_audio(self, audio_chunk: bytes):
+        return
+        yield  # Make it a generator
+    
+    async def stop_streaming(self):
+        return None
+    
+    def supports_realtime(self) -> bool:
+        return False
+    
+    def get_supported_languages(self):
+        return []
+    
+    def get_provider_name(self) -> str:
+        return "no_stt"
+        
 class STTFactory:
-    """Factory for creating STT provider instances"""
+    """Factory for creating STT providers"""
     
     @staticmethod
     def create_provider() -> Optional[STTInterface]:
         """Create STT provider based on configuration"""
-        cfg = ConfigProvider.get()
-        stt_config = cfg.global_config.stt_provider
-        
-        if not stt_config or stt_config.name == "no_stt":
-            log("🔇 No STT provider configured")
-            return None
-        
-        provider_name = stt_config.name
-        log(f"🏭 Creating STT provider: {provider_name}")
-        
-        # Get provider definition
-        provider_def = cfg.global_config.get_provider_config("stt", provider_name)
-        if not provider_def:
-            log(f"⚠️ Unknown STT provider: {provider_name}")
-            return None
-        
-        # Get credentials/API key
-        credentials = STTFactory._get_credentials(stt_config)
-        if not credentials and provider_def.requires_api_key:
-            log(f"⚠️ No credentials for STT provider: {provider_name}")
-            return None
-        
-        # Create provider based on name
-        if provider_name == "google":
-            return GoogleCloudSTT(credentials)
-        elif provider_name == "azure":
-            log("⚠️ Azure STT not implemented yet")
-            return None
-        elif provider_name == "amazon":
-            log("⚠️ Amazon STT not implemented yet")
-            return None
-        elif provider_name == "flicker":
-            log("⚠️ Flicker STT not implemented yet")
-            return None
-        else:
-            log(f"⚠️ Unsupported STT provider: {provider_name}")
-            return None
+        try:
+            cfg = ConfigProvider.get()
+            stt_engine = cfg.global_config.stt_engine
+            
+            log(f"🎤 Creating STT provider: {stt_engine}")
+            
+            if stt_engine == "no_stt":
+                return NoSTT()
+            
+            # Get provider class
+            provider_class = stt_providers.get(stt_engine)
+            if not provider_class:
+                log(f"⚠️ STT provider '{stt_engine}' not available")
+                return NoSTT()
+            
+            # Get API key or credentials
+            api_key = cfg.global_config.get_stt_api_key()
+            
+            if not api_key:
+                log(f"⚠️ No API key configured for {stt_engine}")
+                return NoSTT()
+            
+            # Create provider instance
+            if stt_engine == "google":
+                # For Google, api_key is the path to credentials JSON
+                return provider_class(credentials_path=api_key)
+            elif stt_engine == "azure":
+                # For Azure, parse the key format
+                parts = api_key.split('|')
+                if len(parts) != 2:
+                    log("⚠️ Invalid Azure STT key format. Expected: subscription_key|region")
+                    return NoSTT()
+                return provider_class(subscription_key=parts[0], region=parts[1])
+            elif stt_engine == "flicker":
+                return provider_class(api_key=api_key)
+            else:
+                return provider_class(api_key=api_key)
+                
+        except Exception as e:
+            log(f"❌ Failed to create STT provider: {e}")
+            return NoSTT()
     
     @staticmethod
-    def _get_credentials(stt_config) -> Optional[str]:
-        """Get decrypted credentials/API key"""
-        if not stt_config.api_key:
-            return None
-            
-        if stt_config.api_key.startswith("enc:"):
-            from encryption_utils import decrypt
-            return decrypt(stt_config.api_key)
-        
-        return stt_config.api_key
+    def get_available_providers():
+        """Get list of available STT providers"""
+        return list(stt_providers.keys()) + ["no_stt"]