Google Drive support added + minifixes

app.py

@@ -1,3 +1,6 @@
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*show_api.*") # Предупреждения скрыты
+warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*theme.*")
 import gradio as gr
 import sys
 import json
@@ -6,7 +9,7 @@ from urllib.parse import urlparse
 from pathlib import Path, PurePosixPath
 BASE_DIR = Path(__file__).resolve().parent
 sys.path.append(str(BASE_DIR))
-from extra_utils import tz, define_audio_with_size, update_audio_with_size, base_c_params, UserDirectory, InputFilesDatabase, OutputDir, one_element_list_to_value, dw_file, dw_yt_dlp
+from extra_utils import tz, define_audio_with_size, update_audio_with_size, base_c_params, easy_check_is_colab, get_gdrive_dir, one_element_list_to_value, dw_file, dw_yt_dlp, get_disk_usage
 from inference import Separator, add_params, add_params_list, ensemble_types, BASE_DIR
 from vbach_lib.infer import VbachConverter, stereo_modes
 from vbach_lib.f0_extractor import f0_methods, crepe_like_f0_methods, f0_extract_and_write
@@ -18,10 +21,9 @@ from i18n import _i18n
 from args_parser import parse_app_args
 import tempfile
 import shutil
+from tqdm import tqdm
 from copy import deepcopy
 
-
-
 def generate_add_params_component():
     add_params_components = []
     for tab, components in add_params.items():
@@ -36,10 +38,183 @@ def generate_add_params_component():
                       add_params_components.append(gr.Checkbox(label=_i18n(component_name), value=params["default"], info=_i18n(params.get("info", "")), **base_c_params["base"]))
     return add_params_components
 
+USER_DIR = ""
+GDRIVE_DIR = get_gdrive_dir()
+def generate_user_dir_from_gdrive():
+    global GDRIVE_DIR
+    if GDRIVE_DIR:
+        user_dir = Path(GDRIVE_DIR, "MyDrive", "mvsepless-data")
+        user_dir.mkdir(parents=True, exist_ok=True)
+        return user_dir.as_posix()
+    else:
+        return None
+GDRIVE_USER_DIR = generate_user_dir_from_gdrive()
+
+def get_default_user_dir():
+    if easy_check_is_colab():
+        if GDRIVE_DIR:
+            print(_i18n("gdrive_mount_found"))
+            return GDRIVE_USER_DIR
+        else:
+            return USER_DIR
+    else:
+        return USER_DIR
+
+DEFAULT_USER_DIR = get_default_user_dir()
+
+def rename_user_dir_path(path: str, mode=0):
+    global GDRIVE_USER_DIR, USER_DIR
+    if path:
+        if mode == 0:
+            return (PurePosixPath(GDRIVE_USER_DIR) / PurePosixPath(path).relative_to(USER_DIR)).as_posix()
+        elif mode == 1:
+            return (PurePosixPath(USER_DIR) / PurePosixPath(path).relative_to(GDRIVE_USER_DIR)).as_posix()
+    else:
+        return None
+
+base_names_app_dirs = (
+    "input",
+    "output_mvsepless",
+    "history",
+    "ensemble_flows",
+    "vbach_models",
+    "f0_curves",
+    "custom_separation_models",
+    "vbach_output"
+)
+
+def copy_to_gdrive():
+    global GDRIVE_DIR, GDRIVE_USER_DIR, USER_DIR
+    if GDRIVE_DIR:
+        copied_dirs = []
+        dirs = [[dir, Path(USER_DIR, dir)] for dir in base_names_app_dirs]
+        for (dir_name, dir_path) in tqdm(dirs, desc=_i18n("copy_to_gdrive"), unit=_i18n("dirs")):
+            if dir_path.exists():
+                shutil.copytree(dir_path, Path(GDRIVE_USER_DIR, dir_name), dirs_exist_ok=True)
+                copied_dirs.append("")
+        print(_i18n("copied_dirs")+": "+str(len(copied_dirs)))
+        print(_i18n("copy_to_gdrive_done"))
+        gr.Info(title=_i18n("copy_to_gdrive_done"), message="")
+
+def copy_to_runtime():
+    global GDRIVE_DIR, GDRIVE_USER_DIR, USER_DIR
+    if GDRIVE_DIR:
+        copied_dirs = []
+        dirs = [[dir, Path(GDRIVE_USER_DIR, dir)] for dir in base_names_app_dirs]
+        for (dir_name, dir_path) in tqdm(dirs, desc=_i18n("copy_to_current_user_dir"), unit=_i18n("dirs")):
+            if dir_path.exists():
+                shutil.copytree(dir_path, Path(USER_DIR, dir_name), dirs_exist_ok=True)
+                copied_dirs.append("")
+        print(_i18n("copied_dirs")+": "+str(len(copied_dirs)))
+        print(_i18n("copy_to_gdrive_done"))
+        gr.Info(title=_i18n("copy_to_gdrive_done"), message="")
+
+class UserDirectory:
+    def __init__(self, custom_dir=USER_DIR):
+        self.user_directory = Path(custom_dir if custom_dir else DEFAULT_USER_DIR)
+
+    def change_dir(self, dir: str):
+        self.user_directory = Path(dir)
+
+    def generate(self, name: str):
+        timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
+        generated_directory = self.user_directory / name / timestamp
+        generated_directory.mkdir(parents=True, exist_ok=True)
+        return generated_directory
+    
+    def generate_from_dir(self, dir: str):
+        timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
+        generated_directory = Path(dir) / timestamp
+        generated_directory.mkdir(parents=True, exist_ok=True)
+        return generated_directory
+
+class InputFilesDatabase(UserDirectory):
+    def __init__(self):
+        super().__init__()
+        self.input_dir_base = self.user_directory / base_names_app_dirs[0]
+        self.input_dir_base.mkdir(parents=True, exist_ok=True)
+        self.input_base_json = self.input_dir_base / "inputs.json"
+        self.input_base = []
+        self.load()
+
+    def _write_decorator(func):
+        def wrapper(self, *args, **kwargs):
+            results_ = func(self, *args, **kwargs)
+            self.write()
+            return results_
+        return wrapper
+
+    def _load_decorator(func):
+        def wrapper(self, *args, **kwargs):
+            self.load()
+            results_ = func(self, *args, **kwargs)
+            return results_
+        return wrapper
+
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.input_base)
+        new_data = []
+        if self.input_base_json.exists():
+            new_data: list = json.loads(self.input_base_json.read_text("utf-8"))
+
+        new_data2 = []
+        new_data_to_merge = []
+
+        for file_path in new_data:
+            new_data2.append(rename_user_dir_path(file_path, mode=mode))
+
+        for path2 in new_data2:
+            if path2 not in current_data:
+                new_data_to_merge.append(path2)
+
+        self.input_base = list(dict.fromkeys([*current_data, *new_data_to_merge]))
+
+    def write(self):
+        self.input_base_json.write_text(json.dumps(self.input_base, ensure_ascii=False, indent=4), encoding="utf-8")
+
+    def load(self):
+        if self.input_base_json.exists():
+            self.input_base = json.loads(self.input_base_json.read_text("utf-8"))
+            print(_i18n("input_base_loaded"))
+
+    @_write_decorator
+    def upload(self, files, copy=False):
+        input_dir = self.generate_from_dir(self.input_dir_base)
+        uploaded_input_files = []
+        valid_files = get_audio_files_from_list(files, only_files=True)
+        for file in valid_files:
+            new_file = Namer.iter(input_dir / Path(file).name)
+            if copy:
+                shutil.copy2(file, new_file)
+            else:
+                shutil.move(file, new_file)
+            uploaded_input_files.append(new_file)
+        self.input_base.extend(uploaded_input_files)
+        return uploaded_input_files
+
+    @_write_decorator
+    def clear(self):
+        for path in self.input_base:
+            Path(path).unlink(missing_ok=True)
+        self.input_base.clear()
+        print(_i18n("input_base_cleared"))
+
+    def get_input_list(self):
+        return list(reversed(self.input_base))
+    
+class OutputDir(UserDirectory):
+    def __init__(self, dir: str = base_names_app_dirs[1]):
+        super().__init__()
+        self.output_dir_name = dir
+
+    def gen_output_dir(self):
+        return self.generate(self.output_dir_name)
+
 class History(UserDirectory):
     def __init__(self, name: str = "mvsepless"):
         super().__init__()
-        self.history_dir_base = self.user_directory / "history"
+        self.history_dir_base = self.user_directory / base_names_app_dirs[2]
         self.history_dir_base.mkdir(parents=True, exist_ok=True)
         self.history_dict_json = self.history_dir_base / f"{name}.json"
         self.history_dict = {}
@@ -67,6 +242,32 @@ class History(UserDirectory):
             self.history_dict = json.loads(self.history_dict_json.read_text("utf-8"))
             print(_i18n("history_loaded"))
 
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.history_dict)
+        new_data = {}
+        if self.history_dict_json.exists():
+            new_data: dict = json.loads(self.history_dict_json.read_text("utf-8"))
+            
+        new_data_to_merge = {}
+
+        for key, state in new_data.items():
+            new_state = []
+            for basename, stems_list in state:
+                new_stems_list = [basename]
+                new_stems_list.append([[stem_name, rename_user_dir_path(stem_path, mode=mode)] for stem_name, stem_path in stems_list])
+                new_state.extend(deepcopy(new_stems_list))
+            new_data[key] = deepcopy(new_state)
+
+        for key2, state2 in new_data.items():
+            if key2 not in list(current_data.keys()) and state2 != current_data.get(key2):
+                new_data_to_merge[key2] = state2
+
+        self.history_dict: dict = {
+            **current_data,
+            **new_data_to_merge
+        }
+
     def get_list(self, update_from_file=False):
         if update_from_file:
             self.load()
@@ -78,7 +279,7 @@ class History(UserDirectory):
         self.history_dict.update([(f"{timestamp} | {model_name}", deepcopy(state))])
 
     def get_from_history(self, key: str):
-        return deepcopy(self.history_dict.get(key, []))
+        return deepcopy(self.history_dict.get(key, None))
 
 class HistoryAutoEnsemble(History):
     def __init__(self):
@@ -97,6 +298,30 @@ class HistoryAutoEnsemble(History):
             results_ = func(self, *args, **kwargs)
             return results_
         return wrapper
+    
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.history_dict)
+        new_data = {}
+        if self.history_dict_json.exists():
+            new_data: dict = json.loads(self.history_dict_json.read_text("utf-8"))
+        new_data_to_merge = {}
+
+        for key, state in new_data.items():
+            new_state = [
+                rename_user_dir_path(state[0], mode=mode),  # result
+                rename_user_dir_path(state[1], mode=mode),  # invert
+                [rename_user_dir_path(stem_path, mode=mode) for stem_path in state[2]]  # primary_stems_list
+            ]
+            new_data[key] = deepcopy(new_state)
+        for key2, state2 in new_data.items():
+            if key2 not in list(current_data.keys()) and state2 != current_data.get(key2):
+                new_data_to_merge[key2] = state2
+
+        self.history_dict: dict = {
+            **current_data,
+            **new_data_to_merge
+        }
 
     @_write_decorator
     def add_to_history(self, etype: str, output: str, inverted_output: str, primary_stems_list: list = []):
@@ -124,6 +349,29 @@ class HistoryManualEnsemble(History):
             return results_
         return wrapper
 
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.history_dict)
+        new_data = {}
+        if self.history_dict_json.exists():
+            new_data: dict = json.loads(self.history_dict_json.read_text("utf-8"))
+        new_data_to_merge = {}
+
+        for key, state in new_data.items():
+            new_state = None
+            if state:
+                new_state = rename_user_dir_path(state, mode=mode)
+            new_data[key] = deepcopy(new_state)
+
+        for key2, state2 in new_data.items():
+            if key2 not in list(current_data.keys()) and state2 != current_data.get(key2):
+                new_data_to_merge[key2] = state2
+
+        self.history_dict: dict = {
+            **current_data,
+            **new_data_to_merge
+        }
+
     @_write_decorator
     def add_to_history(self, etype: str, state: str):
         timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
@@ -150,6 +398,29 @@ class HistorySubtractor(History):
             return results_
         return wrapper
 
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.history_dict)
+        new_data = {}
+        if self.history_dict_json.exists():
+            new_data: dict = json.loads(self.history_dict_json.read_text("utf-8"))
+        new_data_to_merge = {}
+
+        for key, state in new_data.items():
+            new_state = None
+            if state:
+                new_state = rename_user_dir_path(state, mode=mode)
+            new_data[key] = deepcopy(new_state)
+
+        for key2, state2 in new_data.items():
+            if key2 not in list(current_data.keys()) and state2 != current_data.get(key2):
+                new_data_to_merge[key2] = state2
+
+        self.history_dict: dict = {
+            **current_data,
+            **new_data_to_merge
+        }
+
     @_write_decorator
     def add_to_history(self, itype: str, state: str):
         timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
@@ -173,6 +444,29 @@ class HistoryVbach(History):
             return results_
         return wrapper
 
+    @_write_decorator
+    def update_data(self, mode: int):
+        current_data = deepcopy(self.history_dict)
+        new_data = {}
+        if self.history_dict_json.exists():
+            new_data: dict = json.loads(self.history_dict_json.read_text("utf-8"))
+        new_data_to_merge = {}
+
+        for key, state in new_data.items():
+            new_state = []
+            if state:
+                new_state = [rename_user_dir_path(file_path, mode=mode) for file_path in state]
+            new_data[key] = deepcopy(new_state)
+
+        for key2, state2 in new_data.items():
+            if key2 not in list(current_data.keys()) and state2 != current_data.get(key2):
+                new_data_to_merge[key2] = state2
+
+        self.history_dict: dict = {
+            **current_data,
+            **new_data_to_merge
+        }
+
     @_write_decorator
     def add_to_history(self, model_name: str, f0_method: str, pitch: int, output_files: list):
         timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
@@ -185,7 +479,7 @@ class AutoEnsembleApp(UserDirectory):
     def __init__(self):
         super().__init__()
         self.state = []
-        self.ensemble_base = self.user_directory / "ensemble_flows"
+        self.ensemble_base = self.user_directory / base_names_app_dirs[3]
         self.ensemble_base.mkdir(parents=True, exist_ok=True)
         
     def write_flow(self, name: str):
@@ -294,7 +588,7 @@ class VbachModelsDir(UserDirectory):
     
     def __init__(self):
         super().__init__()
-        self.vbach_models_base = self.user_directory / "vbach_models"
+        self.vbach_models_base = self.user_directory / base_names_app_dirs[4]
         self.pth_models_dir = self.vbach_models_base / "pth"
         self.index_models_dir = self.vbach_models_base / "index"
         self.pth_models_dir.mkdir(parents=True, exist_ok=True)
@@ -408,7 +702,7 @@ class VbachModelsDir(UserDirectory):
 class F0GenerateOutPath(UserDirectory):
     def __init__(self):
         super().__init__()
-        self.f0_curves_dir = self.user_directory / "f0_curves"
+        self.f0_curves_dir = self.user_directory / base_names_app_dirs[5]
         self.f0_curves_dir.mkdir(parents=True, exist_ok=True)
 
     def generate_output_path(self, name: str, f0_method: str):
@@ -421,7 +715,7 @@ class CustomSeparationModelsDir(UserDirectory):
     
     def __init__(self):
         super().__init__()
-        self.custom_models_base = self.user_directory / "custom_separation_models"
+        self.custom_models_base = self.user_directory / base_names_app_dirs[6]
         self.checkpoints_dir = self.custom_models_base / "checkpoints"
         self.configs_dir = self.custom_models_base / "configs"
         self.checkpoints_dir.mkdir(parents=True, exist_ok=True)
@@ -617,14 +911,8 @@ class App(Separator):
             return gr.skip()
         return gr.update(choices=current_configs, value=value), current_configs
 
-    def get_actual_custom_sep_history_list(self, value, state):
-        """Get updated history list"""
-        current_history = self.custom_sep_history.get_list()
-        if current_history == state:
-            return gr.skip()
-        return gr.update(choices=current_history, value=value), current_history
-
     def UI(self, theme=None, hf_space_mode=False):
+        global GDRIVE_DIR, IS_CUSTOM_DIR
         all_models = self.get_all_models()
         default_model = all_models[0]
         stems_default = self.get_stems(default_model)
@@ -1472,7 +1760,7 @@ class App(Separator):
                             gr.Warning(_i18n("model_not_selected"))
                             return [], gr.skip()
                         
-                        output_dir = self.output_dir.generate("vbach_output")
+                        output_dir = self.output_dir.generate(base_names_app_dirs[7])
                         download_hubert(embedder_model, use_transformers)
                         results = self.vbach_converter.convert_audio(
                             audio_input=input_files,
@@ -1769,7 +2057,7 @@ class App(Separator):
                             gr.Warning(_i18n("no_f0_file_selected"))
                             return update_audio_with_size(label=_i18n("vbach_result"), value=None), gr.skip()
                         
-                        output_dir = self.output_dir.generate("vbach_custom_output")
+                        output_dir = self.output_dir.generate(base_names_app_dirs[7])
                         download_hubert(embedder_model, use_transformers)
                         
                         result = self.vbach_converter.convert_audio_custom_f0(
@@ -2072,6 +2360,21 @@ class App(Separator):
                                         def upload_vbach_index_fn(files: list, progress=gr.Progress(track_tqdm=True)):
                                             self.vbach_model_manager.upload_index_model(files)
                                             return gr.update(value=[])
+                                        
+            if GDRIVE_USER_DIR:
+                with gr.Tab(_i18n("google_drive")):
+                    gdrive_info = gr.Textbox(lines=3, label=_i18n("status"), interactive=False)
+                    gr.Timer().tick(lambda: gr.update(value=get_disk_usage(GDRIVE_DIR)), outputs=gdrive_info)
+                    copy_to_gdrive_btn = gr.Button(_i18n("copy_from_current_user_dir_to_gdrive"), **base_c_params["base"])
+                    @copy_to_gdrive_btn.click()
+                    def copy_to_gdrive_fn():
+                        copy_to_gdrive()
+                        self.input_files.update_data(0)
+                        self.history.update_data(0)
+                        self.auto_ensemble_history_app.update_data(0)
+                        self.manual_ensemble_history_app.update_data(0)
+                        self.subtract_history_app.update_data(0)
+                        self.vbach_history_app.update_data(0)
 
         return mvsepless_app
 

args_parser.py

@@ -1,631 +1,631 @@
-import argparse
-from pathlib import Path
-from i18n import _i18n
-BASE_DIR = Path(__file__).resolve().parent
-from audio import output_formats
-
-def tobool(val: str | bool | int):
-    if isinstance(val, int):
-        return True if val >= 1 else False
-    elif isinstance(val, str):
-        if val in ["y", "yes", "Yes", "true", "True", "1"]:
-            return True
-        else:
-            return False
-    elif isinstance(val, bool):
-        return val
-
-class NestedAction(argparse.Action):
-    def __call__(self, parser, namespace, values, option_string=None):
-        # Разбиваем dest по точке, например 'database.host'
-        group, dest = self.dest.split('.', 1)
-        # Получаем или создаем вложенный Namespace
-        groupspace = getattr(namespace, group, argparse.Namespace())
-        # Устанавливаем значение во вложенный объект
-        setattr(groupspace, dest, values)
-        # Сохраняем вложенный объект в основной
-        setattr(namespace, group, groupspace)
-
-class NestedStoreTrue(argparse.Action):
-    def __init__(self, option_strings, dest, default=False, help=None, **kwargs):
-        # 1. Сразу при создании парсера готовим структуру во вложенном Namespace
-        super().__init__(option_strings=option_strings, dest=dest, nargs=0, default=default, help=help, **kwargs)
-        
-    def __call__(self, parser, namespace, values, option_string=None):
-        # 2. Если флаг передан, меняем False на True
-        group, attr = self.dest.split('.', 1)
-        groupspace = getattr(namespace, group, argparse.Namespace())
-        setattr(groupspace, attr, True)
-        setattr(namespace, group, groupspace)
-
-def parse_separator_args(add_params_args: dict = {}):
-    parser = argparse.ArgumentParser(
-        description=_i18n("arg_main_description"),
-        epilog=_i18n("arg_main_epilog")
-    )
-    subparsers = parser.add_subparsers(
-        title=_i18n("arg_subcommands_title"),
-        dest="mode",
-        description=_i18n("arg_subcommands_description"),
-        help=_i18n("arg_subcommands_help")
-    )
-    
-    # separate
-    separate_parser = subparsers.add_parser(
-        "separate",
-        help=_i18n("arg_separate_help"),
-        description=_i18n("arg_separate_description"),
-        epilog=_i18n("arg_separate_epilog")
-    )
-    
-    # custom_separate
-    custom_separate_parser = subparsers.add_parser(
-        "custom_separate",
-        help=_i18n("arg_custom_separate_help"),
-        description=_i18n("arg_custom_separate_description"),
-        epilog=_i18n("arg_custom_separate_epilog")
-    )
-    
-    # info
-    info_parser = subparsers.add_parser(
-        "info",
-        help=_i18n("arg_info_help"),
-        description=_i18n("arg_info_description"),
-        epilog=_i18n("arg_info_epilog")
-    )
-    
-    # auto_ensemble
-    auto_ensemble_parser = subparsers.add_parser(
-        "auto_ensemble",
-        help=_i18n("arg_auto_ensemble_help"),
-        description=_i18n("arg_auto_ensemble_description"),
-        epilog=_i18n("arg_auto_ensemble_epilog")
-    )
-    
-    # manual_ensemble
-    manual_ensemble_parser = subparsers.add_parser(
-        "manual_ensemble",
-        help=_i18n("arg_manual_ensemble_help"),
-        description=_i18n("arg_manual_ensemble_description"),
-        epilog=_i18n("arg_manual_ensemble_epilog")
-    )
-    
-    # subtract
-    subtract_parser = subparsers.add_parser(
-        "subtract",
-        help=_i18n("arg_subtract_help"),
-        description=_i18n("arg_subtract_description"),
-        epilog=_i18n("arg_subtract_epilog")
-    )
-
-    # separate
-    separate_parser.add_argument(
-        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
-        nargs="+", dest="input",
-        help=_i18n("arg_input_help")
-    )
-    separate_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    separate_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    separate_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_STEM_MODEL", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_separate"), example="NAME_STEM_MODEL")
-    )
-    separate_parser.add_argument(
-        "-mn", "-model", "--model_name", "--model-name", 
-        type=str, default="bs_6stem", dest="model_name",
-        help=_i18n("arg_model_name_help")
-    )
-    separate_parser.add_argument(
-        "-inst", "-ext_inst", "-ext-inst", "--extract_instrumental", "--extract-instrumental", 
-        action="store_true", dest="extract_instrumental",
-        help=_i18n("arg_extract_instrumental_help")
-    )
-    separate_parser.add_argument(
-        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
-        action="store_true", dest="use_spec_invert",
-        help=_i18n("arg_use_spec_invert_help")
-    )
-    separate_parser.add_argument(
-        "-st", "--st", "-stems", "--stems", "--selected_stems", "--selected-stems", 
-        nargs="*", metavar="STEM", dest="selected_stems",
-        help=_i18n("arg_selected_stems_help")
-    )
-    for param_name, param_value in add_params_args.items():
-        param_type = param_value.get("type")
-        default = param_value.get("default")
-        separate_parser.add_argument(
-            f"--{param_name}", 
-            action=NestedStoreTrue if param_type == "bool" else NestedAction,
-            type=None if param_type == "bool" else (int if param_type == "int" else (float if param_type == "float" else str)),
-            default=default,
-            dest=f"add_params.{param_name}",
-            help=_i18n("arg_add_param_help")
-        )
-
-    # custom_separate
-    custom_separate_parser.add_argument(
-        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
-        nargs="+", dest="input",
-        help=_i18n("arg_input_help")
-    )
-    custom_separate_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    custom_separate_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    custom_separate_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_STEM_MODEL", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_separate"), example="NAME_STEM_MODEL")
-    )
-    custom_separate_parser.add_argument(
-        "-mt", "-mtype", "--model_type", "--model-type", 
-        type=str, default="bs_roformer", dest="model_type",
-        help=_i18n("arg_model_type_help")
-    )
-    custom_separate_parser.add_argument(
-        "-ckpt", "--ckpt", "-checkpoint", "--checkpoint", "--checkpoint_path", "--checkpoint-path", 
-        type=str, required=True, dest="checkpoint_path",
-        help=_i18n("arg_checkpoint_path_help")
-    )
-    custom_separate_parser.add_argument(
-        "-conf", "--conf", "-config", "--config", "--config_path", "--config-path", 
-        type=str, required=True, dest="config_path",
-        help=_i18n("arg_config_path_help")
-    )
-    custom_separate_parser.add_argument(
-        "-inst", "-ext_inst", "-ext-inst", "--extract_instrumental", "--extract-instrumental", 
-        action="store_true", dest="extract_instrumental",
-        help=_i18n("arg_extract_instrumental_help")
-    )
-    custom_separate_parser.add_argument(
-        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
-        action="store_true", dest="use_spec_invert",
-        help=_i18n("arg_use_spec_invert_help")
-    )
-    custom_separate_parser.add_argument(
-        "-st", "--st", "-stems", "--stems", "--selected_stems", "--selected-stems", 
-        nargs="*", metavar="STEM", dest="selected_stems",
-        help=_i18n("arg_selected_stems_help")
-    )
-    for param_name, param_value in add_params_args.items():
-        param_type = param_value.get("type")
-        default = param_value.get("default")
-        custom_separate_parser.add_argument(
-            f"--{param_name}", 
-            action=NestedStoreTrue if param_type == "bool" else NestedAction,
-            type=None if param_type == "bool" else (int if param_type == "int" else (float if param_type == "float" else str)),
-            default=default,
-            dest=f"add_params.{param_name}",
-            help=_i18n("arg_add_param_help")
-        )
-
-    # auto_ensemble
-    auto_ensemble_parser.add_argument(
-        "-i", "--i", "-input", "--input", "--input_file", "--input-file", 
-        type=str, required=True, dest="input",
-        help=_i18n("arg_input_single_help")
-    )
-    auto_ensemble_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    auto_ensemble_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    auto_ensemble_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE_COUNT", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_auto_ensemble"), example="NAME_COUNT_TYPE")
-    )
-    auto_ensemble_parser.add_argument(
-        "-t", "-type", "-etype", "--ensemble_type", "--ensemble-type", 
-        type=str, default="avg_fft", dest="ensemble_type",
-        help=_i18n("arg_ensemble_type_help")
-    )
-    auto_ensemble_parser.add_argument(
-        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
-        action="store_true", dest="use_spec_invert",
-        help=_i18n("arg_use_spec_invert_help")
-    )
-    auto_ensemble_parser.add_argument(
-        "-save_stems", "-save-stems", "-save_primary_stems", "--save-primary-stems", 
-        action="store_true", dest="save_primary_stems",
-        help=_i18n("arg_save_primary_stems_help")
-    )
-    auto_ensemble_flow_group = auto_ensemble_parser.add_mutually_exclusive_group(required=True)
-    auto_ensemble_flow_group.add_argument(
-        "-flow", "--flow", nargs="+", metavar="MODEL:PRIMARY_STEM:INVERT:WEIGHTS", 
-        dest="flow",
-        help=_i18n("arg_flow_help")
-    )
-    auto_ensemble_flow_group.add_argument(
-        "-json", "-preset", "-preset_json", "-preset-json", "--preset_json", "--preset-json", 
-        type=str, dest="preset",
-        help=_i18n("arg_preset_json_help")
-    )
-
-    # manual_ensemble
-    manual_ensemble_parser.add_argument(
-        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
-        nargs="+", dest="input",
-        help=_i18n("arg_input_help")
-    )
-    manual_ensemble_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    manual_ensemble_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    manual_ensemble_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_manual_ensemble"), example="NAME_TYPE")
-    )
-    manual_ensemble_parser.add_argument(
-        "-t", "-type", "-etype", "--ensemble_type", "--ensemble-type", 
-        type=str, default="avg_fft", dest="ensemble_type",
-        help=_i18n("arg_ensemble_type_help")
-    )
-    manual_ensemble_parser.add_argument(
-        "-w", "-weights", "--weights", type=float, nargs="*", dest="weights",
-        help=_i18n("arg_weights_help")
-    )
-
-    # subtract
-    subtract_parser.add_argument(
-        "-i1", "--i1", "-input1", "--input1", "--input_file1", "--input-file1", 
-        type=str, required=True, dest="input_1",
-        help=_i18n("arg_input1_help")
-    )
-    subtract_parser.add_argument(
-        "-i2", "--i2", "-input2", "--input2", "--input_file2", "--input-file2", 
-        type=str, required=True, dest="input_2",
-        help=_i18n("arg_input2_help")
-    )
-    subtract_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    subtract_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    subtract_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_subtract"), example="NAME_TYPE")
-    )
-    subtract_parser.add_argument(
-        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
-        action="store_true", dest="use_spec_invert",
-        help=_i18n("arg_use_spec_invert_help")
-    )
-
-    # info
-    info_parser.add_argument(
-        "-u", "-update", "--update", action="store_true", dest="update",
-        help=_i18n("arg_update_help")
-    )
-    info_parser.add_argument(
-        "-clear", "-clear_cache", "-clear-cache", "--clear_cache", "--clear-cache", 
-        action="store_true", dest="clear_cache",
-        help=_i18n("arg_clear_cache_help")
-    )
-    info_parser.add_argument(
-        "-mn", "-model", "--model_name", "--model-name", 
-        type=str, default="bs_6stem", dest="model_name",
-        help=_i18n("arg_model_name_help")
-    )
-    info_parser.add_argument(
-        "-dw", "-download", "--download", action="store_true", dest="download",
-        help=_i18n("arg_download_help")
-    )
-    info_parser.add_argument(
-        "-l", "-limit", "--limit", type=int, default=None, dest="limit",
-        help=_i18n("arg_limit_help")
-    )
-    info_parser.add_argument(
-        "-s", "-stem", "--stem", type=str, default=None, dest="stem",
-        help=_i18n("arg_stem_filter_help")
-    )
-    info_parser.add_argument(
-        "-oi", "-installed", "--only_installed", "--only-installed", 
-        action="store_true", dest="only_installed",
-        help=_i18n("arg_only_installed_help")
-    )
-
-    return parser.parse_args()
-
-
-def parse_vbach_args():
-    parser = argparse.ArgumentParser(
-        description=_i18n("vbach_main_description"),
-        epilog=_i18n("vbach_main_epilog")
-    )
-    subparsers = parser.add_subparsers(
-        title=_i18n("arg_subcommands_title"),
-        dest="mode",
-        description=_i18n("arg_subcommands_description"),
-        help=_i18n("arg_subcommands_help")
-    )
-    
-    # infer
-    infer_parser = subparsers.add_parser(
-        "infer",
-        help=_i18n("vbach_infer_help"),
-        description=_i18n("vbach_infer_description"),
-        epilog=_i18n("vbach_infer_epilog")
-    )
-    
-    # infer_custom_f0
-    infer_custom_f0_parser = subparsers.add_parser(
-        "infer_custom_f0",
-        help=_i18n("vbach_infer_custom_f0_help"),
-        description=_i18n("vbach_infer_custom_f0_description"),
-        epilog=_i18n("vbach_infer_custom_f0_epilog")
-    )
-    
-    # download_hubert
-    download_hubert_parser = subparsers.add_parser(
-        "download_hubert",
-        help=_i18n("vbach_download_hubert_help"),
-        description=_i18n("vbach_download_hubert_description"),
-        epilog=_i18n("vbach_download_hubert_epilog")
-    )
-
-    # infer
-    infer_parser.add_argument(
-        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
-        nargs="+", dest="input",
-        help=_i18n("arg_input_help")
-    )
-    infer_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    infer_parser.add_argument(
-        "-m", "-model", "--model_path", "--model-path", 
-        type=str, required=True, dest="checkpoint_path",
-        help=_i18n("vbach_model_path_help")
-    )
-    infer_parser.add_argument(
-        "-idx", "-index", "--index_path", "--index-path", 
-        type=str, default="", dest="index_path",
-        help=_i18n("vbach_index_path_help")
-    )
-    infer_parser.add_argument(
-        "-p", "-pitch", "--pitch", type=int, default=0, dest="pitch",
-        help=_i18n("vbach_pitch_help")
-    )
-    infer_parser.add_argument(
-        "-f0m", "-f0_method", "--f0_method", "--f0-method", 
-        type=str, default="rmvpe+", dest="f0_method",
-        help=_i18n("vbach_f0_method_help")
-    )
-    infer_parser.add_argument(
-        "-idxr", "-index_rate", "--index_rate", "--index-rate", 
-        type=float, default=0.75, dest="index_rate",
-        help=_i18n("vbach_index_rate_help")
-    )
-    infer_parser.add_argument(
-        "-ve", "-volume_envelope", "--volume_envelope", "--volume-envelope", 
-        type=float, default=0.25, dest="volume_envelope",
-        help=_i18n("vbach_volume_envelope_help")
-    )
-    infer_parser.add_argument(
-        "-pr", "-protect", "--protect", type=float, default=0.33, dest="protect",
-        help=_i18n("vbach_protect_help")
-    )
-    infer_parser.add_argument(
-        "-hl", "-hop_length", "--hop_length", "--hop-length", 
-        type=int, default=128, dest="hop_length",
-        help=_i18n("vbach_hop_length_help")
-    )
-    infer_parser.add_argument(
-        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
-        type=str, default="hubert_base", dest="embedder",
-        help=_i18n("vbach_embedder_help")
-    )
-    infer_parser.add_argument(
-        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
-        action="store_true", dest="use_transformers",
-        help=_i18n("vbach_use_transformers_help")
-    )
-    infer_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    infer_parser.add_argument(
-        "-stm", "-stereo_mode", "--stereo_mode", "--stereo-mode", 
-        type=str, choices=("mono", "left/right", "sim/dif"), default="mono", dest="stereo_mode",
-        help=_i18n("vbach_stereo_mode_help")
-    )
-    infer_parser.add_argument(
-        "-f0min", "--f0_min", "--f0-min", type=int, default=50, dest="f0_min",
-        help=_i18n("vbach_f0_min_help")
-    )
-    infer_parser.add_argument(
-        "-f0max", "--f0_max", "--f0-max", type=int, default=1100, dest="f0_max",
-        help=_i18n("vbach_f0_max_help")
-    )
-    infer_parser.add_argument(
-        "-chd", "-chunk_duration", "--chunk_duration", "--chunk-duration", 
-        type=int, default=7, dest="chunk_duration",
-        help=_i18n("vbach_chunk_duration_help")
-    )
-    infer_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_F0METHOD_PITCH", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_vbach"), example="NAME_F0METHOD_PITCH")
-    )
-
-    # infer_custom_f0
-    infer_custom_f0_parser.add_argument(
-        "-i", "--i", "-input", "--input", type=str, required=True, dest="input",
-        help=_i18n("arg_input_single_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
-        type=str, default=".", dest="output_dir",
-        help=_i18n("arg_output_dir_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-m", "-model", "--model_path", "--model-path", 
-        type=str, required=True, dest="checkpoint_path",
-        help=_i18n("vbach_model_path_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-idx", "-index", "--index_path", "--index-path", 
-        type=str, default="", dest="index_path",
-        help=_i18n("vbach_index_path_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-p", "-pitch", "--pitch", type=int, default=0, dest="pitch",
-        help=_i18n("vbach_pitch_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-f0f", "-f0_file", "--f0_file", "--f0-file", 
-        type=str, dest="f0_file",
-        help=_i18n("vbach_f0_file_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-idxr", "-index_rate", "--index_rate", "--index-rate", 
-        type=float, default=0.75, dest="index_rate",
-        help=_i18n("vbach_index_rate_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-ve", "-volume_envelope", "--volume_envelope", "--volume-envelope", 
-        type=float, default=0.25, dest="volume_envelope",
-        help=_i18n("vbach_volume_envelope_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-pr", "-protect", "--protect", type=float, default=0.33, dest="protect",
-        help=_i18n("vbach_protect_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
-        type=str, default="hubert_base", dest="embedder",
-        help=_i18n("vbach_embedder_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
-        action="store_true", dest="use_transformers",
-        help=_i18n("vbach_use_transformers_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-of", "-output_fmt", "--output_format", "--output-format", 
-        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
-        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
-    )
-    infer_custom_f0_parser.add_argument(
-        "-stm", "-stereo_mode", "--stereo_mode", "--stereo-mode", 
-        type=str, choices=("mono", "left/right", "sim/dif"), default="mono", dest="stereo_mode",
-        help=_i18n("vbach_stereo_mode_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-f0min", "--f0_min", "--f0-min", type=int, default=50, dest="f0_min",
-        help=_i18n("vbach_f0_min_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-f0max", "--f0_max", "--f0-max", type=int, default=1100, dest="f0_max",
-        help=_i18n("vbach_f0_max_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-chd", "-chunk_duration", "--chunk_duration", "--chunk-duration", 
-        type=int, default=7, dest="chunk_duration",
-        help=_i18n("vbach_chunk_duration_help")
-    )
-    infer_custom_f0_parser.add_argument(
-        "-tm", "-tmplt", "--template", type=str, default="NAME_F0METHOD_PITCH", dest="template",
-        help=_i18n("arg_template_help", keys=_i18n("template_keys_vbach"), example="NAME_F0METHOD_PITCH")
-    )
-
-    # download_hubert
-    download_hubert_parser.add_argument(
-        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
-        type=str, default="hubert_base", dest="embedder",
-        help=_i18n("vbach_embedder_help")
-    )
-    download_hubert_parser.add_argument(
-        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
-        action="store_true", dest="use_transformers",
-        help=_i18n("vbach_use_transformers_help")
-    )
-
-    return parser.parse_args()
-
-
-def parse_f0_extract():
-    parser = argparse.ArgumentParser(
-        description=_i18n("f0_extract_description"),
-        epilog=_i18n("f0_extract_epilog")
-    )
-    parser.add_argument(
-        "-i", "--i", "-input", "--input", 
-        type=str, required=True, dest="input",
-        help=_i18n("arg_input_single_help")
-    )
-    parser.add_argument(
-        "-f0m", "-f0_method", "--f0_method", "--f0-method", 
-        type=str, default="rmvpe+", dest="f0_method",
-        help=_i18n("vbach_f0_method_help")
-    )
-    parser.add_argument(
-        "-f0min", "--f0_min", "--f0-min", 
-        type=int, default=50, dest="f0_min",
-        help=_i18n("vbach_f0_min_help")
-    )
-    parser.add_argument(
-        "-f0max", "--f0_max", "--f0-max", 
-        type=int, default=1100, dest="f0_max",
-        help=_i18n("vbach_f0_max_help")
-    )
-    parser.add_argument(
-        "-o", "-out", "-output", "--output", "--output_path", "--output-path", 
-        type=str, default=None, dest="output_path",
-        help=_i18n("f0_extract_output_help")
-    )
-    return parser.parse_args()
-
-
-def parse_app_args():
-    parser = argparse.ArgumentParser(
-        description=_i18n("app_description"),
-        epilog=_i18n("app_epilog")
-    )
-    parser.add_argument(
-        "-s", "-share", "--share", "--public", "--gradio_share", "--gradio-share", 
-        action="store_true", dest="share",
-        help=_i18n("app_share_help")
-    )
-    parser.add_argument(
-        "-p", "-port", "--port", "--server_port", "--server-port", 
-        type=int, default=None, dest="port",
-        help=_i18n("app_port_help")
-    )
-    parser.add_argument(
-        "-f", "-full", "--full", "--no_hf_mode", "--no-hf-mode", 
-        action="store_true", dest="full",
-        help=_i18n("app_full_help")
-    )
+import argparse
+from pathlib import Path
+from i18n import _i18n
+BASE_DIR = Path(__file__).resolve().parent
+from audio import output_formats
+
+def tobool(val: str | bool | int):
+    if isinstance(val, int):
+        return True if val >= 1 else False
+    elif isinstance(val, str):
+        if val in ["y", "yes", "Yes", "true", "True", "1"]:
+            return True
+        else:
+            return False
+    elif isinstance(val, bool):
+        return val
+
+class NestedAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        # Разбиваем dest по точке, например 'database.host'
+        group, dest = self.dest.split('.', 1)
+        # Получаем или создаем вложенный Namespace
+        groupspace = getattr(namespace, group, argparse.Namespace())
+        # Устанавливаем значение во вложенный объект
+        setattr(groupspace, dest, values)
+        # Сохраняем вложенный объект в основной
+        setattr(namespace, group, groupspace)
+
+class NestedStoreTrue(argparse.Action):
+    def __init__(self, option_strings, dest, default=False, help=None, **kwargs):
+        # 1. Сразу при создании парсера готовим структуру во вложенном Namespace
+        super().__init__(option_strings=option_strings, dest=dest, nargs=0, default=default, help=help, **kwargs)
+        
+    def __call__(self, parser, namespace, values, option_string=None):
+        # 2. Если флаг передан, меняем False на True
+        group, attr = self.dest.split('.', 1)
+        groupspace = getattr(namespace, group, argparse.Namespace())
+        setattr(groupspace, attr, True)
+        setattr(namespace, group, groupspace)
+
+def parse_separator_args(add_params_args: dict = {}):
+    parser = argparse.ArgumentParser(
+        description=_i18n("arg_main_description"),
+        epilog=_i18n("arg_main_epilog")
+    )
+    subparsers = parser.add_subparsers(
+        title=_i18n("arg_subcommands_title"),
+        dest="mode",
+        description=_i18n("arg_subcommands_description"),
+        help=_i18n("arg_subcommands_help")
+    )
+    
+    # separate
+    separate_parser = subparsers.add_parser(
+        "separate",
+        help=_i18n("arg_separate_help"),
+        description=_i18n("arg_separate_description"),
+        epilog=_i18n("arg_separate_epilog")
+    )
+    
+    # custom_separate
+    custom_separate_parser = subparsers.add_parser(
+        "custom_separate",
+        help=_i18n("arg_custom_separate_help"),
+        description=_i18n("arg_custom_separate_description"),
+        epilog=_i18n("arg_custom_separate_epilog")
+    )
+    
+    # info
+    info_parser = subparsers.add_parser(
+        "info",
+        help=_i18n("arg_info_help"),
+        description=_i18n("arg_info_description"),
+        epilog=_i18n("arg_info_epilog")
+    )
+    
+    # auto_ensemble
+    auto_ensemble_parser = subparsers.add_parser(
+        "auto_ensemble",
+        help=_i18n("arg_auto_ensemble_help"),
+        description=_i18n("arg_auto_ensemble_description"),
+        epilog=_i18n("arg_auto_ensemble_epilog")
+    )
+    
+    # manual_ensemble
+    manual_ensemble_parser = subparsers.add_parser(
+        "manual_ensemble",
+        help=_i18n("arg_manual_ensemble_help"),
+        description=_i18n("arg_manual_ensemble_description"),
+        epilog=_i18n("arg_manual_ensemble_epilog")
+    )
+    
+    # subtract
+    subtract_parser = subparsers.add_parser(
+        "subtract",
+        help=_i18n("arg_subtract_help"),
+        description=_i18n("arg_subtract_description"),
+        epilog=_i18n("arg_subtract_epilog")
+    )
+
+    # separate
+    separate_parser.add_argument(
+        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
+        nargs="+", dest="input",
+        help=_i18n("arg_input_help")
+    )
+    separate_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    separate_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    separate_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_STEM_MODEL", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_separate"), example="NAME_STEM_MODEL")
+    )
+    separate_parser.add_argument(
+        "-mn", "-model", "--model_name", "--model-name", 
+        type=str, default="bs_6stem", dest="model_name",
+        help=_i18n("arg_model_name_help")
+    )
+    separate_parser.add_argument(
+        "-inst", "-ext_inst", "-ext-inst", "--extract_instrumental", "--extract-instrumental", 
+        action="store_true", dest="extract_instrumental",
+        help=_i18n("arg_extract_instrumental_help")
+    )
+    separate_parser.add_argument(
+        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
+        action="store_true", dest="use_spec_invert",
+        help=_i18n("arg_use_spec_invert_help")
+    )
+    separate_parser.add_argument(
+        "-st", "--st", "-stems", "--stems", "--selected_stems", "--selected-stems", 
+        nargs="*", metavar="STEM", dest="selected_stems",
+        help=_i18n("arg_selected_stems_help")
+    )
+    for param_name, param_value in add_params_args.items():
+        param_type = param_value.get("type")
+        default = param_value.get("default")
+        separate_parser.add_argument(
+            f"--{param_name}", 
+            action=NestedStoreTrue if param_type == "bool" else NestedAction,
+            type=None if param_type == "bool" else (int if param_type == "int" else (float if param_type == "float" else str)),
+            default=default,
+            dest=f"add_params.{param_name}",
+            help=_i18n("arg_add_param_help")
+        )
+
+    # custom_separate
+    custom_separate_parser.add_argument(
+        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
+        nargs="+", dest="input",
+        help=_i18n("arg_input_help")
+    )
+    custom_separate_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    custom_separate_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    custom_separate_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_STEM_MODEL", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_separate"), example="NAME_STEM_MODEL")
+    )
+    custom_separate_parser.add_argument(
+        "-mt", "-mtype", "--model_type", "--model-type", 
+        type=str, default="bs_roformer", dest="model_type",
+        help=_i18n("arg_model_type_help")
+    )
+    custom_separate_parser.add_argument(
+        "-ckpt", "--ckpt", "-checkpoint", "--checkpoint", "--checkpoint_path", "--checkpoint-path", 
+        type=str, required=True, dest="checkpoint_path",
+        help=_i18n("arg_checkpoint_path_help")
+    )
+    custom_separate_parser.add_argument(
+        "-conf", "--conf", "-config", "--config", "--config_path", "--config-path", 
+        type=str, required=True, dest="config_path",
+        help=_i18n("arg_config_path_help")
+    )
+    custom_separate_parser.add_argument(
+        "-inst", "-ext_inst", "-ext-inst", "--extract_instrumental", "--extract-instrumental", 
+        action="store_true", dest="extract_instrumental",
+        help=_i18n("arg_extract_instrumental_help")
+    )
+    custom_separate_parser.add_argument(
+        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
+        action="store_true", dest="use_spec_invert",
+        help=_i18n("arg_use_spec_invert_help")
+    )
+    custom_separate_parser.add_argument(
+        "-st", "--st", "-stems", "--stems", "--selected_stems", "--selected-stems", 
+        nargs="*", metavar="STEM", dest="selected_stems",
+        help=_i18n("arg_selected_stems_help")
+    )
+    for param_name, param_value in add_params_args.items():
+        param_type = param_value.get("type")
+        default = param_value.get("default")
+        custom_separate_parser.add_argument(
+            f"--{param_name}", 
+            action=NestedStoreTrue if param_type == "bool" else NestedAction,
+            type=None if param_type == "bool" else (int if param_type == "int" else (float if param_type == "float" else str)),
+            default=default,
+            dest=f"add_params.{param_name}",
+            help=_i18n("arg_add_param_help")
+        )
+
+    # auto_ensemble
+    auto_ensemble_parser.add_argument(
+        "-i", "--i", "-input", "--input", "--input_file", "--input-file", 
+        type=str, required=True, dest="input",
+        help=_i18n("arg_input_single_help")
+    )
+    auto_ensemble_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    auto_ensemble_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    auto_ensemble_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE_COUNT", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_auto_ensemble"), example="NAME_COUNT_TYPE")
+    )
+    auto_ensemble_parser.add_argument(
+        "-t", "-type", "-etype", "--ensemble_type", "--ensemble-type", 
+        type=str, default="avg_fft", dest="ensemble_type",
+        help=_i18n("arg_ensemble_type_help")
+    )
+    auto_ensemble_parser.add_argument(
+        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
+        action="store_true", dest="use_spec_invert",
+        help=_i18n("arg_use_spec_invert_help")
+    )
+    auto_ensemble_parser.add_argument(
+        "-save_stems", "-save-stems", "-save_primary_stems", "--save-primary-stems", 
+        action="store_true", dest="save_primary_stems",
+        help=_i18n("arg_save_primary_stems_help")
+    )
+    auto_ensemble_flow_group = auto_ensemble_parser.add_mutually_exclusive_group(required=True)
+    auto_ensemble_flow_group.add_argument(
+        "-flow", "--flow", nargs="+", metavar="MODEL:PRIMARY_STEM:INVERT:WEIGHTS", 
+        dest="flow",
+        help=_i18n("arg_flow_help")
+    )
+    auto_ensemble_flow_group.add_argument(
+        "-json", "-preset", "-preset_json", "-preset-json", "--preset_json", "--preset-json", 
+        type=str, dest="preset",
+        help=_i18n("arg_preset_json_help")
+    )
+
+    # manual_ensemble
+    manual_ensemble_parser.add_argument(
+        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
+        nargs="+", dest="input",
+        help=_i18n("arg_input_help")
+    )
+    manual_ensemble_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    manual_ensemble_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    manual_ensemble_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_manual_ensemble"), example="NAME_TYPE")
+    )
+    manual_ensemble_parser.add_argument(
+        "-t", "-type", "-etype", "--ensemble_type", "--ensemble-type", 
+        type=str, default="avg_fft", dest="ensemble_type",
+        help=_i18n("arg_ensemble_type_help")
+    )
+    manual_ensemble_parser.add_argument(
+        "-w", "-weights", "--weights", type=float, nargs="*", dest="weights",
+        help=_i18n("arg_weights_help")
+    )
+
+    # subtract
+    subtract_parser.add_argument(
+        "-i1", "--i1", "-input1", "--input1", "--input_file1", "--input-file1", 
+        type=str, required=True, dest="input_1",
+        help=_i18n("arg_input1_help")
+    )
+    subtract_parser.add_argument(
+        "-i2", "--i2", "-input2", "--input2", "--input_file2", "--input-file2", 
+        type=str, required=True, dest="input_2",
+        help=_i18n("arg_input2_help")
+    )
+    subtract_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    subtract_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    subtract_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_TYPE", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_subtract"), example="NAME_TYPE")
+    )
+    subtract_parser.add_argument(
+        "-ispec", "-spec_invert", "-spec-invert", "--use_spec_invert", "--use-spec-invert",  
+        action="store_true", dest="use_spec_invert",
+        help=_i18n("arg_use_spec_invert_help")
+    )
+
+    # info
+    info_parser.add_argument(
+        "-u", "-update", "--update", action="store_true", dest="update",
+        help=_i18n("arg_update_help")
+    )
+    info_parser.add_argument(
+        "-clear", "-clear_cache", "-clear-cache", "--clear_cache", "--clear-cache", 
+        action="store_true", dest="clear_cache",
+        help=_i18n("arg_clear_cache_help")
+    )
+    info_parser.add_argument(
+        "-mn", "-model", "--model_name", "--model-name", 
+        type=str, default="bs_6stem", dest="model_name",
+        help=_i18n("arg_model_name_help")
+    )
+    info_parser.add_argument(
+        "-dw", "-download", "--download", action="store_true", dest="download",
+        help=_i18n("arg_download_help")
+    )
+    info_parser.add_argument(
+        "-l", "-limit", "--limit", type=int, default=None, dest="limit",
+        help=_i18n("arg_limit_help")
+    )
+    info_parser.add_argument(
+        "-s", "-stem", "--stem", type=str, default=None, dest="stem",
+        help=_i18n("arg_stem_filter_help")
+    )
+    info_parser.add_argument(
+        "-oi", "-installed", "--only_installed", "--only-installed", 
+        action="store_true", dest="only_installed",
+        help=_i18n("arg_only_installed_help")
+    )
+
+    return parser.parse_args()
+
+
+def parse_vbach_args():
+    parser = argparse.ArgumentParser(
+        description=_i18n("vbach_main_description"),
+        epilog=_i18n("vbach_main_epilog")
+    )
+    subparsers = parser.add_subparsers(
+        title=_i18n("arg_subcommands_title"),
+        dest="mode",
+        description=_i18n("arg_subcommands_description"),
+        help=_i18n("arg_subcommands_help")
+    )
+    
+    # infer
+    infer_parser = subparsers.add_parser(
+        "infer",
+        help=_i18n("vbach_infer_help"),
+        description=_i18n("vbach_infer_description"),
+        epilog=_i18n("vbach_infer_epilog")
+    )
+    
+    # infer_custom_f0
+    infer_custom_f0_parser = subparsers.add_parser(
+        "infer_custom_f0",
+        help=_i18n("vbach_infer_custom_f0_help"),
+        description=_i18n("vbach_infer_custom_f0_description"),
+        epilog=_i18n("vbach_infer_custom_f0_epilog")
+    )
+    
+    # download_hubert
+    download_hubert_parser = subparsers.add_parser(
+        "download_hubert",
+        help=_i18n("vbach_download_hubert_help"),
+        description=_i18n("vbach_download_hubert_description"),
+        epilog=_i18n("vbach_download_hubert_epilog")
+    )
+
+    # infer
+    infer_parser.add_argument(
+        "-i", "--i", "-input", "--input", "--input_files", "--input-files", 
+        nargs="+", dest="input",
+        help=_i18n("arg_input_help")
+    )
+    infer_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    infer_parser.add_argument(
+        "-m", "-model", "--model_path", "--model-path", 
+        type=str, required=True, dest="checkpoint_path",
+        help=_i18n("vbach_model_path_help")
+    )
+    infer_parser.add_argument(
+        "-idx", "-index", "--index_path", "--index-path", 
+        type=str, default="", dest="index_path",
+        help=_i18n("vbach_index_path_help")
+    )
+    infer_parser.add_argument(
+        "-p", "-pitch", "--pitch", type=int, default=0, dest="pitch",
+        help=_i18n("vbach_pitch_help")
+    )
+    infer_parser.add_argument(
+        "-f0m", "-f0_method", "--f0_method", "--f0-method", 
+        type=str, default="rmvpe+", dest="f0_method",
+        help=_i18n("vbach_f0_method_help")
+    )
+    infer_parser.add_argument(
+        "-idxr", "-index_rate", "--index_rate", "--index-rate", 
+        type=float, default=0.75, dest="index_rate",
+        help=_i18n("vbach_index_rate_help")
+    )
+    infer_parser.add_argument(
+        "-ve", "-volume_envelope", "--volume_envelope", "--volume-envelope", 
+        type=float, default=0.25, dest="volume_envelope",
+        help=_i18n("vbach_volume_envelope_help")
+    )
+    infer_parser.add_argument(
+        "-pr", "-protect", "--protect", type=float, default=0.33, dest="protect",
+        help=_i18n("vbach_protect_help")
+    )
+    infer_parser.add_argument(
+        "-hl", "-hop_length", "--hop_length", "--hop-length", 
+        type=int, default=128, dest="hop_length",
+        help=_i18n("vbach_hop_length_help")
+    )
+    infer_parser.add_argument(
+        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
+        type=str, default="hubert_base", dest="embedder",
+        help=_i18n("vbach_embedder_help")
+    )
+    infer_parser.add_argument(
+        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
+        action="store_true", dest="use_transformers",
+        help=_i18n("vbach_use_transformers_help")
+    )
+    infer_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    infer_parser.add_argument(
+        "-stm", "-stereo_mode", "--stereo_mode", "--stereo-mode", 
+        type=str, choices=("mono", "left/right", "sim/dif"), default="mono", dest="stereo_mode",
+        help=_i18n("vbach_stereo_mode_help")
+    )
+    infer_parser.add_argument(
+        "-f0min", "--f0_min", "--f0-min", type=int, default=50, dest="f0_min",
+        help=_i18n("vbach_f0_min_help")
+    )
+    infer_parser.add_argument(
+        "-f0max", "--f0_max", "--f0-max", type=int, default=1100, dest="f0_max",
+        help=_i18n("vbach_f0_max_help")
+    )
+    infer_parser.add_argument(
+        "-chd", "-chunk_duration", "--chunk_duration", "--chunk-duration", 
+        type=int, default=7, dest="chunk_duration",
+        help=_i18n("vbach_chunk_duration_help")
+    )
+    infer_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_F0METHOD_PITCH", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_vbach"), example="NAME_F0METHOD_PITCH")
+    )
+
+    # infer_custom_f0
+    infer_custom_f0_parser.add_argument(
+        "-i", "--i", "-input", "--input", type=str, required=True, dest="input",
+        help=_i18n("arg_input_single_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_dir", "--output-dir", 
+        type=str, default=".", dest="output_dir",
+        help=_i18n("arg_output_dir_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-m", "-model", "--model_path", "--model-path", 
+        type=str, required=True, dest="checkpoint_path",
+        help=_i18n("vbach_model_path_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-idx", "-index", "--index_path", "--index-path", 
+        type=str, default="", dest="index_path",
+        help=_i18n("vbach_index_path_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-p", "-pitch", "--pitch", type=int, default=0, dest="pitch",
+        help=_i18n("vbach_pitch_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-f0f", "-f0_file", "--f0_file", "--f0-file", 
+        type=str, dest="f0_file",
+        help=_i18n("vbach_f0_file_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-idxr", "-index_rate", "--index_rate", "--index-rate", 
+        type=float, default=0.75, dest="index_rate",
+        help=_i18n("vbach_index_rate_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-ve", "-volume_envelope", "--volume_envelope", "--volume-envelope", 
+        type=float, default=0.25, dest="volume_envelope",
+        help=_i18n("vbach_volume_envelope_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-pr", "-protect", "--protect", type=float, default=0.33, dest="protect",
+        help=_i18n("vbach_protect_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
+        type=str, default="hubert_base", dest="embedder",
+        help=_i18n("vbach_embedder_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
+        action="store_true", dest="use_transformers",
+        help=_i18n("vbach_use_transformers_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-of", "-output_fmt", "--output_format", "--output-format", 
+        type=str, choices=output_formats, default=output_formats[0], dest="output_format",
+        help=_i18n("arg_output_format_help", formats=", ".join(output_formats), default=output_formats[0])
+    )
+    infer_custom_f0_parser.add_argument(
+        "-stm", "-stereo_mode", "--stereo_mode", "--stereo-mode", 
+        type=str, choices=("mono", "left/right", "sim/dif"), default="mono", dest="stereo_mode",
+        help=_i18n("vbach_stereo_mode_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-f0min", "--f0_min", "--f0-min", type=int, default=50, dest="f0_min",
+        help=_i18n("vbach_f0_min_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-f0max", "--f0_max", "--f0-max", type=int, default=1100, dest="f0_max",
+        help=_i18n("vbach_f0_max_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-chd", "-chunk_duration", "--chunk_duration", "--chunk-duration", 
+        type=int, default=7, dest="chunk_duration",
+        help=_i18n("vbach_chunk_duration_help")
+    )
+    infer_custom_f0_parser.add_argument(
+        "-tm", "-tmplt", "--template", type=str, default="NAME_F0METHOD_PITCH", dest="template",
+        help=_i18n("arg_template_help", keys=_i18n("template_keys_vbach"), example="NAME_F0METHOD_PITCH")
+    )
+
+    # download_hubert
+    download_hubert_parser.add_argument(
+        "-emb", "-embedder", "--embedder_model", "--embedder-model", 
+        type=str, default="hubert_base", dest="embedder",
+        help=_i18n("vbach_embedder_help")
+    )
+    download_hubert_parser.add_argument(
+        "-tf", "-use_transformers", "--use_transformers", "--use-transformers", 
+        action="store_true", dest="use_transformers",
+        help=_i18n("vbach_use_transformers_help")
+    )
+
+    return parser.parse_args()
+
+
+def parse_f0_extract():
+    parser = argparse.ArgumentParser(
+        description=_i18n("f0_extract_description"),
+        epilog=_i18n("f0_extract_epilog")
+    )
+    parser.add_argument(
+        "-i", "--i", "-input", "--input", 
+        type=str, required=True, dest="input",
+        help=_i18n("arg_input_single_help")
+    )
+    parser.add_argument(
+        "-f0m", "-f0_method", "--f0_method", "--f0-method", 
+        type=str, default="rmvpe+", dest="f0_method",
+        help=_i18n("vbach_f0_method_help")
+    )
+    parser.add_argument(
+        "-f0min", "--f0_min", "--f0-min", 
+        type=int, default=50, dest="f0_min",
+        help=_i18n("vbach_f0_min_help")
+    )
+    parser.add_argument(
+        "-f0max", "--f0_max", "--f0-max", 
+        type=int, default=1100, dest="f0_max",
+        help=_i18n("vbach_f0_max_help")
+    )
+    parser.add_argument(
+        "-o", "-out", "-output", "--output", "--output_path", "--output-path", 
+        type=str, default=None, dest="output_path",
+        help=_i18n("f0_extract_output_help")
+    )
+    return parser.parse_args()
+
+
+def parse_app_args():
+    parser = argparse.ArgumentParser(
+        description=_i18n("app_description"),
+        epilog=_i18n("app_epilog")
+    )
+    parser.add_argument(
+        "-s", "-share", "--share", "--public", "--gradio_share", "--gradio-share", 
+        action="store_true", dest="share",
+        help=_i18n("app_share_help")
+    )
+    parser.add_argument(
+        "-p", "-port", "--port", "--server_port", "--server-port", 
+        type=int, default=None, dest="port",
+        help=_i18n("app_port_help")
+    )
+    parser.add_argument(
+        "-f", "-full", "--full", "--no_hf_mode", "--no-hf-mode", 
+        action="store_true", dest="full",
+        help=_i18n("app_full_help")
+    )
     return parser.parse_args()

extra_utils.py

@@ -20,7 +20,7 @@ import ctypes
 import platform
 import numpy as np
 import yt_dlp
-import hashlib
+import subprocess
 
 try:
     import spaces
@@ -47,7 +47,39 @@ if spaces is not None:
 import torch
 tz = timezone(timedelta(hours=3))
 
+def get_gdrive_dir():
+    try:
+        result = subprocess.run(['/bin/mount'], capture_output=True, text=True)
+        for line in result.stdout.strip().split('\n'):
+            if 'type fuse.drive' in line:
+                parts = line.split(' type ')
+                if len(parts) >= 2:
+                    source_mount = parts[0]
+                    source, mount_point = source_mount.split(' on ')
+                    return mount_point
+    except:
+        pass
+    return None
 
+def easy_check_is_colab() -> bool:
+    """
+    Проверить, выполняется ли код в Google Colab
+    
+    Returns:
+        True если в Colab
+    """
+    if platform.machine() == "x86_64" and "Linux" in platform.platform():
+        try:
+            import google.colab
+            module_path: str = google.colab.__file__
+            if module_path.startswith("/usr/local/lib/python") and module_path.endswith("/dist-packages/google/colab/__init__.py"):
+                return True
+            else:
+                return False
+        except ImportError:
+            return False
+    else:
+        return False
 
 class DownloadError(Exception): pass
 
@@ -80,9 +112,6 @@ base_c_params = {
     }
 }
 
-def get_info():
-    pass
-
 def size_readable(size_bytes: int):
     if size_bytes == 0:
         return f"0 {_i18n('bytes')}"
@@ -95,6 +124,23 @@ def size_readable(size_bytes: int):
         i += 1
     return f"{size_bytes:.2f} {units[i]}"
 
+def get_size_folder(folder: str | Path):
+    folder_path = Path(folder)
+    return sum([file.stat().st_size for file in folder_path.rglob('*') if file.is_file()])
+
+def get_disk_usage(path="/content/drive/MyDrive", user_dir="", user_gdrive_dir="", list_subdirs=[]):
+    try:
+        usage = shutil.disk_usage(path)
+        
+        total_gb = size_readable(usage.total)
+        used_gb = size_readable(usage.used)
+        free_gb = size_readable(usage.free)
+        return f"""{_i18n("all_space")}: {total_gb}
+{_i18n("used_space")}: {used_gb}
+{_i18n("free_space")}: {free_gb}"""
+    except Exception as e:
+        return ""
+
 def define_audio_with_size(basename: bool = False, **kwargs):
     path = kwargs.get("value", None)
     if not path:
@@ -510,87 +556,4 @@ def extra_clear_torch_cache():
     if hasattr(torch._C, "_jit_pass_onnx_clear_scope_records"):
         try:
             torch._C._jit_pass_onnx_clear_scope_records()
-        except Exception: pass
-
-class UserDirectory:
-    def __init__(self):
-        self.user_directory = Path('.')
-
-    def change_dir(self, dir: str):
-        self.user_directory = Path(dir)
-
-    def generate(self, name: str):
-        timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
-        generated_directory = self.user_directory / name / timestamp
-        generated_directory.mkdir(parents=True, exist_ok=True)
-        return generated_directory
-    
-    def generate_from_dir(self, dir: str):
-        timestamp = datetime.now(tz).strftime("%Y-%m-%d_%H-%M-%S")
-        generated_directory = Path(dir) / timestamp
-        generated_directory.mkdir(parents=True, exist_ok=True)
-        return generated_directory
-
-class InputFilesDatabase(UserDirectory):
-    def __init__(self):
-        super().__init__()
-        self.input_dir_base = self.user_directory / "input"
-        self.input_dir_base.mkdir(parents=True, exist_ok=True)
-        self.input_base_json = self.input_dir_base / "inputs.json"
-        self.input_base = []
-        self.load()
-
-    def _write_decorator(func):
-        def wrapper(self, *args, **kwargs):
-            results_ = func(self, *args, **kwargs)
-            self.write()
-            return results_
-        return wrapper
-
-    def _load_decorator(func):
-        def wrapper(self, *args, **kwargs):
-            self.load()
-            results_ = func(self, *args, **kwargs)
-            return results_
-        return wrapper
-
-    def write(self):
-        self.input_base_json.write_text(json.dumps(self.input_base, ensure_ascii=False, indent=4), encoding="utf-8")
-
-    def load(self):
-        if self.input_base_json.exists():
-            self.input_base = json.loads(self.input_base_json.read_text("utf-8"))
-            print(_i18n("input_base_loaded"))
-
-    @_write_decorator
-    def upload(self, files, copy=False):
-        input_dir = self.generate_from_dir(self.input_dir_base)
-        uploaded_input_files = []
-        valid_files = get_audio_files_from_list(files, only_files=True)
-        for file in valid_files:
-            new_file = Namer.iter(input_dir / Path(file).name)
-            if copy:
-                shutil.copy2(file, new_file)
-            else:
-                shutil.move(file, new_file)
-            uploaded_input_files.append(new_file)
-        self.input_base.extend(uploaded_input_files)
-        return uploaded_input_files
-
-    @_write_decorator
-    def clear(self):
-        for path in self.input_base:
-            Path(path).unlink(missing_ok=True)
-        self.input_base.clear()
-        print(_i18n("input_base_cleared"))
-
-    def get_input_list(self):
-        return list(reversed(self.input_base))
-    
-class OutputDir(UserDirectory):
-    def __init__(self, dir: str = "output_mvsepless"):
-        super().__init__()
-        self.output_dir_name = dir
-
-    def gen_output_dir(self):
-        return self.generate(self.output_dir_name)
+        except Exception: pass

i18n.py

@@ -551,7 +551,22 @@ TRANSLATIONS: Dict[Language, Dict[str, str]] = {
         "no": "Нет",
         "zerogpu=true": "Среда выполнения - ZeroGPU",
         "ensemble_processing": "Создание ансамбля",
-        "tracks": "треков"
+        "tracks": "треков",
+        "app_user_dir_help": "Путь к директории для хранения пользовательских файлов",
+        "gdrive_mount_found": "Обнаружен привязанный Google Диск",
+        "copy_to_gdrive": "Копирование данных на Google Диск",
+        "dirs": "директорий",
+        "copy_to_gdrive_done": "Копирование завершено",
+        "copied_dirs": "Скопировано директорий",
+        "copy_from_current_user_dir_to_gdrive": "Копировать все пользовательские данные на Google Диск",
+        "google_drive": "Google Диск",
+        "copy_from_gdrive_to_current_user_dir": "Копировать все пользовательские данные с Google Диска в среду выполнения",
+        "copy_to_current_user_dir": "Копирование данных в среду выполнения",
+        "free_space": "Свободно",
+        "used_space": "Использовано",
+        "all_space": "Всего",
+        "used_space_data_local": "Обьем пользовательских данных в среде выполнения",
+        "used_space_data_gdrive": "Обьем пользовательских данных на Google Диске"
     },
     "en": {
         "bytes": "B",
@@ -1087,7 +1102,20 @@ Example: `NAME_F0METHOD_PITCH` → `Song_custom_0`
         "no": "No",
         "zerogpu=true": "Runtime is ZeroGPU",
         "ensemble_processing": "Creating ensemble",
-        "tracks": "tracks"
+        "tracks": "tracks",
+        "app_user_dir_help": "Path to directories for storing user files",
+        "gdrive_mount_found": "Detected mounted Google Drive",
+        "copy_to_gdrive": "Copying data to Google Drive",
+        "dirs": "directories",
+        "copy_to_gdrive_done": "Copy complete",
+        "copied_dirs": "Directories copied",
+        "copy_from_current_user_dir_to_gdrive": "Copy all user data to Google Drive",
+        "google_drive": "Google Drive",
+        "free_space": "Free",
+        "used_space": "Used",
+        "all_space": "All",
+        "used_space_data_local": "User data space in runtime",
+        "used_space_data_gdrive": "User data space on Google Drive"
     }
 }
 

inference.py

@@ -273,24 +273,30 @@ class MSSI: # Music Source Separation Inference
     def set_add_params(self, **kwargs):
         self.add_params = kwargs
 
-    def load_config(self, model_type: str, conf: str):
-        conf_ = Path(conf)
+    def load_config(self, model_type: str, conf: str | Path):
+        if not conf:
+            raise PathNotSpecified(_i18n("path_not_specified"))
+        self.conf_path = Path(conf)
+        if not self.conf_path.exists():
+            self.conf_path = None
+            raise PathNotExist(_i18n("path_not_exist"))
         if model_type not in self.model_types:
             raise UnknownModelType(_i18n("unknown_model_type", model_type=model_type))
         self.model_type = model_type
         try:
             if self.model_type == "htdemucs":
-                self.config = OmegaConf.load(conf_)
+                self.config = OmegaConf.load(self.conf_path)
                 self.sample_rate = self.config.training.samplerate
             else:
-                with conf_.open("r", encoding="utf-8") as f:
+                with self.conf_path.open("r", encoding="utf-8") as f:
                     self.config = ConfigDict(yaml.load(f, Loader=yaml.FullLoader))
                     self.sample_rate = self.config.audio.sample_rate
             self.target_instrument = self.config.training.target_instrument
             self.instruments = self.config.training.instruments
-            print(_i18n("config_loaded")+": "+conf.name)
+            print(_i18n("config_loaded")+": "+self.conf_path.name)
         except FileNotFoundError:
             self.config = None
+            self.conf_path = None
             self.model_type = None
             self.target_instrument = None
             self.instruments = []
@@ -298,6 +304,7 @@ class MSSI: # Music Source Separation Inference
             raise FileNotFoundError(_i18n("config_not_found", path=conf)) from e
         except Exception as e:
             self.config = None
+            self.conf_path = None
             self.model_type = None
             self.target_instrument = None
             self.instruments = []
@@ -508,13 +515,13 @@ class MSSI: # Music Source Separation Inference
     def load_checkpoint(self, ckpt: str | Path):
         if not ckpt:
             raise PathNotSpecified(_i18n("path_not_specified"))
-        ckpt_ = Path(ckpt)
-        if not ckpt_.exists():
+        self.ckpt_path = Path(ckpt)
+        if not self.ckpt_path.exists():
+            self.ckpt_path = None
             raise PathNotExist(_i18n("path_not_exist"))
         if not self.model:
+            self.ckpt_path = None
             raise ModelNotLoaded(_i18n("model_not_loaded"))
-        
-        self.ckpt_path = ckpt_
 
         if self.model_type == "mdxnet":
             try:
@@ -1312,7 +1319,7 @@ class MSSI: # Music Source Separation Inference
             result = self.output_arrays[primary_stem]
         return result, self.sample_rate
 
-    def load_model(self, model_type: str, ckpt: str, conf: str):
+    def load_model(self, model_type: str, ckpt: str | Path, conf: str | Path):
         self.clear_model()
         self.load_config(model_type=model_type, conf=conf)
         self.load_model_instance()

vbach_lib/infer.py

@@ -1,398 +1,399 @@
-from pathlib import Path
-import sys
-SCRIPT_DIR = Path(__file__).resolve().parent
-sys.path.append(str(SCRIPT_DIR.parent))
-from extra_utils import hf_spaces_gpu, extra_clear_torch_cache, nuclear_clear_model, emergency_ram_clear
-if __package__:
-    from .hubert_manager import get_hubert, download_hubert, huberts_fairseq
-    from .pipeline import VC
-    from .config import Config
-    from .fairseq import load_model
-    from .algorithm.synthesizers import Synthesizer
-else:
-    from vbach_lib.hubert_manager import get_hubert, download_hubert, huberts_fairseq
-    from vbach_lib.pipeline import VC
-    from vbach_lib.config import Config
-    from vbach_lib.fairseq import load_model
-    from vbach_lib.algorithm.synthesizers import Synthesizer
-from transformers import HubertModel
-from pathlib import Path
-import traceback
-from audio import read, write, split_channels, split_mid_side, multi_channel_array_from_arrays, output_formats, stereo_to_mono, reshape, mix_arrays, get_audio_files_from_list, check
-from inference import PathsNotSpecified, PathNotExist, PathNotSpecified, FileIsNotAudio
-from i18n import _i18n
-from namer import Namer
-from args_parser import parse_vbach_args
-import numpy as np
-import torch
-from torch import nn
-import gc
-
-class VbachModelNotFound(Exception): pass
-
-stereo_modes = ("mono", "left/right", "sim/dif")
-
-class HubertModelWithFinalProj(HubertModel):
-    """Hubert модель с финальной проекцией"""
-    
-    def __init__(self, config):
-        super().__init__(config)
-        self.final_proj = nn.Linear(config.hidden_size, config.classifier_proj_size)
-
-def load_audio(path: str | Path, sr: int, stereo_mode: str = stereo_modes[0]):
-    mixtures = []
-    add_text = []
-    if stereo_mode == "mono":
-        mix, _sr = read(path, sr, mono=True, flatten=True)
-        mixtures.append(mix)
-        add_text.append(None)
-    elif stereo_mode == "left/right":
-        mix, _sr = read(path, sr, mono=False)
-        mixtures.extend(split_channels(mix))
-        add_text.extend(["[L]", "[R]"])
-    elif stereo_mode == "sim/dif":
-        mix, _sr = read(path, sr, mono=False)
-        center, stereo_base = split_mid_side(mix, var=3, sr=sr)
-        phantom_center = stereo_to_mono(center, to_flatten=True)
-        stereo_base_left, stereo_base_right = split_channels(stereo_base)
-        mixtures.extend([phantom_center, stereo_base_left, stereo_base_right])
-        add_text.extend(["[Sim]", "[Dif-L]", "[Dif-R]"])
-    return mixtures, add_text
-
-def post_process_audio(mixtures: list[np.ndarray], target_sr: int, stereo_mode: str = stereo_modes[0]):
-    if stereo_mode == "mono":
-        return reshape(mixtures[0], ("channels", "samples"))
-    elif stereo_mode == "left/right":
-        dtype = mixtures[0].dtype
-        return multi_channel_array_from_arrays(*mixtures, index=1, dtype=dtype)
-    elif stereo_mode == "sim/dif":
-        sim, dif_l, dif_r = mixtures
-        dtype = sim.dtype
-        sim_channel = multi_channel_array_from_arrays(sim, sim, index=1, dtype=dtype)
-        dif_channel = multi_channel_array_from_arrays(dif_l, dif_r, index=1, dtype=dtype)
-        return mix_arrays([sim_channel, dif_channel], [target_sr, target_sr], target_sr, index=1, dtype=dtype)[0]
-
-class VbachConverter:
-    def __init__(self):
-        self.config = Config()
-        self.hubert_model = None 
-        self.cpt = self.version = self.net_g = self.tgt_sr = self.vc = self.use_f0 = self.vocoder = self.emb_weight_shape = self.required_keys = self.missing_keys = self.text_enc_hidden_dim = None
-    def load_hubert(self, name: str, use_transformers: bool):
-        if use_transformers:
-            model_path = get_hubert(name, True)
-            self.hubert_model = HubertModelWithFinalProj.from_pretrained(model_path)
-            self.hubert_model = self.hubert_model.to(self.config.device)
-        else:
-            model_path = get_hubert(name, False)
-            self.hubert_model = load_model(model_path)
-            self.hubert_model = self.hubert_model.to(self.config.device)
-            self.hubert_model = self.hubert_model.half() if self.config.is_half else self.hubert_model.float()
-            self.hubert_model.eval()
-        print(_i18n("hubert_checkpoint_loaded")+": "+name)
-
-    def unload_hubert(self):
-        self.hubert_model = self.hubert_model.cpu()
-        self.hubert_model = None
-        gc.collect()
-        extra_clear_torch_cache()
-        nuclear_clear_model()
-        emergency_ram_clear()
-
-    def unload_model(self):
-        self.net_g = self.net_g.cpu()
-        del self.cpt, self.version, self.net_g, self.tgt_sr, self.vc, self.use_f0, self.vocoder, self.emb_weight_shape, self.required_keys, self.missing_keys, self.text_enc_hidden_dim
-        self.cpt = self.version = self.net_g = self.tgt_sr = self.vc = self.use_f0 = self.vocoder = self.emb_weight_shape = self.required_keys = self.missing_keys = self.text_enc_hidden_dim = None
-        extra_clear_torch_cache()
-        nuclear_clear_model()
-        emergency_ram_clear()
-
-    def clear_gpu_cache(self):
-        gc.collect()
-        torch.clear_autocast_cache()
-        if self.config.device.type == "mps":
-            torch.mps.empty_cache()
-        if self.config.device.type == "cuda":
-            torch.cuda.synchronize()
-            torch.cuda.ipc_collect()
-            torch.cuda.empty_cache()
-
-    def get_vc(self, model_path: str | Path, use_transformers: bool):
-        self.cpt = torch.load(model_path, map_location="cpu", weights_only=True)
-        self.required_keys = ["config", "weight"]
-        self.missing_keys = [key for key in self.required_keys if key not in self.cpt]
-
-        self.tgt_sr = self.cpt["config"][-1]
-
-        self.emb_weight_shape = self.cpt["weight"]["emb_g.weight"].shape
-        self.cpt["config"][-3] = self.emb_weight_shape[0]
-
-        self.use_f0 = self.cpt.get("f0", 1)
-        self.version = self.cpt.get("version", "v1")
-        self.vocoder = self.cpt.get("vocoder", "HiFi-GAN")
-
-        self.text_enc_hidden_dim = 768 if self.version == "v2" else 256
-
-        self.net_g = Synthesizer(
-            *self.cpt["config"],
-            use_f0=self.use_f0,
-            text_enc_hidden_dim=self.text_enc_hidden_dim,
-            vocoder=self.vocoder,
-        )
-
-        if hasattr(self.net_g, "enc_q"):
-            del self.net_g.enc_q
-        else:
-            pass
-
-        self.net_g.load_state_dict(
-            self.cpt["weight"], strict=False
-        )
-        self.net_g.eval()
-
-        self.net_g = self.net_g.to(self.config.device)
-        if self.config.is_half:
-            self.net_g = self.net_g.half()
-        else:
-            self.net_g = self.net_g.float()
-
-        self.vc = VC(self.tgt_sr, self.config, use_transformers)
-        print(_i18n("checkpoint_loaded")+": "+Path(model_path).name)
-
-    @hf_spaces_gpu
-    def convert_audio(
-        self,
-        audio_input: str | Path | list[str | Path],
-        output_dir: str | Path,
-        model_path: str,
-        index_path: str,
-        pitch: int = 0,
-        f0_method: str = "rmvpe+",
-        index_rate: float = 0.75,
-        volume_envelope: float = 0.25,
-        protect: float = 0.33,
-        hop_length: int = 128,
-        embedder_model: str = "hubert_base",
-        use_transformers: bool = False,
-        output_format: str = output_formats[0],
-        stereo_mode: str = stereo_modes[0],
-        f0_min: int = 50,
-        f0_max: int = 1100,
-        chunk_duration: int = 7,
-        template: str = "NAME_F0METHOD_PITCH",
-        **kwargs,
-    ):
-        template = Namer.sanitize(template)
-        template = Namer.dedup_template(template, keys=["NAME", "F0METHOD", "PITCH"])
-        template = Namer.short(template, length=40)
-
-        if not model_path:
-            raise VbachModelNotFound()
-    
-        self.get_vc(model_path, use_transformers)
-    
-        if not self.hubert_model:
-            self.load_hubert(embedder_model, use_transformers)
-
-        if not output_dir:
-            output_dir = ""
-
-        output_dir = Path(output_dir)
-
-        input_valid_files = get_audio_files_from_list(audio_input, only_files=False)
-        if not input_valid_files:
-            raise PathsNotSpecified(_i18n("paths_not_specified"))
-
-        total = len(input_valid_files)
-
-        print(_i18n("f0_method")+": "+f0_method)
-
-        processed_audios = []
-
-        for i, audio_input_path in enumerate(input_valid_files, start=1):
-            try:
-                input_file_name = Path(audio_input_path).stem
-                mixtures, add_text = load_audio(audio_input_path, 16000, stereo_mode)
-                print(_i18n("loaded_mix")+": "+input_file_name)
-                converted_mixtures = []
-
-                for mix, add_text_progress in zip(mixtures, add_text):
-                    audio_max = np.abs(mix).max() / 0.95
-                    if audio_max > 1:
-                        mix /= audio_max
-                    audio_opt = self.vc.pipeline(
-                        model=self.hubert_model,
-                        net_g=self.net_g,
-                        sid=0,
-                        audio=mix,
-                        pitch=pitch,
-                        f0_method=f0_method,
-                        hop_length=hop_length,
-                        file_index=index_path,
-                        index_rate=index_rate,
-                        pitch_guidance=self.use_f0,
-                        volume_envelope=volume_envelope,
-                        version=self.version,
-                        protect=protect,
-                        tgt_sr=self.tgt_sr,
-                        f0_min=f0_min,
-                        f0_max=f0_max,
-                        chunk_duration=chunk_duration,
-                        add_text_channel=add_text_progress,
-                        add_text_custom=f"{i}/{total} {_i18n('files')}",
-                    )
-                    converted_mixtures.append(audio_opt)
-                custom_name = Namer.template(
-                    template,
-                    PITCH=pitch,
-                    F0METHOD=f0_method,
-                    NAME=Namer.short_input_name_template(template, PITCH=pitch, F0METHOD=f0_method, NAME=input_file_name)
-                )
-                processed_audios.append(write(Namer.iter(output_dir / f"{custom_name}.{output_format}"), post_process_audio(converted_mixtures, self.tgt_sr, stereo_mode), self.tgt_sr))
-            except Exception as e:
-                traceback.print_exc()
-
-        self.unload_model()
-        self.unload_hubert()
-
-        return processed_audios
-
-    @hf_spaces_gpu
-    def convert_audio_custom_f0(
-        self,
-        audio_input: str | Path,
-        output_dir: str | Path,
-        model_path: str,
-        index_path: str,
-        pitch: int = 0,
-        f0_file: str | Path = None,
-        index_rate: float = 0.75,
-        volume_envelope: float = 0.25,
-        protect: float = 0.33,
-        embedder_model: str = "hubert_base",
-        use_transformers: bool = False,
-        output_format: str = output_formats[0],
-        f0_min: int = 50,
-        f0_max: int = 1100,
-        chunk_duration: int = 7,
-        template: str = "NAME_F0METHOD_PITCH",
-        **kwargs,
-    ):
-        template = Namer.sanitize(template)
-        template = Namer.dedup_template(template, keys=["NAME", "F0METHOD", "PITCH"])
-        template = Namer.short(template, length=40)
-
-        if not model_path:
-            raise VbachModelNotFound()
-    
-        self.get_vc(model_path, use_transformers)
-    
-        if not self.hubert_model:
-            self.load_hubert(embedder_model, use_transformers)
-
-        if not output_dir:
-            output_dir = ""
-
-        output_dir = Path(output_dir)
-        output_path = None
-
-        print(_i18n("f0_method")+": "+"custom")
-
-        try:
-            if not audio_input:
-                raise PathNotSpecified(_i18n("path_not_specified"))
-            audio_input = Path(audio_input)
-            if not audio_input.exists():
-                raise PathNotExist(_i18n("path_not_exist"))
-            if check(audio_input):
-                input_file_name = Path(audio_input).stem
-                mix, sr = read(audio_input, sr=16000, mono=True, flatten=True)
-                print(_i18n("loaded_mix")+": "+input_file_name)
-            else:
-                raise FileIsNotAudio(_i18n("file_is_not_audio", path=audio_input))
-
-            audio_max = np.abs(mix).max() / 0.95
-            if audio_max > 1:
-                mix /= audio_max
-            audio_opt = self.vc.pipeline_custom_f0(
-                model=self.hubert_model,
-                net_g=self.net_g,
-                sid=0,
-                audio=mix,
-                pitch=pitch,
-                f0_file=f0_file,
-                file_index=index_path,
-                index_rate=index_rate,
-                pitch_guidance=self.use_f0,
-                volume_envelope=volume_envelope,
-                version=self.version,
-                protect=protect,
-                tgt_sr=self.tgt_sr,
-                f0_min=f0_min,
-                f0_max=f0_max,
-                chunk_duration=chunk_duration,
-                add_text_channel="",
-                add_text_custom=f"{_i18n('custom_f0')}",
-            )
-            custom_name = Namer.template(
-                template,
-                PITCH=pitch,
-                F0METHOD="custom",
-                NAME=Namer.short_input_name_template(template, PITCH=pitch, F0METHOD="custom", NAME=input_file_name)
-            )
-            output_path = write(Namer.iter(output_dir / f"{custom_name}.{output_format}"), audio_opt, self.tgt_sr)
-        except Exception as e:
-            traceback.print_exc()
-
-        self.unload_model()
-        self.unload_hubert()
-
-        return output_path
-    
-if __name__ == "__main__":
-    vbach = VbachConverter()
-    args = parse_vbach_args()
-    if args.mode == "infer":
-        download_hubert(args.embedder, args.use_transformers)
-        vbach.convert_audio(
-            audio_input=args.input,
-            output_dir=args.output_dir,
-            model_path=args.checkpoint_path,
-            index_path=args.index_path,
-            pitch=args.pitch,
-            f0_method=args.f0_method,
-            index_rate=args.index_rate,
-            volume_envelope=args.volume_envelope,
-            protect=args.protect,
-            hop_length=args.hop_length,
-            embedder_model=args.embedder,
-            use_transformers=args.use_transformers,
-            output_format=args.output_format,
-            stereo_mode=args.stereo_mode,
-            f0_min=args.f0_min,
-            f0_max=args.f0_max,
-            chunk_duration=args.chunk_duration,
-            template=args.template
-        )
-    elif args.mode == "infer_custom_f0":
-        download_hubert(args.embedder, args.use_transformers)
-        vbach.convert_audio_custom_f0(
-            audio_input=args.input,
-            output_dir=args.output_dir,
-            model_path=args.checkpoint_path,
-            index_path=args.index_path,
-            pitch=args.pitch,
-            f0_file=args.f0_file,
-            index_rate=args.index_rate,
-            volume_envelope=args.volume_envelope,
-            protect=args.protect,
-            embedder_model=args.embedder,
-            use_transformers=args.use_transformers,
-            output_format=args.output_format,
-            stereo_mode=args.stereo_mode,
-            f0_min=args.f0_min,
-            f0_max=args.f0_max,
-            chunk_duration=args.chunk_duration,
-            template=args.template
-        )
-    elif args.mode == "download_hubert":
+from pathlib import Path
+import sys
+SCRIPT_DIR = Path(__file__).resolve().parent
+sys.path.append(str(SCRIPT_DIR.parent))
+from extra_utils import hf_spaces_gpu, extra_clear_torch_cache, nuclear_clear_model, emergency_ram_clear
+if __package__:
+    from .hubert_manager import get_hubert, download_hubert, huberts_fairseq
+    from .pipeline import VC
+    from .config import Config
+    from .fairseq import load_model
+    from .algorithm.synthesizers import Synthesizer
+else:
+    from vbach_lib.hubert_manager import get_hubert, download_hubert, huberts_fairseq
+    from vbach_lib.pipeline import VC
+    from vbach_lib.config import Config
+    from vbach_lib.fairseq import load_model
+    from vbach_lib.algorithm.synthesizers import Synthesizer
+from transformers import HubertModel
+from pathlib import Path
+import traceback
+from audio import read, write, split_channels, split_mid_side, multi_channel_array_from_arrays, output_formats, stereo_to_mono, reshape, mix_arrays, get_audio_files_from_list, check
+from inference import PathsNotSpecified, PathNotExist, PathNotSpecified, FileIsNotAudio
+from i18n import _i18n
+from namer import Namer
+from args_parser import parse_vbach_args
+import numpy as np
+import torch
+from torch import nn
+import gc
+
+class VbachModelNotFound(Exception): pass
+
+stereo_modes = ("mono", "left/right", "sim/dif")
+
+class HubertModelWithFinalProj(HubertModel):
+    """Hubert модель с финальной проекцией"""
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.final_proj = nn.Linear(config.hidden_size, config.classifier_proj_size)
+
+def load_audio(path: str | Path, sr: int, stereo_mode: str = stereo_modes[0]):
+    mixtures = []
+    add_text = []
+    if stereo_mode == "mono":
+        mix, _sr = read(path, sr, mono=True, flatten=True)
+        mixtures.append(mix)
+        add_text.append(None)
+    elif stereo_mode == "left/right":
+        mix, _sr = read(path, sr, mono=False)
+        mixtures.extend(split_channels(mix))
+        add_text.extend(["[L]", "[R]"])
+    elif stereo_mode == "sim/dif":
+        mix, _sr = read(path, sr, mono=False)
+        center, stereo_base = split_mid_side(mix, var=3, sr=sr)
+        phantom_center = stereo_to_mono(center, to_flatten=True)
+        stereo_base_left, stereo_base_right = split_channels(stereo_base)
+        mixtures.extend([phantom_center, stereo_base_left, stereo_base_right])
+        add_text.extend(["[Sim]", "[Dif-L]", "[Dif-R]"])
+    return mixtures, add_text
+
+def post_process_audio(mixtures: list[np.ndarray], target_sr: int, stereo_mode: str = stereo_modes[0]):
+    if stereo_mode == "mono":
+        return reshape(mixtures[0], ("channels", "samples"))
+    elif stereo_mode == "left/right":
+        dtype = mixtures[0].dtype
+        return multi_channel_array_from_arrays(*mixtures, index=1, dtype=dtype)
+    elif stereo_mode == "sim/dif":
+        sim, dif_l, dif_r = mixtures
+        dtype = sim.dtype
+        sim_channel = multi_channel_array_from_arrays(sim, sim, index=1, dtype=dtype)
+        dif_channel = multi_channel_array_from_arrays(dif_l, dif_r, index=1, dtype=dtype)
+        return mix_arrays([sim_channel, dif_channel], [target_sr, target_sr], target_sr, index=1, dtype=dtype)[0]
+
+class VbachConverter:
+    def __init__(self):
+        self.config = Config()
+        self.hubert_model = None 
+        self.cpt = self.version = self.net_g = self.tgt_sr = self.vc = self.use_f0 = self.vocoder = self.emb_weight_shape = self.required_keys = self.missing_keys = self.text_enc_hidden_dim = None
+    def load_hubert(self, name: str, use_transformers: bool):
+        if use_transformers:
+            model_path = get_hubert(name, True)
+            self.hubert_model = HubertModelWithFinalProj.from_pretrained(model_path)
+            self.hubert_model = self.hubert_model.to(self.config.device)
+        else:
+            model_path = get_hubert(name, False)
+            self.hubert_model = load_model(model_path)
+            self.hubert_model = self.hubert_model.to(self.config.device)
+            self.hubert_model = self.hubert_model.half() if self.config.is_half else self.hubert_model.float()
+            self.hubert_model.eval()
+        print(_i18n("hubert_checkpoint_loaded")+": "+name)
+
+    def unload_hubert(self):
+        self.hubert_model = self.hubert_model.cpu()
+        self.hubert_model = None
+        gc.collect()
+        extra_clear_torch_cache()
+        nuclear_clear_model()
+        emergency_ram_clear()
+
+    def unload_model(self):
+        self.net_g = self.net_g.cpu()
+        del self.cpt, self.version, self.net_g, self.tgt_sr, self.vc, self.use_f0, self.vocoder, self.emb_weight_shape, self.required_keys, self.missing_keys, self.text_enc_hidden_dim
+        self.cpt = self.version = self.net_g = self.tgt_sr = self.vc = self.use_f0 = self.vocoder = self.emb_weight_shape = self.required_keys = self.missing_keys = self.text_enc_hidden_dim = None
+        extra_clear_torch_cache()
+        nuclear_clear_model()
+        emergency_ram_clear()
+
+    def clear_gpu_cache(self):
+        gc.collect()
+        torch.clear_autocast_cache()
+        if self.config.device.type == "mps":
+            torch.mps.empty_cache()
+        if self.config.device.type == "cuda":
+            torch.cuda.synchronize()
+            torch.cuda.ipc_collect()
+            torch.cuda.empty_cache()
+
+    def get_vc(self, model_path: str | Path, use_transformers: bool):
+        self.cpt = torch.load(model_path, map_location="cpu", weights_only=True)
+        self.required_keys = ["config", "weight"]
+        self.missing_keys = [key for key in self.required_keys if key not in self.cpt]
+
+        self.tgt_sr = self.cpt["config"][-1]
+
+        self.emb_weight_shape = self.cpt["weight"]["emb_g.weight"].shape
+        self.cpt["config"][-3] = self.emb_weight_shape[0]
+
+        self.use_f0 = self.cpt.get("f0", 1)
+        self.version = self.cpt.get("version", "v1")
+        self.vocoder = self.cpt.get("vocoder", "HiFi-GAN")
+
+        self.text_enc_hidden_dim = 768 if self.version == "v2" else 256
+
+        self.net_g = Synthesizer(
+            *self.cpt["config"],
+            use_f0=self.use_f0,
+            text_enc_hidden_dim=self.text_enc_hidden_dim,
+            vocoder=self.vocoder,
+        )
+
+        if hasattr(self.net_g, "enc_q"):
+            del self.net_g.enc_q
+        else:
+            pass
+
+        self.net_g.load_state_dict(
+            self.cpt["weight"], strict=False
+        )
+        self.net_g.eval()
+
+        self.net_g = self.net_g.to(self.config.device)
+        if self.config.is_half:
+            self.net_g = self.net_g.half()
+        else:
+            self.net_g = self.net_g.float()
+
+        self.vc = VC(self.tgt_sr, self.config, use_transformers)
+        print(_i18n("checkpoint_loaded")+": "+Path(model_path).name)
+
+    @hf_spaces_gpu # (duration=120) Для спейса LongQuota / длинная квота на HuggingFace ZeroGPU (по умолчанию 60 секунд)
+    def convert_audio(
+        self,
+        audio_input: str | Path | list[str | Path],
+        output_dir: str | Path,
+        model_path: str,
+        index_path: str,
+        pitch: int = 0,
+        f0_method: str = "rmvpe+",
+        index_rate: float = 0.75,
+        volume_envelope: float = 0.25,
+        protect: float = 0.33,
+        hop_length: int = 128,
+        embedder_model: str = "hubert_base",
+        use_transformers: bool = False,
+        output_format: str = output_formats[0],
+        stereo_mode: str = stereo_modes[0],
+        f0_min: int = 50,
+        f0_max: int = 1100,
+        chunk_duration: int = 7,
+        template: str = "NAME_F0METHOD_PITCH",
+        **kwargs,
+    ):
+        template = Namer.sanitize(template)
+        template = Namer.dedup_template(template, keys=["NAME", "F0METHOD", "PITCH"])
+        template = Namer.short(template, length=40)
+
+        if not model_path:
+            raise VbachModelNotFound()
+    
+        self.get_vc(model_path, use_transformers)
+    
+        if not self.hubert_model:
+            self.load_hubert(embedder_model, use_transformers)
+
+        if not output_dir:
+            output_dir = ""
+
+        output_dir = Path(output_dir)
+
+        input_valid_files = get_audio_files_from_list(audio_input, only_files=False)
+        if not input_valid_files:
+            raise PathsNotSpecified(_i18n("paths_not_specified"))
+
+        total = len(input_valid_files)
+
+        print(_i18n("f0_method")+": "+f0_method)
+
+        processed_audios = []
+
+        for i, audio_input_path in enumerate(input_valid_files, start=1):
+            try:
+                input_file_name = Path(audio_input_path).stem
+
+                mixtures, add_text = load_audio(audio_input_path, 16000, stereo_mode)
+                print(_i18n("loaded_mix")+": "+Path(audio_input_path).name)
+                converted_mixtures = []
+
+                for mix, add_text_progress in zip(mixtures, add_text):
+                    audio_max = np.abs(mix).max() / 0.95
+                    if audio_max > 1:
+                        mix /= audio_max
+                    audio_opt = self.vc.pipeline(
+                        model=self.hubert_model,
+                        net_g=self.net_g,
+                        sid=0,
+                        audio=mix,
+                        pitch=pitch,
+                        f0_method=f0_method,
+                        hop_length=hop_length,
+                        file_index=index_path,
+                        index_rate=index_rate,
+                        pitch_guidance=self.use_f0,
+                        volume_envelope=volume_envelope,
+                        version=self.version,
+                        protect=protect,
+                        tgt_sr=self.tgt_sr,
+                        f0_min=f0_min,
+                        f0_max=f0_max,
+                        chunk_duration=chunk_duration,
+                        add_text_channel=add_text_progress,
+                        add_text_custom=f"{i}/{total} {_i18n('files')}",
+                    )
+                    converted_mixtures.append(audio_opt)
+                custom_name = Namer.template(
+                    template,
+                    PITCH=pitch,
+                    F0METHOD=f0_method,
+                    NAME=Namer.short_input_name_template(template, PITCH=pitch, F0METHOD=f0_method, NAME=input_file_name)
+                )
+                processed_audios.append(write(Namer.iter(output_dir / f"{custom_name}.{output_format}"), post_process_audio(converted_mixtures, self.tgt_sr, stereo_mode), self.tgt_sr))
+            except Exception as e:
+                traceback.print_exc()
+
+        self.unload_model()
+        self.unload_hubert()
+
+        return processed_audios
+
+    @hf_spaces_gpu # (duration=120) Для спейса LongQuota / длинная квота на HuggingFace ZeroGPU (по умолчанию 60 секунд)
+    def convert_audio_custom_f0(
+        self,
+        audio_input: str | Path,
+        output_dir: str | Path,
+        model_path: str,
+        index_path: str,
+        pitch: int = 0,
+        f0_file: str | Path = None,
+        index_rate: float = 0.75,
+        volume_envelope: float = 0.25,
+        protect: float = 0.33,
+        embedder_model: str = "hubert_base",
+        use_transformers: bool = False,
+        output_format: str = output_formats[0],
+        f0_min: int = 50,
+        f0_max: int = 1100,
+        chunk_duration: int = 7,
+        template: str = "NAME_F0METHOD_PITCH",
+        **kwargs,
+    ):
+        template = Namer.sanitize(template)
+        template = Namer.dedup_template(template, keys=["NAME", "F0METHOD", "PITCH"])
+        template = Namer.short(template, length=40)
+
+        if not model_path:
+            raise VbachModelNotFound()
+    
+        self.get_vc(model_path, use_transformers)
+    
+        if not self.hubert_model:
+            self.load_hubert(embedder_model, use_transformers)
+
+        if not output_dir:
+            output_dir = ""
+
+        output_dir = Path(output_dir)
+        output_path = None
+
+        print(_i18n("f0_method")+": "+"custom")
+
+        try:
+            if not audio_input:
+                raise PathNotSpecified(_i18n("path_not_specified"))
+            audio_input = Path(audio_input)
+            if not audio_input.exists():
+                raise PathNotExist(_i18n("path_not_exist"))
+            if check(audio_input):
+                input_file_name = Path(audio_input).stem
+                mix, sr = read(audio_input, sr=16000, mono=True, flatten=True)
+                print(_i18n("loaded_mix")+": "+Path(audio_input).name)
+            else:
+                raise FileIsNotAudio(_i18n("file_is_not_audio", path=audio_input))
+
+            audio_max = np.abs(mix).max() / 0.95
+            if audio_max > 1:
+                mix /= audio_max
+            audio_opt = self.vc.pipeline_custom_f0(
+                model=self.hubert_model,
+                net_g=self.net_g,
+                sid=0,
+                audio=mix,
+                pitch=pitch,
+                f0_file=f0_file,
+                file_index=index_path,
+                index_rate=index_rate,
+                pitch_guidance=self.use_f0,
+                volume_envelope=volume_envelope,
+                version=self.version,
+                protect=protect,
+                tgt_sr=self.tgt_sr,
+                f0_min=f0_min,
+                f0_max=f0_max,
+                chunk_duration=chunk_duration,
+                add_text_channel="",
+                add_text_custom=f"{_i18n('custom_f0')}",
+            )
+            custom_name = Namer.template(
+                template,
+                PITCH=pitch,
+                F0METHOD="custom",
+                NAME=Namer.short_input_name_template(template, PITCH=pitch, F0METHOD="custom", NAME=input_file_name)
+            )
+            output_path = write(Namer.iter(output_dir / f"{custom_name}.{output_format}"), audio_opt, self.tgt_sr)
+        except Exception as e:
+            traceback.print_exc()
+
+        self.unload_model()
+        self.unload_hubert()
+
+        return output_path
+    
+if __name__ == "__main__":
+    vbach = VbachConverter()
+    args = parse_vbach_args()
+    if args.mode == "infer":
+        download_hubert(args.embedder, args.use_transformers)
+        vbach.convert_audio(
+            audio_input=args.input,
+            output_dir=args.output_dir,
+            model_path=args.checkpoint_path,
+            index_path=args.index_path,
+            pitch=args.pitch,
+            f0_method=args.f0_method,
+            index_rate=args.index_rate,
+            volume_envelope=args.volume_envelope,
+            protect=args.protect,
+            hop_length=args.hop_length,
+            embedder_model=args.embedder,
+            use_transformers=args.use_transformers,
+            output_format=args.output_format,
+            stereo_mode=args.stereo_mode,
+            f0_min=args.f0_min,
+            f0_max=args.f0_max,
+            chunk_duration=args.chunk_duration,
+            template=args.template
+        )
+    elif args.mode == "infer_custom_f0":
+        download_hubert(args.embedder, args.use_transformers)
+        vbach.convert_audio_custom_f0(
+            audio_input=args.input,
+            output_dir=args.output_dir,
+            model_path=args.checkpoint_path,
+            index_path=args.index_path,
+            pitch=args.pitch,
+            f0_file=args.f0_file,
+            index_rate=args.index_rate,
+            volume_envelope=args.volume_envelope,
+            protect=args.protect,
+            embedder_model=args.embedder,
+            use_transformers=args.use_transformers,
+            output_format=args.output_format,
+            stereo_mode=args.stereo_mode,
+            f0_min=args.f0_min,
+            f0_max=args.f0_max,
+            chunk_duration=args.chunk_duration,
+            template=args.template
+        )
+    elif args.mode == "download_hubert":
         download_hubert(args.embedder, args.use_transformers)