Spaces:
Running
Running
File size: 5,494 Bytes
9f6a4bd e99df76 691dc7c 2415446 691dc7c 2415446 691dc7c 2415446 691dc7c 2415446 a9e27c0 2415446 691dc7c a9e27c0 691dc7c f7872b8 691dc7c f7872b8 a9e27c0 691dc7c 2415446 691dc7c f7872b8 691dc7c f7872b8 a9e27c0 691dc7c f7872b8 691dc7c a9e27c0 a1bab2d 2415446 691dc7c a9e27c0 f7872b8 a1bab2d 2415446 a9e27c0 691dc7c 2415446 a1bab2d f7872b8 691dc7c 2415446 f7872b8 2415446 f7872b8 2415446 691dc7c f7872b8 691dc7c f7872b8 691dc7c f7872b8 691dc7c f7872b8 691dc7c f7872b8 691dc7c a9e27c0 691dc7c f7872b8 691dc7c 2415446 691dc7c 2415446 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | from __future__ import annotations
"""One closable generation of lazily constructed provider clients."""
import asyncio
from collections.abc import Awaitable, Callable, Mapping, MutableMapping
from functools import partial
from typing import TYPE_CHECKING
from free_claude_code.application.errors import ApplicationUnavailableError
from free_claude_code.config.settings import Settings
from free_claude_code.core.async_tasks import run_sync_owned
from free_claude_code.providers.admission_registry import ProviderAdmissionRegistry
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.history_negotiation import HistoryModeCache
if TYPE_CHECKING:
from .factory import ProviderFactory
type ProviderConstructor = Callable[
[str, Settings, ProviderAdmissionRegistry, int, HistoryModeCache],
Awaitable[BaseProvider],
]
type ProviderLoader = Callable[[], ProviderFactory]
type ProviderClientKey = tuple[str, int]
def _load_constructor(
provider_id: str,
provider_loaders: Mapping[str, ProviderLoader],
settings: Settings,
api_key_number: int,
) -> Callable[
[Settings, ProviderAdmissionRegistry, HistoryModeCache | None], BaseProvider
]:
from .factory import prepare_provider
return prepare_provider(
provider_id,
provider_loaders,
settings.custom_provider(provider_id)
if provider_id.startswith("custom_")
else None,
api_key_number=api_key_number,
)
async def create_provider(
provider_id: str,
settings: Settings,
admission_registry: ProviderAdmissionRegistry,
api_key_number: int = 1,
history_cache: HistoryModeCache | None = None,
*,
provider_loaders: Mapping[str, ProviderLoader] | None = None,
) -> BaseProvider:
constructor = await run_sync_owned(
partial(
_load_constructor,
provider_id,
provider_loaders or {},
settings,
api_key_number,
)
)
return constructor(settings, admission_registry, history_cache)
class ProviderRuntime:
"""Own provider instances for one immutable settings snapshot."""
def __init__(
self,
settings: Settings,
admission_registry: ProviderAdmissionRegistry,
history_cache: HistoryModeCache | None = None,
providers: MutableMapping[ProviderClientKey, BaseProvider] | None = None,
*,
provider_constructor: ProviderConstructor = create_provider,
) -> None:
self.settings = settings
self._history_cache = (
history_cache if history_cache is not None else HistoryModeCache()
)
self._admission_registry = admission_registry
self._providers = providers if providers is not None else {}
self._provider_constructor = provider_constructor
self._creations: dict[ProviderClientKey, asyncio.Task[BaseProvider]] = {}
self._closing = False
def is_cached(self, provider_id: str, api_key_number: int = 1) -> bool:
"""Return whether this provider/key client is already cached."""
return (provider_id, api_key_number) in self._providers
async def resolve_provider(
self, provider_id: str, api_key_number: int = 1
) -> BaseProvider:
"""Return an existing provider or create it lazily."""
if self._closing:
raise ApplicationUnavailableError("Provider runtime is shutting down.")
key = (provider_id, api_key_number)
if key in self._providers:
return self._providers[key]
task = self._creations.get(key)
if task is None or task.done():
task = asyncio.create_task(self._construct(key))
self._creations[key] = task
task.add_done_callback(partial(self._creation_done, key))
return await asyncio.shield(task)
def _creation_done(
self, key: ProviderClientKey, task: asyncio.Task[BaseProvider]
) -> None:
if self._creations.get(key) is task:
del self._creations[key]
if not task.cancelled():
task.exception() # Observe failures even when every caller stopped waiting.
async def _construct(self, key: ProviderClientKey) -> BaseProvider:
provider_id, api_key_number = key
provider = await self._provider_constructor(
provider_id,
self.settings,
self._admission_registry,
api_key_number,
self._history_cache,
)
self._providers[key] = provider
return provider
async def cleanup(self) -> None:
"""Release every provider client constructed by this generation."""
self._closing = True
creations = tuple(self._creations.values())
for task in creations:
if not task.done():
task.cancel()
await asyncio.gather(*creations, return_exceptions=True)
self._creations.clear()
errors: list[Exception] = []
for provider_id, provider in list(self._providers.items()):
try:
await provider.cleanup()
except asyncio.CancelledError:
raise
except Exception as exc:
errors.append(exc)
else:
self._providers.pop(provider_id, None)
if len(errors) == 1:
raise errors[0]
if len(errors) > 1:
raise ExceptionGroup("One or more provider cleanups failed", errors)
|