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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# 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