init

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

MANIFEST.in

@@ -0,0 +1,3 @@
+include requirements.txt
+recursive-include tts_colab/static *
+recursive-include tts_colab/templates *

pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tts_colab"
+version = "0.1.5"
+dependencies = [
+    "pydub==0.25.1",
+    "soundfile==0.13.1",
+    "f5-tts==1.1.7",
+    "ruaccent==1.5.8.3",
+    "numpy<=1.26.4",
+    "huggingface_hub",
+    "requests",
+    "flask",
+    "waitress",
+    "onnx_asr"
+]
+
+[tool.setuptools]
+package-dir = {"" = "."}
+packages = ["tts_colab"]
+
+[tool.setuptools.package-data]
+"tts_colab" = ["static/css/*", "static/js/*", "static/generated/*", "templates/*"]

requirements.txt

@@ -0,0 +1,11 @@
+pydub==0.25.1
+soundfile==0.13.1
+f5-tts==1.1.7
+ruaccent==1.5.8.3
+numpy<=1.26.4
+onnx_asr
+huggingface_hub
+requests
+flask
+waitress
+

setup.py

@@ -0,0 +1,45 @@
+from setuptools import setup, find_packages
+
+def parse_requirements():
+    requirements = []
+    with open('requirements.txt', 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#') or line.startswith('-'):
+                continue
+
+            requirements.append(line)
+    return requirements
+
+
+setup(
+    name="tts_colab",
+    version="0.1.5",
+    packages=find_packages(),
+    include_package_data=True,
+    package_data={
+        'tts_colab': [
+            'static/css/*.css',
+            'static/js/*.js',
+            'static/generated/*',
+            'templates/*.html'
+        ],
+    },
+    install_requires=parse_requirements(),
+    entry_points={
+        'console_scripts': [
+            'tts-colab=tts_colab.tts:main',
+        ],
+    },
+    author="prolapse",
+    author_email="[email protected]",
+    description="Text-to-Speech web application for Colab",
+    keywords="tts colab text-to-speech",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+)

tts_colab/__init__.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from random import randint
+from os import environ
+
+
+tmp = Path(__file__).parent / 'tmp'
+tmp.mkdir(exist_ok=True)
+(tmp / 'transformers').mkdir(exist_ok=True)
+(tmp / 'hub').mkdir(exist_ok=True)
+
+environ['appdata'] = tmp.resolve().as_posix()
+environ['userprofile'] = tmp.resolve().as_posix()
+environ['temp'] = tmp.resolve().as_posix()
+environ['PYTHONWARNINGS'] = 'ignore::FutureWarning'
+
+environ['HF_HOME'] = tmp.resolve().as_posix()
+environ['TRANSFORMERS_CACHE'] = (tmp / 'transformers').resolve().as_posix()
+environ['HUGGINGFACE_HUB_CACHE'] = (tmp / 'hub').resolve().as_posix()
+
+
+if 'MPLBACKEND' in environ:
+    del environ['MPLBACKEND']
+
+from waitress import serve
+from tts_colab.share import try_all
+from tts_colab.tts import app
+
+
+def start(port: int = randint(7860, 8999)):
+    try:
+        from IPython.display import clear_output
+
+        clear_output()
+    except:
+        pass
+
+    print(f'ссылки на WebUI:\n{try_all(port)}')
+
+    serve(app, host='0.0.0.0', port=port)
+
+
+

tts_colab/__main__.py

@@ -0,0 +1,4 @@
+from tts_colab import *
+
+if __name__ == '__main__':
+    start()

tts_colab/share.py

@@ -0,0 +1,355 @@
+from atexit import register as exit_register
+from os import close, read, name as os_name
+from pathlib import Path
+from pty import openpty
+from re import compile, search
+from shutil import move
+from subprocess import PIPE, Popen, STDOUT, check_output, CalledProcessError
+from sys import stdout
+from time import sleep, time
+from urllib.parse import unquote, urlparse
+
+from requests import get as get_url, head as get_head
+from requests.structures import CaseInsensitiveDict
+
+WORK_FOLDER = Path('/content')
+
+claudflare_bin = WORK_FOLDER / 'claudflared'
+gradio_bin = WORK_FOLDER / 'frpc_linux_amd64'
+links_file = WORK_FOLDER / 'links.txt'
+
+
+
+def determine_archive_format(filepath: str | Path) -> str | None:
+    filepath = Path(filepath)
+    zip_signature = bytes([0x50, 0x4B, 0x03, 0x04])
+    seven_z_signature = bytes([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
+    lzma_xz_signature = bytes([0xFD, 0x37, 0x7A, 0x58, 0x5A])
+    tgz_signature = bytes([0x1F, 0x8B])
+    tbz_signature = bytes([0x42, 0x5A, 0x68])
+    ustar_signature = bytes([0x75, 0x73, 0x74, 0x61, 0x72])
+    with filepath.open('rb') as file:
+        header = file.read(262)
+    if header.startswith(zip_signature):
+        return 'zip'
+    elif header.startswith(seven_z_signature) or header.startswith(lzma_xz_signature):
+        return '7z'
+    elif header.startswith(tgz_signature):
+        return 'tar.gz'
+    elif header.startswith(tbz_signature):
+        return 'tar.bz2'
+    elif header[0x101:0x101 + len(ustar_signature)] == ustar_signature:
+        return 'tar'
+    return None
+
+
+def unpack_archive(archive_path: str | Path, dest_path: str | Path, rm_archive: bool = True):
+    if str(archive_path).startswith(('https://', 'http://')):
+        archive_path = download(archive_path, save_path=WORK_FOLDER, progress=False)
+    if not Path(archive_path).exists():
+        raise RuntimeError(f'архив {archive_path} не найден.')
+    archive_path = Path(archive_path)
+    dest_path = Path(dest_path)
+
+    if not archive_path.exists():
+        raise RuntimeError(f'архив {archive_path} не найден.')
+
+    determine_format = determine_archive_format(archive_path)
+
+    try:
+        if determine_format == '7z' or archive_path.suffix == '.7z':
+            run(f'7z -bso0 -bd -slp -y x {str(archive_path)} -o{str(dest_path)}')
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+        elif determine_format == 'tar' or archive_path.suffix in ['.tar']:
+            run(f'tar -xvpf {str(archive_path)} -C {str(dest_path)}')
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+        elif determine_format == 'tar.gz' or archive_path.suffix in ['.tar.gz', '.tar.bz2', '.tar.xz']:
+            result = run(f'tar -xvzpf {str(archive_path)} -C {str(dest_path)}')
+            if result['status_code'] != 0:
+                run(f'gzip -d {str(archive_path)}', dest_path)
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+        elif determine_format == 'zip' or archive_path.suffix == '.zip':
+            run(f'unzip {str(archive_path)} -d {str(dest_path)}')
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+        else:
+            run(f'7z -bso0 -bd -slp -y x {str(archive_path)} -o{str(dest_path)}')
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+    except:
+        try:
+            run(f'7z -bso0 -bd -mmt4 -slp -y x {str(archive_path)} -o{str(dest_path)}')
+            archive_path.unlink(missing_ok=True) if rm_archive else None
+        except:
+            raise RuntimeError(
+                f'формат архива {archive_path.suffix} не определен, нужно задать формат в "determine_format".')
+
+
+def run(command: str, cwd: str | Path | None = None, live_output: bool = False) -> dict:
+    process = Popen(command, shell=True, cwd=cwd, stdout=PIPE, stderr=STDOUT)
+    encodings = ['iso-8859-5', 'windows-1251', 'iso-8859-1', 'cp866', 'koi8-r', 'mac_cyrillic']
+    is_progress_bar_pattern = r'\d+%|\d+/\d+'
+
+    def decode_output(output_data):
+        for encoding in encodings:
+            try:
+                return output_data.decode(encoding)
+            except UnicodeDecodeError:
+                continue
+        return output_data.decode('utf-8', errors='replace')
+
+    final_output = []
+    last_progress_bar = ''
+
+    def process_output():
+        nonlocal last_progress_bar
+        for line in iter(process.stdout.readline, b''):
+            try:
+                line_decoded = line.decode('utf-8').strip()
+            except UnicodeDecodeError:
+                line_decoded = decode_output(line.strip())
+
+            if search(is_progress_bar_pattern, line_decoded):
+                last_progress_bar = line_decoded
+                if live_output:
+                    stdout.write('\r' + line_decoded)
+            else:
+                final_output.append(line_decoded)
+                if live_output:
+                    stdout.write('\n' + line_decoded)
+
+            if live_output: stdout.flush()
+
+    process_output()
+    process.wait()
+    if last_progress_bar:
+        final_output.append(last_progress_bar)
+    return {
+        'status_code': process.returncode,
+        'output': '\n'.join(final_output)
+    }
+
+
+def is_valid_url(url: str) -> bool:
+    headers = None
+    for attempt in range(2):
+        try:
+            with get_url(url, headers=headers, allow_redirects=True, stream=True) as response:
+                if 200 <= response.status_code < 300:
+                    return True
+        except:
+            try:
+                response = get_head(url, headers=headers, allow_redirects=True)
+                if 200 <= response.status_code < 300:
+                    return True
+            except:
+                pass
+        else:
+            break
+    return False
+
+
+def get_filename_from_headers(requests_headers: CaseInsensitiveDict) -> str | None:
+    content_disposition = requests_headers.get('content-disposition')
+    if not content_disposition:
+        return requests_headers.get('filename')
+    parts = content_disposition.split(';')
+    filename = None
+    for part in parts:
+        part = part.strip()
+        if part.startswith('filename*='):
+            encoding, _, encoded_filename = part[len('filename*='):].partition("''")
+            filename = unquote(encoded_filename, encoding=encoding)
+            break
+        elif part.startswith('filename='):
+            filename = part[len('filename='):].strip('"')
+            break
+    return filename
+
+
+def download(url: str, filename: str | Path | None = None, save_path: str | Path | None = None,
+             progress: bool = True) -> Path | None:
+    headers = None
+    url_with_header = url.replace('"', '').replace("'", '').split('--header=')
+    if len(url_with_header) > 1:
+        url = (url_with_header[0]).strip()
+        header = url_with_header[1]
+        headers = {
+            header.split(':')[0].strip(): header.split(':')[1].strip()
+        }
+    if is_valid_url(url):
+        save_path = Path(save_path) if save_path else Path.cwd()
+        save_path.mkdir(parents=True, exist_ok=True)
+
+        with get_url(url, stream=True, allow_redirects=True, headers=headers) as request:
+            file_size = int(request.headers.get('content-length', 0))
+            file_name = filename or get_filename_from_headers(request.headers) or Path(urlparse(request.url).path).name
+            file_path = save_path / file_name
+
+            chunk_size = max(4096, file_size // 2000)
+            downloaded_size = 0
+            try:
+                with open(file_path, 'wb') as fp:
+                    start = time()
+                    for chunk in request.iter_content(chunk_size=chunk_size):
+                        if chunk:
+                            fp.write(chunk)
+                            if progress:
+                                downloaded_size += len(chunk)
+                                percent_completed = downloaded_size / file_size * 100
+                                elapsed_time = time() - start
+                                print(f'\rзагрузка {file_name}: {percent_completed:.2f}% | {elapsed_time:.2f} сек.',
+                                      end='')
+            except Exception as e:
+                raise RuntimeError(f'не удалось загрузить файл по ссылке {url}:\n{e}')
+            return file_path
+    else:
+        raise RuntimeError(f'недействительная ссылка на файл: {url}')
+
+
+def is_process_running(process_name: str | Path) -> bool:
+    try:
+        output = check_output(['pgrep', '-f', str(process_name)], text=True)
+        return len(output.strip().split('\n')) > 0
+    except CalledProcessError:
+        return False
+
+
+def move_path(old_path: Path | str, new_path: Path | str):
+    old, new = Path(old_path), Path(new_path)
+    if old_path.exists():
+        try:
+            old_path.replace(new)
+        except:
+            try:
+                move(old, new)
+            except:
+                if os_name == 'posix':
+                    run(f'mv "{old}" "{new}"')
+                else:
+                    run(f'move "{old}" "{new}"')
+    else:
+        raise RuntimeError(f'не найден исходный путь для перемещения: {old}')
+
+
+def terminate_process(process_name: str, process_obj: Popen):
+    process_obj.stdout.close()
+    process_obj.stderr.close()
+    process_obj.terminate()
+    run(f'pkill -f {process_name}')
+
+
+def is_ipv4(address: str) -> bool:
+    ipv4_pattern = compile(r'^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$')
+    if ipv4_pattern.match(address):
+        return True
+    else:
+        return False
+
+
+def get_revproxy_url(bin_url: str, need_unpack: bool, bin_path: Path, start_commands: list, read_from_stderr: bool,
+                     lines_to_read: int, url_pattern: str = r'https://\S+', write_link: bool = False) -> str:
+    if not bin_path.exists():
+        files_before = {item.name for item in WORK_FOLDER.iterdir() if item.is_file()}
+        if need_unpack:
+            unpack_archive(download(bin_url, progress=False), WORK_FOLDER, rm_archive=True)
+        else:
+            download(bin_url, save_path=bin_path.parent, progress=False)
+        files_after = {item.name for item in WORK_FOLDER.iterdir() if item.is_file()}
+        new_files = files_after - files_before
+        if len(new_files) == 1:
+            unpacked_file = WORK_FOLDER / new_files.pop()
+            move_path(unpacked_file, bin_path)
+        else:
+            unpacked_files = ', '.join(new_files)
+            raise RuntimeError(f'ошибка при определении нового файла после распаковки!\n'
+                               f'ожидалось что за время работы добавится один файл (распакованный бинарник),\n'
+                               f'а добавилсь эти: {unpacked_files}')
+        bin_path.chmod(0o777)
+
+    if is_process_running(bin_path.name):
+        run(f'pkill -f {bin_path.name}')
+
+    process = Popen(start_commands, stdout=PIPE, stderr=PIPE, text=True)
+    lines = []
+    stream = process.stderr if read_from_stderr else process.stdout
+    for _ in range(lines_to_read):
+        line = stream.readline()
+        # print(f'# {line}')
+        if len(lines) == lines_to_read or not line:
+            break
+        lines.append(line.strip())
+
+    ipv4 = next((line for line in lines if is_ipv4(line)), None)
+
+    urls = [search(url_pattern, url).group() for url in lines if search(url_pattern, url)]
+
+    if urls:
+        exit_register(terminate_process, bin_path.name, process)
+        if write_link:
+            links_file.write_text(urls[0])
+        return f'{urls[0]}\n пароль(IP): {ipv4}' if ipv4 else urls[0]
+    else:
+        run(f'pkill -f {bin_path.name}')
+        output = '\n'.join(lines)
+        raise RuntimeError(f'ссылку получить не удалось, вывод работы бинарника:\n{output}')
+
+
+
+
+
+def get_cloudflared_url(port: int) -> str:
+    return get_revproxy_url(
+        bin_url='https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64',
+        need_unpack=False,
+        bin_path=Path(claudflare_bin),
+        start_commands=[f'{claudflare_bin}', 'tunnel', '--url', f'http://127.0.0.1:{port}'],
+        read_from_stderr=True,
+        lines_to_read=6,
+        url_pattern=r'(?P<url>https?://\S+\.trycloudflare\.com)'
+    )
+
+
+def get_gradio_url(port: int) -> str | None:
+    max_attempts = 3
+    for attempt in range(max_attempts):
+        try:
+            response = get_url('https://api.gradio.app/v2/tunnel-request')
+            if response and response.status_code == 200:
+                remote_host, remote_port = response.json()[0]['host'], int(response.json()[0]['port'])
+                com = [f'{gradio_bin}', 'http', '-n', 'random', '-l', f'{port}', '-i', '127.0.0.1', '--uc', '--sd',
+                       'random', '--ue', '--server_addr', f'{remote_host}:{remote_port}', '--disable_log_color']
+                return get_revproxy_url(
+                    bin_url='https://cdn-media.huggingface.co/frpc-gradio-0.1/frpc_linux_amd64',
+                    need_unpack=False,
+                    bin_path=Path(gradio_bin),
+                    start_commands=com,
+                    read_from_stderr=False,
+                    lines_to_read=3,
+                )
+        except Exception as e:
+            if attempt < max_attempts - 1:
+                print(f'попытка {attempt + 1} получить ссылку градио провалилась: {e}. пробуем еще...')
+                sleep(5)
+                return None
+            else:
+                raise RuntimeError(f'после трех попыток поднять туннель градио не удалось: {e}')
+    return None
+
+
+proxies_functions = {
+    'cloudflared': get_cloudflared_url,
+    'gradio': get_gradio_url
+}
+
+
+def try_all(port: int) -> str:
+    results = []
+    for proxy_name, proxy_func in proxies_functions.items():
+        try:
+            url = proxy_func(port)
+            results.append(url)
+        except Exception as e:
+            print(f'{proxy_name}: {e}')
+    return '\n'.join(results)
+
+
+

tts_colab/static/css/style.css

@@ -0,0 +1,112 @@
+:root {
+    --bg-color: #0d1117;
+    --surface-color: rgba(22, 27, 34, 0.7);
+    --border-color: rgba(255, 255, 255, 0.1);
+    --primary-gradient: linear-gradient(90deg, #00c6ff, #0072ff);
+    --primary-color-static: #008cff;
+    --secondary-color: #30363d;
+    --secondary-hover: #484f58;
+    --text-color: #c9d1d9;
+    --text-secondary-color: #8b949e;
+    --success-color: #238636;
+    --error-color: #da3633;
+    --font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: var(--font-family); background-color: var(--bg-color); color: var(--text-color); line-height: 1.6; font-size: 15px; overflow: hidden; }
+::-webkit-scrollbar { width: 8px; } ::-webkit-scrollbar-track { background: var(--bg-color); } ::-webkit-scrollbar-thumb { background: var(--secondary-color); border-radius: 4px; } ::-webkit-scrollbar-thumb:hover { background: var(--secondary-hover); }
+
+.main-layout { display: grid; grid-template-columns: 450px 1fr; height: 100vh; }
+.controls-panel { background-color: var(--bg-color); border-right: 1px solid var(--border-color); padding: 1.5rem 2rem; overflow-y: auto; display: flex; flex-direction: column; }
+.results-panel { padding: 2.5rem; overflow-y: auto; display: flex; flex-direction: column; justify-content: center; align-items: center; }
+
+header { text-align: left; margin-bottom: 2rem; }
+header h1 { font-size: 1.8rem; font-weight: 700; }
+header h1 a { background: var(--primary-gradient); -webkit-background-clip: text; -webkit-text-fill-color: transparent; text-decoration: none; transition: opacity 0.3s; }
+header h1 a:hover { opacity: 0.8; }
+
+.card { background-color: var(--surface-color); border: 1px solid var(--border-color); border-radius: 12px; padding: 1.5rem; margin-bottom: 1rem; backdrop-filter: blur(10px); -webkit-backdrop-filter: blur(10px); }
+.card h3 { margin-bottom: 1.5rem; font-size: 1.2rem; }
+
+.form-group { margin-bottom: 1.25rem; } .form-group:last-child { margin-bottom: 0; } .form-group label { display: block; margin-bottom: 0.5rem; font-weight: 500; }
+
+input, textarea, select { width: 100%; padding: 0.7rem; background-color: #0d1117; border: 1px solid var(--secondary-color); border-radius: 6px; color: var(--text-color); font-family: inherit; font-size: 0.95rem; transition: all 0.2s; }
+input:focus, textarea:focus, select:focus { outline: none; border-color: var(--primary-color-static); box-shadow: 0 0 0 3px rgba(0, 140, 255, 0.3); }
+textarea { resize: vertical; min-height: 80px; }
+
+.info-text { font-size: 0.85rem; color: var(--text-secondary-color); background-color: rgba(0, 140, 255, 0.05); padding: 0.75rem; border-radius: 8px; border-left: 3px solid var(--primary-color-static); margin-top: auto; }
+
+.accordion { padding: 0; } .accordion summary { padding: 0.5rem 0; cursor: pointer; list-style: none; display: flex; justify-content: space-between; align-items: center; }
+.accordion.card summary { padding: 1rem 1.5rem; } .accordion.card[open] { padding-bottom: 1.5rem; }
+.accordion summary h3, .accordion summary label { margin: 0; font-size: 1.2rem; font-weight: 600; }
+.accordion.text-accordion summary label { font-size: 1rem; font-weight: 500; }
+.accordion summary::after { content: '▶'; font-size: 0.8em; transform: rotate(0deg); transition: transform 0.3s; }
+.accordion[open] summary::after { transform: rotate(90deg); }
+.accordion-content { padding-top: 1rem; } .accordion.card .accordion-content { padding: 0 1.5rem; } .accordion.text-accordion .accordion-content { padding-top: 0.5rem; }
+
+.file-drop-area { position: relative; text-align: center; padding: 1.5rem 1rem; border: 2px dashed var(--secondary-color); border-radius: 8px; transition: all 0.3s; }
+.file-drop-area.is-active { border-color: var(--primary-color-static); background-color: rgba(0, 140, 255, 0.1); }
+.file-msg { color: var(--text-secondary-color); font-size: 0.9rem; }
+.file-drop-area input[type="file"] { position: absolute; width: 100%; height: 100%; top: 0; left: 0; opacity: 0; cursor: pointer; }
+.audio-preview { margin-top: 1rem; }
+
+.settings-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; }
+.settings-grid-bottom { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; align-items: end; margin-top: 1rem; }
+.slider-group label { display: flex; justify-content: space-between; font-size: 0.9rem; }
+input[type="range"] { -webkit-appearance: none; width: 100%; height: 4px; background: var(--secondary-color); border-radius: 2px; outline: none; padding: 0; }
+input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; appearance: none; width: 16px; height: 16px; background: var(--primary-color-static); cursor: pointer; border-radius: 50%; border: 2px solid var(--bg-color); transition: background-color 0.2s; }
+
+.checkbox-group { display: flex; align-items: center; gap: 0.5rem; padding-bottom: 0.5rem; }
+.checkbox-group label { margin-bottom: 0; }
+.checkbox-group input { width: auto; }
+.radio-group { display: flex; gap: 1.5rem; background-color: #0d1117; border: 1px solid var(--secondary-color); border-radius: 6px; padding: 0.5rem 0.75rem; }
+.radio-group div { display: flex; align-items: center; gap: 0.5rem; }
+.radio-group label { margin: 0; font-weight: normal; font-size: 0.9rem; }
+.radio-group input[type="radio"] { width: auto; }
+
+.actions { display: flex; gap: 1rem; margin: 1rem 0; }
+button { flex-grow: 1; padding: 0.8rem 1rem; font-size: 1rem; font-weight: 600; border: none; border-radius: 8px; cursor: pointer; transition: all 0.2s ease; }
+.primary-btn { background: var(--primary-gradient); color: white; }
+.primary-btn:hover:not(:disabled) { transform: translateY(-2px); box-shadow: 0 4px 15px rgba(0, 140, 255, 0.3); }
+.accent-btn { background-color: var(--secondary-color); color: var(--text-color); width: 100%; margin-top: 0.75rem; flex-grow: 0; font-size: 0.9rem; padding: 0.6rem; }
+.accent-btn:hover:not(:disabled) { background-color: var(--secondary-hover); }
+button:disabled { opacity: 0.5; cursor: not-allowed; transform: none; box-shadow: none;}
+
+#results-placeholder { text-align: center; color: var(--text-secondary-color); } #results-placeholder h2 { color: var(--text-color); margin-bottom: 0.5rem; }
+#results-container { width: 100%; max-width: 700px; } .result-item { margin-bottom: 2rem; } .result-item h4 { margin-bottom: 0.75rem; color: var(--text-secondary-color); font-weight: 500; }
+#spectrogram-output { width: 100%; border-radius: 8px; border: 1px solid var(--border-color); }
+#status-container { width: 100%; max-width: 700px; margin-top: 1.5rem; padding: 1rem; border-radius: 8px; text-align: center; font-weight: 500; display: none; }
+#status-container.success { background-color: rgba(35, 134, 54, 0.2); color: #3fb950; border: 1px solid var(--success-color); }
+#status-container.error { background-color: rgba(218, 54, 51, 0.2); color: #f85149; border: 1px solid var(--error-color); }
+.hidden { display: none !important; }
+
+#generation-progress { width: 100%; max-width: 700px; }
+.loader-content { background-color: var(--surface-color); padding: 2rem; border-radius: 12px; border: 1px solid var(--border-color); text-align: center; }
+.loader-content h3 { font-size: 1.3rem; margin-bottom: 0.5rem; } .loader-content p { color: var(--text-secondary-color); margin-bottom: 1.5rem; }
+.progress-bar-container { width: 100%; height: 8px; background-color: var(--secondary-color); border-radius: 4px; overflow: hidden; }
+.progress-bar { width: 0%; height: 100%; background: var(--primary-gradient); transition: width 0.3s cubic-bezier(0.4, 0, 0.2, 1); }
+.loader-footer { display: flex; justify-content: space-between; margin-top: 0.75rem; color: var(--text-secondary-color); font-size: 0.9rem; }
+
+.custom-audio-player { background: var(--surface-color); border: 1px solid var(--border-color); border-radius: 8px; padding: 0.75rem 1rem; display: flex; align-items: center; gap: 1rem; backdrop-filter: blur(5px); }
+.play-pause-btn { background: none; border: none; cursor: pointer; padding: 0; width: 32px; height: 32px; display: flex; align-items: center; justify-content: center; flex-shrink: 0; }
+.play-pause-btn svg { width: 24px; height: 24px; fill: var(--text-color); transition: transform 0.2s; }
+.play-pause-btn:hover svg { fill: white; }
+.player-controls { display: flex; align-items: center; gap: 0.75rem; width: 100%; }
+.time-display { font-size: 0.85rem; color: var(--text-secondary-color); font-family: monospace; font-feature-settings: 'tnum'; }
+.progress-bar-wrapper { flex-grow: 1; height: 6px; background-color: var(--secondary-color); border-radius: 3px; cursor: pointer; }
+.progress-bar-fill { width: 0%; height: 100%; background: var(--primary-gradient); border-radius: 3px; transition: width 0.1s linear; }
+.volume-wrapper { position: relative; display: flex; align-items: center; }
+.volume-btn { background: none; border: none; cursor: pointer; padding: 0; width: 24px; height: 24px; display: flex; align-items: center; justify-content: center; }
+.volume-btn svg { width: 20px; height: 20px; fill: var(--text-secondary-color); transition: fill 0.2s; }
+.volume-btn:hover svg { fill: var(--text-color); }
+.volume-slider-wrapper { position: absolute; bottom: 150%; left: 50%; transform: translateX(-50%); background: var(--surface-color); border: 1px solid var(--border-color); border-radius: 6px; padding: 0.75rem 0.5rem; visibility: hidden; opacity: 0; transition: all 0.2s; }
+.volume-wrapper:hover .volume-slider-wrapper { visibility: visible; opacity: 1; }
+.volume-slider { -webkit-appearance: none; appearance: none; width: 8px; height: 100px; background: var(--secondary-color); border-radius: 4px; outline: none; writing-mode: bt-lr; -webkit-appearance: slider-vertical; }
+.volume-slider::-webkit-slider-thumb { -webkit-appearance: none; appearance: none; width: 16px; height: 16px; background: var(--primary-color-static); cursor: pointer; border-radius: 50%; border: 2px solid var(--bg-color); }
+
+.download-btn { background: none; border: none; cursor: pointer; padding: 0; width: 32px; height: 32px; display: flex; align-items: center; justify-content: center; flex-shrink: 0; }
+.download-btn svg { width: 22px; height: 22px; fill: var(--text-secondary-color); transition: all 0.2s; }
+.download-btn:hover svg { fill: var(--primary-color-static); transform: scale(1.1); }
+
+@media (max-width: 1024px) { .main-layout { grid-template-columns: 1fr; } .controls-panel { border-right: none; height: auto; } .results-panel { height: auto; padding: 2rem; } }

tts_colab/static/js/script.js

@@ -0,0 +1,154 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const ttsForm = document.getElementById('tts-form');
+    const generateBtn = document.getElementById('generate-btn');
+    const processTextBtn = document.getElementById('process-text-btn');
+    const generationProgress = document.getElementById('generation-progress');
+    const statusContainer = document.getElementById('status-container');
+    const resultsContainer = document.getElementById('results-container');
+    const resultsPlaceholder = document.getElementById('results-placeholder');
+    const audioOutputContainer = document.getElementById('audio-output-container');
+    const spectrogramOutput = document.getElementById('spectrogram-output');
+    const fileInput = document.getElementById('ref_audio');
+    const fileDropArea = document.querySelector('.file-drop-area');
+    const fileMsg = document.querySelector('.file-msg');
+    const refAudioPreview = document.getElementById('ref-audio-preview');
+    const refTextInput = document.getElementById('ref_text');
+    const genTextInput = document.getElementById('gen_text');
+    const loaderStatusText = document.getElementById('loader-status-text');
+    const timerElement = document.getElementById('timer');
+    const progressBar = document.querySelector('.progress-bar');
+    const progressPercent = document.getElementById('progress-percent');
+    let timerInterval, pollInterval;
+
+    const createCustomPlayer = (audioSrc) => {
+        const playerContainer = document.createElement('div');
+        playerContainer.className = 'custom-audio-player';
+        const audio = new Audio(audioSrc);
+        audio.style.display = 'none';
+
+        playerContainer.innerHTML = `
+            <button type="button" class="play-pause-btn">
+                <svg viewBox="0 0 24 24" class="play-icon"><path d="M8 5v14l11-7z"></path></svg>
+                <svg viewBox="0 0 24 24" class="pause-icon" style="display: none;"><path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"></path></svg>
+            </button>
+            <div class="player-controls">
+                <span class="time-display current-time">00:00</span>
+                <div class="progress-bar-wrapper">
+                    <div class="progress-bar-fill"></div>
+                </div>
+                <span class="time-display duration">00:00</span>
+            </div>
+            <div class="volume-wrapper">
+                <button type="button" class="volume-btn">
+                    <svg viewBox="0 0 24 24"><path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"></path></svg>
+                </button>
+                <div class="volume-slider-wrapper">
+                    <input type="range" class="volume-slider" min="0" max="1" step="0.01" value="1" style="writing-mode: bt-lr; -webkit-appearance: slider-vertical;">
+                </div>
+            </div>
+            <a href="${audioSrc}" class="download-btn" download title="Скачать аудио">
+                <svg viewBox="0 0 24 24"><path d="M5 20h14v-2H5v2zM19 9h-4V3H9v6H5l7 7 7-7z"></path></svg>
+            </a>
+        `;
+        playerContainer.appendChild(audio);
+
+        const playPauseBtn = playerContainer.querySelector('.play-pause-btn');
+        const playIcon = playerContainer.querySelector('.play-icon');
+        const pauseIcon = playerContainer.querySelector('.pause-icon');
+        const currentTimeEl = playerContainer.querySelector('.current-time');
+        const durationEl = playerContainer.querySelector('.duration');
+        const progressBarFill = playerContainer.querySelector('.progress-bar-fill');
+        const progressBarWrapper = playerContainer.querySelector('.progress-bar-wrapper');
+        const volumeSlider = playerContainer.querySelector('.volume-slider');
+        let animationFrameId;
+
+        const formatTime = (time) => { const minutes = Math.floor(time / 60); const seconds = Math.floor(time % 60); return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`; };
+        
+        const updateProgress = () => {
+            currentTimeEl.textContent = formatTime(audio.currentTime);
+            progressBarFill.style.width = `${(audio.currentTime / audio.duration) * 100}%`;
+            animationFrameId = requestAnimationFrame(updateProgress);
+        };
+
+        const togglePlay = () => {
+            if (audio.paused) { audio.play(); playIcon.style.display = 'none'; pauseIcon.style.display = 'block'; }
+            else { audio.pause(); playIcon.style.display = 'block'; pauseIcon.style.display = 'none'; }
+        };
+        
+        audio.addEventListener('loadedmetadata', () => { durationEl.textContent = formatTime(audio.duration); });
+        audio.addEventListener('play', () => { animationFrameId = requestAnimationFrame(updateProgress); });
+        audio.addEventListener('pause', () => { cancelAnimationFrame(animationFrameId); });
+        audio.addEventListener('ended', () => {
+            cancelAnimationFrame(animationFrameId); playIcon.style.display = 'block'; pauseIcon.style.display = 'none';
+            progressBarFill.style.width = '0%'; currentTimeEl.textContent = '00:00';
+        });
+
+        playPauseBtn.addEventListener('click', togglePlay);
+        progressBarWrapper.addEventListener('click', (e) => { const rect = progressBarWrapper.getBoundingClientRect(); const clickX = e.clientX - rect.left; audio.currentTime = audio.duration * (clickX / rect.width); });
+        volumeSlider.addEventListener('input', (e) => { audio.volume = e.target.value; });
+        
+        return playerContainer;
+    };
+    
+    const sliders = [ { id: 'speed', valueId: 'speed-value' }, { id: 'nfe', valueId: 'nfe-value' }, { id: 'cross_fade', valueId: 'cross-fade-value' } ];
+    sliders.forEach(s => { const el = document.getElementById(s.id); if (el) el.addEventListener('input', () => document.getElementById(s.valueId).textContent = el.value); });
+    
+    function handleFile(file) { if (file && file.type.startsWith('audio/')) { fileMsg.textContent = file.name; refAudioPreview.innerHTML = ''; const player = createCustomPlayer(URL.createObjectURL(file)); refAudioPreview.appendChild(player); refTextInput.value = ''; } }
+    fileInput.addEventListener('change', () => handleFile(fileInput.files[0]));
+    fileDropArea.addEventListener('dragover', (e) => { e.preventDefault(); fileDropArea.classList.add('is-active'); });
+    fileDropArea.addEventListener('dragleave', () => fileDropArea.classList.remove('is-active'));
+    fileDropArea.addEventListener('drop', (e) => { e.preventDefault(); fileDropArea.classList.remove('is-active'); const f = e.dataTransfer.files; if (f.length) { fileInput.files = f; handleFile(f[0]); } });
+
+    function showStatus(message, isError = false) { statusContainer.textContent = message; statusContainer.className = isError ? 'error' : 'success'; statusContainer.style.display = 'block'; }
+    
+    function startLoader() {
+        resultsPlaceholder.classList.add('hidden'); resultsContainer.classList.add('hidden'); generationProgress.classList.remove('hidden');
+        let seconds = 0; timerElement.textContent = '00:00'; progressBar.style.width = '0%'; progressPercent.textContent = '0%'; loaderStatusText.textContent = 'Инициализация...';
+        timerInterval = setInterval(() => { seconds++; const m = String(Math.floor(seconds/60)).padStart(2,'0'); const s = String(seconds%60).padStart(2,'0'); timerElement.textContent = `${m}:${s}`; }, 1000);
+    }
+    
+    function stopLoader() { clearInterval(timerInterval); clearInterval(pollInterval); }
+
+    function pollStatus(taskId) {
+        pollInterval = setInterval(async () => {
+            try {
+                const response = await fetch(`/status/${taskId}`); const data = await response.json();
+                progressBar.style.width = `${data.progress || 0}%`; progressPercent.textContent = `${data.progress || 0}%`;
+                if (data.description) loaderStatusText.textContent = data.description;
+                if (data.status === 'complete' || data.status === 'error') {
+                    stopLoader(); generationProgress.classList.add('hidden'); generateBtn.disabled = false;
+                    if (data.status === 'complete') {
+                        const result = data.result; resultsContainer.classList.remove('hidden');
+                        audioOutputContainer.innerHTML = ''; const player = createCustomPlayer(result.audio_url); audioOutputContainer.appendChild(player);
+                        spectrogramOutput.src = result.spectrogram_url; refTextInput.value = result.ref_text; genTextInput.value = result.gen_text;
+                        showStatus('Синтез успешно завершен!', false);
+                    } else { showStatus(`Ошибка: ${data.error}`, true); resultsPlaceholder.classList.remove('hidden'); }
+                }
+            } catch (error) { stopLoader(); generationProgress.classList.add('hidden'); resultsPlaceholder.classList.remove('hidden'); showStatus('Ошибка сети.', true); generateBtn.disabled = false; }
+        }, 1000);
+    }
+
+    processTextBtn.addEventListener('click', async () => {
+        processTextBtn.disabled = true; processTextBtn.innerHTML = 'Обработка...';
+        try {
+            const response = await fetch('/process-text', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ gen_text: genTextInput.value }) });
+            const data = await response.json();
+            if (data.success) { genTextInput.value = data.gen_text; showStatus('Ударения для текста генерации расставлены.', false); } 
+            else { showStatus(data.error || 'Ошибка обработки текста.', true); }
+        } catch (error) { showStatus('Ошибка сети.', true); } 
+        finally { processTextBtn.disabled = false; processTextBtn.innerHTML = '✏️ Расставить ударения'; }
+    });
+
+    ttsForm.addEventListener('submit', async (e) => {
+        e.preventDefault();
+        generateBtn.disabled = true; statusContainer.style.display = 'none';
+        startLoader(); const formData = new FormData(ttsForm);
+        formData.set('remove_silence', document.getElementById('remove_silence').checked);
+        try {
+            const response = await fetch('/synthesize', { method: 'POST', body: formData });
+            const data = await response.json();
+            if (response.ok && data.success) { pollStatus(data.task_id); } 
+            else { stopLoader(); generationProgress.classList.add('hidden'); resultsPlaceholder.classList.remove('hidden'); showStatus(data.error || 'Не удалось запустить задачу.', true); generateBtn.disabled = false; }
+        } catch (error) { stopLoader(); generationProgress.classList.add('hidden'); resultsPlaceholder.classList.remove('hidden'); showStatus('Критическая ошибка сети.', true); generateBtn.disabled = false; }
+    });
+});

tts_colab/templates/index.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ESpeech-TTS-AINetSD Interface</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+</head>
+<body>
+    <div class="main-layout">
+        <aside class="controls-panel">
+            <header><h1>ESpeech-TTS</h1></header>
+            <form id="tts-form" enctype="multipart/form-data">
+                <div class="card">
+                    <h3>Модель и данные</h3>
+                    <div class="form-group"><label for="model_choice">Модель</label><select id="model_choice" name="model_choice">{% for model in models %}<option value="{{ model }}">{{ model }}</option>{% endfor %}</select></div>
+                    <div class="form-group"><label for="ref_audio">Референтное аудио (до 12 сек)</label><div class="file-drop-area"><span class="file-msg">Перетащите файл или кликните</span><input type="file" id="ref_audio" name="ref_audio" accept="audio/*" required></div><div id="ref-audio-preview" class="audio-preview"></div></div>
+                    <details class="accordion text-accordion"><summary><label for="ref_text">Текст референса (необязательно)</label></summary><div class="accordion-content"><textarea id="ref_text" name="ref_text" rows="3" placeholder="Оставьте пустым для ASR"></textarea></div></details>
+                    <div class="form-group"><label for="gen_text">Текст для генерации</label><textarea id="gen_text" name="gen_text" rows="5" placeholder="Введите текст..." required></textarea><button type="button" id="process-text-btn" class="secondary-btn accent-btn">✏️ Расставить ударения</button></div>
+                </div>
+                <details class="card accordion">
+                    <summary><h3>Настройки</h3></summary>
+                    <div class="accordion-content">
+                        <div class="settings-grid">
+                            <div class="form-group slider-group"><label for="speed">Скорость: <span id="speed-value">1.0</span></label><input type="range" id="speed" name="speed" min="0.3" max="2.0" value="1.0" step="0.1"></div>
+                            <div class="form-group slider-group"><label for="nfe">Шаги NFE: <span id="nfe-value">48</span></label><input type="range" id="nfe" name="nfe" min="4" max="64" value="48" step="2"></div>
+                            <div class="form-group slider-group"><label for="cross_fade">Cross-Fade: <span id="cross-fade-value">0.15</span></label><input type="range" id="cross_fade" name="cross_fade" min="0.0" max="1.0" value="0.15" step="0.01"></div>
+                            <div class="form-group"><label for="seed">Сид</label><input type="number" id="seed" name="seed" value="-1" placeholder="-1 для случайного"></div>
+                        </div>
+                        <div class="settings-grid-bottom">
+                            <div class="form-group checkbox-group"><input type="checkbox" id="remove_silence" name="remove_silence"><label for="remove_silence">Удалить тишину</label></div>
+                            <div class="form-group">
+                                <label>Формат вывода</label>
+                                <div class="radio-group">
+                                    <div><input type="radio" id="format_wav" name="output_format" value="wav"><label for="format_wav">WAV</label></div>
+                                    <div><input type="radio" id="format_mp3" name="output_format" value="mp3" checked><label for="format_mp3">MP3</label></div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </details>
+                <div class="actions"><button type="submit" id="generate-btn" class="primary-btn"><span>🎤 Сгенерировать</span></button></div>
+            </form>
+             <div class="info-text">💡 Можно использовать `+` для ручного ударения</div>
+        </aside>
+        <main class="results-panel">
+            <div id="results-placeholder"><h2>Результат генерации</h2><p>Здесь появится сгенерированное аудио и его спектрограмма.</p></div>
+            <div id="generation-progress" class="hidden"><div class="loader-content"><h3>Идёт синтез...</h3><p id="loader-status-text">Инициализация...</p><div class="progress-bar-container"><div class="progress-bar"></div></div><div class="loader-footer"><span id="progress-percent">0%</span><span id="timer">00:00</span></div></div></div>
+            <div id="results-container" class="hidden">
+                 <div class="result-item">
+                    <h4>Сгенерированное Аудио</h4>
+                    <div id="audio-output-container"></div>
+                </div>
+                 <div class="result-item">
+                    <h4>Спектрограмма</h4>
+                    <img id="spectrogram-output" src="" alt="Spectrogram">
+                </div>
+            </div>
+             <div id="status-container"></div>
+        </main>
+    </div>
+    <script src="{{ url_for('static', filename='js/script.js') }}"></script>
+</body>
+</html>

tts_colab/tts.py

@@ -0,0 +1,242 @@
+import gc
+import tempfile
+import threading
+import time
+import traceback
+import uuid
+from pathlib import Path
+
+import numpy as np
+import onnx_asr
+import soundfile as sf
+import torch
+import torchaudio
+from f5_tts.infer.utils_infer import (
+    infer_process, load_model, load_vocoder, preprocess_ref_audio_text,
+    remove_silence_for_generated_wav, save_spectrogram, tempfile_kwargs,
+)
+from f5_tts.model import DiT
+from flask import Flask, render_template, request, jsonify
+from huggingface_hub import hf_hub_download
+from pydub import AudioSegment
+from ruaccent import RUAccent
+
+
+
+
+COLAB_ROOT = Path('/content')
+GENERATED_FOLDER = Path(__file__).parent / 'static' / 'generated'
+
+GENERATED_FOLDER.mkdir(exist_ok=True)
+
+app = Flask(__name__)
+
+TASK_STATUS = {}
+
+MODEL_REPOS = {
+    "ESpeech-TTS-1 [RL] V2": {"repo_id": "ESpeech/ESpeech-TTS-1_RL-V2", "filename": "espeech_tts_rlv2.pt"},
+    "ESpeech-TTS-1 [RL] V1": {"repo_id": "ESpeech/ESpeech-TTS-1_RL-V1", "filename": "espeech_tts_rlv1.pt"},
+    "ESpeech-TTS-1 [SFT] 95K": {"repo_id": "ESpeech/ESpeech-TTS-1_SFT-95K", "filename": "espeech_tts_95k.pt"},
+    "ESpeech-TTS-1 [SFT] 265K": {"repo_id": "ESpeech/ESpeech-TTS-1_SFT-256K", "filename": "espeech_tts_256k.pt"},
+    "ESpeech-TTS-1 PODCASTER [SFT]": {"repo_id": "ESpeech/ESpeech-TTS-1_podcaster",
+                                      "filename": "espeech_tts_podcaster.pt"},
+}
+VOCAB_REPO = "ESpeech/ESpeech-TTS-1_podcaster"
+VOCAB_FILENAME = "vocab.txt"
+MODEL_CFG = dict(dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4)
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+_cached_local_paths = {}
+_loaded_models_on_device = {}
+
+
+def hf_download_file(repo_id: str, filename: str):
+    try:
+        p = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="model")
+        return p
+    except Exception as e:
+        app.logger.error(f"Ошибка загрузки: {e}")
+        raise
+
+
+def get_vocab_path():
+    key = f"{VOCAB_REPO}::{VOCAB_FILENAME}"
+    p = _cached_local_paths.get(key)
+    if p and Path(p).exists(): return p
+    p = hf_download_file(VOCAB_REPO, VOCAB_FILENAME)
+    _cached_local_paths[key] = p
+    return p
+
+
+def get_model_local_path(choice: str):
+    repo = MODEL_REPOS[choice]
+    key = f"{repo['repo_id']}::{repo['filename']}"
+    p = _cached_local_paths.get(key)
+    if p and Path(p).exists(): return p
+    p = hf_download_file(repo["repo_id"], repo["filename"])
+    _cached_local_paths[key] = p
+    return p
+
+
+def get_model_on_device(choice: str):
+    if choice in _loaded_models_on_device: return _loaded_models_on_device[choice]
+    model_file, vocab_file = get_model_local_path(choice), get_vocab_path()
+    model = load_model(DiT, MODEL_CFG, model_file, vocab_file=vocab_file)
+    model.to(DEVICE).float().eval()
+    _loaded_models_on_device[choice] = model
+    return model
+
+
+class CustomProgressTracker:
+    def __init__(self, task_id, progress_range=(0, 100)):
+        self.task_id = task_id
+        self.start, self.end = progress_range
+        self.range = self.end - self.start
+        self.last_update_time = time.time()
+        self.tqdm = lambda x: x
+
+    def __call__(self, progress, desc=""):
+        current_time = time.time()
+        if current_time - self.last_update_time < 0.1: return
+        percent_in_range = (progress[0] / progress[1]) if progress[1] > 0 else 0
+        scaled_percent = int(self.start + percent_in_range * self.range)
+        TASK_STATUS[self.task_id].update({"progress": scaled_percent, "description": desc})
+        self.last_update_time = current_time
+
+
+def process_text_with_accent(text, accentizer):
+    if not text or not text.strip() or '+' in text: return text
+    return accentizer.process_all(text)
+
+
+def update_task_progress(task_id, progress, description):
+    TASK_STATUS[task_id].update({"progress": progress, "description": description})
+    time.sleep(0.05)
+
+
+def run_synthesis(task_id, params):
+    try:
+        model_choice, ref_audio_path, ref_text, gen_text, remove_silence, seed, cross_fade_duration, nfe_step, speed, output_format = (
+            params['model_choice'], params['ref_audio_path'], params['ref_text'], params['gen_text'],
+            params['remove_silence'], params['seed'], params['cross_fade_duration'], params['nfe_step'],
+            params['speed'], params['output_format']
+        )
+        ref_audio_path = Path(ref_audio_path)
+        if seed is None or seed < 0 or seed > 2 ** 31 - 1: seed = np.random.randint(0, 2 ** 31 - 1)
+        torch.manual_seed(int(seed))
+        if not ref_text or not ref_text.strip():
+            update_task_progress(task_id, 5, 'Транскрипция (ASR)...')
+            waveform, sample_rate = torchaudio.load(ref_audio_path)
+            waveform = waveform.numpy()
+            if waveform.dtype == np.int16:
+                waveform = waveform / 2 ** 15
+            elif waveform.dtype == np.int32:
+                waveform = waveform / 2 ** 31
+            if waveform.ndim == 2: waveform = waveform.mean(axis=0)
+            ref_text = asr_model.recognize(waveform, sample_rate=sample_rate)
+            update_task_progress(task_id, 15, 'Транскрипция завершена')
+        processed_ref_text = process_text_with_accent(ref_text, accentizer)
+        model = get_model_on_device(model_choice)
+        update_task_progress(task_id, 20, 'Предобработка аудио...')
+        ref_audio_proc, processed_ref_text_final = preprocess_ref_audio_text(ref_audio_path, processed_ref_text,
+                                                                             show_info=app.logger.info)
+        update_task_progress(task_id, 30, 'Запуск синтеза...')
+        progress_tracker = CustomProgressTracker(task_id, progress_range=(30, 90))
+        final_wave, final_sample_rate, combined_spectrogram = infer_process(
+            ref_audio_proc, processed_ref_text_final, gen_text, model, vocoder,
+            cross_fade_duration=cross_fade_duration, nfe_step=nfe_step, speed=speed,
+            show_info=app.logger.info, progress=progress_tracker)
+        update_task_progress(task_id, 95, 'Постобработка...')
+        if remove_silence:
+            with tempfile.NamedTemporaryFile(suffix=".wav", **tempfile_kwargs) as f:
+                temp_path = f.name
+                sf.write(temp_path, final_wave, final_sample_rate)
+                remove_silence_for_generated_wav(temp_path)
+                final_wave_tensor, _ = torchaudio.load(temp_path)
+                final_wave = final_wave_tensor.squeeze().cpu().numpy()
+        unique_id = uuid.uuid4()
+        wav_filename = f'{unique_id}.wav'
+        wav_path = GENERATED_FOLDER / wav_filename
+        sf.write(wav_path, final_wave, final_sample_rate)
+
+        audio_url_final = f'/static/generated/{wav_filename}'
+        if output_format == 'mp3':
+            update_task_progress(task_id, 98, 'Конвертация в MP3...')
+            mp3_filename = f'{unique_id}.mp3'
+            mp3_path = GENERATED_FOLDER / mp3_filename
+            sound = AudioSegment.from_wav(wav_path)
+            sound.export(mp3_path, format="mp3", bitrate="192k")
+            audio_url_final = f'/static/generated/{mp3_filename}'
+            wav_path.unlink()
+
+        spectrogram_filename = f'{unique_id}.png'
+        spectrogram_path = GENERATED_FOLDER / spectrogram_filename
+        save_spectrogram(combined_spectrogram, spectrogram_path)
+        if DEVICE.type == "cuda": torch.cuda.empty_cache()
+        gc.collect()
+        ref_audio_path.unlink()
+
+        TASK_STATUS[task_id].update({
+            "status": "complete", "progress": 100, "description": "Готово!", "result": {
+                'audio_url': audio_url_final, 'spectrogram_url': f'/static/generated/{spectrogram_filename}',
+                'ref_text': processed_ref_text_final, 'gen_text': gen_text}})
+    except Exception as e:
+        app.logger.error(f"Ошибка в задаче {task_id}: {e}")
+        traceback.print_exc()
+        TASK_STATUS[task_id].update({"status": "error", "error": str(e)})
+        if params['ref_audio_path']:
+            Path(params['ref_audio_path']).unlink(missing_ok=True)
+
+
+@app.route('/')
+def index(): return render_template('index.html', models=MODEL_REPOS.keys())
+
+
+@app.route('/process-text', methods=['POST'])
+def process_text_endpoint():
+    data = request.json
+    gen_text = process_text_with_accent(data.get('gen_text', ''), accentizer)
+    return jsonify({'success': True, 'gen_text': gen_text})
+
+
+@app.route('/synthesize', methods=['POST'])
+def synthesize_start():
+    task_id = str(uuid.uuid4())
+    ref_audio_file = request.files.get('ref_audio')
+    if not ref_audio_file: return jsonify({'success': False, 'error': 'Аудиофайл не найден.'}), 400
+    _, ext = ref_audio_file.filename.split('.')
+    temp_audio_path = Path(tempfile.gettempdir()) / f"{task_id}{ext}"
+    ref_audio_file.save(temp_audio_path)
+    params = {
+        'model_choice': request.form.get('model_choice'), 'ref_audio_path': temp_audio_path,
+        'ref_text': request.form.get('ref_text', ''), 'gen_text': request.form.get('gen_text', ''),
+        'remove_silence': request.form.get('remove_silence') == 'true', 'seed': int(request.form.get('seed', -1)),
+        'cross_fade_duration': float(request.form.get('cross_fade', 0.15)),
+        'nfe_step': int(request.form.get('nfe', 48)), 'speed': float(request.form.get('speed', 1.0)),
+        'output_format': request.form.get('output_format', 'wav'),
+    }
+    TASK_STATUS[task_id] = {"status": "processing", "progress": 0, "description": "В очереди..."}
+    thread = threading.Thread(target=run_synthesis, args=(task_id, params))
+    thread.daemon = True
+    thread.start()
+    return jsonify({'success': True, 'task_id': task_id})
+
+
+@app.route('/status/<task_id>')
+def get_status(task_id):
+    return jsonify(TASK_STATUS.get(task_id, {"status": "not_found"}))
+
+
+print(f"--- Используемое устройство: {DEVICE} ---")
+print("--- Загрузка RUAccent... ---")
+accentizer = RUAccent()
+accentizer.load(omograph_model_size='turbo3.1', use_dictionary=True, tiny_mode=False)
+print("--- Загрузка ASR (nemo-fastconformer-ru-rnnt)... ---")
+asr_model = onnx_asr.load_model("nemo-fastconformer-ru-rnnt")
+vocoder = load_vocoder()
+try:
+    vocoder.to(DEVICE).float()
+except:
+    print("--- Вокодер остался на CPU ---")
+
+
+