"""Optional provider adapters. There are none, by design. The recovered TasteForge flow used Fal for vision distillation, image-to-3D, reference-to-video generation, and hosted ffmpeg composition. In this repeatable lane those become *optional adapters* that FAIL CLOSED: * the default registry is empty; * looking up a provider raises before any network-capable module is imported; * even opting in requires BOTH an explicit runtime registration with ``authorize=True`` AND the ``TASTEFORGE_ALLOW_PROVIDERS`` environment flag, and no adapter ships with this package. Nothing in this module (or package) imports fal_client, urllib, sockets, or any other network facility. """ from __future__ import annotations import os from typing import Any, Callable ALLOW_ENV = "TASTEFORGE_ALLOW_PROVIDERS" _FAIL_CLOSED_MESSAGE = ( "provider {provider!r} is not available: provider generation in " "TasteForge requires explicit separately authorized execution. This " "package ships no provider adapters and performs no network calls; the " "deterministic offline workflows (inspect/validate/interview/distill " "dry-run/apply local/export) need no provider." ) class ProviderNotAuthorizedError(RuntimeError): """Raised before any provider interaction when access is not authorized.""" AdapterFactory = Callable[[], Any] def list_providers() -> list[str]: """Registered provider ids. Always empty in this lane.""" return sorted(_REGISTRY) def get(provider: str) -> Any: """Return the adapter for ``provider`` or fail closed. Fails closed - raising before any import or I/O - unless the provider was explicitly registered with authorization AND the opt-in environment flag is set. No provider is ever registered by this package. """ entry = _REGISTRY.get(provider) if entry is None or not entry.get("authorized"): raise ProviderNotAuthorizedError(_FAIL_CLOSED_MESSAGE.format(provider=provider)) if os.environ.get(ALLOW_ENV, "").strip().lower() not in {"1", "true", "yes", "on"}: raise ProviderNotAuthorizedError(_FAIL_CLOSED_MESSAGE.format(provider=provider)) return entry["factory"]() def register( provider: str, callable_factory: AdapterFactory, *, authorize: bool = False, ) -> None: """Register an adapter factory. Refuses silent authorization. ``authorize=True`` without the ``TASTEFORGE_ALLOW_PROVIDERS`` environment flag is still a refusal: enabling a provider is a two-step deliberate act, never a default. """ if not authorize: raise ProviderNotAuthorizedError( _FAIL_CLOSED_MESSAGE.format(provider=provider) ) _REGISTRY[provider] = {"factory": callable_factory, "authorized": True} def reset() -> None: """Clear the registry (test helper).""" _REGISTRY.clear() _REGISTRY: dict[str, dict[str, Any]] = {}