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.8 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

"""Owner-held switch for whether managed accounts may point a provider connection at a private address."""

from __future__ import annotations

import os
import threading
import time
from typing import Any

MANAGED_PRIVATE_PROVIDER_URLS_SETTING_KEY = "managed_private_provider_urls_allowed"
DEFAULT_MANAGED_PRIVATE_PROVIDER_URLS_ALLOWED = False

# Blocks private addresses for every account, owner included; outranks the stored preference, so an env setting is not undone from a settings page.
BLOCK_PRIVATE_ENV = "UNSLOTH_STUDIO_BLOCK_PRIVATE_PROVIDER_URLS"

# Cache briefly: each uncached read costs a SQLite connection on the shared loop.
_CACHE_TTL_SECONDS = 1.0
_cache_lock = threading.Lock()
_cached: tuple[float, bool] | None = None
# Bumped by every write so an older read cannot publish stale state; otherwise a disable keeps allowing private egress for the rest of the TTL.
_generation = 0


def _remembered() -> bool | None:
    with _cache_lock:
        if _cached is not None and _cached[0] > time.monotonic():
            return _cached[1]
    return None


def _remember(value: bool, generation: int) -> None:
    global _cached
    with _cache_lock:
        if generation != _generation:
            return
        _cached = (time.monotonic() + _CACHE_TTL_SECONDS, value)


def forget_cached_setting() -> None:
    """Drop the held answer and retire any read already in flight. Called on write."""
    global _cached, _generation
    with _cache_lock:
        _cached = None
        _generation += 1


def _coerce_bool(value: Any) -> bool | None:
    if isinstance(value, bool):
        return value
    if isinstance(value, str):
        normalized = value.strip().lower()
        if normalized in {"1", "true", "yes", "on"}:
            return True
        if normalized in {"0", "false", "no", "off", ""}:
            return False
    return None


def private_urls_locked_by_environment() -> bool:
    """True when the shared-host environment opt-in decides this, whatever the stored preference."""
    return os.environ.get(BLOCK_PRIVATE_ENV) == "1"


def get_managed_private_provider_urls_allowed() -> bool:
    """Installation-wide, read from the owner store; a missing setting keeps the refusal, an unreadable one fails closed so managed accounts cannot widen reach."""
    if private_urls_locked_by_environment():
        return False
    held = _remembered()
    if held is not None:
        return held
    with _cache_lock:
        generation = _generation
    try:
        from storage.studio_db import get_app_setting
        from utils.account_context import OWNER, run_as
        stored = run_as(OWNER, get_app_setting, MANAGED_PRIVATE_PROVIDER_URLS_SETTING_KEY, None)
    except Exception:  # noqa: BLE001 - an unreadable settings DB keeps the stricter answer
        return False
    parsed = _coerce_bool(stored)
    allowed = parsed if parsed is not None else DEFAULT_MANAGED_PRIVATE_PROVIDER_URLS_ALLOWED
    _remember(allowed, generation)
    return allowed


def set_managed_private_provider_urls_allowed(value: Any) -> bool:
    """Persist whether managed accounts may dial private provider addresses."""
    parsed = _coerce_bool(value)
    if parsed is None:
        raise ValueError("The managed-account private provider URL setting must be true or false.")

    from storage.studio_db import upsert_app_settings
    from utils.account_context import OWNER, run_as

    # Owner-bound like the read: the two halves have to name one store.
    run_as(OWNER, upsert_app_settings, {MANAGED_PRIVATE_PROVIDER_URLS_SETTING_KEY: parsed})
    # Dropped, not replaced with `parsed`: a write that did not land must not be believed.
    forget_cached_setting()
    return parsed