verify_runtime.py

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  # noqa: F401
        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  # noqa: F401
        import tn.english.normalizer as english_normalizer  # noqa: F401
        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)