Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

10.3 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.

"""Pre-load unsloth_zoo.device_type with torch.cuda.is_available mocked, so its @cache captures cuda."""

from __future__ import annotations

# Must run before torch is imported anywhere below, so it is not a fixture.
import importlib.util as _ilu  # noqa: E402
import pathlib as _pathlib  # noqa: E402

_iso = _pathlib.Path(__file__).resolve()
for _up in _iso.parents:
    _candidate = _up / "tests" / "_shared" / "compile_cache_isolation.py"
    if _candidate.is_file():
        _spec = _ilu.spec_from_file_location("_unsloth_compile_cache_isolation", _candidate)
        _mod = _ilu.module_from_spec(_spec)
        _spec.loader.exec_module(_mod)  # sets the env vars on import
        break

# One CPU share per xdist worker, set before torch is imported: otherwise each worker starts a
# torch/OpenMP pool as wide as the machine, slowing CPU training tests; an explicit thread setting
# is kept; loaded by path because tests/_shared is only put on sys.path below.
import os as _os  # noqa: E402

# The suite predates the CPU training backend: a GPU-less runner must keep refusing `import unsloth`
# (so GPU-path tests skip there, as before) and stubbed-torch tests must not inherit this host's
# CPU-fallback answer. tests/test_cpu_backend_init.py removes it to exercise the backend itself.
_os.environ.setdefault("UNSLOTH_DISABLE_CPU_FALLBACK", "1")

_share_path = _iso.parent / "_shared" / "xdist_cpu_share.py"
if _share_path.is_file():
    _spec = _ilu.spec_from_file_location("xdist_cpu_share", _share_path)
    _mod = _ilu.module_from_spec(_spec)
    _spec.loader.exec_module(_mod)
    _mod.apply(_os.environ)

# --- shared test helpers on sys.path -----------------------------------------------
# tests/_shared holds no package marker and pytest only puts a *test file's* own
# directory on sys.path, so tests/python/, tests/studio/install/ and tests/security/
# cannot reach it by import. Adding it here (this conftest is collected for anything
# under tests/) is what lets all four levels share one module rather than each growing
# a private copy -- see tests/_shared/unsloth_pwsh_runner.py for the case that forced it.
import sys as _sys  # noqa: E402

_shared_dir = _iso.parent / "_shared"
if _shared_dir.is_dir() and str(_shared_dir) not in _sys.path:
    _sys.path.insert(0, str(_shared_dir))

# pytest 9.2's monkeypatch deletes a torch config entry on undo instead of restoring it; see torch_config_guard.py.
from torch_config_guard import install_monkeypatch_fix  # noqa: E402

install_monkeypatch_fix()

import importlib.util
import os
import sys
import types

import pytest

# A test that hides nvidia-smi to fake a CPU host must not find the real GPUs through NVML.
os.environ.setdefault("UNSLOTH_NVIDIA_LIBRARY_PROBE", "0")
# A fake CPU host must not take the Vulkan route through this machine's real GPUs.
os.environ.setdefault("UNSLOTH_VULKAN_DEVICE_PROBE", "0")


@pytest.fixture(autouse = True)
def _contain_installer_venv_root(tmp_path_factory, monkeypatch):
    """Imported in the body because tests/_shared is added to sys.path further down this file."""
    from installer_venv_root import contain_installer_venv_root
    contain_installer_venv_root(monkeypatch, tmp_path_factory)


@pytest.fixture(autouse = True)
def _no_deleted_torch_config_entries():
    """A test that leaves a dynamo / inductor config entry deleted errors at its own teardown; see
    tests/_shared/torch_config_guard.py."""
    from torch_config_guard import check_after_test, install_delete_recorder

    install_delete_recorder()
    yield
    check_after_test()


@pytest.fixture(autouse = True)
def _fresh_parallel_layout():
    """unsloth.models.tp_env reads the UNSLOTH_TP_SIZE / UNSLOTH_PARALLEL layout once per process. A test
    that read it under another environment would hand every later test in its worker that stale layout,
    so each test starts with it unread. Only when the module is already imported: no unsloth import here."""
    tp_env = sys.modules.get("unsloth.models.tp_env")
    if tp_env is not None:
        tp_env._reset_env_layout()


@pytest.fixture(autouse = True)
def _fresh_new_mapper_cache():
    """Reset loader_utils' process-wide mapper cache; never imports unsloth."""
    loader_utils = sys.modules.get("unsloth.models.loader_utils")
    if loader_utils is not None and hasattr(loader_utils, "_NEW_MAPPER_CACHE"):
        loader_utils._NEW_MAPPER_CACHE["entry"] = None


@pytest.hookimpl(trylast = True)
def pytest_collection_modifyitems(config, items):
    """After xdist tags grouped tests; see tests/_shared/xdist_group_check.py."""
    from xdist_group_check import check
    check(config, items)


def _has_real_accelerator() -> bool:
    """Calls the probe before any spoof; the name is pinned by a test that reads this file's AST."""
    from real_accelerator import has_real_accelerator
    return has_real_accelerator()


def _preload_device_type(package: str, prereqs: tuple[str, ...] = ()) -> bool:
    """Pre-load <package>.device_type under a mocked is_available()==True so its
    @cache captures "cuda"; prereqs are submodules to load first (e.g. 'utils').
    Returns False if anything is unimportable, so the caller falls back to a stub."""
    target = f"{package}.device_type"
    if target in sys.modules:
        return True
    pkg_spec = importlib.util.find_spec(package)
    if pkg_spec is None or not pkg_spec.submodule_search_locations:
        return False
    pkg_path = pkg_spec.submodule_search_locations[0]

    skeleton_already = package in sys.modules
    if not skeleton_already:
        skel = types.ModuleType(package)
        skel.__path__ = [pkg_path]
        skel.__spec__ = pkg_spec
        skel.__package__ = package
        sys.modules[package] = skel

    try:
        for prereq in prereqs:
            full = f"{package}.{prereq}"
            if full in sys.modules:
                continue
            prereq_path = os.path.join(pkg_path, f"{prereq}.py")
            prereq_spec = importlib.util.spec_from_file_location(full, prereq_path)
            prereq_mod = importlib.util.module_from_spec(prereq_spec)
            sys.modules[full] = prereq_mod
            prereq_spec.loader.exec_module(prereq_mod)

        device_type_path = os.path.join(pkg_path, "device_type.py")
        dt_spec = importlib.util.spec_from_file_location(target, device_type_path)
        dt_mod = importlib.util.module_from_spec(dt_spec)
        sys.modules[target] = dt_mod

        import torch

        _orig_is_avail = torch.cuda.is_available
        torch.cuda.is_available = lambda: True  # type: ignore[assignment]
        try:
            dt_spec.loader.exec_module(dt_mod)
        finally:
            torch.cuda.is_available = _orig_is_avail
    except Exception:
        sys.modules.pop(target, None)
        return False
    finally:
        if not skeleton_already:
            sys.modules.pop(package, None)

    return True


def _patch_torch_cuda_for_import() -> None:
    """Stubs the torch.cuda.* probes that fire at import once DEVICE_TYPE is forced to cuda,
    returning plausible Ampere values so the import finishes; real-tensor tests still run on CPU."""
    try:
        import torch.cuda.memory as _cuda_memory  # type: ignore

        # Zero free is an exhausted card, which callers treat as fatal.
        _cuda_memory.mem_get_info = lambda *a, **k: (60 * 1024**3, 80 * 1024**3)
    except Exception:
        pass
    try:
        import torch
        torch.cuda.get_device_capability = lambda *a, **k: (8, 0)
        torch.cuda.is_bf16_supported = lambda *a, **k: True
    except Exception:
        pass


def _install_device_type_stub(name: str) -> None:
    stub = types.ModuleType(name)
    stub.DEVICE_TYPE = "cuda"
    stub.DEVICE_TYPE_TORCH = "cuda"
    stub.DEVICE_COUNT = 1
    stub.ALLOW_PREQUANTIZED_MODELS = False
    stub.is_hip = lambda: False
    stub.get_device_type = lambda: "cuda"
    stub.get_device_count = lambda: 1
    stub.device_synchronize = lambda *a, **k: None
    stub.device_empty_cache = lambda *a, **k: None
    stub.device_is_bf16_supported = lambda *a, **k: False
    stub.arch_lacks_bf16 = lambda arch: (
        str(arch or "").split(":", 1)[0].strip().lower().startswith("gfx10")
    )
    # gfx101x (RDNA1) only; gfx103x (RDNA2) must not match.
    stub.arch_lacks_buffer_ops = lambda arch: (
        str(arch or "").split(":", 1)[0].strip().lower().startswith("gfx101")
    )
    stub.apply_gfx101x_triton_workaround = lambda *a, **k: False
    stub.gfx101x_triton_workaround_applied = lambda: False
    stub.hip_visible_archs = lambda: []
    stub.cuda_visible_capabilities = lambda *a, **k: []
    stub.cuda_gate_capabilities = lambda: []
    stub.cuda_current_capability = lambda: None
    stub.cuda_bf16_capability = lambda: None
    stub.distributed_launch = lambda: False
    stub.apply_pre_volta_compile_workaround = lambda *a, **k: False
    stub.hip_current_arch = lambda: ""
    stub.arch_breaks_compile = lambda arch: False
    stub.cuda_order_mismatch_names = lambda: []
    stub.xpu_supports_native_bf16 = lambda: True
    stub.zoo_shares_xpu_bf16 = lambda: False
    sys.modules[name] = stub


def _preimport_bitsandbytes() -> None:
    """Import bitsandbytes before the CUDA spoof; inside it, a CPU-only torch raises AttributeError."""
    try:
        import bitsandbytes  # noqa: F401
    except Exception:
        pass


if not _has_real_accelerator():
    _preimport_bitsandbytes()
    if not _preload_device_type("unsloth_zoo", prereqs = ("utils",)):
        _install_device_type_stub("unsloth_zoo.device_type")
    if not _preload_device_type("unsloth"):
        _install_device_type_stub("unsloth.device_type")
    _patch_torch_cuda_for_import()


# Import unsloth to apply its import-time upstream-drift fixes; ImportError is swallowed.


def _apply_upstream_import_fixes_for_tests() -> None:
    try:
        import unsloth  # noqa: F401  # runs unsloth/import_fixes.py
    except Exception:
        pass


_apply_upstream_import_fixes_for_tests()


@pytest.fixture(scope = "session")
def _kernel_lock_dir(tmp_path_factory):
    return str(tmp_path_factory.mktemp("kernel-locks"))


@pytest.fixture(autouse = True)
def _isolated_kernel_install_locks(monkeypatch, _kernel_lock_dir):
    # Tests never take (or create) the environment's real kernel install locks.
    monkeypatch.setenv("UNSLOTH_KERNEL_LOCK_DIR", _kernel_lock_dir)