An asynchronous version of :class:`pathlib.Path`. This class cannot be substituted for :class:`pathlib.Path` or :class:`pathlib.PurePath

Wraps a unit of work that can be made separately cancellable. :param deadline: The time (clock value) when this scope is cancelled automatic

A context manager for ensuring that a resource is only used by a single task at a time. Entering this context manager while the previous

Like a :class:`~contextvars.ContextVar`, except scoped to the running event loop. Can be used as a context manager, Just like :class:`~conte

Combines two object streams into a single, bidirectional object stream. Extra attributes will be provided from both streams, with the receiv

An object that lets external threads run code in an asynchronous event loop. :raises NoEventLoopError: if no supported asynchronous event lo

Wraps any bytes-based receive stream and uses a buffer to provide sophisticated receiving capabilities in the form of a byte stream.

An asynchronous file object. This class wraps a standard file object and provides async friendly versions of the following blocking meth

Raised when two tasks are trying to read from or write to the same resource concurrently.

An asynchronous spooled temporary file that starts in memory and is spooled to disk. This class provides an asynchronous interface to a spoo

Raised when awaiting on, or attempting to access the return value of, a :class:`.TaskHandle` that was cancelled.

Encapsulates auxiliary task information that cannot be added to the Task instance itself because there are no guarantees about its implementa

A full-duplex variant of :class:`BufferedByteReceiveStream`. All writes are passed through to the wrapped stream as-is.

:ivar int borrowed_tokens: number of tokens currently borrowed by tasks :ivar float total_tokens: total number of available tokens :ivar

Raised when trying to use a resource that has been closed.

:ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait`

:ivar bool locked: flag indicating if this lock is locked or not :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if

Combines multiple listeners into one, serving connections from all of them at once. Any MultiListeners in the given collection of listeners

Raised by several functions that require an event loop to be running in the current thread when there is no running event loop. This is

:ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire`

Connects to a TCP server at the given host and port. :param host: host name or IP address of the server :param port: TCP port number of

Returned from the task-spawning methods of :class:`TaskGroup`. Can be awaited on to get the return value of the task (or the raised exception

An asynchronous temporary directory that is created and cleaned up automatically. This class provides an asynchronous context manager for cr

Stream wrapper that decodes bytes to strings using the given encoding. Decoding is done using :class:`~codecs.IncrementalDecoder` which retu

Sends strings to the wrapped stream as bytes using the given encoding. :param AnyByteSendStream transport_stream: any bytes-based send strea

Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is raised in the subinterpreter.

Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or otherwise misbehaves.

Raised when a connection attempt fails. .. note:: This class inherits from :exc:`OSError` for backwards compatibility.

An opaque object that holds a reference to an event loop. .. versionadded:: 4.11.0

A byte stream that reads from a file in the file system. :param file: a file that has been opened for reading in binary mode .. version

Manages port generation based on specified socket kind, ensuring no duplicate ports are generated. This class provides functionality for

Wraps another connectable and does TLS negotiation after a successful connection. :param connectable: the connectable to wrap :param hos

Raised when attempting to access the return value or exception of a :class:`.TaskHandle` that is still pending completion.

A bidirectional stream that decodes bytes to strings on receive and encodes strings to bytes on send. Extra attributes will be provided

Connects to a UNIX domain socket at the given path. :param path: the file system path of the socket

A manager for a blocking portal. Used as a context manager. The first thread to enter this context manager causes a blocking portal to be sta

Wraps a byte stream connectable to produce :class:`BufferedByteStream` connections. Use this when you want the streams returned by :meth:`co

:ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait` :ivar ~anyio.LockStatistics lock_statistics: statistics of the u

Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the maximum number of bytes has been read withou