Portable fail-closed lock based on immutable owner claims.

Cross-process read-write lock backed by SQLite. Allows concurrent shared readers or a single exclusive writer. The lock is reentrant within

Cooperative file lock based on a shared existence marker. Unlike :class:`UnixFileLock <filelock.UnixFileLock>` and :class:`WindowsFileLock <

Cross-process and cross-host reader/writer lock built on :class:`SoftFileLock` primitives. Use this class instead of :class:`~filelock.ReadW

Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications. This wrapper dispatches every blocking SQLite operation to

Existence lock whose claim expires, so a peer may take it while the previous holder still runs. A lease trades mutual exclusion for progress

Simply watches the existence of the lock file.

Raised when the lock could not be acquired in *timeout* seconds.

Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.

Raised when strict soft-lock state cannot be interpreted without risking overlap.

A context-aware object that will release the lock file when exiting.

Run strict owner-claim locking without blocking the event loop.

One measured metric, in the unit named by ``unit``.

Pause one call inside the executor thread so a cancellation lands after the backend work started.

The owner published in a protocol 2 marker.

One parsed strict soft-lock claim.

Context-aware object that releases the async read/write lock on exit.

Async context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.

Existence lock whose claim expires, so a peer may take it while the previous holder still runs.

Async wrapper around :class:`SoftReadWriteLock` for ``asyncio`` applications. The sync class's blocking filesystem operations run on a threa

A context-aware object that will release the lock file when exiting.

Exclude ``needs``/``lacks`` capability pragmas on the runtimes where that code cannot run.

Why a held lease stopped being this process's to hold.

A lease contender disagrees with the published claim about how long the lease lasts.

A running heartbeat and the event that stops it, which only ever exist together.

Everything that exists only while a lock is held; ``None`` when the instance has no lock.

The state of one claim: its token, its heartbeat, and how that claim was lost.

An awaitable that parks its coroutine once, so a probe can throw into a suspended frame without a loop.

A dataclass which holds the context for a ``BaseAsyncFileLock`` object.

A thread local version of the ``FileLockContext`` class.

Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.

Uses the :func:`msvcrt.locking` to hard lock the lock file on windows systems.

Base class for asynchronous file locks. .. versionadded:: 3.15.0

Abstract base class for a file lock object. Provides the common reentrant API and state management. Subclasses implement the locking mechani

Holds the context for a ``BaseFileLock`` object.

Every option the metaclass forwards, so a subclass adding its own can still type what it passes through.

An existence lock whose marker carries a protocol 2 owner record.

The configured soft-lock lifetime permits overlapping live holders after expiry.

A thread local version of the ``FileLockContext`` class.

Uses ``LockFileEx`` to hard lock a byte range of the lock file on Windows systems. Lock file cleanup: Windows attempts to delete the