Spaces:
Running
Running
Download src/free_claude_code/providers/runtime/runtime.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 5.49 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/runtime/runtime.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/providers/runtime/runtime.py
-
curl -L -o runtime.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/runtime/runtime.py
5.49 kB
| 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) | |