| from __future__ import annotations |
|
|
| import ctypes |
| import os |
| import re |
| import shutil |
| import sys |
| import zipfile |
| from pathlib import Path |
|
|
|
|
| def _runtime_work_root(input_root: Path) -> Path: |
| explicit = os.environ.get("FISH_AUDIO_S2_RUNTIME_WORK_DIR") |
| if explicit: |
| return Path(explicit).expanduser().resolve() |
|
|
| root_text = str(input_root) |
| if root_text.startswith("/kaggle/input/"): |
| return Path(os.environ.get("FISH_AUDIO_S2_SCRATCH_ROOT", "/tmp/phorcys_fish_audio_s2_work")) / "phorcys_fish_audio_s2_runtime" / input_root.name |
|
|
| return input_root |
|
|
|
|
| def _contains_expected_payload(root: Path, target_name: str) -> bool: |
| if target_name == "pyLib": |
| return (root / "fish_audio_s2_runtime.py").exists() or (root / "fish_speech").exists() |
| if target_name == ".venv": |
| return (root / "bin" / "python").exists() or (root / "Scripts" / "python.exe").exists() |
| if target_name in {"native", "native-src"}: |
| return any(root.glob("**/s2")) or any(root.glob("**/*.so")) or any(root.glob("**/*.dylib")) or any(root.glob("**/*.pyd")) |
| return any(root.iterdir()) if root.exists() and root.is_dir() else False |
|
|
|
|
| def _coerce_archive_root(target: Path, target_name: str) -> Path: |
| if _contains_expected_payload(target, target_name): |
| return target |
|
|
| nested = target / target_name |
| if nested.exists() and nested.is_dir(): |
| return nested |
|
|
| visible_children = [child for child in target.iterdir() if child.name != ".phorcys-extracted.ok"] if target.exists() and target.is_dir() else [] |
| if len(visible_children) == 1 and visible_children[0].is_dir(): |
| nested = visible_children[0] |
| if _contains_expected_payload(nested, target_name): |
| return nested |
|
|
| return target |
|
|
|
|
| def _site_packages_matches_runtime(path: Path) -> bool: |
| match = re.search(r"python(\d+)\.(\d+)", str(path)) |
| if match is None: |
| return True |
| return (int(match.group(1)), int(match.group(2))) == (sys.version_info.major, sys.version_info.minor) |
|
|
|
|
| def _archive_fingerprint(archive: Path) -> str: |
| stat = archive.stat() |
| return f"{archive.name}:{stat.st_size}:{stat.st_mtime_ns}" |
|
|
|
|
| def _extract_archive(input_root: Path, work_root: Path, archive_names: tuple[str, ...], target_name: str, expanded_names: tuple[str, ...] = ()) -> Path: |
| for expanded_name in (target_name, *expanded_names): |
| mounted_target = input_root / expanded_name |
| if mounted_target.exists(): |
| return _coerce_archive_root(mounted_target, target_name) |
|
|
| target = work_root / target_name |
| for archive_name in archive_names: |
| archive = input_root / archive_name |
| if not archive.exists(): |
| continue |
|
|
| fingerprint = _archive_fingerprint(archive) |
| marker = target / ".phorcys-extracted.ok" |
| if target.exists() and marker.exists(): |
| try: |
| if marker.read_text(encoding="utf-8") == fingerprint: |
| return _coerce_archive_root(target, target_name) |
| except Exception: |
| pass |
|
|
| if target.exists(): |
| shutil.rmtree(target) |
| target.mkdir(parents=True, exist_ok=True) |
| with zipfile.ZipFile(archive, "r") as zip_file: |
| zip_file.extractall(target) |
| marker.write_text(fingerprint, encoding="utf-8") |
| return _coerce_archive_root(target, target_name) |
|
|
| if target.exists(): |
| return _coerce_archive_root(target, target_name) |
|
|
| return mounted_target |
|
|
|
|
| def _linux_soname_alias_names(file_name: str) -> list[str]: |
| match = re.match(r"^(lib.+?\.so)(?:\.(\d+)(?:\..*)?)?$", file_name) |
| if match is None: |
| return [] |
| base_name = match.group(1) |
| major_version = match.group(2) |
| aliases: list[str] = [] |
| if file_name != base_name: |
| aliases.append(base_name) |
| if major_version: |
| major_alias = f"{base_name}.{major_version}" |
| if file_name != major_alias: |
| aliases.append(major_alias) |
| elif file_name == base_name: |
| aliases.append(f"{base_name}.0") |
| return aliases |
|
|
|
|
| def _ensure_linux_soname_aliases(native_dir: Path) -> None: |
| if not sys.platform.startswith("linux") or not native_dir.exists(): |
| return |
| sources = [source for source in sorted(native_dir.glob("lib*.so*")) if source.is_file()] |
| for source in sources: |
| for alias_name in _linux_soname_alias_names(source.name): |
| alias = native_dir / alias_name |
| if alias.exists() or alias == source: |
| continue |
| try: |
| try: |
| alias.symlink_to(source.name) |
| except Exception: |
| shutil.copy2(source, alias) |
| except Exception: |
| continue |
|
|
|
|
| def _preload_linux_native_dependencies(native_dir: Path) -> None: |
| if not sys.platform.startswith("linux") or not native_dir.exists(): |
| return |
| _ensure_linux_soname_aliases(native_dir) |
| candidate_patterns = ( |
| "libggml.so*", |
| "libggml-base.so*", |
| "libggml-cpu.so*", |
| "libggml-cuda.so*", |
| "libggml*.so*", |
| "libllama.so*", |
| ) |
| candidates: list[Path] = [] |
| for pattern in candidate_patterns: |
| candidates.extend(sorted(native_dir.glob(pattern))) |
| seen: set[str] = set() |
| for candidate in candidates: |
| if not candidate.is_file() or candidate.name in seen: |
| continue |
| seen.add(candidate.name) |
| try: |
| ctypes.CDLL(str(candidate), mode=getattr(ctypes, "RTLD_GLOBAL", 0)) |
| except OSError: |
| continue |
|
|
|
|
| def _ensure_linux_executable_bits(native_dir: Path) -> None: |
| if not sys.platform.startswith("linux") or not native_dir.exists(): |
| return |
| for executable in native_dir.glob("**/s2"): |
| if not executable.is_file(): |
| continue |
| try: |
| executable.chmod(executable.stat().st_mode | 0o755) |
| except Exception: |
| continue |
|
|
|
|
| def _ensure_fish_speech_project_root_markers(paths: list[Path]) -> list[str]: |
| markers: list[str] = [] |
| candidates: list[Path] = [] |
| for root in paths: |
| if not root.exists(): |
| continue |
| package_dir = root / "fish_speech" |
| if package_dir.exists() and package_dir.is_dir(): |
| candidates.append(package_dir) |
| if root.name == "fish_speech" and root.is_dir(): |
| candidates.append(root) |
|
|
| seen: set[str] = set() |
| for package_dir in candidates: |
| for marker_root in (package_dir.parent, package_dir): |
| marker = marker_root / ".project-root" |
| key = str(marker) |
| if key in seen: |
| continue |
| seen.add(key) |
| try: |
| if not marker.exists(): |
| marker.write_text("phorcys generated marker for pip-installed fish-speech runtime\n", encoding="utf-8") |
| markers.append(key) |
| except Exception: |
| continue |
| return markers |
|
|
|
|
| def activate(runtime_root: str | os.PathLike[str] | None = None) -> Path: |
| input_root = Path(runtime_root).resolve() if runtime_root else Path(__file__).resolve().parent |
| work_root = _runtime_work_root(input_root) |
| work_root.mkdir(parents=True, exist_ok=True) |
|
|
| py_lib = _extract_archive(input_root, work_root, ("pyLib.phzip", "pyLib.zip"), "pyLib") |
| _extract_archive(input_root, work_root, ("requirements.phzip", "requirements.zip"), "requirements") |
| _extract_archive(input_root, work_root, ("native.phzip", "native.zip"), "native") |
| _extract_archive(input_root, work_root, ("native-src.phzip", "native-src.zip"), "native-src") |
| _extract_archive(input_root, work_root, ("stressLexicons.phzip", "stressLexicons.zip"), "stressLexicons") |
| _extract_archive(input_root, work_root, ("wheelhouse.phzip", "wheelhouse.zip"), "wheelhouse") |
| _extract_archive(input_root, work_root, ("models.phzip", "models.zip"), "models") |
| venv_root = _extract_archive(input_root, work_root, ("dot-venv.phzip", "dot-venv.zip", ".venv.zip", "venv.zip"), ".venv", ("dot-venv", "venv")) |
|
|
| vendor = py_lib / "vendor" |
| site_candidates = [] |
| site_candidates.extend((venv_root / "lib").glob("python*/site-packages")) |
| site_candidates.append(venv_root / "Lib" / "site-packages") |
| for candidate in site_candidates: |
| if candidate.exists() and _site_packages_matches_runtime(candidate): |
| text = str(candidate) |
| if text not in sys.path: |
| sys.path.insert(0, text) |
| source_roots = [vendor / "sglang-omni", vendor / "sglang_omni"] |
| for candidate in (py_lib, vendor, *source_roots): |
| if candidate.exists(): |
| text = str(candidate) |
| if text not in sys.path: |
| sys.path.insert(0, text) |
|
|
| native_dirs = [ |
| vendor / "fish_speech", |
| py_lib / "vendor" / "fish_speech", |
| input_root / "native", |
| input_root / "lib", |
| input_root / "libs", |
| work_root / "native", |
| work_root / "lib", |
| work_root / "libs", |
| ] |
| expanded_native_dirs: list[Path] = [] |
| for native_root in (input_root / "native", work_root / "native"): |
| if native_root.exists(): |
| expanded_native_dirs.append(native_root) |
| expanded_native_dirs.extend([child for child in native_root.glob("**") if child.is_dir() and (any(child.glob("s2")) or any(child.glob("*.so*")))]) |
| existing_native_dirs = [] |
| seen_native_dirs: set[str] = set() |
| for path in [*native_dirs, *expanded_native_dirs]: |
| if not path.exists(): |
| continue |
| key = str(path.resolve()) |
| if key in seen_native_dirs: |
| continue |
| seen_native_dirs.add(key) |
| existing_native_dirs.append(path) |
| if existing_native_dirs: |
| old = os.environ.get("LD_LIBRARY_PATH", "") |
| os.environ["LD_LIBRARY_PATH"] = os.pathsep.join([str(path) for path in existing_native_dirs] + ([old] if old else [])) |
| old_windows = os.environ.get("FISH_AUDIO_S2_NATIVE_DLL_DIRS", "") |
| os.environ["FISH_AUDIO_S2_NATIVE_DLL_DIRS"] = os.pathsep.join([str(path) for path in existing_native_dirs] + ([old_windows] if old_windows else [])) |
| os.environ["FISH_AUDIO_S2_RUNTIME_NATIVE_DIRS"] = os.pathsep.join(str(path) for path in existing_native_dirs) |
| for native_dir in existing_native_dirs: |
| _ensure_linux_executable_bits(native_dir) |
| _ensure_linux_soname_aliases(native_dir) |
| _preload_linux_native_dependencies(native_dir) |
|
|
| os.environ["FISH_AUDIO_S2_RUNTIME_ACTIVATED_ROOT"] = str(work_root) |
| _ensure_fish_speech_project_root_markers([py_lib, vendor, *site_candidates]) |
| return work_root |
|
|
|
|
| if __name__ == "__main__": |
| activated = activate(sys.argv[1] if len(sys.argv) > 1 else None) |
| print(f"activated={activated}") |
| print("sys.path[0:8]=" + repr(sys.path[:8])) |
