The open-source AI voice studio. Clone, dictate, create.
fix(build): repair frozen-binary imports for kokoro, chatterbox-multilingual, scipy, transformers (#438)
Jamie Pinec8cb12f1bc98
diff --git a/backend/build_binary.py b/backend/build_binary.pyindex 84c019ab..875d6733 100644--- a/backend/build_binary.py+++ b/backend/build_binary.py@@ -55,10 +55,23 @@ def build_server(cuda=False):# numpy 2.x / torch ABI mismatch fix: install memmove fallback for# torch.from_numpy() before the app starts. Runtime hooks run after# FrozenImporter is registered so frozen torch/numpy are importable.+ # Paths are passed relative to backend_dir because os.chdir(backend_dir)+ # runs before PyInstaller. Absolute paths would get baked into the+ # generated .spec, breaking reproducible builds on other machines / CI.args.extend(["--runtime-hook",- str(backend_dir / "pyi_rth_numpy_compat.py"),+ "pyi_rth_numpy_compat.py",+ # Stub torch.compiler.disable before transformers imports+ # flex_attention, which otherwise triggers torch._dynamo →+ # torch._numpy._ufuncs and crashes at module load under+ # PyInstaller. See pyi_rth_torch_compiler_disable.py.+ "--runtime-hook",+ "pyi_rth_torch_compiler_disable.py",+ # Per-module collection overrides (e.g. forcing scipy.stats._distn_infrastructure+ # to bundle .py source alongside .pyc so the runtime hook can source-patch it).+ "--additional-hooks-dir",+ "pyi_hooks",])@@ -125,6 +138,11 @@ def build_server(cuda=False):"backend.backends.chatterbox_backend","--hidden-import","backend.backends.chatterbox_turbo_backend",+ # chatterbox multilingual uses spacy_pkuseg for Chinese word+ # segmentation, which ships pickled dict files (dicts/default.pkl)+ # and native .so extensions that --hidden-import alone won't bundle.+ "--collect-all",+ "spacy_pkuseg","--hidden-import","backend.backends.luxtts_backend","--hidden-import",@@ -241,20 +259,13 @@ def build_server(cuda=False):"--collect-submodules","tada",# Kokoro 82M — lightweight TTS engine using misaki G2P+ # collect-all is required because transformers introspects .py source+ # files at runtime (e.g. _can_set_attn_implementation opens the class+ # file); hidden-import alone only bundles bytecode."--hidden-import","backend.backends.kokoro_backend",- "--hidden-import",+ "--collect-all","kokoro",- "--hidden-import",- "kokoro.pipeline",- "--hidden-import",- "kokoro.model",- "--hidden-import",- "kokoro.istftnet",- "--hidden-import",- "kokoro.modules",- "--hidden-import",- "kokoro.custom_stft",# misaki ships G2P data files (dictionaries, phoneme tables)# that must be bundled for espeak/en/ja/zh G2P to work"--collect-all",diff --git a/backend/pyi_hooks/hook-scipy.stats._distn_infrastructure.py b/backend/pyi_hooks/hook-scipy.stats._distn_infrastructure.pynew file mode 100644index 00000000..653f0c12--- /dev/null+++ b/backend/pyi_hooks/hook-scipy.stats._distn_infrastructure.py@@ -0,0 +1,12 @@+"""+Force scipy.stats._distn_infrastructure to be bundled with its .py source file+alongside the .pyc bytecode.++The runtime hook in backend/pyi_rth_torch_compiler_disable.py patches this+module's source at load time (the module has a `del obj` at line 369 that+raises NameError under PyInstaller's frozen importer). That patch reads the+source via loader.get_source(), which only works if the .py file was+actually collected into the bundle.+"""++module_collection_mode = "pyz+py"diff --git a/backend/pyi_hooks/hook-transformers.masking_utils.py b/backend/pyi_hooks/hook-transformers.masking_utils.pynew file mode 100644index 00000000..e18e9836--- /dev/null+++ b/backend/pyi_hooks/hook-transformers.masking_utils.py@@ -0,0 +1,11 @@+"""+Force transformers.masking_utils to be bundled with its .py source alongside+the .pyc bytecode so the runtime hook in+backend/pyi_rth_torch_compiler_disable.py can source-patch it.++The patch forces the torch<2.6 code path, bypassing `with TransformGetItemToIndex()`+which our torch._dynamo no-op stub can't implement for real — the real context+manager uses dynamo graph transforms to avoid `.item()` calls inside vmap.+"""++module_collection_mode = "pyz+py"diff --git a/backend/pyi_rth_torch_compiler_disable.py b/backend/pyi_rth_torch_compiler_disable.pynew file mode 100644index 00000000..e8810079--- /dev/null+++ b/backend/pyi_rth_torch_compiler_disable.py@@ -0,0 +1,540 @@+"""+PyInstaller runtime hook: stub torch._dynamo to a no-op module.++Problem+-------+transformers triggers torch._dynamo import at module-load time (not just+when torch.compile is called) via class-body decorators:++ transformers/modeling_utils.py:1984+ @torch._dynamo.allow_in_graph+ class PreTrainedModel(...)++ transformers/integrations/flex_attention.py:61+ @torch.compiler.disable(recursive=False)+ class WrappedFlexAttention...++The attribute access triggers torch.__getattr__ -> importlib.import_module+-> torch._dynamo -> torch._dynamo.utils imports torch._numpy ->+torch._numpy._ndarray imports torch._numpy._ufuncs, which crashes under+PyInstaller with:++ File "torch/_numpy/_ufuncs.py", line 235, in <module>+ vars()[name] = deco_binary_ufunc(ufunc)+ NameError: name 'name' is not defined++(The module-level `for name in _binary: vars()[name] = ...` pattern works+in a regular venv but fails in the PyInstaller bundle. Root cause is in+PyInstaller's importer / bytecode pipeline and not easily fixed upstream.)++Surfaces as Kokoro failing to load when `from transformers import AlbertModel`+trips the decorator chain.++Fix+---+voicebox never uses torch.compile / torch._dynamo for inference, so we+replace torch._dynamo with a no-op stub module before transformers is+imported. Any attribute access on the stub returns a pass-through callable,+so `@torch._dynamo.allow_in_graph`, `torch._dynamo.is_compiling()`,+`torch._dynamo.mark_static_address(...)`, etc. all work.++This hook is pure sys.modules manipulation — we deliberately do NOT import+torch here. Runtime hooks run before the app starts and before+pyi_rth_numpy_compat has had a chance to patch torch.from_numpy (it runs+in a background thread, waiting for torch to appear in sys.modules).+Eager-importing torch at hook time would trip the numpy ABI issue and+kill the server process at startup.++torch.compiler.disable does not need a separate stub: its implementation+is effectively `import torch._dynamo; return torch._dynamo.disable(...)`,+and since our stub is in sys.modules, that call resolves to our no-op+_NoopDecorator pass-through.+"""++import os+import sys+import tempfile+import types+++# Diagnostics — log hook activity to a file alongside the bundle so we can+# see what's happening when the server is run as a sidecar (no stdout for+# runtime hook prints). Safe no-op if the file can't be written.+_DIAG_PATH = os.path.join(tempfile.gettempdir(), "voicebox_rt_hook.log")+++def _diag(msg: str) -> None:+ try:+ with open(_DIAG_PATH, "a", encoding="utf-8") as f:+ f.write(msg + "\n")+ except Exception:+ pass+++_HOOK_VERSION = "v6-masking-utils-finder"+_diag(f"=== runtime hook load @ pid={os.getpid()} version={_HOOK_VERSION} ===")+++class _NoopDecorator:+ """Multi-role no-op: decorator, falsey predicate, and context manager.++ Returned from calls like `torch._dynamo.disable()` (decorator),+ `torch._dynamo.is_compiling()` (predicate used in `if not ...`), and+ `with torch._dynamo._trace_wrapped_higher_order_op.TransformGetItemToIndex():`+ (context manager used to scope an fx graph transformation).++ By implementing __call__, __bool__, __enter__, __exit__, and __iter__ we+ cover every use pattern we've seen transformers/torch use on a stubbed+ object. Anything we haven't covered will raise a clearer error than a+ silent wrong-result.+ """++ __slots__ = ()++ def __call__(self, fn=None, *args, **kwargs):+ return fn++ def __bool__(self) -> bool:+ return False++ def __enter__(self):+ return self++ def __exit__(self, exc_type, exc_value, traceback):+ return False # don't suppress exceptions++ def __iter__(self):+ return iter(())+++_noop_decorator_singleton = _NoopDecorator()+++def _noop_callable(*args, **kwargs):+ # Direct-decorator use: @torch._dynamo.foo (no parens) — fn is positional+ if len(args) == 1 and callable(args[0]) and not kwargs:+ return args[0]+ # Side-effect call with non-callable arg(s), e.g. mark_static_address(tensor)+ return _noop_decorator_singleton+++class _NoopDynamoModule(types.ModuleType):+ """Permissive stub: every attribute is a pass-through callable.++ Covers attributes transformers hits at import time (allow_in_graph) and+ runtime (is_compiling, mark_static_address, reset, disable, ...).++ Dunder attributes (__file__, __spec__, __loader__, ...) raise+ AttributeError so probes like inspect.getmodule() — which does+ `hasattr(m, '__file__')` then `os.path.normpath(m.__file__)` — see the+ module as having no source file and fall through to its normal+ handling, instead of receiving a function and blowing up.+ """++ def __getattr__(self, name: str):+ if name.startswith("__") and name.endswith("__"):+ raise AttributeError(name)+ return _noop_callable+++class _DynamoLoader:+ """Loader used by _DynamoMetaPathFinder to materialise stub submodules."""++ def create_module(self, spec):+ return _NoopDynamoModule(spec.name)++ def exec_module(self, module):+ # Mark every stub submodule as a package so deeper submodule imports+ # (`from torch._dynamo.X.Y import Z`) keep working.+ module.__path__ = []+++class _DynamoMetaPathFinder:+ """Resolve any `torch._dynamo.X[.Y...]` import to a no-op stub module.++ Without this, `from torch._dynamo._trace_wrapped_higher_order_op import X`+ fails even with torch._dynamo pre-populated in sys.modules — Python's+ import machinery checks the parent's __path__ and then looks up the+ child, and we need to provide both.+ """++ def find_spec(self, fullname, path=None, target=None):+ if fullname == "torch._dynamo":+ return None # handled by the pre-populated sys.modules entry+ if not fullname.startswith("torch._dynamo."):+ return None+ from importlib.machinery import ModuleSpec++ return ModuleSpec(fullname, _DynamoLoader(), is_package=True)+++class _TransformersStubFinder:+ """Replace specific transformers submodules with no-op stubs.++ Two modules are targeted:++ 1. transformers.utils.auto_docstring+ The real @auto_docstring decorator loads+ transformers.models.auto.modeling_auto just to build example docstrings,+ which drags in GenerationMixin -> candidate_generator -> sklearn.metrics+ -> scipy.stats._distn_infrastructure and trips (2) below. Docstrings+ aren't functional for inference, so a pass-through decorator is safe.++ 2. transformers.generation.candidate_generator+ Imported at module scope by transformers.generation.utils. It does+ `from sklearn.metrics import roc_curve` at module load, which triggers:++ File "scipy/stats/_distn_infrastructure.py", line 369, in <module>+ NameError: name 'obj' is not defined++ This is a PyInstaller-specific module-load bug (same class as the+ torch._numpy._ufuncs crash) where a module-level `for obj in [s for s+ in dir() if ...]` loop evaluates to empty in the bundle, leaving `obj`+ unbound before `del obj`.++ The exports (AssistedCandidateGenerator, EarlyExitCandidateGenerator,+ etc.) are speculative-decoding helpers voicebox's TTS engines do not+ use; a no-op stub module satisfies the imports.+ """++ _STUBBED_MODULES = frozenset(+ {+ "transformers.utils.auto_docstring",+ "transformers.generation.candidate_generator",+ }+ )++ def find_spec(self, fullname, path=None, target=None):+ if fullname not in self._STUBBED_MODULES:+ return None+ from importlib.machinery import ModuleSpec++ return ModuleSpec(fullname, _NoopStubLoader(), is_package=False)+++class _NoopStubLoader:+ def create_module(self, spec):+ return _NoopDynamoModule(spec.name)++ def exec_module(self, module):+ # _NoopDynamoModule.__getattr__ already answers every non-dunder+ # attribute with a pass-through callable, which satisfies+ # `from stubbed_module import X` for any X.+ pass+++def _patch_scipy_distn_source(source: str) -> str:+ """Replace the unsafe `del obj` with a no-op that survives when obj is unbound.++ Returns the input unchanged if the target line isn't found (e.g. scipy+ version has changed).+ """+ target = "\ndel obj\n"+ replacement = "\nglobals().pop('obj', None)\n"+ if target in source:+ return source.replace(target, replacement, 1)+ return source+++def _patch_masking_utils_source(source: str) -> str:+ """Force torch<2.6 code path in transformers.masking_utils.++ The torch>=2.6 path uses `with TransformGetItemToIndex():` to allow+ `.item()` calls inside vmap. That context manager is implemented via+ torch._dynamo graph transforms, which our stub doesn't reproduce — it's+ a no-op. The inner `_vmap_for_bhqkv` then crashes with:++ RuntimeError: vmap: It looks like you're calling .item() on a Tensor.++ Forcing the torch<2.6 flag off selects sdpa_mask_older_torch which uses+ a different vmap pattern that does not hit .item() and does not need+ TransformGetItemToIndex.+ """+ target = 'is_torch_greater_or_equal("2.6", accept_dev=True)'+ # Find the specific line that assigns _is_torch_greater_or_equal_than_2_6+ if "_is_torch_greater_or_equal_than_2_6 = " + target in source:+ return source.replace(+ "_is_torch_greater_or_equal_than_2_6 = " + target,+ "_is_torch_greater_or_equal_than_2_6 = False",+ 1,+ )+ return source+++class _SourcePatchingFinder:+ """Generic delegate-and-wrap meta-path finder that patches a module's+ source before exec'ing.++ Subclasses declare `target` (module fullname) and `patch` (str->str).+ Requires the target module's .py source to be bundled (use a PyInstaller+ hook setting module_collection_mode = "pyz+py").+ """++ target: str+ patch_fn: callable = None++ def find_spec(self, fullname, path=None, target=None):+ if fullname != self.target:+ return None+ for finder in sys.meta_path:+ if finder is self:+ continue+ find = getattr(finder, "find_spec", None)+ if find is None:+ continue+ try:+ real_spec = find(fullname, path, target)+ except Exception:+ continue+ if real_spec is None or real_spec.loader is None:+ continue+ real_spec.loader = _SourcePatchLoader(real_spec.loader, self.patch_fn)+ return real_spec+ return None+++class _SourcePatchLoader:+ """Delegate loader that reads source via get_source, applies a patch, and+ compile/exec's the patched text into module.__dict__.+ """++ def __init__(self, inner, patch_fn):+ self._inner = inner+ self._patch_fn = patch_fn++ def __getattr__(self, name):+ return getattr(self._inner, name)++ def create_module(self, spec):+ return self._inner.create_module(spec)++ def exec_module(self, module):+ source = None+ try:+ source = self._inner.get_source(module.__name__)+ except Exception as e:+ _diag(f"[source-patch] get_source({module.__name__}) failed: {e!r}")++ if not source:+ _diag(+ f"[source-patch] no source for {module.__name__}; "+ "falling back to inner exec_module (patch NOT applied)"+ )+ self._inner.exec_module(module)+ return++ patched = self._patch_fn(source)+ _diag(+ f"[source-patch] {module.__name__}: "+ f"patched={patched is not source}, len={len(patched)}"+ )+ spec = module.__spec__+ if spec is not None and spec.submodule_search_locations is not None:+ module.__path__ = spec.submodule_search_locations+ filename = getattr(self._inner, "path", module.__name__)+ exec(compile(patched, filename, "exec"), module.__dict__)+ _diag(f"[source-patch] {module.__name__} OK")+++class _MaskingUtilsFinder(_SourcePatchingFinder):+ target = "transformers.masking_utils"+ patch_fn = staticmethod(_patch_masking_utils_source)+++class _ScipyDistnPatchingFinder:+ """Delegate-and-wrap finder for scipy.stats._distn_infrastructure.++ That module ends with:++ for obj in [s for s in dir() if s.startswith('_doc_')]:+ exec('del ' + obj)+ del obj++ In the PyInstaller bundle the list comprehension evaluates to empty+ (module-level dir() under the frozen importer returns a different scope+ than CPython's normal module-exec path — same class of bug as the+ torch._numpy._ufuncs crash). The for loop body doesn't run, `obj` is+ never bound, and the trailing `del obj` raises NameError at module load.++ This kills every downstream module: librosa (needed by nearly every TTS+ engine for mel filters) -> scipy.signal -> scipy.stats -> here.++ Workaround: delegate to the real loader, but pre-bind `obj = None` in the+ module namespace before its bytecode runs. If the for loop executes, each+ iteration overwrites the sentinel via STORE_NAME (normal behaviour). If it+ doesn't, `del obj` removes the sentinel and module load succeeds. The+ `_doc_*` cleanup this line was meant to do is purely cosmetic — those vars+ stay in the module namespace but nothing references them after this point.+ """++ _TARGET = "scipy.stats._distn_infrastructure"++ def find_spec(self, fullname, path=None, target=None):+ if fullname != self._TARGET:+ return None+ _diag(f"[scipy-finder] match: {fullname}, path={path!r}")+ # Delegate to the other finders to locate the real spec+ for finder in sys.meta_path:+ if finder is self:+ continue+ find = getattr(finder, "find_spec", None)+ if find is None:+ continue+ try:+ real_spec = find(fullname, path, target)+ except Exception as e:+ _diag(f"[scipy-finder] inner finder {type(finder).__name__} raised: {e}")+ continue+ if real_spec is None:+ continue+ if real_spec.loader is None:+ _diag(f"[scipy-finder] {type(finder).__name__} returned spec with loader=None")+ continue+ _diag(+ f"[scipy-finder] wrapped loader from "+ f"{type(finder).__name__} -> {type(real_spec.loader).__name__}"+ )+ real_spec.loader = _ScipyDistnPrebindLoader(real_spec.loader)+ return real_spec+ _diag("[scipy-finder] NO inner finder returned a spec")+ return None+++class _ScipyDistnPrebindLoader:+ """Thin wrapper that pre-binds `obj = None` before delegating to the+ real PyInstaller loader.++ Every other attribute/method delegates to the inner loader — PyiFrozenLoader+ is a rich FileLoader/ExecutionLoader with get_code/get_source/get_filename/+ is_package/get_resource_reader/etc., any of which Python's import machinery+ or 3rd-party code may call on spec.loader. Forwarding via __getattr__+ avoids breaking any of those paths (and preserves @_check_name contracts+ because the decorated methods run on the inner instance where self.name+ matches spec.name).+ """++ def __init__(self, inner):+ self._inner = inner++ def __getattr__(self, name):+ # __getattr__ fires only for attrs not already on self, so delegate+ # everything that isn't create_module/exec_module (or __getattr__/init).+ return getattr(self._inner, name)++ def create_module(self, spec):+ return self._inner.create_module(spec)++ def exec_module(self, module):+ # Compile scipy's module source with the problematic line patched.+ #+ # The real module ends with:+ # for obj in [s for s in dir() if s.startswith('_doc_')]:+ # exec('del ' + obj)+ # del obj+ #+ # Under PyInstaller's frozen importer, `del obj` raises NameError+ # even when we pre-populate module.__dict__['obj'] — the pre-compiled+ # .pyc bytecode interacts with the frame setup differently than a+ # fresh compile() from source. Easiest robust fix: read the source+ # and replace `del obj` with a safe variant before compiling.+ #+ # Requires the .py source to be bundled alongside the .pyc — see+ # backend/pyi_hooks/hook-scipy.stats._distn_infrastructure.py.+ source = None+ try:+ source = self._inner.get_source(module.__name__)+ except Exception as e:+ _diag(f"[scipy-loader] get_source failed: {e!r}")++ if source:+ patched = _patch_scipy_distn_source(source)+ _diag(+ f"[scipy-loader] source-patch path: patched={patched is not source}, "+ f"len={len(patched)}"+ )+ spec = module.__spec__+ if spec is not None and spec.submodule_search_locations is not None:+ module.__path__ = spec.submodule_search_locations+ filename = getattr(self._inner, "path", module.__name__)+ bytecode = compile(patched, filename, "exec")+ try:+ exec(bytecode, module.__dict__)+ except Exception as e:+ _diag(f"[scipy-loader] patched exec raised {type(e).__name__}: {e!r}")+ raise+ _diag(f"[scipy-loader] exec_module {module.__name__} OK (source-patched)")+ return++ # No source available — fall back to the pre-bind approach. This is+ # best-effort; if the frozen .pyc really does see a different `obj`+ # slot, this will still crash, but we've done all we can without+ # source.+ _diag("[scipy-loader] no source available; falling back to pre-bind")+ module.__dict__["obj"] = None+ self._inner.exec_module(module)+++def _install_dynamo_stub() -> None:+ stub = _NoopDynamoModule("torch._dynamo")+ # Mark as a package so `from torch._dynamo.X import Y` imports work+ # (Python's import machinery checks parent.__path__ before looking up+ # the child).+ stub.__path__ = []+ # torch._dynamo.config is accessed as a nested attribute namespace+ # (e.g. `torch._dynamo.config.capture_scalar_outputs = True`), so use+ # a permissive module so any attr read returns a no-op and sets succeed.+ stub.config = _NoopDynamoModule("torch._dynamo.config")+ stub.config.__path__ = []+ sys.modules["torch._dynamo"] = stub+ sys.modules["torch._dynamo.config"] = stub.config++ # Finders:+ # - torch._dynamo.* submodules -> no-op stubs+ # - transformers.utils.auto_docstring and+ # transformers.generation.candidate_generator -> no-op stubs (both+ # paths reach sklearn -> scipy.stats which trips a separate crash)+ # - scipy.stats._distn_infrastructure -> real load with `obj` pre-bound,+ # so librosa -> scipy.signal -> scipy.stats loads cleanly+ for _FinderCls in (+ _DynamoMetaPathFinder,+ _TransformersStubFinder,+ _ScipyDistnPatchingFinder,+ _MaskingUtilsFinder,+ ):+ try:+ sys.meta_path.insert(0, _FinderCls())+ _diag(f"installed finder: {_FinderCls.__name__}")+ except Exception as e:+ _diag(f"FAILED to install {_FinderCls.__name__}: {e!r}")+ _diag(+ "final sys.meta_path head: "+ + ", ".join(type(f).__name__ for f in sys.meta_path[:6])+ )++ # If torch is already imported, also set the attribute on the package so+ # `torch._dynamo` resolves to our stub without triggering torch.__getattr__+ # (which would lazy-import the real module and crash).+ torch_mod = sys.modules.get("torch")+ if torch_mod is not None:+ torch_mod._dynamo = stub+++try:+ _install_dynamo_stub()+except Exception as _e:+ # Best effort. If this fails the original NameError will surface when+ # transformers imports — no worse than not patching at all.+ _diag(f"_install_dynamo_stub FAILED: {_e!r}")++# NOTE: we deliberately do NOT import torch or torch.compiler here.+# Runtime hooks run before the app starts and before pyi_rth_numpy_compat+# has had a chance to patch torch.from_numpy (it runs in a background+# thread, waiting for torch to appear in sys.modules). Importing torch+# eagerly at hook time would trip the numpy ABI issue and kill the+# server process at startup.+#+# torch.compiler.disable does not need an explicit stub: its+# implementation is effectively `import torch._dynamo; return+# torch._dynamo.disable(fn, recursive, reason=reason)`, and since our+# stub is installed in sys.modules, that call resolves to our no-op+# _NoopDecorator pass-through.diff --git a/backend/voicebox-server.spec b/backend/voicebox-server.specindex c1acc541..ab8566c8 100644--- a/backend/voicebox-server.spec+++ b/backend/voicebox-server.spec@@ -5,7 +5,7 @@ from PyInstaller.utils.hooks import copy_metadatadatas = []binaries = []-hiddenimports = ['backend', 'backend.main', 'backend.config', 'backend.database', 'backend.models', 'backend.services.profiles', 'backend.services.history', 'backend.services.tts', 'backend.services.transcribe', 'backend.utils.platform_detect', 'backend.backends', 'backend.backends.pytorch_backend', 'backend.backends.qwen_custom_voice_backend', 'backend.utils.audio', 'backend.utils.cache', 'backend.utils.progress', 'backend.utils.hf_progress', 'backend.services.cuda', 'backend.services.effects', 'backend.utils.effects', 'backend.services.versions', 'pedalboard', 'chatterbox', 'chatterbox.tts_turbo', 'chatterbox.mtl_tts', 'backend.backends.chatterbox_backend', 'backend.backends.chatterbox_turbo_backend', 'backend.backends.luxtts_backend', 'zipvoice', 'zipvoice.luxvoice', 'torch', 'transformers', 'fastapi', 'uvicorn', 'sqlalchemy', 'soundfile', 'qwen_tts', 'qwen_tts.inference', 'qwen_tts.inference.qwen3_tts_model', 'qwen_tts.inference.qwen3_tts_tokenizer', 'qwen_tts.core', 'qwen_tts.cli', 'requests', 'pkg_resources.extern', 'backend.backends.hume_backend', 'tada', 'tada.modules', 'tada.modules.tada', 'tada.modules.encoder', 'tada.modules.decoder', 'tada.modules.aligner', 'tada.modules.acoustic_spkr_verf', 'tada.nn', 'tada.nn.vibevoice', 'tada.utils', 'tada.utils.gray_code', 'tada.utils.text', 'backend.utils.dac_shim', 'torchaudio', 'backend.backends.kokoro_backend', 'kokoro', 'kokoro.pipeline', 'kokoro.model', 'kokoro.istftnet', 'kokoro.modules', 'kokoro.custom_stft', 'en_core_web_sm', 'loguru', 'backend.backends.mlx_backend', 'mlx', 'mlx.core', 'mlx.nn', 'mlx_audio', 'mlx_audio.tts', 'mlx_audio.stt']+hiddenimports = ['backend', 'backend.main', 'backend.config', 'backend.database', 'backend.models', 'backend.services.profiles', 'backend.services.history', 'backend.services.tts', 'backend.services.transcribe', 'backend.utils.platform_detect', 'backend.backends', 'backend.backends.pytorch_backend', 'backend.backends.qwen_custom_voice_backend', 'backend.utils.audio', 'backend.utils.cache', 'backend.utils.progress', 'backend.utils.hf_progress', 'backend.services.cuda', 'backend.services.effects', 'backend.utils.effects', 'backend.services.versions', 'pedalboard', 'chatterbox', 'chatterbox.tts_turbo', 'chatterbox.mtl_tts', 'backend.backends.chatterbox_backend', 'backend.backends.chatterbox_turbo_backend', 'backend.backends.luxtts_backend', 'zipvoice', 'zipvoice.luxvoice', 'torch', 'transformers', 'fastapi', 'uvicorn', 'sqlalchemy', 'soundfile', 'qwen_tts', 'qwen_tts.inference', 'qwen_tts.inference.qwen3_tts_model', 'qwen_tts.inference.qwen3_tts_tokenizer', 'qwen_tts.core', 'qwen_tts.cli', 'requests', 'pkg_resources.extern', 'backend.backends.hume_backend', 'tada', 'tada.modules', 'tada.modules.tada', 'tada.modules.encoder', 'tada.modules.decoder', 'tada.modules.aligner', 'tada.modules.acoustic_spkr_verf', 'tada.nn', 'tada.nn.vibevoice', 'tada.utils', 'tada.utils.gray_code', 'tada.utils.text', 'backend.utils.dac_shim', 'torchaudio', 'backend.backends.kokoro_backend', 'en_core_web_sm', 'loguru', 'backend.backends.mlx_backend', 'mlx', 'mlx.core', 'mlx.nn', 'mlx_audio', 'mlx_audio.tts', 'mlx_audio.stt']datas += copy_metadata('qwen-tts')datas += copy_metadata('requests')datas += copy_metadata('transformers')@@ -18,6 +18,8 @@ hiddenimports += collect_submodules('jaraco')hiddenimports += collect_submodules('tada')hiddenimports += collect_submodules('mlx')hiddenimports += collect_submodules('mlx_audio')+tmp_ret = collect_all('spacy_pkuseg')+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]tmp_ret = collect_all('zipvoice')datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]tmp_ret = collect_all('linacodec')@@ -34,6 +36,8 @@ tmp_ret = collect_all('perth')datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]tmp_ret = collect_all('piper_phonemize')datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]+tmp_ret = collect_all('kokoro')+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]tmp_ret = collect_all('misaki')datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]tmp_ret = collect_all('language_tags')@@ -54,9 +58,9 @@ a = Analysis(binaries=binaries,datas=datas,hiddenimports=hiddenimports,- hookspath=[],+ hookspath=['pyi_hooks'],hooksconfig={},- runtime_hooks=[],+ runtime_hooks=['pyi_rth_numpy_compat.py', 'pyi_rth_torch_compiler_disable.py'],excludes=['nvidia', 'nvidia.cublas', 'nvidia.cuda_cupti', 'nvidia.cuda_nvrtc', 'nvidia.cuda_runtime', 'nvidia.cudnn', 'nvidia.cufft', 'nvidia.curand', 'nvidia.cusolver', 'nvidia.cusparse', 'nvidia.nccl', 'nvidia.nvjitlink', 'nvidia.nvtx'],noarchive=False,optimize=0,