Spaces:
Running
Running
sync: upstream 9194f15 + custom addons (KeyRotator, RotatingChatTransport, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
e99df76 Download src/free_claude_code/application/session_events.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 4.14 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/session_events.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/application/session_events.py
-
curl -L -o session_events.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/session_events.py
4.14 kB
| from __future__ import annotations | |
| """Bounded in-process fan-out for observable session state changes.""" | |
| import asyncio | |
| from collections.abc import AsyncIterator | |
| from dataclasses import dataclass | |
| from free_claude_code.core.json_types import JsonObject | |
| class PublishedEvent: | |
| event: str | |
| id: int | |
| data: JsonObject | |
| class EventOverflowError(Exception): | |
| """One slow observer must reconnect from an authoritative snapshot.""" | |
| def __init__(self, cursor: int) -> None: | |
| super().__init__("Session event subscription overflowed.") | |
| self.cursor = cursor | |
| _DEFAULT_QUEUE_SIZE = 128 | |
| class _Closed: | |
| pass | |
| _CLOSED = _Closed() | |
| class _Overflow: | |
| def __init__(self, cursor: int) -> None: | |
| self.cursor = cursor | |
| type _QueueItem = PublishedEvent | _Overflow | _Closed | |
| class EventSubscription: | |
| """One observer's independent view of the process-local session feed.""" | |
| def __init__( | |
| self, | |
| publisher: EventPublisher, | |
| *, | |
| cursor: int, | |
| queue_size: int, | |
| ) -> None: | |
| self._publisher = publisher | |
| self._queue: asyncio.Queue[_QueueItem] = asyncio.Queue(maxsize=queue_size) | |
| self.cursor = cursor | |
| self._closed = False | |
| def __aiter__(self) -> AsyncIterator[PublishedEvent]: | |
| return self._events() | |
| async def _events(self) -> AsyncIterator[PublishedEvent]: | |
| while True: | |
| item = await self._queue.get() | |
| if item is _CLOSED: | |
| return | |
| if isinstance(item, _Overflow): | |
| raise EventOverflowError(item.cursor) | |
| if isinstance(item, PublishedEvent): | |
| yield item | |
| async def aclose(self) -> None: | |
| if self._closed: | |
| return | |
| self._closed = True | |
| self._publisher.unsubscribe(self) | |
| self.signal(_CLOSED) | |
| def signal(self, item: _QueueItem) -> None: | |
| while True: | |
| try: | |
| self._queue.get_nowait() | |
| except asyncio.QueueEmpty: | |
| break | |
| self._queue.put_nowait(item) | |
| class EventPublisher: | |
| """Publish without allowing one observer to backpressure session work.""" | |
| def __init__(self, *, queue_size: int = _DEFAULT_QUEUE_SIZE) -> None: | |
| if queue_size <= 0: | |
| raise ValueError("session event queue size must be positive.") | |
| self._queue_size = queue_size | |
| self._sequence = 0 | |
| self._subscriptions: set[EventSubscription] = set() | |
| self._closed = False | |
| def cursor(self) -> int: | |
| return self._sequence | |
| def subscribe(self) -> EventSubscription: | |
| if self._closed: | |
| raise RuntimeError("session event publisher is closed.") | |
| subscription = EventSubscription( | |
| self, | |
| cursor=self._sequence, | |
| queue_size=self._queue_size, | |
| ) | |
| self._subscriptions.add(subscription) | |
| return subscription | |
| def publish(self, event: str, data: JsonObject) -> PublishedEvent: | |
| if self._closed: | |
| raise RuntimeError("session event publisher is closed.") | |
| self._sequence += 1 | |
| published = PublishedEvent(event=event, id=self._sequence, data={**data}) | |
| for subscription in tuple(self._subscriptions): | |
| try: | |
| subscription._queue.put_nowait(published) | |
| except asyncio.QueueFull: | |
| self._subscriptions.discard(subscription) | |
| subscription.signal(_Overflow(self._sequence)) | |
| return published | |
| def unsubscribe(self, subscription: EventSubscription) -> None: | |
| self._subscriptions.discard(subscription) | |
| def close(self) -> None: | |
| if self._closed: | |
| return | |
| self._closed = True | |
| self.disconnect_subscribers() | |
| def disconnect_subscribers(self) -> None: | |
| """Finish observer feeds while allowing owned work to settle and publish.""" | |
| subscriptions = tuple(self._subscriptions) | |
| self._subscriptions.clear() | |
| for subscription in subscriptions: | |
| subscription.signal(_CLOSED) | |