hmdev-cli 1.0.1 → 1.0.3

package/python/.venv/Lib/site-packages/anyio/_core/_typedattr.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable, Mapping
-from typing import Any, TypeVar, final, overload
-
-from ._exceptions import TypedAttributeLookupError
-
-T_Attr = TypeVar("T_Attr")
-T_Default = TypeVar("T_Default")
-undefined = object()
-
-
-def typed_attribute() -> Any:
-    """Return a unique object, used to mark typed attributes."""
-    return object()
-
-
-class TypedAttributeSet:
-    """
-    Superclass for typed attribute collections.
-
-    Checks that every public attribute of every subclass has a type annotation.
-    """
-
-    def __init_subclass__(cls) -> None:
-        annotations: dict[str, Any] = getattr(cls, "__annotations__", {})
-        for attrname in dir(cls):
-            if not attrname.startswith("_") and attrname not in annotations:
-                raise TypeError(
-                    f"Attribute {attrname!r} is missing its type annotation"
-                )
-
-        super().__init_subclass__()
-
-
-class TypedAttributeProvider:
-    """Base class for classes that wish to provide typed extra attributes."""
-
-    @property
-    def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
-        """
-        A mapping of the extra attributes to callables that return the corresponding
-        values.
-
-        If the provider wraps another provider, the attributes from that wrapper should
-        also be included in the returned mapping (but the wrapper may override the
-        callables from the wrapped instance).
-
-        """
-        return {}
-
-    @overload
-    def extra(self, attribute: T_Attr) -> T_Attr: ...
-
-    @overload
-    def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default: ...
-
-    @final
-    def extra(self, attribute: Any, default: object = undefined) -> object:
-        """
-        extra(attribute, default=undefined)
-
-        Return the value of the given typed extra attribute.
-
-        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to
-            look for
-        :param default: the value that should be returned if no value is found for the
-            attribute
-        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default
-            value was given
-
-        """
-        try:
-            getter = self.extra_attributes[attribute]
-        except KeyError:
-            if default is undefined:
-                raise TypedAttributeLookupError("Attribute not found") from None
-            else:
-                return default
-
-        return getter()

package/python/.venv/Lib/site-packages/anyio/abc/__init__.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from ._eventloop import AsyncBackend as AsyncBackend
-from ._resources import AsyncResource as AsyncResource
-from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket
-from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket
-from ._sockets import IPAddressType as IPAddressType
-from ._sockets import IPSockAddrType as IPSockAddrType
-from ._sockets import SocketAttribute as SocketAttribute
-from ._sockets import SocketListener as SocketListener
-from ._sockets import SocketStream as SocketStream
-from ._sockets import UDPPacketType as UDPPacketType
-from ._sockets import UDPSocket as UDPSocket
-from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType
-from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket
-from ._sockets import UNIXSocketStream as UNIXSocketStream
-from ._streams import AnyByteReceiveStream as AnyByteReceiveStream
-from ._streams import AnyByteSendStream as AnyByteSendStream
-from ._streams import AnyByteStream as AnyByteStream
-from ._streams import AnyByteStreamConnectable as AnyByteStreamConnectable
-from ._streams import AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream
-from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream
-from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream
-from ._streams import ByteReceiveStream as ByteReceiveStream
-from ._streams import ByteSendStream as ByteSendStream
-from ._streams import ByteStream as ByteStream
-from ._streams import ByteStreamConnectable as ByteStreamConnectable
-from ._streams import Listener as Listener
-from ._streams import ObjectReceiveStream as ObjectReceiveStream
-from ._streams import ObjectSendStream as ObjectSendStream
-from ._streams import ObjectStream as ObjectStream
-from ._streams import ObjectStreamConnectable as ObjectStreamConnectable
-from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream
-from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream
-from ._streams import UnreliableObjectStream as UnreliableObjectStream
-from ._subprocesses import Process as Process
-from ._tasks import TaskGroup as TaskGroup
-from ._tasks import TaskStatus as TaskStatus
-from ._testing import TestRunner as TestRunner
-
-# Re-exported here, for backwards compatibility
-# isort: off
-from .._core._synchronization import (
-    CapacityLimiter as CapacityLimiter,
-    Condition as Condition,
-    Event as Event,
-    Lock as Lock,
-    Semaphore as Semaphore,
-)
-from .._core._tasks import CancelScope as CancelScope
-from ..from_thread import BlockingPortal as BlockingPortal
-
-# Re-export imports so they look like they live directly in this package
-for __value in list(locals().values()):
-    if getattr(__value, "__module__", "").startswith("anyio.abc."):
-        __value.__module__ = __name__
-
-del __value

package/python/.venv/Lib/site-packages/anyio/abc/_eventloop.py

@@ -1,409 +0,0 @@
-from __future__ import annotations
-
-import math
-import sys
-from abc import ABCMeta, abstractmethod
-from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
-from contextlib import AbstractContextManager
-from os import PathLike
-from signal import Signals
-from socket import AddressFamily, SocketKind, socket
-from typing import (
-    IO,
-    TYPE_CHECKING,
-    Any,
-    TypeAlias,
-    TypeVar,
-    overload,
-)
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-if TYPE_CHECKING:
-    from _typeshed import FileDescriptorLike
-
-    from .._core._synchronization import CapacityLimiter, Event, Lock, Semaphore
-    from .._core._tasks import CancelScope
-    from .._core._testing import TaskInfo
-    from ._sockets import (
-        ConnectedUDPSocket,
-        ConnectedUNIXDatagramSocket,
-        IPSockAddrType,
-        SocketListener,
-        SocketStream,
-        UDPSocket,
-        UNIXDatagramSocket,
-        UNIXSocketStream,
-    )
-    from ._subprocesses import Process
-    from ._tasks import TaskGroup
-    from ._testing import TestRunner
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
-
-
-class AsyncBackend(metaclass=ABCMeta):
-    @classmethod
-    @abstractmethod
-    def run(
-        cls,
-        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
-        args: tuple[Unpack[PosArgsT]],
-        kwargs: dict[str, Any],
-        options: dict[str, Any],
-    ) -> 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 kwargs: positional arguments to ``func``
-        :param options: keyword arguments to call the backend ``run()`` implementation
-            with
-        :return: the return value of the coroutine function
-        """
-
-    @classmethod
-    @abstractmethod
-    def current_token(cls) -> object:
-        """
-        Return an object that allows other threads to run code inside the event loop.
-
-        :return: a token object, specific to the event loop running in the current
-            thread
-        """
-
-    @classmethod
-    @abstractmethod
-    def current_time(cls) -> float:
-        """
-        Return the current value of the event loop's internal clock.
-
-        :return: the clock value (seconds)
-        """
-
-    @classmethod
-    @abstractmethod
-    def cancelled_exception_class(cls) -> type[BaseException]:
-        """Return the exception class that is raised in a task if it's cancelled."""
-
-    @classmethod
-    @abstractmethod
-    async def checkpoint(cls) -> None:
-        """
-        Check if the task has been cancelled, and allow rescheduling of other tasks.
-
-        This is effectively the same as running :meth:`checkpoint_if_cancelled` and then
-        :meth:`cancel_shielded_checkpoint`.
-        """
-
-    @classmethod
-    async def checkpoint_if_cancelled(cls) -> None:
-        """
-        Check if the current task group has been cancelled.
-
-        This will check if the task has been cancelled, but will not allow other tasks
-        to be scheduled if not.
-
-        """
-        if cls.current_effective_deadline() == -math.inf:
-            await cls.checkpoint()
-
-    @classmethod
-    async def cancel_shielded_checkpoint(cls) -> None:
-        """
-        Allow the rescheduling of other tasks.
-
-        This will give other tasks the opportunity to run, but without checking if the
-        current task group has been cancelled, unlike with :meth:`checkpoint`.
-
-        """
-        with cls.create_cancel_scope(shield=True):
-            await cls.sleep(0)
-
-    @classmethod
-    @abstractmethod
-    async def sleep(cls, delay: float) -> None:
-        """
-        Pause the current task for the specified duration.
-
-        :param delay: the duration, in seconds
-        """
-
-    @classmethod
-    @abstractmethod
-    def create_cancel_scope(
-        cls, *, deadline: float = math.inf, shield: bool = False
-    ) -> CancelScope:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def current_effective_deadline(cls) -> float:
-        """
-        Return the nearest deadline among all the cancel scopes effective for the
-        current task.
-
-        :return:
-            - a clock value from the event loop's internal clock
-            - ``inf`` if there is no deadline in effect
-            - ``-inf`` if the current scope has been cancelled
-        :rtype: float
-        """
-
-    @classmethod
-    @abstractmethod
-    def create_task_group(cls) -> TaskGroup:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_event(cls) -> Event:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_lock(cls, *, fast_acquire: bool) -> Lock:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_semaphore(
-        cls,
-        initial_value: int,
-        *,
-        max_value: int | None = None,
-        fast_acquire: bool = False,
-    ) -> Semaphore:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def run_sync_in_worker_thread(
-        cls,
-        func: Callable[[Unpack[PosArgsT]], T_Retval],
-        args: tuple[Unpack[PosArgsT]],
-        abandon_on_cancel: bool = False,
-        limiter: CapacityLimiter | None = None,
-    ) -> T_Retval:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def check_cancelled(cls) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def run_async_from_thread(
-        cls,
-        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
-        args: tuple[Unpack[PosArgsT]],
-        token: object,
-    ) -> T_Retval:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def run_sync_from_thread(
-        cls,
-        func: Callable[[Unpack[PosArgsT]], T_Retval],
-        args: tuple[Unpack[PosArgsT]],
-        token: object,
-    ) -> T_Retval:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def open_process(
-        cls,
-        command: StrOrBytesPath | Sequence[StrOrBytesPath],
-        *,
-        stdin: int | IO[Any] | None,
-        stdout: int | IO[Any] | None,
-        stderr: int | IO[Any] | None,
-        **kwargs: Any,
-    ) -> Process:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def setup_process_pool_exit_at_shutdown(cls, workers: set[Process]) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def connect_tcp(
-        cls, host: str, port: int, local_address: IPSockAddrType | None = None
-    ) -> SocketStream:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def connect_unix(cls, path: str | bytes) -> UNIXSocketStream:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_tcp_listener(cls, sock: socket) -> SocketListener:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_unix_listener(cls, sock: socket) -> SocketListener:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def create_udp_socket(
-        cls,
-        family: AddressFamily,
-        local_address: IPSockAddrType | None,
-        remote_address: IPSockAddrType | None,
-        reuse_port: bool,
-    ) -> UDPSocket | ConnectedUDPSocket:
-        pass
-
-    @classmethod
-    @overload
-    async def create_unix_datagram_socket(
-        cls, raw_socket: socket, remote_path: None
-    ) -> UNIXDatagramSocket: ...
-
-    @classmethod
-    @overload
-    async def create_unix_datagram_socket(
-        cls, raw_socket: socket, remote_path: str | bytes
-    ) -> ConnectedUNIXDatagramSocket: ...
-
-    @classmethod
-    @abstractmethod
-    async def create_unix_datagram_socket(
-        cls, raw_socket: socket, remote_path: str | bytes | None
-    ) -> UNIXDatagramSocket | ConnectedUNIXDatagramSocket:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def getaddrinfo(
-        cls,
-        host: bytes | str | None,
-        port: str | int | None,
-        *,
-        family: int | AddressFamily = 0,
-        type: int | SocketKind = 0,
-        proto: int = 0,
-        flags: int = 0,
-    ) -> Sequence[
-        tuple[
-            AddressFamily,
-            SocketKind,
-            int,
-            str,
-            tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes],
-        ]
-    ]:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def getnameinfo(
-        cls, sockaddr: IPSockAddrType, flags: int = 0
-    ) -> tuple[str, str]:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wait_readable(cls, obj: FileDescriptorLike) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wait_writable(cls, obj: FileDescriptorLike) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def notify_closing(cls, obj: FileDescriptorLike) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_listener_socket(cls, sock: socket) -> SocketListener:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_stream_socket(cls, sock: socket) -> SocketStream:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_unix_stream_socket(cls, sock: socket) -> UNIXSocketStream:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_udp_socket(cls, sock: socket) -> UDPSocket:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_connected_udp_socket(cls, sock: socket) -> ConnectedUDPSocket:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_unix_datagram_socket(cls, sock: socket) -> UNIXDatagramSocket:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wrap_connected_unix_datagram_socket(
-        cls, sock: socket
-    ) -> ConnectedUNIXDatagramSocket:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def current_default_thread_limiter(cls) -> CapacityLimiter:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def open_signal_receiver(
-        cls, *signals: Signals
-    ) -> AbstractContextManager[AsyncIterator[Signals]]:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def get_current_task(cls) -> TaskInfo:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def get_running_tasks(cls) -> Sequence[TaskInfo]:
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def wait_all_tasks_blocked(cls) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
-        pass

package/python/.venv/Lib/site-packages/anyio/abc/_resources.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from abc import ABCMeta, abstractmethod
-from types import TracebackType
-from typing import TypeVar
-
-T = TypeVar("T")
-
-
-class AsyncResource(metaclass=ABCMeta):
-    """
-    Abstract base class for all closeable asynchronous resources.
-
-    Works as an asynchronous context manager which returns the instance itself on enter,
-    and calls :meth:`aclose` on exit.
-    """
-
-    __slots__ = ()
-
-    async def __aenter__(self: T) -> T:
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        await self.aclose()
-
-    @abstractmethod
-    async def aclose(self) -> None:
-        """Close the resource."""