498 lines
17 KiB
Python
498 lines
17 KiB
Python
"""
|
|
Interface for Voice Services
|
|
Provides a generic interface layer between routes and voice connectors.
|
|
Handles voice operations including speech-to-text, text-to-speech, and translation.
|
|
"""
|
|
|
|
import logging
|
|
from typing import Dict, Any, Optional, List
|
|
from datetime import datetime, UTC
|
|
|
|
from modules.connectors.connectorVoiceGoogle import ConnectorGoogleSpeech
|
|
from modules.datamodels.datamodelVoice import VoiceSettings
|
|
from modules.datamodels.datamodelUam import User
|
|
from modules.shared.timezoneUtils import get_utc_timestamp
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Singleton factory for Voice instances
|
|
_instancesVoice = {}
|
|
|
|
class VoiceObjects:
|
|
"""
|
|
Interface for Voice Services.
|
|
Provides a generic interface layer between routes and voice connectors.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""Initialize the Voice Interface."""
|
|
self.currentUser: Optional[User] = None
|
|
self.userId: Optional[str] = None
|
|
self._google_speech_connector: Optional[ConnectorGoogleSpeech] = None
|
|
|
|
def setUserContext(self, currentUser: User):
|
|
"""Set the user context for the interface."""
|
|
if not currentUser:
|
|
logger.info("Initializing voice interface without user context")
|
|
return
|
|
|
|
self.currentUser = currentUser
|
|
self.userId = currentUser.id
|
|
|
|
if not self.userId:
|
|
raise ValueError("Invalid user context: id is required")
|
|
|
|
logger.debug(f"Voice interface user context set: userId={self.userId}")
|
|
|
|
def _getGoogleSpeechConnector(self) -> ConnectorGoogleSpeech:
|
|
"""Get or create Google Cloud Speech connector instance."""
|
|
if self._google_speech_connector is None:
|
|
try:
|
|
self._google_speech_connector = ConnectorGoogleSpeech()
|
|
logger.info("✅ Google Cloud Speech connector initialized")
|
|
except Exception as e:
|
|
logger.error(f"❌ Failed to initialize Google Cloud Speech connector: {e}")
|
|
raise
|
|
return self._google_speech_connector
|
|
|
|
# Speech-to-Text Operations
|
|
|
|
async def speechToText(self, audioContent: bytes, language: str = "de-DE",
|
|
sampleRate: int = None, channels: int = None) -> Dict[str, Any]:
|
|
"""
|
|
Convert speech to text using Google Cloud Speech-to-Text API.
|
|
|
|
Args:
|
|
audioContent: Raw audio data
|
|
language: Language code (e.g., 'de-DE', 'en-US')
|
|
sampleRate: Audio sample rate (auto-detected if None)
|
|
channels: Number of audio channels (auto-detected if None)
|
|
|
|
Returns:
|
|
Dict containing transcribed text, confidence, and metadata
|
|
"""
|
|
try:
|
|
logger.info(f"🎤 Speech-to-text request: {len(audioContent)} bytes, language: {language}")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.speech_to_text(
|
|
audio_content=audioContent,
|
|
language=language,
|
|
sample_rate=sampleRate,
|
|
channels=channels
|
|
)
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Speech-to-text successful: '{result['text']}' (confidence: {result['confidence']:.2f})")
|
|
else:
|
|
logger.warning(f"⚠️ Speech-to-text failed: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Speech-to-text error: {e}")
|
|
return {
|
|
"success": False,
|
|
"text": "",
|
|
"confidence": 0.0,
|
|
"error": str(e)
|
|
}
|
|
|
|
# Translation Operations
|
|
|
|
async def translateText(self, text: str, sourceLanguage: str = "de",
|
|
targetLanguage: str = "en") -> Dict[str, Any]:
|
|
"""
|
|
Translate text using Google Cloud Translation API.
|
|
|
|
Args:
|
|
text: Text to translate
|
|
sourceLanguage: Source language code (e.g., 'de', 'en')
|
|
targetLanguage: Target language code (e.g., 'en', 'de')
|
|
|
|
Returns:
|
|
Dict containing translated text and metadata
|
|
"""
|
|
try:
|
|
logger.info(f"🌐 Translation request: '{text}' ({sourceLanguage} -> {targetLanguage})")
|
|
|
|
if not text.strip():
|
|
return {
|
|
"success": False,
|
|
"translated_text": "",
|
|
"error": "Empty text provided"
|
|
}
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.translate_text(
|
|
text=text,
|
|
source_language=sourceLanguage,
|
|
target_language=targetLanguage
|
|
)
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Translation successful: '{result['translated_text']}'")
|
|
else:
|
|
logger.warning(f"⚠️ Translation failed: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Translation error: {e}")
|
|
return {
|
|
"success": False,
|
|
"translated_text": "",
|
|
"error": str(e)
|
|
}
|
|
|
|
# Combined Operations
|
|
|
|
async def speechToTranslatedText(self, audioContent: bytes,
|
|
fromLanguage: str = "de-DE",
|
|
toLanguage: str = "en") -> Dict[str, Any]:
|
|
"""
|
|
Complete pipeline: Speech-to-Text + Translation.
|
|
|
|
Args:
|
|
audioContent: Raw audio data
|
|
fromLanguage: Source language for speech recognition
|
|
toLanguage: Target language for translation
|
|
|
|
Returns:
|
|
Dict containing original text, translated text, and metadata
|
|
"""
|
|
try:
|
|
logger.info(f"🔄 Speech-to-translation pipeline: {fromLanguage} -> {toLanguage}")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.speech_to_translated_text(
|
|
audio_content=audioContent,
|
|
from_language=fromLanguage,
|
|
to_language=toLanguage
|
|
)
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Complete pipeline successful:")
|
|
logger.info(f" Original: '{result['original_text']}'")
|
|
logger.info(f" Translated: '{result['translated_text']}'")
|
|
else:
|
|
logger.warning(f"⚠️ Speech-to-translation pipeline failed: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Speech-to-translation pipeline error: {e}")
|
|
return {
|
|
"success": False,
|
|
"original_text": "",
|
|
"translated_text": "",
|
|
"error": str(e)
|
|
}
|
|
|
|
# Text-to-Speech Operations
|
|
|
|
async def textToSpeech(self, text: str, languageCode: str = "de-DE",
|
|
voiceName: str = None) -> Dict[str, Any]:
|
|
"""
|
|
Convert text to speech using Google Cloud Text-to-Speech.
|
|
|
|
Args:
|
|
text: Text to convert to speech
|
|
languageCode: Language code (e.g., 'de-DE', 'en-US')
|
|
voiceName: Specific voice name (optional)
|
|
|
|
Returns:
|
|
Dict with success status and audio data
|
|
"""
|
|
try:
|
|
logger.info(f"🔊 Text-to-Speech request: '{text[:50]}...' in {languageCode}")
|
|
|
|
if not text.strip():
|
|
return {
|
|
"success": False,
|
|
"error": "Empty text provided for text-to-speech"
|
|
}
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.text_to_speech(
|
|
text=text,
|
|
language_code=languageCode,
|
|
voice_name=voiceName
|
|
)
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Text-to-Speech successful: {len(result['audio_content'])} bytes")
|
|
else:
|
|
logger.warning(f"⚠️ Text-to-Speech failed: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Text-to-Speech error: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": str(e)
|
|
}
|
|
|
|
# Voice Settings Management
|
|
|
|
def getVoiceSettings(self, userId: str) -> Optional[VoiceSettings]:
|
|
"""
|
|
Get voice settings for a user.
|
|
|
|
Args:
|
|
userId: User ID to get settings for
|
|
|
|
Returns:
|
|
VoiceSettings object or None if not found
|
|
"""
|
|
try:
|
|
# This would typically query the database
|
|
# For now, return None as this is handled by the database interface
|
|
logger.debug(f"Getting voice settings for user: {userId}")
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error getting voice settings: {e}")
|
|
return None
|
|
|
|
def createVoiceSettings(self, settingsData: Dict[str, Any]) -> Optional[VoiceSettings]:
|
|
"""
|
|
Create new voice settings.
|
|
|
|
Args:
|
|
settingsData: Dictionary containing voice settings data
|
|
|
|
Returns:
|
|
Created VoiceSettings object or None if failed
|
|
"""
|
|
try:
|
|
logger.info(f"Creating voice settings: {settingsData}")
|
|
|
|
# Add timestamps
|
|
currentTime = get_utc_timestamp()
|
|
settingsData["creationDate"] = currentTime
|
|
settingsData["lastModified"] = currentTime
|
|
|
|
# Create VoiceSettings object
|
|
voiceSettings = VoiceSettings(**settingsData)
|
|
|
|
logger.info(f"✅ Voice settings created: {voiceSettings.id}")
|
|
return voiceSettings
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error creating voice settings: {e}")
|
|
return None
|
|
|
|
def updateVoiceSettings(self, userId: str, settingsData: Dict[str, Any]) -> Optional[VoiceSettings]:
|
|
"""
|
|
Update existing voice settings.
|
|
|
|
Args:
|
|
userId: User ID to update settings for
|
|
settingsData: Dictionary containing updated voice settings data
|
|
|
|
Returns:
|
|
Updated VoiceSettings object or None if failed
|
|
"""
|
|
try:
|
|
logger.info(f"Updating voice settings for user {userId}: {settingsData}")
|
|
|
|
# Add last modified timestamp
|
|
settingsData["lastModified"] = get_utc_timestamp()
|
|
|
|
# Create updated VoiceSettings object
|
|
voiceSettings = VoiceSettings(**settingsData)
|
|
|
|
logger.info(f"✅ Voice settings updated: {voiceSettings.id}")
|
|
return voiceSettings
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error updating voice settings: {e}")
|
|
return None
|
|
|
|
def getOrCreateVoiceSettings(self, userId: str) -> Optional[VoiceSettings]:
|
|
"""
|
|
Get existing voice settings or create default ones.
|
|
|
|
Args:
|
|
userId: User ID to get/create settings for
|
|
|
|
Returns:
|
|
VoiceSettings object
|
|
"""
|
|
try:
|
|
# Try to get existing settings
|
|
existingSettings = self.getVoiceSettings(userId)
|
|
|
|
if existingSettings:
|
|
return existingSettings
|
|
|
|
# Create default settings if none exist
|
|
defaultSettings = {
|
|
"userId": userId,
|
|
"sttLanguage": "de-DE",
|
|
"ttsLanguage": "de-DE",
|
|
"ttsVoice": "de-DE-Wavenet-A",
|
|
"translationEnabled": True,
|
|
"targetLanguage": "en-US"
|
|
}
|
|
|
|
return self.createVoiceSettings(defaultSettings)
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error getting or creating voice settings: {e}")
|
|
return None
|
|
|
|
# Language and Voice Information
|
|
|
|
async def getAvailableLanguages(self) -> Dict[str, Any]:
|
|
"""
|
|
Get available languages from Google Cloud Text-to-Speech.
|
|
|
|
Returns:
|
|
Dict containing success status and list of available languages
|
|
"""
|
|
try:
|
|
logger.info("🌐 Getting available languages from Google Cloud TTS")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.get_available_languages()
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Found {len(result['languages'])} available languages")
|
|
else:
|
|
logger.warning(f"⚠️ Failed to get languages: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error getting available languages: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": str(e),
|
|
"languages": []
|
|
}
|
|
|
|
async def getAvailableVoices(self, languageCode: Optional[str] = None) -> Dict[str, Any]:
|
|
"""
|
|
Get available voices from Google Cloud Text-to-Speech.
|
|
|
|
Args:
|
|
languageCode: Optional language code to filter voices
|
|
|
|
Returns:
|
|
Dict containing success status and list of available voices
|
|
"""
|
|
try:
|
|
logger.info(f"🎤 Getting available voices, language filter: {languageCode}")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = await connector.get_available_voices(language_code=languageCode)
|
|
|
|
if result["success"]:
|
|
logger.info(f"✅ Found {len(result['voices'])} voices for language filter: {languageCode}")
|
|
else:
|
|
logger.warning(f"⚠️ Failed to get voices: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error getting available voices: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": str(e),
|
|
"voices": []
|
|
}
|
|
|
|
# Audio Validation
|
|
|
|
def validateAudioFormat(self, audioContent: bytes) -> Dict[str, Any]:
|
|
"""
|
|
Validate audio format for Google Cloud Speech-to-Text.
|
|
|
|
Args:
|
|
audioContent: Raw audio data
|
|
|
|
Returns:
|
|
Dict containing validation results
|
|
"""
|
|
try:
|
|
logger.debug(f"Validating audio format: {len(audioContent)} bytes")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
result = connector.validate_audio_format(audioContent)
|
|
|
|
if result["valid"]:
|
|
logger.debug(f"✅ Audio validation successful: {result['format']}, {result['sample_rate']}Hz, {result['channels']}ch")
|
|
else:
|
|
logger.warning(f"⚠️ Audio validation failed: {result.get('error', 'Unknown error')}")
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Audio validation error: {e}")
|
|
return {
|
|
"valid": False,
|
|
"error": str(e)
|
|
}
|
|
|
|
# Health Check
|
|
|
|
async def healthCheck(self) -> Dict[str, Any]:
|
|
"""
|
|
Perform health check for voice services.
|
|
|
|
Returns:
|
|
Dict containing health status and test results
|
|
"""
|
|
try:
|
|
logger.info("🏥 Performing voice services health check")
|
|
|
|
connector = self._getGoogleSpeechConnector()
|
|
|
|
# Test with a simple translation
|
|
testResult = await connector.translate_text(
|
|
text="Hello",
|
|
source_language="en",
|
|
target_language="de"
|
|
)
|
|
|
|
if testResult["success"]:
|
|
return {
|
|
"status": "healthy",
|
|
"service": "Google Cloud Speech-to-Text & Translation",
|
|
"test_translation": testResult["translated_text"]
|
|
}
|
|
else:
|
|
return {
|
|
"status": "unhealthy",
|
|
"error": testResult.get("error", "Unknown error")
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Health check failed: {e}")
|
|
return {
|
|
"status": "unhealthy",
|
|
"error": str(e)
|
|
}
|
|
|
|
|
|
def getVoiceInterface(currentUser: User = None) -> VoiceObjects:
|
|
"""
|
|
Factory function to get or create Voice interface instance.
|
|
|
|
Args:
|
|
currentUser: User object for context (optional)
|
|
|
|
Returns:
|
|
VoiceObjects instance
|
|
"""
|
|
# For now, create a new instance each time
|
|
# In the future, this could be enhanced with singleton pattern per user
|
|
voiceInterface = VoiceObjects()
|
|
|
|
if currentUser:
|
|
voiceInterface.setUserContext(currentUser)
|
|
|
|
return voiceInterface
|