Upload 3 files

app.py

@@ -0,0 +1,497 @@
+from typing import List
+import gradio as gr
+from pathlib import Path
+from sonic_api_wrapper import CartesiaVoiceManager, VoiceAccessibility, improve_tts_text
+import os
+import json
+
+# Инициализация базовых переменных
+DEFAULT_API_KEY = ""
+LANGUAGE_CHOICES = ["all", "ru", "en", "es", "pl", "de", "fr"]
+ACCESS_TYPE_MAP = {
+    "Все": VoiceAccessibility.ALL,
+    "Только кастомные": VoiceAccessibility.ONLY_CUSTOM,
+    "Апи": VoiceAccessibility.ONLY_PUBLIC
+}
+# Обновленные константы
+SPEED_CHOICES = ["Очень медленно", "Медленно", "Нормально", "Быстро", "Очень быстро"]
+EMOTION_CHOICES = ["Нейтрально", "Весело", "Грустно", "Злобно", "Удивленно", "Любопытно"]
+EMOTION_INTENSITY = ["Очень слабая", "Слабая", "Средняя", "Сильная", "Очень сильная"]
+
+# Глобальная переменная для хранения экземпляра менеджера
+manager = None
+
+import datetime
+
+def map_speed(speed_type: str) -> float:
+    speed_map = {
+        "Очень медленно": -1.0,
+        "Медленно": -0.5,
+        "Нормально": 0.0,
+        "Быстро": 0.5,
+        "Очень быстро": 1.0
+    }
+    return speed_map[speed_type]
+
+def generate_output_filename(language: str) -> str:
+    """Генерация имени файла с временной меткой и языком"""
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"output/{timestamp}_{language}.wav"
+
+def extract_voice_id_from_label(voice_label: str) -> str:
+    """
+    Извлекает ID голоса из метки в dropdown
+    Например: "John (en) [Custom]" -> извлечет ID из словаря голосов
+    """
+    if not manager:
+        return None
+        
+    # Получаем все голоса и их метки
+    choices = manager.get_voice_choices()
+    # Находим голос по метке и берем его ID
+    voice_data = next((c for c in choices if c["label"] == voice_label), None)
+    return voice_data["value"] if voice_data else None
+
+def initialize_manager(api_key: str) -> str:
+    global manager
+    try:
+        manager = CartesiaVoiceManager(api_key=api_key, base_dir=Path("voice2voice"))
+        return "✅ Менеджер инициализирован"
+    except Exception as e:
+        return f"❌ Ошибка: {str(e)}"
+
+def get_initial_voices():
+    """Получение начального списка голосов"""
+    if not manager:
+        initialize_manager(DEFAULT_API_KEY)
+    choices = manager.get_voice_choices()
+    return [c["label"] for c in choices], choices[0]["label"] if choices else None
+
+def update_voice_list (language: str, access_type: str, current_voice: str = None):
+    """
+    Обновление списка голосов с сохранением текущего выбора
+    """
+    if not manager:
+        return gr.update(choices=[], value=None), "❌ Менеджер не инициализирован"
+    
+    try:
+        choices = manager.get_voice_choices(
+            language=None if language == "all" else language,
+            accessibility=ACCESS_TYPE_MAP[access_type]
+        )
+        
+        # Преобразуем в список меток
+        choice_labels = [c["label"] for c in choices]
+        
+        # Определяем значение для выбора
+        if current_voice in choice_labels:
+            # Сохраняем текущий выбор, если он доступен
+            new_value = current_voice
+        else:
+            # Иначе берем первый доступный голос
+            new_value = choice_labels[0] if choice_labels else None
+            
+        return gr.update(choices=choice_labels, value=new_value), "✅ Список голосов обновлен"
+    except Exception as e:
+        return gr.update(choices=[], value=None), f"❌ Ошибка: {str(e)}"
+
+def update_voice_info(voice_label: str) -> str:
+    """Обновление информации о голосе"""
+    if not manager or not voice_label:
+        return ""
+    
+    try:
+        voice_id = extract_voice_id_from_label(voice_label)
+        if not voice_id:
+            return "❌ Голос не найден"
+            
+        info = manager.get_voice_info(voice_id)
+        return (
+            f"Имя: {info['name']}\n"
+            f"Язык: {info['language']}\n"
+            f"Тип: {'Кастомный' if info.get('is_custom') else 'API'}\n"
+            f"ID: {info['id']}"
+        )
+    except Exception as e:
+        return f"❌ Ошибка: {str(e)}"
+
+def create_custom_voice(name: str, language: str, audio_data: tuple) -> tuple:
+    """
+    Создание кастомного голоса и обновление списка голосов
+    Возвращает: (статус, обновленный dropdown, информация о голосе)
+    """
+    if not manager:
+        return "❌ Менеджер не инициализирован", gr.update(), ""
+    
+    if not name or not audio_data:
+        return "❌ Необходимо указать имя и файл голоса", gr.update(), ""
+    
+    try:
+        # Получаем путь к аудио файлу
+        audio_path = audio_data[0] if isinstance(audio_data, tuple) else audio_data
+        
+        # Создаем голос
+        voice_id = manager.create_custom_embedding(
+            file_path=audio_path,
+            name=name,
+            language=language
+        )
+        
+        print(voice_id)
+        
+        # Получаем обновленный список голосов
+        choices = manager.get_voice_choices()
+        choice_labels = [c["label"] for c in choices]
+        
+        # Находим метку для нового голоса
+        new_voice_label = next(c["label"] for c in choices if c["value"] == voice_id)
+        
+        # Получаем информацию о новом голосе
+        voice_info = manager.get_voice_info(voice_id)
+        info_text = (
+            f"Имя: {voice_info['name']}\n"
+            f"Язык: {voice_info['language']}\n"
+            f"Тип: Кастомный\n"
+            f"ID: {voice_info['id']}"
+        )
+        
+        return (
+            f"✅ Создан кастомный голос: {voice_id}",
+            gr.update(choices=choice_labels, value=new_voice_label),
+            info_text
+        )
+        
+    except Exception as e:
+        return f"❌ Ошибка создания голоса: {str(e)}", gr.update(), ""
+
+def on_auto_language_change(auto_language: bool):
+    """Обработчик изменения галочки автоопределения языка"""
+    return gr.update(visible=not auto_language)
+
+def map_emotions(selected_emotions, intensity):
+    emotion_map = {
+        "Весело": "positivity",
+        "Грустно": "sadness",
+        "Злобно": "anger",
+        "Удивленно": "surprise",
+        "Любопытно": "curiosity"
+    }
+    
+    intensity_map = {
+        "Очень слабая": "lowest",
+        "Слабая": "low",
+        "Средняя": "medium",
+        "Сильная": "high",
+        "Очень сильная": "highest"
+    }
+    
+    emotions = []
+    for emotion in selected_emotions:
+        if emotion == "Нейтрально":
+            continue
+        if emotion in emotion_map:
+            emotions.append({
+                "name": emotion_map[emotion],
+                "level": intensity_map[intensity]
+            })
+    return emotions
+
+def generate_speech(
+    text: str,
+    voice_label: str,
+    improve_text: bool,
+    auto_language: bool,
+    manual_language: str,
+    speed_type: str,
+    use_custom_speed: bool,
+    custom_speed: float,
+    emotions: List[str],
+    emotion_intensity: str
+):
+    """Генерация речи с учетом настроек языка"""
+    if not manager:
+        return None, "❌ Менеджер не инициализирован"
+    
+    if not text or not voice_label:
+        return None, "❌ Необходимо указать текст и голос"
+    
+    try:
+        # Извлекаем ID голоса из метки
+        voice_id = extract_voice_id_from_label(voice_label)
+        if not voice_id:
+            return None, "❌ Голос не найден"
+            
+        # Устанавливаем голос по ID
+        manager.set_voice(voice_id)
+        
+        # Если автоопределение выключено, устанавливаем язык вручную
+        if not auto_language:
+            manager.set_language(manual_language)
+        
+        # В функции generate_speech обновите установку скорости:
+        if use_custom_speed:
+            manager.speed = custom_speed
+        else:
+            manager.speed = map_speed(speed_type)
+        
+        # Установка эмоций
+        emotion_map = {
+            "Нейтрально": None,
+            "Весело": "positivity",
+            "Грустно": "sadness",
+            "Злобно": "anger",
+            "Удивленно": "surprise",
+            "Любопытно": "curiosity"
+        }
+        
+        intensity_map = {
+            "Слабая": "low",
+            "Средняя": "medium",
+            "Сильная": "high"
+        }
+        
+        if emotions and emotions != ["Нейтрально"]:
+            manager.set_emotions(map_emotions(emotions, emotion_intensity))
+        else:
+            manager.set_emotions()  # Сброс эмоций
+        
+        # Генерация имени файла
+        output_file = generate_output_filename(
+            manual_language if not auto_language else manager.current_language
+        )
+        
+        # Создаем директорию для выходных файлов, если её нет
+        os.makedirs("output", exist_ok=True)
+        
+        # Генерация речи
+        output_path = manager.speak(
+            text=text if not improve_text else improve_tts_text(text, manager.current_language),
+            output_file=output_file
+        )
+        
+        return output_path, "✅ Аудио сгенерировано успешно"
+        
+    except Exception as e:
+        return None, f"❌ Ошибка генерации: {str(e)}"
+
+# Создание интерфейса
+with gr.Blocks() as demo:
+    # API ключ
+    cartesia_api_key = gr.Textbox(
+        label="API ключ Cartesia",
+        value=DEFAULT_API_KEY,
+        type='password'
+    )
+    
+    with gr.Row():
+        # Левая колонка
+        with gr.Column():
+            cartesia_text = gr.TextArea(label="Текст")
+            
+            with gr.Accordion(label="Настройки", open=True):
+                # Фильтры
+                with gr.Accordion("Фильтры", open=True):
+                    cartesia_setting_filter_lang = gr.Dropdown(
+                        label="Язык",
+                        choices=LANGUAGE_CHOICES,
+                        value="all"
+                    )
+                    cartesia_setting_filter_type = gr.Dropdown(
+                        label="Тип",
+                        choices=ACCESS_TYPE_MAP,
+                        value="Все"
+                    )
+                
+                # Вкладки настроек
+                with gr.Tab("Стандарт"):
+                    cartesia_setting_voice_info = gr.Textbox(
+                        label="Информация о голосе",
+                        interactive=False
+                    )
+                    with gr.Row():
+                        initial_choices, initial_value = get_initial_voices()
+                        cartesia_setting_voice = gr.Dropdown(
+                            label="Голос",
+                            choices=initial_choices,
+                            value=initial_value
+                        )
+                    cartesia_setting_voice_update = gr.Button("Обновить")
+                    cartesia_setting_auto_language = gr.Checkbox(
+                         label="Автоматически определять язык из голоса",
+                         value=True
+                     )
+                    cartesia_setting_manual_language = gr.Dropdown(
+                         label="Язык озвучки",
+                         choices=["ru", "en", "es", "fr", "de", "pl", "it", "ja", "ko", "zh", "hi"],
+                         value="en",
+                         visible=False  # Изначально скрыт
+                     )
+                
+                with gr.Tab("Кастомный"):
+                    cartesia_setting_custom_name = gr.Textbox(label="Имя")
+                    cartesia_setting_custom_lang = gr.Dropdown(
+                        label="Язык",
+                        choices=LANGUAGE_CHOICES[1:]  # Исключаем "all"
+                    )
+                    cartesia_setting_custom_voice = gr.Audio(label="Файл голоса",type='filepath')
+                    cartesia_setting_custom_add = gr.Button("Добавить")
+                
+                # with gr.Tab("Микс"):
+                #     cartesia_setting_custom_mix = gr.Dropdown(
+                #         label="Выберите голоса",
+                #         multiselect=True,
+                #         choices=[]
+                #     )
+                #     cartesia_setting_custom_mix_update = gr.Button("Обновить")
+                #     for i in range(5):
+                #         setattr(
+                #             demo,
+                #             f'mix_voice_{i+1}',
+                #             gr.Slider(
+                #                 label=f"Голос {i+1}",
+                #                 value=0.5,
+                #                 minimum=0,
+                #                 maximum=1,
+                #                 step=0.01,
+                #                 visible=False
+                #             )
+                #         )
+            
+            # Контроль эмоций
+            with gr.Accordion(label="Контроль эмоций (Beta)", open=False):
+                cartesia_emotions = gr.Dropdown(
+                    label="Эмоции",
+                    multiselect=True,
+                    choices=EMOTION_CHOICES
+                )
+                cartesia_emotions_intensity = gr.Dropdown(
+                    label="Интенсивность",
+                    choices=EMOTION_INTENSITY,
+                    value="Средняя"
+                )
+            
+            # Настройки скорости
+            with gr.Accordion("Скорость", open=True):
+                cartesia_speed_speed = gr.Dropdown(
+                    label="Скорость речи",
+                    choices=SPEED_CHOICES,
+                    value="Нормально"
+                )
+                cartesia_speed_speed_allow_custom = gr.Checkbox(
+                    label="Использовать кастомное значение скорости"
+                )
+                cartesia_speed_speed_custom = gr.Slider(
+                    label="Скорость",
+                    value=0,
+                    minimum=-1,
+                    maximum=1,
+                    step=0.1,
+                    visible=False
+                )
+            
+            cartesia_setting_improve_text = gr.Checkbox(
+                label="Улучшить текст согласно рекомендациям",
+                value=True
+            )
+        
+        # Правая колонка
+        with gr.Column():
+            cartessia_status_bar = gr.Label(value="Статус")
+            cartesia_output_audio = gr.Audio(
+                label="Результат",
+                interactive=False
+            )
+            cartesia_output_button = gr.Button("Генерация")
+    
+    # События
+    cartesia_api_key.change(
+        initialize_manager,
+        inputs=[cartesia_api_key],
+        outputs=[cartessia_status_bar]
+    )
+    
+    cartesia_setting_filter_lang.change(
+        update_voice_list,
+        inputs=[
+            cartesia_setting_filter_lang,
+            cartesia_setting_filter_type,
+            cartesia_setting_voice  # Передаем текущий выбор
+        ],
+        outputs=[cartesia_setting_voice, cartessia_status_bar]
+    )
+
+    cartesia_setting_filter_type.change(
+        update_voice_list,
+        inputs=[
+            cartesia_setting_filter_lang,
+            cartesia_setting_filter_type,
+            cartesia_setting_voice  # Передаем текущий выбор
+        ],
+        outputs=[cartesia_setting_voice, cartessia_status_bar]
+    )
+    
+    cartesia_setting_voice.change(
+        update_voice_info,
+        inputs=[cartesia_setting_voice],
+        outputs=[cartesia_setting_voice_info]
+    )
+    
+    cartesia_setting_voice_update.click(
+        update_voice_list,
+        inputs=[cartesia_setting_filter_lang, cartesia_setting_filter_type],
+        outputs=[cartesia_setting_voice]
+    )
+    
+    cartesia_speed_speed_allow_custom.change(
+        lambda x: gr.update(visible=x),
+        inputs=[cartesia_speed_speed_allow_custom],
+        outputs=[cartesia_speed_speed_custom]
+    )
+    
+    cartesia_setting_custom_add.click(
+        create_custom_voice,
+        inputs=[
+            cartesia_setting_custom_name,
+            cartesia_setting_custom_lang,
+            cartesia_setting_custom_voice
+        ],
+        outputs=[
+            cartessia_status_bar,
+            cartesia_setting_voice,  # Обновляем dropdown
+            cartesia_setting_voice_info  # Обновляем информацию о голосе
+        ]
+    )
+    
+    # Обновляем привязки событий
+    cartesia_setting_auto_language.change(
+        on_auto_language_change,
+        inputs=[cartesia_setting_auto_language],
+        outputs=[cartesia_setting_manual_language]
+    )
+
+    cartesia_output_button.click(
+        generate_speech,
+        inputs=[
+            cartesia_text,
+            cartesia_setting_voice,
+            cartesia_setting_improve_text,
+            cartesia_setting_auto_language,
+            cartesia_setting_manual_language,
+            cartesia_speed_speed,
+            cartesia_speed_speed_allow_custom,
+            cartesia_speed_speed_custom,
+            cartesia_emotions,
+            cartesia_emotions_intensity
+        ],
+        outputs=[
+            cartesia_output_audio,
+            cartessia_status_bar
+        ]
+    )
+
+# Запуск приложения
+if __name__ == "__main__":
+    # Инициализация менеджера при запуске
+    initialize_manager(DEFAULT_API_KEY)
+    # Запуск интерфейса
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+cartesia
+tqdm
+loguru

sonic_api_wrapper.py

@@ -0,0 +1,446 @@
+import os
+import json
+from pathlib import Path
+from typing import List, Dict, Union, Optional
+from enum import Enum
+from cartesia import Cartesia
+from tqdm import tqdm
+from loguru import logger
+from datetime import datetime
+import re
+
+class VoiceAccessibility(Enum):
+    ALL = "all"
+    ONLY_PUBLIC = "only_public"
+    ONLY_PRIVATE = "only_private"
+    ONLY_CUSTOM = "only_custom"
+
+class CartesiaVoiceManager:
+    SPEED_OPTIONS = {
+        "slowest": -1.0,
+        "slow": -0.5,
+        "normal": 0.0,
+        "fast": 0.5,
+        "fastest": 1.0
+    }
+    EMOTION_NAMES = ["anger", "positivity", "surprise", "sadness", "curiosity"]
+    EMOTION_LEVELS = ["lowest", "low", "medium", "high", "highest"]
+
+    def __init__(self, api_key: str = None, base_dir: Path = None):
+        self.api_key = api_key or os.environ.get("CARTESIA_API_KEY")
+        if not self.api_key:
+            raise ValueError("API key is required. Please provide it as an argument or set CARTESIA_API_KEY environment variable.")
+        
+        self.client = Cartesia(api_key=self.api_key)
+        self.current_voice = None
+        self.current_model = None
+        self.current_language = None
+        self.current_mix = None
+        
+        # Настройка директорий
+        self.base_dir = base_dir or Path("voice2voice")
+        self.api_dir = self.base_dir / "api"
+        self.custom_dir = self.base_dir / "custom"
+        
+        # Создание необходимых директорий
+        self.api_dir.mkdir(parents=True, exist_ok=True)
+        self.custom_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Инициализация голосов
+        self.voices = {}
+        self.loaded_voices = set()
+        
+        # Настройки скорости и эмоций
+        self._speed = 0.0  # normal speed
+        self._emotions = {}
+        
+        logger.add("cartesia_voice_manager.log", rotation="10 MB")
+        logger.info("CartesiaVoiceManager initialized")
+
+    def load_voice(self, voice_id: str) -> Dict:
+        if voice_id in self.loaded_voices:
+            return self.voices[voice_id]
+            
+        voice_file = None
+        # Поиск файла голоса в api и custom директориях
+        api_file = self.api_dir / f"{voice_id}.json"
+        custom_file = self.custom_dir / f"{voice_id}.json"
+        
+        if api_file.exists():
+            voice_file = api_file
+        elif custom_file.exists():
+            voice_file = custom_file
+            
+        if voice_file:
+            with open(voice_file, "r") as f:
+                voice_data = json.load(f)
+                self.voices[voice_id] = voice_data
+                self.loaded_voices.add(voice_id)
+                logger.info(f"Loaded voice {voice_id} from {voice_file}")
+                return voice_data
+        else:
+            # Если голос не найден локально, пытаемся загрузить из API
+            try:
+                voice_data = self.client.voices.get(id=voice_id)
+                self._save_voice_to_api(voice_data)
+                self.voices[voice_id] = voice_data
+                self.loaded_voices.add(voice_id)
+                logger.info(f"Loaded voice {voice_id} from API")
+                return voice_data
+            except Exception as e:
+                logger.error(f"Failed to load voice {voice_id}: {e}")
+                raise ValueError(f"Voice with id {voice_id} not found")
+
+    def extract_voice_id_from_label(self, voice_label: str) -> Optional[str]:
+        """
+        Извлекает ID голоса из метки в dropdown
+        Например: "John (en) [Custom]" -> извлечет ID из словаря голосов
+        """
+        # Получаем все голоса и их метки
+        choices = self.get_voice_choices()
+        # Находим голос по метке и берем его ID
+        voice_data = next((c for c in choices if c["label"] == voice_label), None)
+        return voice_data["value"] if voice_data else None
+    
+    def get_voice_choices(self, language: str = None, accessibility: VoiceAccessibility = VoiceAccessibility.ALL) -> List[Dict]:
+        """
+        Возвращает список голосов для dropdown меню
+        """
+        voices = self.list_available_voices(
+            languages=[language] if language else None,
+            accessibility=accessibility
+        )
+
+        choices = []
+        for voice in voices:
+            # Сохраняем только ID в value
+            choices.append({
+                "label": f"{voice['name']} ({voice['language']}){' [Custom]' if voice.get('is_custom') else ''}",
+                "value": voice['id']  # Здесь только ID
+            })
+
+        return sorted(choices, key=lambda x: x['label'])
+
+    def get_voice_info(self, voice_id: str) -> Dict:
+        """
+        Возвращает информацию о голосе для отображения
+        """
+        voice = self.load_voice(voice_id)
+        return {
+            "name": voice['name'],
+            "language": voice['language'],
+            "is_custom": voice.get('is_custom', False),
+            "is_public": voice.get('is_public', True),
+            "id": voice['id']
+        }
+    
+    def _save_voice_to_api(self, voice_data: Dict):
+        voice_id = voice_data["id"]
+        file_path = self.api_dir / f"{voice_id}.json"
+        with open(file_path, "w") as f:
+            json.dump(voice_data, f, indent=2)
+        logger.info(f"Saved API voice {voice_id} to {file_path}")
+
+    def _save_voice_to_custom(self, voice_data: Dict):
+        voice_id = voice_data["id"]
+        file_path = self.custom_dir / f"{voice_id}.json"
+        with open(file_path, "w") as f:
+            json.dump(voice_data, f, indent=2)
+        logger.info(f"Saved custom voice {voice_id} to {file_path}")
+
+    def update_voices_from_api(self):
+        logger.info("Updating voices from API")
+        api_voices = self.client.voices.list()
+        for voice in tqdm(api_voices, desc="Updating voices"):
+            voice_id = voice["id"]
+            full_voice_data = self.client.voices.get(id=voice_id)
+            self._save_voice_to_api(full_voice_data)
+            if voice_id in self.loaded_voices:
+                self.voices[voice_id] = full_voice_data
+        logger.info(f"Updated {len(api_voices)} voices from API")
+
+    def list_available_voices(self, languages: List[str] = None, accessibility: VoiceAccessibility = VoiceAccessibility.ALL) -> List[Dict]:
+        filtered_voices = []
+
+        # Получаем только метаданные из API (без эмбеддингов)
+        if accessibility in [VoiceAccessibility.ALL, VoiceAccessibility.ONLY_PUBLIC]:
+            try:
+                api_voices = self.client.voices.list()
+                # Сохраняем только метаданные
+                for voice in api_voices:
+                    metadata = {
+                        'id': voice['id'],
+                        'name': voice['name'],
+                        'language': voice['language'],
+                        'is_public': True
+                    }
+                    if languages is None or metadata['language'] in languages:
+                        filtered_voices.append(metadata)
+            except Exception as e:
+                logger.error(f"Failed to fetch voices from API: {e}")
+
+        # Добавляем кастомные голоса если нужно
+        if accessibility in [VoiceAccessibility.ALL, VoiceAccessibility.ONLY_PRIVATE, VoiceAccessibility.ONLY_CUSTOM]:
+            for file in self.custom_dir.glob("*.json"):
+                with open(file, "r") as f:
+                    voice_data = json.load(f)
+                    if languages is None or voice_data['language'] in languages:
+                        filtered_voices.append({
+                            'id': voice_data['id'],
+                            'name': voice_data['name'],
+                            'language': voice_data['language'],
+                            'is_public': False,
+                            'is_custom': True
+                        })
+
+        logger.info(f"Found {len(filtered_voices)} voices matching criteria")
+        return filtered_voices
+
+    def set_voice(self, voice_id: str):
+        # Проверяем наличие локального файла с эмбеддингом
+        voice_file = None
+        api_file = self.api_dir / f"{voice_id}.json"
+        custom_file = self.custom_dir / f"{voice_id}.json"
+
+        if api_file.exists():
+            voice_file = api_file
+        elif custom_file.exists():
+            voice_file = custom_file
+
+        if voice_file:
+            # Используем локальные данные
+            with open(voice_file, "r") as f:
+                self.current_voice = json.load(f)
+        else:
+            # Получаем полные данные с эмбеддингом из API
+            try:
+                voice_data = self.client.voices.get(id=voice_id)
+                # Сохраняем для будущего использования
+                self._save_voice_to_api(voice_data)
+                self.current_voice = voice_data
+            except Exception as e:
+                logger.error(f"Failed to get voice {voice_id}: {e}")
+                raise ValueError(f"Voice with id {voice_id} not found")
+
+        self.set_language(self.current_voice['language'])
+        logger.info(f"Set current voice to {voice_id}")
+
+    def set_model(self, language: str):
+        if language.lower() in ['en', 'eng', 'english']:
+            self.current_model = "sonic-english"
+        else:
+            self.current_model = "sonic-multilingual"
+        self.current_language = language
+        logger.info(f"Set model to {self.current_model} for language {language}")
+
+    def set_language(self, language: str):
+        self.current_language = language
+        self.set_model(language)
+        logger.info(f"Set language to {language}")
+
+    @property
+    def speed(self):
+        return self._speed
+
+    @speed.setter
+    def speed(self, value):
+        if isinstance(value, str):
+            if value not in self.SPEED_OPTIONS:
+                raise ValueError(f"Invalid speed value. Use one of: {list(self.SPEED_OPTIONS.keys())}")
+            self._speed = self.SPEED_OPTIONS[value]
+        elif isinstance(value, (int, float)):
+            if not -1 <= value <= 1:
+                raise ValueError("Speed value must be between -1 and 1")
+            self._speed = value
+        else:
+            raise ValueError("Speed must be a string from SPEED_OPTIONS or a number between -1 and 1")
+        logger.info(f"Set speed to {self._speed}")
+
+    def set_emotions(self, emotions: List[Dict[str, str]] = None):
+        if emotions is None:
+            self._emotions = {}
+            logger.info("Cleared all emotions")
+            return
+            
+        self._emotions = {}
+        for emotion in emotions:
+            name = emotion.get("name")
+            level = emotion.get("level")
+            
+            if name not in self.EMOTION_NAMES:
+                raise ValueError(f"Invalid emotion name. Choose from: {self.EMOTION_NAMES}")
+            if level not in self.EMOTION_LEVELS:
+                raise ValueError(f"Invalid emotion level. Choose from: {self.EMOTION_LEVELS}")
+                
+            self._emotions[name] = level
+        
+        logger.info(f"Set emotions: {self._emotions}")
+
+    def _get_voice_controls(self):
+        controls = {"speed": self._speed}
+        
+        if self._emotions:
+            controls["emotion"] = [f"{name}:{level}" for name, level in self._emotions.items()]
+            
+        return controls
+
+    def speak(self, text: str, output_file: str = None):
+        if not self.current_model or not (self.current_voice or self.current_mix):
+            raise ValueError("Please set a model and a voice or voice mix before speaking.")
+
+        voice_embedding = self.current_voice['embedding'] if self.current_voice else self.current_mix
+
+        improved_text = improve_tts_text(text, self.current_language)
+
+        output_format = {
+            "container": "wav",
+            "encoding": "pcm_f32le",
+            "sample_rate": 44100,
+        }
+
+        voice_controls = self._get_voice_controls()
+        
+        logger.info(f"Generating audio for text: {text[:50]}... with voice controls: {voice_controls}")
+        if self.current_language == 'en':
+            audio_data = self.client.tts.bytes(
+                model_id='sonic-english',
+                transcript=improved_text,
+                voice_embedding=voice_embedding,
+                duration=None,
+                output_format=output_format,
+                # language=self.current_language,
+                _experimental_voice_controls=voice_controls
+            )
+        else:
+            audio_data = self.client.tts.bytes(
+            model_id='sonic-multilingual',
+            transcript=improved_text,
+            voice_embedding=voice_embedding,
+            duration=None,
+            output_format=output_format,
+            language=self.current_language,
+            _experimental_voice_controls=voice_controls)
+
+        if output_file is None:
+            output_file = f"output_{self.current_language}.wav"
+
+        with open(output_file, "wb") as f:
+            f.write(audio_data)
+        logger.info(f"Audio saved to {output_file}")
+        print(f"Audio generated and saved to {output_file}")
+
+        return output_file
+
+    def _get_embedding(self, source: Union[str, Dict]) -> Dict:
+        """
+        Получает эмбеддинг из различных источников: ID, путь к файлу или существующий эмбеддинг
+        """
+        if isinstance(source, dict) and 'embedding' in source:
+            return source['embedding']
+        elif isinstance(source, str):
+            if os.path.isfile(source):
+                # Если это путь к файлу, создаем новый эмбеддинг
+                return self.client.voices.clone(filepath=source)
+            else:
+                # Если это ID, загружаем голос и возвращаем его эмбеддинг
+                voice = self.load_voice(source)
+                return voice['embedding']
+        else:
+            raise ValueError(f"Invalid source type: {type(source)}")
+
+    def create_mixed_embedding(self, components: List[Dict[str, Union[str, float, Dict]]]) -> Dict:
+        """
+        Создает смешанный эмбеддинг из нескольких компонентов
+        
+        :param components: Список словарей, каждый содержит 'id' (или 'path', или эмбеддинг) и 'weight'
+        :return: Новый смешанный эмбеддинг
+        """
+        mix_components = []
+        for component in components:
+            embedding = self._get_embedding(component.get('id') or component.get('path') or component)
+            mix_components.append({
+                "embedding": embedding,
+                "weight": component['weight']
+            })
+        
+        return self.client.voices.mix(mix_components)
+
+    def create_custom_voice(self, name: str, source: Union[str, List[Dict]], description: str = "", language: str = "en"):
+        """
+        Создает кастомный голос из файла или смеси голосов
+        
+        :param name: Имя нового голоса
+        :param source: Путь к файлу или список компонентов для смешивания
+        :param description: Описание голоса
+        :param language: Язык голоса
+        :return: ID нового голоса
+        """
+        logger.info(f"Creating custom voice: {name}")
+        
+        if isinstance(source, str):
+            # Если источник - строка, считаем это путем к файлу
+            embedding = self.client.voices.clone(filepath=source)
+        elif isinstance(source, list):
+            # Если источник - список, создаем смешанный эмбеддинг
+            embedding = self.create_mixed_embedding(source)
+        else:
+            raise ValueError("Invalid source type. Expected file path or list of components.")
+
+        voice_id = f"custom_{len([f for f in self.custom_dir.glob('*.json')])}"
+        
+        voice_data = {
+            "id": voice_id,
+            "name": name,
+            "description": description,
+            "embedding": embedding,
+            "language": language,
+            "is_public": False,
+            "is_custom": True
+        }
+        
+        self._save_voice_to_custom(voice_data)
+        self.voices[voice_id] = voice_data
+        self.loaded_voices.add(voice_id)
+        
+        logger.info(f"Created custom voice with id: {voice_id}")
+        return voice_id
+
+    def get_voice_id_by_name(self, name: str) -> List[str]:
+        matching_voices = []
+        
+        # Проверяем оба каталога
+        for directory in [self.api_dir, self.custom_dir]:
+            for file in directory.glob("*.json"):
+                with open(file, "r") as f:
+                    voice_data = json.load(f)
+                    if voice_data['name'] == name:
+                        matching_voices.append(voice_data['id'])
+        
+        if not matching_voices:
+            logger.warning(f"No voices found with name: {name}")
+        else:
+            logger.info(f"Found {len(matching_voices)} voice(s) with name: {name}")
+        
+        return matching_voices
+
+def improve_tts_text(text: str, language: str = 'en') -> str:
+    text = re.sub(r'(\w+)(\s*)$', r'\1.\2', text)
+    text = re.sub(r'(\w+)(\s*\n)', r'\1.\2', text)
+
+    def format_date(match):
+        date = datetime.strptime(match.group(), '%Y-%m-%d')
+        return date.strftime('%m/%d/%Y')
+    
+    text = re.sub(r'\d{4}-\d{2}-\d{2}', format_date, text)
+    text = text.replace(' - ', ' - - ')
+    text = re.sub(r'\?(?![\s\n])', '??', text)
+    text = text.replace('"', '')
+    text = text.replace("'", '')
+    text = re.sub(r'(https?://\S+|\S+@\S+\.\S+)\?', r'\1 ?', text)
+
+    if language.lower() in ['ru', 'rus', 'russian']:
+        text = text.replace('г.', 'году')
+    elif language.lower() in ['fr', 'fra', 'french']:
+        text = text.replace('M.', 'Monsieur')
+
+    return text