Upload folder using huggingface_hub

.gitignore

@@ -4,5 +4,6 @@ __pycache__/
 *.pyc
 .env
 assets/audios/
-logs/male-1/
+logs/
 rvc/models/
+voices/

.vscode/launch.json

@@ -4,6 +4,15 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "upload-voices",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "tts_service/cli.py",
+            "args": ["service", "upload-voices", "voices"],
+            "console": "integratedTerminal",
+            "justMyCode": false
+        },
         {
             "name": "App",
             "type": "debugpy",

.vscode/settings.json

@@ -1,12 +1,12 @@
 {
     "editor.codeActionsOnSave": {
-        "source.organizeImports": "never",
-        "source.unusedImports": "never"
+        "source.organizeImports": "always",
+        "source.unusedImports": "always"
     },
     "editor.detectIndentation": false,
     "editor.formatOnPaste": true,
-    "editor.formatOnSave": false,
-    "editor.formatOnSaveMode": "modifications",
+    "editor.formatOnSave": true,
+    "editor.formatOnSaveMode": "file",
     "editor.formatOnType": true,
     "editor.renderWhitespace": "all",
     "editor.rulers": [132],
@@ -32,9 +32,9 @@
         "prettier.tabWidth": 4,
         "editor.defaultFormatter": "esbenp.prettier-vscode"
     },
-    // "[python]": {
-    //     "editor.defaultFormatter": "charliermarsh.ruff"
-    // },
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff"
+    },
     "[yaml]": {
         "editor.defaultFormatter": "kiliantyler.kubernetes-yaml-formatter-x"
     }

assets/i18n/i18n.py

@@ -45,8 +45,5 @@ class I18nAuto:
         language_files = [path.stem for path in Path(self.LANGUAGE_PATH).glob("*.json")]
         return language_files
 
-    def _language_exists(self, language):
-        return (Path(self.LANGUAGE_PATH) / f"{language}.json").exists()
-
     def __call__(self, key):
         return self.language_map.get(key, key)

assets/themes/loadThemes.py

@@ -21,63 +21,6 @@ def read_json_file(filename):
         return json.load(json_file)
 
 
-def get_class(filename):
-    """Retrieve the name of the first class found in the specified Python file."""
-    with open(filename, "r", encoding="utf8") as file:
-        for line in file:
-            if "class " in line:
-                class_name = line.split("class ")[1].split(":")[0].split("(")[0].strip()
-                return class_name
-    return None
-
-
-def get_theme_list():
-    """Compile a list of available themes from Python files and a JSON file."""
-    themes_from_files = [
-        os.path.splitext(name)[0]
-        for root, _, files in os.walk(folder)
-        for name in files
-        if name.endswith(".py") and root == folder
-    ]
-
-    json_file_path = os.path.join(folder, "theme_list.json")
-    themes_from_url = []
-
-    try:
-        themes_from_url = [item["id"] for item in read_json_file(json_file_path)]
-    except FileNotFoundError:
-        print("theme_list.json not found, proceeding with available files only.")
-
-    return list(set(themes_from_files + themes_from_url))
-
-
-def select_theme(name):
-    """Select a theme by its name, updating the configuration file accordingly."""
-    selected_file = f"{name}.py"
-    full_path = os.path.join(folder, selected_file)
-
-    config_data = read_json_file(config_file)
-
-    if not os.path.exists(full_path):
-        config_data["theme"]["file"] = None
-        config_data["theme"]["class"] = name
-    else:
-        class_found = get_class(full_path)
-        if class_found:
-            config_data["theme"]["file"] = selected_file
-            config_data["theme"]["class"] = class_found
-        else:
-            print(f"Theme class not found in {selected_file}.")
-            return
-
-    with open(config_file, "w", encoding="utf8") as json_file:
-        json.dump(config_data, json_file, indent=2)
-
-    message = f"Theme {name} successfully selected. Restart the application."
-    print(message)
-    gr.Info(message)
-
-
 def load_theme():
     """Load the selected theme based on the configuration file."""
     try:
@@ -99,17 +42,3 @@ def load_theme():
     except Exception as error:
         print(f"An error occurred while loading the theme: {error}")
         return None
-
-
-def read_current_theme():
-    """Read the current theme class from the configuration file."""
-    try:
-        config_data = read_json_file(config_file)
-        selected_file = config_data["theme"]["file"]
-        class_name = config_data["theme"]["class"]
-
-        return class_name if class_name else "ParityError/Interstellar"
-
-    except Exception as error:
-        print(f"An error occurred loading the theme: {error}")
-        return "ParityError/Interstellar"

core/__init__.py

@@ -1,41 +1,16 @@
 import os
-import sys
-import json
-import argparse
 import subprocess
+import sys
 from functools import lru_cache
-from distutils.util import strtobool
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
 
-current_script_directory = os.path.dirname(os.path.realpath(__file__))
-logs_path = os.path.join(current_script_directory, "logs")
-
-from rvc.lib.tools.prerequisites_download import prequisites_download_pipeline
-from rvc.train.process.model_blender import model_blender
-from rvc.train.process.model_information import model_information
-from rvc.train.process.extract_small_model import extract_small_model
-from rvc.lib.tools.analyzer import analyze_audio
-from rvc.lib.tools.launch_tensorboard import launch_tensorboard_pipeline
 from rvc.lib.tools.model_download import model_download_pipeline
+from rvc.lib.tools.prerequisites_download import prequisites_download_pipeline
+from tts_service.utils import cache_path
+from tts_service.voices import voice_manager
 
 python = sys.executable
 
 
-# Get TTS Voices -> https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list?trustedclienttoken=6A5AA1D4EAFF4E9FB37E23D68491D6F4
-@lru_cache(maxsize=1)  # Cache only one result since the file is static
-def load_voices_data():
-    with open(
-        os.path.join("rvc", "lib", "tools", "tts_voices.json"), "r", encoding="utf-8"
-    ) as file:
-        return json.load(file)
-
-
-voices_data = load_voices_data()
-locales = list({voice["Locale"] for voice in voices_data})
-
-
 @lru_cache(maxsize=None)
 def import_voice_converter():
     from rvc.infer.infer import VoiceConverter
@@ -43,587 +18,85 @@ def import_voice_converter():
     return VoiceConverter()
 
 
-@lru_cache(maxsize=1)
-def get_config():
-    from rvc.configs.config import Config
-
-    return Config()
-
-
-# Infer
-def run_infer_script(
-    pitch: int,
-    filter_radius: int,
-    index_rate: float,
-    volume_envelope: int,
-    protect: float,
-    hop_length: int,
-    f0_method: str,
-    input_path: str,
-    output_path: str,
-    pth_path: str,
-    index_path: str,
-    split_audio: bool,
-    f0_autotune: bool,
-    f0_autotune_strength: float,
-    clean_audio: bool,
-    clean_strength: float,
-    export_format: str,
-    upscale_audio: bool,
-    f0_file: str,
-    embedder_model: str,
-    embedder_model_custom: str | None = None,
-    formant_shifting: bool = False,
-    formant_qfrency: float = 1.0,
-    formant_timbre: float = 1.0,
-    post_process: bool = False,
-    reverb: bool = False,
-    pitch_shift: bool = False,
-    limiter: bool = False,
-    gain: bool = False,
-    distortion: bool = False,
-    chorus: bool = False,
-    bitcrush: bool = False,
-    clipping: bool = False,
-    compressor: bool = False,
-    delay: bool = False,
-    reverb_room_size: float = 0.5,
-    reverb_damping: float = 0.5,
-    reverb_wet_gain: float = 0.5,
-    reverb_dry_gain: float = 0.5,
-    reverb_width: float = 0.5,
-    reverb_freeze_mode: float = 0.5,
-    pitch_shift_semitones: float = 0.0,
-    limiter_threshold: float = -6,
-    limiter_release_time: float = 0.01,
-    gain_db: float = 0.0,
-    distortion_gain: float = 25,
-    chorus_rate: float = 1.0,
-    chorus_depth: float = 0.25,
-    chorus_center_delay: float = 7,
-    chorus_feedback: float = 0.0,
-    chorus_mix: float = 0.5,
-    bitcrush_bit_depth: int = 8,
-    clipping_threshold: float = -6,
-    compressor_threshold: float = 0,
-    compressor_ratio: float = 1,
-    compressor_attack: float = 1.0,
-    compressor_release: float = 100,
-    delay_seconds: float = 0.5,
-    delay_feedback: float = 0.0,
-    delay_mix: float = 0.5,
-    sid: int = 0,
-):
-    kwargs = {
-        "audio_input_path": input_path,
-        "audio_output_path": output_path,
-        "model_path": pth_path,
-        "index_path": index_path,
-        "pitch": pitch,
-        "filter_radius": filter_radius,
-        "index_rate": index_rate,
-        "volume_envelope": volume_envelope,
-        "protect": protect,
-        "hop_length": hop_length,
-        "f0_method": f0_method,
-        "pth_path": pth_path,
-        "index_path": index_path,
-        "split_audio": split_audio,
-        "f0_autotune": f0_autotune,
-        "f0_autotune_strength": f0_autotune_strength,
-        "clean_audio": clean_audio,
-        "clean_strength": clean_strength,
-        "export_format": export_format,
-        "upscale_audio": upscale_audio,
-        "f0_file": f0_file,
-        "embedder_model": embedder_model,
-        "embedder_model_custom": embedder_model_custom,
-        "post_process": post_process,
-        "formant_shifting": formant_shifting,
-        "formant_qfrency": formant_qfrency,
-        "formant_timbre": formant_timbre,
-        "reverb": reverb,
-        "pitch_shift": pitch_shift,
-        "limiter": limiter,
-        "gain": gain,
-        "distortion": distortion,
-        "chorus": chorus,
-        "bitcrush": bitcrush,
-        "clipping": clipping,
-        "compressor": compressor,
-        "delay": delay,
-        "reverb_room_size": reverb_room_size,
-        "reverb_damping": reverb_damping,
-        "reverb_wet_level": reverb_wet_gain,
-        "reverb_dry_level": reverb_dry_gain,
-        "reverb_width": reverb_width,
-        "reverb_freeze_mode": reverb_freeze_mode,
-        "pitch_shift_semitones": pitch_shift_semitones,
-        "limiter_threshold": limiter_threshold,
-        "limiter_release": limiter_release_time,
-        "gain_db": gain_db,
-        "distortion_gain": distortion_gain,
-        "chorus_rate": chorus_rate,
-        "chorus_depth": chorus_depth,
-        "chorus_delay": chorus_center_delay,
-        "chorus_feedback": chorus_feedback,
-        "chorus_mix": chorus_mix,
-        "bitcrush_bit_depth": bitcrush_bit_depth,
-        "clipping_threshold": clipping_threshold,
-        "compressor_threshold": compressor_threshold,
-        "compressor_ratio": compressor_ratio,
-        "compressor_attack": compressor_attack,
-        "compressor_release": compressor_release,
-        "delay_seconds": delay_seconds,
-        "delay_feedback": delay_feedback,
-        "delay_mix": delay_mix,
-        "sid": sid,
-    }
-    infer_pipeline = import_voice_converter()
-    infer_pipeline.convert_audio(
-        **kwargs,
-    )
-    return f"File {input_path} inferred successfully.", output_path.replace(
-        ".wav", f".{export_format.lower()}"
-    )
-
-
-# Batch infer
-def run_batch_infer_script(
-    pitch: int,
-    filter_radius: int,
-    index_rate: float,
-    volume_envelope: int,
-    protect: float,
-    hop_length: int,
-    f0_method: str,
-    input_folder: str,
-    output_folder: str,
-    pth_path: str,
-    index_path: str,
-    split_audio: bool,
-    f0_autotune: bool,
-    f0_autotune_strength: float,
-    clean_audio: bool,
-    clean_strength: float,
-    export_format: str,
-    upscale_audio: bool,
-    f0_file: str,
-    embedder_model: str,
-    embedder_model_custom: str | None = None,
-    formant_shifting: bool = False,
-    formant_qfrency: float = 1.0,
-    formant_timbre: float = 1.0,
-    post_process: bool = False,
-    reverb: bool = False,
-    pitch_shift: bool = False,
-    limiter: bool = False,
-    gain: bool = False,
-    distortion: bool = False,
-    chorus: bool = False,
-    bitcrush: bool = False,
-    clipping: bool = False,
-    compressor: bool = False,
-    delay: bool = False,
-    reverb_room_size: float = 0.5,
-    reverb_damping: float = 0.5,
-    reverb_wet_gain: float = 0.5,
-    reverb_dry_gain: float = 0.5,
-    reverb_width: float = 0.5,
-    reverb_freeze_mode: float = 0.5,
-    pitch_shift_semitones: float = 0.0,
-    limiter_threshold: float = -6,
-    limiter_release_time: float = 0.01,
-    gain_db: float = 0.0,
-    distortion_gain: float = 25,
-    chorus_rate: float = 1.0,
-    chorus_depth: float = 0.25,
-    chorus_center_delay: float = 7,
-    chorus_feedback: float = 0.0,
-    chorus_mix: float = 0.5,
-    bitcrush_bit_depth: int = 8,
-    clipping_threshold: float = -6,
-    compressor_threshold: float = 0,
-    compressor_ratio: float = 1,
-    compressor_attack: float = 1.0,
-    compressor_release: float = 100,
-    delay_seconds: float = 0.5,
-    delay_feedback: float = 0.0,
-    delay_mix: float = 0.5,
-    sid: int = 0,
-):
-    kwargs = {
-        "audio_input_paths": input_folder,
-        "audio_output_path": output_folder,
-        "model_path": pth_path,
-        "index_path": index_path,
-        "pitch": pitch,
-        "filter_radius": filter_radius,
-        "index_rate": index_rate,
-        "volume_envelope": volume_envelope,
-        "protect": protect,
-        "hop_length": hop_length,
-        "f0_method": f0_method,
-        "pth_path": pth_path,
-        "index_path": index_path,
-        "split_audio": split_audio,
-        "f0_autotune": f0_autotune,
-        "f0_autotune_strength": f0_autotune_strength,
-        "clean_audio": clean_audio,
-        "clean_strength": clean_strength,
-        "export_format": export_format,
-        "upscale_audio": upscale_audio,
-        "f0_file": f0_file,
-        "embedder_model": embedder_model,
-        "embedder_model_custom": embedder_model_custom,
-        "post_process": post_process,
-        "formant_shifting": formant_shifting,
-        "formant_qfrency": formant_qfrency,
-        "formant_timbre": formant_timbre,
-        "reverb": reverb,
-        "pitch_shift": pitch_shift,
-        "limiter": limiter,
-        "gain": gain,
-        "distortion": distortion,
-        "chorus": chorus,
-        "bitcrush": bitcrush,
-        "clipping": clipping,
-        "compressor": compressor,
-        "delay": delay,
-        "reverb_room_size": reverb_room_size,
-        "reverb_damping": reverb_damping,
-        "reverb_wet_level": reverb_wet_gain,
-        "reverb_dry_level": reverb_dry_gain,
-        "reverb_width": reverb_width,
-        "reverb_freeze_mode": reverb_freeze_mode,
-        "pitch_shift_semitones": pitch_shift_semitones,
-        "limiter_threshold": limiter_threshold,
-        "limiter_release": limiter_release_time,
-        "gain_db": gain_db,
-        "distortion_gain": distortion_gain,
-        "chorus_rate": chorus_rate,
-        "chorus_depth": chorus_depth,
-        "chorus_delay": chorus_center_delay,
-        "chorus_feedback": chorus_feedback,
-        "chorus_mix": chorus_mix,
-        "bitcrush_bit_depth": bitcrush_bit_depth,
-        "clipping_threshold": clipping_threshold,
-        "compressor_threshold": compressor_threshold,
-        "compressor_ratio": compressor_ratio,
-        "compressor_attack": compressor_attack,
-        "compressor_release": compressor_release,
-        "delay_seconds": delay_seconds,
-        "delay_feedback": delay_feedback,
-        "delay_mix": delay_mix,
-        "sid": sid,
-    }
-    infer_pipeline = import_voice_converter()
-    infer_pipeline.convert_audio_batch(
-        **kwargs,
-    )
-
-    return f"Files from {input_folder} inferred successfully."
-
-
 # TTS
 def run_tts_script(
-    tts_file: str,
     tts_text: str,
-    tts_voice: str,
+    voice_name: str,
     tts_rate: int,
-    pitch: int,
-    filter_radius: int,
-    index_rate: float,
-    volume_envelope: int,
-    protect: float,
-    hop_length: int,
-    f0_method: str,
-    output_tts_path: str,
-    output_rvc_path: str,
-    pth_path: str,
-    index_path: str,
-    split_audio: bool,
-    f0_autotune: bool,
-    f0_autotune_strength: float,
-    clean_audio: bool,
-    clean_strength: float,
-    export_format: str,
-    upscale_audio: bool,
-    f0_file: str,
-    embedder_model: str,
-    embedder_model_custom: str | None = None,
-    sid: int = 0,
-):
-
+) -> tuple[str, str]:
     tts_script_path = os.path.join("rvc", "lib", "tools", "tts.py")
 
-    if os.path.exists(output_tts_path):
-        os.remove(output_tts_path)
-    dirname = os.path.dirname(output_tts_path)
-    if not os.path.exists(dirname):
-        os.makedirs(dirname)
-
-    command_tts = [
-        *map(
-            str,
-            [
-                python,
-                tts_script_path,
-                tts_file,
-                tts_text,
-                tts_voice,
-                tts_rate,
-                output_tts_path,
-            ],
-        ),
-    ]
-    subprocess.run(command_tts)
-    infer_pipeline = import_voice_converter()
-    infer_pipeline.convert_audio(
-        pitch=pitch,
-        filter_radius=filter_radius,
-        index_rate=index_rate,
-        volume_envelope=volume_envelope,
-        protect=protect,
-        hop_length=hop_length,
-        f0_method=f0_method,
-        audio_input_path=output_tts_path,
-        audio_output_path=output_rvc_path,
-        model_path=pth_path,
-        index_path=index_path,
-        split_audio=split_audio,
-        f0_autotune=f0_autotune,
-        f0_autotune_strength=f0_autotune_strength,
-        clean_audio=clean_audio,
-        clean_strength=clean_strength,
-        export_format=export_format,
-        upscale_audio=upscale_audio,
-        f0_file=f0_file,
-        embedder_model=embedder_model,
-        embedder_model_custom=embedder_model_custom,
-        sid=sid,
-        formant_shifting=None,
-        formant_qfrency=None,
-        formant_timbre=None,
-        post_process=None,
-        reverb=None,
-        pitch_shift=None,
-        limiter=None,
-        gain=None,
-        distortion=None,
-        chorus=None,
-        bitcrush=None,
-        clipping=None,
-        compressor=None,
-        delay=None,
-        sliders=None,
-    )
-
-    return f"Text {tts_text} synthesized successfully.", output_rvc_path.replace(
-        ".wav", f".{export_format.lower()}"
-    )
-
-
-# Preprocess
-def run_preprocess_script(
-    model_name: str,
-    dataset_path: str,
-    sample_rate: int,
-    cpu_cores: int,
-    cut_preprocess: bool,
-    process_effects: bool,
-    noise_reduction: bool,
-    clean_strength: float,
-):
-    config = get_config()
-    per = 3.0 if config.is_half else 3.7
-    preprocess_script_path = os.path.join("rvc", "train", "preprocess", "preprocess.py")
-    command = [
-        python,
-        preprocess_script_path,
-        *map(
-            str,
-            [
-                os.path.join(logs_path, model_name),
-                dataset_path,
-                sample_rate,
-                per,
-                cpu_cores,
-                cut_preprocess,
-                process_effects,
-                noise_reduction,
-                clean_strength,
-            ],
-        ),
-    ]
-    subprocess.run(command)
-    return f"Model {model_name} preprocessed successfully."
-
-
-# Extract
-def run_extract_script(
-    model_name: str,
-    rvc_version: str,
-    f0_method: str,
-    hop_length: int,
-    cpu_cores: int,
-    gpu: int,
-    sample_rate: int,
-    embedder_model: str,
-    embedder_model_custom: str | None = None,
-):
-
-    model_path = os.path.join(logs_path, model_name)
-    extract = os.path.join("rvc", "train", "extract", "extract.py")
-
-    command_1 = [
-        python,
-        extract,
-        *map(
-            str,
-            [
-                model_path,
-                f0_method,
-                hop_length,
-                cpu_cores,
-                gpu,
-                rvc_version,
-                sample_rate,
-                embedder_model,
-                embedder_model_custom,
-            ],
-        ),
-    ]
-
-    subprocess.run(command_1)
-
-    return f"Model {model_name} extracted successfully."
-
-
-# Train
-def run_train_script(
-    model_name: str,
-    rvc_version: str,
-    save_every_epoch: int,
-    save_only_latest: bool,
-    save_every_weights: bool,
-    total_epoch: int,
-    sample_rate: int,
-    batch_size: int,
-    gpu: int,
-    pitch_guidance: bool,
-    overtraining_detector: bool,
-    overtraining_threshold: int,
-    pretrained: bool,
-    cleanup: bool,
-    index_algorithm: str = "Auto",
-    cache_data_in_gpu: bool = False,
-    custom_pretrained: bool = False,
-    g_pretrained_path: str | None = None,
-    d_pretrained_path: str | None = None,
-):
-
-    if pretrained == True:
-        from rvc.lib.tools.pretrained_selector import pretrained_selector
-
-        if custom_pretrained == False:
-            pg, pd = pretrained_selector(bool(pitch_guidance))[str(rvc_version)][
-                int(sample_rate)
-            ]
-        else:
-            if g_pretrained_path is None or d_pretrained_path is None:
-                raise ValueError(
-                    "Please provide the path to the pretrained G and D models."
-                )
-            pg, pd = g_pretrained_path, d_pretrained_path
-    else:
-        pg, pd = "", ""
-
-    train_script_path = os.path.join("rvc", "train", "train.py")
-    command = [
-        python,
-        train_script_path,
-        *map(
-            str,
-            [
-                model_name,
-                save_every_epoch,
-                total_epoch,
-                pg,
-                pd,
-                rvc_version,
-                gpu,
-                batch_size,
-                sample_rate,
-                pitch_guidance,
-                save_only_latest,
-                save_every_weights,
-                cache_data_in_gpu,
-                overtraining_detector,
-                overtraining_threshold,
-                cleanup,
-            ],
-        ),
-    ]
-    subprocess.run(command)
-    run_index_script(model_name, rvc_version, index_algorithm)
-    return f"Model {model_name} trained successfully."
-
-
-# Index
-def run_index_script(model_name: str, rvc_version: str, index_algorithm: str):
-    index_script_path = os.path.join("rvc", "train", "process", "extract_index.py")
-    command = [
-        python,
-        index_script_path,
-        os.path.join(logs_path, model_name),
-        rvc_version,
-        index_algorithm,
-    ]
-
-    subprocess.run(command)
-    return f"Index file for {model_name} generated successfully."
-
-
-# Model extract
-def run_model_extract_script(
-    pth_path: str,
-    model_name: str,
-    sample_rate: int,
-    pitch_guidance: bool,
-    rvc_version: str,
-    epoch: int,
-    step: int,
-):
-    extract_small_model(
-        pth_path, model_name, sample_rate, pitch_guidance, rvc_version, epoch, step
-    )
-    return f"Model {model_name} extracted successfully."
-
-
-# Model information
-def run_model_information_script(pth_path: str):
-    print(model_information(pth_path))
-    return model_information(pth_path)
-
-
-# Model blender
-def run_model_blender_script(
-    model_name: str, pth_path_1: str, pth_path_2: str, ratio: float
-):
-    message, model_blended = model_blender(model_name, pth_path_1, pth_path_2, ratio)
-    return message, model_blended
-
-
-# Tensorboard
-def run_tensorboard_script():
-    launch_tensorboard_pipeline()
+    voice = voice_manager.voices[voice_name]
+    format = "wav"
+
+    output_tts_path = cache_path(voice.tts, tts_text, extension=format)
+    if not os.path.exists(output_tts_path):
+        command_tts = [
+            *map(
+                str,
+                [
+                    python,
+                    tts_script_path,
+                    "",  # tts_file
+                    tts_text,
+                    voice.tts,
+                    tts_rate,
+                    output_tts_path,
+                ],
+            ),
+        ]
+        subprocess.run(command_tts)
+
+    output_rvc_path = cache_path(voice.tts, voice.name, tts_text, extension=format)
+    if not os.path.exists(output_rvc_path):
+        infer_pipeline = import_voice_converter()
+        infer_pipeline.convert_audio(
+            pitch=voice.pitch,
+            filter_radius=voice.filter_radius,
+            index_rate=voice.index_rate,
+            volume_envelope=voice.rms_mix_rate,
+            protect=voice.protect,
+            hop_length=voice.hop_length,
+            f0_method=voice.f0_method,
+            audio_input_path=str(output_tts_path),
+            audio_output_path=str(output_rvc_path),
+            model_path=voice.model,
+            index_path=voice.index,
+            split_audio=False,
+            f0_autotune=voice.autotune is not None,
+            f0_autotune_strength=voice.autotune,
+            clean_audio=voice.clean is not None,
+            clean_strength=voice.clean,
+            export_format=format.upper(),
+            upscale_audio=voice.upscale,
+            f0_file=None,
+            embedder_model=voice.embedder_model,
+            embedder_model_custom=None,
+            sid=0,
+            formant_shifting=None,
+            formant_qfrency=None,
+            formant_timbre=None,
+            post_process=None,
+            reverb=None,
+            pitch_shift=None,
+            limiter=None,
+            gain=None,
+            distortion=None,
+            chorus=None,
+            bitcrush=None,
+            clipping=None,
+            compressor=None,
+            delay=None,
+            sliders=None,
+        )
+
+    return "Text synthesized successfully.", str(output_rvc_path)
 
 
 # Download
 def run_download_script(model_link: str):
     model_download_pipeline(model_link)
-    return f"Model downloaded successfully."
+    return "Model downloaded successfully."
 
 
 # Prerequisites
@@ -633,7 +106,7 @@ def run_prerequisites_script(
     pretraineds_v2_f0: bool,
     pretraineds_v2_nof0: bool,
     models: bool,
-    exe: bool,
+    voices: bool,
 ):
     prequisites_download_pipeline(
         pretraineds_v1_f0,
@@ -641,1918 +114,6 @@ def run_prerequisites_script(
         pretraineds_v2_f0,
         pretraineds_v2_nof0,
         models,
-        exe,
+        voices,
     )
     return "Prerequisites installed successfully."
-
-
-# Audio analyzer
-def run_audio_analyzer_script(
-    input_path: str, save_plot_path: str = "logs/audio_analysis.png"
-):
-    audio_info, plot_path = analyze_audio(input_path, save_plot_path)
-    print(
-        f"Audio info of {input_path}: {audio_info}",
-        f"Audio file {input_path} analyzed successfully. Plot saved at: {plot_path}",
-    )
-    return audio_info, plot_path
-
-
-# Parse arguments
-def parse_arguments():
-    parser = argparse.ArgumentParser(
-        description="Run the main.py script with specific parameters."
-    )
-    subparsers = parser.add_subparsers(
-        title="subcommands", dest="mode", help="Choose a mode"
-    )
-
-    # Parser for 'infer' mode
-    infer_parser = subparsers.add_parser("infer", help="Run inference")
-    pitch_description = (
-        "Set the pitch of the audio. Higher values result in a higher pitch."
-    )
-    infer_parser.add_argument(
-        "--pitch",
-        type=int,
-        help=pitch_description,
-        choices=range(-24, 25),
-        default=0,
-    )
-    filter_radius_description = "Apply median filtering to the extracted pitch values if this value is greater than or equal to three. This can help reduce breathiness in the output audio."
-    infer_parser.add_argument(
-        "--filter_radius",
-        type=int,
-        help=filter_radius_description,
-        choices=range(11),
-        default=3,
-    )
-    index_rate_description = "Control the influence of the index file on the output. Higher values mean stronger influence. Lower values can help reduce artifacts but may result in less accurate voice cloning."
-    infer_parser.add_argument(
-        "--index_rate",
-        type=float,
-        help=index_rate_description,
-        choices=[i / 100.0 for i in range(0, 101)],
-        default=0.3,
-    )
-    volume_envelope_description = "Control the blending of the output's volume envelope. A value of 1 means the output envelope is fully used."
-    infer_parser.add_argument(
-        "--volume_envelope",
-        type=float,
-        help=volume_envelope_description,
-        choices=[i / 100.0 for i in range(0, 101)],
-        default=1,
-    )
-    protect_description = "Protect consonants and breathing sounds from artifacts. A value of 0.5 offers the strongest protection, while lower values may reduce the protection level but potentially mitigate the indexing effect."
-    infer_parser.add_argument(
-        "--protect",
-        type=float,
-        help=protect_description,
-        choices=[i / 1000.0 for i in range(0, 501)],
-        default=0.33,
-    )
-    hop_length_description = "Only applicable for the Crepe pitch extraction method. Determines the time it takes for the system to react to a significant pitch change. Smaller values require more processing time but can lead to better pitch accuracy."
-    infer_parser.add_argument(
-        "--hop_length",
-        type=int,
-        help=hop_length_description,
-        choices=range(1, 513),
-        default=128,
-    )
-    f0_method_description = "Choose the pitch extraction algorithm for the conversion. 'rmvpe' is the default and generally recommended."
-    infer_parser.add_argument(
-        "--f0_method",
-        type=str,
-        help=f0_method_description,
-        choices=[
-            "crepe",
-            "crepe-tiny",
-            "rmvpe",
-            "fcpe",
-            "hybrid[crepe+rmvpe]",
-            "hybrid[crepe+fcpe]",
-            "hybrid[rmvpe+fcpe]",
-            "hybrid[crepe+rmvpe+fcpe]",
-        ],
-        default="rmvpe",
-    )
-    infer_parser.add_argument(
-        "--output_rvc_path",
-        type=str,
-        help="Full path to the output RVC file.",
-        required=True,
-    )
-    infer_parser.add_argument(
-        "--output_tts_path",
-        type=str,
-        help="Full path to the output TTS audio file.",
-        required=True,
-    )
-    pth_path_description = "Full path to the RVC model file (.pth)."
-    infer_parser.add_argument(
-        "--pth_path", type=str, help=pth_path_description, required=True
-    )
-    index_path_description = "Full path to the index file (.index)."
-    infer_parser.add_argument(
-        "--index_path", type=str, help=index_path_description, required=True
-    )
-    split_audio_description = "Split the audio into smaller segments before inference. This can improve the quality of the output for longer audio files."
-    infer_parser.add_argument(
-        "--split_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=split_audio_description,
-        default=False,
-    )
-    f0_autotune_description = "Apply a light autotune to the inferred audio. Particularly useful for singing voice conversions."
-    infer_parser.add_argument(
-        "--f0_autotune",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=f0_autotune_description,
-        default=False,
-    )
-    f0_autotune_strength_description = "Set the autotune strength - the more you increase it the more it will snap to the chromatic grid."
-    infer_parser.add_argument(
-        "--f0_autotune_strength",
-        type=float,
-        help=f0_autotune_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=1.0,
-    )
-    clean_audio_description = "Clean the output audio using noise reduction algorithms. Recommended for speech conversions."
-    infer_parser.add_argument(
-        "--clean_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=clean_audio_description,
-        default=False,
-    )
-    clean_strength_description = "Adjust the intensity of the audio cleaning process. Higher values result in stronger cleaning, but may lead to a more compressed sound."
-    infer_parser.add_argument(
-        "--clean_strength",
-        type=float,
-        help=clean_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=0.7,
-    )
-    export_format_description = "Select the desired output audio format."
-    infer_parser.add_argument(
-        "--export_format",
-        type=str,
-        help=export_format_description,
-        choices=["WAV", "MP3", "FLAC", "OGG", "M4A"],
-        default="WAV",
-    )
-    embedder_model_description = (
-        "Choose the model used for generating speaker embeddings."
-    )
-    infer_parser.add_argument(
-        "--embedder_model",
-        type=str,
-        help=embedder_model_description,
-        choices=[
-            "contentvec",
-            "chinese-hubert-base",
-            "japanese-hubert-base",
-            "korean-hubert-base",
-            "custom",
-        ],
-        default="contentvec",
-    )
-    embedder_model_custom_description = "Specify the path to a custom model for speaker embedding. Only applicable if 'embedder_model' is set to 'custom'."
-    infer_parser.add_argument(
-        "--embedder_model_custom",
-        type=str,
-        help=embedder_model_custom_description,
-        default=None,
-    )
-    upscale_audio_description = "Upscale the input audio to a higher quality before processing. This can improve the overall quality of the output, especially for low-quality input audio."
-    infer_parser.add_argument(
-        "--upscale_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=upscale_audio_description,
-        default=False,
-    )
-    f0_file_description = "Full path to an external F0 file (.f0). This allows you to use pre-computed pitch values for the input audio."
-    infer_parser.add_argument(
-        "--f0_file",
-        type=str,
-        help=f0_file_description,
-        default=None,
-    )
-    formant_shifting_description = "Apply formant shifting to the input audio. This can help adjust the timbre of the voice."
-    infer_parser.add_argument(
-        "--formant_shifting",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=formant_shifting_description,
-        default=False,
-        required=False,
-    )
-    formant_qfrency_description = "Control the frequency of the formant shifting effect. Higher values result in a more pronounced effect."
-    infer_parser.add_argument(
-        "--formant_qfrency",
-        type=float,
-        help=formant_qfrency_description,
-        default=1.0,
-        required=False,
-    )
-    formant_timbre_description = "Control the timbre of the formant shifting effect. Higher values result in a more pronounced effect."
-    infer_parser.add_argument(
-        "--formant_timbre",
-        type=float,
-        help=formant_timbre_description,
-        default=1.0,
-        required=False,
-    )
-    sid_description = "Speaker ID for multi-speaker models."
-    infer_parser.add_argument(
-        "--sid",
-        type=int,
-        help=sid_description,
-        default=0,
-        required=False,
-    )
-    post_process_description = "Apply post-processing effects to the output audio."
-    infer_parser.add_argument(
-        "--post_process",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=post_process_description,
-        default=False,
-        required=False,
-    )
-    reverb_description = "Apply reverb effect to the output audio."
-    infer_parser.add_argument(
-        "--reverb",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=reverb_description,
-        default=False,
-        required=False,
-    )
-
-    pitch_shift_description = "Apply pitch shifting effect to the output audio."
-    infer_parser.add_argument(
-        "--pitch_shift",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=pitch_shift_description,
-        default=False,
-        required=False,
-    )
-
-    limiter_description = "Apply limiter effect to the output audio."
-    infer_parser.add_argument(
-        "--limiter",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=limiter_description,
-        default=False,
-        required=False,
-    )
-
-    gain_description = "Apply gain effect to the output audio."
-    infer_parser.add_argument(
-        "--gain",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=gain_description,
-        default=False,
-        required=False,
-    )
-
-    distortion_description = "Apply distortion effect to the output audio."
-    infer_parser.add_argument(
-        "--distortion",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=distortion_description,
-        default=False,
-        required=False,
-    )
-
-    chorus_description = "Apply chorus effect to the output audio."
-    infer_parser.add_argument(
-        "--chorus",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=chorus_description,
-        default=False,
-        required=False,
-    )
-
-    bitcrush_description = "Apply bitcrush effect to the output audio."
-    infer_parser.add_argument(
-        "--bitcrush",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=bitcrush_description,
-        default=False,
-        required=False,
-    )
-
-    clipping_description = "Apply clipping effect to the output audio."
-    infer_parser.add_argument(
-        "--clipping",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=clipping_description,
-        default=False,
-        required=False,
-    )
-
-    compressor_description = "Apply compressor effect to the output audio."
-    infer_parser.add_argument(
-        "--compressor",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=compressor_description,
-        default=False,
-        required=False,
-    )
-
-    delay_description = "Apply delay effect to the output audio."
-    infer_parser.add_argument(
-        "--delay",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=delay_description,
-        default=False,
-        required=False,
-    )
-
-    reverb_room_size_description = "Control the room size of the reverb effect. Higher values result in a larger room size."
-    infer_parser.add_argument(
-        "--reverb_room_size",
-        type=float,
-        help=reverb_room_size_description,
-        default=0.5,
-        required=False,
-    )
-
-    reverb_damping_description = "Control the damping of the reverb effect. Higher values result in a more damped sound."
-    infer_parser.add_argument(
-        "--reverb_damping",
-        type=float,
-        help=reverb_damping_description,
-        default=0.5,
-        required=False,
-    )
-
-    reverb_wet_gain_description = "Control the wet gain of the reverb effect. Higher values result in a stronger reverb effect."
-    infer_parser.add_argument(
-        "--reverb_wet_gain",
-        type=float,
-        help=reverb_wet_gain_description,
-        default=0.5,
-        required=False,
-    )
-
-    reverb_dry_gain_description = "Control the dry gain of the reverb effect. Higher values result in a stronger dry signal."
-    infer_parser.add_argument(
-        "--reverb_dry_gain",
-        type=float,
-        help=reverb_dry_gain_description,
-        default=0.5,
-        required=False,
-    )
-
-    reverb_width_description = "Control the stereo width of the reverb effect. Higher values result in a wider stereo image."
-    infer_parser.add_argument(
-        "--reverb_width",
-        type=float,
-        help=reverb_width_description,
-        default=0.5,
-        required=False,
-    )
-
-    reverb_freeze_mode_description = "Control the freeze mode of the reverb effect. Higher values result in a stronger freeze effect."
-    infer_parser.add_argument(
-        "--reverb_freeze_mode",
-        type=float,
-        help=reverb_freeze_mode_description,
-        default=0.5,
-        required=False,
-    )
-
-    pitch_shift_semitones_description = "Control the pitch shift in semitones. Positive values increase the pitch, while negative values decrease it."
-    infer_parser.add_argument(
-        "--pitch_shift_semitones",
-        type=float,
-        help=pitch_shift_semitones_description,
-        default=0.0,
-        required=False,
-    )
-
-    limiter_threshold_description = "Control the threshold of the limiter effect. Higher values result in a stronger limiting effect."
-    infer_parser.add_argument(
-        "--limiter_threshold",
-        type=float,
-        help=limiter_threshold_description,
-        default=-6,
-        required=False,
-    )
-
-    limiter_release_time_description = "Control the release time of the limiter effect. Higher values result in a longer release time."
-    infer_parser.add_argument(
-        "--limiter_release_time",
-        type=float,
-        help=limiter_release_time_description,
-        default=0.01,
-        required=False,
-    )
-
-    gain_db_description = "Control the gain in decibels. Positive values increase the gain, while negative values decrease it."
-    infer_parser.add_argument(
-        "--gain_db",
-        type=float,
-        help=gain_db_description,
-        default=0.0,
-        required=False,
-    )
-
-    distortion_gain_description = "Control the gain of the distortion effect. Higher values result in a stronger distortion effect."
-    infer_parser.add_argument(
-        "--distortion_gain",
-        type=float,
-        help=distortion_gain_description,
-        default=25,
-        required=False,
-    )
-
-    chorus_rate_description = "Control the rate of the chorus effect. Higher values result in a faster chorus effect."
-    infer_parser.add_argument(
-        "--chorus_rate",
-        type=float,
-        help=chorus_rate_description,
-        default=1.0,
-        required=False,
-    )
-
-    chorus_depth_description = "Control the depth of the chorus effect. Higher values result in a stronger chorus effect."
-    infer_parser.add_argument(
-        "--chorus_depth",
-        type=float,
-        help=chorus_depth_description,
-        default=0.25,
-        required=False,
-    )
-
-    chorus_center_delay_description = "Control the center delay of the chorus effect. Higher values result in a longer center delay."
-    infer_parser.add_argument(
-        "--chorus_center_delay",
-        type=float,
-        help=chorus_center_delay_description,
-        default=7,
-        required=False,
-    )
-
-    chorus_feedback_description = "Control the feedback of the chorus effect. Higher values result in a stronger feedback effect."
-    infer_parser.add_argument(
-        "--chorus_feedback",
-        type=float,
-        help=chorus_feedback_description,
-        default=0.0,
-        required=False,
-    )
-
-    chorus_mix_description = "Control the mix of the chorus effect. Higher values result in a stronger chorus effect."
-    infer_parser.add_argument(
-        "--chorus_mix",
-        type=float,
-        help=chorus_mix_description,
-        default=0.5,
-        required=False,
-    )
-
-    bitcrush_bit_depth_description = "Control the bit depth of the bitcrush effect. Higher values result in a stronger bitcrush effect."
-    infer_parser.add_argument(
-        "--bitcrush_bit_depth",
-        type=int,
-        help=bitcrush_bit_depth_description,
-        default=8,
-        required=False,
-    )
-
-    clipping_threshold_description = "Control the threshold of the clipping effect. Higher values result in a stronger clipping effect."
-    infer_parser.add_argument(
-        "--clipping_threshold",
-        type=float,
-        help=clipping_threshold_description,
-        default=-6,
-        required=False,
-    )
-
-    compressor_threshold_description = "Control the threshold of the compressor effect. Higher values result in a stronger compressor effect."
-    infer_parser.add_argument(
-        "--compressor_threshold",
-        type=float,
-        help=compressor_threshold_description,
-        default=0,
-        required=False,
-    )
-
-    compressor_ratio_description = "Control the ratio of the compressor effect. Higher values result in a stronger compressor effect."
-    infer_parser.add_argument(
-        "--compressor_ratio",
-        type=float,
-        help=compressor_ratio_description,
-        default=1,
-        required=False,
-    )
-
-    compressor_attack_description = "Control the attack of the compressor effect. Higher values result in a stronger compressor effect."
-    infer_parser.add_argument(
-        "--compressor_attack",
-        type=float,
-        help=compressor_attack_description,
-        default=1.0,
-        required=False,
-    )
-
-    compressor_release_description = "Control the release of the compressor effect. Higher values result in a stronger compressor effect."
-    infer_parser.add_argument(
-        "--compressor_release",
-        type=float,
-        help=compressor_release_description,
-        default=100,
-        required=False,
-    )
-
-    delay_seconds_description = "Control the delay time in seconds. Higher values result in a longer delay time."
-    infer_parser.add_argument(
-        "--delay_seconds",
-        type=float,
-        help=delay_seconds_description,
-        default=0.5,
-        required=False,
-    )
-    delay_feedback_description = "Control the feedback of the delay effect. Higher values result in a stronger feedback effect."
-    infer_parser.add_argument(
-        "--delay_feedback",
-        type=float,
-        help=delay_feedback_description,
-        default=0.0,
-        required=False,
-    )
-    delay_mix_description = "Control the mix of the delay effect. Higher values result in a stronger delay effect."
-    infer_parser.add_argument(
-        "--delay_mix",
-        type=float,
-        help=delay_mix_description,
-        default=0.5,
-        required=False,
-    )
-
-    # Parser for 'batch_infer' mode
-    batch_infer_parser = subparsers.add_parser(
-        "batch_infer",
-        help="Run batch inference",
-    )
-    batch_infer_parser.add_argument(
-        "--pitch",
-        type=int,
-        help=pitch_description,
-        choices=range(-24, 25),
-        default=0,
-    )
-    batch_infer_parser.add_argument(
-        "--filter_radius",
-        type=int,
-        help=filter_radius_description,
-        choices=range(11),
-        default=3,
-    )
-    batch_infer_parser.add_argument(
-        "--index_rate",
-        type=float,
-        help=index_rate_description,
-        choices=[i / 100.0 for i in range(0, 101)],
-        default=0.3,
-    )
-    batch_infer_parser.add_argument(
-        "--volume_envelope",
-        type=float,
-        help=volume_envelope_description,
-        choices=[i / 100.0 for i in range(0, 101)],
-        default=1,
-    )
-    batch_infer_parser.add_argument(
-        "--protect",
-        type=float,
-        help=protect_description,
-        choices=[i / 1000.0 for i in range(0, 501)],
-        default=0.33,
-    )
-    batch_infer_parser.add_argument(
-        "--hop_length",
-        type=int,
-        help=hop_length_description,
-        choices=range(1, 513),
-        default=128,
-    )
-    batch_infer_parser.add_argument(
-        "--f0_method",
-        type=str,
-        help=f0_method_description,
-        choices=[
-            "crepe",
-            "crepe-tiny",
-            "rmvpe",
-            "fcpe",
-            "hybrid[crepe+rmvpe]",
-            "hybrid[crepe+fcpe]",
-            "hybrid[rmvpe+fcpe]",
-            "hybrid[crepe+rmvpe+fcpe]",
-        ],
-        default="rmvpe",
-    )
-    batch_infer_parser.add_argument(
-        "--input_folder",
-        type=str,
-        help="Path to the folder containing input audio files.",
-        required=True,
-    )
-    batch_infer_parser.add_argument(
-        "--output_folder",
-        type=str,
-        help="Path to the folder for saving output audio files.",
-        required=True,
-    )
-    batch_infer_parser.add_argument(
-        "--pth_path", type=str, help=pth_path_description, required=True
-    )
-    batch_infer_parser.add_argument(
-        "--index_path", type=str, help=index_path_description, required=True
-    )
-    batch_infer_parser.add_argument(
-        "--split_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=split_audio_description,
-        default=False,
-    )
-    batch_infer_parser.add_argument(
-        "--f0_autotune",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=f0_autotune_description,
-        default=False,
-    )
-    batch_infer_parser.add_argument(
-        "--f0_autotune_strength",
-        type=float,
-        help=clean_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=1.0,
-    )
-    batch_infer_parser.add_argument(
-        "--clean_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=clean_audio_description,
-        default=False,
-    )
-    batch_infer_parser.add_argument(
-        "--clean_strength",
-        type=float,
-        help=clean_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=0.7,
-    )
-    batch_infer_parser.add_argument(
-        "--export_format",
-        type=str,
-        help=export_format_description,
-        choices=["WAV", "MP3", "FLAC", "OGG", "M4A"],
-        default="WAV",
-    )
-    batch_infer_parser.add_argument(
-        "--embedder_model",
-        type=str,
-        help=embedder_model_description,
-        choices=[
-            "contentvec",
-            "chinese-hubert-base",
-            "japanese-hubert-base",
-            "korean-hubert-base",
-            "custom",
-        ],
-        default="contentvec",
-    )
-    batch_infer_parser.add_argument(
-        "--embedder_model_custom",
-        type=str,
-        help=embedder_model_custom_description,
-        default=None,
-    )
-    batch_infer_parser.add_argument(
-        "--upscale_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=upscale_audio_description,
-        default=False,
-    )
-    batch_infer_parser.add_argument(
-        "--f0_file",
-        type=str,
-        help=f0_file_description,
-        default=None,
-    )
-    batch_infer_parser.add_argument(
-        "--formant_shifting",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=formant_shifting_description,
-        default=False,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--formant_qfrency",
-        type=float,
-        help=formant_qfrency_description,
-        default=1.0,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--formant_timbre",
-        type=float,
-        help=formant_timbre_description,
-        default=1.0,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--sid",
-        type=int,
-        help=sid_description,
-        default=0,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--post_process",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=post_process_description,
-        default=False,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--reverb",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=reverb_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--pitch_shift",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=pitch_shift_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--limiter",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=limiter_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--gain",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=gain_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--distortion",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=distortion_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--chorus",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=chorus_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--bitcrush",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=bitcrush_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--clipping",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=clipping_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--compressor",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=compressor_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--delay",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=delay_description,
-        default=False,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_room_size",
-        type=float,
-        help=reverb_room_size_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_damping",
-        type=float,
-        help=reverb_damping_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_wet_gain",
-        type=float,
-        help=reverb_wet_gain_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_dry_gain",
-        type=float,
-        help=reverb_dry_gain_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_width",
-        type=float,
-        help=reverb_width_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--reverb_freeze_mode",
-        type=float,
-        help=reverb_freeze_mode_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--pitch_shift_semitones",
-        type=float,
-        help=pitch_shift_semitones_description,
-        default=0.0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--limiter_threshold",
-        type=float,
-        help=limiter_threshold_description,
-        default=-6,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--limiter_release_time",
-        type=float,
-        help=limiter_release_time_description,
-        default=0.01,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--gain_db",
-        type=float,
-        help=gain_db_description,
-        default=0.0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--distortion_gain",
-        type=float,
-        help=distortion_gain_description,
-        default=25,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--chorus_rate",
-        type=float,
-        help=chorus_rate_description,
-        default=1.0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--chorus_depth",
-        type=float,
-        help=chorus_depth_description,
-        default=0.25,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--chorus_center_delay",
-        type=float,
-        help=chorus_center_delay_description,
-        default=7,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--chorus_feedback",
-        type=float,
-        help=chorus_feedback_description,
-        default=0.0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--chorus_mix",
-        type=float,
-        help=chorus_mix_description,
-        default=0.5,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--bitcrush_bit_depth",
-        type=int,
-        help=bitcrush_bit_depth_description,
-        default=8,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--clipping_threshold",
-        type=float,
-        help=clipping_threshold_description,
-        default=-6,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--compressor_threshold",
-        type=float,
-        help=compressor_threshold_description,
-        default=0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--compressor_ratio",
-        type=float,
-        help=compressor_ratio_description,
-        default=1,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--compressor_attack",
-        type=float,
-        help=compressor_attack_description,
-        default=1.0,
-        required=False,
-    )
-
-    batch_infer_parser.add_argument(
-        "--compressor_release",
-        type=float,
-        help=compressor_release_description,
-        default=100,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--delay_seconds",
-        type=float,
-        help=delay_seconds_description,
-        default=0.5,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--delay_feedback",
-        type=float,
-        help=delay_feedback_description,
-        default=0.0,
-        required=False,
-    )
-    batch_infer_parser.add_argument(
-        "--delay_mix",
-        type=float,
-        help=delay_mix_description,
-        default=0.5,
-        required=False,
-    )
-
-    # Parser for 'tts' mode
-    tts_parser = subparsers.add_parser("tts", help="Run TTS inference")
-    tts_parser.add_argument(
-        "--tts_file", type=str, help="File with a text to be synthesized", required=True
-    )
-    tts_parser.add_argument(
-        "--tts_text", type=str, help="Text to be synthesized", required=True
-    )
-    tts_parser.add_argument(
-        "--tts_voice",
-        type=str,
-        help="Voice to be used for TTS synthesis.",
-        choices=locales,
-        required=True,
-    )
-    tts_parser.add_argument(
-        "--tts_rate",
-        type=int,
-        help="Control the speaking rate of the TTS. Values range from -100 (slower) to 100 (faster).",
-        choices=range(-100, 101),
-        default=0,
-    )
-    tts_parser.add_argument(
-        "--pitch",
-        type=int,
-        help=pitch_description,
-        choices=range(-24, 25),
-        default=0,
-    )
-    tts_parser.add_argument(
-        "--filter_radius",
-        type=int,
-        help=filter_radius_description,
-        choices=range(11),
-        default=3,
-    )
-    tts_parser.add_argument(
-        "--index_rate",
-        type=float,
-        help=index_rate_description,
-        choices=[(i / 10) for i in range(11)],
-        default=0.3,
-    )
-    tts_parser.add_argument(
-        "--volume_envelope",
-        type=float,
-        help=volume_envelope_description,
-        choices=[(i / 10) for i in range(11)],
-        default=1,
-    )
-    tts_parser.add_argument(
-        "--protect",
-        type=float,
-        help=protect_description,
-        choices=[(i / 10) for i in range(6)],
-        default=0.33,
-    )
-    tts_parser.add_argument(
-        "--hop_length",
-        type=int,
-        help=hop_length_description,
-        choices=range(1, 513),
-        default=128,
-    )
-    tts_parser.add_argument(
-        "--f0_method",
-        type=str,
-        help=f0_method_description,
-        choices=[
-            "crepe",
-            "crepe-tiny",
-            "rmvpe",
-            "fcpe",
-            "hybrid[crepe+rmvpe]",
-            "hybrid[crepe+fcpe]",
-            "hybrid[rmvpe+fcpe]",
-            "hybrid[crepe+rmvpe+fcpe]",
-        ],
-        default="rmvpe",
-    )
-    tts_parser.add_argument(
-        "--output_tts_path",
-        type=str,
-        help="Full path to save the synthesized TTS audio.",
-        required=True,
-    )
-    tts_parser.add_argument(
-        "--output_rvc_path",
-        type=str,
-        help="Full path to save the voice-converted audio using the synthesized TTS.",
-        required=True,
-    )
-    tts_parser.add_argument(
-        "--pth_path", type=str, help=pth_path_description, required=True
-    )
-    tts_parser.add_argument(
-        "--index_path", type=str, help=index_path_description, required=True
-    )
-    tts_parser.add_argument(
-        "--split_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=split_audio_description,
-        default=False,
-    )
-    tts_parser.add_argument(
-        "--f0_autotune",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=f0_autotune_description,
-        default=False,
-    )
-    tts_parser.add_argument(
-        "--f0_autotune_strength",
-        type=float,
-        help=clean_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=1.0,
-    )
-    tts_parser.add_argument(
-        "--clean_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=clean_audio_description,
-        default=False,
-    )
-    tts_parser.add_argument(
-        "--clean_strength",
-        type=float,
-        help=clean_strength_description,
-        choices=[(i / 10) for i in range(11)],
-        default=0.7,
-    )
-    tts_parser.add_argument(
-        "--export_format",
-        type=str,
-        help=export_format_description,
-        choices=["WAV", "MP3", "FLAC", "OGG", "M4A"],
-        default="WAV",
-    )
-    tts_parser.add_argument(
-        "--embedder_model",
-        type=str,
-        help=embedder_model_description,
-        choices=[
-            "contentvec",
-            "chinese-hubert-base",
-            "japanese-hubert-base",
-            "korean-hubert-base",
-            "custom",
-        ],
-        default="contentvec",
-    )
-    tts_parser.add_argument(
-        "--embedder_model_custom",
-        type=str,
-        help=embedder_model_custom_description,
-        default=None,
-    )
-    tts_parser.add_argument(
-        "--upscale_audio",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help=upscale_audio_description,
-        default=False,
-    )
-    tts_parser.add_argument(
-        "--f0_file",
-        type=str,
-        help=f0_file_description,
-        default=None,
-    )
-
-    # Parser for 'preprocess' mode
-    preprocess_parser = subparsers.add_parser(
-        "preprocess", help="Preprocess a dataset for training."
-    )
-    preprocess_parser.add_argument(
-        "--model_name", type=str, help="Name of the model to be trained.", required=True
-    )
-    preprocess_parser.add_argument(
-        "--dataset_path", type=str, help="Path to the dataset directory.", required=True
-    )
-    preprocess_parser.add_argument(
-        "--sample_rate",
-        type=int,
-        help="Target sampling rate for the audio data.",
-        choices=[32000, 40000, 48000],
-        required=True,
-    )
-    preprocess_parser.add_argument(
-        "--cpu_cores",
-        type=int,
-        help="Number of CPU cores to use for preprocessing.",
-        choices=range(1, 65),
-    )
-    preprocess_parser.add_argument(
-        "--cut_preprocess",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Cut the dataset into smaller segments for faster preprocessing.",
-        default=True,
-        required=False,
-    )
-    preprocess_parser.add_argument(
-        "--process_effects",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Disable all filters during preprocessing.",
-        default=False,
-        required=False,
-    )
-    preprocess_parser.add_argument(
-        "--noise_reduction",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Enable noise reduction during preprocessing.",
-        default=False,
-        required=False,
-    )
-    preprocess_parser.add_argument(
-        "--noise_reduction_strength",
-        type=float,
-        help="Strength of the noise reduction filter.",
-        choices=[(i / 10) for i in range(11)],
-        default=0.7,
-        required=False,
-    )
-
-    # Parser for 'extract' mode
-    extract_parser = subparsers.add_parser(
-        "extract", help="Extract features from a dataset."
-    )
-    extract_parser.add_argument(
-        "--model_name", type=str, help="Name of the model.", required=True
-    )
-    extract_parser.add_argument(
-        "--rvc_version",
-        type=str,
-        help="Version of the RVC model ('v1' or 'v2').",
-        choices=["v1", "v2"],
-        default="v2",
-    )
-    extract_parser.add_argument(
-        "--f0_method",
-        type=str,
-        help="Pitch extraction method to use.",
-        choices=[
-            "crepe",
-            "crepe-tiny",
-            "rmvpe",
-        ],
-        default="rmvpe",
-    )
-    extract_parser.add_argument(
-        "--hop_length",
-        type=int,
-        help="Hop length for feature extraction. Only applicable for Crepe pitch extraction.",
-        choices=range(1, 513),
-        default=128,
-    )
-    extract_parser.add_argument(
-        "--cpu_cores",
-        type=int,
-        help="Number of CPU cores to use for feature extraction (optional).",
-        choices=range(1, 65),
-        default=None,
-    )
-    extract_parser.add_argument(
-        "--gpu",
-        type=int,
-        help="GPU device to use for feature extraction (optional).",
-        default="-",
-    )
-    extract_parser.add_argument(
-        "--sample_rate",
-        type=int,
-        help="Target sampling rate for the audio data.",
-        choices=[32000, 40000, 48000],
-        required=True,
-    )
-    extract_parser.add_argument(
-        "--embedder_model",
-        type=str,
-        help=embedder_model_description,
-        choices=[
-            "contentvec",
-            "chinese-hubert-base",
-            "japanese-hubert-base",
-            "korean-hubert-base",
-            "custom",
-        ],
-        default="contentvec",
-    )
-    extract_parser.add_argument(
-        "--embedder_model_custom",
-        type=str,
-        help=embedder_model_custom_description,
-        default=None,
-    )
-
-    # Parser for 'train' mode
-    train_parser = subparsers.add_parser("train", help="Train an RVC model.")
-    train_parser.add_argument(
-        "--model_name", type=str, help="Name of the model to be trained.", required=True
-    )
-    train_parser.add_argument(
-        "--rvc_version",
-        type=str,
-        help="Version of the RVC model to train ('v1' or 'v2').",
-        choices=["v1", "v2"],
-        default="v2",
-    )
-    train_parser.add_argument(
-        "--save_every_epoch",
-        type=int,
-        help="Save the model every specified number of epochs.",
-        choices=range(1, 101),
-        required=True,
-    )
-    train_parser.add_argument(
-        "--save_only_latest",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Save only the latest model checkpoint.",
-        default=False,
-    )
-    train_parser.add_argument(
-        "--save_every_weights",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Save model weights every epoch.",
-        default=True,
-    )
-    train_parser.add_argument(
-        "--total_epoch",
-        type=int,
-        help="Total number of epochs to train for.",
-        choices=range(1, 10001),
-        default=1000,
-    )
-    train_parser.add_argument(
-        "--sample_rate",
-        type=int,
-        help="Sampling rate of the training data.",
-        choices=[32000, 40000, 48000],
-        required=True,
-    )
-    train_parser.add_argument(
-        "--batch_size",
-        type=int,
-        help="Batch size for training.",
-        choices=range(1, 51),
-        default=8,
-    )
-    train_parser.add_argument(
-        "--gpu",
-        type=str,
-        help="GPU device to use for training (e.g., '0').",
-        default="0",
-    )
-    train_parser.add_argument(
-        "--pitch_guidance",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Enable or disable pitch guidance during training.",
-        default=True,
-    )
-    train_parser.add_argument(
-        "--pretrained",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Use a pretrained model for initialization.",
-        default=True,
-    )
-    train_parser.add_argument(
-        "--custom_pretrained",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Use a custom pretrained model.",
-        default=False,
-    )
-    train_parser.add_argument(
-        "--g_pretrained_path",
-        type=str,
-        nargs="?",
-        default=None,
-        help="Path to the pretrained generator model file.",
-    )
-    train_parser.add_argument(
-        "--d_pretrained_path",
-        type=str,
-        nargs="?",
-        default=None,
-        help="Path to the pretrained discriminator model file.",
-    )
-    train_parser.add_argument(
-        "--overtraining_detector",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Enable overtraining detection.",
-        default=False,
-    )
-    train_parser.add_argument(
-        "--overtraining_threshold",
-        type=int,
-        help="Threshold for overtraining detection.",
-        choices=range(1, 101),
-        default=50,
-    )
-    train_parser.add_argument(
-        "--cleanup",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Cleanup previous training attempt.",
-        default=False,
-    )
-    train_parser.add_argument(
-        "--cache_data_in_gpu",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Cache training data in GPU memory.",
-        default=False,
-    )
-    train_parser.add_argument(
-        "--index_algorithm",
-        type=str,
-        choices=["Auto", "Faiss", "KMeans"],
-        help="Choose the method for generating the index file.",
-        default="Auto",
-        required=False,
-    )
-
-    # Parser for 'index' mode
-    index_parser = subparsers.add_parser(
-        "index", help="Generate an index file for an RVC model."
-    )
-    index_parser.add_argument(
-        "--model_name", type=str, help="Name of the model.", required=True
-    )
-    index_parser.add_argument(
-        "--rvc_version",
-        type=str,
-        help="Version of the RVC model ('v1' or 'v2').",
-        choices=["v1", "v2"],
-        default="v2",
-    )
-    index_parser.add_argument(
-        "--index_algorithm",
-        type=str,
-        choices=["Auto", "Faiss", "KMeans"],
-        help="Choose the method for generating the index file.",
-        default="Auto",
-        required=False,
-    )
-
-    # Parser for 'model_extract' mode
-    model_extract_parser = subparsers.add_parser(
-        "model_extract", help="Extract a specific epoch from a trained model."
-    )
-    model_extract_parser.add_argument(
-        "--pth_path", type=str, help="Path to the main .pth model file.", required=True
-    )
-    model_extract_parser.add_argument(
-        "--model_name", type=str, help="Name of the model.", required=True
-    )
-    model_extract_parser.add_argument(
-        "--sample_rate",
-        type=int,
-        help="Sampling rate of the extracted model.",
-        choices=[32000, 40000, 48000],
-        required=True,
-    )
-    model_extract_parser.add_argument(
-        "--pitch_guidance",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        help="Enable or disable pitch guidance for the extracted model.",
-        required=True,
-    )
-    model_extract_parser.add_argument(
-        "--rvc_version",
-        type=str,
-        help="Version of the extracted RVC model ('v1' or 'v2').",
-        choices=["v1", "v2"],
-        default="v2",
-    )
-    model_extract_parser.add_argument(
-        "--epoch",
-        type=int,
-        help="Epoch number to extract from the model.",
-        choices=range(1, 10001),
-        required=True,
-    )
-    model_extract_parser.add_argument(
-        "--step",
-        type=str,
-        help="Step number to extract from the model (optional).",
-        required=False,
-    )
-
-    # Parser for 'model_information' mode
-    model_information_parser = subparsers.add_parser(
-        "model_information", help="Display information about a trained model."
-    )
-    model_information_parser.add_argument(
-        "--pth_path", type=str, help="Path to the .pth model file.", required=True
-    )
-
-    # Parser for 'model_blender' mode
-    model_blender_parser = subparsers.add_parser(
-        "model_blender", help="Fuse two RVC models together."
-    )
-    model_blender_parser.add_argument(
-        "--model_name", type=str, help="Name of the new fused model.", required=True
-    )
-    model_blender_parser.add_argument(
-        "--pth_path_1",
-        type=str,
-        help="Path to the first .pth model file.",
-        required=True,
-    )
-    model_blender_parser.add_argument(
-        "--pth_path_2",
-        type=str,
-        help="Path to the second .pth model file.",
-        required=True,
-    )
-    model_blender_parser.add_argument(
-        "--ratio",
-        type=float,
-        help="Ratio for blending the two models (0.0 to 1.0).",
-        choices=[(i / 10) for i in range(11)],
-        default=0.5,
-    )
-
-    # Parser for 'tensorboard' mode
-    subparsers.add_parser(
-        "tensorboard", help="Launch TensorBoard for monitoring training progress."
-    )
-
-    # Parser for 'download' mode
-    download_parser = subparsers.add_parser(
-        "download", help="Download a model from a provided link."
-    )
-    download_parser.add_argument(
-        "--model_link", type=str, help="Direct link to the model file.", required=True
-    )
-
-    # Parser for 'prerequisites' mode
-    prerequisites_parser = subparsers.add_parser(
-        "prerequisites", help="Install prerequisites for RVC."
-    )
-    prerequisites_parser.add_argument(
-        "--pretraineds_v1_f0",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=False,
-        help="Download pretrained models for RVC v1.",
-    )
-    prerequisites_parser.add_argument(
-        "--pretraineds_v2_f0",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=True,
-        help="Download pretrained models for RVC v2.",
-    )
-    prerequisites_parser.add_argument(
-        "--pretraineds_v1_nof0",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=False,
-        help="Download non f0 pretrained models for RVC v1.",
-    )
-    prerequisites_parser.add_argument(
-        "--pretraineds_v2_nof0",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=False,
-        help="Download non f0 pretrained models for RVC v2.",
-    )
-    prerequisites_parser.add_argument(
-        "--models",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=True,
-        help="Download additional models.",
-    )
-    prerequisites_parser.add_argument(
-        "--exe",
-        type=lambda x: bool(strtobool(x)),
-        choices=[True, False],
-        default=True,
-        help="Download required executables.",
-    )
-
-    # Parser for 'audio_analyzer' mode
-    audio_analyzer = subparsers.add_parser(
-        "audio_analyzer", help="Analyze an audio file."
-    )
-    audio_analyzer.add_argument(
-        "--input_path", type=str, help="Path to the input audio file.", required=True
-    )
-
-    return parser.parse_args()
-
-
-def main():
-    if len(sys.argv) == 1:
-        print("Please run the script with '-h' for more information.")
-        sys.exit(1)
-
-    args = parse_arguments()
-
-    try:
-        if args.mode == "infer":
-            run_infer_script(
-                pitch=args.pitch,
-                filter_radius=args.filter_radius,
-                index_rate=args.index_rate,
-                volume_envelope=args.volume_envelope,
-                protect=args.protect,
-                hop_length=args.hop_length,
-                f0_method=args.f0_method,
-                input_path=args.input_path,
-                output_path=args.output_path,
-                pth_path=args.pth_path,
-                index_path=args.index_path,
-                split_audio=args.split_audio,
-                f0_autotune=args.f0_autotune,
-                f0_autotune_strength=args.f0_autotune_strength,
-                clean_audio=args.clean_audio,
-                clean_strength=args.clean_strength,
-                export_format=args.export_format,
-                embedder_model=args.embedder_model,
-                embedder_model_custom=args.embedder_model_custom,
-                upscale_audio=args.upscale_audio,
-                f0_file=args.f0_file,
-                formant_shifting=args.formant_shifting,
-                formant_qfrency=args.formant_qfrency,
-                formant_timbre=args.formant_timbre,
-                sid=args.sid,
-                post_process=args.post_process,
-                reverb=args.reverb,
-                pitch_shift=args.pitch_shift,
-                limiter=args.limiter,
-                gain=args.gain,
-                distortion=args.distortion,
-                chorus=args.chorus,
-                bitcrush=args.bitcrush,
-                clipping=args.clipping,
-                compressor=args.compressor,
-                delay=args.delay,
-                reverb_room_size=args.reverb_room_size,
-                reverb_damping=args.reverb_damping,
-                reverb_wet_gain=args.reverb_wet_gain,
-                reverb_dry_gain=args.reverb_dry_gain,
-                reverb_width=args.reverb_width,
-                reverb_freeze_mode=args.reverb_freeze_mode,
-                pitch_shift_semitones=args.pitch_shift_semitones,
-                limiter_threshold=args.limiter_threshold,
-                limiter_release_time=args.limiter_release_time,
-                gain_db=args.gain_db,
-                distortion_gain=args.distortion_gain,
-                chorus_rate=args.chorus_rate,
-                chorus_depth=args.chorus_depth,
-                chorus_center_delay=args.chorus_center_delay,
-                chorus_feedback=args.chorus_feedback,
-                chorus_mix=args.chorus_mix,
-                bitcrush_bit_depth=args.bitcrush_bit_depth,
-                clipping_threshold=args.clipping_threshold,
-                compressor_threshold=args.compressor_threshold,
-                compressor_ratio=args.compressor_ratio,
-                compressor_attack=args.compressor_attack,
-                compressor_release=args.compressor_release,
-                delay_seconds=args.delay_seconds,
-                delay_feedback=args.delay_feedback,
-                delay_mix=args.delay_mix,
-            )
-        elif args.mode == "batch_infer":
-            run_batch_infer_script(
-                pitch=args.pitch,
-                filter_radius=args.filter_radius,
-                index_rate=args.index_rate,
-                volume_envelope=args.volume_envelope,
-                protect=args.protect,
-                hop_length=args.hop_length,
-                f0_method=args.f0_method,
-                input_folder=args.input_folder,
-                output_folder=args.output_folder,
-                pth_path=args.pth_path,
-                index_path=args.index_path,
-                split_audio=args.split_audio,
-                f0_autotune=args.f0_autotune,
-                f0_autotune_strength=args.f0_autotune_strength,
-                clean_audio=args.clean_audio,
-                clean_strength=args.clean_strength,
-                export_format=args.export_format,
-                embedder_model=args.embedder_model,
-                embedder_model_custom=args.embedder_model_custom,
-                upscale_audio=args.upscale_audio,
-                f0_file=args.f0_file,
-                formant_shifting=args.formant_shifting,
-                formant_qfrency=args.formant_qfrency,
-                formant_timbre=args.formant_timbre,
-                sid=args.sid,
-                post_process=args.post_process,
-                reverb=args.reverb,
-                pitch_shift=args.pitch_shift,
-                limiter=args.limiter,
-                gain=args.gain,
-                distortion=args.distortion,
-                chorus=args.chorus,
-                bitcrush=args.bitcrush,
-                clipping=args.clipping,
-                compressor=args.compressor,
-                delay=args.delay,
-                reverb_room_size=args.reverb_room_size,
-                reverb_damping=args.reverb_damping,
-                reverb_wet_gain=args.reverb_wet_gain,
-                reverb_dry_gain=args.reverb_dry_gain,
-                reverb_width=args.reverb_width,
-                reverb_freeze_mode=args.reverb_freeze_mode,
-                pitch_shift_semitones=args.pitch_shift_semitones,
-                limiter_threshold=args.limiter_threshold,
-                limiter_release_time=args.limiter_release_time,
-                gain_db=args.gain_db,
-                distortion_gain=args.distortion_gain,
-                chorus_rate=args.chorus_rate,
-                chorus_depth=args.chorus_depth,
-                chorus_center_delay=args.chorus_center_delay,
-                chorus_feedback=args.chorus_feedback,
-                chorus_mix=args.chorus_mix,
-                bitcrush_bit_depth=args.bitcrush_bit_depth,
-                clipping_threshold=args.clipping_threshold,
-                compressor_threshold=args.compressor_threshold,
-                compressor_ratio=args.compressor_ratio,
-                compressor_attack=args.compressor_attack,
-                compressor_release=args.compressor_release,
-                delay_seconds=args.delay_seconds,
-                delay_feedback=args.delay_feedback,
-                delay_mix=args.delay_mix,
-            )
-        elif args.mode == "tts":
-            run_tts_script(
-                tts_file=args.tts_file,
-                tts_text=args.tts_text,
-                tts_voice=args.tts_voice,
-                tts_rate=args.tts_rate,
-                pitch=args.pitch,
-                filter_radius=args.filter_radius,
-                index_rate=args.index_rate,
-                volume_envelope=args.volume_envelope,
-                protect=args.protect,
-                hop_length=args.hop_length,
-                f0_method=args.f0_method,
-                output_rvc_path=args.output_rvc_path,
-                output_tts_path=args.output_tts_path,
-                pth_path=args.pth_path,
-                index_path=args.index_path,
-                split_audio=args.split_audio,
-                f0_autotune=args.f0_autotune,
-                f0_autotune_strength=args.f0_autotune_strength,
-                clean_audio=args.clean_audio,
-                clean_strength=args.clean_strength,
-                export_format=args.export_format,
-                embedder_model=args.embedder_model,
-                embedder_model_custom=args.embedder_model_custom,
-                upscale_audio=args.upscale_audio,
-                f0_file=args.f0_file,
-            )
-        elif args.mode == "preprocess":
-            run_preprocess_script(
-                model_name=args.model_name,
-                dataset_path=args.dataset_path,
-                sample_rate=args.sample_rate,
-                cpu_cores=args.cpu_cores,
-                cut_preprocess=args.cut_preprocess,
-                process_effects=args.process_effects,
-                noise_reduction=args.noise_reduction,
-                clean_strength=args.noise_reduction_strength,
-            )
-        elif args.mode == "extract":
-            run_extract_script(
-                model_name=args.model_name,
-                rvc_version=args.rvc_version,
-                f0_method=args.f0_method,
-                hop_length=args.hop_length,
-                cpu_cores=args.cpu_cores,
-                gpu=args.gpu,
-                sample_rate=args.sample_rate,
-                embedder_model=args.embedder_model,
-                embedder_model_custom=args.embedder_model_custom,
-            )
-        elif args.mode == "train":
-            run_train_script(
-                model_name=args.model_name,
-                rvc_version=args.rvc_version,
-                save_every_epoch=args.save_every_epoch,
-                save_only_latest=args.save_only_latest,
-                save_every_weights=args.save_every_weights,
-                total_epoch=args.total_epoch,
-                sample_rate=args.sample_rate,
-                batch_size=args.batch_size,
-                gpu=args.gpu,
-                pitch_guidance=args.pitch_guidance,
-                overtraining_detector=args.overtraining_detector,
-                overtraining_threshold=args.overtraining_threshold,
-                pretrained=args.pretrained,
-                custom_pretrained=args.custom_pretrained,
-                cleanup=args.cleanup,
-                index_algorithm=args.index_algorithm,
-                cache_data_in_gpu=args.cache_data_in_gpu,
-                g_pretrained_path=args.g_pretrained_path,
-                d_pretrained_path=args.d_pretrained_path,
-            )
-        elif args.mode == "index":
-            run_index_script(
-                model_name=args.model_name,
-                rvc_version=args.rvc_version,
-                index_algorithm=args.index_algorithm,
-            )
-        elif args.mode == "model_extract":
-            run_model_extract_script(
-                pth_path=args.pth_path,
-                model_name=args.model_name,
-                sample_rate=args.sample_rate,
-                pitch_guidance=args.pitch_guidance,
-                rvc_version=args.rvc_version,
-                epoch=args.epoch,
-                step=args.step,
-            )
-        elif args.mode == "model_information":
-            run_model_information_script(
-                pth_path=args.pth_path,
-            )
-        elif args.mode == "model_blender":
-            run_model_blender_script(
-                model_name=args.model_name,
-                pth_path_1=args.pth_path_1,
-                pth_path_2=args.pth_path_2,
-                ratio=args.ratio,
-            )
-        elif args.mode == "tensorboard":
-            run_tensorboard_script()
-        elif args.mode == "download":
-            run_download_script(
-                model_link=args.model_link,
-            )
-        elif args.mode == "prerequisites":
-            run_prerequisites_script(
-                pretraineds_v1_f0=args.pretraineds_v1_f0,
-                pretraineds_v1_nof0=args.pretraineds_v1_nof0,
-                pretraineds_v2_f0=args.pretraineds_v2_f0,
-                pretraineds_v2_nof0=args.pretraineds_v2_nof0,
-                models=args.models,
-                exe=args.exe,
-            )
-        elif args.mode == "audio_analyzer":
-            run_audio_analyzer_script(
-                input_path=args.input_path,
-            )
-    except Exception as error:
-        print(f"An error occurred during execution: {error}")
-
-        import traceback
-
-        traceback.print_exc()
-
-
-if __name__ == "__main__":
-    main()

poetry.lock

@@ -316,6 +316,479 @@ files = [
     {file = "blinker-1.9.0.tar.gz", hash = "sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf"},
 ]
 
+[[package]]
+name = "boto3"
+version = "1.35.70"
+description = "The AWS SDK for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "boto3-1.35.70-py3-none-any.whl", hash = "sha256:ca385708f83f01b3f27d9d675880d2458cb3b40ed1e25da688f551454ed0c112"},
+    {file = "boto3-1.35.70.tar.gz", hash = "sha256:121dce8c7102eea6a6047d46bcd74e8a24dac793a4a3857de4f4bad9c12566fd"},
+]
+
+[package.dependencies]
+botocore = ">=1.35.70,<1.36.0"
+jmespath = ">=0.7.1,<2.0.0"
+s3transfer = ">=0.10.0,<0.11.0"
+
+[package.extras]
+crt = ["botocore[crt] (>=1.21.0,<2.0a0)"]
+
+[[package]]
+name = "boto3-stubs"
+version = "1.35.70"
+description = "Type annotations for boto3 1.35.70 generated with mypy-boto3-builder 8.3.1"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "boto3_stubs-1.35.70-py3-none-any.whl", hash = "sha256:509d720396e839bf1bbe5a8786beba5b8360f79ab0faeb1ee4a3def224400ffc"},
+    {file = "boto3_stubs-1.35.70.tar.gz", hash = "sha256:920040a940accfdb5fbc7703128c0997fa5e23701f641c9ef0b43a5266f6c110"},
+]
+
+[package.dependencies]
+botocore-stubs = "*"
+types-s3transfer = "*"
+typing-extensions = {version = ">=4.1.0", markers = "python_version < \"3.12\""}
+
+[package.extras]
+accessanalyzer = ["mypy-boto3-accessanalyzer (>=1.35.0,<1.36.0)"]
+account = ["mypy-boto3-account (>=1.35.0,<1.36.0)"]
+acm = ["mypy-boto3-acm (>=1.35.0,<1.36.0)"]
+acm-pca = ["mypy-boto3-acm-pca (>=1.35.0,<1.36.0)"]
+all = ["mypy-boto3-accessanalyzer (>=1.35.0,<1.36.0)", "mypy-boto3-account (>=1.35.0,<1.36.0)", "mypy-boto3-acm (>=1.35.0,<1.36.0)", "mypy-boto3-acm-pca (>=1.35.0,<1.36.0)", "mypy-boto3-amp (>=1.35.0,<1.36.0)", "mypy-boto3-amplify (>=1.35.0,<1.36.0)", "mypy-boto3-amplifybackend (>=1.35.0,<1.36.0)", "mypy-boto3-amplifyuibuilder (>=1.35.0,<1.36.0)", "mypy-boto3-apigateway (>=1.35.0,<1.36.0)", "mypy-boto3-apigatewaymanagementapi (>=1.35.0,<1.36.0)", "mypy-boto3-apigatewayv2 (>=1.35.0,<1.36.0)", "mypy-boto3-appconfig (>=1.35.0,<1.36.0)", "mypy-boto3-appconfigdata (>=1.35.0,<1.36.0)", "mypy-boto3-appfabric (>=1.35.0,<1.36.0)", "mypy-boto3-appflow (>=1.35.0,<1.36.0)", "mypy-boto3-appintegrations (>=1.35.0,<1.36.0)", "mypy-boto3-application-autoscaling (>=1.35.0,<1.36.0)", "mypy-boto3-application-insights (>=1.35.0,<1.36.0)", "mypy-boto3-application-signals (>=1.35.0,<1.36.0)", "mypy-boto3-applicationcostprofiler (>=1.35.0,<1.36.0)", "mypy-boto3-appmesh (>=1.35.0,<1.36.0)", "mypy-boto3-apprunner (>=1.35.0,<1.36.0)", "mypy-boto3-appstream (>=1.35.0,<1.36.0)", "mypy-boto3-appsync (>=1.35.0,<1.36.0)", "mypy-boto3-apptest (>=1.35.0,<1.36.0)", "mypy-boto3-arc-zonal-shift (>=1.35.0,<1.36.0)", "mypy-boto3-artifact (>=1.35.0,<1.36.0)", "mypy-boto3-athena (>=1.35.0,<1.36.0)", "mypy-boto3-auditmanager (>=1.35.0,<1.36.0)", "mypy-boto3-autoscaling (>=1.35.0,<1.36.0)", "mypy-boto3-autoscaling-plans (>=1.35.0,<1.36.0)", "mypy-boto3-b2bi (>=1.35.0,<1.36.0)", "mypy-boto3-backup (>=1.35.0,<1.36.0)", "mypy-boto3-backup-gateway (>=1.35.0,<1.36.0)", "mypy-boto3-batch (>=1.35.0,<1.36.0)", "mypy-boto3-bcm-data-exports (>=1.35.0,<1.36.0)", "mypy-boto3-bcm-pricing-calculator (>=1.35.0,<1.36.0)", "mypy-boto3-bedrock (>=1.35.0,<1.36.0)", "mypy-boto3-bedrock-agent (>=1.35.0,<1.36.0)", "mypy-boto3-bedrock-agent-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-bedrock-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-billing (>=1.35.0,<1.36.0)", "mypy-boto3-billingconductor (>=1.35.0,<1.36.0)", "mypy-boto3-braket (>=1.35.0,<1.36.0)", "mypy-boto3-budgets (>=1.35.0,<1.36.0)", "mypy-boto3-ce (>=1.35.0,<1.36.0)", "mypy-boto3-chatbot (>=1.35.0,<1.36.0)", "mypy-boto3-chime (>=1.35.0,<1.36.0)", "mypy-boto3-chime-sdk-identity (>=1.35.0,<1.36.0)", "mypy-boto3-chime-sdk-media-pipelines (>=1.35.0,<1.36.0)", "mypy-boto3-chime-sdk-meetings (>=1.35.0,<1.36.0)", "mypy-boto3-chime-sdk-messaging (>=1.35.0,<1.36.0)", "mypy-boto3-chime-sdk-voice (>=1.35.0,<1.36.0)", "mypy-boto3-cleanrooms (>=1.35.0,<1.36.0)", "mypy-boto3-cleanroomsml (>=1.35.0,<1.36.0)", "mypy-boto3-cloud9 (>=1.35.0,<1.36.0)", "mypy-boto3-cloudcontrol (>=1.35.0,<1.36.0)", "mypy-boto3-clouddirectory (>=1.35.0,<1.36.0)", "mypy-boto3-cloudformation (>=1.35.0,<1.36.0)", "mypy-boto3-cloudfront (>=1.35.0,<1.36.0)", "mypy-boto3-cloudfront-keyvaluestore (>=1.35.0,<1.36.0)", "mypy-boto3-cloudhsm (>=1.35.0,<1.36.0)", "mypy-boto3-cloudhsmv2 (>=1.35.0,<1.36.0)", "mypy-boto3-cloudsearch (>=1.35.0,<1.36.0)", "mypy-boto3-cloudsearchdomain (>=1.35.0,<1.36.0)", "mypy-boto3-cloudtrail (>=1.35.0,<1.36.0)", "mypy-boto3-cloudtrail-data (>=1.35.0,<1.36.0)", "mypy-boto3-cloudwatch (>=1.35.0,<1.36.0)", "mypy-boto3-codeartifact (>=1.35.0,<1.36.0)", "mypy-boto3-codebuild (>=1.35.0,<1.36.0)", "mypy-boto3-codecatalyst (>=1.35.0,<1.36.0)", "mypy-boto3-codecommit (>=1.35.0,<1.36.0)", "mypy-boto3-codeconnections (>=1.35.0,<1.36.0)", "mypy-boto3-codedeploy (>=1.35.0,<1.36.0)", "mypy-boto3-codeguru-reviewer (>=1.35.0,<1.36.0)", "mypy-boto3-codeguru-security (>=1.35.0,<1.36.0)", "mypy-boto3-codeguruprofiler (>=1.35.0,<1.36.0)", "mypy-boto3-codepipeline (>=1.35.0,<1.36.0)", "mypy-boto3-codestar-connections (>=1.35.0,<1.36.0)", "mypy-boto3-codestar-notifications (>=1.35.0,<1.36.0)", "mypy-boto3-cognito-identity (>=1.35.0,<1.36.0)", "mypy-boto3-cognito-idp (>=1.35.0,<1.36.0)", "mypy-boto3-cognito-sync (>=1.35.0,<1.36.0)", "mypy-boto3-comprehend (>=1.35.0,<1.36.0)", "mypy-boto3-comprehendmedical (>=1.35.0,<1.36.0)", "mypy-boto3-compute-optimizer (>=1.35.0,<1.36.0)", "mypy-boto3-config (>=1.35.0,<1.36.0)", "mypy-boto3-connect (>=1.35.0,<1.36.0)", "mypy-boto3-connect-contact-lens (>=1.35.0,<1.36.0)", "mypy-boto3-connectcampaigns (>=1.35.0,<1.36.0)", "mypy-boto3-connectcampaignsv2 (>=1.35.0,<1.36.0)", "mypy-boto3-connectcases (>=1.35.0,<1.36.0)", "mypy-boto3-connectparticipant (>=1.35.0,<1.36.0)", "mypy-boto3-controlcatalog (>=1.35.0,<1.36.0)", "mypy-boto3-controltower (>=1.35.0,<1.36.0)", "mypy-boto3-cost-optimization-hub (>=1.35.0,<1.36.0)", "mypy-boto3-cur (>=1.35.0,<1.36.0)", "mypy-boto3-customer-profiles (>=1.35.0,<1.36.0)", "mypy-boto3-databrew (>=1.35.0,<1.36.0)", "mypy-boto3-dataexchange (>=1.35.0,<1.36.0)", "mypy-boto3-datapipeline (>=1.35.0,<1.36.0)", "mypy-boto3-datasync (>=1.35.0,<1.36.0)", "mypy-boto3-datazone (>=1.35.0,<1.36.0)", "mypy-boto3-dax (>=1.35.0,<1.36.0)", "mypy-boto3-deadline (>=1.35.0,<1.36.0)", "mypy-boto3-detective (>=1.35.0,<1.36.0)", "mypy-boto3-devicefarm (>=1.35.0,<1.36.0)", "mypy-boto3-devops-guru (>=1.35.0,<1.36.0)", "mypy-boto3-directconnect (>=1.35.0,<1.36.0)", "mypy-boto3-discovery (>=1.35.0,<1.36.0)", "mypy-boto3-dlm (>=1.35.0,<1.36.0)", "mypy-boto3-dms (>=1.35.0,<1.36.0)", "mypy-boto3-docdb (>=1.35.0,<1.36.0)", "mypy-boto3-docdb-elastic (>=1.35.0,<1.36.0)", "mypy-boto3-drs (>=1.35.0,<1.36.0)", "mypy-boto3-ds (>=1.35.0,<1.36.0)", "mypy-boto3-ds-data (>=1.35.0,<1.36.0)", "mypy-boto3-dynamodb (>=1.35.0,<1.36.0)", "mypy-boto3-dynamodbstreams (>=1.35.0,<1.36.0)", "mypy-boto3-ebs (>=1.35.0,<1.36.0)", "mypy-boto3-ec2 (>=1.35.0,<1.36.0)", "mypy-boto3-ec2-instance-connect (>=1.35.0,<1.36.0)", "mypy-boto3-ecr (>=1.35.0,<1.36.0)", "mypy-boto3-ecr-public (>=1.35.0,<1.36.0)", "mypy-boto3-ecs (>=1.35.0,<1.36.0)", "mypy-boto3-efs (>=1.35.0,<1.36.0)", "mypy-boto3-eks (>=1.35.0,<1.36.0)", "mypy-boto3-eks-auth (>=1.35.0,<1.36.0)", "mypy-boto3-elastic-inference (>=1.35.0,<1.36.0)", "mypy-boto3-elasticache (>=1.35.0,<1.36.0)", "mypy-boto3-elasticbeanstalk (>=1.35.0,<1.36.0)", "mypy-boto3-elastictranscoder (>=1.35.0,<1.36.0)", "mypy-boto3-elb (>=1.35.0,<1.36.0)", "mypy-boto3-elbv2 (>=1.35.0,<1.36.0)", "mypy-boto3-emr (>=1.35.0,<1.36.0)", "mypy-boto3-emr-containers (>=1.35.0,<1.36.0)", "mypy-boto3-emr-serverless (>=1.35.0,<1.36.0)", "mypy-boto3-entityresolution (>=1.35.0,<1.36.0)", "mypy-boto3-es (>=1.35.0,<1.36.0)", "mypy-boto3-events (>=1.35.0,<1.36.0)", "mypy-boto3-evidently (>=1.35.0,<1.36.0)", "mypy-boto3-finspace (>=1.35.0,<1.36.0)", "mypy-boto3-finspace-data (>=1.35.0,<1.36.0)", "mypy-boto3-firehose (>=1.35.0,<1.36.0)", "mypy-boto3-fis (>=1.35.0,<1.36.0)", "mypy-boto3-fms (>=1.35.0,<1.36.0)", "mypy-boto3-forecast (>=1.35.0,<1.36.0)", "mypy-boto3-forecastquery (>=1.35.0,<1.36.0)", "mypy-boto3-frauddetector (>=1.35.0,<1.36.0)", "mypy-boto3-freetier (>=1.35.0,<1.36.0)", "mypy-boto3-fsx (>=1.35.0,<1.36.0)", "mypy-boto3-gamelift (>=1.35.0,<1.36.0)", "mypy-boto3-geo-maps (>=1.35.0,<1.36.0)", "mypy-boto3-geo-places (>=1.35.0,<1.36.0)", "mypy-boto3-geo-routes (>=1.35.0,<1.36.0)", "mypy-boto3-glacier (>=1.35.0,<1.36.0)", "mypy-boto3-globalaccelerator (>=1.35.0,<1.36.0)", "mypy-boto3-glue (>=1.35.0,<1.36.0)", "mypy-boto3-grafana (>=1.35.0,<1.36.0)", "mypy-boto3-greengrass (>=1.35.0,<1.36.0)", "mypy-boto3-greengrassv2 (>=1.35.0,<1.36.0)", "mypy-boto3-groundstation (>=1.35.0,<1.36.0)", "mypy-boto3-guardduty (>=1.35.0,<1.36.0)", "mypy-boto3-health (>=1.35.0,<1.36.0)", "mypy-boto3-healthlake (>=1.35.0,<1.36.0)", "mypy-boto3-iam (>=1.35.0,<1.36.0)", "mypy-boto3-identitystore (>=1.35.0,<1.36.0)", "mypy-boto3-imagebuilder (>=1.35.0,<1.36.0)", "mypy-boto3-importexport (>=1.35.0,<1.36.0)", "mypy-boto3-inspector (>=1.35.0,<1.36.0)", "mypy-boto3-inspector-scan (>=1.35.0,<1.36.0)", "mypy-boto3-inspector2 (>=1.35.0,<1.36.0)", "mypy-boto3-internetmonitor (>=1.35.0,<1.36.0)", "mypy-boto3-iot (>=1.35.0,<1.36.0)", "mypy-boto3-iot-data (>=1.35.0,<1.36.0)", "mypy-boto3-iot-jobs-data (>=1.35.0,<1.36.0)", "mypy-boto3-iot1click-devices (>=1.35.0,<1.36.0)", "mypy-boto3-iot1click-projects (>=1.35.0,<1.36.0)", "mypy-boto3-iotanalytics (>=1.35.0,<1.36.0)", "mypy-boto3-iotdeviceadvisor (>=1.35.0,<1.36.0)", "mypy-boto3-iotevents (>=1.35.0,<1.36.0)", "mypy-boto3-iotevents-data (>=1.35.0,<1.36.0)", "mypy-boto3-iotfleethub (>=1.35.0,<1.36.0)", "mypy-boto3-iotfleetwise (>=1.35.0,<1.36.0)", "mypy-boto3-iotsecuretunneling (>=1.35.0,<1.36.0)", "mypy-boto3-iotsitewise (>=1.35.0,<1.36.0)", "mypy-boto3-iotthingsgraph (>=1.35.0,<1.36.0)", "mypy-boto3-iottwinmaker (>=1.35.0,<1.36.0)", "mypy-boto3-iotwireless (>=1.35.0,<1.36.0)", "mypy-boto3-ivs (>=1.35.0,<1.36.0)", "mypy-boto3-ivs-realtime (>=1.35.0,<1.36.0)", "mypy-boto3-ivschat (>=1.35.0,<1.36.0)", "mypy-boto3-kafka (>=1.35.0,<1.36.0)", "mypy-boto3-kafkaconnect (>=1.35.0,<1.36.0)", "mypy-boto3-kendra (>=1.35.0,<1.36.0)", "mypy-boto3-kendra-ranking (>=1.35.0,<1.36.0)", "mypy-boto3-keyspaces (>=1.35.0,<1.36.0)", "mypy-boto3-kinesis (>=1.35.0,<1.36.0)", "mypy-boto3-kinesis-video-archived-media (>=1.35.0,<1.36.0)", "mypy-boto3-kinesis-video-media (>=1.35.0,<1.36.0)", "mypy-boto3-kinesis-video-signaling (>=1.35.0,<1.36.0)", "mypy-boto3-kinesis-video-webrtc-storage (>=1.35.0,<1.36.0)", "mypy-boto3-kinesisanalytics (>=1.35.0,<1.36.0)", "mypy-boto3-kinesisanalyticsv2 (>=1.35.0,<1.36.0)", "mypy-boto3-kinesisvideo (>=1.35.0,<1.36.0)", "mypy-boto3-kms (>=1.35.0,<1.36.0)", "mypy-boto3-lakeformation (>=1.35.0,<1.36.0)", "mypy-boto3-lambda (>=1.35.0,<1.36.0)", "mypy-boto3-launch-wizard (>=1.35.0,<1.36.0)", "mypy-boto3-lex-models (>=1.35.0,<1.36.0)", "mypy-boto3-lex-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-lexv2-models (>=1.35.0,<1.36.0)", "mypy-boto3-lexv2-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-license-manager (>=1.35.0,<1.36.0)", "mypy-boto3-license-manager-linux-subscriptions (>=1.35.0,<1.36.0)", "mypy-boto3-license-manager-user-subscriptions (>=1.35.0,<1.36.0)", "mypy-boto3-lightsail (>=1.35.0,<1.36.0)", "mypy-boto3-location (>=1.35.0,<1.36.0)", "mypy-boto3-logs (>=1.35.0,<1.36.0)", "mypy-boto3-lookoutequipment (>=1.35.0,<1.36.0)", "mypy-boto3-lookoutmetrics (>=1.35.0,<1.36.0)", "mypy-boto3-lookoutvision (>=1.35.0,<1.36.0)", "mypy-boto3-m2 (>=1.35.0,<1.36.0)", "mypy-boto3-machinelearning (>=1.35.0,<1.36.0)", "mypy-boto3-macie2 (>=1.35.0,<1.36.0)", "mypy-boto3-mailmanager (>=1.35.0,<1.36.0)", "mypy-boto3-managedblockchain (>=1.35.0,<1.36.0)", "mypy-boto3-managedblockchain-query (>=1.35.0,<1.36.0)", "mypy-boto3-marketplace-agreement (>=1.35.0,<1.36.0)", "mypy-boto3-marketplace-catalog (>=1.35.0,<1.36.0)", "mypy-boto3-marketplace-deployment (>=1.35.0,<1.36.0)", "mypy-boto3-marketplace-entitlement (>=1.35.0,<1.36.0)", "mypy-boto3-marketplace-reporting (>=1.35.0,<1.36.0)", "mypy-boto3-marketplacecommerceanalytics (>=1.35.0,<1.36.0)", "mypy-boto3-mediaconnect (>=1.35.0,<1.36.0)", "mypy-boto3-mediaconvert (>=1.35.0,<1.36.0)", "mypy-boto3-medialive (>=1.35.0,<1.36.0)", "mypy-boto3-mediapackage (>=1.35.0,<1.36.0)", "mypy-boto3-mediapackage-vod (>=1.35.0,<1.36.0)", "mypy-boto3-mediapackagev2 (>=1.35.0,<1.36.0)", "mypy-boto3-mediastore (>=1.35.0,<1.36.0)", "mypy-boto3-mediastore-data (>=1.35.0,<1.36.0)", "mypy-boto3-mediatailor (>=1.35.0,<1.36.0)", "mypy-boto3-medical-imaging (>=1.35.0,<1.36.0)", "mypy-boto3-memorydb (>=1.35.0,<1.36.0)", "mypy-boto3-meteringmarketplace (>=1.35.0,<1.36.0)", "mypy-boto3-mgh (>=1.35.0,<1.36.0)", "mypy-boto3-mgn (>=1.35.0,<1.36.0)", "mypy-boto3-migration-hub-refactor-spaces (>=1.35.0,<1.36.0)", "mypy-boto3-migrationhub-config (>=1.35.0,<1.36.0)", "mypy-boto3-migrationhuborchestrator (>=1.35.0,<1.36.0)", "mypy-boto3-migrationhubstrategy (>=1.35.0,<1.36.0)", "mypy-boto3-mq (>=1.35.0,<1.36.0)", "mypy-boto3-mturk (>=1.35.0,<1.36.0)", "mypy-boto3-mwaa (>=1.35.0,<1.36.0)", "mypy-boto3-neptune (>=1.35.0,<1.36.0)", "mypy-boto3-neptune-graph (>=1.35.0,<1.36.0)", "mypy-boto3-neptunedata (>=1.35.0,<1.36.0)", "mypy-boto3-network-firewall (>=1.35.0,<1.36.0)", "mypy-boto3-networkmanager (>=1.35.0,<1.36.0)", "mypy-boto3-networkmonitor (>=1.35.0,<1.36.0)", "mypy-boto3-notifications (>=1.35.0,<1.36.0)", "mypy-boto3-notificationscontacts (>=1.35.0,<1.36.0)", "mypy-boto3-oam (>=1.35.0,<1.36.0)", "mypy-boto3-omics (>=1.35.0,<1.36.0)", "mypy-boto3-opensearch (>=1.35.0,<1.36.0)", "mypy-boto3-opensearchserverless (>=1.35.0,<1.36.0)", "mypy-boto3-opsworks (>=1.35.0,<1.36.0)", "mypy-boto3-opsworkscm (>=1.35.0,<1.36.0)", "mypy-boto3-organizations (>=1.35.0,<1.36.0)", "mypy-boto3-osis (>=1.35.0,<1.36.0)", "mypy-boto3-outposts (>=1.35.0,<1.36.0)", "mypy-boto3-panorama (>=1.35.0,<1.36.0)", "mypy-boto3-partnercentral-selling (>=1.35.0,<1.36.0)", "mypy-boto3-payment-cryptography (>=1.35.0,<1.36.0)", "mypy-boto3-payment-cryptography-data (>=1.35.0,<1.36.0)", "mypy-boto3-pca-connector-ad (>=1.35.0,<1.36.0)", "mypy-boto3-pca-connector-scep (>=1.35.0,<1.36.0)", "mypy-boto3-pcs (>=1.35.0,<1.36.0)", "mypy-boto3-personalize (>=1.35.0,<1.36.0)", "mypy-boto3-personalize-events (>=1.35.0,<1.36.0)", "mypy-boto3-personalize-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-pi (>=1.35.0,<1.36.0)", "mypy-boto3-pinpoint (>=1.35.0,<1.36.0)", "mypy-boto3-pinpoint-email (>=1.35.0,<1.36.0)", "mypy-boto3-pinpoint-sms-voice (>=1.35.0,<1.36.0)", "mypy-boto3-pinpoint-sms-voice-v2 (>=1.35.0,<1.36.0)", "mypy-boto3-pipes (>=1.35.0,<1.36.0)", "mypy-boto3-polly (>=1.35.0,<1.36.0)", "mypy-boto3-pricing (>=1.35.0,<1.36.0)", "mypy-boto3-privatenetworks (>=1.35.0,<1.36.0)", "mypy-boto3-proton (>=1.35.0,<1.36.0)", "mypy-boto3-qapps (>=1.35.0,<1.36.0)", "mypy-boto3-qbusiness (>=1.35.0,<1.36.0)", "mypy-boto3-qconnect (>=1.35.0,<1.36.0)", "mypy-boto3-qldb (>=1.35.0,<1.36.0)", "mypy-boto3-qldb-session (>=1.35.0,<1.36.0)", "mypy-boto3-quicksight (>=1.35.0,<1.36.0)", "mypy-boto3-ram (>=1.35.0,<1.36.0)", "mypy-boto3-rbin (>=1.35.0,<1.36.0)", "mypy-boto3-rds (>=1.35.0,<1.36.0)", "mypy-boto3-rds-data (>=1.35.0,<1.36.0)", "mypy-boto3-redshift (>=1.35.0,<1.36.0)", "mypy-boto3-redshift-data (>=1.35.0,<1.36.0)", "mypy-boto3-redshift-serverless (>=1.35.0,<1.36.0)", "mypy-boto3-rekognition (>=1.35.0,<1.36.0)", "mypy-boto3-repostspace (>=1.35.0,<1.36.0)", "mypy-boto3-resiliencehub (>=1.35.0,<1.36.0)", "mypy-boto3-resource-explorer-2 (>=1.35.0,<1.36.0)", "mypy-boto3-resource-groups (>=1.35.0,<1.36.0)", "mypy-boto3-resourcegroupstaggingapi (>=1.35.0,<1.36.0)", "mypy-boto3-robomaker (>=1.35.0,<1.36.0)", "mypy-boto3-rolesanywhere (>=1.35.0,<1.36.0)", "mypy-boto3-route53 (>=1.35.0,<1.36.0)", "mypy-boto3-route53-recovery-cluster (>=1.35.0,<1.36.0)", "mypy-boto3-route53-recovery-control-config (>=1.35.0,<1.36.0)", "mypy-boto3-route53-recovery-readiness (>=1.35.0,<1.36.0)", "mypy-boto3-route53domains (>=1.35.0,<1.36.0)", "mypy-boto3-route53profiles (>=1.35.0,<1.36.0)", "mypy-boto3-route53resolver (>=1.35.0,<1.36.0)", "mypy-boto3-rum (>=1.35.0,<1.36.0)", "mypy-boto3-s3 (>=1.35.0,<1.36.0)", "mypy-boto3-s3control (>=1.35.0,<1.36.0)", "mypy-boto3-s3outposts (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-a2i-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-edge (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-featurestore-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-geospatial (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-metrics (>=1.35.0,<1.36.0)", "mypy-boto3-sagemaker-runtime (>=1.35.0,<1.36.0)", "mypy-boto3-savingsplans (>=1.35.0,<1.36.0)", "mypy-boto3-scheduler (>=1.35.0,<1.36.0)", "mypy-boto3-schemas (>=1.35.0,<1.36.0)", "mypy-boto3-sdb (>=1.35.0,<1.36.0)", "mypy-boto3-secretsmanager (>=1.35.0,<1.36.0)", "mypy-boto3-securityhub (>=1.35.0,<1.36.0)", "mypy-boto3-securitylake (>=1.35.0,<1.36.0)", "mypy-boto3-serverlessrepo (>=1.35.0,<1.36.0)", "mypy-boto3-service-quotas (>=1.35.0,<1.36.0)", "mypy-boto3-servicecatalog (>=1.35.0,<1.36.0)", "mypy-boto3-servicecatalog-appregistry (>=1.35.0,<1.36.0)", "mypy-boto3-servicediscovery (>=1.35.0,<1.36.0)", "mypy-boto3-ses (>=1.35.0,<1.36.0)", "mypy-boto3-sesv2 (>=1.35.0,<1.36.0)", "mypy-boto3-shield (>=1.35.0,<1.36.0)", "mypy-boto3-signer (>=1.35.0,<1.36.0)", "mypy-boto3-simspaceweaver (>=1.35.0,<1.36.0)", "mypy-boto3-sms (>=1.35.0,<1.36.0)", "mypy-boto3-sms-voice (>=1.35.0,<1.36.0)", "mypy-boto3-snow-device-management (>=1.35.0,<1.36.0)", "mypy-boto3-snowball (>=1.35.0,<1.36.0)", "mypy-boto3-sns (>=1.35.0,<1.36.0)", "mypy-boto3-socialmessaging (>=1.35.0,<1.36.0)", "mypy-boto3-sqs (>=1.35.0,<1.36.0)", "mypy-boto3-ssm (>=1.35.0,<1.36.0)", "mypy-boto3-ssm-contacts (>=1.35.0,<1.36.0)", "mypy-boto3-ssm-incidents (>=1.35.0,<1.36.0)", "mypy-boto3-ssm-quicksetup (>=1.35.0,<1.36.0)", "mypy-boto3-ssm-sap (>=1.35.0,<1.36.0)", "mypy-boto3-sso (>=1.35.0,<1.36.0)", "mypy-boto3-sso-admin (>=1.35.0,<1.36.0)", "mypy-boto3-sso-oidc (>=1.35.0,<1.36.0)", "mypy-boto3-stepfunctions (>=1.35.0,<1.36.0)", "mypy-boto3-storagegateway (>=1.35.0,<1.36.0)", "mypy-boto3-sts (>=1.35.0,<1.36.0)", "mypy-boto3-supplychain (>=1.35.0,<1.36.0)", "mypy-boto3-support (>=1.35.0,<1.36.0)", "mypy-boto3-support-app (>=1.35.0,<1.36.0)", "mypy-boto3-swf (>=1.35.0,<1.36.0)", "mypy-boto3-synthetics (>=1.35.0,<1.36.0)", "mypy-boto3-taxsettings (>=1.35.0,<1.36.0)", "mypy-boto3-textract (>=1.35.0,<1.36.0)", "mypy-boto3-timestream-influxdb (>=1.35.0,<1.36.0)", "mypy-boto3-timestream-query (>=1.35.0,<1.36.0)", "mypy-boto3-timestream-write (>=1.35.0,<1.36.0)", "mypy-boto3-tnb (>=1.35.0,<1.36.0)", "mypy-boto3-transcribe (>=1.35.0,<1.36.0)", "mypy-boto3-transfer (>=1.35.0,<1.36.0)", "mypy-boto3-translate (>=1.35.0,<1.36.0)", "mypy-boto3-trustedadvisor (>=1.35.0,<1.36.0)", "mypy-boto3-verifiedpermissions (>=1.35.0,<1.36.0)", "mypy-boto3-voice-id (>=1.35.0,<1.36.0)", "mypy-boto3-vpc-lattice (>=1.35.0,<1.36.0)", "mypy-boto3-waf (>=1.35.0,<1.36.0)", "mypy-boto3-waf-regional (>=1.35.0,<1.36.0)", "mypy-boto3-wafv2 (>=1.35.0,<1.36.0)", "mypy-boto3-wellarchitected (>=1.35.0,<1.36.0)", "mypy-boto3-wisdom (>=1.35.0,<1.36.0)", "mypy-boto3-workdocs (>=1.35.0,<1.36.0)", "mypy-boto3-workmail (>=1.35.0,<1.36.0)", "mypy-boto3-workmailmessageflow (>=1.35.0,<1.36.0)", "mypy-boto3-workspaces (>=1.35.0,<1.36.0)", "mypy-boto3-workspaces-thin-client (>=1.35.0,<1.36.0)", "mypy-boto3-workspaces-web (>=1.35.0,<1.36.0)", "mypy-boto3-xray (>=1.35.0,<1.36.0)"]
+amp = ["mypy-boto3-amp (>=1.35.0,<1.36.0)"]
+amplify = ["mypy-boto3-amplify (>=1.35.0,<1.36.0)"]
+amplifybackend = ["mypy-boto3-amplifybackend (>=1.35.0,<1.36.0)"]
+amplifyuibuilder = ["mypy-boto3-amplifyuibuilder (>=1.35.0,<1.36.0)"]
+apigateway = ["mypy-boto3-apigateway (>=1.35.0,<1.36.0)"]
+apigatewaymanagementapi = ["mypy-boto3-apigatewaymanagementapi (>=1.35.0,<1.36.0)"]
+apigatewayv2 = ["mypy-boto3-apigatewayv2 (>=1.35.0,<1.36.0)"]
+appconfig = ["mypy-boto3-appconfig (>=1.35.0,<1.36.0)"]
+appconfigdata = ["mypy-boto3-appconfigdata (>=1.35.0,<1.36.0)"]
+appfabric = ["mypy-boto3-appfabric (>=1.35.0,<1.36.0)"]
+appflow = ["mypy-boto3-appflow (>=1.35.0,<1.36.0)"]
+appintegrations = ["mypy-boto3-appintegrations (>=1.35.0,<1.36.0)"]
+application-autoscaling = ["mypy-boto3-application-autoscaling (>=1.35.0,<1.36.0)"]
+application-insights = ["mypy-boto3-application-insights (>=1.35.0,<1.36.0)"]
+application-signals = ["mypy-boto3-application-signals (>=1.35.0,<1.36.0)"]
+applicationcostprofiler = ["mypy-boto3-applicationcostprofiler (>=1.35.0,<1.36.0)"]
+appmesh = ["mypy-boto3-appmesh (>=1.35.0,<1.36.0)"]
+apprunner = ["mypy-boto3-apprunner (>=1.35.0,<1.36.0)"]
+appstream = ["mypy-boto3-appstream (>=1.35.0,<1.36.0)"]
+appsync = ["mypy-boto3-appsync (>=1.35.0,<1.36.0)"]
+apptest = ["mypy-boto3-apptest (>=1.35.0,<1.36.0)"]
+arc-zonal-shift = ["mypy-boto3-arc-zonal-shift (>=1.35.0,<1.36.0)"]
+artifact = ["mypy-boto3-artifact (>=1.35.0,<1.36.0)"]
+athena = ["mypy-boto3-athena (>=1.35.0,<1.36.0)"]
+auditmanager = ["mypy-boto3-auditmanager (>=1.35.0,<1.36.0)"]
+autoscaling = ["mypy-boto3-autoscaling (>=1.35.0,<1.36.0)"]
+autoscaling-plans = ["mypy-boto3-autoscaling-plans (>=1.35.0,<1.36.0)"]
+b2bi = ["mypy-boto3-b2bi (>=1.35.0,<1.36.0)"]
+backup = ["mypy-boto3-backup (>=1.35.0,<1.36.0)"]
+backup-gateway = ["mypy-boto3-backup-gateway (>=1.35.0,<1.36.0)"]
+batch = ["mypy-boto3-batch (>=1.35.0,<1.36.0)"]
+bcm-data-exports = ["mypy-boto3-bcm-data-exports (>=1.35.0,<1.36.0)"]
+bcm-pricing-calculator = ["mypy-boto3-bcm-pricing-calculator (>=1.35.0,<1.36.0)"]
+bedrock = ["mypy-boto3-bedrock (>=1.35.0,<1.36.0)"]
+bedrock-agent = ["mypy-boto3-bedrock-agent (>=1.35.0,<1.36.0)"]
+bedrock-agent-runtime = ["mypy-boto3-bedrock-agent-runtime (>=1.35.0,<1.36.0)"]
+bedrock-runtime = ["mypy-boto3-bedrock-runtime (>=1.35.0,<1.36.0)"]
+billing = ["mypy-boto3-billing (>=1.35.0,<1.36.0)"]
+billingconductor = ["mypy-boto3-billingconductor (>=1.35.0,<1.36.0)"]
+boto3 = ["boto3 (==1.35.70)", "botocore (==1.35.70)"]
+braket = ["mypy-boto3-braket (>=1.35.0,<1.36.0)"]
+budgets = ["mypy-boto3-budgets (>=1.35.0,<1.36.0)"]
+ce = ["mypy-boto3-ce (>=1.35.0,<1.36.0)"]
+chatbot = ["mypy-boto3-chatbot (>=1.35.0,<1.36.0)"]
+chime = ["mypy-boto3-chime (>=1.35.0,<1.36.0)"]
+chime-sdk-identity = ["mypy-boto3-chime-sdk-identity (>=1.35.0,<1.36.0)"]
+chime-sdk-media-pipelines = ["mypy-boto3-chime-sdk-media-pipelines (>=1.35.0,<1.36.0)"]
+chime-sdk-meetings = ["mypy-boto3-chime-sdk-meetings (>=1.35.0,<1.36.0)"]
+chime-sdk-messaging = ["mypy-boto3-chime-sdk-messaging (>=1.35.0,<1.36.0)"]
+chime-sdk-voice = ["mypy-boto3-chime-sdk-voice (>=1.35.0,<1.36.0)"]
+cleanrooms = ["mypy-boto3-cleanrooms (>=1.35.0,<1.36.0)"]
+cleanroomsml = ["mypy-boto3-cleanroomsml (>=1.35.0,<1.36.0)"]
+cloud9 = ["mypy-boto3-cloud9 (>=1.35.0,<1.36.0)"]
+cloudcontrol = ["mypy-boto3-cloudcontrol (>=1.35.0,<1.36.0)"]
+clouddirectory = ["mypy-boto3-clouddirectory (>=1.35.0,<1.36.0)"]
+cloudformation = ["mypy-boto3-cloudformation (>=1.35.0,<1.36.0)"]
+cloudfront = ["mypy-boto3-cloudfront (>=1.35.0,<1.36.0)"]
+cloudfront-keyvaluestore = ["mypy-boto3-cloudfront-keyvaluestore (>=1.35.0,<1.36.0)"]
+cloudhsm = ["mypy-boto3-cloudhsm (>=1.35.0,<1.36.0)"]
+cloudhsmv2 = ["mypy-boto3-cloudhsmv2 (>=1.35.0,<1.36.0)"]
+cloudsearch = ["mypy-boto3-cloudsearch (>=1.35.0,<1.36.0)"]
+cloudsearchdomain = ["mypy-boto3-cloudsearchdomain (>=1.35.0,<1.36.0)"]
+cloudtrail = ["mypy-boto3-cloudtrail (>=1.35.0,<1.36.0)"]
+cloudtrail-data = ["mypy-boto3-cloudtrail-data (>=1.35.0,<1.36.0)"]
+cloudwatch = ["mypy-boto3-cloudwatch (>=1.35.0,<1.36.0)"]
+codeartifact = ["mypy-boto3-codeartifact (>=1.35.0,<1.36.0)"]
+codebuild = ["mypy-boto3-codebuild (>=1.35.0,<1.36.0)"]
+codecatalyst = ["mypy-boto3-codecatalyst (>=1.35.0,<1.36.0)"]
+codecommit = ["mypy-boto3-codecommit (>=1.35.0,<1.36.0)"]
+codeconnections = ["mypy-boto3-codeconnections (>=1.35.0,<1.36.0)"]
+codedeploy = ["mypy-boto3-codedeploy (>=1.35.0,<1.36.0)"]
+codeguru-reviewer = ["mypy-boto3-codeguru-reviewer (>=1.35.0,<1.36.0)"]
+codeguru-security = ["mypy-boto3-codeguru-security (>=1.35.0,<1.36.0)"]
+codeguruprofiler = ["mypy-boto3-codeguruprofiler (>=1.35.0,<1.36.0)"]
+codepipeline = ["mypy-boto3-codepipeline (>=1.35.0,<1.36.0)"]
+codestar-connections = ["mypy-boto3-codestar-connections (>=1.35.0,<1.36.0)"]
+codestar-notifications = ["mypy-boto3-codestar-notifications (>=1.35.0,<1.36.0)"]
+cognito-identity = ["mypy-boto3-cognito-identity (>=1.35.0,<1.36.0)"]
+cognito-idp = ["mypy-boto3-cognito-idp (>=1.35.0,<1.36.0)"]
+cognito-sync = ["mypy-boto3-cognito-sync (>=1.35.0,<1.36.0)"]
+comprehend = ["mypy-boto3-comprehend (>=1.35.0,<1.36.0)"]
+comprehendmedical = ["mypy-boto3-comprehendmedical (>=1.35.0,<1.36.0)"]
+compute-optimizer = ["mypy-boto3-compute-optimizer (>=1.35.0,<1.36.0)"]
+config = ["mypy-boto3-config (>=1.35.0,<1.36.0)"]
+connect = ["mypy-boto3-connect (>=1.35.0,<1.36.0)"]
+connect-contact-lens = ["mypy-boto3-connect-contact-lens (>=1.35.0,<1.36.0)"]
+connectcampaigns = ["mypy-boto3-connectcampaigns (>=1.35.0,<1.36.0)"]
+connectcampaignsv2 = ["mypy-boto3-connectcampaignsv2 (>=1.35.0,<1.36.0)"]
+connectcases = ["mypy-boto3-connectcases (>=1.35.0,<1.36.0)"]
+connectparticipant = ["mypy-boto3-connectparticipant (>=1.35.0,<1.36.0)"]
+controlcatalog = ["mypy-boto3-controlcatalog (>=1.35.0,<1.36.0)"]
+controltower = ["mypy-boto3-controltower (>=1.35.0,<1.36.0)"]
+cost-optimization-hub = ["mypy-boto3-cost-optimization-hub (>=1.35.0,<1.36.0)"]
+cur = ["mypy-boto3-cur (>=1.35.0,<1.36.0)"]
+customer-profiles = ["mypy-boto3-customer-profiles (>=1.35.0,<1.36.0)"]
+databrew = ["mypy-boto3-databrew (>=1.35.0,<1.36.0)"]
+dataexchange = ["mypy-boto3-dataexchange (>=1.35.0,<1.36.0)"]
+datapipeline = ["mypy-boto3-datapipeline (>=1.35.0,<1.36.0)"]
+datasync = ["mypy-boto3-datasync (>=1.35.0,<1.36.0)"]
+datazone = ["mypy-boto3-datazone (>=1.35.0,<1.36.0)"]
+dax = ["mypy-boto3-dax (>=1.35.0,<1.36.0)"]
+deadline = ["mypy-boto3-deadline (>=1.35.0,<1.36.0)"]
+detective = ["mypy-boto3-detective (>=1.35.0,<1.36.0)"]
+devicefarm = ["mypy-boto3-devicefarm (>=1.35.0,<1.36.0)"]
+devops-guru = ["mypy-boto3-devops-guru (>=1.35.0,<1.36.0)"]
+directconnect = ["mypy-boto3-directconnect (>=1.35.0,<1.36.0)"]
+discovery = ["mypy-boto3-discovery (>=1.35.0,<1.36.0)"]
+dlm = ["mypy-boto3-dlm (>=1.35.0,<1.36.0)"]
+dms = ["mypy-boto3-dms (>=1.35.0,<1.36.0)"]
+docdb = ["mypy-boto3-docdb (>=1.35.0,<1.36.0)"]
+docdb-elastic = ["mypy-boto3-docdb-elastic (>=1.35.0,<1.36.0)"]
+drs = ["mypy-boto3-drs (>=1.35.0,<1.36.0)"]
+ds = ["mypy-boto3-ds (>=1.35.0,<1.36.0)"]
+ds-data = ["mypy-boto3-ds-data (>=1.35.0,<1.36.0)"]
+dynamodb = ["mypy-boto3-dynamodb (>=1.35.0,<1.36.0)"]
+dynamodbstreams = ["mypy-boto3-dynamodbstreams (>=1.35.0,<1.36.0)"]
+ebs = ["mypy-boto3-ebs (>=1.35.0,<1.36.0)"]
+ec2 = ["mypy-boto3-ec2 (>=1.35.0,<1.36.0)"]
+ec2-instance-connect = ["mypy-boto3-ec2-instance-connect (>=1.35.0,<1.36.0)"]
+ecr = ["mypy-boto3-ecr (>=1.35.0,<1.36.0)"]
+ecr-public = ["mypy-boto3-ecr-public (>=1.35.0,<1.36.0)"]
+ecs = ["mypy-boto3-ecs (>=1.35.0,<1.36.0)"]
+efs = ["mypy-boto3-efs (>=1.35.0,<1.36.0)"]
+eks = ["mypy-boto3-eks (>=1.35.0,<1.36.0)"]
+eks-auth = ["mypy-boto3-eks-auth (>=1.35.0,<1.36.0)"]
+elastic-inference = ["mypy-boto3-elastic-inference (>=1.35.0,<1.36.0)"]
+elasticache = ["mypy-boto3-elasticache (>=1.35.0,<1.36.0)"]
+elasticbeanstalk = ["mypy-boto3-elasticbeanstalk (>=1.35.0,<1.36.0)"]
+elastictranscoder = ["mypy-boto3-elastictranscoder (>=1.35.0,<1.36.0)"]
+elb = ["mypy-boto3-elb (>=1.35.0,<1.36.0)"]
+elbv2 = ["mypy-boto3-elbv2 (>=1.35.0,<1.36.0)"]
+emr = ["mypy-boto3-emr (>=1.35.0,<1.36.0)"]
+emr-containers = ["mypy-boto3-emr-containers (>=1.35.0,<1.36.0)"]
+emr-serverless = ["mypy-boto3-emr-serverless (>=1.35.0,<1.36.0)"]
+entityresolution = ["mypy-boto3-entityresolution (>=1.35.0,<1.36.0)"]
+es = ["mypy-boto3-es (>=1.35.0,<1.36.0)"]
+essential = ["mypy-boto3-cloudformation (>=1.35.0,<1.36.0)", "mypy-boto3-dynamodb (>=1.35.0,<1.36.0)", "mypy-boto3-ec2 (>=1.35.0,<1.36.0)", "mypy-boto3-lambda (>=1.35.0,<1.36.0)", "mypy-boto3-rds (>=1.35.0,<1.36.0)", "mypy-boto3-s3 (>=1.35.0,<1.36.0)", "mypy-boto3-sqs (>=1.35.0,<1.36.0)"]
+events = ["mypy-boto3-events (>=1.35.0,<1.36.0)"]
+evidently = ["mypy-boto3-evidently (>=1.35.0,<1.36.0)"]
+finspace = ["mypy-boto3-finspace (>=1.35.0,<1.36.0)"]
+finspace-data = ["mypy-boto3-finspace-data (>=1.35.0,<1.36.0)"]
+firehose = ["mypy-boto3-firehose (>=1.35.0,<1.36.0)"]
+fis = ["mypy-boto3-fis (>=1.35.0,<1.36.0)"]
+fms = ["mypy-boto3-fms (>=1.35.0,<1.36.0)"]
+forecast = ["mypy-boto3-forecast (>=1.35.0,<1.36.0)"]
+forecastquery = ["mypy-boto3-forecastquery (>=1.35.0,<1.36.0)"]
+frauddetector = ["mypy-boto3-frauddetector (>=1.35.0,<1.36.0)"]
+freetier = ["mypy-boto3-freetier (>=1.35.0,<1.36.0)"]
+fsx = ["mypy-boto3-fsx (>=1.35.0,<1.36.0)"]
+full = ["boto3-stubs-full"]
+gamelift = ["mypy-boto3-gamelift (>=1.35.0,<1.36.0)"]
+geo-maps = ["mypy-boto3-geo-maps (>=1.35.0,<1.36.0)"]
+geo-places = ["mypy-boto3-geo-places (>=1.35.0,<1.36.0)"]
+geo-routes = ["mypy-boto3-geo-routes (>=1.35.0,<1.36.0)"]
+glacier = ["mypy-boto3-glacier (>=1.35.0,<1.36.0)"]
+globalaccelerator = ["mypy-boto3-globalaccelerator (>=1.35.0,<1.36.0)"]
+glue = ["mypy-boto3-glue (>=1.35.0,<1.36.0)"]
+grafana = ["mypy-boto3-grafana (>=1.35.0,<1.36.0)"]
+greengrass = ["mypy-boto3-greengrass (>=1.35.0,<1.36.0)"]
+greengrassv2 = ["mypy-boto3-greengrassv2 (>=1.35.0,<1.36.0)"]
+groundstation = ["mypy-boto3-groundstation (>=1.35.0,<1.36.0)"]
+guardduty = ["mypy-boto3-guardduty (>=1.35.0,<1.36.0)"]
+health = ["mypy-boto3-health (>=1.35.0,<1.36.0)"]
+healthlake = ["mypy-boto3-healthlake (>=1.35.0,<1.36.0)"]
+iam = ["mypy-boto3-iam (>=1.35.0,<1.36.0)"]
+identitystore = ["mypy-boto3-identitystore (>=1.35.0,<1.36.0)"]
+imagebuilder = ["mypy-boto3-imagebuilder (>=1.35.0,<1.36.0)"]
+importexport = ["mypy-boto3-importexport (>=1.35.0,<1.36.0)"]
+inspector = ["mypy-boto3-inspector (>=1.35.0,<1.36.0)"]
+inspector-scan = ["mypy-boto3-inspector-scan (>=1.35.0,<1.36.0)"]
+inspector2 = ["mypy-boto3-inspector2 (>=1.35.0,<1.36.0)"]
+internetmonitor = ["mypy-boto3-internetmonitor (>=1.35.0,<1.36.0)"]
+iot = ["mypy-boto3-iot (>=1.35.0,<1.36.0)"]
+iot-data = ["mypy-boto3-iot-data (>=1.35.0,<1.36.0)"]
+iot-jobs-data = ["mypy-boto3-iot-jobs-data (>=1.35.0,<1.36.0)"]
+iot1click-devices = ["mypy-boto3-iot1click-devices (>=1.35.0,<1.36.0)"]
+iot1click-projects = ["mypy-boto3-iot1click-projects (>=1.35.0,<1.36.0)"]
+iotanalytics = ["mypy-boto3-iotanalytics (>=1.35.0,<1.36.0)"]
+iotdeviceadvisor = ["mypy-boto3-iotdeviceadvisor (>=1.35.0,<1.36.0)"]
+iotevents = ["mypy-boto3-iotevents (>=1.35.0,<1.36.0)"]
+iotevents-data = ["mypy-boto3-iotevents-data (>=1.35.0,<1.36.0)"]
+iotfleethub = ["mypy-boto3-iotfleethub (>=1.35.0,<1.36.0)"]
+iotfleetwise = ["mypy-boto3-iotfleetwise (>=1.35.0,<1.36.0)"]
+iotsecuretunneling = ["mypy-boto3-iotsecuretunneling (>=1.35.0,<1.36.0)"]
+iotsitewise = ["mypy-boto3-iotsitewise (>=1.35.0,<1.36.0)"]
+iotthingsgraph = ["mypy-boto3-iotthingsgraph (>=1.35.0,<1.36.0)"]
+iottwinmaker = ["mypy-boto3-iottwinmaker (>=1.35.0,<1.36.0)"]
+iotwireless = ["mypy-boto3-iotwireless (>=1.35.0,<1.36.0)"]
+ivs = ["mypy-boto3-ivs (>=1.35.0,<1.36.0)"]
+ivs-realtime = ["mypy-boto3-ivs-realtime (>=1.35.0,<1.36.0)"]
+ivschat = ["mypy-boto3-ivschat (>=1.35.0,<1.36.0)"]
+kafka = ["mypy-boto3-kafka (>=1.35.0,<1.36.0)"]
+kafkaconnect = ["mypy-boto3-kafkaconnect (>=1.35.0,<1.36.0)"]
+kendra = ["mypy-boto3-kendra (>=1.35.0,<1.36.0)"]
+kendra-ranking = ["mypy-boto3-kendra-ranking (>=1.35.0,<1.36.0)"]
+keyspaces = ["mypy-boto3-keyspaces (>=1.35.0,<1.36.0)"]
+kinesis = ["mypy-boto3-kinesis (>=1.35.0,<1.36.0)"]
+kinesis-video-archived-media = ["mypy-boto3-kinesis-video-archived-media (>=1.35.0,<1.36.0)"]
+kinesis-video-media = ["mypy-boto3-kinesis-video-media (>=1.35.0,<1.36.0)"]
+kinesis-video-signaling = ["mypy-boto3-kinesis-video-signaling (>=1.35.0,<1.36.0)"]
+kinesis-video-webrtc-storage = ["mypy-boto3-kinesis-video-webrtc-storage (>=1.35.0,<1.36.0)"]
+kinesisanalytics = ["mypy-boto3-kinesisanalytics (>=1.35.0,<1.36.0)"]
+kinesisanalyticsv2 = ["mypy-boto3-kinesisanalyticsv2 (>=1.35.0,<1.36.0)"]
+kinesisvideo = ["mypy-boto3-kinesisvideo (>=1.35.0,<1.36.0)"]
+kms = ["mypy-boto3-kms (>=1.35.0,<1.36.0)"]
+lakeformation = ["mypy-boto3-lakeformation (>=1.35.0,<1.36.0)"]
+lambda = ["mypy-boto3-lambda (>=1.35.0,<1.36.0)"]
+launch-wizard = ["mypy-boto3-launch-wizard (>=1.35.0,<1.36.0)"]
+lex-models = ["mypy-boto3-lex-models (>=1.35.0,<1.36.0)"]
+lex-runtime = ["mypy-boto3-lex-runtime (>=1.35.0,<1.36.0)"]
+lexv2-models = ["mypy-boto3-lexv2-models (>=1.35.0,<1.36.0)"]
+lexv2-runtime = ["mypy-boto3-lexv2-runtime (>=1.35.0,<1.36.0)"]
+license-manager = ["mypy-boto3-license-manager (>=1.35.0,<1.36.0)"]
+license-manager-linux-subscriptions = ["mypy-boto3-license-manager-linux-subscriptions (>=1.35.0,<1.36.0)"]
+license-manager-user-subscriptions = ["mypy-boto3-license-manager-user-subscriptions (>=1.35.0,<1.36.0)"]
+lightsail = ["mypy-boto3-lightsail (>=1.35.0,<1.36.0)"]
+location = ["mypy-boto3-location (>=1.35.0,<1.36.0)"]
+logs = ["mypy-boto3-logs (>=1.35.0,<1.36.0)"]
+lookoutequipment = ["mypy-boto3-lookoutequipment (>=1.35.0,<1.36.0)"]
+lookoutmetrics = ["mypy-boto3-lookoutmetrics (>=1.35.0,<1.36.0)"]
+lookoutvision = ["mypy-boto3-lookoutvision (>=1.35.0,<1.36.0)"]
+m2 = ["mypy-boto3-m2 (>=1.35.0,<1.36.0)"]
+machinelearning = ["mypy-boto3-machinelearning (>=1.35.0,<1.36.0)"]
+macie2 = ["mypy-boto3-macie2 (>=1.35.0,<1.36.0)"]
+mailmanager = ["mypy-boto3-mailmanager (>=1.35.0,<1.36.0)"]
+managedblockchain = ["mypy-boto3-managedblockchain (>=1.35.0,<1.36.0)"]
+managedblockchain-query = ["mypy-boto3-managedblockchain-query (>=1.35.0,<1.36.0)"]
+marketplace-agreement = ["mypy-boto3-marketplace-agreement (>=1.35.0,<1.36.0)"]
+marketplace-catalog = ["mypy-boto3-marketplace-catalog (>=1.35.0,<1.36.0)"]
+marketplace-deployment = ["mypy-boto3-marketplace-deployment (>=1.35.0,<1.36.0)"]
+marketplace-entitlement = ["mypy-boto3-marketplace-entitlement (>=1.35.0,<1.36.0)"]
+marketplace-reporting = ["mypy-boto3-marketplace-reporting (>=1.35.0,<1.36.0)"]
+marketplacecommerceanalytics = ["mypy-boto3-marketplacecommerceanalytics (>=1.35.0,<1.36.0)"]
+mediaconnect = ["mypy-boto3-mediaconnect (>=1.35.0,<1.36.0)"]
+mediaconvert = ["mypy-boto3-mediaconvert (>=1.35.0,<1.36.0)"]
+medialive = ["mypy-boto3-medialive (>=1.35.0,<1.36.0)"]
+mediapackage = ["mypy-boto3-mediapackage (>=1.35.0,<1.36.0)"]
+mediapackage-vod = ["mypy-boto3-mediapackage-vod (>=1.35.0,<1.36.0)"]
+mediapackagev2 = ["mypy-boto3-mediapackagev2 (>=1.35.0,<1.36.0)"]
+mediastore = ["mypy-boto3-mediastore (>=1.35.0,<1.36.0)"]
+mediastore-data = ["mypy-boto3-mediastore-data (>=1.35.0,<1.36.0)"]
+mediatailor = ["mypy-boto3-mediatailor (>=1.35.0,<1.36.0)"]
+medical-imaging = ["mypy-boto3-medical-imaging (>=1.35.0,<1.36.0)"]
+memorydb = ["mypy-boto3-memorydb (>=1.35.0,<1.36.0)"]
+meteringmarketplace = ["mypy-boto3-meteringmarketplace (>=1.35.0,<1.36.0)"]
+mgh = ["mypy-boto3-mgh (>=1.35.0,<1.36.0)"]
+mgn = ["mypy-boto3-mgn (>=1.35.0,<1.36.0)"]
+migration-hub-refactor-spaces = ["mypy-boto3-migration-hub-refactor-spaces (>=1.35.0,<1.36.0)"]
+migrationhub-config = ["mypy-boto3-migrationhub-config (>=1.35.0,<1.36.0)"]
+migrationhuborchestrator = ["mypy-boto3-migrationhuborchestrator (>=1.35.0,<1.36.0)"]
+migrationhubstrategy = ["mypy-boto3-migrationhubstrategy (>=1.35.0,<1.36.0)"]
+mq = ["mypy-boto3-mq (>=1.35.0,<1.36.0)"]
+mturk = ["mypy-boto3-mturk (>=1.35.0,<1.36.0)"]
+mwaa = ["mypy-boto3-mwaa (>=1.35.0,<1.36.0)"]
+neptune = ["mypy-boto3-neptune (>=1.35.0,<1.36.0)"]
+neptune-graph = ["mypy-boto3-neptune-graph (>=1.35.0,<1.36.0)"]
+neptunedata = ["mypy-boto3-neptunedata (>=1.35.0,<1.36.0)"]
+network-firewall = ["mypy-boto3-network-firewall (>=1.35.0,<1.36.0)"]
+networkmanager = ["mypy-boto3-networkmanager (>=1.35.0,<1.36.0)"]
+networkmonitor = ["mypy-boto3-networkmonitor (>=1.35.0,<1.36.0)"]
+notifications = ["mypy-boto3-notifications (>=1.35.0,<1.36.0)"]
+notificationscontacts = ["mypy-boto3-notificationscontacts (>=1.35.0,<1.36.0)"]
+oam = ["mypy-boto3-oam (>=1.35.0,<1.36.0)"]
+omics = ["mypy-boto3-omics (>=1.35.0,<1.36.0)"]
+opensearch = ["mypy-boto3-opensearch (>=1.35.0,<1.36.0)"]
+opensearchserverless = ["mypy-boto3-opensearchserverless (>=1.35.0,<1.36.0)"]
+opsworks = ["mypy-boto3-opsworks (>=1.35.0,<1.36.0)"]
+opsworkscm = ["mypy-boto3-opsworkscm (>=1.35.0,<1.36.0)"]
+organizations = ["mypy-boto3-organizations (>=1.35.0,<1.36.0)"]
+osis = ["mypy-boto3-osis (>=1.35.0,<1.36.0)"]
+outposts = ["mypy-boto3-outposts (>=1.35.0,<1.36.0)"]
+panorama = ["mypy-boto3-panorama (>=1.35.0,<1.36.0)"]
+partnercentral-selling = ["mypy-boto3-partnercentral-selling (>=1.35.0,<1.36.0)"]
+payment-cryptography = ["mypy-boto3-payment-cryptography (>=1.35.0,<1.36.0)"]
+payment-cryptography-data = ["mypy-boto3-payment-cryptography-data (>=1.35.0,<1.36.0)"]
+pca-connector-ad = ["mypy-boto3-pca-connector-ad (>=1.35.0,<1.36.0)"]
+pca-connector-scep = ["mypy-boto3-pca-connector-scep (>=1.35.0,<1.36.0)"]
+pcs = ["mypy-boto3-pcs (>=1.35.0,<1.36.0)"]
+personalize = ["mypy-boto3-personalize (>=1.35.0,<1.36.0)"]
+personalize-events = ["mypy-boto3-personalize-events (>=1.35.0,<1.36.0)"]
+personalize-runtime = ["mypy-boto3-personalize-runtime (>=1.35.0,<1.36.0)"]
+pi = ["mypy-boto3-pi (>=1.35.0,<1.36.0)"]
+pinpoint = ["mypy-boto3-pinpoint (>=1.35.0,<1.36.0)"]
+pinpoint-email = ["mypy-boto3-pinpoint-email (>=1.35.0,<1.36.0)"]
+pinpoint-sms-voice = ["mypy-boto3-pinpoint-sms-voice (>=1.35.0,<1.36.0)"]
+pinpoint-sms-voice-v2 = ["mypy-boto3-pinpoint-sms-voice-v2 (>=1.35.0,<1.36.0)"]
+pipes = ["mypy-boto3-pipes (>=1.35.0,<1.36.0)"]
+polly = ["mypy-boto3-polly (>=1.35.0,<1.36.0)"]
+pricing = ["mypy-boto3-pricing (>=1.35.0,<1.36.0)"]
+privatenetworks = ["mypy-boto3-privatenetworks (>=1.35.0,<1.36.0)"]
+proton = ["mypy-boto3-proton (>=1.35.0,<1.36.0)"]
+qapps = ["mypy-boto3-qapps (>=1.35.0,<1.36.0)"]
+qbusiness = ["mypy-boto3-qbusiness (>=1.35.0,<1.36.0)"]
+qconnect = ["mypy-boto3-qconnect (>=1.35.0,<1.36.0)"]
+qldb = ["mypy-boto3-qldb (>=1.35.0,<1.36.0)"]
+qldb-session = ["mypy-boto3-qldb-session (>=1.35.0,<1.36.0)"]
+quicksight = ["mypy-boto3-quicksight (>=1.35.0,<1.36.0)"]
+ram = ["mypy-boto3-ram (>=1.35.0,<1.36.0)"]
+rbin = ["mypy-boto3-rbin (>=1.35.0,<1.36.0)"]
+rds = ["mypy-boto3-rds (>=1.35.0,<1.36.0)"]
+rds-data = ["mypy-boto3-rds-data (>=1.35.0,<1.36.0)"]
+redshift = ["mypy-boto3-redshift (>=1.35.0,<1.36.0)"]
+redshift-data = ["mypy-boto3-redshift-data (>=1.35.0,<1.36.0)"]
+redshift-serverless = ["mypy-boto3-redshift-serverless (>=1.35.0,<1.36.0)"]
+rekognition = ["mypy-boto3-rekognition (>=1.35.0,<1.36.0)"]
+repostspace = ["mypy-boto3-repostspace (>=1.35.0,<1.36.0)"]
+resiliencehub = ["mypy-boto3-resiliencehub (>=1.35.0,<1.36.0)"]
+resource-explorer-2 = ["mypy-boto3-resource-explorer-2 (>=1.35.0,<1.36.0)"]
+resource-groups = ["mypy-boto3-resource-groups (>=1.35.0,<1.36.0)"]
+resourcegroupstaggingapi = ["mypy-boto3-resourcegroupstaggingapi (>=1.35.0,<1.36.0)"]
+robomaker = ["mypy-boto3-robomaker (>=1.35.0,<1.36.0)"]
+rolesanywhere = ["mypy-boto3-rolesanywhere (>=1.35.0,<1.36.0)"]
+route53 = ["mypy-boto3-route53 (>=1.35.0,<1.36.0)"]
+route53-recovery-cluster = ["mypy-boto3-route53-recovery-cluster (>=1.35.0,<1.36.0)"]
+route53-recovery-control-config = ["mypy-boto3-route53-recovery-control-config (>=1.35.0,<1.36.0)"]
+route53-recovery-readiness = ["mypy-boto3-route53-recovery-readiness (>=1.35.0,<1.36.0)"]
+route53domains = ["mypy-boto3-route53domains (>=1.35.0,<1.36.0)"]
+route53profiles = ["mypy-boto3-route53profiles (>=1.35.0,<1.36.0)"]
+route53resolver = ["mypy-boto3-route53resolver (>=1.35.0,<1.36.0)"]
+rum = ["mypy-boto3-rum (>=1.35.0,<1.36.0)"]
+s3 = ["mypy-boto3-s3 (>=1.35.0,<1.36.0)"]
+s3control = ["mypy-boto3-s3control (>=1.35.0,<1.36.0)"]
+s3outposts = ["mypy-boto3-s3outposts (>=1.35.0,<1.36.0)"]
+sagemaker = ["mypy-boto3-sagemaker (>=1.35.0,<1.36.0)"]
+sagemaker-a2i-runtime = ["mypy-boto3-sagemaker-a2i-runtime (>=1.35.0,<1.36.0)"]
+sagemaker-edge = ["mypy-boto3-sagemaker-edge (>=1.35.0,<1.36.0)"]
+sagemaker-featurestore-runtime = ["mypy-boto3-sagemaker-featurestore-runtime (>=1.35.0,<1.36.0)"]
+sagemaker-geospatial = ["mypy-boto3-sagemaker-geospatial (>=1.35.0,<1.36.0)"]
+sagemaker-metrics = ["mypy-boto3-sagemaker-metrics (>=1.35.0,<1.36.0)"]
+sagemaker-runtime = ["mypy-boto3-sagemaker-runtime (>=1.35.0,<1.36.0)"]
+savingsplans = ["mypy-boto3-savingsplans (>=1.35.0,<1.36.0)"]
+scheduler = ["mypy-boto3-scheduler (>=1.35.0,<1.36.0)"]
+schemas = ["mypy-boto3-schemas (>=1.35.0,<1.36.0)"]
+sdb = ["mypy-boto3-sdb (>=1.35.0,<1.36.0)"]
+secretsmanager = ["mypy-boto3-secretsmanager (>=1.35.0,<1.36.0)"]
+securityhub = ["mypy-boto3-securityhub (>=1.35.0,<1.36.0)"]
+securitylake = ["mypy-boto3-securitylake (>=1.35.0,<1.36.0)"]
+serverlessrepo = ["mypy-boto3-serverlessrepo (>=1.35.0,<1.36.0)"]
+service-quotas = ["mypy-boto3-service-quotas (>=1.35.0,<1.36.0)"]
+servicecatalog = ["mypy-boto3-servicecatalog (>=1.35.0,<1.36.0)"]
+servicecatalog-appregistry = ["mypy-boto3-servicecatalog-appregistry (>=1.35.0,<1.36.0)"]
+servicediscovery = ["mypy-boto3-servicediscovery (>=1.35.0,<1.36.0)"]
+ses = ["mypy-boto3-ses (>=1.35.0,<1.36.0)"]
+sesv2 = ["mypy-boto3-sesv2 (>=1.35.0,<1.36.0)"]
+shield = ["mypy-boto3-shield (>=1.35.0,<1.36.0)"]
+signer = ["mypy-boto3-signer (>=1.35.0,<1.36.0)"]
+simspaceweaver = ["mypy-boto3-simspaceweaver (>=1.35.0,<1.36.0)"]
+sms = ["mypy-boto3-sms (>=1.35.0,<1.36.0)"]
+sms-voice = ["mypy-boto3-sms-voice (>=1.35.0,<1.36.0)"]
+snow-device-management = ["mypy-boto3-snow-device-management (>=1.35.0,<1.36.0)"]
+snowball = ["mypy-boto3-snowball (>=1.35.0,<1.36.0)"]
+sns = ["mypy-boto3-sns (>=1.35.0,<1.36.0)"]
+socialmessaging = ["mypy-boto3-socialmessaging (>=1.35.0,<1.36.0)"]
+sqs = ["mypy-boto3-sqs (>=1.35.0,<1.36.0)"]
+ssm = ["mypy-boto3-ssm (>=1.35.0,<1.36.0)"]
+ssm-contacts = ["mypy-boto3-ssm-contacts (>=1.35.0,<1.36.0)"]
+ssm-incidents = ["mypy-boto3-ssm-incidents (>=1.35.0,<1.36.0)"]
+ssm-quicksetup = ["mypy-boto3-ssm-quicksetup (>=1.35.0,<1.36.0)"]
+ssm-sap = ["mypy-boto3-ssm-sap (>=1.35.0,<1.36.0)"]
+sso = ["mypy-boto3-sso (>=1.35.0,<1.36.0)"]
+sso-admin = ["mypy-boto3-sso-admin (>=1.35.0,<1.36.0)"]
+sso-oidc = ["mypy-boto3-sso-oidc (>=1.35.0,<1.36.0)"]
+stepfunctions = ["mypy-boto3-stepfunctions (>=1.35.0,<1.36.0)"]
+storagegateway = ["mypy-boto3-storagegateway (>=1.35.0,<1.36.0)"]
+sts = ["mypy-boto3-sts (>=1.35.0,<1.36.0)"]
+supplychain = ["mypy-boto3-supplychain (>=1.35.0,<1.36.0)"]
+support = ["mypy-boto3-support (>=1.35.0,<1.36.0)"]
+support-app = ["mypy-boto3-support-app (>=1.35.0,<1.36.0)"]
+swf = ["mypy-boto3-swf (>=1.35.0,<1.36.0)"]
+synthetics = ["mypy-boto3-synthetics (>=1.35.0,<1.36.0)"]
+taxsettings = ["mypy-boto3-taxsettings (>=1.35.0,<1.36.0)"]
+textract = ["mypy-boto3-textract (>=1.35.0,<1.36.0)"]
+timestream-influxdb = ["mypy-boto3-timestream-influxdb (>=1.35.0,<1.36.0)"]
+timestream-query = ["mypy-boto3-timestream-query (>=1.35.0,<1.36.0)"]
+timestream-write = ["mypy-boto3-timestream-write (>=1.35.0,<1.36.0)"]
+tnb = ["mypy-boto3-tnb (>=1.35.0,<1.36.0)"]
+transcribe = ["mypy-boto3-transcribe (>=1.35.0,<1.36.0)"]
+transfer = ["mypy-boto3-transfer (>=1.35.0,<1.36.0)"]
+translate = ["mypy-boto3-translate (>=1.35.0,<1.36.0)"]
+trustedadvisor = ["mypy-boto3-trustedadvisor (>=1.35.0,<1.36.0)"]
+verifiedpermissions = ["mypy-boto3-verifiedpermissions (>=1.35.0,<1.36.0)"]
+voice-id = ["mypy-boto3-voice-id (>=1.35.0,<1.36.0)"]
+vpc-lattice = ["mypy-boto3-vpc-lattice (>=1.35.0,<1.36.0)"]
+waf = ["mypy-boto3-waf (>=1.35.0,<1.36.0)"]
+waf-regional = ["mypy-boto3-waf-regional (>=1.35.0,<1.36.0)"]
+wafv2 = ["mypy-boto3-wafv2 (>=1.35.0,<1.36.0)"]
+wellarchitected = ["mypy-boto3-wellarchitected (>=1.35.0,<1.36.0)"]
+wisdom = ["mypy-boto3-wisdom (>=1.35.0,<1.36.0)"]
+workdocs = ["mypy-boto3-workdocs (>=1.35.0,<1.36.0)"]
+workmail = ["mypy-boto3-workmail (>=1.35.0,<1.36.0)"]
+workmailmessageflow = ["mypy-boto3-workmailmessageflow (>=1.35.0,<1.36.0)"]
+workspaces = ["mypy-boto3-workspaces (>=1.35.0,<1.36.0)"]
+workspaces-thin-client = ["mypy-boto3-workspaces-thin-client (>=1.35.0,<1.36.0)"]
+workspaces-web = ["mypy-boto3-workspaces-web (>=1.35.0,<1.36.0)"]
+xray = ["mypy-boto3-xray (>=1.35.0,<1.36.0)"]
+
+[[package]]
+name = "botocore"
+version = "1.35.70"
+description = "Low-level, data-driven core of boto 3."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "botocore-1.35.70-py3-none-any.whl", hash = "sha256:ba8a4797cf7c5d9c237e67a62692f5146e895613fd3e6a43b00b66f3a8c7fc73"},
+    {file = "botocore-1.35.70.tar.gz", hash = "sha256:18d1bb505722d9efd50c50719ed8de7284bfe6d3908a9e08756a7646e549da21"},
+]
+
+[package.dependencies]
+jmespath = ">=0.7.1,<2.0.0"
+python-dateutil = ">=2.1,<3.0.0"
+urllib3 = {version = ">=1.25.4,<2.2.0 || >2.2.0,<3", markers = "python_version >= \"3.10\""}
+
+[package.extras]
+crt = ["awscrt (==0.22.0)"]
+
+[[package]]
+name = "botocore-stubs"
+version = "1.35.70"
+description = "Type annotations and code completion for botocore"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "botocore_stubs-1.35.70-py3-none-any.whl", hash = "sha256:d717620186b925495bb76870b504ddc28d012c5353b24396214021440a0a0a0a"},
+    {file = "botocore_stubs-1.35.70.tar.gz", hash = "sha256:f79e34cc5be1857c3c952cb934500e8555fde3f90534169ccadc400f219a4890"},
+]
+
+[package.dependencies]
+types-awscrt = "*"
+
+[package.extras]
+botocore = ["botocore"]
+
 [[package]]
 name = "certifi"
 version = "2023.7.22"
@@ -1715,6 +2188,17 @@ MarkupSafe = ">=2.0"
 [package.extras]
 i18n = ["Babel (>=2.7)"]
 
+[[package]]
+name = "jmespath"
+version = "1.0.1"
+description = "JSON Matching Expressions"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980"},
+    {file = "jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe"},
+]
+
 [[package]]
 name = "joblib"
 version = "1.4.2"
@@ -3810,6 +4294,20 @@ files = [
 [package.dependencies]
 six = ">=1.5"
 
+[[package]]
+name = "python-dotenv"
+version = "1.0.1"
+description = "Read key-value pairs from a .env file and set them as environment variables"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"},
+    {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"},
+]
+
+[package.extras]
+cli = ["click (>=5.0)"]
+
 [[package]]
 name = "python-multipart"
 version = "0.0.17"
@@ -4382,6 +4880,23 @@ files = [
     {file = "ruff-0.7.4.tar.gz", hash = "sha256:cd12e35031f5af6b9b93715d8c4f40360070b2041f81273d0527683d5708fce2"},
 ]
 
+[[package]]
+name = "s3transfer"
+version = "0.10.4"
+description = "An Amazon S3 Transfer Manager"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "s3transfer-0.10.4-py3-none-any.whl", hash = "sha256:244a76a24355363a68164241438de1b72f8781664920260c48465896b712a41e"},
+    {file = "s3transfer-0.10.4.tar.gz", hash = "sha256:29edc09801743c21eb5ecbc617a152df41d3c287f67b615f73e5f750583666a7"},
+]
+
+[package.dependencies]
+botocore = ">=1.33.2,<2.0a.0"
+
+[package.extras]
+crt = ["botocore[crt] (>=1.33.2,<2.0a.0)"]
+
 [[package]]
 name = "safetensors"
 version = "0.4.5"
@@ -5358,6 +5873,17 @@ rich = ">=10.11.0"
 shellingham = ">=1.3.0"
 typing-extensions = ">=3.7.4.3"
 
+[[package]]
+name = "types-awscrt"
+version = "0.23.1"
+description = "Type annotations and code completion for awscrt"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "types_awscrt-0.23.1-py3-none-any.whl", hash = "sha256:0d362a5d62d68ca4216f458172f41c1123ec04791d68364de8ee8b61b528b262"},
+    {file = "types_awscrt-0.23.1.tar.gz", hash = "sha256:a20b425dabb258bc3d07a5e7de503fd9558dd1542d72de796e74e402c6d493b2"},
+]
+
 [[package]]
 name = "types-beautifulsoup4"
 version = "4.12.0.20241020"
@@ -5372,6 +5898,20 @@ files = [
 [package.dependencies]
 types-html5lib = "*"
 
+[[package]]
+name = "types-boto3"
+version = "1.0.2"
+description = "Proxy package for boto3-stubs"
+optional = false
+python-versions = "*"
+files = [
+    {file = "types-boto3-1.0.2.tar.gz", hash = "sha256:15f3ffad0314e40a0708fec25f94891414f93260202422bf8b19b6913853c983"},
+    {file = "types_boto3-1.0.2-py3-none-any.whl", hash = "sha256:a6a88e94d59d887839863a64095493956efc148e747206880a7eb47d90ae8398"},
+]
+
+[package.dependencies]
+boto3-stubs = "*"
+
 [[package]]
 name = "types-html5lib"
 version = "1.1.11.20241018"
@@ -5420,30 +5960,27 @@ files = [
 urllib3 = ">=2"
 
 [[package]]
-name = "types-six"
-version = "1.16.21.20241105"
-description = "Typing stubs for six"
+name = "types-s3transfer"
+version = "0.10.4"
+description = "Type annotations and code completion for s3transfer"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "types-six-1.16.21.20241105.tar.gz", hash = "sha256:ce3534c38079ec3242f4a20376283eb265a3837f80592b0ecacb14bd41acc29e"},
-    {file = "types_six-1.16.21.20241105-py3-none-any.whl", hash = "sha256:8b4b29e5c8fe7f1131be8f3cb7cedbcd8bb889707336f32c3fb332c9b1c71991"},
+    {file = "types_s3transfer-0.10.4-py3-none-any.whl", hash = "sha256:22ac1aabc98f9d7f2928eb3fb4d5c02bf7435687f0913345a97dd3b84d0c217d"},
+    {file = "types_s3transfer-0.10.4.tar.gz", hash = "sha256:03123477e3064c81efe712bf9d372c7c72f2790711431f9baa59cf96ea607267"},
 ]
 
 [[package]]
-name = "types-tqdm"
-version = "4.67.0.20241119"
-description = "Typing stubs for tqdm"
+name = "types-six"
+version = "1.16.21.20241105"
+description = "Typing stubs for six"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "types-tqdm-4.67.0.20241119.tar.gz", hash = "sha256:1769e0e94d5e6d8fa814965f9cf3d9928376dd15dabcbcb784bb8769081092b4"},
-    {file = "types_tqdm-4.67.0.20241119-py3-none-any.whl", hash = "sha256:a18d4eb62db0d35c52707ae13d821b5a57970755273ecb56e133ccc0ac7e7c79"},
+    {file = "types-six-1.16.21.20241105.tar.gz", hash = "sha256:ce3534c38079ec3242f4a20376283eb265a3837f80592b0ecacb14bd41acc29e"},
+    {file = "types_six-1.16.21.20241105-py3-none-any.whl", hash = "sha256:8b4b29e5c8fe7f1131be8f3cb7cedbcd8bb889707336f32c3fb332c9b1c71991"},
 ]
 
-[package.dependencies]
-types-requests = "*"
-
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"
@@ -5579,6 +6116,20 @@ platformdirs = ">=3.9.1,<5"
 docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
 test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
 
+[[package]]
+name = "vulture"
+version = "2.13"
+description = "Find dead code"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "vulture-2.13-py2.py3-none-any.whl", hash = "sha256:34793ba60488e7cccbecdef3a7fe151656372ef94fdac9fe004c52a4000a6d44"},
+    {file = "vulture-2.13.tar.gz", hash = "sha256:78248bf58f5eaffcc2ade306141ead73f437339950f80045dce7f8b078e5a1aa"},
+]
+
+[package.dependencies]
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+
 [[package]]
 name = "wcwidth"
 version = "0.2.13"
@@ -5797,4 +6348,4 @@ propcache = ">=0.2.0"
 [metadata]
 lock-version = "2.0"
 python-versions = "~3.10"
-content-hash = "1efb5efb494c33cb4fcc0cae070f9afd155b114529b98360ea2277dea26aafac"
+content-hash = "edbf4967508fd1d767c1ce0b9d98e11b967086e4307c902bae34c7e143a131b9"

pyproject.toml

@@ -19,13 +19,15 @@ tts-service = "tts_service.cli:main"
 
 [tool.poetry.dependencies]
 python = "~3.10"
-regex = "^2024.11.6"
+boto3 = "^1.35.70"
 numpy = "1.23.5"
-tqdm = "^4.67.1"
+pandas = "^2.2.3"
+python-dotenv = "^1.0.1"
+regex = "^2024.11.6"
 requests = ">=2.31.0,<2.32.0"
 six = "^1.16.0"
+tqdm = "^4.67.1"
 wget = "^3.2"
-pandas = "^2.2.3"
 
 [tool.poetry.group.ml.dependencies]
 torch = "2.3.1"
@@ -51,6 +53,7 @@ ipykernel = "^6.29.5"
 pipdeptree = "^2.23.4"
 pre-commit = "^4.0.1"
 ruff = "^0.7.4"
+vulture = "^2.13"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^8.3.3"
@@ -58,12 +61,12 @@ pytest-cov = "^6.0.0"
 
 [tool.poetry.group.typing.dependencies]
 mypy = "^1.13.0"
-types-requests = "^2.32.0.20241016"
-types-tqdm = "^4.67.0.20241119"
-types-six = "^1.16.21.20241105"
+pandas-stubs = "^2.2.3.241009"
 types-beautifulsoup4 = "^4.12.0.20241020"
+types-boto3 = "^1.0.2"
 types-regex = "^2024.11.6.20241108"
-pandas-stubs = "^2.2.3.241009"
+types-requests = "^2.32.0.20241016"
+types-six = "^1.16.21.20241105"
 
 
 [tool.poetry.group.ui.dependencies]
@@ -92,6 +95,7 @@ edge-tts = "6.1.9"
 
 [tool.ruff]
 line-length = 132
+include = ["tts-service/**/*.py"]
 
 [tool.ruff.lint]
 select = [
@@ -113,6 +117,8 @@ select = [
 [tool.mypy]
 packages = "assets,core,rvc,tabs,tts_service,tests"
 check_untyped_defs = true
+explicit_package_bases = true
+namespace_packages = true
 
 [[tool.mypy.overrides]]
 module = [
@@ -143,6 +149,7 @@ module = [
     "rvc.train.preprocess.slicer",
     "rvc.train.process.extract_small_model",
     "tabs.extra.f0_extractor.f0_extractor",
+    "tts_service.whitelist",
 ]
 ignore_errors = true
 
@@ -171,11 +178,30 @@ module = [
     "torchaudio.*",
     "torchcrepe",
     "torchfcpe",
+    "tqdm",
     "transformers",
     "wget",
 ]
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = [
+    "rvc.lib.tools.prerequisites_download",
+    "tts_service.cli",
+    "tts_service.utils",
+]
+warn_unused_configs = true
+disallow_any_generics = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+warn_unused_ignores = true
+warn_return_any = true
+no_implicit_reexport = true
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -105,6 +105,12 @@ bibtexparser==2.0.0b7 ; python_version >= "3.10" and python_version < "3.11" \
 blinker==1.9.0 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf \
     --hash=sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc
+boto3==1.35.70 ; python_version >= "3.10" and python_version < "3.11" \
+    --hash=sha256:121dce8c7102eea6a6047d46bcd74e8a24dac793a4a3857de4f4bad9c12566fd \
+    --hash=sha256:ca385708f83f01b3f27d9d675880d2458cb3b40ed1e25da688f551454ed0c112
+botocore==1.35.70 ; python_version >= "3.10" and python_version < "3.11" \
+    --hash=sha256:18d1bb505722d9efd50c50719ed8de7284bfe6d3908a9e08756a7646e549da21 \
+    --hash=sha256:ba8a4797cf7c5d9c237e67a62692f5146e895613fd3e6a43b00b66f3a8c7fc73
 certifi==2023.7.22 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:539cc1d13202e33ca466e88b2807e29f4c13049d6d87031a3c110744495cb082 \
     --hash=sha256:92d6037539857d8206b8f6ae472e8b77db8058fec5937a1ef3f54304089edbb9
@@ -629,6 +635,9 @@ itsdangerous==2.2.0 ; python_version >= "3.10" and python_version < "3.11" \
 jinja2==3.1.4 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369 \
     --hash=sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d
+jmespath==1.0.1 ; python_version >= "3.10" and python_version < "3.11" \
+    --hash=sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980 \
+    --hash=sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe
 joblib==1.4.2 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6 \
     --hash=sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e
@@ -1529,6 +1538,9 @@ pypresence==4.3.0 ; python_version >= "3.10" and python_version < "3.11" \
 python-dateutil==2.9.0.post0 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3 \
     --hash=sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427
+python-dotenv==1.0.1 ; python_version >= "3.10" and python_version < "3.11" \
+    --hash=sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca \
+    --hash=sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a
 pytz==2024.2 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a \
     --hash=sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725
@@ -1787,6 +1799,9 @@ rpds-py==0.21.0 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:f983e4c2f603c95dde63df633eec42955508eefd8d0f0e6d236d31a044c882d7 \
     --hash=sha256:faa5e8496c530f9c71f2b4e1c49758b06e5f4055e17144906245c99fa6d45356 \
     --hash=sha256:fed5dfefdf384d6fe975cc026886aece4f292feaf69d0eeb716cfd3c5a4dd8be
+s3transfer==0.10.4 ; python_version >= "3.10" and python_version < "3.11" \
+    --hash=sha256:244a76a24355363a68164241438de1b72f8781664920260c48465896b712a41e \
+    --hash=sha256:29edc09801743c21eb5ecbc617a152df41d3c287f67b615f73e5f750583666a7
 safetensors==0.4.5 ; python_version >= "3.10" and python_version < "3.11" \
     --hash=sha256:01c8f00da537af711979e1b42a69a8ec9e1d7112f208e0e9b8a35d2c381085ef \
     --hash=sha256:023b6e5facda76989f4cba95a861b7e656b87e225f61811065d5c501f78cdb3f \

rvc/configs/config.py

@@ -34,26 +34,13 @@ class Config:
             if self.device.startswith("cuda")
             else None
         )
-        self.json_config = self.load_config_json()
         self.gpu_mem = None
         self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config()
 
-    def load_config_json(self) -> dict:
-        configs = {}
-        for config_file in version_config_paths:
-            config_path = os.path.join("rvc", "configs", config_file)
-            with open(config_path, "r") as f:
-                configs[config_file] = json.load(f)
-        return configs
-
     def has_mps(self) -> bool:
         # Check if Metal Performance Shaders are available - for macOS 12.3+.
         return torch.backends.mps.is_available()
 
-    def has_xpu(self) -> bool:
-        # Check if XPU is available.
-        return hasattr(torch, "xpu") and torch.xpu.is_available()
-
     def set_precision(self, precision):
         if precision not in ["fp32", "fp16"]:
             raise ValueError("Invalid precision type. Must be 'fp32' or 'fp16'.")
@@ -91,21 +78,6 @@ class Config:
 
         return f"Overwritten preprocess and config.json to use {precision}."
 
-    def get_precision(self):
-        if not version_config_paths:
-            raise FileNotFoundError("No configuration paths provided.")
-
-        full_config_path = os.path.join("rvc", "configs", version_config_paths[0])
-        try:
-            with open(full_config_path, "r") as f:
-                config = json.load(f)
-            fp16_run_value = config["train"].get("fp16_run", False)
-            precision = "fp16" if fp16_run_value else "fp32"
-            return precision
-        except FileNotFoundError:
-            print(f"File not found: {full_config_path}")
-            return None
-
     def device_config(self) -> tuple:
         if self.device.startswith("cuda"):
             self.set_cuda_config()
@@ -142,38 +114,3 @@ class Config:
         self.gpu_mem = torch.cuda.get_device_properties(i_device).total_memory // (
             1024**3
         )
-
-
-def max_vram_gpu(gpu):
-    if torch.cuda.is_available():
-        gpu_properties = torch.cuda.get_device_properties(gpu)
-        total_memory_gb = round(gpu_properties.total_memory / 1024 / 1024 / 1024)
-        return total_memory_gb
-    else:
-        return "8"
-
-
-def get_gpu_info():
-    ngpu = torch.cuda.device_count()
-    gpu_infos = []
-    if torch.cuda.is_available() or ngpu != 0:
-        for i in range(ngpu):
-            gpu_name = torch.cuda.get_device_name(i)
-            mem = int(
-                torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024
-                + 0.4
-            )
-            gpu_infos.append(f"{i}: {gpu_name} ({mem} GB)")
-    if len(gpu_infos) > 0:
-        gpu_info = "\n".join(gpu_infos)
-    else:
-        gpu_info = "Unfortunately, there is no compatible GPU available to support your training."
-    return gpu_info
-
-
-def get_number_of_gpus():
-    if torch.cuda.is_available():
-        num_gpus = torch.cuda.device_count()
-        return "-".join(map(str, range(num_gpus)))
-    else:
-        return "-"

rvc/infer/infer.py

@@ -58,7 +58,6 @@ class VoiceConverter:
         self.vc = None  # Voice conversion pipeline instance
         self.cpt = None  # Checkpoint for loading model weights
         self.version = None  # Model version
-        self.n_spk = None  # Number of speakers in the model
         self.use_f0 = None  # Whether the model uses F0
         self.loaded_model = None
 
@@ -356,72 +355,6 @@ class VoiceConverter:
             print(f"An error occurred during audio conversion: {error}")
             print(traceback.format_exc())
 
-    def convert_audio_batch(
-        self,
-        audio_input_paths: str,
-        audio_output_path: str,
-        **kwargs,
-    ):
-        """
-        Performs voice conversion on a batch of input audio files.
-
-        Args:
-            audio_input_paths (str): List of paths to the input audio files.
-            audio_output_path (str): Path to the output audio file.
-            resample_sr (int, optional): Resample sampling rate. Default is 0.
-            sid (int, optional): Speaker ID. Default is 0.
-            **kwargs: Additional keyword arguments.
-        """
-        pid = os.getpid()
-        try:
-            with open(
-                os.path.join(now_dir, "assets", "infer_pid.txt"), "w"
-            ) as pid_file:
-                pid_file.write(str(pid))
-            start_time = time.time()
-            print(f"Converting audio batch '{audio_input_paths}'...")
-            audio_files = [
-                f
-                for f in os.listdir(audio_input_paths)
-                if f.endswith(
-                    (
-                        "wav",
-                        "mp3",
-                        "flac",
-                        "ogg",
-                        "opus",
-                        "m4a",
-                        "mp4",
-                        "aac",
-                        "alac",
-                        "wma",
-                        "aiff",
-                        "webm",
-                        "ac3",
-                    )
-                )
-            ]
-            print(f"Detected {len(audio_files)} audio files for inference.")
-            for a in audio_files:
-                new_input = os.path.join(audio_input_paths, a)
-                new_output = os.path.splitext(a)[0] + "_output.wav"
-                new_output = os.path.join(audio_output_path, new_output)
-                if os.path.exists(new_output):
-                    continue
-                self.convert_audio(
-                    audio_input_path=new_input,
-                    audio_output_path=new_output,
-                    **kwargs,
-                )
-            print(f"Conversion completed at '{audio_input_paths}'.")
-            elapsed_time = time.time() - start_time
-            print(f"Batch conversion completed in {elapsed_time:.2f} seconds.")
-        except Exception as error:
-            print(f"An error occurred during audio batch conversion: {error}")
-            print(traceback.format_exc())
-        finally:
-            os.remove(os.path.join(now_dir, "assets", "infer_pid.txt"))
-
     def get_vc(self, weight_root, sid):
         """
         Loads the voice conversion model and sets up the pipeline.
@@ -447,8 +380,8 @@ class VoiceConverter:
         Cleans up the model and releases resources.
         """
         if self.hubert_model is not None:
-            del self.net_g, self.n_spk, self.vc, self.hubert_model, self.tgt_sr
-            self.hubert_model = self.net_g = self.n_spk = self.vc = self.tgt_sr = None
+            del self.net_g, self.vc, self.hubert_model, self.tgt_sr
+            self.hubert_model = self.net_g = self.vc = self.tgt_sr = None
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
 
@@ -500,4 +433,3 @@ class VoiceConverter:
         """
         if self.cpt is not None:
             self.vc = VC(self.tgt_sr, self.config)
-            self.n_spk = self.cpt["config"][-3]

rvc/infer/pipeline.py

@@ -145,7 +145,6 @@ class Pipeline:
         self.t_query = self.sample_rate * self.x_query
         self.t_center = self.sample_rate * self.x_center
         self.t_max = self.sample_rate * self.x_max
-        self.time_step = self.window / self.sample_rate * 1000
         self.f0_min = 50
         self.f0_max = 1100
         self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)

rvc/lib/algorithm/commons.py

@@ -40,23 +40,6 @@ def convert_pad_shape(pad_shape):
     return pad_shape
 
 
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """
-    Calculate the KL divergence between two distributions.
-
-    Args:
-        m_p: The mean of the first distribution.
-        logs_p: The log of the standard deviation of the first distribution.
-        m_q: The mean of the second distribution.
-        logs_q: The log of the standard deviation of the second distribution.
-    """
-    kl = (logs_q - logs_p) - 0.5
-    kl += (
-        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
-    )
-    return kl
-
-
 def slice_segments(
     x: torch.Tensor, ids_str: torch.Tensor, segment_size: int = 4, dim: int = 2
 ):
@@ -103,42 +86,6 @@ def rand_slice_segments(x, x_lengths=None, segment_size=4):
     return ret, ids_str
 
 
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    """
-    Generate a 1D timing signal.
-
-    Args:
-        length: The length of the signal.
-        channels: The number of channels of the signal.
-        min_timescale: The minimum timescale.
-        max_timescale: The maximum timescale.
-    """
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
-        num_timescales - 1
-    )
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
-    )
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = torch.nn.functional.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-
-
-def subsequent_mask(length):
-    """
-    Generate a subsequent mask.
-
-    Args:
-        length: The length of the sequence.
-    """
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-
-
 @torch.jit.script
 def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
     """

rvc/lib/algorithm/generators.py

@@ -127,7 +127,6 @@ class SineGen(torch.nn.Module):
         sine_amp=0.1,
         noise_std=0.003,
         voiced_threshold=0,
-        flag_for_pulse=False,
     ):
         super(SineGen, self).__init__()
         self.sine_amp = sine_amp

rvc/lib/algorithm/nsf.py

@@ -84,7 +84,6 @@ class GeneratorNSF(torch.nn.Module):
 
         self.num_kernels = len(resblock_kernel_sizes)
         self.num_upsamples = len(upsample_rates)
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=math.prod(upsample_rates))
         self.m_source = SourceModuleHnNSF(
             sample_rate=sr, harmonic_num=0, is_half=is_half
         )

rvc/lib/predictors/FCPE.py

@@ -60,22 +60,10 @@ def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False
     return data, sample_rate
 
 
-def dynamic_range_compression(x, C=1, clip_val=1e-5):
-    return np.log(np.clip(x, a_min=clip_val, a_max=None) * C)
-
-
-def dynamic_range_decompression(x, C=1):
-    return np.exp(x) / C
-
-
 def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
     return torch.log(torch.clamp(x, min=clip_val) * C)
 
 
-def dynamic_range_decompression_torch(x, C=1):
-    return torch.exp(x) / C
-
-
 class STFT:
     def __init__(
         self,
@@ -235,10 +223,6 @@ def default(val, d):
     return val if exists(val) else d
 
 
-def cast_tuple(val):
-    return (val,) if not isinstance(val, tuple) else val
-
-
 class PCmer(nn.Module):
     def __init__(
         self,
@@ -469,7 +453,6 @@ class SelfAttention(nn.Module):
         local_heads=0,
         local_window_size=256,
         nb_features=None,
-        feature_redraw_interval=1000,
         generalized_attention=False,
         kernel_fn=nn.ReLU(),
         qr_uniform_q=False,
@@ -521,8 +504,6 @@ class SelfAttention(nn.Module):
         context=None,
         mask=None,
         context_mask=None,
-        name=None,
-        inference=False,
         **kwargs,
     ):
         _, _, _, h, gh = *x.shape, self.heads, self.global_heads
@@ -827,9 +808,6 @@ class F0Predictor(object):
     def compute_f0(self, wav, p_len):
         pass
 
-    def compute_f0_uv(self, wav, p_len):
-        pass
-
 
 class FCPEF0Predictor(F0Predictor):
     def __init__(
@@ -908,13 +886,3 @@ class FCPEF0Predictor(F0Predictor):
                 f0.cpu().numpy() if p_len is None else np.zeros(p_len)
             )
         return self.post_process(x, self.sample_rate, f0, p_len)[0]
-
-    def compute_f0_uv(self, wav, p_len=None):
-        x = torch.FloatTensor(wav).to(self.dtype).to(self.device)
-        p_len = x.shape[0] // self.hop_length if p_len is None else p_len
-        f0 = self.fcpe(x, sr=self.sample_rate, threshold=self.threshold)[0, :, 0]
-        if torch.all(f0 == 0):
-            return f0.cpu().numpy() if p_len is None else np.zeros(p_len), (
-                f0.cpu().numpy() if p_len is None else np.zeros(p_len)
-            )
-        return self.post_process(x, self.sample_rate, f0, p_len)

rvc/lib/predictors/RMVPE.py

@@ -134,7 +134,6 @@ class Encoder(nn.Module):
             in_channels = out_channels
             out_channels *= 2
             in_size //= 2
-        self.out_size = in_size
         self.out_channel = out_channels
 
     def forward(self, x: torch.Tensor):

rvc/lib/tools/gdown.py

@@ -24,10 +24,6 @@ class FileURLRetrievalError(Exception):
     pass
 
 
-class FolderContentsMaximumLimitError(Exception):
-    pass
-
-
 def parse_url(url, warning=True):
     """Parse URLs especially for Google Drive links.
 
@@ -126,7 +122,6 @@ def _get_session(proxy, use_cookies, return_cookies_file=False):
     )
 
     if proxy is not None:
-        sess.proxies = {"http": proxy, "https": proxy}
         print("Using proxy:", proxy, file=sys.stderr)
 
     cookies_file = os.path.join(HOME, ".cache/gdown/cookies.json")

rvc/lib/tools/model_download.py

@@ -42,20 +42,6 @@ def search_pth_index(folder):
     return pth_paths, index_paths
 
 
-def get_mediafire_download_link(url):
-    response = requests.get(url)
-    response.raise_for_status()
-    soup = BeautifulSoup(response.text, "html.parser")
-    download_button = soup.find(
-        "a", {"class": "input popsok", "aria-label": "Download file"}
-    )
-    if download_button:
-        download_link = download_button.get("href")
-        return download_link
-    else:
-        return None
-
-
 def download_from_url(url):
     os.makedirs(zips_path, exist_ok=True)
     if url != "":
@@ -271,14 +257,6 @@ def extract_and_show_progress(zipfile_path, unzips_path):
         return False
 
 
-def unzip_file(zip_path, zip_file_name):
-    zip_file_path = os.path.join(zip_path, zip_file_name + ".zip")
-    extract_path = os.path.join(file_path, zip_file_name)
-    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
-        zip_ref.extractall(extract_path)
-    os.remove(zip_file_path)
-
-
 def model_download_pipeline(url: str):
     try:
         verify = download_from_url(url)

rvc/lib/tools/prerequisites_download.py

@@ -1,7 +1,10 @@
 import os
 from concurrent.futures import ThreadPoolExecutor
-from tqdm import tqdm
+
 import requests
+from tqdm import tqdm
+
+from tts_service.voices import voice_manager
 
 url_base = "https://huggingface.co/IAHispano/Applio/resolve/main/Resources"
 
@@ -45,9 +48,6 @@ pretraineds_v2_list = [
 ]
 models_list = [("predictors/", ["rmvpe.pt", "fcpe.pt"])]
 embedders_list = [("embedders/contentvec/", ["pytorch_model.bin", "config.json"])]
-executables_list = [
-    ("", ["ffmpeg.exe", "ffprobe.exe"]),
-]
 
 folder_mapping_list = {
     "pretrained_v1/": "rvc/models/pretraineds/pretrained_v1/",
@@ -58,7 +58,7 @@ folder_mapping_list = {
 }
 
 
-def get_file_size_if_missing(file_list):
+def get_file_size_if_missing(file_list: list[tuple[str, list[str]]]) -> int:
     """
     Calculate the total size of files to be downloaded only if they do not exist locally.
     """
@@ -74,7 +74,7 @@ def get_file_size_if_missing(file_list):
     return total_size
 
 
-def download_file(url, destination_path, global_bar):
+def download_file(url: str, destination_path: str, global_bar: tqdm) -> None:
     """
     Download a file from the given URL to the specified destination path,
     updating the global progress bar as data is downloaded.
@@ -91,7 +91,7 @@ def download_file(url, destination_path, global_bar):
             global_bar.update(len(data))
 
 
-def download_mapping_files(file_mapping_list, global_bar):
+def download_mapping_files(file_mapping_list: list[tuple[str, list[str]]], global_bar: tqdm) -> None:
     """
     Download all files in the provided file mapping list using a thread pool executor,
     and update the global progress bar as downloads progress.
@@ -104,16 +104,14 @@ def download_mapping_files(file_mapping_list, global_bar):
                 destination_path = os.path.join(local_folder, file)
                 if not os.path.exists(destination_path):
                     url = f"{url_base}/{remote_folder}{file}"
-                    futures.append(
-                        executor.submit(
-                            download_file, url, destination_path, global_bar
-                        )
-                    )
+                    futures.append(executor.submit(download_file, url, destination_path, global_bar))
         for future in futures:
             future.result()
 
 
-def split_pretraineds(pretrained_list):
+def split_pretraineds(
+    pretrained_list: list[tuple[str, list[str]]],
+) -> tuple[list[tuple[str, list[str]]], list[tuple[str, list[str]]]]:
     f0_list = []
     non_f0_list = []
     for folder, files in pretrained_list:
@@ -126,22 +124,18 @@ def split_pretraineds(pretrained_list):
     return f0_list, non_f0_list
 
 
-pretraineds_v1_f0_list, pretraineds_v1_nof0_list = split_pretraineds(
-    pretraineds_v1_list
-)
-pretraineds_v2_f0_list, pretraineds_v2_nof0_list = split_pretraineds(
-    pretraineds_v2_list
-)
+pretraineds_v1_f0_list, pretraineds_v1_nof0_list = split_pretraineds(pretraineds_v1_list)
+pretraineds_v2_f0_list, pretraineds_v2_nof0_list = split_pretraineds(pretraineds_v2_list)
 
 
 def calculate_total_size(
-    pretraineds_v1_f0,
-    pretraineds_v1_nof0,
-    pretraineds_v2_f0,
-    pretraineds_v2_nof0,
-    models,
-    exe,
-):
+    pretraineds_v1_f0: list[tuple[str, list[str]]],
+    pretraineds_v1_nof0: list[tuple[str, list[str]]],
+    pretraineds_v2_f0: list[tuple[str, list[str]]],
+    pretraineds_v2_nof0: list[tuple[str, list[str]]],
+    models: bool,
+    voices: bool,
+) -> int:
     """
     Calculate the total size of all files to be downloaded based on selected categories.
     """
@@ -149,23 +143,23 @@ def calculate_total_size(
     if models:
         total_size += get_file_size_if_missing(models_list)
         total_size += get_file_size_if_missing(embedders_list)
-    if exe and os.name == "nt":
-        total_size += get_file_size_if_missing(executables_list)
     total_size += get_file_size_if_missing(pretraineds_v1_f0)
     total_size += get_file_size_if_missing(pretraineds_v1_nof0)
     total_size += get_file_size_if_missing(pretraineds_v2_f0)
     total_size += get_file_size_if_missing(pretraineds_v2_nof0)
+    if voices:
+        total_size += voice_manager.get_voices_size_if_missing()
     return total_size
 
 
 def prequisites_download_pipeline(
-    pretraineds_v1_f0,
-    pretraineds_v1_nof0,
-    pretraineds_v2_f0,
-    pretraineds_v2_nof0,
-    models,
-    exe,
-):
+    pretraineds_v1_f0: bool,
+    pretraineds_v1_nof0: bool,
+    pretraineds_v2_f0: bool,
+    pretraineds_v2_nof0: bool,
+    models: bool,
+    voices: bool,
+) -> None:
     """
     Manage the download pipeline for different categories of files.
     """
@@ -175,21 +169,14 @@ def prequisites_download_pipeline(
         pretraineds_v2_f0_list if pretraineds_v2_f0 else [],
         pretraineds_v2_nof0_list if pretraineds_v2_nof0 else [],
         models,
-        exe,
+        voices,
     )
 
     if total_size > 0:
-        with tqdm(
-            total=total_size, unit="iB", unit_scale=True, desc="Downloading all files"
-        ) as global_bar:
+        with tqdm(total=total_size, unit="iB", unit_scale=True, desc="Downloading all files") as global_bar:
             if models:
                 download_mapping_files(models_list, global_bar)
                 download_mapping_files(embedders_list, global_bar)
-            if exe:
-                if os.name == "nt":
-                    download_mapping_files(executables_list, global_bar)
-                else:
-                    print("No executables needed")
             if pretraineds_v1_f0:
                 download_mapping_files(pretraineds_v1_f0_list, global_bar)
             if pretraineds_v1_nof0:
@@ -198,5 +185,7 @@ def prequisites_download_pipeline(
                 download_mapping_files(pretraineds_v2_f0_list, global_bar)
             if pretraineds_v2_nof0:
                 download_mapping_files(pretraineds_v2_nof0_list, global_bar)
+            if voices:
+                voice_manager.download_voice_files(global_bar)
     else:
         pass

rvc/lib/utils.py

@@ -5,9 +5,6 @@ import numpy as np
 import re
 import unicodedata
 import wget
-import subprocess
-from pydub import AudioSegment
-import tempfile
 from torch import nn
 
 import logging
@@ -35,20 +32,6 @@ class HubertModelWithFinalProj(HubertModel):
         self.final_proj = nn.Linear(config.hidden_size, config.classifier_proj_size)
 
 
-def load_audio(file, sample_rate):
-    try:
-        file = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-        audio, sr = sf.read(file)
-        if len(audio.shape) > 1:
-            audio = librosa.to_mono(audio.T)
-        if sr != sample_rate:
-            audio = librosa.resample(audio, orig_sr=sr, target_sr=sample_rate)
-    except Exception as error:
-        raise RuntimeError(f"An error occurred loading the audio: {error}")
-
-    return audio.flatten()
-
-
 def load_audio_infer(
     file,
     sample_rate,

rvc/train/mel_processing.py

@@ -15,17 +15,6 @@ def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
     return torch.log(torch.clamp(x, min=clip_val) * C)
 
 
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    Dynamic range decompression using exp.
-
-    Args:
-        x (torch.Tensor): Input tensor.
-        C (float, optional): Scaling factor. Defaults to 1.
-    """
-    return torch.exp(x) / C
-
-
 def spectral_normalize_torch(magnitudes):
     """
     Spectral normalization using dynamic range compression.
@@ -36,16 +25,6 @@ def spectral_normalize_torch(magnitudes):
     return dynamic_range_compression_torch(magnitudes)
 
 
-def spectral_de_normalize_torch(magnitudes):
-    """
-    Spectral de-normalization using dynamic range decompression.
-
-    Args:
-        magnitudes (torch.Tensor): Normalized spectrogram.
-    """
-    return dynamic_range_decompression_torch(magnitudes)
-
-
 mel_basis = {}
 hann_window = {}
 

rvc/train/process/extract_small_model.py

@@ -19,165 +19,3 @@ def replace_keys_in_dict(d, old_key_part, new_key_part):
             value = replace_keys_in_dict(value, old_key_part, new_key_part)
         updated_dict[new_key] = value
     return updated_dict
-
-
-def extract_small_model(
-    path: str,
-    name: str,
-    sr: int,
-    pitch_guidance: bool,
-    version: str,
-    epoch: int,
-    step: int,
-):
-    try:
-        ckpt = torch.load(path, map_location="cpu")
-        pth_file = f"{name}.pth"
-        pth_file_old_version_path = os.path.join("logs", f"{pth_file}_old_version.pth")
-        opt = OrderedDict(
-            weight={
-                key: value.half() for key, value in ckpt.items() if "enc_q" not in key
-            }
-        )
-        if "model" in ckpt:
-            ckpt = ckpt["model"]
-        opt = OrderedDict()
-        opt["weight"] = {}
-        for key in ckpt.keys():
-            if "enc_q" in key:
-                continue
-            opt["weight"][key] = ckpt[key].half()
-        if sr == "40000":
-            opt["config"] = [
-                1025,
-                32,
-                192,
-                192,
-                768,
-                2,
-                6,
-                3,
-                0,
-                "1",
-                [3, 7, 11],
-                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-                [10, 10, 2, 2],
-                512,
-                [16, 16, 4, 4],
-                109,
-                256,
-                40000,
-            ]
-        elif sr == "48000":
-            if version == "v1":
-                opt["config"] = [
-                    1025,
-                    32,
-                    192,
-                    192,
-                    768,
-                    2,
-                    6,
-                    3,
-                    0,
-                    "1",
-                    [3, 7, 11],
-                    [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-                    [10, 6, 2, 2, 2],
-                    512,
-                    [16, 16, 4, 4, 4],
-                    109,
-                    256,
-                    48000,
-                ]
-            else:
-                opt["config"] = [
-                    1025,
-                    32,
-                    192,
-                    192,
-                    768,
-                    2,
-                    6,
-                    3,
-                    0,
-                    "1",
-                    [3, 7, 11],
-                    [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-                    [12, 10, 2, 2],
-                    512,
-                    [24, 20, 4, 4],
-                    109,
-                    256,
-                    48000,
-                ]
-        elif sr == "32000":
-            if version == "v1":
-                opt["config"] = [
-                    513,
-                    32,
-                    192,
-                    192,
-                    768,
-                    2,
-                    6,
-                    3,
-                    0,
-                    "1",
-                    [3, 7, 11],
-                    [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-                    [10, 4, 2, 2, 2],
-                    512,
-                    [16, 16, 4, 4, 4],
-                    109,
-                    256,
-                    32000,
-                ]
-            else:
-                opt["config"] = [
-                    513,
-                    32,
-                    192,
-                    192,
-                    768,
-                    2,
-                    6,
-                    3,
-                    0,
-                    "1",
-                    [3, 7, 11],
-                    [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-                    [10, 8, 2, 2],
-                    512,
-                    [20, 16, 4, 4],
-                    109,
-                    256,
-                    32000,
-                ]
-
-        opt["epoch"] = epoch
-        opt["step"] = step
-        opt["sr"] = sr
-        opt["f0"] = int(pitch_guidance)
-        opt["version"] = version
-        opt["creation_date"] = datetime.datetime.now().isoformat()
-
-        hash_input = f"{str(ckpt)} {epoch} {step} {datetime.datetime.now().isoformat()}"
-        model_hash = hashlib.sha256(hash_input.encode()).hexdigest()
-        opt["model_hash"] = model_hash
-
-        model = torch.load(pth_file_old_version_path, map_location=torch.device("cpu"))
-        torch.save(
-            replace_keys_in_dict(
-                replace_keys_in_dict(
-                    model, ".parametrizations.weight.original1", ".weight_v"
-                ),
-                ".parametrizations.weight.original0",
-                ".weight_g",
-            ),
-            pth_file_old_version_path,
-        )
-        os.remove(pth_file_old_version_path)
-        os.rename(pth_file_old_version_path, pth_file)
-    except Exception as error:
-        print(f"An error occurred extracting the model: {error}")

rvc/train/process/model_blender.py

@@ -12,57 +12,3 @@ def extract(ckpt):
             continue
         opt["weight"][key] = a[key]
     return opt
-
-
-def model_blender(name, path1, path2, ratio):
-    try:
-        message = f"Model {path1} and {path2} are merged with alpha {ratio}."
-        ckpt1 = torch.load(path1, map_location="cpu")
-        ckpt2 = torch.load(path2, map_location="cpu")
-
-        if ckpt1["sr"] != ckpt2["sr"]:
-            return "The sample rates of the two models are not the same."
-
-        cfg = ckpt1["config"]
-        cfg_f0 = ckpt1["f0"]
-        cfg_version = ckpt1["version"]
-        cfg_sr = ckpt1["sr"]
-
-        if "model" in ckpt1:
-            ckpt1 = extract(ckpt1)
-        else:
-            ckpt1 = ckpt1["weight"]
-        if "model" in ckpt2:
-            ckpt2 = extract(ckpt2)
-        else:
-            ckpt2 = ckpt2["weight"]
-
-        if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())):
-            return "Fail to merge the models. The model architectures are not the same."
-
-        opt = OrderedDict()
-        opt["weight"] = {}
-        for key in ckpt1.keys():
-            if key == "emb_g.weight" and ckpt1[key].shape != ckpt2[key].shape:
-                min_shape0 = min(ckpt1[key].shape[0], ckpt2[key].shape[0])
-                opt["weight"][key] = (
-                    ratio * (ckpt1[key][:min_shape0].float())
-                    + (1 - ratio) * (ckpt2[key][:min_shape0].float())
-                ).half()
-            else:
-                opt["weight"][key] = (
-                    ratio * (ckpt1[key].float()) + (1 - ratio) * (ckpt2[key].float())
-                ).half()
-
-        opt["config"] = cfg
-        opt["sr"] = cfg_sr
-        opt["f0"] = cfg_f0
-        opt["version"] = cfg_version
-        opt["info"] = message
-
-        torch.save(opt, os.path.join("logs", f"{name}.pth"))
-        print(message)
-        return message, os.path.join("logs", f"{name}.pth")
-    except Exception as error:
-        print(f"An error occurred blending the models: {error}")
-        return error

rvc/train/train.py

@@ -27,7 +27,7 @@ sys.path.append(os.path.join(now_dir))
 # Zluda hijack
 import rvc.lib.zluda
 
-from utils import (
+from .utils import (
     HParams,
     plot_spectrogram_to_numpy,
     summarize,
@@ -37,13 +37,13 @@ from utils import (
     load_wav_to_torch,
 )
 
-from losses import (
+from .losses import (
     discriminator_loss,
     feature_loss,
     generator_loss,
     kl_loss,
 )
-from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
+from .mel_processing import mel_spectrogram_torch, spec_to_mel_torch
 
 from rvc.train.process.extract_model import extract_model
 
@@ -56,7 +56,6 @@ total_epoch = int(sys.argv[3])
 pretrainG = sys.argv[4]
 pretrainD = sys.argv[5]
 version = sys.argv[6]
-gpus = sys.argv[7]
 batch_size = int(sys.argv[8])
 sample_rate = int(sys.argv[9])
 pitch_guidance = strtobool(sys.argv[10])
@@ -70,7 +69,6 @@ cleanup = strtobool(sys.argv[16])
 current_dir = os.getcwd()
 experiment_dir = os.path.join(current_dir, "logs", model_name)
 config_save_path = os.path.join(experiment_dir, "config.json")
-dataset_path = os.path.join(experiment_dir, "sliced_audios")
 
 with open(config_save_path, "r") as f:
     config = json.load(f)
@@ -81,8 +79,6 @@ torch.backends.cudnn.deterministic = False
 torch.backends.cudnn.benchmark = False
 
 global_step = 0
-last_loss_gen_all = 0
-overtrain_save_epoch = 0
 loss_gen_history = []
 smoothed_loss_gen_history = []
 loss_disc_history = []
@@ -139,7 +135,7 @@ def main():
     """
     Main function to start the training process.
     """
-    global training_file_path, last_loss_gen_all, smoothed_loss_gen_history, loss_gen_history, loss_disc_history, smoothed_loss_disc_history, overtrain_save_epoch
+    global training_file_path, smoothed_loss_gen_history, loss_gen_history, loss_disc_history, smoothed_loss_disc_history
 
     os.environ["MASTER_ADDR"] = "localhost"
     os.environ["MASTER_PORT"] = str(randint(20000, 55555))
@@ -322,7 +318,7 @@ def run(
         torch.cuda.set_device(rank)
 
     # Create datasets and dataloaders
-    from data_utils import (
+    from .data_utils import (
         DistributedBucketSampler,
         TextAudioCollateMultiNSFsid,
         TextAudioLoaderMultiNSFsid,
@@ -533,7 +529,6 @@ def train_and_evaluate(
 
     if epoch == 1:
         lowest_value = {"step": 0, "value": float("inf"), "epoch": 0}
-        last_loss_gen_all = 0.0
         consecutive_increases_gen = 0
         consecutive_increases_disc = 0
 
@@ -888,7 +883,6 @@ def train_and_evaluate(
                 + f" | Number of epochs remaining for overtraining: g/total: {remaining_epochs_gen} d/total: {remaining_epochs_disc} | smoothed_loss_gen={smoothed_value_gen:.3f} | smoothed_loss_disc={smoothed_value_disc:.3f}"
             )
         print(record)
-        last_loss_gen_all = loss_gen_all
 
         if done:
             os._exit(2333333)
@@ -953,8 +947,3 @@ def save_to_json(
     }
     with open(file_path, "w") as f:
         json.dump(data, f)
-
-
-if __name__ == "__main__":
-    torch.multiprocessing.set_start_method("spawn")
-    main()

tabs/plugins/plugins.py

@@ -11,24 +11,3 @@ now_dir = os.getcwd()
 sys.path.append(now_dir)
 
 plugins_core.check_new_folders()
-
-
-def plugins_tab():
-    with gr.TabItem(i18n("Plugin Installer")):
-        dropbox = gr.File(
-            label=i18n("Drag your plugin.zip to install it"),
-            type="filepath",
-        )
-
-        dropbox.upload(
-            fn=plugins_core.save_plugin_dropbox,
-            inputs=[dropbox],
-            outputs=[dropbox],
-        )
-
-    for plugin in os.listdir(os.path.join(now_dir, "tabs", "plugins", "installed")):
-        plugin_main = f"tabs.plugins.installed.{plugin}.plugin"
-        plugin_import = importlib.import_module(plugin_main)
-
-        with gr.TabItem(plugin):
-            plugin_import.applio_plugin()

tabs/plugins/plugins_core.py

@@ -37,65 +37,6 @@ def save_existing_folders(existing_folders):
         json.dump(config, file, indent=2)
 
 
-def save_plugin_dropbox(dropbox):
-    if "zip" not in dropbox:
-        raise gr.Error(
-            message="The file you dropped is not a valid plugin.zip. Please try again."
-        )
-    else:
-        file_name = os.path.basename(dropbox)
-        folder_name = file_name.split(".zip")[0]
-        folder_path = os.path.join(plugins_path, folder_name)
-        zip_file_path = os.path.join(plugins_path, file_name)
-
-        if os.path.exists(folder_name):
-            os.remove(folder_name)
-
-        shutil.move(dropbox, os.path.join(plugins_path, file_name))
-        print("Proceeding with the extraction...")
-
-        with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
-            zip_ref.extractall(plugins_path)
-        os.remove(zip_file_path)
-
-        if os.path.exists(os.path.join(folder_path, "requirements.txt")):
-            if os.name == "nt":
-                subprocess.run(
-                    [
-                        os.path.join("env", "python.exe"),
-                        "-m",
-                        "pip",
-                        "install",
-                        "-r",
-                        os.path.join(folder_path, "requirements.txt"),
-                    ]
-                )
-            else:
-                subprocess.run(
-                    [
-                        "python",
-                        "-m",
-                        "pip",
-                        "install",
-                        "-r",
-                        os.path.join(folder_path, "requirements.txt"),
-                    ]
-                )
-        else:
-            print("No requirements.txt file found in the plugin folder.")
-
-        save_existing_folders(get_existing_folders() + [folder_name])
-
-        print(
-            f"{folder_name} plugin installed in {plugins_path}! Restarting applio to apply the changes."
-        )
-        gr.Info(
-            f"{folder_name} plugin installed in {plugins_path}! Restarting applio to apply the changes."
-        )
-        restart_applio()
-    return None
-
-
 def check_new_folders():
     existing_folders = get_existing_folders()
     new_folders = set(current_folders) - set(existing_folders)

tabs/settings/sections/restart.py

@@ -6,33 +6,6 @@ import json
 now_dir = os.getcwd()
 
 
-def stop_train(model_name: str):
-    pid_file_path = os.path.join(now_dir, "logs", model_name, "config.json")
-    try:
-        with open(pid_file_path, "r") as pid_file:
-            pid_data = json.load(pid_file)
-            pids = pid_data.get("process_pids", [])
-        with open(pid_file_path, "w") as pid_file:
-            pid_data.pop("process_pids", None)
-            json.dump(pid_data, pid_file, indent=4)
-        for pid in pids:
-            os.kill(pid, 9)
-    except:
-        pass
-
-
-def stop_infer():
-    pid_file_path = os.path.join(now_dir, "assets", "infer_pid.txt")
-    try:
-        with open(pid_file_path, "r") as pid_file:
-            pids = [int(pid) for pid in pid_file.readlines()]
-        for pid in pids:
-            os.kill(pid, 9)
-        os.remove(pid_file_path)
-    except:
-        pass
-
-
 def restart_applio():
     if os.name != "nt":
         os.system("clear")
@@ -45,14 +18,3 @@ def restart_applio():
 from assets.i18n.i18n import I18nAuto
 
 i18n = I18nAuto()
-
-
-def restart_tab():
-    with gr.Row():
-        with gr.Column():
-            restart_button = gr.Button(i18n("Restart Applio"))
-            restart_button.click(
-                fn=restart_applio,
-                inputs=[],
-                outputs=[],
-            )

tabs/train/train.py

@@ -1,77 +1,21 @@
 import os
 import shutil
 import sys
-from multiprocessing import cpu_count
 
 import gradio as gr
 
 from assets.i18n.i18n import I18nAuto
-from core import (
-    run_extract_script,
-    run_index_script,
-    run_preprocess_script,
-    run_prerequisites_script,
-    run_train_script,
-)
-from rvc.configs.config import get_gpu_info, get_number_of_gpus, max_vram_gpu
-from rvc.lib.utils import format_title
-from tabs.settings.sections.restart import stop_train
 
 i18n = I18nAuto()
 now_dir = os.getcwd()
 sys.path.append(now_dir)
 
-pretraineds_v1 = [
-    (
-        "pretrained_v1/",
-        [
-            "D32k.pth",
-            "D40k.pth",
-            "D48k.pth",
-            "G32k.pth",
-            "G40k.pth",
-            "G48k.pth",
-            "f0D32k.pth",
-            "f0D40k.pth",
-            "f0D48k.pth",
-            "f0G32k.pth",
-            "f0G40k.pth",
-            "f0G48k.pth",
-        ],
-    ),
-]
-
-folder_mapping = {
-    "pretrained_v1/": "rvc/models/pretraineds/pretrained_v1/",
-}
-
-sup_audioext = {
-    "wav",
-    "mp3",
-    "flac",
-    "ogg",
-    "opus",
-    "m4a",
-    "mp4",
-    "aac",
-    "alac",
-    "wma",
-    "aiff",
-    "webm",
-    "ac3",
-}
-
 # Custom Pretraineds
-pretraineds_custom_path = os.path.join(
-    now_dir, "rvc", "models", "pretraineds", "pretraineds_custom"
-)
+pretraineds_custom_path = os.path.join(now_dir, "rvc", "models", "pretraineds", "pretraineds_custom")
 
 pretraineds_custom_path_relative = os.path.relpath(pretraineds_custom_path, now_dir)
 
-custom_embedder_root = os.path.join(
-    now_dir, "rvc", "models", "embedders", "embedders_custom"
-)
-custom_embedder_root_relative = os.path.relpath(custom_embedder_root, now_dir)
+custom_embedder_root = os.path.join(now_dir, "rvc", "models", "embedders", "embedders_custom")
 
 os.makedirs(custom_embedder_root, exist_ok=True)
 os.makedirs(pretraineds_custom_path_relative, exist_ok=True)
@@ -86,968 +30,22 @@ def get_pretrained_list(suffix):
     ]
 
 
-pretraineds_list_d = get_pretrained_list("D")
-pretraineds_list_g = get_pretrained_list("G")
-
-
-def refresh_custom_pretraineds():
-    return (
-        {"choices": sorted(get_pretrained_list("G")), "__type__": "update"},
-        {"choices": sorted(get_pretrained_list("D")), "__type__": "update"},
-    )
-
-
 # Dataset Creator
 datasets_path = os.path.join(now_dir, "assets", "datasets")
 
 if not os.path.exists(datasets_path):
     os.makedirs(datasets_path)
 
-datasets_path_relative = os.path.relpath(datasets_path, now_dir)
-
-
-def get_datasets_list():
-    return [
-        dirpath
-        for dirpath, _, filenames in os.walk(datasets_path_relative)
-        if any(filename.endswith(tuple(sup_audioext)) for filename in filenames)
-    ]
-
-
-def refresh_datasets():
-    return {"choices": sorted(get_datasets_list()), "__type__": "update"}
-
-
-# Model Names
-models_path = os.path.join(now_dir, "logs")
-
-
-def get_models_list():
-    return [
-        os.path.basename(dirpath)
-        for dirpath in os.listdir(models_path)
-        if os.path.isdir(os.path.join(models_path, dirpath))
-        and all(excluded not in dirpath for excluded in ["zips", "mute", "reference"])
-    ]
-
-
-def refresh_models():
-    return {"choices": sorted(get_models_list()), "__type__": "update"}
-
-
-# Refresh Models and Datasets
-def refresh_models_and_datasets():
-    return (
-        {"choices": sorted(get_models_list()), "__type__": "update"},
-        {"choices": sorted(get_datasets_list()), "__type__": "update"},
-    )
-
-
-# Refresh Custom Embedders
-def get_embedder_custom_list():
-    return [
-        os.path.join(dirpath, dirname)
-        for dirpath, dirnames, _ in os.walk(custom_embedder_root_relative)
-        for dirname in dirnames
-    ]
-
-
-def refresh_custom_embedder_list():
-    return {"choices": sorted(get_embedder_custom_list()), "__type__": "update"}
-
 
 # Drop Model
 def save_drop_model(dropbox):
     if ".pth" not in dropbox:
-        gr.Info(
-            i18n(
-                "The file you dropped is not a valid pretrained file. Please try again."
-            )
-        )
+        gr.Info(i18n("The file you dropped is not a valid pretrained file. Please try again."))
     else:
         file_name = os.path.basename(dropbox)
         pretrained_path = os.path.join(pretraineds_custom_path_relative, file_name)
         if os.path.exists(pretrained_path):
             os.remove(pretrained_path)
         shutil.copy(dropbox, pretrained_path)
-        gr.Info(
-            i18n(
-                "Click the refresh button to see the pretrained file in the dropdown menu."
-            )
-        )
+        gr.Info(i18n("Click the refresh button to see the pretrained file in the dropdown menu."))
     return None
-
-
-# Drop Dataset
-def save_drop_dataset_audio(dropbox, dataset_name):
-    if not dataset_name:
-        gr.Info("Please enter a valid dataset name. Please try again.")
-        return None, None
-    else:
-        file_extension = os.path.splitext(dropbox)[1][1:].lower()
-        if file_extension not in sup_audioext:
-            gr.Info("The file you dropped is not a valid audio file. Please try again.")
-        else:
-            dataset_name = format_title(dataset_name)
-            audio_file = format_title(os.path.basename(dropbox))
-            dataset_path = os.path.join(now_dir, "assets", "datasets", dataset_name)
-            if not os.path.exists(dataset_path):
-                os.makedirs(dataset_path)
-            destination_path = os.path.join(dataset_path, audio_file)
-            if os.path.exists(destination_path):
-                os.remove(destination_path)
-            shutil.copy(dropbox, destination_path)
-            gr.Info(
-                i18n(
-                    "The audio file has been successfully added to the dataset. Please click the preprocess button."
-                )
-            )
-            dataset_path = os.path.dirname(destination_path)
-            relative_dataset_path = os.path.relpath(dataset_path, now_dir)
-
-            return None, relative_dataset_path
-
-
-# Drop Custom Embedder
-def create_folder_and_move_files(folder_name, bin_file, config_file):
-    if not folder_name:
-        return "Folder name must not be empty."
-
-    folder_name = os.path.join(custom_embedder_root, folder_name)
-    os.makedirs(folder_name, exist_ok=True)
-
-    if bin_file:
-        bin_file_path = os.path.join(folder_name, os.path.basename(bin_file))
-        shutil.copy(bin_file, bin_file_path)
-
-    if config_file:
-        config_file_path = os.path.join(folder_name, os.path.basename(config_file))
-        shutil.copy(config_file, config_file_path)
-
-    return f"Files moved to folder {folder_name}"
-
-
-def refresh_embedders_folders():
-    custom_embedders = [
-        os.path.join(dirpath, dirname)
-        for dirpath, dirnames, _ in os.walk(custom_embedder_root_relative)
-        for dirname in dirnames
-    ]
-    return custom_embedders
-
-
-# Export
-## Get Pth and Index Files
-def get_pth_list():
-    return [
-        os.path.relpath(os.path.join(dirpath, filename), now_dir)
-        for dirpath, _, filenames in os.walk(models_path)
-        for filename in filenames
-        if filename.endswith(".pth")
-    ]
-
-
-def get_index_list():
-    return [
-        os.path.relpath(os.path.join(dirpath, filename), now_dir)
-        for dirpath, _, filenames in os.walk(models_path)
-        for filename in filenames
-        if filename.endswith(".index") and "trained" not in filename
-    ]
-
-
-def refresh_pth_and_index_list():
-    return (
-        {"choices": sorted(get_pth_list()), "__type__": "update"},
-        {"choices": sorted(get_index_list()), "__type__": "update"},
-    )
-
-
-## Export Pth and Index Files
-def export_pth(pth_path):
-    if pth_path and os.path.exists(pth_path):
-        return pth_path
-    return None
-
-
-def export_index(index_path):
-    if index_path and os.path.exists(index_path):
-        return index_path
-    return None
-
-
-## Upload to Google Drive
-def upload_to_google_drive(pth_path, index_path):
-    def upload_file(file_path):
-        if file_path:
-            try:
-                gr.Info(f"Uploading {pth_path} to Google Drive...")
-                google_drive_folder = "/content/drive/MyDrive/ApplioExported"
-                if not os.path.exists(google_drive_folder):
-                    os.makedirs(google_drive_folder)
-                google_drive_file_path = os.path.join(
-                    google_drive_folder, os.path.basename(file_path)
-                )
-                if os.path.exists(google_drive_file_path):
-                    os.remove(google_drive_file_path)
-                shutil.copy2(file_path, google_drive_file_path)
-                gr.Info("File uploaded successfully.")
-            except Exception as error:
-                print(f"An error occurred uploading to Google Drive: {error}")
-                gr.Info("Error uploading to Google Drive")
-
-    upload_file(pth_path)
-    upload_file(index_path)
-
-
-# Train Tab
-def train_tab():
-    with gr.Row():
-        model_name = gr.Dropdown(
-            label=i18n("Model Name"),
-            info=i18n("Name of the new model."),
-            choices=get_models_list(),
-            value="my-project",
-            interactive=True,
-            allow_custom_value=True,
-        )
-        sampling_rate = gr.Radio(
-            label=i18n("Sampling Rate"),
-            info=i18n("The sampling rate of the audio files."),
-            choices=["32000", "40000", "48000"],
-            value="40000",
-            interactive=True,
-        )
-        rvc_version = gr.Radio(
-            label=i18n("Model Architecture"),
-            info=i18n("Version of the model architecture."),
-            choices=["v1", "v2"],
-            value="v2",
-            interactive=True,
-            visible=False,
-        )
-    with gr.Accordion(i18n("Preprocess")):
-        dataset_path = gr.Dropdown(
-            label=i18n("Dataset Path"),
-            info=i18n("Path to the dataset folder."),
-            # placeholder=i18n("Enter dataset path"),
-            choices=get_datasets_list(),
-            allow_custom_value=True,
-            interactive=True,
-        )
-        dataset_creator = gr.Checkbox(
-            label=i18n("Dataset Creator"),
-            value=False,
-            interactive=True,
-            visible=True,
-        )
-        with gr.Column(visible=False) as dataset_creator_settings:
-            with gr.Accordion(i18n("Dataset Creator")):
-                dataset_name = gr.Textbox(
-                    label=i18n("Dataset Name"),
-                    info=i18n("Name of the new dataset."),
-                    placeholder=i18n("Enter dataset name"),
-                    interactive=True,
-                )
-                upload_audio_dataset = gr.File(
-                    label=i18n("Upload Audio Dataset"),
-                    type="filepath",
-                    interactive=True,
-                )
-        refresh = gr.Button(i18n("Refresh"))
-
-        with gr.Accordion(i18n("Advanced Settings"), open=False):
-            cpu_cores_preprocess = gr.Slider(
-                1,
-                min(cpu_count(), 32),  # max 32 parallel processes
-                min(cpu_count(), 32),
-                step=1,
-                label=i18n("CPU Cores"),
-                info=i18n(
-                    "The number of CPU cores to use in the preprocess. The default setting are your cpu cores, which is recommended for most cases."
-                ),
-                interactive=True,
-            )
-            with gr.Row():
-                cut_preprocess = gr.Checkbox(
-                    label=i18n("Audio cutting"),
-                    info=i18n(
-                        "It's recommended to deactivate this option if your dataset has already been processed."
-                    ),
-                    value=True,
-                    interactive=True,
-                    visible=True,
-                )
-                process_effects = gr.Checkbox(
-                    label=i18n("Process effects"),
-                    info=i18n(
-                        "It's recommended to deactivate this option if your dataset has already been processed."
-                    ),
-                    value=True,
-                    interactive=True,
-                    visible=True,
-                )
-            with gr.Row():
-                noise_reduction = gr.Checkbox(
-                    label=i18n("Noise Reduction"),
-                    info=i18n(
-                        "It's recommended keep deactivate this option if your dataset has already been processed."
-                    ),
-                    value=False,
-                    interactive=True,
-                    visible=True,
-                )
-                clean_strength = gr.Slider(
-                    minimum=0,
-                    maximum=1,
-                    label=i18n("Noise Reduction Strength"),
-                    info=i18n(
-                        "Set the clean-up level to the audio you want, the more you increase it the more it will clean up, but it is possible that the audio will be more compressed."
-                    ),
-                    visible=False,
-                    value=0.5,
-                    interactive=True,
-                )
-        preprocess_output_info = gr.Textbox(
-            label=i18n("Output Information"),
-            info=i18n("The output information will be displayed here."),
-            value="",
-            max_lines=8,
-            interactive=False,
-        )
-
-        with gr.Row():
-            preprocess_button = gr.Button(i18n("Preprocess Dataset"))
-            preprocess_button.click(
-                fn=run_preprocess_script,
-                inputs=[
-                    model_name,
-                    dataset_path,
-                    sampling_rate,
-                    cpu_cores_preprocess,
-                    cut_preprocess,
-                    process_effects,
-                    noise_reduction,
-                    clean_strength,
-                ],
-                outputs=[preprocess_output_info],
-            )
-
-    with gr.Accordion(i18n("Extract")):
-        with gr.Row():
-            f0_method = gr.Radio(
-                label=i18n("Pitch extraction algorithm"),
-                info=i18n(
-                    "Pitch extraction algorithm to use for the audio conversion. The default algorithm is rmvpe, which is recommended for most cases."
-                ),
-                choices=["crepe", "crepe-tiny", "rmvpe"],
-                value="rmvpe",
-                interactive=True,
-            )
-
-            embedder_model = gr.Radio(
-                label=i18n("Embedder Model"),
-                info=i18n("Model used for learning speaker embedding."),
-                choices=[
-                    "contentvec",
-                    "chinese-hubert-base",
-                    "japanese-hubert-base",
-                    "korean-hubert-base",
-                    "custom",
-                ],
-                value="contentvec",
-                interactive=True,
-            )
-
-        hop_length = gr.Slider(
-            1,
-            512,
-            128,
-            step=1,
-            label=i18n("Hop Length"),
-            info=i18n(
-                "Denotes the duration it takes for the system to transition to a significant pitch change. Smaller hop lengths require more time for inference but tend to yield higher pitch accuracy."
-            ),
-            visible=False,
-            interactive=True,
-        )
-        with gr.Row(visible=False) as embedder_custom:
-            with gr.Accordion("Custom Embedder", open=True):
-                with gr.Row():
-                    embedder_model_custom = gr.Dropdown(
-                        label="Select Custom Embedder",
-                        choices=refresh_embedders_folders(),
-                        interactive=True,
-                        allow_custom_value=True,
-                    )
-                    refresh_embedders_button = gr.Button("Refresh embedders")
-                folder_name_input = gr.Textbox(label="Folder Name", interactive=True)
-                with gr.Row():
-                    bin_file_upload = gr.File(
-                        label="Upload .bin", type="filepath", interactive=True
-                    )
-                    config_file_upload = gr.File(
-                        label="Upload .json", type="filepath", interactive=True
-                    )
-                move_files_button = gr.Button("Move files to custom embedder folder")
-
-        with gr.Accordion(
-            i18n(
-                "We prioritize running the model extraction on the GPU for faster performance. If you prefer to use the CPU, simply leave the GPU field blank."
-            ),
-            open=False,
-        ):
-            with gr.Row():
-                with gr.Column():
-                    cpu_cores_extract = gr.Slider(
-                        1,
-                        min(cpu_count(), 32),  # max 32 parallel processes
-                        min(cpu_count(), 32),
-                        step=1,
-                        label=i18n("CPU Cores"),
-                        info=i18n(
-                            "The number of CPU cores to use in the extraction process. The default setting are your cpu cores, which is recommended for most cases."
-                        ),
-                        interactive=True,
-                    )
-
-                with gr.Column():
-                    gpu_extract = gr.Textbox(
-                        label=i18n("GPU Number"),
-                        info=i18n(
-                            "Specify the number of GPUs you wish to utilize for extracting by entering them separated by hyphens (-)."
-                        ),
-                        placeholder=i18n("0 to ∞ separated by -"),
-                        value=str(get_number_of_gpus()),
-                        interactive=True,
-                    )
-                    gr.Textbox(
-                        label=i18n("GPU Information"),
-                        info=i18n("The GPU information will be displayed here."),
-                        value=get_gpu_info(),
-                        interactive=False,
-                    )
-
-        extract_output_info = gr.Textbox(
-            label=i18n("Output Information"),
-            info=i18n("The output information will be displayed here."),
-            value="",
-            max_lines=8,
-            interactive=False,
-        )
-        extract_button = gr.Button(i18n("Extract Features"))
-        extract_button.click(
-            fn=run_extract_script,
-            inputs=[
-                model_name,
-                rvc_version,
-                f0_method,
-                hop_length,
-                cpu_cores_extract,
-                gpu_extract,
-                sampling_rate,
-                embedder_model,
-                embedder_model_custom,
-            ],
-            outputs=[extract_output_info],
-        )
-
-    with gr.Accordion(i18n("Training")):
-        with gr.Row():
-            batch_size = gr.Slider(
-                1,
-                50,
-                max_vram_gpu(0),
-                step=1,
-                label=i18n("Batch Size"),
-                info=i18n(
-                    "It's advisable to align it with the available VRAM of your GPU. A setting of 4 offers improved accuracy but slower processing, while 8 provides faster and standard results."
-                ),
-                interactive=True,
-            )
-            save_every_epoch = gr.Slider(
-                1,
-                100,
-                10,
-                step=1,
-                label=i18n("Save Every Epoch"),
-                info=i18n("Determine at how many epochs the model will saved at."),
-                interactive=True,
-            )
-            total_epoch = gr.Slider(
-                1,
-                10000,
-                500,
-                step=1,
-                label=i18n("Total Epoch"),
-                info=i18n(
-                    "Specifies the overall quantity of epochs for the model training process."
-                ),
-                interactive=True,
-            )
-        with gr.Accordion(i18n("Advanced Settings"), open=False):
-            with gr.Row():
-                with gr.Column():
-                    save_only_latest = gr.Checkbox(
-                        label=i18n("Save Only Latest"),
-                        info=i18n(
-                            "Enabling this setting will result in the G and D files saving only their most recent versions, effectively conserving storage space."
-                        ),
-                        value=True,
-                        interactive=True,
-                    )
-                    save_every_weights = gr.Checkbox(
-                        label=i18n("Save Every Weights"),
-                        info=i18n(
-                            "This setting enables you to save the weights of the model at the conclusion of each epoch."
-                        ),
-                        value=True,
-                        interactive=True,
-                    )
-                    pretrained = gr.Checkbox(
-                        label=i18n("Pretrained"),
-                        info=i18n(
-                            "Utilize pretrained models when training your own. This approach reduces training duration and enhances overall quality."
-                        ),
-                        value=True,
-                        interactive=True,
-                    )
-                with gr.Column():
-                    cleanup = gr.Checkbox(
-                        label=i18n("Fresh Training"),
-                        info=i18n(
-                            "Enable this setting only if you are training a new model from scratch or restarting the training. Deletes all previously generated weights and tensorboard logs."
-                        ),
-                        value=False,
-                        interactive=True,
-                    )
-                    cache_dataset_in_gpu = gr.Checkbox(
-                        label=i18n("Cache Dataset in GPU"),
-                        info=i18n(
-                            "Cache the dataset in GPU memory to speed up the training process."
-                        ),
-                        value=False,
-                        interactive=True,
-                    )
-                    pitch_guidance = gr.Checkbox(
-                        label=i18n("Pitch Guidance"),
-                        info=i18n(
-                            "By employing pitch guidance, it becomes feasible to mirror the intonation of the original voice, including its pitch. This feature is particularly valuable for singing and other scenarios where preserving the original melody or pitch pattern is essential."
-                        ),
-                        value=True,
-                        interactive=True,
-                    )
-            with gr.Column():
-                custom_pretrained = gr.Checkbox(
-                    label=i18n("Custom Pretrained"),
-                    info=i18n(
-                        "Utilizing custom pretrained models can lead to superior results, as selecting the most suitable pretrained models tailored to the specific use case can significantly enhance performance."
-                    ),
-                    value=False,
-                    interactive=True,
-                )
-                with gr.Column(visible=False) as pretrained_custom_settings:
-                    with gr.Accordion(i18n("Pretrained Custom Settings")):
-                        upload_pretrained = gr.File(
-                            label=i18n("Upload Pretrained Model"),
-                            type="filepath",
-                            interactive=True,
-                        )
-                        refresh_custom_pretaineds_button = gr.Button(
-                            i18n("Refresh Custom Pretraineds")
-                        )
-                        g_pretrained_path = gr.Dropdown(
-                            label=i18n("Custom Pretrained G"),
-                            info=i18n(
-                                "Select the custom pretrained model for the generator."
-                            ),
-                            choices=sorted(pretraineds_list_g),
-                            interactive=True,
-                            allow_custom_value=True,
-                        )
-                        d_pretrained_path = gr.Dropdown(
-                            label=i18n("Custom Pretrained D"),
-                            info=i18n(
-                                "Select the custom pretrained model for the discriminator."
-                            ),
-                            choices=sorted(pretraineds_list_d),
-                            interactive=True,
-                            allow_custom_value=True,
-                        )
-                multiple_gpu = gr.Checkbox(
-                    label=i18n("GPU Settings"),
-                    info=(
-                        i18n(
-                            "Sets advanced GPU settings, recommended for users with better GPU architecture."
-                        )
-                    ),
-                    value=False,
-                    interactive=True,
-                )
-                with gr.Column(visible=False) as gpu_custom_settings:
-                    with gr.Accordion(i18n("GPU Settings")):
-                        gpu = gr.Textbox(
-                            label=i18n("GPU Number"),
-                            info=i18n(
-                                "Specify the number of GPUs you wish to utilize for training by entering them separated by hyphens (-)."
-                            ),
-                            placeholder=i18n("0 to ∞ separated by -"),
-                            value=str(get_number_of_gpus()),
-                            interactive=True,
-                        )
-                        gr.Textbox(
-                            label=i18n("GPU Information"),
-                            info=i18n("The GPU information will be displayed here."),
-                            value=get_gpu_info(),
-                            interactive=False,
-                        )
-                overtraining_detector = gr.Checkbox(
-                    label=i18n("Overtraining Detector"),
-                    info=i18n(
-                        "Detect overtraining to prevent the model from learning the training data too well and losing the ability to generalize to new data."
-                    ),
-                    value=False,
-                    interactive=True,
-                )
-                with gr.Column(visible=False) as overtraining_settings:
-                    with gr.Accordion(i18n("Overtraining Detector Settings")):
-                        overtraining_threshold = gr.Slider(
-                            1,
-                            100,
-                            50,
-                            step=1,
-                            label=i18n("Overtraining Threshold"),
-                            info=i18n(
-                                "Set the maximum number of epochs you want your model to stop training if no improvement is detected."
-                            ),
-                            interactive=True,
-                        )
-                index_algorithm = gr.Radio(
-                    label=i18n("Index Algorithm"),
-                    info=i18n(
-                        "KMeans is a clustering algorithm that divides the dataset into K clusters. This setting is particularly useful for large datasets."
-                    ),
-                    choices=["Auto", "Faiss", "KMeans"],
-                    value="Auto",
-                    interactive=True,
-                )
-
-        with gr.Row():
-            train_output_info = gr.Textbox(
-                label=i18n("Output Information"),
-                info=i18n("The output information will be displayed here."),
-                value="",
-                max_lines=8,
-                interactive=False,
-            )
-
-        with gr.Row():
-            train_button = gr.Button(i18n("Start Training"))
-            train_button.click(
-                fn=run_train_script,
-                inputs=[
-                    model_name,
-                    rvc_version,
-                    save_every_epoch,
-                    save_only_latest,
-                    save_every_weights,
-                    total_epoch,
-                    sampling_rate,
-                    batch_size,
-                    gpu,
-                    pitch_guidance,
-                    overtraining_detector,
-                    overtraining_threshold,
-                    pretrained,
-                    cleanup,
-                    index_algorithm,
-                    cache_dataset_in_gpu,
-                    custom_pretrained,
-                    g_pretrained_path,
-                    d_pretrained_path,
-                ],
-                outputs=[train_output_info],
-            )
-
-            stop_train_button = gr.Button(i18n("Stop Training"), visible=False)
-            stop_train_button.click(
-                fn=stop_train,
-                inputs=[model_name],
-                outputs=[],
-            )
-
-            index_button = gr.Button(i18n("Generate Index"))
-            index_button.click(
-                fn=run_index_script,
-                inputs=[model_name, rvc_version, index_algorithm],
-                outputs=[train_output_info],
-            )
-
-    with gr.Accordion(i18n("Export Model"), open=False):
-        if not os.name == "nt":
-            gr.Markdown(
-                i18n(
-                    "The button 'Upload' is only for google colab: Uploads the exported files to the ApplioExported folder in your Google Drive."
-                )
-            )
-        with gr.Row():
-            with gr.Column():
-                pth_file_export = gr.File(
-                    label=i18n("Exported Pth file"),
-                    type="filepath",
-                    value=None,
-                    interactive=False,
-                )
-                pth_dropdown_export = gr.Dropdown(
-                    label=i18n("Pth file"),
-                    info=i18n("Select the pth file to be exported"),
-                    choices=get_pth_list(),
-                    value=None,
-                    interactive=True,
-                    allow_custom_value=True,
-                )
-            with gr.Column():
-                index_file_export = gr.File(
-                    label=i18n("Exported Index File"),
-                    type="filepath",
-                    value=None,
-                    interactive=False,
-                )
-                index_dropdown_export = gr.Dropdown(
-                    label=i18n("Index File"),
-                    info=i18n("Select the index file to be exported"),
-                    choices=get_index_list(),
-                    value=None,
-                    interactive=True,
-                    allow_custom_value=True,
-                )
-        with gr.Row():
-            with gr.Column():
-                refresh_export = gr.Button(i18n("Refresh"))
-                if not os.name == "nt":
-                    upload_exported = gr.Button(i18n("Upload"), variant="primary")
-                    upload_exported.click(
-                        fn=upload_to_google_drive,
-                        inputs=[pth_dropdown_export, index_dropdown_export],
-                        outputs=[],
-                    )
-
-            def toggle_visible(checkbox):
-                return {"visible": checkbox, "__type__": "update"}
-
-            def toggle_visible_hop_length(f0_method):
-                if f0_method == "crepe" or f0_method == "crepe-tiny":
-                    return {"visible": True, "__type__": "update"}
-                return {"visible": False, "__type__": "update"}
-
-            def toggle_pretrained(pretrained, custom_pretrained):
-                if custom_pretrained == False:
-                    return {"visible": pretrained, "__type__": "update"}, {
-                        "visible": False,
-                        "__type__": "update",
-                    }
-                else:
-                    return {"visible": pretrained, "__type__": "update"}, {
-                        "visible": pretrained,
-                        "__type__": "update",
-                    }
-
-            def enable_stop_train_button():
-                return {"visible": False, "__type__": "update"}, {
-                    "visible": True,
-                    "__type__": "update",
-                }
-
-            def disable_stop_train_button():
-                return {"visible": True, "__type__": "update"}, {
-                    "visible": False,
-                    "__type__": "update",
-                }
-
-            def download_prerequisites(version, pitch_guidance):
-                if version == "v1":
-                    if pitch_guidance:
-                        gr.Info(
-                            "Checking for v1 prerequisites with pitch guidance... Missing files will be downloaded. If you already have them, this step will be skipped."
-                        )
-                        run_prerequisites_script(
-                            pretraineds_v1_f0=True,
-                            pretraineds_v1_nof0=False,
-                            pretraineds_v2_f0=False,
-                            pretraineds_v2_nof0=False,
-                            models=False,
-                            exe=False,
-                        )
-                    else:
-                        gr.Info(
-                            "Checking for v1 prerequisites without pitch guidance... Missing files will be downloaded. If you already have them, this step will be skipped."
-                        )
-                        run_prerequisites_script(
-                            pretraineds_v1_f0=False,
-                            pretraineds_v1_nof0=True,
-                            pretraineds_v2_f0=False,
-                            pretraineds_v2_nof0=False,
-                            models=False,
-                            exe=False,
-                        )
-                elif version == "v2":
-                    if pitch_guidance:
-                        gr.Info(
-                            "Checking for v2 prerequisites with pitch guidance... Missing files will be downloaded. If you already have them, this step will be skipped."
-                        )
-                        run_prerequisites_script(
-                            pretraineds_v1_f0=False,
-                            pretraineds_v1_nof0=False,
-                            pretraineds_v2_f0=True,
-                            pretraineds_v2_nof0=False,
-                            models=False,
-                            exe=False,
-                        )
-                    else:
-                        gr.Info(
-                            "Checking for v2 prerequisites without pitch guidance... Missing files will be downloaded. If you already have them, this step will be skipped."
-                        )
-                        run_prerequisites_script(
-                            pretraineds_v1_f0=False,
-                            pretraineds_v1_nof0=False,
-                            pretraineds_v2_f0=False,
-                            pretraineds_v2_nof0=True,
-                            models=False,
-                            exe=False,
-                        )
-                gr.Info(
-                    "Prerequisites check complete. Missing files were downloaded, and you may now start preprocessing."
-                )
-
-            def toggle_visible_embedder_custom(embedder_model):
-                if embedder_model == "custom":
-                    return {"visible": True, "__type__": "update"}
-                return {"visible": False, "__type__": "update"}
-
-            def update_slider_visibility(noise_reduction):
-                return gr.update(visible=noise_reduction)
-
-            noise_reduction.change(
-                fn=update_slider_visibility,
-                inputs=noise_reduction,
-                outputs=clean_strength,
-            )
-            rvc_version.change(
-                fn=download_prerequisites,
-                inputs=[rvc_version, pitch_guidance],
-                outputs=[],
-            )
-
-            pitch_guidance.change(
-                fn=download_prerequisites,
-                inputs=[rvc_version, pitch_guidance],
-                outputs=[],
-            )
-
-            refresh.click(
-                fn=refresh_models_and_datasets,
-                inputs=[],
-                outputs=[model_name, dataset_path],
-            )
-
-            dataset_creator.change(
-                fn=toggle_visible,
-                inputs=[dataset_creator],
-                outputs=[dataset_creator_settings],
-            )
-
-            upload_audio_dataset.upload(
-                fn=save_drop_dataset_audio,
-                inputs=[upload_audio_dataset, dataset_name],
-                outputs=[upload_audio_dataset, dataset_path],
-            )
-
-            f0_method.change(
-                fn=toggle_visible_hop_length,
-                inputs=[f0_method],
-                outputs=[hop_length],
-            )
-
-            embedder_model.change(
-                fn=toggle_visible_embedder_custom,
-                inputs=[embedder_model],
-                outputs=[embedder_custom],
-            )
-            embedder_model.change(
-                fn=toggle_visible_embedder_custom,
-                inputs=[embedder_model],
-                outputs=[embedder_custom],
-            )
-            move_files_button.click(
-                fn=create_folder_and_move_files,
-                inputs=[folder_name_input, bin_file_upload, config_file_upload],
-                outputs=[],
-            )
-            refresh_embedders_button.click(
-                fn=refresh_embedders_folders, inputs=[], outputs=[embedder_model_custom]
-            )
-            pretrained.change(
-                fn=toggle_pretrained,
-                inputs=[pretrained, custom_pretrained],
-                outputs=[custom_pretrained, pretrained_custom_settings],
-            )
-
-            custom_pretrained.change(
-                fn=toggle_visible,
-                inputs=[custom_pretrained],
-                outputs=[pretrained_custom_settings],
-            )
-
-            refresh_custom_pretaineds_button.click(
-                fn=refresh_custom_pretraineds,
-                inputs=[],
-                outputs=[g_pretrained_path, d_pretrained_path],
-            )
-
-            upload_pretrained.upload(
-                fn=save_drop_model,
-                inputs=[upload_pretrained],
-                outputs=[upload_pretrained],
-            )
-
-            overtraining_detector.change(
-                fn=toggle_visible,
-                inputs=[overtraining_detector],
-                outputs=[overtraining_settings],
-            )
-
-            multiple_gpu.change(
-                fn=toggle_visible,
-                inputs=[multiple_gpu],
-                outputs=[gpu_custom_settings],
-            )
-
-            train_button.click(
-                fn=enable_stop_train_button,
-                inputs=[],
-                outputs=[train_button, stop_train_button],
-            )
-
-            train_output_info.change(
-                fn=disable_stop_train_button,
-                inputs=[],
-                outputs=[train_button, stop_train_button],
-            )
-
-            pth_dropdown_export.change(
-                fn=export_pth,
-                inputs=[pth_dropdown_export],
-                outputs=[pth_file_export],
-            )
-
-            index_dropdown_export.change(
-                fn=export_index,
-                inputs=[index_dropdown_export],
-                outputs=[index_file_export],
-            )
-
-            refresh_export.click(
-                fn=refresh_pth_and_index_list,
-                inputs=[],
-                outputs=[pth_dropdown_export, index_dropdown_export],
-            )

tabs/tts/tts.py

@@ -1,343 +1,39 @@
-import json
-import os
-import random
-import sys
-
 import gradio as gr
 
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-
 from assets.i18n.i18n import I18nAuto
 from core import run_tts_script
-from tabs.inference.inference import (
-    change_choices,
-    create_folder_and_move_files,
-    get_indexes,
-    get_speakers_id,
-    match_index,
-    names,
-    refresh_embedders_folders,
-)
+from tts_service.voices import voice_manager
 
 i18n = I18nAuto()
 
-default_weight = random.choice(names) if names else ""
-
-with open(
-    os.path.join("rvc", "lib", "tools", "tts_voices.json"), "r", encoding="utf-8"
-) as file:
-    tts_voices_data = json.load(file)
-
-short_names = [voice.get("ShortName", "") for voice in tts_voices_data]
-
-
-def process_input(file_path):
-    try:
-        with open(file_path, "r", encoding="utf-8") as file:
-            file.read()
-        gr.Info(f"The file has been loaded!")
-        return file_path, file_path
-    except UnicodeDecodeError:
-        gr.Info(f"The file has to be in UTF-8 encoding.")
-        return None, None
-
 
 # TTS tab
 def tts_tab():
-    with gr.Column():
+    with gr.Column():  # noqa: SIM117
         with gr.Row():
-            model_file = gr.Dropdown(
+            voice_name = gr.Dropdown(
                 label=i18n("Voice Model"),
-                info=i18n("Select the voice model to use for the conversion."),
-                choices=sorted(names, key=lambda path: os.path.getsize(path)),
-                interactive=True,
-                value=default_weight,
-                allow_custom_value=True,
-            )
-            best_default_index_path = match_index(model_file.value)
-            index_file = gr.Dropdown(
-                label=i18n("Index File"),
-                info=i18n("Select the index file to use for the conversion."),
-                choices=get_indexes(),
-                value=best_default_index_path,
-                interactive=True,
-                allow_custom_value=True,
-            )
-        with gr.Row():
-            unload_button = gr.Button(i18n("Unload Voice"))
-            refresh_button = gr.Button(i18n("Refresh"))
-
-            unload_button.click(
-                fn=lambda: (
-                    {"value": "", "__type__": "update"},
-                    {"value": "", "__type__": "update"},
-                ),
-                inputs=[],
-                outputs=[model_file, index_file],
-            )
-
-            model_file.select(
-                fn=lambda model_file_value: match_index(model_file_value),
-                inputs=[model_file],
-                outputs=[index_file],
-            )
-
-    gr.Markdown(
-        i18n(
-            f"Applio is a Speech-to-Speech conversion software, utilizing EdgeTTS as middleware for running the Text-to-Speech (TTS) component. Read more about it [here!](https://docs.applio.org/getting-started/tts#disclaimer)"
-        )
-    )
-    tts_voice = gr.Dropdown(
-        label=i18n("TTS Voices"),
-        info=i18n("Select the TTS voice to use for the conversion."),
-        choices=short_names,
-        interactive=True,
-        value=None,
-    )
-
-    tts_rate = gr.Slider(
-        minimum=-100,
-        maximum=100,
-        step=1,
-        label=i18n("TTS Speed"),
-        info=i18n("Increase or decrease TTS speed."),
-        value=0,
-        interactive=True,
-    )
-
-    with gr.Tabs():
-        with gr.Tab(label="Text to Speech"):
-            tts_text = gr.Textbox(
-                label=i18n("Text to Synthesize"),
-                info=i18n("Enter the text to synthesize."),
-                placeholder=i18n("Enter text to synthesize"),
-                lines=3,
-            )
-        with gr.Tab(label="File to Speech"):
-            txt_file = gr.File(
-                label=i18n("Upload a .txt file"),
-                type="filepath",
-            )
-            input_tts_path = gr.Textbox(
-                label=i18n("Input path for text file"),
-                placeholder=i18n(
-                    "The path to the text file that contains content for text to speech."
-                ),
-                value="",
-                interactive=True,
+                info=i18n("Select the voice model."),
+                choices=voice_manager.voice_names,
+                value=voice_manager.voice_names[0],
             )
 
-    with gr.Accordion(i18n("Advanced Settings"), open=False):
-        with gr.Column():
-            output_tts_path = gr.Textbox(
-                label=i18n("Output Path for TTS Audio"),
-                placeholder=i18n("Enter output path"),
-                value=os.path.join(now_dir, "assets", "audios", "tts_output.wav"),
-                interactive=True,
-            )
-            output_rvc_path = gr.Textbox(
-                label=i18n("Output Path for RVC Audio"),
-                placeholder=i18n("Enter output path"),
-                value=os.path.join(now_dir, "assets", "audios", "tts_rvc_output.wav"),
-                interactive=True,
-            )
-            export_format = gr.Radio(
-                label=i18n("Export Format"),
-                info=i18n("Select the format to export the audio."),
-                choices=["WAV", "MP3", "FLAC", "OGG", "M4A"],
-                value="WAV",
-                interactive=True,
-            )
-            sid = gr.Dropdown(
-                label=i18n("Speaker ID"),
-                info=i18n("Select the speaker ID to use for the conversion."),
-                choices=get_speakers_id(model_file.value),
-                value=0,
-                interactive=True,
-            )
-            split_audio = gr.Checkbox(
-                label=i18n("Split Audio"),
-                info=i18n(
-                    "Split the audio into chunks for inference to obtain better results in some cases."
-                ),
-                visible=True,
-                value=False,
-                interactive=True,
-            )
-            autotune = gr.Checkbox(
-                label=i18n("Autotune"),
-                info=i18n(
-                    "Apply a soft autotune to your inferences, recommended for singing conversions."
-                ),
-                visible=True,
-                value=False,
-                interactive=True,
-            )
-            autotune_strength = gr.Slider(
-                minimum=0,
-                maximum=1,
-                label=i18n("Autotune Strength"),
-                info=i18n(
-                    "Set the autotune strength - the more you increase it the more it will snap to the chromatic grid."
-                ),
-                visible=False,
-                value=1,
-                interactive=True,
-            )
-            clean_audio = gr.Checkbox(
-                label=i18n("Clean Audio"),
-                info=i18n(
-                    "Clean your audio output using noise detection algorithms, recommended for speaking audios."
-                ),
-                visible=True,
-                value=True,
-                interactive=True,
-            )
-            clean_strength = gr.Slider(
-                minimum=0,
-                maximum=1,
-                label=i18n("Clean Strength"),
-                info=i18n(
-                    "Set the clean-up level to the audio you want, the more you increase it the more it will clean up, but it is possible that the audio will be more compressed."
-                ),
-                visible=True,
-                value=0.5,
-                interactive=True,
-            )
-            upscale_audio = gr.Checkbox(
-                label=i18n("Upscale Audio"),
-                info=i18n(
-                    "Upscale the audio to a higher quality, recommended for low-quality audios. (It could take longer to process the audio)"
-                ),
-                visible=True,
-                value=False,
-                interactive=True,
-            )
-            pitch = gr.Slider(
-                minimum=-24,
-                maximum=24,
+            tts_rate = gr.Slider(
+                minimum=-100,
+                maximum=100,
                 step=1,
-                label=i18n("Pitch"),
-                info=i18n(
-                    "Set the pitch of the audio, the higher the value, the higher the pitch."
-                ),
+                label=i18n("TTS Speed"),
+                info=i18n("Increase or decrease TTS speed."),
                 value=0,
                 interactive=True,
             )
-            filter_radius = gr.Slider(
-                minimum=0,
-                maximum=7,
-                label=i18n("Filter Radius"),
-                info=i18n(
-                    "If the number is greater than or equal to three, employing median filtering on the collected tone results has the potential to decrease respiration."
-                ),
-                value=3,
-                step=1,
-                interactive=True,
-            )
-            index_rate = gr.Slider(
-                minimum=0,
-                maximum=1,
-                label=i18n("Search Feature Ratio"),
-                info=i18n(
-                    "Influence exerted by the index file; a higher value corresponds to greater influence. However, opting for lower values can help mitigate artifacts present in the audio."
-                ),
-                value=0.75,
-                interactive=True,
-            )
-            rms_mix_rate = gr.Slider(
-                minimum=0,
-                maximum=1,
-                label=i18n("Volume Envelope"),
-                info=i18n(
-                    "Substitute or blend with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is employed."
-                ),
-                value=1,
-                interactive=True,
-            )
-            protect = gr.Slider(
-                minimum=0,
-                maximum=0.5,
-                label=i18n("Protect Voiceless Consonants"),
-                info=i18n(
-                    "Safeguard distinct consonants and breathing sounds to prevent electro-acoustic tearing and other artifacts. Pulling the parameter to its maximum value of 0.5 offers comprehensive protection. However, reducing this value might decrease the extent of protection while potentially mitigating the indexing effect."
-                ),
-                value=0.5,
-                interactive=True,
-            )
-            hop_length = gr.Slider(
-                minimum=1,
-                maximum=512,
-                step=1,
-                label=i18n("Hop Length"),
-                info=i18n(
-                    "Denotes the duration it takes for the system to transition to a significant pitch change. Smaller hop lengths require more time for inference but tend to yield higher pitch accuracy."
-                ),
-                value=128,
-                interactive=True,
-            )
-            f0_method = gr.Radio(
-                label=i18n("Pitch extraction algorithm"),
-                info=i18n(
-                    "Pitch extraction algorithm to use for the audio conversion. The default algorithm is rmvpe, which is recommended for most cases."
-                ),
-                choices=[
-                    "crepe",
-                    "crepe-tiny",
-                    "rmvpe",
-                    "fcpe",
-                    "hybrid[rmvpe+fcpe]",
-                ],
-                value="rmvpe",
-                interactive=True,
-            )
-            embedder_model = gr.Radio(
-                label=i18n("Embedder Model"),
-                info=i18n("Model used for learning speaker embedding."),
-                choices=[
-                    "contentvec",
-                    "chinese-hubert-base",
-                    "japanese-hubert-base",
-                    "korean-hubert-base",
-                    "custom",
-                ],
-                value="contentvec",
-                interactive=True,
-            )
-            with gr.Column(visible=False) as embedder_custom:
-                with gr.Accordion(i18n("Custom Embedder"), open=True):
-                    with gr.Row():
-                        embedder_model_custom = gr.Dropdown(
-                            label=i18n("Select Custom Embedder"),
-                            choices=refresh_embedders_folders(),
-                            interactive=True,
-                            allow_custom_value=True,
-                        )
-                        refresh_embedders_button = gr.Button(i18n("Refresh embedders"))
-                    folder_name_input = gr.Textbox(
-                        label=i18n("Folder Name"), interactive=True
-                    )
-                    with gr.Row():
-                        bin_file_upload = gr.File(
-                            label=i18n("Upload .bin"),
-                            type="filepath",
-                            interactive=True,
-                        )
-                        config_file_upload = gr.File(
-                            label=i18n("Upload .json"),
-                            type="filepath",
-                            interactive=True,
-                        )
-                    move_files_button = gr.Button(
-                        i18n("Move files to custom embedder folder")
-                    )
-            f0_file = gr.File(
-                label=i18n(
-                    "The f0 curve represents the variations in the base frequency of a voice over time, showing how pitch rises and falls."
-                ),
-                visible=True,
-            )
+
+    tts_text = gr.Textbox(
+        label=i18n("Text to Synthesize"),
+        info=i18n("Enter the text to synthesize."),
+        placeholder=i18n("Enter text to synthesize"),
+        lines=3,
+    )
 
     convert_button = gr.Button(i18n("Convert"))
 
@@ -348,78 +44,12 @@ def tts_tab():
         )
         vc_output2 = gr.Audio(label=i18n("Export Audio"))
 
-    def toggle_visible(checkbox):
-        return {"visible": checkbox, "__type__": "update"}
-
-    def toggle_visible_embedder_custom(embedder_model):
-        if embedder_model == "custom":
-            return {"visible": True, "__type__": "update"}
-        return {"visible": False, "__type__": "update"}
-
-    autotune.change(
-        fn=toggle_visible,
-        inputs=[autotune],
-        outputs=[autotune_strength],
-    )
-    clean_audio.change(
-        fn=toggle_visible,
-        inputs=[clean_audio],
-        outputs=[clean_strength],
-    )
-    refresh_button.click(
-        fn=change_choices,
-        inputs=[model_file],
-        outputs=[model_file, index_file, sid],
-    )
-    txt_file.upload(
-        fn=process_input,
-        inputs=[txt_file],
-        outputs=[input_tts_path, txt_file],
-    )
-    embedder_model.change(
-        fn=toggle_visible_embedder_custom,
-        inputs=[embedder_model],
-        outputs=[embedder_custom],
-    )
-    move_files_button.click(
-        fn=create_folder_and_move_files,
-        inputs=[folder_name_input, bin_file_upload, config_file_upload],
-        outputs=[],
-    )
-    refresh_embedders_button.click(
-        fn=lambda: gr.update(choices=refresh_embedders_folders()),
-        inputs=[],
-        outputs=[embedder_model_custom],
-    )
     convert_button.click(
         fn=run_tts_script,
         inputs=[
-            input_tts_path,
             tts_text,
-            tts_voice,
+            voice_name,
             tts_rate,
-            pitch,
-            filter_radius,
-            index_rate,
-            rms_mix_rate,
-            protect,
-            hop_length,
-            f0_method,
-            output_tts_path,
-            output_rvc_path,
-            model_file,
-            index_file,
-            split_audio,
-            autotune,
-            autotune_strength,
-            clean_audio,
-            clean_strength,
-            export_format,
-            upscale_audio,
-            f0_file,
-            embedder_model,
-            embedder_model_custom,
-            sid,
         ],
         outputs=[vc_output1, vc_output2],
     )

tts_service/app.py

@@ -1,36 +1,26 @@
-import gradio as gr
-import sys
-import os
 import logging
+import sys
+
+import gradio as gr
 
-# Constants
-DEFAULT_PORT = 6969
-MAX_PORT_ATTEMPTS = 10
+import assets.installation_checker as installation_checker
+import assets.themes.loadThemes as loadThemes
+from assets.i18n.i18n import I18nAuto
+from core import run_prerequisites_script
+from tabs.download.download import download_tab
+from tabs.plugins import plugins_core
+from tabs.tts.tts import tts_tab
+from tts_service.utils import env_bool
 
 # Set up logging
 logging.getLogger("uvicorn").setLevel(logging.WARNING)
 logging.getLogger("httpx").setLevel(logging.WARNING)
 
-# Add current directory to sys.path
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-
-# Zluda hijack
-import rvc.lib.zluda
-
 # Import Tabs
-from tabs.inference.inference import inference_tab
-from tabs.train.train import train_tab
-from tabs.extra.extra import extra_tab
-from tabs.report.report import report_tab
-from tabs.download.download import download_tab
-from tabs.tts.tts import tts_tab
-from tabs.voice_blender.voice_blender import voice_blender_tab
-from tabs.plugins.plugins import plugins_tab
-from tabs.settings.settings import settings_tab
+
+plugins_core.check_new_folders()
 
 # Run prerequisites
-from core import run_prerequisites_script
 
 run_prerequisites_script(
     pretraineds_v1_f0=False,
@@ -38,75 +28,31 @@ run_prerequisites_script(
     pretraineds_v2_f0=True,
     pretraineds_v2_nof0=False,
     models=True,
-    exe=True,
+    voices=not env_bool("OFFLINE", False),
 )
 
 # Initialize i18n
-from assets.i18n.i18n import I18nAuto
 
 i18n = I18nAuto()
 
-# Start Discord presence if enabled
-from tabs.settings.sections.presence import load_config_presence
-
-if load_config_presence():
-    from assets.discord_presence import RPCManager
-
-    RPCManager.start_presence()
-
 # Check installation
-import assets.installation_checker as installation_checker
 
 installation_checker.check_installation()
 
 # Start Flask server if enabled
-from assets.flask.server import start_flask, load_config_flask
-
-if load_config_flask():
-    print("Starting Flask server")
-    start_flask()
-
-# Load theme
-import assets.themes.loadThemes as loadThemes
 
 my_applio = loadThemes.load_theme() or "ParityError/Interstellar"
 
 # Define Gradio interface
 with gr.Blocks(theme=my_applio, title="Applio", css="footer{display:none !important}") as Applio:
-    gr.Markdown("# Applio")
-    gr.Markdown(i18n("A simple, high-quality voice conversion tool focused on ease of use and performance."))
-    gr.Markdown(
-        i18n(
-            "[Support](https://discord.gg/urxFjYmYYh) — [Discord Bot](https://discord.com/oauth2/authorize?client_id=1144714449563955302&permissions=1376674695271&scope=bot%20applications.commands) — [Find Voices](https://applio.org/models) — [GitHub](https://github.com/IAHispano/Applio)"
-        )
-    )
-    with gr.Tab(i18n("Inference")):
-        inference_tab()
-
-    with gr.Tab(i18n("Training")):
-        train_tab()
-
+    gr.Markdown("# Text-to-Speech Playground")
+    gr.Markdown(i18n("Select a voice model, enter text, and press 'Convert' to synthesize speech."))
     with gr.Tab(i18n("TTS")):
         tts_tab()
 
-    with gr.Tab(i18n("Voice Blender")):
-        voice_blender_tab()
-
-    with gr.Tab(i18n("Plugins")):
-        plugins_tab()
-
     with gr.Tab(i18n("Download")):
         download_tab()
 
-    with gr.Tab(i18n("Report a Bug")):
-        report_tab()
-
-    with gr.Tab(i18n("Extra")):
-        extra_tab()
-
-    with gr.Tab(i18n("Settings")):
-        settings_tab()
-
 
 def launch_gradio():
     Applio.launch(
@@ -116,23 +62,5 @@ def launch_gradio():
     )
 
 
-def get_port_from_args():
-    if "--port" in sys.argv:
-        port_index = sys.argv.index("--port") + 1
-        if port_index < len(sys.argv):
-            return int(sys.argv[port_index])
-    return DEFAULT_PORT
-
-
 if __name__ == "__main__":
-    port = get_port_from_args()
-    for _ in range(MAX_PORT_ATTEMPTS):
-        try:
-            launch_gradio()
-            break
-        except OSError:
-            print(f"Failed to launch on port {port}, trying again on port {port - 1}...")
-            port -= 1
-        except Exception as error:
-            print(f"An error occurred launching Gradio: {error}")
-            break
+    launch_gradio()

tts_service/cli.py

@@ -1,5 +1,12 @@
+import os
+from pathlib import Path
+
+import boto3
 import click
 from click_help_colors import HelpColorsGroup
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 @click.group(
@@ -16,8 +23,52 @@ def main() -> None:
 def serve(share: bool) -> None:
     """Start the TTS Service"""
     from tts_service.app import Applio
+
     Applio.launch(share=share)
 
 
+@main.group()
+def service() -> None:
+    """Manages the deployed service."""
+
+
+@service.command()
+@click.option("--bucket", "-b", default=lambda: os.environ["BUCKET"], help="the bucket to upload voices to")
+@click.option("--prefix", "-p", default=lambda: os.environ["VOICES_KEY_PREFIX"], help="the prefix to use for the keys")
+@click.option("--delete", is_flag=True, help="delete extraneous files from dest")
+@click.option("--dry-run", "-n", is_flag=True, help="perform a trial run with no changes made")
+@click.argument("directory", type=click.Path(exists=True, file_okay=False, path_type=Path), nargs=1)
+def upload_voices(bucket: str, prefix: str, delete: bool, dry_run: bool, directory: Path) -> None:
+    """Upload voices to the service"""
+    s3 = boto3.client("s3")
+    prefix = prefix.strip("/")
+    names = set()
+    for path in directory.glob("*.pth"):
+        names.add(path.name)
+        with path.open("rb") as file:
+            if dry_run:
+                click.echo(f"Would upload {path.name} to {bucket}/{prefix}")
+            else:
+                s3.put_object(Bucket=bucket, Key=f"{prefix}/{path.name}", Body=file)
+                # s3.upload_fileobj(file, bucket, f"{prefix}/{path.name}")
+    if not names:
+        raise click.ClickException(f"no voices found in directory {directory}")
+    deleted = 0
+    if delete:
+        paginator = s3.get_paginator("list_objects_v2")
+        for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
+            for obj in page["Contents"]:
+                key = obj["Key"]
+                if key.split("/")[-1] not in names:
+                    if dry_run:
+                        click.echo(f"Would delete {key}")
+                    else:
+                        s3.delete_object(Bucket=bucket, Key=key)
+                    deleted += 1
+    deleted_message = f", {deleted} deleted" if delete else ""
+    if not dry_run:
+        click.echo(f"{bucket}/{prefix}: {len(names)} voices uploaded{deleted_message}")
+
+
 if __name__ == "__main__":
     main()

tts_service/utils.py

@@ -0,0 +1,49 @@
+import hashlib
+import os
+from pathlib import Path
+from typing import Any
+
+
+class Unspecified:
+    pass
+
+
+UNSPECIFIED = Unspecified()
+FALSISH_STRINGS = {"", "0", "false", "n", "no", "off", "disabled"}
+
+
+def env_str(name: str, default: str | Unspecified = UNSPECIFIED) -> str:
+    value = os.environ.get(name)
+    if value is None:
+        if isinstance(default, Unspecified):
+            raise ValueError(f"environment variable {name} is not set")
+        return default
+    return value
+
+
+def env_bool(name: str, default: bool | Unspecified = UNSPECIFIED) -> bool:
+    value = os.environ.get(name)
+    if value is None:
+        if isinstance(default, Unspecified):
+            raise ValueError(f"environment variable {name} is not set")
+        return default
+    return value.lower() not in FALSISH_STRINGS
+
+
+def data_dir(name: str) -> Path:
+    rv = Path(env_str("DATA_DIR", "/var/tts-service")) / name
+    if not rv.exists():
+        os.makedirs(rv)
+    return Path(rv)
+
+
+def cache_path(*keys: Any, extension: str | None = None) -> Path:
+    key = "\0".join(str(k) for k in keys)
+    hash = hashlib.md5(key.encode()).hexdigest()
+    dir_path = data_dir("cache") / hash[0:2]
+    if not dir_path.exists():
+        os.makedirs(dir_path)
+    name = f"{hash[2:]}"
+    if extension:
+        name += f".{extension}"
+    return dir_path / name

tts_service/voices.py

@@ -0,0 +1,119 @@
+import logging
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Generator
+
+import boto3
+from pydantic import BaseModel, Field, TypeAdapter
+from tqdm import tqdm
+
+from .utils import data_dir, env_str
+
+
+@dataclass
+class S3VoiceObj:
+    key: str
+    size: int
+
+    @property
+    def name(self) -> str:
+        return self.key.split("/")[-1]
+
+    @classmethod
+    def from_s3_obj(cls, obj: Any) -> "S3VoiceObj":
+        return S3VoiceObj(key=obj["Key"], size=obj["Size"])
+
+
+class Voice(BaseModel):
+    name: str
+    model: str
+    tts: str
+    index: str = ""
+    autotune: float | None = None
+    clean: float | None = 0.5
+    upscale: bool = False
+    pitch: int = 0
+    filter_radius: int = 3
+    index_rate: float = 0.75
+    rms_mix_rate: float = 1
+    protect: float = 0.5
+    hop_length: int = 128
+    f0_method: str = "rmvpe"
+    embedder_model: str = "contentvec"
+
+
+class TTSVoice(BaseModel):
+    name: str = Field(alias="ShortName")
+
+
+class VoiceManager:
+    def __init__(self) -> None:
+        self.s3 = boto3.client("s3")
+        self.bucket = env_str("BUCKET")
+        self.prefix = env_str("VOICES_KEY_PREFIX")
+        self.voices_dir = Path(data_dir("voices"))
+
+    def _iter_s3_objects(self) -> Generator[S3VoiceObj, None, None]:
+        response = self.s3.list_objects_v2(Bucket=self.bucket, Prefix=self.prefix)
+        for obj in response.get("Contents", []):
+            yield S3VoiceObj.from_s3_obj(obj)
+
+    def get_voices_size_if_missing(self) -> int:
+        """
+        Calculate the total size of the voice files only if they do not exist locally.
+        """
+        total_size = 0
+        paths: set[Path] = set()
+        for obj in self._iter_s3_objects():
+            destination_path = self.voices_dir / obj.name
+            paths.add(destination_path)
+            if not destination_path.exists() or destination_path.stat().st_size != obj.size:
+                total_size += obj.size
+
+        for path in self.voices_dir.glob("*"):
+            if path not in paths:
+                path.unlink()
+
+        return total_size
+
+    def download_voice_files(self, progress_bar: tqdm) -> None:
+        """
+        Download all voice files from s3 updating the global progress bar.
+        """
+
+        def callback(bytes_amount: int) -> None:
+            progress_bar.update(bytes_amount)
+
+        for obj in self._iter_s3_objects():
+            destination_path = self.voices_dir / obj.name
+            if not destination_path.exists() or destination_path.stat().st_size != obj.size:
+                self.s3.download_file(Bucket=self.bucket, Key=obj.key, Filename=destination_path, Callback=callback)
+
+    @cached_property
+    def tts_voices(self) -> dict[str, TTSVoice]:
+        path = Path("rvc/lib/tools/tts_voices.json")
+        voices = TypeAdapter(list[TTSVoice]).validate_json(path.read_bytes())
+        return {v.name: v for v in voices}
+
+    @property
+    def voice_names(self) -> list[str]:
+        return list(self.voices.keys())
+
+    @cached_property
+    def voices(self) -> dict[str, Voice]:
+        rv = {}
+        for path in self.voices_dir.glob("*.json"):
+            voice = Voice.model_validate_json(path.read_bytes())
+            model_path = self.voices_dir / f"{voice.model}"
+            if not model_path.exists():
+                logging.warning("Voice %s missing model %s", voice.name, voice.model)
+            elif voice.tts not in self.tts_voices:
+                logging.warning("Voice %s references invalid tts %s", voice.name, voice.model)
+            else:
+                voice.model = str(model_path)
+                rv[voice.name] = voice
+        return rv
+
+
+voice_manager = VoiceManager()

tts_service/whitelist.py

@@ -0,0 +1,24 @@
+_.secondary_100  # unused attribute (assets/themes/Applio.py:44)
+_.secondary_200  # unused attribute (assets/themes/Applio.py:45)
+_.secondary_300  # unused attribute (assets/themes/Applio.py:46)
+_.secondary_400  # unused attribute (assets/themes/Applio.py:47)
+_.secondary_50  # unused attribute (assets/themes/Applio.py:48)
+_.secondary_500  # unused attribute (assets/themes/Applio.py:49)
+_.secondary_600  # unused attribute (assets/themes/Applio.py:50)
+_.secondary_700  # unused attribute (assets/themes/Applio.py:51)
+_.secondary_800  # unused attribute (assets/themes/Applio.py:52)
+_.secondary_900  # unused attribute (assets/themes/Applio.py:53)
+_.secondary_950  # unused attribute (assets/themes/Applio.py:54)
+__getattr__  # unused function (rvc/lib/predictors/FCPE.py:799)
+_.graph  # unused attribute (rvc/lib/zluda.py:33)
+_.enabled  # unused attribute (rvc/lib/zluda.py:40)
+rvc  # unused import (rvc/train/extract/extract.py:19)
+_.nprobe  # unused attribute (rvc/train/process/extract_index.py:76)
+rvc  # unused import (rvc/train/train.py:28)
+_.deterministic  # unused attribute (rvc/train/train.py:80)
+_.benchmark  # unused attribute (rvc/train/train.py:81)
+losses_disc_g  # unused variable (rvc/train/train.py:632)
+losses_disc_r  # unused variable (rvc/train/train.py:632)
+losses_gen  # unused variable (rvc/train/train.py:651)
+components  # unused variable (tabs/report/report.py:55)
+rvc  # unused import (tts_service/app.py:19)