Brand and Term Mispronunciation

class PronunciationManager:
    """Manage pronunciation for brand and domain terms"""
    
    # Custom lexicon with IPA and alternative spellings
    LEXICON = {
        "Zapp Chess": {
            "phonetic": "Zap Chess",  # How to write for TTS
            "ipa": "zæp tʃɛs",
            "ssml": '<phoneme alphabet="ipa" ph="zæp tʃɛs">Zapp Chess</phoneme>'
        },
        "GDPR": {
            "phonetic": "G D P R",
            "ssml": '<say-as interpret-as="characters">GDPR</say-as>'
        },
        "OAuth": {
            "phonetic": "oh auth",
            "ipa": "oʊ ɔːθ",
            "ssml": '<phoneme alphabet="ipa" ph="oʊ ɔːθ">OAuth</phoneme>'
        },
        "v2.5": {
            "phonetic": "version two point five",
            "ssml": '<say-as interpret-as="characters">v</say-as> 2.5'
        }
    }
    
    def __init__(self, use_ssml=True):
        self.use_ssml = use_ssml
    
    def process_text(self, text: str) -> str:
        """Replace terms with pronunciation-safe versions"""
        processed = text
        
        for term, pronunciation in self.LEXICON.items():
            if term.lower() in processed.lower():
                if self.use_ssml:
                    replacement = pronunciation.get("ssml", 
                                    pronunciation["phonetic"])
                else:
                    replacement = pronunciation["phonetic"]
                
                # Case-insensitive replacement
                import re
                processed = re.sub(
                    re.escape(term), 
                    replacement, 
                    processed, 
                    flags=re.IGNORECASE
                )
        
        return processed
    
    def add_term(self, term: str, phonetic: str, 
                 ipa: str = None) -> None:
        """Add new term to lexicon"""
        self.LEXICON[term] = {
            "phonetic": phonetic,
            "ipa": ipa,
            "ssml": f'<phoneme alphabet="ipa" ph="{ipa}">{term}</phoneme>' 
                    if ipa else phonetic
        }


# ElevenLabs specific pronunciation
class ElevenLabsPronunciation:
    """Handle ElevenLabs-specific pronunciation hints"""
    
    def __init__(self):
        # ElevenLabs pronunciation dictionary format
        self.pronunciation_dict = []
    
    def add_pronunciation(self, original: str, 
                          replacement: str) -> None:
        """Add to ElevenLabs pronunciation dictionary"""
        self.pronunciation_dict.append({
            "original": original,
            "replacement": replacement
        })
    
    def get_api_format(self) -> list:
        """Return in ElevenLabs API format"""
        return self.pronunciation_dict


# Example configuration
pronunciation_config = {
    "text_to_speech": {
        "provider": "elevenlabs",
        "pronunciation": [
            {"original": "Zapp Chess", "replacement": "Zap Chess"},
            {"original": "chess", "replacement": "chess"},  # Reinforce
            {"original": "GDPR", "replacement": "G D P R"},
        ]
    }
}

<!-- Brand name with phoneme -->
<speak>
  Hi, this is Riya from 
  <phoneme alphabet="ipa" ph="zæp tʃɛs">Zapp Chess</phoneme>.
</speak>

<!-- Acronym spelled out -->
<speak>
  We're <say-as interpret-as="characters">GDPR</say-as> compliant.
</speak>

<!-- Version number -->
<speak>
  You're using version 
  <say-as interpret-as="cardinal">2</say-as> point 
  <say-as interpret-as="cardinal">5</say-as>.
</speak>

<!-- Indian university name with emphasis -->
<speak>
  Are you at 
  <lang xml:lang="hi-IN">Jamia Millia Islamia</lang>?
</speak>

{
  "speech_to_text": {
    "keyterms": [
      "Zapp Chess",
      "Zap Chess",
      "chess",
      "Campus Ambassador",
      "WhatsApp",
      "playbook"
    ]
  }
}