oracle_context_cache/Lux-Luna__LunaVox.json

{"repo": "Lux-Luna/LunaVox", "n_pairs": 66, "version": "v2_function_scoped", "contexts": {"unit_tests/test_phase1_cleanup.py::20": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/Languages/Chinese/__init__.py", "src/lunavox_tts/Languages/Chinese/ZhBert.py", "src/lunavox_tts/Resources/Audio/__init__.py", "src/lunavox_tts/Resources/Audio/SpeakerVector.py", "src/lunavox_tts/ModelManager.py"], "used_names": ["MagicMock", "ZhBert", "runtime_manager"], "enclosing_function": "test_zh_bert_cleanup", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()", "n_imports_parsed": 8, "n_files_resolved": 6, "n_chars_extracted": 84}, "unit_tests/test_phase1_cleanup.py::27": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/Languages/Chinese/__init__.py", "src/lunavox_tts/Languages/Chinese/ZhBert.py", "src/lunavox_tts/Resources/Audio/__init__.py", "src/lunavox_tts/Resources/Audio/SpeakerVector.py", "src/lunavox_tts/ModelManager.py"], "used_names": ["MagicMock", "ZhBert", "runtime_manager"], "enclosing_function": "test_zh_bert_cleanup", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()", "n_imports_parsed": 8, "n_files_resolved": 6, "n_chars_extracted": 84}, "unit_tests/test_phase1_cleanup.py::26": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/Languages/Chinese/__init__.py", "src/lunavox_tts/Languages/Chinese/ZhBert.py", "src/lunavox_tts/Resources/Audio/__init__.py", "src/lunavox_tts/Resources/Audio/SpeakerVector.py", "src/lunavox_tts/ModelManager.py"], "used_names": ["MagicMock", "ZhBert", "runtime_manager"], "enclosing_function": "test_zh_bert_cleanup", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()", "n_imports_parsed": 8, "n_files_resolved": 6, "n_chars_extracted": 84}, "unit_tests/integration/test_memory_integration.py::120": {"resolved_imports": ["src/lunavox_tts/API/characters.py", "src/lunavox_tts/API/state.py"], "used_names": ["_reference_audios", "clear_all_reference_audio", "patch", "set_reference_audio_config", "unload_character"], "enclosing_function": "test_multi_unload_clears_all_state", "extracted_code": "# Source: src/lunavox_tts/API/characters.py\ndef unload_character(\n        character_name: str,\n) -> None:\n    \"\"\"\n    Unloads a previously loaded character model to free up resources.\n    \n    Also clears any associated reference audio configuration to prevent\n    memory leaks from orphaned ReferenceAudio objects.\n\n    Args:\n        character_name (str): The name of the character to unload.\n    \"\"\"\n    # Clean up API state first (removes ReferenceAudio reference)\n    from .state import remove_reference_audio\n    remove_reference_audio(character_name)\n    \n    # Then remove the model session\n    model_manager.remove_character(\n        character_name=character_name,\n    )\n\n\n# Source: src/lunavox_tts/API/state.py\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 1036}, "unit_tests/integration/test_memory_integration.py::48": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["ModelManager", "os"], "enclosing_function": "test_model_manager_cache_capacity_reduced", "extracted_code": "# Source: src/lunavox_tts/ModelManager.py\nclass ModelManager:\n    \"\"\"\n    Facade for model management. \n    Maintains a cache of active model sessions and handles resource lifecycle.\n    \"\"\"\n    \n    def __init__(self):\n        capacity_str = os.getenv('Max_Cached_Character_Models', '1')\n        self.character_to_model: Dict[str, Dict[str, InferenceSession]] = LRUCacheDict(\n            capacity=int(capacity_str)\n        )\n        self.providers = resolve_providers()\n        self.providers = resolve_providers()\n\n    def load_cn_hubert(self) -> bool:\n        \"\"\"Load the Chinese HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        return resource_manager.load_cn_hubert(self.providers)\n\n    def unload_cn_hubert(self) -> None:\n        \"\"\"Unload HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        resource_manager.unload_cn_hubert()\n\n    def cleanup_global_resources(self) -> None:\n        \"\"\"\n        Clean up all global/singleton resources for fresh measurement.\n        Delegates to GlobalResourceManager.\n        \"\"\"\n        from .Utils.RuntimeManager import runtime_manager\n        runtime_manager.cleanup_all()\n\n    def get(self, character_name: str, skip_prompt_encoder: bool = False) -> Optional[GSVModel]:\n        \"\"\"Retrieve a character's model sessions, loading them if necessary.\"\"\"\n        name = character_name.lower()\n        \n        # Check cache\n        if name in self.character_to_model:\n            m = self.character_to_model[name]\n            return GSVModel(\n                T2S_ENCODER=m[\"T2S_ENCODER\"],\n                T2S_FIRST_STAGE_DECODER=m[\"T2S_FIRST_STAGE_DECODER\"],\n                T2S_STAGE_DECODER=m[\"T2S_STAGE_DECODER\"],\n                VITS=m[\"VITS\"],\n                PROMPT_ENCODER=m.get(\"PROMPT_ENCODER\")\n            )\n        \n        # Load if registered\n        entry = model_registry.get(name)\n        if entry:\n            if self.load_character(name, entry.path, skip_prompt_encoder=skip_prompt_encoder):\n                return self.get(name)\n        \n        return None\n\n    def has_character(self, character_name: str) -> bool:\n        return model_registry.has(character_name)\n\n    def load_character(self, character_name: str, model_dir: str, skip_prompt_encoder: bool = False) -> bool:\n        \"\"\"\n        Load all model components for a character.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to the model directory.\n            skip_prompt_encoder: If True, skip loading PROMPT_ENCODER (for Persona mode).\n        \"\"\"\n        import time\n        t_start = time.perf_counter()\n        name = character_name.lower()\n        \n        # 1. Check if already loaded with SAME model_dir\n        existing_entry = model_registry.get(name)\n        already_loaded = (\n            name in self.character_to_model and\n            existing_entry and \n            existing_entry.path == model_dir\n        )\n        \n        if already_loaded:\n            # Already loaded with same path - return early\n            return True\n        \n        # 2. Detect version and register\n        version = detect_model_version(model_dir)\n        spec = get_model_spec(version)\n        model_registry.register(name, model_dir, force_version=version)\n        \n        # If loaded with different model_dir, force reload\n        if name in self.character_to_model:\n            logger.info(f\"Character '{character_name}' model changed from previous, reloading...\")\n\n        # 3. Resource Pre-check\n        from .Utils.AssetManager import asset_manager\n        is_v2pp = version in ('v2ProPlus', 'v2pp')\n        asset_manager.ensure_base()\n        if is_v2pp:\n            asset_manager.ensure_v2pp(skip_prompt_encoder=skip_prompt_encoder)\n        \n        # 4. Actual Loading via ModelLoader (wrapped in monitoring)\n        with monitor.measure(f\"Model Loading ({character_name})\", category=\"USER_PERCEIVED\"):\n            model_loader.refresh_providers()\n            self.providers = model_loader.providers\n            \n            skip = set()\n            if skip_prompt_encoder:\n                skip.add(\"PROMPT_ENCODER\")\n                \n            try:\n                model_dict = model_loader.load_all(model_dir, spec, skip_components=skip)\n                self.character_to_model[name] = model_dict\n                model_registry.mark_loaded(name, set(model_dict.keys()))\n                \n                t_end = time.perf_counter()\n                duration = t_end - t_start\n                \n                logger.info(f\"✓ Character '{character_name.capitalize()}' loaded: type={version}, providers={self.providers}\")\n                monitor.log_metric(f\"Load time ({name})\", f\"{duration:.2f}\", \"s\")\n                return True\n            except Exception as e:\n                logger.error(f\"Error loading character '{character_name}': {e}\", exc_info=True)\n                return False\n\n    def get_character_version(self, character_name: str) -> str:\n        entry = model_registry.get(character_name)\n        return entry.version if entry else 'v2'\n\n    def remove_character(self, character_name: str) -> None:\n        \"\"\"Remove a character model and force memory release.\"\"\"\n        name = character_name.lower()\n        if name in self.character_to_model:\n            # Explicitly clear session references to help GC\n            sessions = self.character_to_model[name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n            del self.character_to_model[name]\n        model_registry.unregister(name)\n        # Double GC needed for ONNX Session C++ destructor chain\n        gc.collect()\n        gc.collect()\n\n    def clean_cache(self) -> None:\n        \"\"\"Clear all cached models with explicit cleanup.\"\"\"\n        # Explicitly null out all sessions before clearing\n        for char_name in list(self.character_to_model.keys()):\n            sessions = self.character_to_model[char_name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n        self.character_to_model.clear()\n        gc.collect()\n        gc.collect()\n\n\n    @property\n    def cn_hubert(self) -> Optional[InferenceSession]:\n        from .ResourceManager import resource_manager\n        return resource_manager.cn_hubert", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 6367}, "unit_tests/integration/test_memory_integration.py::68": {"resolved_imports": ["src/lunavox_tts/Resources/Audio/ReferenceAudio.py"], "used_names": ["ReferenceAudio", "os", "reload"], "enclosing_function": "test_reference_audio_cache_capacity_reduced", "extracted_code": "# Source: src/lunavox_tts/Resources/Audio/ReferenceAudio.py\nclass ReferenceAudio:\n    \"\"\"\n    Lightweight data container for reference audio and its extracted features.\n    \n    This class acts as a DTO (Data Transfer Object). Actual feature extraction\n    is handled by Core.Processors.FeatureExtractor.\n    \"\"\"\n    \n    _prompt_cache: dict[tuple[str, str, str], \"ReferenceAudio\"] = LRUCacheDict(\n        capacity=int(os.getenv(\"Max_Cached_Reference_Audio\", \"2\"))\n    )\n    \n    # Persona support: indicates if this instance was loaded from cached features\n    _is_persona_based: bool = False\n\n    @property\n    def is_persona_based(self) -> bool:\n        \"\"\"Returns True if this instance was loaded from a Persona (no wav processing).\"\"\"\n        return getattr(self, '_is_persona_based', False)\n\n    def __new__(cls, prompt_wav: str, prompt_text: str, language: str = \"auto\", model_version: str = 'v2'):\n        # Cache key includes model_version to avoid conflicts\n        key = (prompt_wav, (language or \"auto\"), model_version)\n        if key in cls._prompt_cache:\n            instance = cls._prompt_cache[key]\n            if instance.text != prompt_text or instance.language != language:\n                instance.text = prompt_text\n                instance.language = language\n                instance._invalidate_features()\n            return instance\n\n        instance = super().__new__(cls)\n        cls._prompt_cache[key] = instance\n        return instance\n\n    def __init__(self, prompt_wav: str, prompt_text: str, language: str = \"auto\", model_version: str = 'v2'):\n        if hasattr(self, \"_initialized\"):\n            return\n\n        self.wav_path: str = prompt_wav\n        self.text: str = prompt_text\n        self.language: str = language or \"auto\"\n        self.model_version: str = model_version\n        \n        # Features (lazily populated by FeatureExtractor)\n        self.phonemes_seq: Optional[np.ndarray] = None\n        self.text_bert: Optional[np.ndarray] = None\n        self.sv_emb: Optional[np.ndarray] = None\n        self.global_emb: Optional[np.ndarray] = None\n        self.global_emb_advanced: Optional[np.ndarray] = None\n        self.ssl_content: Optional[np.ndarray] = None\n        self.resolved_language: Optional[str] = None\n        \n        # Audio buffers\n        self.audio_32k: Optional[np.ndarray] = None\n        self.audio_16k: Optional[np.ndarray] = None\n\n        self._initialized = True\n\n    def _load_audio(self):\n        \"\"\"Internal method to load audio data.\"\"\"\n        if self.audio_32k is not None:\n            return\n            \n        self.audio_32k = load_audio(\n            audio_path=self.wav_path,\n            target_sampling_rate=32000,\n        )\n        if self.audio_32k is not None and np.isnan(self.audio_32k).any():\n            logger.warning(f\"NaNs detected in loaded audio: {self.wav_path}. Replacing with zeros.\")\n            self.audio_32k = np.nan_to_num(self.audio_32k)\n\n    def _invalidate_features(self):\n        \"\"\"Clear extracted features when text or language changes.\"\"\"\n        self.phonemes_seq = None\n        self.text_bert = None\n        self.ssl_content = None\n        self.sv_emb = None\n        self.global_emb = None\n        self.global_emb_advanced = None\n        self.resolved_language = None\n\n    @classmethod\n    def clear_cache(cls) -> None:\n        cls._prompt_cache.clear()", "n_imports_parsed": 7, "n_files_resolved": 1, "n_chars_extracted": 3358}, "unit_tests/integration/test_memory_integration.py::134": {"resolved_imports": [], "used_names": ["CHAR_NAME_POOL", "LANG_TO_INDEX", "pytest", "sys"], "enclosing_function": "test_character_name_pool_exists", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 0, "n_chars_extracted": 0}, "unit_tests/integration/test_memory_integration.py::91": {"resolved_imports": [], "used_names": ["gc", "weakref"], "enclosing_function": "test_dict_cleanup_releases_reference", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 0, "n_chars_extracted": 0}, "unit_tests/integration/test_memory_integration.py::152": {"resolved_imports": [], "used_names": ["get_character_name", "pytest", "sys"], "enclosing_function": "test_character_name_reuses_pool", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 0, "n_chars_extracted": 0}, "unit_tests/integration/test_memory_integration.py::156": {"resolved_imports": [], "used_names": ["get_character_name", "pytest", "sys"], "enclosing_function": "test_character_name_reuses_pool", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 0, "n_chars_extracted": 0}, "unit_tests/integration/test_memory_integration.py::135": {"resolved_imports": [], "used_names": ["CHAR_NAME_POOL", "LANG_TO_INDEX", "pytest", "sys"], "enclosing_function": "test_character_name_pool_exists", "extracted_code": "", "n_imports_parsed": 6, "n_files_resolved": 0, "n_chars_extracted": 0}, "unit_tests/unit/api/test_loading_order.py::39": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_without_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::24": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_with_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::65": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_get_skip_components_for_persona_no_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::38": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_without_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::147": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["ModelManager", "inspect"], "enclosing_function": "test_load_character_no_optimization_hint_check", "extracted_code": "# Source: src/lunavox_tts/ModelManager.py\nclass ModelManager:\n    \"\"\"\n    Facade for model management. \n    Maintains a cache of active model sessions and handles resource lifecycle.\n    \"\"\"\n    \n    def __init__(self):\n        capacity_str = os.getenv('Max_Cached_Character_Models', '1')\n        self.character_to_model: Dict[str, Dict[str, InferenceSession]] = LRUCacheDict(\n            capacity=int(capacity_str)\n        )\n        self.providers = resolve_providers()\n        self.providers = resolve_providers()\n\n    def load_cn_hubert(self) -> bool:\n        \"\"\"Load the Chinese HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        return resource_manager.load_cn_hubert(self.providers)\n\n    def unload_cn_hubert(self) -> None:\n        \"\"\"Unload HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        resource_manager.unload_cn_hubert()\n\n    def cleanup_global_resources(self) -> None:\n        \"\"\"\n        Clean up all global/singleton resources for fresh measurement.\n        Delegates to GlobalResourceManager.\n        \"\"\"\n        from .Utils.RuntimeManager import runtime_manager\n        runtime_manager.cleanup_all()\n\n    def get(self, character_name: str, skip_prompt_encoder: bool = False) -> Optional[GSVModel]:\n        \"\"\"Retrieve a character's model sessions, loading them if necessary.\"\"\"\n        name = character_name.lower()\n        \n        # Check cache\n        if name in self.character_to_model:\n            m = self.character_to_model[name]\n            return GSVModel(\n                T2S_ENCODER=m[\"T2S_ENCODER\"],\n                T2S_FIRST_STAGE_DECODER=m[\"T2S_FIRST_STAGE_DECODER\"],\n                T2S_STAGE_DECODER=m[\"T2S_STAGE_DECODER\"],\n                VITS=m[\"VITS\"],\n                PROMPT_ENCODER=m.get(\"PROMPT_ENCODER\")\n            )\n        \n        # Load if registered\n        entry = model_registry.get(name)\n        if entry:\n            if self.load_character(name, entry.path, skip_prompt_encoder=skip_prompt_encoder):\n                return self.get(name)\n        \n        return None\n\n    def has_character(self, character_name: str) -> bool:\n        return model_registry.has(character_name)\n\n    def load_character(self, character_name: str, model_dir: str, skip_prompt_encoder: bool = False) -> bool:\n        \"\"\"\n        Load all model components for a character.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to the model directory.\n            skip_prompt_encoder: If True, skip loading PROMPT_ENCODER (for Persona mode).\n        \"\"\"\n        import time\n        t_start = time.perf_counter()\n        name = character_name.lower()\n        \n        # 1. Check if already loaded with SAME model_dir\n        existing_entry = model_registry.get(name)\n        already_loaded = (\n            name in self.character_to_model and\n            existing_entry and \n            existing_entry.path == model_dir\n        )\n        \n        if already_loaded:\n            # Already loaded with same path - return early\n            return True\n        \n        # 2. Detect version and register\n        version = detect_model_version(model_dir)\n        spec = get_model_spec(version)\n        model_registry.register(name, model_dir, force_version=version)\n        \n        # If loaded with different model_dir, force reload\n        if name in self.character_to_model:\n            logger.info(f\"Character '{character_name}' model changed from previous, reloading...\")\n\n        # 3. Resource Pre-check\n        from .Utils.AssetManager import asset_manager\n        is_v2pp = version in ('v2ProPlus', 'v2pp')\n        asset_manager.ensure_base()\n        if is_v2pp:\n            asset_manager.ensure_v2pp(skip_prompt_encoder=skip_prompt_encoder)\n        \n        # 4. Actual Loading via ModelLoader (wrapped in monitoring)\n        with monitor.measure(f\"Model Loading ({character_name})\", category=\"USER_PERCEIVED\"):\n            model_loader.refresh_providers()\n            self.providers = model_loader.providers\n            \n            skip = set()\n            if skip_prompt_encoder:\n                skip.add(\"PROMPT_ENCODER\")\n                \n            try:\n                model_dict = model_loader.load_all(model_dir, spec, skip_components=skip)\n                self.character_to_model[name] = model_dict\n                model_registry.mark_loaded(name, set(model_dict.keys()))\n                \n                t_end = time.perf_counter()\n                duration = t_end - t_start\n                \n                logger.info(f\"✓ Character '{character_name.capitalize()}' loaded: type={version}, providers={self.providers}\")\n                monitor.log_metric(f\"Load time ({name})\", f\"{duration:.2f}\", \"s\")\n                return True\n            except Exception as e:\n                logger.error(f\"Error loading character '{character_name}': {e}\", exc_info=True)\n                return False\n\n    def get_character_version(self, character_name: str) -> str:\n        entry = model_registry.get(character_name)\n        return entry.version if entry else 'v2'\n\n    def remove_character(self, character_name: str) -> None:\n        \"\"\"Remove a character model and force memory release.\"\"\"\n        name = character_name.lower()\n        if name in self.character_to_model:\n            # Explicitly clear session references to help GC\n            sessions = self.character_to_model[name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n            del self.character_to_model[name]\n        model_registry.unregister(name)\n        # Double GC needed for ONNX Session C++ destructor chain\n        gc.collect()\n        gc.collect()\n\n    def clean_cache(self) -> None:\n        \"\"\"Clear all cached models with explicit cleanup.\"\"\"\n        # Explicitly null out all sessions before clearing\n        for char_name in list(self.character_to_model.keys()):\n            sessions = self.character_to_model[char_name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n        self.character_to_model.clear()\n        gc.collect()\n        gc.collect()\n\n\n    @property\n    def cn_hubert(self) -> Optional[InferenceSession]:\n        from .ResourceManager import resource_manager\n        return resource_manager.cn_hubert", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 6367}, "unit_tests/unit/api/test_loading_order.py::50": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_reference", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::169": {"resolved_imports": ["src/lunavox_tts/Core/Model/registry.py"], "used_names": ["ModelEntry", "dataclasses"], "enclosing_function": "test_model_entry_has_no_hint_field", "extracted_code": "# Source: src/lunavox_tts/Core/Model/registry.py\nclass ModelEntry:\n    \"\"\"Metadata entry for a loaded/registered model.\"\"\"\n    name: str\n    path: str\n    version: str\n    spec: ModelSpec\n    is_loaded: bool = False\n    components_loaded: Set[str] = field(default_factory=set)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 276}, "unit_tests/unit/api/test_loading_order.py::23": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_with_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::37": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_without_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_loading_order.py::25": {"resolved_imports": ["src/lunavox_tts/Core/Model/LoadingContext.py"], "used_names": ["LoadingContext"], "enclosing_function": "test_create_for_persona_with_ge", "extracted_code": "# Source: src/lunavox_tts/Core/Model/LoadingContext.py\nclass LoadingContext:\n    \"\"\"\n    Configuration object for intent-driven model loading.\n    \n    Instead of loading everything and unloading unused components,\n    this context specifies exactly what should be loaded.\n    \n    Modes:\n        - reference: Full model with all components (for reference audio TTS)\n        - persona_with_ge: Persona mode but global_emb not cached (needs PE)\n        - persona_no_ge: Persona mode with cached global_emb (skips PE)\n    \n    Usage:\n        context = LoadingContext(\n            character_name=\"luna\",\n            model_dir=\"/path/to/model\",\n            mode=\"persona_no_ge\"\n        )\n        model_manager.load_character_with_context(context)\n    \"\"\"\n    character_name: str\n    model_dir: str\n    mode: Literal[\"reference\", \"persona_with_ge\", \"persona_no_ge\"]\n    version: Optional[str] = None  # Auto-detected if None\n    \n    def get_skip_components(self) -> Set[str]:\n        \"\"\"\n        Return the set of components to skip during loading.\n        \n        Returns:\n            Set of component names to skip.\n        \"\"\"\n        if self.mode == \"persona_no_ge\":\n            return {\"PROMPT_ENCODER\"}\n        return set()\n    \n    @property\n    def skip_prompt_encoder(self) -> bool:\n        \"\"\"Convenience property for backward compatibility.\"\"\"\n        return self.mode == \"persona_no_ge\"\n    \n    @classmethod\n    def for_persona(cls, character_name: str, model_dir: str, has_global_emb: bool) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Persona mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            has_global_emb: Whether the persona has cached global embeddings.\n            \n        Returns:\n            LoadingContext configured for optimal persona loading.\n        \"\"\"\n        mode = \"persona_no_ge\" if has_global_emb else \"persona_with_ge\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=mode)\n    \n    @classmethod\n    def for_reference(cls, character_name: str, model_dir: str) -> \"LoadingContext\":\n        \"\"\"\n        Factory method for Reference audio mode.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to model directory.\n            \n        Returns:\n            LoadingContext configured for reference audio TTS.\n        \"\"\"\n        return cls(character_name=character_name, model_dir=model_dir, mode=\"reference\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2522}, "unit_tests/unit/api/test_memory_lifecycle.py::129": {"resolved_imports": ["src/lunavox_tts/Resources/Audio/ReferenceAudio.py", "src/lunavox_tts/Utils/RuntimeManager.py"], "used_names": ["ReferenceAudio", "runtime_manager"], "enclosing_function": "test_cleanup_all_clears_reference_audio_cache", "extracted_code": "# Source: src/lunavox_tts/Resources/Audio/ReferenceAudio.py\nclass ReferenceAudio:\n    \"\"\"\n    Lightweight data container for reference audio and its extracted features.\n    \n    This class acts as a DTO (Data Transfer Object). Actual feature extraction\n    is handled by Core.Processors.FeatureExtractor.\n    \"\"\"\n    \n    _prompt_cache: dict[tuple[str, str, str], \"ReferenceAudio\"] = LRUCacheDict(\n        capacity=int(os.getenv(\"Max_Cached_Reference_Audio\", \"2\"))\n    )\n    \n    # Persona support: indicates if this instance was loaded from cached features\n    _is_persona_based: bool = False\n\n    @property\n    def is_persona_based(self) -> bool:\n        \"\"\"Returns True if this instance was loaded from a Persona (no wav processing).\"\"\"\n        return getattr(self, '_is_persona_based', False)\n\n    def __new__(cls, prompt_wav: str, prompt_text: str, language: str = \"auto\", model_version: str = 'v2'):\n        # Cache key includes model_version to avoid conflicts\n        key = (prompt_wav, (language or \"auto\"), model_version)\n        if key in cls._prompt_cache:\n            instance = cls._prompt_cache[key]\n            if instance.text != prompt_text or instance.language != language:\n                instance.text = prompt_text\n                instance.language = language\n                instance._invalidate_features()\n            return instance\n\n        instance = super().__new__(cls)\n        cls._prompt_cache[key] = instance\n        return instance\n\n    def __init__(self, prompt_wav: str, prompt_text: str, language: str = \"auto\", model_version: str = 'v2'):\n        if hasattr(self, \"_initialized\"):\n            return\n\n        self.wav_path: str = prompt_wav\n        self.text: str = prompt_text\n        self.language: str = language or \"auto\"\n        self.model_version: str = model_version\n        \n        # Features (lazily populated by FeatureExtractor)\n        self.phonemes_seq: Optional[np.ndarray] = None\n        self.text_bert: Optional[np.ndarray] = None\n        self.sv_emb: Optional[np.ndarray] = None\n        self.global_emb: Optional[np.ndarray] = None\n        self.global_emb_advanced: Optional[np.ndarray] = None\n        self.ssl_content: Optional[np.ndarray] = None\n        self.resolved_language: Optional[str] = None\n        \n        # Audio buffers\n        self.audio_32k: Optional[np.ndarray] = None\n        self.audio_16k: Optional[np.ndarray] = None\n\n        self._initialized = True\n\n    def _load_audio(self):\n        \"\"\"Internal method to load audio data.\"\"\"\n        if self.audio_32k is not None:\n            return\n            \n        self.audio_32k = load_audio(\n            audio_path=self.wav_path,\n            target_sampling_rate=32000,\n        )\n        if self.audio_32k is not None and np.isnan(self.audio_32k).any():\n            logger.warning(f\"NaNs detected in loaded audio: {self.wav_path}. Replacing with zeros.\")\n            self.audio_32k = np.nan_to_num(self.audio_32k)\n\n    def _invalidate_features(self):\n        \"\"\"Clear extracted features when text or language changes.\"\"\"\n        self.phonemes_seq = None\n        self.text_bert = None\n        self.ssl_content = None\n        self.sv_emb = None\n        self.global_emb = None\n        self.global_emb_advanced = None\n        self.resolved_language = None\n\n    @classmethod\n    def clear_cache(cls) -> None:\n        cls._prompt_cache.clear()\n\n\n# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 3445}, "unit_tests/unit/api/test_memory_lifecycle.py::26": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "has_reference_audio", "remove_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_remove_existing_character", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef has_reference_audio(character_name: str) -> bool:\n    \"\"\"Check if a character has reference audio configured.\"\"\"\n    return character_name in _reference_audios\n\ndef remove_reference_audio(character_name: str) -> bool:\n    \"\"\"\n    Remove reference audio configuration for a specific character.\n    \n    Args:\n        character_name: Name of the character to remove.\n        \n    Returns:\n        True if the character was found and removed, False otherwise.\n    \"\"\"\n    if character_name in _reference_audios:\n        del _reference_audios[character_name]\n        return True\n    return False\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 952}, "unit_tests/unit/api/test_memory_lifecycle.py::31": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "has_reference_audio", "remove_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_remove_existing_character", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef has_reference_audio(character_name: str) -> bool:\n    \"\"\"Check if a character has reference audio configured.\"\"\"\n    return character_name in _reference_audios\n\ndef remove_reference_audio(character_name: str) -> bool:\n    \"\"\"\n    Remove reference audio configuration for a specific character.\n    \n    Args:\n        character_name: Name of the character to remove.\n        \n    Returns:\n        True if the character was found and removed, False otherwise.\n    \"\"\"\n    if character_name in _reference_audios:\n        del _reference_audios[character_name]\n        return True\n    return False\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 952}, "unit_tests/unit/api/test_state.py::35": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "get_reference_audio"], "enclosing_function": "test_get_nonexistent_returns_none", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef get_reference_audio(character_name: str) -> Optional[Dict[str, Any]]:\n    \"\"\"Get reference audio configuration for a character.\"\"\"\n    return _reference_audios.get(character_name)\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 346}, "unit_tests/unit/api/test_state.py::50": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "has_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_has_reference_audio", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef has_reference_audio(character_name: str) -> bool:\n    \"\"\"Check if a character has reference audio configured.\"\"\"\n    return character_name in _reference_audios\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 520}, "unit_tests/unit/api/test_state.py::92": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["normalize_language"], "enclosing_function": "test_supported_languages", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef normalize_language(code: Optional[str]) -> str:\n    \"\"\"Normalize language code to supported values.\"\"\"\n    lang = (code or \"ja\").lower()\n    return lang if lang in {\"ja\", \"en\", \"zh\"} else \"ja\"", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 235}, "unit_tests/unit/api/test_state.py::93": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["normalize_language"], "enclosing_function": "test_supported_languages", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef normalize_language(code: Optional[str]) -> str:\n    \"\"\"Normalize language code to supported values.\"\"\"\n    lang = (code or \"ja\").lower()\n    return lang if lang in {\"ja\", \"en\", \"zh\"} else \"ja\"", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 235}, "unit_tests/unit/api/test_state.py::94": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["normalize_language"], "enclosing_function": "test_supported_languages", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef normalize_language(code: Optional[str]) -> str:\n    \"\"\"Normalize language code to supported values.\"\"\"\n    lang = (code or \"ja\").lower()\n    return lang if lang in {\"ja\", \"en\", \"zh\"} else \"ja\"", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 235}, "unit_tests/unit/api/test_state.py::47": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "has_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_has_reference_audio", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef has_reference_audio(character_name: str) -> bool:\n    \"\"\"Check if a character has reference audio configured.\"\"\"\n    return character_name in _reference_audios\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 520}, "unit_tests/unit/api/test_state.py::26": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "get_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_set_and_get_reference_audio", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef get_reference_audio(character_name: str) -> Optional[Dict[str, Any]]:\n    \"\"\"Get reference audio configuration for a character.\"\"\"\n    return _reference_audios.get(character_name)\n\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 540}, "unit_tests/unit/api/test_state.py::82": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["clear_all_reference_audio", "get_reference_audio", "set_reference_audio_config"], "enclosing_function": "test_overwrite_existing", "extracted_code": "# Source: src/lunavox_tts/API/state.py\ndef get_reference_audio(character_name: str) -> Optional[Dict[str, Any]]:\n    \"\"\"Get reference audio configuration for a character.\"\"\"\n    return _reference_audios.get(character_name)\n\ndef set_reference_audio_config(character_name: str, config: Dict[str, Any]) -> None:\n    \"\"\"Set reference audio configuration for a character.\"\"\"\n    _reference_audios[character_name] = config\n\ndef clear_all_reference_audio() -> None:\n    \"\"\"Clear all reference audio configurations.\"\"\"\n    _reference_audios.clear()", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 540}, "unit_tests/unit/api/test_state.py::136": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["SUPPORTED_AUDIO_EXTS"], "enclosing_function": "test_case_sensitive", "extracted_code": "# Source: src/lunavox_tts/API/state.py\nSUPPORTED_AUDIO_EXTS = {'.wav', '.flac', '.ogg', '.aiff', '.aif'}", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 104}, "unit_tests/unit/api/test_state.py::126": {"resolved_imports": ["src/lunavox_tts/API/state.py"], "used_names": ["SUPPORTED_AUDIO_EXTS"], "enclosing_function": "test_wav_supported", "extracted_code": "# Source: src/lunavox_tts/API/state.py\nSUPPORTED_AUDIO_EXTS = {'.wav', '.flac', '.ogg', '.aiff', '.aif'}", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 104}, "unit_tests/unit/core/test_env_logic.py::22": {"resolved_imports": ["src/lunavox_tts/Utils/EnvManager.py"], "used_names": ["EnvManager", "patch"], "enclosing_function": "test_get_mode_respects_config", "extracted_code": "# Source: src/lunavox_tts/Utils/EnvManager.py\nclass EnvManager:\n    def __init__(self):\n        # Determine the Data directory relative to the package root.\n        try:\n            current_file = Path(__file__).resolve()\n            repo_root = current_file.parents[3]\n            self.repo_root = repo_root\n            self.data_root = repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n        except Exception:\n            self.repo_root = Path(\".\")\n            self.data_root = self.repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n\n        # Allow override via env var\n        data_dir_env = os.environ.get(\"LUNAVOX_DATA_DIR\")\n        if data_dir_env:\n            self.config_dir = Path(data_dir_env)\n            \n        self.config_dir.mkdir(parents=True, exist_ok=True)\n        self.config_file = self.config_dir / \"env_config.json\"\n        self._config = self._load_config()\n        self._mode_override: Optional[str] = None\n        self._cached_env_status: Optional[EnvironmentStatus] = None\n        \n        # Setup portable CUDA paths if on Windows and GPU mode is active\n        if sys.platform == \"win32\" and self.get_mode() == \"gpu\":\n            setup_portable_cuda_paths()\n\n        self._setup_default_paths()\n\n    def _setup_default_paths(self):\n        \"\"\"Automatically configure environment variables for standard model paths if they exist.\"\"\"\n        # 1. Hubert Model\n        if 'HUBERT_MODEL_PATH' not in os.environ:\n            hubert_path = self.data_root / 'TTSData' / 'chinese-hubert-base' / 'chinese-hubert-base.onnx'\n            if hubert_path.exists():\n                os.environ['HUBERT_MODEL_PATH'] = str(hubert_path)\n                logger.debug(f\"Auto-configured HUBERT_MODEL_PATH: {hubert_path}\")\n\n\n    def _load_config(self):\n        if self.config_file.exists():\n            try:\n                with open(self.config_file, \"r\", encoding=\"utf-8\") as f:\n                    return json.load(f)\n            except Exception as e:\n                logger.error(f\"Failed to load env config: {e}\")\n        return {\"mode\": \"cpu\", \"developer_mode\": False}\n\n    def _save_config(self):\n        try:\n            with open(self.config_file, \"w\", encoding=\"utf-8\") as f:\n                json.dump(self._config, f, indent=4)\n        except Exception as e:\n            logger.error(f\"Failed to save env config: {e}\")\n\n    def get_mode(self) -> str:\n        \"\"\"Returns the configured mode ('cpu' or 'gpu'), respecting overrides.\"\"\"\n        if self._mode_override:\n            return self._mode_override\n        return self._config.get(\"mode\", \"cpu\")\n\n    def get_developer_mode(self) -> bool:\n        \"\"\"Returns True if developer mode is enabled.\"\"\"\n        return self._config.get(\"developer_mode\", False)\n\n    def set_developer_mode(self, enabled: bool):\n        \"\"\"Sets the developer mode and saves configuration.\"\"\"\n        if enabled:\n            ensure_developer_dependencies()\n        \n        self._config[\"developer_mode\"] = enabled\n        self._save_config()\n        logger.info(f\"Developer mode set to: {enabled}\")\n\n    def set_mode(self, mode: str):\n        \"\"\"Sets the desired mode and saves configuration.\"\"\"\n        if mode not in [\"cpu\", \"gpu\"]:\n            raise ValueError(\"Mode must be 'cpu' or 'gpu'\")\n        \n        if mode == \"gpu\" and self.get_environment_status() == EnvironmentStatus.CPU_ONLY:\n            print_gpu_instruction()\n            logger.warning(\"GPU mode set, but environment is CPU-only.\")\n             \n        self._config[\"mode\"] = mode\n        self._save_config()\n        logger.info(f\"LunaVox mode set to: {mode}\")\n\n    def is_gpu_installed(self) -> bool:\n        \"\"\"Checks if onnxruntime-gpu is currently installed and functional.\"\"\"\n        try:\n            import onnxruntime as ort\n            providers = ort.get_available_providers()\n            if \"CUDAExecutionProvider\" not in providers:\n                return False\n            return True\n        except Exception:\n            return False\n\n    def get_environment_status(self) -> EnvironmentStatus:\n        \"\"\"Detect the current runtime environment status.\"\"\"\n        if self._cached_env_status is not None:\n            return self._cached_env_status\n        \n        try:\n            import onnxruntime as ort\n            available_providers = set(ort.get_available_providers())\n            \n            if \"CUDAExecutionProvider\" in available_providers:\n                self._cached_env_status = EnvironmentStatus.GPU_READY\n                return self._cached_env_status\n            \n            try:\n                from importlib.metadata import distribution\n                dist = distribution('onnxruntime-gpu')\n                if dist:\n                    self._cached_env_status = EnvironmentStatus.GPU_DEPS_MISSING\n                    return self._cached_env_status\n            except Exception:\n                pass\n            \n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n            \n        except ImportError:\n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n\n    def invalidate_cache(self) -> None:\n        \"\"\"Clear cached environment status.\"\"\"\n        self._cached_env_status = None\n\n    def temporary_mode(self, mode: str):\n        \"\"\"Context manager to temporarily override mode without saving.\"\"\"\n        from contextlib import contextmanager\n\n        @contextmanager\n        def _override():\n            old_override = self._mode_override\n            self._mode_override = mode\n            try:\n                yield\n            finally:\n                self._mode_override = old_override\n        \n        return _override()\n\n    def ensure_environment(self) -> bool:\n        \"\"\"Validates environment against requested mode.\"\"\"\n        target_mode = self.get_mode()\n        status = self.get_environment_status()\n\n        if target_mode == \"gpu\":\n            if status == EnvironmentStatus.CPU_ONLY:\n                print_gpu_instruction()\n                from ..Core.Model.ExecutionPolicy import EnvironmentMismatchError\n                raise EnvironmentMismatchError(\n                    \"GPU mode requested but only CPU runtime is installed.\"\n                )\n            elif status == EnvironmentStatus.GPU_DEPS_MISSING:\n                logger.warning(\"GPU package installed but CUDA deps missing.\")\n        \n        return True", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 6474}, "unit_tests/unit/core/test_env_logic.py::75": {"resolved_imports": ["src/lunavox_tts/Utils/EnvManager.py", "src/lunavox_tts/Core/Model/ExecutionPolicy.py"], "used_names": ["EnvManager", "EnvironmentMismatchError", "EnvironmentStatus", "MagicMock", "patch", "pytest"], "enclosing_function": "test_ensure_environment_mismatch_raises", "extracted_code": "# Source: src/lunavox_tts/Utils/EnvManager.py\nclass EnvironmentStatus(Enum):\n    \"\"\"Runtime environment detection status.\"\"\"\n    CPU_ONLY = \"cpu_only\"           # Only onnxruntime installed (no GPU support)\n    GPU_READY = \"gpu_ready\"         # onnxruntime-gpu installed and CUDA available\n    GPU_DEPS_MISSING = \"gpu_deps_missing\"\n\nclass EnvManager:\n    def __init__(self):\n        # Determine the Data directory relative to the package root.\n        try:\n            current_file = Path(__file__).resolve()\n            repo_root = current_file.parents[3]\n            self.repo_root = repo_root\n            self.data_root = repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n        except Exception:\n            self.repo_root = Path(\".\")\n            self.data_root = self.repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n\n        # Allow override via env var\n        data_dir_env = os.environ.get(\"LUNAVOX_DATA_DIR\")\n        if data_dir_env:\n            self.config_dir = Path(data_dir_env)\n            \n        self.config_dir.mkdir(parents=True, exist_ok=True)\n        self.config_file = self.config_dir / \"env_config.json\"\n        self._config = self._load_config()\n        self._mode_override: Optional[str] = None\n        self._cached_env_status: Optional[EnvironmentStatus] = None\n        \n        # Setup portable CUDA paths if on Windows and GPU mode is active\n        if sys.platform == \"win32\" and self.get_mode() == \"gpu\":\n            setup_portable_cuda_paths()\n\n        self._setup_default_paths()\n\n    def _setup_default_paths(self):\n        \"\"\"Automatically configure environment variables for standard model paths if they exist.\"\"\"\n        # 1. Hubert Model\n        if 'HUBERT_MODEL_PATH' not in os.environ:\n            hubert_path = self.data_root / 'TTSData' / 'chinese-hubert-base' / 'chinese-hubert-base.onnx'\n            if hubert_path.exists():\n                os.environ['HUBERT_MODEL_PATH'] = str(hubert_path)\n                logger.debug(f\"Auto-configured HUBERT_MODEL_PATH: {hubert_path}\")\n\n\n    def _load_config(self):\n        if self.config_file.exists():\n            try:\n                with open(self.config_file, \"r\", encoding=\"utf-8\") as f:\n                    return json.load(f)\n            except Exception as e:\n                logger.error(f\"Failed to load env config: {e}\")\n        return {\"mode\": \"cpu\", \"developer_mode\": False}\n\n    def _save_config(self):\n        try:\n            with open(self.config_file, \"w\", encoding=\"utf-8\") as f:\n                json.dump(self._config, f, indent=4)\n        except Exception as e:\n            logger.error(f\"Failed to save env config: {e}\")\n\n    def get_mode(self) -> str:\n        \"\"\"Returns the configured mode ('cpu' or 'gpu'), respecting overrides.\"\"\"\n        if self._mode_override:\n            return self._mode_override\n        return self._config.get(\"mode\", \"cpu\")\n\n    def get_developer_mode(self) -> bool:\n        \"\"\"Returns True if developer mode is enabled.\"\"\"\n        return self._config.get(\"developer_mode\", False)\n\n    def set_developer_mode(self, enabled: bool):\n        \"\"\"Sets the developer mode and saves configuration.\"\"\"\n        if enabled:\n            ensure_developer_dependencies()\n        \n        self._config[\"developer_mode\"] = enabled\n        self._save_config()\n        logger.info(f\"Developer mode set to: {enabled}\")\n\n    def set_mode(self, mode: str):\n        \"\"\"Sets the desired mode and saves configuration.\"\"\"\n        if mode not in [\"cpu\", \"gpu\"]:\n            raise ValueError(\"Mode must be 'cpu' or 'gpu'\")\n        \n        if mode == \"gpu\" and self.get_environment_status() == EnvironmentStatus.CPU_ONLY:\n            print_gpu_instruction()\n            logger.warning(\"GPU mode set, but environment is CPU-only.\")\n             \n        self._config[\"mode\"] = mode\n        self._save_config()\n        logger.info(f\"LunaVox mode set to: {mode}\")\n\n    def is_gpu_installed(self) -> bool:\n        \"\"\"Checks if onnxruntime-gpu is currently installed and functional.\"\"\"\n        try:\n            import onnxruntime as ort\n            providers = ort.get_available_providers()\n            if \"CUDAExecutionProvider\" not in providers:\n                return False\n            return True\n        except Exception:\n            return False\n\n    def get_environment_status(self) -> EnvironmentStatus:\n        \"\"\"Detect the current runtime environment status.\"\"\"\n        if self._cached_env_status is not None:\n            return self._cached_env_status\n        \n        try:\n            import onnxruntime as ort\n            available_providers = set(ort.get_available_providers())\n            \n            if \"CUDAExecutionProvider\" in available_providers:\n                self._cached_env_status = EnvironmentStatus.GPU_READY\n                return self._cached_env_status\n            \n            try:\n                from importlib.metadata import distribution\n                dist = distribution('onnxruntime-gpu')\n                if dist:\n                    self._cached_env_status = EnvironmentStatus.GPU_DEPS_MISSING\n                    return self._cached_env_status\n            except Exception:\n                pass\n            \n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n            \n        except ImportError:\n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n\n    def invalidate_cache(self) -> None:\n        \"\"\"Clear cached environment status.\"\"\"\n        self._cached_env_status = None\n\n    def temporary_mode(self, mode: str):\n        \"\"\"Context manager to temporarily override mode without saving.\"\"\"\n        from contextlib import contextmanager\n\n        @contextmanager\n        def _override():\n            old_override = self._mode_override\n            self._mode_override = mode\n            try:\n                yield\n            finally:\n                self._mode_override = old_override\n        \n        return _override()\n\n    def ensure_environment(self) -> bool:\n        \"\"\"Validates environment against requested mode.\"\"\"\n        target_mode = self.get_mode()\n        status = self.get_environment_status()\n\n        if target_mode == \"gpu\":\n            if status == EnvironmentStatus.CPU_ONLY:\n                print_gpu_instruction()\n                from ..Core.Model.ExecutionPolicy import EnvironmentMismatchError\n                raise EnvironmentMismatchError(\n                    \"GPU mode requested but only CPU runtime is installed.\"\n                )\n            elif status == EnvironmentStatus.GPU_DEPS_MISSING:\n                logger.warning(\"GPU package installed but CUDA deps missing.\")\n        \n        return True\n\n\n# Source: src/lunavox_tts/Core/Model/ExecutionPolicy.py\nclass EnvironmentMismatchError(Exception):\n    \"\"\"Raised when requested execution mode doesn't match environment capabilities.\"\"\"\n    pass", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 6958}, "unit_tests/unit/core/test_env_logic.py::65": {"resolved_imports": ["src/lunavox_tts/Utils/EnvManager.py"], "used_names": ["EnvManager", "EnvironmentStatus", "patch"], "enclosing_function": "test_get_environment_status_cpu_only", "extracted_code": "# Source: src/lunavox_tts/Utils/EnvManager.py\nclass EnvironmentStatus(Enum):\n    \"\"\"Runtime environment detection status.\"\"\"\n    CPU_ONLY = \"cpu_only\"           # Only onnxruntime installed (no GPU support)\n    GPU_READY = \"gpu_ready\"         # onnxruntime-gpu installed and CUDA available\n    GPU_DEPS_MISSING = \"gpu_deps_missing\"\n\nclass EnvManager:\n    def __init__(self):\n        # Determine the Data directory relative to the package root.\n        try:\n            current_file = Path(__file__).resolve()\n            repo_root = current_file.parents[3]\n            self.repo_root = repo_root\n            self.data_root = repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n        except Exception:\n            self.repo_root = Path(\".\")\n            self.data_root = self.repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n\n        # Allow override via env var\n        data_dir_env = os.environ.get(\"LUNAVOX_DATA_DIR\")\n        if data_dir_env:\n            self.config_dir = Path(data_dir_env)\n            \n        self.config_dir.mkdir(parents=True, exist_ok=True)\n        self.config_file = self.config_dir / \"env_config.json\"\n        self._config = self._load_config()\n        self._mode_override: Optional[str] = None\n        self._cached_env_status: Optional[EnvironmentStatus] = None\n        \n        # Setup portable CUDA paths if on Windows and GPU mode is active\n        if sys.platform == \"win32\" and self.get_mode() == \"gpu\":\n            setup_portable_cuda_paths()\n\n        self._setup_default_paths()\n\n    def _setup_default_paths(self):\n        \"\"\"Automatically configure environment variables for standard model paths if they exist.\"\"\"\n        # 1. Hubert Model\n        if 'HUBERT_MODEL_PATH' not in os.environ:\n            hubert_path = self.data_root / 'TTSData' / 'chinese-hubert-base' / 'chinese-hubert-base.onnx'\n            if hubert_path.exists():\n                os.environ['HUBERT_MODEL_PATH'] = str(hubert_path)\n                logger.debug(f\"Auto-configured HUBERT_MODEL_PATH: {hubert_path}\")\n\n\n    def _load_config(self):\n        if self.config_file.exists():\n            try:\n                with open(self.config_file, \"r\", encoding=\"utf-8\") as f:\n                    return json.load(f)\n            except Exception as e:\n                logger.error(f\"Failed to load env config: {e}\")\n        return {\"mode\": \"cpu\", \"developer_mode\": False}\n\n    def _save_config(self):\n        try:\n            with open(self.config_file, \"w\", encoding=\"utf-8\") as f:\n                json.dump(self._config, f, indent=4)\n        except Exception as e:\n            logger.error(f\"Failed to save env config: {e}\")\n\n    def get_mode(self) -> str:\n        \"\"\"Returns the configured mode ('cpu' or 'gpu'), respecting overrides.\"\"\"\n        if self._mode_override:\n            return self._mode_override\n        return self._config.get(\"mode\", \"cpu\")\n\n    def get_developer_mode(self) -> bool:\n        \"\"\"Returns True if developer mode is enabled.\"\"\"\n        return self._config.get(\"developer_mode\", False)\n\n    def set_developer_mode(self, enabled: bool):\n        \"\"\"Sets the developer mode and saves configuration.\"\"\"\n        if enabled:\n            ensure_developer_dependencies()\n        \n        self._config[\"developer_mode\"] = enabled\n        self._save_config()\n        logger.info(f\"Developer mode set to: {enabled}\")\n\n    def set_mode(self, mode: str):\n        \"\"\"Sets the desired mode and saves configuration.\"\"\"\n        if mode not in [\"cpu\", \"gpu\"]:\n            raise ValueError(\"Mode must be 'cpu' or 'gpu'\")\n        \n        if mode == \"gpu\" and self.get_environment_status() == EnvironmentStatus.CPU_ONLY:\n            print_gpu_instruction()\n            logger.warning(\"GPU mode set, but environment is CPU-only.\")\n             \n        self._config[\"mode\"] = mode\n        self._save_config()\n        logger.info(f\"LunaVox mode set to: {mode}\")\n\n    def is_gpu_installed(self) -> bool:\n        \"\"\"Checks if onnxruntime-gpu is currently installed and functional.\"\"\"\n        try:\n            import onnxruntime as ort\n            providers = ort.get_available_providers()\n            if \"CUDAExecutionProvider\" not in providers:\n                return False\n            return True\n        except Exception:\n            return False\n\n    def get_environment_status(self) -> EnvironmentStatus:\n        \"\"\"Detect the current runtime environment status.\"\"\"\n        if self._cached_env_status is not None:\n            return self._cached_env_status\n        \n        try:\n            import onnxruntime as ort\n            available_providers = set(ort.get_available_providers())\n            \n            if \"CUDAExecutionProvider\" in available_providers:\n                self._cached_env_status = EnvironmentStatus.GPU_READY\n                return self._cached_env_status\n            \n            try:\n                from importlib.metadata import distribution\n                dist = distribution('onnxruntime-gpu')\n                if dist:\n                    self._cached_env_status = EnvironmentStatus.GPU_DEPS_MISSING\n                    return self._cached_env_status\n            except Exception:\n                pass\n            \n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n            \n        except ImportError:\n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n\n    def invalidate_cache(self) -> None:\n        \"\"\"Clear cached environment status.\"\"\"\n        self._cached_env_status = None\n\n    def temporary_mode(self, mode: str):\n        \"\"\"Context manager to temporarily override mode without saving.\"\"\"\n        from contextlib import contextmanager\n\n        @contextmanager\n        def _override():\n            old_override = self._mode_override\n            self._mode_override = mode\n            try:\n                yield\n            finally:\n                self._mode_override = old_override\n        \n        return _override()\n\n    def ensure_environment(self) -> bool:\n        \"\"\"Validates environment against requested mode.\"\"\"\n        target_mode = self.get_mode()\n        status = self.get_environment_status()\n\n        if target_mode == \"gpu\":\n            if status == EnvironmentStatus.CPU_ONLY:\n                print_gpu_instruction()\n                from ..Core.Model.ExecutionPolicy import EnvironmentMismatchError\n                raise EnvironmentMismatchError(\n                    \"GPU mode requested but only CPU runtime is installed.\"\n                )\n            elif status == EnvironmentStatus.GPU_DEPS_MISSING:\n                logger.warning(\"GPU package installed but CUDA deps missing.\")\n        \n        return True", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 6761}, "unit_tests/unit/core/test_env_logic.py::41": {"resolved_imports": ["src/lunavox_tts/Utils/EnvManager.py"], "used_names": ["EnvManager", "EnvironmentStatus", "patch"], "enclosing_function": "test_get_environment_status_gpu_ready", "extracted_code": "# Source: src/lunavox_tts/Utils/EnvManager.py\nclass EnvironmentStatus(Enum):\n    \"\"\"Runtime environment detection status.\"\"\"\n    CPU_ONLY = \"cpu_only\"           # Only onnxruntime installed (no GPU support)\n    GPU_READY = \"gpu_ready\"         # onnxruntime-gpu installed and CUDA available\n    GPU_DEPS_MISSING = \"gpu_deps_missing\"\n\nclass EnvManager:\n    def __init__(self):\n        # Determine the Data directory relative to the package root.\n        try:\n            current_file = Path(__file__).resolve()\n            repo_root = current_file.parents[3]\n            self.repo_root = repo_root\n            self.data_root = repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n        except Exception:\n            self.repo_root = Path(\".\")\n            self.data_root = self.repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n\n        # Allow override via env var\n        data_dir_env = os.environ.get(\"LUNAVOX_DATA_DIR\")\n        if data_dir_env:\n            self.config_dir = Path(data_dir_env)\n            \n        self.config_dir.mkdir(parents=True, exist_ok=True)\n        self.config_file = self.config_dir / \"env_config.json\"\n        self._config = self._load_config()\n        self._mode_override: Optional[str] = None\n        self._cached_env_status: Optional[EnvironmentStatus] = None\n        \n        # Setup portable CUDA paths if on Windows and GPU mode is active\n        if sys.platform == \"win32\" and self.get_mode() == \"gpu\":\n            setup_portable_cuda_paths()\n\n        self._setup_default_paths()\n\n    def _setup_default_paths(self):\n        \"\"\"Automatically configure environment variables for standard model paths if they exist.\"\"\"\n        # 1. Hubert Model\n        if 'HUBERT_MODEL_PATH' not in os.environ:\n            hubert_path = self.data_root / 'TTSData' / 'chinese-hubert-base' / 'chinese-hubert-base.onnx'\n            if hubert_path.exists():\n                os.environ['HUBERT_MODEL_PATH'] = str(hubert_path)\n                logger.debug(f\"Auto-configured HUBERT_MODEL_PATH: {hubert_path}\")\n\n\n    def _load_config(self):\n        if self.config_file.exists():\n            try:\n                with open(self.config_file, \"r\", encoding=\"utf-8\") as f:\n                    return json.load(f)\n            except Exception as e:\n                logger.error(f\"Failed to load env config: {e}\")\n        return {\"mode\": \"cpu\", \"developer_mode\": False}\n\n    def _save_config(self):\n        try:\n            with open(self.config_file, \"w\", encoding=\"utf-8\") as f:\n                json.dump(self._config, f, indent=4)\n        except Exception as e:\n            logger.error(f\"Failed to save env config: {e}\")\n\n    def get_mode(self) -> str:\n        \"\"\"Returns the configured mode ('cpu' or 'gpu'), respecting overrides.\"\"\"\n        if self._mode_override:\n            return self._mode_override\n        return self._config.get(\"mode\", \"cpu\")\n\n    def get_developer_mode(self) -> bool:\n        \"\"\"Returns True if developer mode is enabled.\"\"\"\n        return self._config.get(\"developer_mode\", False)\n\n    def set_developer_mode(self, enabled: bool):\n        \"\"\"Sets the developer mode and saves configuration.\"\"\"\n        if enabled:\n            ensure_developer_dependencies()\n        \n        self._config[\"developer_mode\"] = enabled\n        self._save_config()\n        logger.info(f\"Developer mode set to: {enabled}\")\n\n    def set_mode(self, mode: str):\n        \"\"\"Sets the desired mode and saves configuration.\"\"\"\n        if mode not in [\"cpu\", \"gpu\"]:\n            raise ValueError(\"Mode must be 'cpu' or 'gpu'\")\n        \n        if mode == \"gpu\" and self.get_environment_status() == EnvironmentStatus.CPU_ONLY:\n            print_gpu_instruction()\n            logger.warning(\"GPU mode set, but environment is CPU-only.\")\n             \n        self._config[\"mode\"] = mode\n        self._save_config()\n        logger.info(f\"LunaVox mode set to: {mode}\")\n\n    def is_gpu_installed(self) -> bool:\n        \"\"\"Checks if onnxruntime-gpu is currently installed and functional.\"\"\"\n        try:\n            import onnxruntime as ort\n            providers = ort.get_available_providers()\n            if \"CUDAExecutionProvider\" not in providers:\n                return False\n            return True\n        except Exception:\n            return False\n\n    def get_environment_status(self) -> EnvironmentStatus:\n        \"\"\"Detect the current runtime environment status.\"\"\"\n        if self._cached_env_status is not None:\n            return self._cached_env_status\n        \n        try:\n            import onnxruntime as ort\n            available_providers = set(ort.get_available_providers())\n            \n            if \"CUDAExecutionProvider\" in available_providers:\n                self._cached_env_status = EnvironmentStatus.GPU_READY\n                return self._cached_env_status\n            \n            try:\n                from importlib.metadata import distribution\n                dist = distribution('onnxruntime-gpu')\n                if dist:\n                    self._cached_env_status = EnvironmentStatus.GPU_DEPS_MISSING\n                    return self._cached_env_status\n            except Exception:\n                pass\n            \n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n            \n        except ImportError:\n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n\n    def invalidate_cache(self) -> None:\n        \"\"\"Clear cached environment status.\"\"\"\n        self._cached_env_status = None\n\n    def temporary_mode(self, mode: str):\n        \"\"\"Context manager to temporarily override mode without saving.\"\"\"\n        from contextlib import contextmanager\n\n        @contextmanager\n        def _override():\n            old_override = self._mode_override\n            self._mode_override = mode\n            try:\n                yield\n            finally:\n                self._mode_override = old_override\n        \n        return _override()\n\n    def ensure_environment(self) -> bool:\n        \"\"\"Validates environment against requested mode.\"\"\"\n        target_mode = self.get_mode()\n        status = self.get_environment_status()\n\n        if target_mode == \"gpu\":\n            if status == EnvironmentStatus.CPU_ONLY:\n                print_gpu_instruction()\n                from ..Core.Model.ExecutionPolicy import EnvironmentMismatchError\n                raise EnvironmentMismatchError(\n                    \"GPU mode requested but only CPU runtime is installed.\"\n                )\n            elif status == EnvironmentStatus.GPU_DEPS_MISSING:\n                logger.warning(\"GPU package installed but CUDA deps missing.\")\n        \n        return True", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 6761}, "unit_tests/unit/core/test_env_logic.py::53": {"resolved_imports": ["src/lunavox_tts/Utils/EnvManager.py"], "used_names": ["EnvManager", "EnvironmentStatus", "MagicMock", "patch"], "enclosing_function": "test_get_environment_status_deps_missing", "extracted_code": "# Source: src/lunavox_tts/Utils/EnvManager.py\nclass EnvironmentStatus(Enum):\n    \"\"\"Runtime environment detection status.\"\"\"\n    CPU_ONLY = \"cpu_only\"           # Only onnxruntime installed (no GPU support)\n    GPU_READY = \"gpu_ready\"         # onnxruntime-gpu installed and CUDA available\n    GPU_DEPS_MISSING = \"gpu_deps_missing\"\n\nclass EnvManager:\n    def __init__(self):\n        # Determine the Data directory relative to the package root.\n        try:\n            current_file = Path(__file__).resolve()\n            repo_root = current_file.parents[3]\n            self.repo_root = repo_root\n            self.data_root = repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n        except Exception:\n            self.repo_root = Path(\".\")\n            self.data_root = self.repo_root / \"lunavoxData\"\n            self.config_dir = self.data_root / \"TTSData\"\n\n        # Allow override via env var\n        data_dir_env = os.environ.get(\"LUNAVOX_DATA_DIR\")\n        if data_dir_env:\n            self.config_dir = Path(data_dir_env)\n            \n        self.config_dir.mkdir(parents=True, exist_ok=True)\n        self.config_file = self.config_dir / \"env_config.json\"\n        self._config = self._load_config()\n        self._mode_override: Optional[str] = None\n        self._cached_env_status: Optional[EnvironmentStatus] = None\n        \n        # Setup portable CUDA paths if on Windows and GPU mode is active\n        if sys.platform == \"win32\" and self.get_mode() == \"gpu\":\n            setup_portable_cuda_paths()\n\n        self._setup_default_paths()\n\n    def _setup_default_paths(self):\n        \"\"\"Automatically configure environment variables for standard model paths if they exist.\"\"\"\n        # 1. Hubert Model\n        if 'HUBERT_MODEL_PATH' not in os.environ:\n            hubert_path = self.data_root / 'TTSData' / 'chinese-hubert-base' / 'chinese-hubert-base.onnx'\n            if hubert_path.exists():\n                os.environ['HUBERT_MODEL_PATH'] = str(hubert_path)\n                logger.debug(f\"Auto-configured HUBERT_MODEL_PATH: {hubert_path}\")\n\n\n    def _load_config(self):\n        if self.config_file.exists():\n            try:\n                with open(self.config_file, \"r\", encoding=\"utf-8\") as f:\n                    return json.load(f)\n            except Exception as e:\n                logger.error(f\"Failed to load env config: {e}\")\n        return {\"mode\": \"cpu\", \"developer_mode\": False}\n\n    def _save_config(self):\n        try:\n            with open(self.config_file, \"w\", encoding=\"utf-8\") as f:\n                json.dump(self._config, f, indent=4)\n        except Exception as e:\n            logger.error(f\"Failed to save env config: {e}\")\n\n    def get_mode(self) -> str:\n        \"\"\"Returns the configured mode ('cpu' or 'gpu'), respecting overrides.\"\"\"\n        if self._mode_override:\n            return self._mode_override\n        return self._config.get(\"mode\", \"cpu\")\n\n    def get_developer_mode(self) -> bool:\n        \"\"\"Returns True if developer mode is enabled.\"\"\"\n        return self._config.get(\"developer_mode\", False)\n\n    def set_developer_mode(self, enabled: bool):\n        \"\"\"Sets the developer mode and saves configuration.\"\"\"\n        if enabled:\n            ensure_developer_dependencies()\n        \n        self._config[\"developer_mode\"] = enabled\n        self._save_config()\n        logger.info(f\"Developer mode set to: {enabled}\")\n\n    def set_mode(self, mode: str):\n        \"\"\"Sets the desired mode and saves configuration.\"\"\"\n        if mode not in [\"cpu\", \"gpu\"]:\n            raise ValueError(\"Mode must be 'cpu' or 'gpu'\")\n        \n        if mode == \"gpu\" and self.get_environment_status() == EnvironmentStatus.CPU_ONLY:\n            print_gpu_instruction()\n            logger.warning(\"GPU mode set, but environment is CPU-only.\")\n             \n        self._config[\"mode\"] = mode\n        self._save_config()\n        logger.info(f\"LunaVox mode set to: {mode}\")\n\n    def is_gpu_installed(self) -> bool:\n        \"\"\"Checks if onnxruntime-gpu is currently installed and functional.\"\"\"\n        try:\n            import onnxruntime as ort\n            providers = ort.get_available_providers()\n            if \"CUDAExecutionProvider\" not in providers:\n                return False\n            return True\n        except Exception:\n            return False\n\n    def get_environment_status(self) -> EnvironmentStatus:\n        \"\"\"Detect the current runtime environment status.\"\"\"\n        if self._cached_env_status is not None:\n            return self._cached_env_status\n        \n        try:\n            import onnxruntime as ort\n            available_providers = set(ort.get_available_providers())\n            \n            if \"CUDAExecutionProvider\" in available_providers:\n                self._cached_env_status = EnvironmentStatus.GPU_READY\n                return self._cached_env_status\n            \n            try:\n                from importlib.metadata import distribution\n                dist = distribution('onnxruntime-gpu')\n                if dist:\n                    self._cached_env_status = EnvironmentStatus.GPU_DEPS_MISSING\n                    return self._cached_env_status\n            except Exception:\n                pass\n            \n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n            \n        except ImportError:\n            self._cached_env_status = EnvironmentStatus.CPU_ONLY\n            return self._cached_env_status\n\n    def invalidate_cache(self) -> None:\n        \"\"\"Clear cached environment status.\"\"\"\n        self._cached_env_status = None\n\n    def temporary_mode(self, mode: str):\n        \"\"\"Context manager to temporarily override mode without saving.\"\"\"\n        from contextlib import contextmanager\n\n        @contextmanager\n        def _override():\n            old_override = self._mode_override\n            self._mode_override = mode\n            try:\n                yield\n            finally:\n                self._mode_override = old_override\n        \n        return _override()\n\n    def ensure_environment(self) -> bool:\n        \"\"\"Validates environment against requested mode.\"\"\"\n        target_mode = self.get_mode()\n        status = self.get_environment_status()\n\n        if target_mode == \"gpu\":\n            if status == EnvironmentStatus.CPU_ONLY:\n                print_gpu_instruction()\n                from ..Core.Model.ExecutionPolicy import EnvironmentMismatchError\n                raise EnvironmentMismatchError(\n                    \"GPU mode requested but only CPU runtime is installed.\"\n                )\n            elif status == EnvironmentStatus.GPU_DEPS_MISSING:\n                logger.warning(\"GPU package installed but CUDA deps missing.\")\n        \n        return True", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 6761}, "unit_tests/unit/core/test_registry.py::23": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_register_and_get", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::91": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_is_supported", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::92": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_is_supported", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::50": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_case_insensitive", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::51": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_case_insensitive", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::80": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_list_languages_includes_registered", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::134": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["MagicMock", "get_language_frontend", "register_language"], "enclosing_function": "test_get_language_frontend", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\ndef get_language_frontend(language: str) -> \"AbstractFrontend\":\n    return language_registry.get(language)\n\ndef register_language(language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n    language_registry.register(language, frontend_class)", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 304}, "unit_tests/unit/core/test_registry.py::114": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "MagicMock"], "enclosing_function": "test_re_register_clears_instance", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_registry.py::32": {"resolved_imports": ["src/lunavox_tts/Core/Frontend/registry.py"], "used_names": ["LanguageRegistry", "pytest"], "enclosing_function": "test_unsupported_language_raises", "extracted_code": "# Source: src/lunavox_tts/Core/Frontend/registry.py\nclass LanguageRegistry:\n    \"\"\"Central registry for language-specific frontends.\n    \n    Uses lazy import to avoid loading heavy dependencies (jieba, pyopenjtalk)\n    until a language is actually requested.\n    \"\"\"\n    \n    # Builtin frontend paths (module:class format)\n    _BUILTIN_FRONTENDS = {\n        'en': 'lunavox_tts.Languages.English.EnglishG2P:EnglishFrontend',\n        'zh': 'lunavox_tts.Languages.Chinese.ChineseG2P:ChineseFrontend',\n        'ja': 'lunavox_tts.Languages.Japanese.JapaneseG2P:JapaneseFrontend',\n    }\n    \n    def __init__(self):\n        # Store module paths as strings for lazy import\n        self._frontend_paths: Dict[str, str] = dict(self._BUILTIN_FRONTENDS)\n        self._instances: Dict[str, \"AbstractFrontend\"] = {}\n    \n    def register(self, language: str, frontend_class: Type[\"AbstractFrontend\"]) -> None:\n        \"\"\"Register a frontend class directly (for plugins).\"\"\"\n        lang = language.lower()\n        # Store the class directly, not as path\n        self._frontend_paths[lang] = frontend_class\n        if lang in self._instances:\n            del self._instances[lang]\n        logger.debug(f\"Registered frontend for language: {lang}\")\n    \n    def get(self, language: str) -> \"AbstractFrontend\":\n        \"\"\"Get frontend instance, lazily importing if needed.\"\"\"\n        lang = language.lower()\n        \n        if lang in self._instances:\n            return self._instances[lang]\n        \n        if lang not in self._frontend_paths:\n            raise ValueError(f\"Unsupported language: {language}. Available: {self.list_languages()}\")\n        \n        frontend_ref = self._frontend_paths[lang]\n        \n        # Handle both string paths and direct class references\n        if isinstance(frontend_ref, str):\n            frontend_class = self._import_frontend(frontend_ref)\n        else:\n            frontend_class = frontend_ref\n        \n        instance = frontend_class()\n        self._instances[lang] = instance\n        return instance\n    \n    def _import_frontend(self, path: str) -> Type[\"AbstractFrontend\"]:\n        \"\"\"Dynamically import a frontend class from module:class path.\"\"\"\n        import importlib\n        module_path, class_name = path.rsplit(':', 1)\n        try:\n            module = importlib.import_module(module_path)\n            return getattr(module, class_name)\n        except ImportError as e:\n            logger.error(f\"Failed to import frontend from {path}: {e}\")\n            raise\n    \n    def list_languages(self) -> List[str]:\n        return list(self._frontend_paths.keys())\n    \n    def is_supported(self, language: str) -> bool:\n        return language.lower() in self._frontend_paths\n    \n    def clear_instances(self) -> None:\n        \"\"\"Clear cached frontend instances to release memory.\"\"\"\n        self._instances.clear()\n        logger.debug(\"Frontend instances cleared.\")", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 2909}, "unit_tests/unit/core/test_resource_lifecycle.py::20": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py"], "used_names": ["RuntimeManager"], "enclosing_function": "test_singleton_pattern", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nclass RuntimeManager:\n    \"\"\"\n    Singleton manager for heavyweight global models.\n    \n    Usage:\n        from lunavox_tts.Utils.RuntimeManager import runtime_manager\n        runtime_manager.cleanup_all()  # Clean everything for fresh measurement\n    \"\"\"\n    \n    _instance: Optional[\"RuntimeManager\"] = None\n    \n    def __new__(cls) -> \"RuntimeManager\":\n        if cls._instance is None:\n            cls._instance = super().__new__(cls)\n        return cls._instance\n    \n    # =========================================================================\n    # HuBERT Management\n    # =========================================================================\n    \n    def load_hubert(self) -> bool:\n        \"\"\"Load HuBERT model via ModelManager.\"\"\"\n        return model_manager.load_cn_hubert()\n    \n    def unload_hubert(self) -> None:\n        \"\"\"Unload HuBERT model and release memory.\"\"\"\n        model_manager.unload_cn_hubert()\n    \n    def is_hubert_loaded(self) -> bool:\n        \"\"\"Check if HuBERT is currently loaded.\"\"\"\n        return model_manager.cn_hubert is not None\n    \n    # =========================================================================\n    # Chinese BERT Management\n    # =========================================================================\n    \n    def load_zh_bert(self) -> bool:\n        \"\"\"Load Chinese RoBERTa BERT model.\"\"\"\n        try:\n            # Still use protected import for internal function\n            ZhBert._load_model()\n            return True\n        except Exception as e:\n            logger.error(f\"Failed to load ZhBERT: {e}\")\n            return False\n    \n    def unload_zh_bert(self) -> None:\n        \"\"\"Unload Chinese RoBERTa BERT model and release memory.\"\"\"\n        ZhBert.unload()\n        gc.collect()\n        logger.info(\"✓ Chinese BERT model unloaded.\")\n    \n    def is_zh_bert_loaded(self) -> bool:\n        \"\"\"Check if Chinese BERT is currently loaded.\"\"\"\n        return ZhBert.is_loaded()\n    \n    def unload_all_bert(self) -> None:\n        \"\"\"Unload all language BERT models.\"\"\"\n        self.unload_zh_bert()\n        # Future: add English BERT, Japanese BERT if needed\n    \n    # =========================================================================\n    # Speaker Vector (SV) Management\n    # =========================================================================\n    \n    def load_sv(self) -> bool:\n        \"\"\"Load Speaker Vector model.\"\"\"\n        return SpeakerVector.load_sv_model()\n    \n    def unload_sv(self) -> None:\n        \"\"\"Unload Speaker Vector model and release memory.\"\"\"\n        SpeakerVector.unload()\n        gc.collect()\n        logger.info(\"✓ Speaker Vector model unloaded.\")\n    \n    def is_sv_loaded(self) -> bool:\n        \"\"\"Check if Speaker Vector model is currently loaded.\"\"\"\n        return SpeakerVector.is_loaded()\n    \n    # =========================================================================\n    # Character Model Management (delegated)\n    # =========================================================================\n    \n    def unload_all_characters(self) -> None:\n        \"\"\"Unload all cached character models.\"\"\"\n        logger.info(\"Unloading all character models...\")\n        model_manager.clean_cache()\n        gc.collect()\n        logger.info(\"✓ All character models unloaded.\")\n    \n    # =========================================================================\n    # Aggregate Cleanup\n    # =========================================================================\n    \n    def cleanup_all(self) -> None:\n        \"\"\"\n        Release ALL heavy resources for clean memory measurement.\n        \n        Call this between benchmark runs to ensure each test starts\n        from a pristine state with no residual models.\n        \"\"\"\n        import time\n        \n        logger.info(\"=== RuntimeManager: Full Cleanup ===\")\n        self.unload_hubert()\n        self.unload_all_bert()\n        self.unload_sv()\n        self.unload_all_characters()\n        self.clear_api_state()\n        self.clear_frontend_cache()\n        \n        # Allow async operations to complete\n        time.sleep(0.1)\n        \n        # Multiple GC passes for ONNX C++ destructor chain\n        gc.collect()\n        gc.collect()\n        gc.collect()\n        \n        self.try_empty_vram()\n        logger.info(\"=== Cleanup Complete ===\")\n    \n    def clear_api_state(self) -> None:\n        \"\"\"\n        Clear API-level state that holds ReferenceAudio objects.\n        \n        This prevents memory leaks from orphaned feature arrays when\n        switching characters or running benchmarks.\n        \"\"\"\n        try:\n            clear_all_reference_audio()\n            logger.debug(\"✓ API reference audio state cleared.\")\n        except ImportError:\n            pass\n        \n        try:\n            ReferenceAudio.clear_cache()\n            logger.debug(\"✓ ReferenceAudio prompt cache cleared.\")\n        except (ImportError, AttributeError):\n            pass\n    \n    def clear_frontend_cache(self) -> None:\n        \"\"\"\n        Clear cached frontend instances from LanguageRegistry.\n        \n        This releases heavy dependencies like jieba (Chinese) and\n        pyopenjtalk (Japanese) that get cached after first use.\n        \"\"\"\n        try:\n            language_registry.clear_instances()\n            logger.debug(\"✓ Frontend instances cleared.\")\n        except ImportError:\n            pass\n    \n    def try_empty_vram(self) -> None:\n        \"\"\"\n        Attempt to release GPU memory.\n        \n        Note: LunaVox uses ONNX Runtime, not PyTorch. ONNX RT manages\n        its own GPU memory pools. We only call gc.collect() here.\n        Importing torch would add ~360MB RAM overhead for no benefit.\n        \"\"\"\n        gc.collect()\n    \n    def get_loaded_resources(self) -> dict:\n        \"\"\"Return a dict of which resources are currently loaded.\"\"\"\n        return {\n            \"hubert\": self.is_hubert_loaded(),\n            \"zh_bert\": self.is_zh_bert_loaded(),\n            \"sv\": self.is_sv_loaded(),\n        }", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 6047}, "unit_tests/unit/core/test_resource_lifecycle.py::29": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/ResourceManager.py"], "used_names": ["MagicMock", "resource_manager", "runtime_manager"], "enclosing_function": "test_unload_hubert_sets_none", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()\n\n\n# Source: src/lunavox_tts/ResourceManager.py\nresource_manager = GlobalResourceManager()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 174}, "unit_tests/unit/core/test_resource_lifecycle.py::111": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/ResourceManager.py"], "used_names": ["MagicMock", "resource_manager", "runtime_manager"], "enclosing_function": "test_is_hubert_loaded_reflects_state", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()\n\n\n# Source: src/lunavox_tts/ResourceManager.py\nresource_manager = GlobalResourceManager()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 174}, "unit_tests/unit/core/test_resource_lifecycle.py::107": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py", "src/lunavox_tts/ResourceManager.py"], "used_names": ["MagicMock", "resource_manager", "runtime_manager"], "enclosing_function": "test_is_hubert_loaded_reflects_state", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()\n\n\n# Source: src/lunavox_tts/ResourceManager.py\nresource_manager = GlobalResourceManager()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 174}, "unit_tests/unit/core/test_resource_lifecycle.py::96": {"resolved_imports": ["src/lunavox_tts/Utils/RuntimeManager.py"], "used_names": ["runtime_manager"], "enclosing_function": "test_get_loaded_resources_returns_dict", "extracted_code": "# Source: src/lunavox_tts/Utils/RuntimeManager.py\nruntime_manager = RuntimeManager()", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 84}, "unit_tests/unit/core/test_spec.py::26": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["ModelVersion"], "enclosing_function": "test_model_version_count", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nclass ModelVersion(Enum):\n    \"\"\"Supported model versions.\"\"\"\n    V2 = \"v2\"\n    V2_PRO = \"v2Pro\"\n    V2_PRO_PLUS = \"v2ProPlus\"", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 171}, "unit_tests/unit/core/test_spec.py::18": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["ModelVersion"], "enclosing_function": "test_model_version_values", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nclass ModelVersion(Enum):\n    \"\"\"Supported model versions.\"\"\"\n    V2 = \"v2\"\n    V2_PRO = \"v2Pro\"\n    V2_PRO_PLUS = \"v2ProPlus\"", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 171}, "unit_tests/unit/core/test_spec.py::179": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["MagicMock", "get_model_spec"], "enclosing_function": "test_basic_inputs", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\ndef get_model_spec(version: str) -> ModelSpec:\n    \"\"\"Get the model specification for a given version string.\"\"\"\n    version_lower = version.lower().replace(\"_\", \"\").replace(\"-\", \"\")\n    \n    if version_lower in (\"v2proplus\", \"v2pp\"):\n        return V2_PRO_PLUS_SPEC\n    elif version_lower == \"v2pro\":\n        return V2_PRO_SPEC\n    else:\n        return V2_SPEC", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 406}, "unit_tests/unit/core/test_spec.py::19": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["ModelVersion"], "enclosing_function": "test_model_version_values", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nclass ModelVersion(Enum):\n    \"\"\"Supported model versions.\"\"\"\n    V2 = \"v2\"\n    V2_PRO = \"v2Pro\"\n    V2_PRO_PLUS = \"v2ProPlus\"", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 171}, "unit_tests/unit/core/test_spec.py::37": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["V2_SPEC", "get_model_spec"], "enclosing_function": "test_get_spec_v2", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nV2_SPEC = ModelSpec(\n    version=ModelVersion.V2, \n    requires_global_emb=False, \n    requires_sv_emb=False,\n    vocoder_inputs=V2_VOCODER_INPUTS,\n)\n\ndef get_model_spec(version: str) -> ModelSpec:\n    \"\"\"Get the model specification for a given version string.\"\"\"\n    version_lower = version.lower().replace(\"_\", \"\").replace(\"-\", \"\")\n    \n    if version_lower in (\"v2proplus\", \"v2pp\"):\n        return V2_PRO_PLUS_SPEC\n    elif version_lower == \"v2pro\":\n        return V2_PRO_SPEC\n    else:\n        return V2_SPEC", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 557}, "unit_tests/unit/core/test_spec.py::20": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["ModelVersion"], "enclosing_function": "test_model_version_values", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nclass ModelVersion(Enum):\n    \"\"\"Supported model versions.\"\"\"\n    V2 = \"v2\"\n    V2_PRO = \"v2Pro\"\n    V2_PRO_PLUS = \"v2ProPlus\"", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 171}, "unit_tests/unit/core/test_spec.py::51": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["V2_PRO_SPEC", "get_model_spec"], "enclosing_function": "test_get_spec_v2pro", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nV2_PRO_SPEC = ModelSpec(\n    version=ModelVersion.V2_PRO, \n    requires_global_emb=False, \n    requires_sv_emb=True,\n    vocoder_inputs=V2_PRO_VOCODER_INPUTS,\n)\n\ndef get_model_spec(version: str) -> ModelSpec:\n    \"\"\"Get the model specification for a given version string.\"\"\"\n    version_lower = version.lower().replace(\"_\", \"\").replace(\"-\", \"\")\n    \n    if version_lower in (\"v2proplus\", \"v2pp\"):\n        return V2_PRO_PLUS_SPEC\n    elif version_lower == \"v2pro\":\n        return V2_PRO_SPEC\n    else:\n        return V2_SPEC", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 568}, "unit_tests/unit/core/test_spec.py::108": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["VocoderInputSpec"], "enclosing_function": "test_get_all_inputs", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nclass VocoderInputSpec:\n    \"\"\"\n    Specification for vocoder input assembly.\n    \n    Defines which inputs are required/optional for each model version's vocoder,\n    enabling spec-driven input assembly instead of hardcoded version checks.\n    \"\"\"\n    required_inputs: List[str] = field(default_factory=lambda: [\"text_seq\", \"pred_semantic\"])\n    optional_inputs: List[str] = field(default_factory=list)\n    \n    # Feature source mappings: input_name -> attribute path on FeaturePacket/ReferenceAudio\n    feature_mappings: Dict[str, str] = field(default_factory=dict)\n    \n    def get_all_inputs(self) -> List[str]:\n        \"\"\"Get all possible inputs (required + optional).\"\"\"\n        return self.required_inputs + self.optional_inputs", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 780}, "unit_tests/unit/core/test_spec.py::58": {"resolved_imports": ["src/lunavox_tts/Core/Model/spec.py"], "used_names": ["V2_PRO_PLUS_SPEC", "get_model_spec"], "enclosing_function": "test_get_spec_v2proplus", "extracted_code": "# Source: src/lunavox_tts/Core/Model/spec.py\nV2_PRO_PLUS_SPEC = ModelSpec(\n    version=ModelVersion.V2_PRO_PLUS,\n    prompt_encoder=ModelFileSpec(\"prompt_encoder_fp32.onnx\", \"prompt_encoder_fp16.bin\", required=False),\n    requires_global_emb=True,\n    requires_sv_emb=True,\n    vocoder_inputs=V2_PRO_PLUS_VOCODER_INPUTS,\n)\n\ndef get_model_spec(version: str) -> ModelSpec:\n    \"\"\"Get the model specification for a given version string.\"\"\"\n    version_lower = version.lower().replace(\"_\", \"\").replace(\"-\", \"\")\n    \n    if version_lower in (\"v2proplus\", \"v2pp\"):\n        return V2_PRO_PLUS_SPEC\n    elif version_lower == \"v2pro\":\n        return V2_PRO_SPEC\n    else:\n        return V2_SPEC", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 685}, "unit_tests/unit/core/test_state_healing.py::78": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["ModelManager", "inspect"], "enclosing_function": "test_no_optimization_hint_in_load_character", "extracted_code": "# Source: src/lunavox_tts/ModelManager.py\nclass ModelManager:\n    \"\"\"\n    Facade for model management. \n    Maintains a cache of active model sessions and handles resource lifecycle.\n    \"\"\"\n    \n    def __init__(self):\n        capacity_str = os.getenv('Max_Cached_Character_Models', '1')\n        self.character_to_model: Dict[str, Dict[str, InferenceSession]] = LRUCacheDict(\n            capacity=int(capacity_str)\n        )\n        self.providers = resolve_providers()\n        self.providers = resolve_providers()\n\n    def load_cn_hubert(self) -> bool:\n        \"\"\"Load the Chinese HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        return resource_manager.load_cn_hubert(self.providers)\n\n    def unload_cn_hubert(self) -> None:\n        \"\"\"Unload HuBERT model (delegated to ResourceManager).\"\"\"\n        from .ResourceManager import resource_manager\n        resource_manager.unload_cn_hubert()\n\n    def cleanup_global_resources(self) -> None:\n        \"\"\"\n        Clean up all global/singleton resources for fresh measurement.\n        Delegates to GlobalResourceManager.\n        \"\"\"\n        from .Utils.RuntimeManager import runtime_manager\n        runtime_manager.cleanup_all()\n\n    def get(self, character_name: str, skip_prompt_encoder: bool = False) -> Optional[GSVModel]:\n        \"\"\"Retrieve a character's model sessions, loading them if necessary.\"\"\"\n        name = character_name.lower()\n        \n        # Check cache\n        if name in self.character_to_model:\n            m = self.character_to_model[name]\n            return GSVModel(\n                T2S_ENCODER=m[\"T2S_ENCODER\"],\n                T2S_FIRST_STAGE_DECODER=m[\"T2S_FIRST_STAGE_DECODER\"],\n                T2S_STAGE_DECODER=m[\"T2S_STAGE_DECODER\"],\n                VITS=m[\"VITS\"],\n                PROMPT_ENCODER=m.get(\"PROMPT_ENCODER\")\n            )\n        \n        # Load if registered\n        entry = model_registry.get(name)\n        if entry:\n            if self.load_character(name, entry.path, skip_prompt_encoder=skip_prompt_encoder):\n                return self.get(name)\n        \n        return None\n\n    def has_character(self, character_name: str) -> bool:\n        return model_registry.has(character_name)\n\n    def load_character(self, character_name: str, model_dir: str, skip_prompt_encoder: bool = False) -> bool:\n        \"\"\"\n        Load all model components for a character.\n        \n        Args:\n            character_name: Name of the character.\n            model_dir: Path to the model directory.\n            skip_prompt_encoder: If True, skip loading PROMPT_ENCODER (for Persona mode).\n        \"\"\"\n        import time\n        t_start = time.perf_counter()\n        name = character_name.lower()\n        \n        # 1. Check if already loaded with SAME model_dir\n        existing_entry = model_registry.get(name)\n        already_loaded = (\n            name in self.character_to_model and\n            existing_entry and \n            existing_entry.path == model_dir\n        )\n        \n        if already_loaded:\n            # Already loaded with same path - return early\n            return True\n        \n        # 2. Detect version and register\n        version = detect_model_version(model_dir)\n        spec = get_model_spec(version)\n        model_registry.register(name, model_dir, force_version=version)\n        \n        # If loaded with different model_dir, force reload\n        if name in self.character_to_model:\n            logger.info(f\"Character '{character_name}' model changed from previous, reloading...\")\n\n        # 3. Resource Pre-check\n        from .Utils.AssetManager import asset_manager\n        is_v2pp = version in ('v2ProPlus', 'v2pp')\n        asset_manager.ensure_base()\n        if is_v2pp:\n            asset_manager.ensure_v2pp(skip_prompt_encoder=skip_prompt_encoder)\n        \n        # 4. Actual Loading via ModelLoader (wrapped in monitoring)\n        with monitor.measure(f\"Model Loading ({character_name})\", category=\"USER_PERCEIVED\"):\n            model_loader.refresh_providers()\n            self.providers = model_loader.providers\n            \n            skip = set()\n            if skip_prompt_encoder:\n                skip.add(\"PROMPT_ENCODER\")\n                \n            try:\n                model_dict = model_loader.load_all(model_dir, spec, skip_components=skip)\n                self.character_to_model[name] = model_dict\n                model_registry.mark_loaded(name, set(model_dict.keys()))\n                \n                t_end = time.perf_counter()\n                duration = t_end - t_start\n                \n                logger.info(f\"✓ Character '{character_name.capitalize()}' loaded: type={version}, providers={self.providers}\")\n                monitor.log_metric(f\"Load time ({name})\", f\"{duration:.2f}\", \"s\")\n                return True\n            except Exception as e:\n                logger.error(f\"Error loading character '{character_name}': {e}\", exc_info=True)\n                return False\n\n    def get_character_version(self, character_name: str) -> str:\n        entry = model_registry.get(character_name)\n        return entry.version if entry else 'v2'\n\n    def remove_character(self, character_name: str) -> None:\n        \"\"\"Remove a character model and force memory release.\"\"\"\n        name = character_name.lower()\n        if name in self.character_to_model:\n            # Explicitly clear session references to help GC\n            sessions = self.character_to_model[name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n            del self.character_to_model[name]\n        model_registry.unregister(name)\n        # Double GC needed for ONNX Session C++ destructor chain\n        gc.collect()\n        gc.collect()\n\n    def clean_cache(self) -> None:\n        \"\"\"Clear all cached models with explicit cleanup.\"\"\"\n        # Explicitly null out all sessions before clearing\n        for char_name in list(self.character_to_model.keys()):\n            sessions = self.character_to_model[char_name]\n            for key in list(sessions.keys()):\n                sessions[key] = None\n        self.character_to_model.clear()\n        gc.collect()\n        gc.collect()\n\n\n    @property\n    def cn_hubert(self) -> Optional[InferenceSession]:\n        from .ResourceManager import resource_manager\n        return resource_manager.cn_hubert", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 6367}, "unit_tests/unit/core/test_state_healing.py::43": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["Mock", "patch"], "enclosing_function": "test_load_character_with_skip_prompt_encoder_false", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "unit_tests/unit/core/test_state_healing.py::61": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["Mock", "patch"], "enclosing_function": "test_load_character_same_path_returns_early", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "unit_tests/unit/core/test_state_healing.py::30": {"resolved_imports": ["src/lunavox_tts/ModelManager.py"], "used_names": ["Mock", "patch"], "enclosing_function": "test_load_character_with_skip_prompt_encoder_true", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}}}