Try to acquire the file lock. :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeo

Release the file lock. The lock is only completely released when the lock counter reaches 0. The lock file itself may be deleted auto

Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usa

Acquire an exclusive write lock. If this instance already holds a write lock from the same thread, the lock level is incremented (re

Acquire a shared read lock. If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acq

Release any held lock and release internal filesystem resources. Idempotent. After calling this method the instance can no longer ac

Reap every process on the way out, whatever the block did.

Context manager that acquires and releases an exclusive write lock. Falls back to instance defaults for *timeout* and *blocking* whe

Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usa

Release one level of the current lock. When the lock level reaches zero the underlying SQLite transaction is rolled back, releasing

Context manager that acquires and releases a shared read lock. Falls back to instance defaults for *timeout* and *blocking* when ``N

Release one level of the current lock. See :meth:`ReadWriteLock.release` for full semantics. :param force: if ``True``, rel

The process creation FILETIME as a 100ns tick count, or ``None`` when it cannot be read.

The hostname recorded alongside an owner, so a marker written on another machine is never probed here. Marker formats here hold the field to

Release one level of the current lock. When the lock level reaches zero the heartbeat thread is stopped and the held marker file is

Take the native OS lock on *fd*, a file descriptor the caller opened and owns. This is the same one-byte exclusive lock :class:`FileLock` us

Acquire an exclusive write lock. See :meth:`ReadWriteLock.acquire_write` for full semantics. :param timeout: maximum wait t

Acquire an exclusive write lock. If this instance already holds a write lock from the same thread, the lock level is incremented (re

Remove one named claim, allowing overlap if its owner still holds the protected resource.

Atomically break a stale lock file judged stale at modification time *mtime_before*. Rename the file to a process-private name before unlink

Whether the recorded owner is provably gone, so reclaiming its marker cannot detach a live holder. Fail closed: return ``True`` only when th

Raise an exception if attempting to open the file for writing would fail. Separates files that can never be written from files that are writ

Release the native OS lock on *fd* without touching the descriptor. :param fd: the descriptor a prior :func:`lock_descriptor` locked; the ca

Mode for ``os.open``: 0o666 when unset so umask and ACLs decide, otherwise the explicit mode.

Acquire a shared read lock. See :meth:`ReadWriteLock.acquire_read` for full semantics. :param timeout: maximum wait time in

Acquire a shared read lock. If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acq

Return one stable key for *path*, collapsing equivalent spellings without following a final symlink. Relative, absolute, and ``./`` spelling

Ensure the directory containing the file exists (create it if necessary). :param filename: file.

Whether a process with this PID exists, treating an access denial as proof it does.

Async context manager that acquires and releases a shared read lock. Falls back to instance defaults for *timeout* and *blocking* wh

Return the singleton :class:`ReadWriteLock` for *lock_file*. :param lock_file: path to the SQLite database file used as the lock

:returns: a flag indicating if this lock is thread local or not

Write the whole buffer to *fd*, looping over the short writes ``os.write`` is allowed to make. A marker written with a bare ``os.write`` can

Async context manager that acquires and releases an exclusive write lock. Falls back to instance defaults for *timeout* and *blockin

Record this instance as the holder once the first acquire succeeds, so peers can detect the deadlock.

Record the lock as fully released: reset the recursion counter and drop the deadlock-registry entry.