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.

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

import itertools
import sys
import types


class _BaseModel:
    def __init__(self, **kwargs):
        for name, value in self.__class__.__dict__.items():
            if name.startswith("_") or callable(value):
                continue
            if name not in kwargs:
                setattr(self, name, value)
        for key, value in kwargs.items():
            setattr(self, key, value)

    def model_dump(self):
        return dict(self.__dict__)

    def model_copy(self, update = None):
        data = self.model_dump()
        if update:
            data.update(update)
        return self.__class__(**data)


def _field(default = ..., **kwargs):
    if "default_factory" in kwargs:
        return kwargs["default_factory"]()
    return None if default is ... else default


def _model_validator(*args, **kwargs):
    def decorator(fn):
        return fn

    return decorator


class _HTTPException(Exception):
    def __init__(
        self,
        status_code: int,
        detail = None,
    ):
        super().__init__(detail)
        self.status_code = status_code
        self.detail = detail


class _APIRouter:
    def get(self, *args, **kwargs):
        return lambda fn: fn

    def post(self, *args, **kwargs):
        return lambda fn: fn

    def delete(self, *args, **kwargs):
        return lambda fn: fn


def _fastapi_marker(
    default = None,
    *args,
    **kwargs,
):
    return default


class _DummyLogger:
    def __getattr__(self, _name):
        return lambda *args, **kwargs: None


def _stub_unless_installed(name: str, stub) -> None:
    """Stub only when truly not installed; stubs are never removed and would shadow later real imports."""
    if name in sys.modules:
        return
    try:
        __import__(name)
    except ImportError:
        sys.modules[name] = stub


_stub_unless_installed(
    "pydantic",
    types.SimpleNamespace(
        BaseModel = _BaseModel,
        Field = _field,
        PrivateAttr = _field,
        model_validator = _model_validator,
    ),
)
_stub_unless_installed(
    "fastapi",
    types.SimpleNamespace(
        APIRouter = _APIRouter,
        Body = _fastapi_marker,
        Depends = _fastapi_marker,
        Header = _fastapi_marker,
        HTTPException = _HTTPException,
        Query = _fastapi_marker,
        UploadFile = object,
    ),
)
sys.modules.setdefault(
    "loggers",
    types.SimpleNamespace(get_logger = lambda *args, **kwargs: _DummyLogger()),
)
sys.modules.setdefault(
    "structlog",
    types.SimpleNamespace(
        BoundLogger = _DummyLogger,
        get_logger = lambda *args, **kwargs: _DummyLogger(),
    ),
)


import pytest


@pytest.fixture(scope = "session")
def _hub_studio_home_root(tmp_path_factory):
    """Create the parent once per session: mktemp rescans basetemp on each call, which is quadratic."""
    return tmp_path_factory.mktemp("hub_studio_homes")


_studio_home_counter = itertools.count()


@pytest.fixture(autouse = True)
def _isolate_studio_home(_hub_studio_home_root, monkeypatch):
    home = _hub_studio_home_root / f"home-{next(_studio_home_counter)}"
    home.mkdir()
    monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(home))
    for name, module in tuple(sys.modules.items()):
        if name.startswith(("storage.", "hub.storage.")) and hasattr(module, "_schema_ready"):
            monkeypatch.setattr(module, "_schema_ready", set())


@pytest.fixture(autouse = True)
def _reset_optional_module_memo():
    """Clear the optional-module memo between tests so one test's fake module cannot answer the next."""
    try:
        import utils.hf_xet_fallback as _shim
    except Exception:  # noqa: BLE001 - hub tests run against stubbed modules
        yield
        return
    _shim._reset_optional_module_cache()
    yield
    _shim._reset_optional_module_cache()