claude-all-hands 1.0.0 → 1.0.1

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/streams/memory.py

@@ -1,325 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "MemoryObjectReceiveStream",
-    "MemoryObjectSendStream",
-    "MemoryObjectStreamStatistics",
-)
-
-import warnings
-from collections import OrderedDict, deque
-from dataclasses import dataclass, field
-from types import TracebackType
-from typing import Generic, NamedTuple, TypeVar
-
-from .. import (
-    BrokenResourceError,
-    ClosedResourceError,
-    EndOfStream,
-    WouldBlock,
-)
-from .._core._testing import TaskInfo, get_current_task
-from ..abc import Event, ObjectReceiveStream, ObjectSendStream
-from ..lowlevel import checkpoint
-
-T_Item = TypeVar("T_Item")
-T_co = TypeVar("T_co", covariant=True)
-T_contra = TypeVar("T_contra", contravariant=True)
-
-
-class MemoryObjectStreamStatistics(NamedTuple):
-    current_buffer_used: int  #: number of items stored in the buffer
-    #: maximum number of items that can be stored on this stream (or :data:`math.inf`)
-    max_buffer_size: float
-    open_send_streams: int  #: number of unclosed clones of the send stream
-    open_receive_streams: int  #: number of unclosed clones of the receive stream
-    #: number of tasks blocked on :meth:`MemoryObjectSendStream.send`
-    tasks_waiting_send: int
-    #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive`
-    tasks_waiting_receive: int
-
-
-@dataclass(eq=False)
-class _MemoryObjectItemReceiver(Generic[T_Item]):
-    task_info: TaskInfo = field(init=False, default_factory=get_current_task)
-    item: T_Item = field(init=False)
-
-    def __repr__(self) -> str:
-        # When item is not defined, we get following error with default __repr__:
-        # AttributeError: 'MemoryObjectItemReceiver' object has no attribute 'item'
-        item = getattr(self, "item", None)
-        return f"{self.__class__.__name__}(task_info={self.task_info}, item={item!r})"
-
-
-@dataclass(eq=False)
-class _MemoryObjectStreamState(Generic[T_Item]):
-    max_buffer_size: float = field()
-    buffer: deque[T_Item] = field(init=False, default_factory=deque)
-    open_send_channels: int = field(init=False, default=0)
-    open_receive_channels: int = field(init=False, default=0)
-    waiting_receivers: OrderedDict[Event, _MemoryObjectItemReceiver[T_Item]] = field(
-        init=False, default_factory=OrderedDict
-    )
-    waiting_senders: OrderedDict[Event, T_Item] = field(
-        init=False, default_factory=OrderedDict
-    )
-
-    def statistics(self) -> MemoryObjectStreamStatistics:
-        return MemoryObjectStreamStatistics(
-            len(self.buffer),
-            self.max_buffer_size,
-            self.open_send_channels,
-            self.open_receive_channels,
-            len(self.waiting_senders),
-            len(self.waiting_receivers),
-        )
-
-
-@dataclass(eq=False)
-class MemoryObjectReceiveStream(Generic[T_co], ObjectReceiveStream[T_co]):
-    _state: _MemoryObjectStreamState[T_co]
-    _closed: bool = field(init=False, default=False)
-
-    def __post_init__(self) -> None:
-        self._state.open_receive_channels += 1
-
-    def receive_nowait(self) -> T_co:
-        """
-        Receive the next item if it can be done without waiting.
-
-        :return: the received item
-        :raises ~anyio.ClosedResourceError: if this send stream has been closed
-        :raises ~anyio.EndOfStream: if the buffer is empty and this stream has been
-            closed from the sending end
-        :raises ~anyio.WouldBlock: if there are no items in the buffer and no tasks
-            waiting to send
-
-        """
-        if self._closed:
-            raise ClosedResourceError
-
-        if self._state.waiting_senders:
-            # Get the item from the next sender
-            send_event, item = self._state.waiting_senders.popitem(last=False)
-            self._state.buffer.append(item)
-            send_event.set()
-
-        if self._state.buffer:
-            return self._state.buffer.popleft()
-        elif not self._state.open_send_channels:
-            raise EndOfStream
-
-        raise WouldBlock
-
-    async def receive(self) -> T_co:
-        await checkpoint()
-        try:
-            return self.receive_nowait()
-        except WouldBlock:
-            # Add ourselves in the queue
-            receive_event = Event()
-            receiver = _MemoryObjectItemReceiver[T_co]()
-            self._state.waiting_receivers[receive_event] = receiver
-
-            try:
-                await receive_event.wait()
-            finally:
-                self._state.waiting_receivers.pop(receive_event, None)
-
-            try:
-                return receiver.item
-            except AttributeError:
-                raise EndOfStream from None
-
-    def clone(self) -> MemoryObjectReceiveStream[T_co]:
-        """
-        Create a clone of this receive stream.
-
-        Each clone can be closed separately. Only when all clones have been closed will
-        the receiving end of the memory stream be considered closed by the sending ends.
-
-        :return: the cloned stream
-
-        """
-        if self._closed:
-            raise ClosedResourceError
-
-        return MemoryObjectReceiveStream(_state=self._state)
-
-    def close(self) -> None:
-        """
-        Close the stream.
-
-        This works the exact same way as :meth:`aclose`, but is provided as a special
-        case for the benefit of synchronous callbacks.
-
-        """
-        if not self._closed:
-            self._closed = True
-            self._state.open_receive_channels -= 1
-            if self._state.open_receive_channels == 0:
-                send_events = list(self._state.waiting_senders.keys())
-                for event in send_events:
-                    event.set()
-
-    async def aclose(self) -> None:
-        self.close()
-
-    def statistics(self) -> MemoryObjectStreamStatistics:
-        """
-        Return statistics about the current state of this stream.
-
-        .. versionadded:: 3.0
-        """
-        return self._state.statistics()
-
-    def __enter__(self) -> MemoryObjectReceiveStream[T_co]:
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self.close()
-
-    def __del__(self) -> None:
-        if not self._closed:
-            warnings.warn(
-                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
-                ResourceWarning,
-                stacklevel=1,
-                source=self,
-            )
-
-
-@dataclass(eq=False)
-class MemoryObjectSendStream(Generic[T_contra], ObjectSendStream[T_contra]):
-    _state: _MemoryObjectStreamState[T_contra]
-    _closed: bool = field(init=False, default=False)
-
-    def __post_init__(self) -> None:
-        self._state.open_send_channels += 1
-
-    def send_nowait(self, item: T_contra) -> None:
-        """
-        Send an item immediately if it can be done without waiting.
-
-        :param item: the item to send
-        :raises ~anyio.ClosedResourceError: if this send stream has been closed
-        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
-            receiving end
-        :raises ~anyio.WouldBlock: if the buffer is full and there are no tasks waiting
-            to receive
-
-        """
-        if self._closed:
-            raise ClosedResourceError
-        if not self._state.open_receive_channels:
-            raise BrokenResourceError
-
-        while self._state.waiting_receivers:
-            receive_event, receiver = self._state.waiting_receivers.popitem(last=False)
-            if not receiver.task_info.has_pending_cancellation():
-                receiver.item = item
-                receive_event.set()
-                return
-
-        if len(self._state.buffer) < self._state.max_buffer_size:
-            self._state.buffer.append(item)
-        else:
-            raise WouldBlock
-
-    async def send(self, item: T_contra) -> None:
-        """
-        Send an item to the stream.
-
-        If the buffer is full, this method blocks until there is again room in the
-        buffer or the item can be sent directly to a receiver.
-
-        :param item: the item to send
-        :raises ~anyio.ClosedResourceError: if this send stream has been closed
-        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
-            receiving end
-
-        """
-        await checkpoint()
-        try:
-            self.send_nowait(item)
-        except WouldBlock:
-            # Wait until there's someone on the receiving end
-            send_event = Event()
-            self._state.waiting_senders[send_event] = item
-            try:
-                await send_event.wait()
-            except BaseException:
-                self._state.waiting_senders.pop(send_event, None)
-                raise
-
-            if send_event in self._state.waiting_senders:
-                del self._state.waiting_senders[send_event]
-                raise BrokenResourceError from None
-
-    def clone(self) -> MemoryObjectSendStream[T_contra]:
-        """
-        Create a clone of this send stream.
-
-        Each clone can be closed separately. Only when all clones have been closed will
-        the sending end of the memory stream be considered closed by the receiving ends.
-
-        :return: the cloned stream
-
-        """
-        if self._closed:
-            raise ClosedResourceError
-
-        return MemoryObjectSendStream(_state=self._state)
-
-    def close(self) -> None:
-        """
-        Close the stream.
-
-        This works the exact same way as :meth:`aclose`, but is provided as a special
-        case for the benefit of synchronous callbacks.
-
-        """
-        if not self._closed:
-            self._closed = True
-            self._state.open_send_channels -= 1
-            if self._state.open_send_channels == 0:
-                receive_events = list(self._state.waiting_receivers.keys())
-                self._state.waiting_receivers.clear()
-                for event in receive_events:
-                    event.set()
-
-    async def aclose(self) -> None:
-        self.close()
-
-    def statistics(self) -> MemoryObjectStreamStatistics:
-        """
-        Return statistics about the current state of this stream.
-
-        .. versionadded:: 3.0
-        """
-        return self._state.statistics()
-
-    def __enter__(self) -> MemoryObjectSendStream[T_contra]:
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self.close()
-
-    def __del__(self) -> None:
-        if not self._closed:
-            warnings.warn(
-                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
-                ResourceWarning,
-                stacklevel=1,
-                source=self,
-            )

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/streams/stapled.py

@@ -1,147 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "MultiListener",
-    "StapledByteStream",
-    "StapledObjectStream",
-)
-
-from collections.abc import Callable, Mapping, Sequence
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
-
-from ..abc import (
-    ByteReceiveStream,
-    ByteSendStream,
-    ByteStream,
-    Listener,
-    ObjectReceiveStream,
-    ObjectSendStream,
-    ObjectStream,
-    TaskGroup,
-)
-
-T_Item = TypeVar("T_Item")
-T_Stream = TypeVar("T_Stream")
-
-
-@dataclass(eq=False)
-class StapledByteStream(ByteStream):
-    """
-    Combines two byte streams into a single, bidirectional byte stream.
-
-    Extra attributes will be provided from both streams, with the receive stream
-    providing the values in case of a conflict.
-
-    :param ByteSendStream send_stream: the sending byte stream
-    :param ByteReceiveStream receive_stream: the receiving byte stream
-    """
-
-    send_stream: ByteSendStream
-    receive_stream: ByteReceiveStream
-
-    async def receive(self, max_bytes: int = 65536) -> bytes:
-        return await self.receive_stream.receive(max_bytes)
-
-    async def send(self, item: bytes) -> None:
-        await self.send_stream.send(item)
-
-    async def send_eof(self) -> None:
-        await self.send_stream.aclose()
-
-    async def aclose(self) -> None:
-        await self.send_stream.aclose()
-        await self.receive_stream.aclose()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        return {
-            **self.send_stream.extra_attributes,
-            **self.receive_stream.extra_attributes,
-        }
-
-
-@dataclass(eq=False)
-class StapledObjectStream(Generic[T_Item], ObjectStream[T_Item]):
-    """
-    Combines two object streams into a single, bidirectional object stream.
-
-    Extra attributes will be provided from both streams, with the receive stream
-    providing the values in case of a conflict.
-
-    :param ObjectSendStream send_stream: the sending object stream
-    :param ObjectReceiveStream receive_stream: the receiving object stream
-    """
-
-    send_stream: ObjectSendStream[T_Item]
-    receive_stream: ObjectReceiveStream[T_Item]
-
-    async def receive(self) -> T_Item:
-        return await self.receive_stream.receive()
-
-    async def send(self, item: T_Item) -> None:
-        await self.send_stream.send(item)
-
-    async def send_eof(self) -> None:
-        await self.send_stream.aclose()
-
-    async def aclose(self) -> None:
-        await self.send_stream.aclose()
-        await self.receive_stream.aclose()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        return {
-            **self.send_stream.extra_attributes,
-            **self.receive_stream.extra_attributes,
-        }
-
-
-@dataclass(eq=False)
-class MultiListener(Generic[T_Stream], Listener[T_Stream]):
-    """
-    Combines multiple listeners into one, serving connections from all of them at once.
-
-    Any MultiListeners in the given collection of listeners will have their listeners
-    moved into this one.
-
-    Extra attributes are provided from each listener, with each successive listener
-    overriding any conflicting attributes from the previous one.
-
-    :param listeners: listeners to serve
-    :type listeners: Sequence[Listener[T_Stream]]
-    """
-
-    listeners: Sequence[Listener[T_Stream]]
-
-    def __post_init__(self) -> None:
-        listeners: list[Listener[T_Stream]] = []
-        for listener in self.listeners:
-            if isinstance(listener, MultiListener):
-                listeners.extend(listener.listeners)
-                del listener.listeners[:]  # type: ignore[attr-defined]
-            else:
-                listeners.append(listener)
-
-        self.listeners = listeners
-
-    async def serve(
-        self, handler: Callable[[T_Stream], Any], task_group: TaskGroup | None = None
-    ) -> None:
-        from .. import create_task_group
-
-        async with create_task_group() as tg:
-            for listener in self.listeners:
-                tg.start_soon(listener.serve, handler, task_group)
-
-    async def aclose(self) -> None:
-        for listener in self.listeners:
-            await listener.aclose()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        attributes: dict = {}
-        for listener in self.listeners:
-            attributes.update(listener.extra_attributes)
-
-        return attributes

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/streams/text.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "TextConnectable",
-    "TextReceiveStream",
-    "TextSendStream",
-    "TextStream",
-)
-
-import codecs
-import sys
-from collections.abc import Callable, Mapping
-from dataclasses import InitVar, dataclass, field
-from typing import Any
-
-from ..abc import (
-    AnyByteReceiveStream,
-    AnyByteSendStream,
-    AnyByteStream,
-    AnyByteStreamConnectable,
-    ObjectReceiveStream,
-    ObjectSendStream,
-    ObjectStream,
-    ObjectStreamConnectable,
-)
-
-if sys.version_info >= (3, 12):
-    from typing import override
-else:
-    from typing_extensions import override
-
-
-@dataclass(eq=False)
-class TextReceiveStream(ObjectReceiveStream[str]):
-    """
-    Stream wrapper that decodes bytes to strings using the given encoding.
-
-    Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any
-    completely received unicode characters as soon as they come in.
-
-    :param transport_stream: any bytes-based receive stream
-    :param encoding: character encoding to use for decoding bytes to strings (defaults
-        to ``utf-8``)
-    :param errors: handling scheme for decoding errors (defaults to ``strict``; see the
-        `codecs module documentation`_ for a comprehensive list of options)
-
-    .. _codecs module documentation:
-        https://docs.python.org/3/library/codecs.html#codec-objects
-    """
-
-    transport_stream: AnyByteReceiveStream
-    encoding: InitVar[str] = "utf-8"
-    errors: InitVar[str] = "strict"
-    _decoder: codecs.IncrementalDecoder = field(init=False)
-
-    def __post_init__(self, encoding: str, errors: str) -> None:
-        decoder_class = codecs.getincrementaldecoder(encoding)
-        self._decoder = decoder_class(errors=errors)
-
-    async def receive(self) -> str:
-        while True:
-            chunk = await self.transport_stream.receive()
-            decoded = self._decoder.decode(chunk)
-            if decoded:
-                return decoded
-
-    async def aclose(self) -> None:
-        await self.transport_stream.aclose()
-        self._decoder.reset()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        return self.transport_stream.extra_attributes
-
-
-@dataclass(eq=False)
-class TextSendStream(ObjectSendStream[str]):
-    """
-    Sends strings to the wrapped stream as bytes using the given encoding.
-
-    :param AnyByteSendStream transport_stream: any bytes-based send stream
-    :param str encoding: character encoding to use for encoding strings to bytes
-        (defaults to ``utf-8``)
-    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
-        the `codecs module documentation`_ for a comprehensive list of options)
-
-    .. _codecs module documentation:
-        https://docs.python.org/3/library/codecs.html#codec-objects
-    """
-
-    transport_stream: AnyByteSendStream
-    encoding: InitVar[str] = "utf-8"
-    errors: str = "strict"
-    _encoder: Callable[..., tuple[bytes, int]] = field(init=False)
-
-    def __post_init__(self, encoding: str) -> None:
-        self._encoder = codecs.getencoder(encoding)
-
-    async def send(self, item: str) -> None:
-        encoded = self._encoder(item, self.errors)[0]
-        await self.transport_stream.send(encoded)
-
-    async def aclose(self) -> None:
-        await self.transport_stream.aclose()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        return self.transport_stream.extra_attributes
-
-
-@dataclass(eq=False)
-class TextStream(ObjectStream[str]):
-    """
-    A bidirectional stream that decodes bytes to strings on receive and encodes strings
-    to bytes on send.
-
-    Extra attributes will be provided from both streams, with the receive stream
-    providing the values in case of a conflict.
-
-    :param AnyByteStream transport_stream: any bytes-based stream
-    :param str encoding: character encoding to use for encoding/decoding strings to/from
-        bytes (defaults to ``utf-8``)
-    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
-        the `codecs module documentation`_ for a comprehensive list of options)
-
-    .. _codecs module documentation:
-        https://docs.python.org/3/library/codecs.html#codec-objects
-    """
-
-    transport_stream: AnyByteStream
-    encoding: InitVar[str] = "utf-8"
-    errors: InitVar[str] = "strict"
-    _receive_stream: TextReceiveStream = field(init=False)
-    _send_stream: TextSendStream = field(init=False)
-
-    def __post_init__(self, encoding: str, errors: str) -> None:
-        self._receive_stream = TextReceiveStream(
-            self.transport_stream, encoding=encoding, errors=errors
-        )
-        self._send_stream = TextSendStream(
-            self.transport_stream, encoding=encoding, errors=errors
-        )
-
-    async def receive(self) -> str:
-        return await self._receive_stream.receive()
-
-    async def send(self, item: str) -> None:
-        await self._send_stream.send(item)
-
-    async def send_eof(self) -> None:
-        await self.transport_stream.send_eof()
-
-    async def aclose(self) -> None:
-        await self._send_stream.aclose()
-        await self._receive_stream.aclose()
-
-    @property
-    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        return {
-            **self._send_stream.extra_attributes,
-            **self._receive_stream.extra_attributes,
-        }
-
-
-class TextConnectable(ObjectStreamConnectable[str]):
-    def __init__(self, connectable: AnyByteStreamConnectable):
-        """
-        :param connectable: the bytestream endpoint to wrap
-
-        """
-        self.connectable = connectable
-
-    @override
-    async def connect(self) -> TextStream:
-        stream = await self.connectable.connect()
-        return TextStream(stream)