Add fastapi code

venv/lib/python3.11/site-packages/anyio/abc/__init__.py

@@ -0,0 +1,88 @@
+__all__ = (
+    "AsyncResource",
+    "IPAddressType",
+    "IPSockAddrType",
+    "SocketAttribute",
+    "SocketStream",
+    "SocketListener",
+    "UDPSocket",
+    "UNIXSocketStream",
+    "UDPPacketType",
+    "ConnectedUDPSocket",
+    "UnreliableObjectReceiveStream",
+    "UnreliableObjectSendStream",
+    "UnreliableObjectStream",
+    "ObjectReceiveStream",
+    "ObjectSendStream",
+    "ObjectStream",
+    "ByteReceiveStream",
+    "ByteSendStream",
+    "ByteStream",
+    "AnyUnreliableByteReceiveStream",
+    "AnyUnreliableByteSendStream",
+    "AnyUnreliableByteStream",
+    "AnyByteReceiveStream",
+    "AnyByteSendStream",
+    "AnyByteStream",
+    "Listener",
+    "Process",
+    "Event",
+    "Condition",
+    "Lock",
+    "Semaphore",
+    "CapacityLimiter",
+    "CancelScope",
+    "TaskGroup",
+    "TaskStatus",
+    "TestRunner",
+    "BlockingPortal",
+)
+
+from typing import Any
+
+from ._resources import AsyncResource
+from ._sockets import (
+    ConnectedUDPSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketAttribute,
+    SocketListener,
+    SocketStream,
+    UDPPacketType,
+    UDPSocket,
+    UNIXSocketStream,
+)
+from ._streams import (
+    AnyByteReceiveStream,
+    AnyByteSendStream,
+    AnyByteStream,
+    AnyUnreliableByteReceiveStream,
+    AnyUnreliableByteSendStream,
+    AnyUnreliableByteStream,
+    ByteReceiveStream,
+    ByteSendStream,
+    ByteStream,
+    Listener,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    UnreliableObjectReceiveStream,
+    UnreliableObjectSendStream,
+    UnreliableObjectStream,
+)
+from ._subprocesses import Process
+from ._tasks import TaskGroup, TaskStatus
+from ._testing import TestRunner
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .._core._synchronization import CapacityLimiter, Condition, Event, Lock, Semaphore
+from .._core._tasks import CancelScope
+from ..from_thread import BlockingPortal
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio.abc."):
+        value.__module__ = __name__

venv/lib/python3.11/site-packages/anyio/abc/_resources.py

@@ -0,0 +1,29 @@
+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import Optional, Type, 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.
+    """
+
+    async def __aenter__(self: T) -> T:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    @abstractmethod
+    async def aclose(self) -> None:
+        """Close the resource."""

venv/lib/python3.11/site-packages/anyio/abc/_sockets.py

@@ -0,0 +1,183 @@
+import socket
+from abc import abstractmethod
+from io import IOBase
+from ipaddress import IPv4Address, IPv6Address
+from socket import AddressFamily
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncContextManager,
+    Callable,
+    Collection,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from .._core._typedattr import (
+    TypedAttributeProvider,
+    TypedAttributeSet,
+    typed_attribute,
+)
+from ._streams import ByteStream, Listener, T_Stream, UnreliableObjectStream
+from ._tasks import TaskGroup
+
+IPAddressType = Union[str, IPv4Address, IPv6Address]
+IPSockAddrType = Tuple[str, int]
+SockAddrType = Union[IPSockAddrType, str]
+UDPPacketType = Tuple[bytes, IPSockAddrType]
+T_Retval = TypeVar("T_Retval")
+
+
+class _NullAsyncContextManager:
+    async def __aenter__(self) -> None:
+        pass
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return None
+
+
+class SocketAttribute(TypedAttributeSet):
+    #: the address family of the underlying socket
+    family: AddressFamily = typed_attribute()
+    #: the local socket address of the underlying socket
+    local_address: SockAddrType = typed_attribute()
+    #: for IP addresses, the local port the underlying socket is bound to
+    local_port: int = typed_attribute()
+    #: the underlying stdlib socket object
+    raw_socket: socket.socket = typed_attribute()
+    #: the remote address the underlying socket is connected to
+    remote_address: SockAddrType = typed_attribute()
+    #: for IP addresses, the remote port the underlying socket is connected to
+    remote_port: int = typed_attribute()
+
+
+class _SocketProvider(TypedAttributeProvider):
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        from .._core._sockets import convert_ipv6_sockaddr as convert
+
+        attributes: Dict[Any, Callable[[], Any]] = {
+            SocketAttribute.family: lambda: self._raw_socket.family,
+            SocketAttribute.local_address: lambda: convert(
+                self._raw_socket.getsockname()
+            ),
+            SocketAttribute.raw_socket: lambda: self._raw_socket,
+        }
+        try:
+            peername: Optional[Tuple[str, int]] = convert(
+                self._raw_socket.getpeername()
+            )
+        except OSError:
+            peername = None
+
+        # Provide the remote address for connected sockets
+        if peername is not None:
+            attributes[SocketAttribute.remote_address] = lambda: peername
+
+        # Provide local and remote ports for IP based sockets
+        if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6):
+            attributes[
+                SocketAttribute.local_port
+            ] = lambda: self._raw_socket.getsockname()[1]
+            if peername is not None:
+                remote_port = peername[1]
+                attributes[SocketAttribute.remote_port] = lambda: remote_port
+
+        return attributes
+
+    @property
+    @abstractmethod
+    def _raw_socket(self) -> socket.socket:
+        pass
+
+
+class SocketStream(ByteStream, _SocketProvider):
+    """
+    Transports bytes over a socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+
+class UNIXSocketStream(SocketStream):
+    @abstractmethod
+    async def send_fds(
+        self, message: bytes, fds: Collection[Union[int, IOBase]]
+    ) -> None:
+        """
+        Send file descriptors along with a message to the peer.
+
+        :param message: a non-empty bytestring
+        :param fds: a collection of files (either numeric file descriptors or open file or socket
+            objects)
+        """
+
+    @abstractmethod
+    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+        """
+        Receive file descriptors along with a message from the peer.
+
+        :param msglen: length of the message to expect from the peer
+        :param maxfds: maximum number of file descriptors to expect from the peer
+        :return: a tuple of (message, file descriptors)
+        """
+
+
+class SocketListener(Listener[SocketStream], _SocketProvider):
+    """
+    Listens to incoming socket connections.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @abstractmethod
+    async def accept(self) -> SocketStream:
+        """Accept an incoming connection."""
+
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+    ) -> None:
+        from .. import create_task_group
+
+        context_manager: AsyncContextManager
+        if task_group is None:
+            task_group = context_manager = create_task_group()
+        else:
+            # Can be replaced with AsyncExitStack once on py3.7+
+            context_manager = _NullAsyncContextManager()
+
+        async with context_manager:
+            while True:
+                stream = await self.accept()
+                task_group.start_soon(handler, stream)
+
+
+class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider):
+    """
+    Represents an unconnected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    async def sendto(self, data: bytes, host: str, port: int) -> None:
+        """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port)))."""
+        return await self.send((data, (host, port)))
+
+
+class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider):
+    """
+    Represents an connected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """

venv/lib/python3.11/site-packages/anyio/abc/_streams.py

@@ -0,0 +1,198 @@
+from abc import abstractmethod
+from typing import Any, Callable, Generic, Optional, TypeVar, Union
+
+from .._core._exceptions import EndOfStream
+from .._core._typedattr import TypedAttributeProvider
+from ._resources import AsyncResource
+from ._tasks import TaskGroup
+
+T_Item = TypeVar("T_Item")
+T_Stream = TypeVar("T_Stream")
+
+
+class UnreliableObjectReceiveStream(
+    Generic[T_Item], AsyncResource, TypedAttributeProvider
+):
+    """
+    An interface for receiving objects.
+
+    This interface makes no guarantees that the received messages arrive in the order in which they
+    were sent, or that no messages are missed.
+
+    Asynchronously iterating over objects of this type will yield objects matching the given type
+    parameter.
+    """
+
+    def __aiter__(self) -> "UnreliableObjectReceiveStream[T_Item]":
+        return self
+
+    async def __anext__(self) -> T_Item:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration
+
+    @abstractmethod
+    async def receive(self) -> T_Item:
+        """
+        Receive the next item.
+
+        :raises ~anyio.ClosedResourceError: if the receive stream has been explicitly
+            closed
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectSendStream(
+    Generic[T_Item], AsyncResource, TypedAttributeProvider
+):
+    """
+    An interface for sending objects.
+
+    This interface makes no guarantees that the messages sent will reach the recipient(s) in the
+    same order in which they were sent, or at all.
+    """
+
+    @abstractmethod
+    async def send(self, item: T_Item) -> None:
+        """
+        Send an item to the peer(s).
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if the send stream has been explicitly
+            closed
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectStream(
+    UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item]
+):
+    """
+    A bidirectional message stream which does not guarantee the order or reliability of message
+    delivery.
+    """
+
+
+class ObjectReceiveStream(UnreliableObjectReceiveStream[T_Item]):
+    """
+    A receive message stream which guarantees that messages are received in the same order in
+    which they were sent, and that no messages are missed.
+    """
+
+
+class ObjectSendStream(UnreliableObjectSendStream[T_Item]):
+    """
+    A send message stream which guarantees that messages are delivered in the same order in which
+    they were sent, without missing any messages in the middle.
+    """
+
+
+class ObjectStream(
+    ObjectReceiveStream[T_Item],
+    ObjectSendStream[T_Item],
+    UnreliableObjectStream[T_Item],
+):
+    """
+    A bidirectional message stream which guarantees the order and reliability of message delivery.
+    """
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this method.
+        This method is idempotent (does nothing on successive calls).
+        """
+
+
+class ByteReceiveStream(AsyncResource, TypedAttributeProvider):
+    """
+    An interface for receiving bytes from a single peer.
+
+    Iterating this byte stream will yield a byte string of arbitrary length, but no more than
+    65536 bytes.
+    """
+
+    def __aiter__(self) -> "ByteReceiveStream":
+        return self
+
+    async def __anext__(self) -> bytes:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration
+
+    @abstractmethod
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        """
+        Receive at most ``max_bytes`` bytes from the peer.
+
+        .. note:: Implementors of this interface should not return an empty :class:`bytes` object,
+            and users should ignore them.
+
+        :param max_bytes: maximum number of bytes to receive
+        :return: the received bytes
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        """
+
+
+class ByteSendStream(AsyncResource, TypedAttributeProvider):
+    """An interface for sending bytes to a single peer."""
+
+    @abstractmethod
+    async def send(self, item: bytes) -> None:
+        """
+        Send the given bytes to the peer.
+
+        :param item: the bytes to send
+        """
+
+
+class ByteStream(ByteReceiveStream, ByteSendStream):
+    """A bidirectional byte stream."""
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this method.
+        This method is idempotent (does nothing on successive calls).
+        """
+
+
+#: Type alias for all unreliable bytes-oriented receive streams.
+AnyUnreliableByteReceiveStream = Union[
+    UnreliableObjectReceiveStream[bytes], ByteReceiveStream
+]
+#: Type alias for all unreliable bytes-oriented send streams.
+AnyUnreliableByteSendStream = Union[UnreliableObjectSendStream[bytes], ByteSendStream]
+#: Type alias for all unreliable bytes-oriented streams.
+AnyUnreliableByteStream = Union[UnreliableObjectStream[bytes], ByteStream]
+#: Type alias for all bytes-oriented receive streams.
+AnyByteReceiveStream = Union[ObjectReceiveStream[bytes], ByteReceiveStream]
+#: Type alias for all bytes-oriented send streams.
+AnyByteSendStream = Union[ObjectSendStream[bytes], ByteSendStream]
+#: Type alias for all bytes-oriented streams.
+AnyByteStream = Union[ObjectStream[bytes], ByteStream]
+
+
+class Listener(Generic[T_Stream], AsyncResource, TypedAttributeProvider):
+    """An interface for objects that let you accept incoming connections."""
+
+    @abstractmethod
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+    ) -> None:
+        """
+        Accept incoming connections as they come in and start tasks to handle them.
+
+        :param handler: a callable that will be used to handle each accepted connection
+        :param task_group: the task group that will be used to start tasks for handling each
+            accepted connection (if omitted, an ad-hoc task group will be created)
+        """

venv/lib/python3.11/site-packages/anyio/abc/_subprocesses.py

@@ -0,0 +1,78 @@
+from abc import abstractmethod
+from signal import Signals
+from typing import Optional
+
+from ._resources import AsyncResource
+from ._streams import ByteReceiveStream, ByteSendStream
+
+
+class Process(AsyncResource):
+    """An asynchronous version of :class:`subprocess.Popen`."""
+
+    @abstractmethod
+    async def wait(self) -> int:
+        """
+        Wait until the process exits.
+
+        :return: the exit code of the process
+        """
+
+    @abstractmethod
+    def terminate(self) -> None:
+        """
+        Terminates the process, gracefully if possible.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGTERM`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.terminate`
+        """
+
+    @abstractmethod
+    def kill(self) -> None:
+        """
+        Kills the process.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGKILL`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.kill`
+        """
+
+    @abstractmethod
+    def send_signal(self, signal: Signals) -> None:
+        """
+        Send a signal to the subprocess.
+
+        .. seealso:: :meth:`subprocess.Popen.send_signal`
+
+        :param signal: the signal number (e.g. :data:`signal.SIGHUP`)
+        """
+
+    @property
+    @abstractmethod
+    def pid(self) -> int:
+        """The process ID of the process."""
+
+    @property
+    @abstractmethod
+    def returncode(self) -> Optional[int]:
+        """
+        The return code of the process. If the process has not yet terminated, this will be
+        ``None``.
+        """
+
+    @property
+    @abstractmethod
+    def stdin(self) -> Optional[ByteSendStream]:
+        """The stream for the standard input of the process."""
+
+    @property
+    @abstractmethod
+    def stdout(self) -> Optional[ByteReceiveStream]:
+        """The stream for the standard output of the process."""
+
+    @property
+    @abstractmethod
+    def stderr(self) -> Optional[ByteReceiveStream]:
+        """The stream for the standard error output of the process."""

venv/lib/python3.11/site-packages/anyio/abc/_tasks.py

@@ -0,0 +1,104 @@
+import typing
+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import Any, Callable, Coroutine, Optional, Type, TypeVar
+from warnings import warn
+
+if typing.TYPE_CHECKING:
+    from anyio._core._tasks import CancelScope
+
+T_Retval = TypeVar("T_Retval")
+
+
+class TaskStatus(metaclass=ABCMeta):
+    @abstractmethod
+    def started(self, value: object = None) -> None:
+        """
+        Signal that the task has started.
+
+        :param value: object passed back to the starter of the task
+        """
+
+
+class TaskGroup(metaclass=ABCMeta):
+    """
+    Groups several asynchronous tasks together.
+
+    :ivar cancel_scope: the cancel scope inherited by all child tasks
+    :vartype cancel_scope: CancelScope
+    """
+
+    cancel_scope: "CancelScope"
+
+    async def spawn(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> None:
+        """
+        Start a new task in this task group.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+
+        .. deprecated:: 3.0
+           Use :meth:`start_soon` instead. If your code needs AnyIO 2 compatibility, you
+           can keep using this until AnyIO 4.
+
+        """
+        warn(
+            'spawn() is deprecated -- use start_soon() (without the "await") instead',
+            DeprecationWarning,
+        )
+        self.start_soon(func, *args, name=name)
+
+    @abstractmethod
+    def start_soon(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> None:
+        """
+        Start a new task in this task group.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+
+        .. versionadded:: 3.0
+        """
+
+    @abstractmethod
+    async def start(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> object:
+        """
+        Start a new task and wait until it signals for readiness.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+        :return: the value passed to ``task_status.started()``
+        :raises RuntimeError: if the task finishes without calling ``task_status.started()``
+
+        .. versionadded:: 3.0
+        """
+
+    @abstractmethod
+    async def __aenter__(self) -> "TaskGroup":
+        """Enter the task group context and allow starting new tasks."""
+
+    @abstractmethod
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        """Exit the task group context waiting for all tasks to finish."""

venv/lib/python3.11/site-packages/anyio/abc/_testing.py

@@ -0,0 +1,68 @@
+import types
+from abc import ABCMeta, abstractmethod
+from collections.abc import AsyncGenerator, Iterable
+from typing import Any, Callable, Coroutine, Dict, Optional, Type, TypeVar
+
+_T = TypeVar("_T")
+
+
+class TestRunner(metaclass=ABCMeta):
+    """
+    Encapsulates a running event loop. Every call made through this object will use the same event
+    loop.
+    """
+
+    def __enter__(self) -> "TestRunner":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[types.TracebackType],
+    ) -> Optional[bool]:
+        self.close()
+        return None
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the event loop."""
+
+    @abstractmethod
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., "AsyncGenerator[_T, Any]"],
+        kwargs: Dict[str, Any],
+    ) -> "Iterable[_T]":
+        """
+        Run an async generator fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: an iterator yielding the value yielded from the async generator
+        """
+
+    @abstractmethod
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, _T]],
+        kwargs: Dict[str, Any],
+    ) -> _T:
+        """
+        Run an async fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: the return value of the fixture function
+        """
+
+    @abstractmethod
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: Dict[str, Any]
+    ) -> None:
+        """
+        Run an async test function.
+
+        :param test_func: the test function
+        :param kwargs: keyword arguments to call the test function with
+        """