claude-all-hands 1.0.0 → 1.0.1

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/_core/_asyncio_selector_thread.py

@@ -1,167 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import socket
-import threading
-from collections.abc import Callable
-from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from _typeshed import FileDescriptorLike
-
-_selector_lock = threading.Lock()
-_selector: Selector | None = None
-
-
-class Selector:
-    def __init__(self) -> None:
-        self._thread = threading.Thread(target=self.run, name="AnyIO socket selector")
-        self._selector = DefaultSelector()
-        self._send, self._receive = socket.socketpair()
-        self._send.setblocking(False)
-        self._receive.setblocking(False)
-        # This somewhat reduces the amount of memory wasted queueing up data
-        # for wakeups. With these settings, maximum number of 1-byte sends
-        # before getting BlockingIOError:
-        #   Linux 4.8: 6
-        #   macOS (darwin 15.5): 1
-        #   Windows 10: 525347
-        # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send
-        # blocking, even on non-blocking sockets, so don't do that.)
-        self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1)
-        self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
-        # On Windows this is a TCP socket so this might matter. On other
-        # platforms this fails b/c AF_UNIX sockets aren't actually TCP.
-        try:
-            self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        except OSError:
-            pass
-
-        self._selector.register(self._receive, EVENT_READ)
-        self._closed = False
-
-    def start(self) -> None:
-        self._thread.start()
-        threading._register_atexit(self._stop)  # type: ignore[attr-defined]
-
-    def _stop(self) -> None:
-        global _selector
-        self._closed = True
-        self._notify_self()
-        self._send.close()
-        self._thread.join()
-        self._selector.unregister(self._receive)
-        self._receive.close()
-        self._selector.close()
-        _selector = None
-        assert not self._selector.get_map(), (
-            "selector still has registered file descriptors after shutdown"
-        )
-
-    def _notify_self(self) -> None:
-        try:
-            self._send.send(b"\x00")
-        except BlockingIOError:
-            pass
-
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
-        loop = asyncio.get_running_loop()
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)})
-        else:
-            if EVENT_READ in key.data:
-                raise ValueError(
-                    "this file descriptor is already registered for reading"
-                )
-
-            key.data[EVENT_READ] = loop, callback
-            self._selector.modify(fd, key.events | EVENT_READ, key.data)
-
-        self._notify_self()
-
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
-        loop = asyncio.get_running_loop()
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)})
-        else:
-            if EVENT_WRITE in key.data:
-                raise ValueError(
-                    "this file descriptor is already registered for writing"
-                )
-
-            key.data[EVENT_WRITE] = loop, callback
-            self._selector.modify(fd, key.events | EVENT_WRITE, key.data)
-
-        self._notify_self()
-
-    def remove_reader(self, fd: FileDescriptorLike) -> bool:
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-
-        if new_events := key.events ^ EVENT_READ:
-            del key.data[EVENT_READ]
-            self._selector.modify(fd, new_events, key.data)
-        else:
-            self._selector.unregister(fd)
-
-        return True
-
-    def remove_writer(self, fd: FileDescriptorLike) -> bool:
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-
-        if new_events := key.events ^ EVENT_WRITE:
-            del key.data[EVENT_WRITE]
-            self._selector.modify(fd, new_events, key.data)
-        else:
-            self._selector.unregister(fd)
-
-        return True
-
-    def run(self) -> None:
-        while not self._closed:
-            for key, events in self._selector.select():
-                if key.fileobj is self._receive:
-                    try:
-                        while self._receive.recv(4096):
-                            pass
-                    except BlockingIOError:
-                        pass
-
-                    continue
-
-                if events & EVENT_READ:
-                    loop, callback = key.data[EVENT_READ]
-                    self.remove_reader(key.fd)
-                    try:
-                        loop.call_soon_threadsafe(callback)
-                    except RuntimeError:
-                        pass  # the loop was already closed
-
-                if events & EVENT_WRITE:
-                    loop, callback = key.data[EVENT_WRITE]
-                    self.remove_writer(key.fd)
-                    try:
-                        loop.call_soon_threadsafe(callback)
-                    except RuntimeError:
-                        pass  # the loop was already closed
-
-
-def get_selector() -> Selector:
-    global _selector
-
-    with _selector_lock:
-        if _selector is None:
-            _selector = Selector()
-            _selector.start()
-
-        return _selector

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/_core/_contextmanagers.py

@@ -1,200 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
-from inspect import isasyncgen, iscoroutine, isgenerator
-from types import TracebackType
-from typing import Protocol, TypeVar, cast, final
-
-_T_co = TypeVar("_T_co", covariant=True)
-_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None")
-
-
-class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]):
-    def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ...
-
-
-class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]):
-    def __asynccontextmanager__(
-        self,
-    ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ...
-
-
-class ContextManagerMixin:
-    """
-    Mixin class providing context manager functionality via a generator-based
-    implementation.
-
-    This class allows you to implement a context manager via :meth:`__contextmanager__`
-    which should return a generator. The mechanics are meant to mirror those of
-    :func:`@contextmanager <contextlib.contextmanager>`.
-
-    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
-        that once you enter it, you can't re-enter before first exiting it.
-
-    .. seealso:: :doc:`contextmanagers`
-    """
-
-    __cm: AbstractContextManager[object, bool | None] | None = None
-
-    @final
-    def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, ContextManagerMixin)
-        if self.__cm is not None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has already been entered"
-            )
-
-        cm = self.__contextmanager__()
-        if not isinstance(cm, AbstractContextManager):
-            if isgenerator(cm):
-                raise TypeError(
-                    "__contextmanager__() returned a generator object instead of "
-                    "a context manager. Did you forget to add the @contextmanager "
-                    "decorator?"
-                )
-
-            raise TypeError(
-                f"__contextmanager__() did not return a context manager object, "
-                f"but {cm.__class__!r}"
-            )
-
-        if cm is self:
-            raise TypeError(
-                f"{self.__class__.__qualname__}.__contextmanager__() returned "
-                f"self. Did you forget to add the @contextmanager decorator and a "
-                f"'yield' statement?"
-            )
-
-        value = cm.__enter__()
-        self.__cm = cm
-        return value
-
-    @final
-    def __exit__(
-        self: _SupportsCtxMgr[object, _ExitT_co],
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> _ExitT_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, ContextManagerMixin)
-        if self.__cm is None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has not been entered yet"
-            )
-
-        # Prevent circular references
-        cm = self.__cm
-        del self.__cm
-
-        return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb))
-
-    @abstractmethod
-    def __contextmanager__(self) -> AbstractContextManager[object, bool | None]:
-        """
-        Implement your context manager logic here.
-
-        This method **must** be decorated with
-        :func:`@contextmanager <contextlib.contextmanager>`.
-
-        .. note:: Remember that the ``yield`` will raise any exception raised in the
-            enclosed context block, so use a ``finally:`` block to clean up resources!
-
-        :return: a context manager object
-        """
-
-
-class AsyncContextManagerMixin:
-    """
-    Mixin class providing async context manager functionality via a generator-based
-    implementation.
-
-    This class allows you to implement a context manager via
-    :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of
-    :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
-
-    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
-        that once you enter it, you can't re-enter before first exiting it.
-
-    .. seealso:: :doc:`contextmanagers`
-    """
-
-    __cm: AbstractAsyncContextManager[object, bool | None] | None = None
-
-    @final
-    async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, AsyncContextManagerMixin)
-        if self.__cm is not None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has already been entered"
-            )
-
-        cm = self.__asynccontextmanager__()
-        if not isinstance(cm, AbstractAsyncContextManager):
-            if isasyncgen(cm):
-                raise TypeError(
-                    "__asynccontextmanager__() returned an async generator instead of "
-                    "an async context manager. Did you forget to add the "
-                    "@asynccontextmanager decorator?"
-                )
-            elif iscoroutine(cm):
-                cm.close()
-                raise TypeError(
-                    "__asynccontextmanager__() returned a coroutine object instead of "
-                    "an async context manager. Did you forget to add the "
-                    "@asynccontextmanager decorator and a 'yield' statement?"
-                )
-
-            raise TypeError(
-                f"__asynccontextmanager__() did not return an async context manager, "
-                f"but {cm.__class__!r}"
-            )
-
-        if cm is self:
-            raise TypeError(
-                f"{self.__class__.__qualname__}.__asynccontextmanager__() returned "
-                f"self. Did you forget to add the @asynccontextmanager decorator and a "
-                f"'yield' statement?"
-            )
-
-        value = await cm.__aenter__()
-        self.__cm = cm
-        return value
-
-    @final
-    async def __aexit__(
-        self: _SupportsAsyncCtxMgr[object, _ExitT_co],
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> _ExitT_co:
-        assert isinstance(self, AsyncContextManagerMixin)
-        if self.__cm is None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has not been entered yet"
-            )
-
-        # Prevent circular references
-        cm = self.__cm
-        del self.__cm
-
-        return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb))
-
-    @abstractmethod
-    def __asynccontextmanager__(
-        self,
-    ) -> AbstractAsyncContextManager[object, bool | None]:
-        """
-        Implement your async context manager logic here.
-
-        This method **must** be decorated with
-        :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
-
-        .. note:: Remember that the ``yield`` will raise any exception raised in the
-            enclosed context block, so use a ``finally:`` block to clean up resources!
-
-        :return: an async context manager object
-        """

package/.claude/envoy/.venv/lib/python3.9/site-packages/anyio/_core/_eventloop.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-import math
-import sys
-import threading
-from collections.abc import Awaitable, Callable, Generator
-from contextlib import contextmanager
-from contextvars import Token
-from importlib import import_module
-from typing import TYPE_CHECKING, Any, TypeVar
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-sniffio: Any
-try:
-    import sniffio
-except ModuleNotFoundError:
-    sniffio = None
-
-if TYPE_CHECKING:
-    from ..abc import AsyncBackend
-
-# This must be updated when new backends are introduced
-BACKENDS = "asyncio", "trio"
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-
-threadlocals = threading.local()
-loaded_backends: dict[str, type[AsyncBackend]] = {}
-
-
-def run(
-    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
-    *args: Unpack[PosArgsT],
-    backend: str = "asyncio",
-    backend_options: dict[str, Any] | None = None,
-) -> T_Retval:
-    """
-    Run the given coroutine function in an asynchronous event loop.
-
-    The current thread must not be already running an event loop.
-
-    :param func: a coroutine function
-    :param args: positional arguments to ``func``
-    :param backend: name of the asynchronous event loop implementation – currently
-        either ``asyncio`` or ``trio``
-    :param backend_options: keyword arguments to call the backend ``run()``
-        implementation with (documented :ref:`here <backend options>`)
-    :return: the return value of the coroutine function
-    :raises RuntimeError: if an asynchronous event loop is already running in this
-        thread
-    :raises LookupError: if the named backend is not found
-
-    """
-    if asynclib_name := current_async_library():
-        raise RuntimeError(f"Already running {asynclib_name} in this thread")
-
-    try:
-        async_backend = get_async_backend(backend)
-    except ImportError as exc:
-        raise LookupError(f"No such backend: {backend}") from exc
-
-    token = None
-    if asynclib_name is None:
-        # Since we're in control of the event loop, we can cache the name of the async
-        # library
-        token = set_current_async_library(backend)
-
-    try:
-        backend_options = backend_options or {}
-        return async_backend.run(func, args, {}, backend_options)
-    finally:
-        reset_current_async_library(token)
-
-
-async def sleep(delay: float) -> None:
-    """
-    Pause the current task for the specified duration.
-
-    :param delay: the duration, in seconds
-
-    """
-    return await get_async_backend().sleep(delay)
-
-
-async def sleep_forever() -> None:
-    """
-    Pause the current task until it's cancelled.
-
-    This is a shortcut for ``sleep(math.inf)``.
-
-    .. versionadded:: 3.1
-
-    """
-    await sleep(math.inf)
-
-
-async def sleep_until(deadline: float) -> None:
-    """
-    Pause the current task until the given time.
-
-    :param deadline: the absolute time to wake up at (according to the internal
-        monotonic clock of the event loop)
-
-    .. versionadded:: 3.1
-
-    """
-    now = current_time()
-    await sleep(max(deadline - now, 0))
-
-
-def current_time() -> float:
-    """
-    Return the current value of the event loop's internal clock.
-
-    :return: the clock value (seconds)
-
-    """
-    return get_async_backend().current_time()
-
-
-def get_all_backends() -> tuple[str, ...]:
-    """Return a tuple of the names of all built-in backends."""
-    return BACKENDS
-
-
-def get_available_backends() -> tuple[str, ...]:
-    """
-    Test for the availability of built-in backends.
-
-    :return a tuple of the built-in backend names that were successfully imported
-
-    .. versionadded:: 4.12
-
-    """
-    available_backends: list[str] = []
-    for backend_name in get_all_backends():
-        try:
-            get_async_backend(backend_name)
-        except ImportError:
-            continue
-
-        available_backends.append(backend_name)
-
-    return tuple(available_backends)
-
-
-def get_cancelled_exc_class() -> type[BaseException]:
-    """Return the current async library's cancellation exception class."""
-    return get_async_backend().cancelled_exception_class()
-
-
-#
-# Private API
-#
-
-
-@contextmanager
-def claim_worker_thread(
-    backend_class: type[AsyncBackend], token: object
-) -> Generator[Any, None, None]:
-    from ..lowlevel import EventLoopToken
-
-    threadlocals.current_token = EventLoopToken(backend_class, token)
-    try:
-        yield
-    finally:
-        del threadlocals.current_token
-
-
-class NoCurrentAsyncBackend(Exception):
-    def __init__(self) -> None:
-        super().__init__(
-            f"Not currently running on any asynchronous event loop"
-            f"Available async backends: {', '.join(get_all_backends())}"
-        )
-
-
-def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]:
-    if asynclib_name is None:
-        asynclib_name = current_async_library()
-        if not asynclib_name:
-            raise NoCurrentAsyncBackend
-
-    # We use our own dict instead of sys.modules to get the already imported back-end
-    # class because the appropriate modules in sys.modules could potentially be only
-    # partially initialized
-    try:
-        return loaded_backends[asynclib_name]
-    except KeyError:
-        module = import_module(f"anyio._backends._{asynclib_name}")
-        loaded_backends[asynclib_name] = module.backend_class
-        return module.backend_class
-
-
-def current_async_library() -> str | None:
-    if sniffio is None:
-        # If sniffio is not installed, we assume we're either running asyncio or nothing
-        import asyncio
-
-        try:
-            asyncio.get_running_loop()
-            return "asyncio"
-        except RuntimeError:
-            pass
-    else:
-        try:
-            return sniffio.current_async_library()
-        except sniffio.AsyncLibraryNotFoundError:
-            pass
-
-    return None
-
-
-def set_current_async_library(asynclib_name: str | None) -> Token | None:
-    # no-op if sniffio is not installed
-    if sniffio is None:
-        return None
-
-    return sniffio.current_async_library_cvar.set(asynclib_name)
-
-
-def reset_current_async_library(token: Token | None) -> None:
-    if token is not None:
-        sniffio.current_async_library_cvar.reset(token)