| from __future__ import annotations |
|
|
| import importlib |
| import json |
| import os |
| import shutil |
| import sys |
| import types |
| from pathlib import Path |
| from typing import Any |
|
|
| import runtime_bootstrap |
|
|
| root = runtime_bootstrap.activate(Path(__file__).resolve().parent) |
|
|
|
|
| def probe_ptxas() -> dict[str, object]: |
| """Return ptxas discovery diagnostics for optimized TorchInductor/Triton CUDA warmup.""" |
| report: dict[str, object] = {"checked": True, "found": False, "candidates": []} |
| raw_candidates: list[Path] = [] |
| for env_name in ("TRITON_PTXAS_PATH", "PTXAS_PATH"): |
| env_value = os.environ.get(env_name) |
| if env_value: |
| raw_candidates.append(Path(env_value)) |
| path_hit = shutil.which("ptxas") |
| if path_hit: |
| raw_candidates.append(Path(path_hit)) |
| raw_candidates.extend([ |
| Path("/usr/local/cuda/bin/ptxas"), |
| Path("/opt/conda/bin/ptxas"), |
| Path("/usr/bin/ptxas"), |
| ]) |
| for search_root in [root, Path(sys.prefix), Path.cwd()]: |
| for pattern in ("**/nvidia/cuda_nvcc/bin/ptxas", "**/cuda_nvcc/bin/ptxas", "**/ptxas"): |
| try: |
| raw_candidates.extend(search_root.glob(pattern)) |
| except OSError: |
| continue |
| seen: set[str] = set() |
| for candidate in raw_candidates: |
| try: |
| key = str(candidate.resolve()) |
| except OSError: |
| key = str(candidate) |
| if key in seen: |
| continue |
| seen.add(key) |
| item = {"path": key, "exists": candidate.exists(), "executable": candidate.is_file() and os.access(candidate, os.X_OK)} |
| report["candidates"].append(item) |
| if item["executable"] and not report["found"]: |
| report["found"] = True |
| report["path"] = key |
| os.environ["TRITON_PTXAS_PATH"] = key |
| os.environ["PTXAS_PATH"] = key |
| return report |
|
|
|
|
| def probe_pyopenssl_compat() -> dict[str, object]: |
| """Return pyOpenSSL/cryptography import status for ABI diagnostics.""" |
| report: dict[str, object] = {"checked": True, "ok": False} |
| try: |
| import cryptography |
| import OpenSSL |
| import OpenSSL.crypto |
| report["ok"] = True |
| report["cryptography_version"] = getattr(cryptography, "__version__", None) |
| report["pyopenssl_version"] = getattr(OpenSSL, "__version__", None) |
| except Exception as exc: |
| report["error"] = repr(exc) |
| return report |
|
|
|
|
| def install_text_normalizer_fallback() -> dict[str, object]: |
| """Install no-op tn.* modules before importing dots_tts.runtime. |
| |
| WeTextProcessing is intentionally optional for this payload because pynini/OpenFst |
| native artifacts are brittle in portable Kaggle datasets. The verifier must match |
| the runner: it validates that DotsTTS can import with a deterministic no-op tn.* |
| compatibility package when the real package is absent. |
| """ |
| report: dict[str, object] = {"installed": False, "real_package": False} |
| try: |
| import tn.chinese.normalizer as chinese_normalizer |
| import tn.english.normalizer as english_normalizer |
| report["real_package"] = not ( |
| getattr(chinese_normalizer, "_phorcys_noop_normalizer", False) |
| or getattr(english_normalizer, "_phorcys_noop_normalizer", False) |
| ) |
| report["installed"] = True |
| return report |
| except ModuleNotFoundError: |
| pass |
|
|
| class _NoOpNormalizer: |
| """Minimal Normalizer replacement returning the input text unchanged.""" |
|
|
| def __init__(self, *args: Any, **kwargs: Any) -> None: |
| del args, kwargs |
|
|
| def normalize(self, text: str) -> str: |
| """Return text unchanged while preserving WeTextProcessing's API shape.""" |
| return text |
|
|
| tn_module = sys.modules.get("tn") or types.ModuleType("tn") |
| chinese_module = sys.modules.get("tn.chinese") or types.ModuleType("tn.chinese") |
| english_module = sys.modules.get("tn.english") or types.ModuleType("tn.english") |
| generic_normalizer = types.ModuleType("tn.normalizer") |
| chinese_normalizer = types.ModuleType("tn.chinese.normalizer") |
| english_normalizer = types.ModuleType("tn.english.normalizer") |
| for module in (tn_module, chinese_module, english_module): |
| module.__dict__.setdefault("__path__", []) |
| for module in (generic_normalizer, chinese_normalizer, english_normalizer): |
| module.Normalizer = _NoOpNormalizer |
| module.__dict__["_phorcys_noop_normalizer"] = True |
| chinese_module.normalizer = chinese_normalizer |
| english_module.normalizer = english_normalizer |
| tn_module.normalizer = generic_normalizer |
| tn_module.chinese = chinese_module |
| tn_module.english = english_module |
| sys.modules["tn"] = tn_module |
| sys.modules["tn.normalizer"] = generic_normalizer |
| sys.modules["tn.chinese"] = chinese_module |
| sys.modules["tn.english"] = english_module |
| sys.modules["tn.chinese.normalizer"] = chinese_normalizer |
| sys.modules["tn.english.normalizer"] = english_normalizer |
| report["installed"] = True |
| report["fallback"] = True |
| return report |
|
|
|
|
| def patch_transformers_qwen2_compat() -> dict[str, object]: |
| """Expose Qwen2ForCausalLM on transformers top-level when required by dots.tts.""" |
| report: dict[str, object] = {"attempted": False, "patched": False} |
| report["pyopenssl_compat"] = probe_pyopenssl_compat() |
| try: |
| import transformers |
| report["transformers_version"] = getattr(transformers, "__version__", None) |
| report["has_top_level_before"] = hasattr(transformers, "Qwen2ForCausalLM") |
| if report["has_top_level_before"]: |
| return report |
| report["attempted"] = True |
| from transformers.models.qwen2.modeling_qwen2 import Qwen2ForCausalLM |
| setattr(transformers, "Qwen2ForCausalLM", Qwen2ForCausalLM) |
| report["patched"] = True |
| report["class_module"] = getattr(Qwen2ForCausalLM, "__module__", None) |
| except Exception as exc: |
| report["error"] = repr(exc) |
| return report |
|
|
|
|
| ptxas_report = probe_ptxas() |
| text_normalizer_report = install_text_normalizer_fallback() |
| qwen2_report = patch_transformers_qwen2_compat() |
| mods = [ |
| "torch", |
| "transformers", |
| "google.oauth2.service_account", |
| "google.auth.transport.requests", |
| "requests", |
| "cryptography", |
| "OpenSSL", |
| "OpenSSL.crypto", |
| "kaggle", |
| "numpy", |
| "soundfile", |
| "tokenizers", |
| "lingua", |
| "lingua.lingua", |
| "tn.chinese.normalizer", |
| "tn.english.normalizer", |
| "dots_tts", |
| "dots_tts.runtime", |
| ] |
| report = { |
| "root": str(root), |
| "python": sys.version.split()[0], |
| "executable": sys.executable, |
| "qwen2_compat": qwen2_report, |
| "text_normalizer": text_normalizer_report, |
| "ptxas": ptxas_report, |
| "imports": {}, |
| } |
| for name in mods: |
| try: |
| module = importlib.import_module(name) |
| report["imports"][name] = {"ok": True, "file": getattr(module, "__file__", None)} |
| except Exception as exc: |
| report["imports"][name] = {"ok": False, "error": repr(exc)} |
| print(json.dumps(report, ensure_ascii=False, indent=2)) |
| if not all(item["ok"] for item in report["imports"].values()): |
| sys.exit(1) |
| if not qwen2_report.get("patched") and not qwen2_report.get("has_top_level_before"): |
| sys.exit(2) |
