NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
PyPI, #478 most downloaded on PyPI
Cross-platform file locking, with Redis, PID-file and bounded-semaphore locks
Latest stable
4.4.2
Last release 25 days ago
28 Oct 2026
Release timing varies
gaps range from 2 weeks to 1.1 years
Nearly every release is documented
notes for 50 of 55 stable releases
1 version withdrawn
withdrawn after publishing
16 years old
56 releases · first in 2011
Drag across the ruler to compare, or tap a release to open it.
The build backend requirement is now uv_build>=0.11,<1 instead of <0.13 . Every uv minor so far shipped without a change to the uv_build configuration
4.4.2:
uv_build>=0.11,<1 instead of<0.13. Every uv minor so far shipped without a change to theuv_build configuration, and the old bound only stopped other buildSigned on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
open_atomic now anchors a relative destination when the context is entered, so a working-directory change inside the body no longer makes publication
4.4.1:
open_atomic now anchors a relative destination when the context isFileNotFoundError or leaves the temporary filename of theFileExistsError messages aresetup-uv andcodeql-action among them. No library code changed for this.Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Deprecated passing a bool as timeout or check_interval . bool subclasses int , so Lock(timeout=True) has always meant one second and timeout=False zer…
4.4.0:
timeout or check_interval.bool subclasses int, so Lock(timeout=True) has alwaystimeout=False zero, rather than anything theTypeError in 5.0. Reported and originally patched by Jonpytest.raises pattern wasSigned on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Restored the coverage badge. CI now merges the coverage data from every matrix cell, holds the merged result to the same 100% threshold each cell alre
4.3.2:
setup-uv across
a major version among them.<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Refreshed the README in Markdown and added a branded documentation landing page, light and dark logos, and links to the locking guides. README example
4.3.1:
check_interval no longer adds a full interval after the timeout.
Reply polling retains its final read so buffered holder responses are
processed before deciding that a holder is unavailable.<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
The filehandle returned by Lock and RLock is now typed by the open mode (#97): a literal text mode yields IO[str], a literal binary mode IO[bytes], so
4.3.0:
The filehandle returned by Lock and RLock is now typed by the
open mode (#97): a literal text mode yields IO[str], a literal
binary mode IO[bytes], so fh.read() type-checks as str or
bytes instead of Any. Both classes are generic over the
filehandle (Lock[IO[bytes]]), with a PEP 696 default that keeps a
bare Lock annotation valid and equal to Lock[IO[str]],
matching the default mode of 'a'. A mode that is not a literal at
the call site (a Mode-typed variable, a conditional) falls back
to the honest IO[Any] of 4.2.0 through a catch-all overload.
TemporaryFileLock and its PidFileLock subclass are pinned to
IO[str]. No runtime dependency was added: the type variable
default comes from a typing_extensions import that only type
checkers see.
New portalocker.types.TextMode and portalocker.types.BinaryMode
aliases drive the overloads above. portalocker.types.Mode stays a
single flat Literal, so typing.get_args(Mode) still returns
the mode strings themselves and the
mode in typing.get_args(Mode) validation idiom keeps working.
Migration notes for the stricter typing, in decreasing order of likelihood that they hit you:
-> Lock that returns a binary-mode lock
now errors on every checker (Lock is invariant and bare
Lock means Lock[IO[str]]). Annotate it
-> Lock[typing.IO[bytes]].class MyLock(Lock)) is a text lock. Using it
with a binary mode silently yields IO[str] on both mypy and
pyright while the runtime hands out bytes, so pin it
(class MyLock(Lock[IO[bytes]])) or keep it generic
(class MyLock(Lock[IOT])).Lock annotation. Strict-mode checking of code using
bare Lock needs mypy 1.9 or newer; pyright has understood
defaults since early 2023, and non-strict mypy is unaffected._get_fh, _get_lock and _prepare_fh
hooks that copied the 4.2.0 signatures (types.IO) now fail
override checks, because the hooks are typed by the class's type
variable. Re-type them with the subclass's filehandle type,
typing.IO[str] for a bare subclass.super().__init__(): no overload
binds an unsolved type variable. Run the parent initialization
through Lock._init, the plain method RLock itself uses.Lock and RLock accept subscription
(Lock[typing.IO[bytes]] raised TypeError on 4.2.0), and
RLock.__init__ now initializes through Lock._init instead
of calling Lock.__init__, which monkeypatched constructors
notice. Everything else is unchanged at runtime.<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
The main-thread interrupt is governed by the new interrupt_on_lost parameter, defaulting to True in 4.2 with a DeprecationWarning at loss time when le…
4.2.0:
RedisLock subscription now
lives on a dedicated connection that never retries and never
reconnects (retry=Retry(NoBackoff(), 0, supported_errors=()),
holder name set at the connection level, RESP2 with maintenance
notifications disabled), derived per attempt from the command
connection's pool and inheriting that connection's
health_check_interval (a supplied connection left at the redis-py
default of 0 therefore gets no health-check ping on the subscription
either, so a silently partitioned link is only noticed through the
socket, as the module documentation has always advised setting it).
Previously a killed or dropped holder connection
was silently resurrected by redis-py's retry machinery: the holder
resubscribed without its name, kept believing it held the lock
while the channel had already released it, inflated the subscriber
count, and could never be reaped again, permanently blocking
exclusive acquisition. Holders on flaky networks now lose their
locks loudly instead of keeping them incorrectly, which is the
correctness fix. The command connection keeps its default retry
policy, and waiter-side blips still only cost one acquire attempt.
Exotic setups (Sentinel, cluster, custom pools) can supply the new
subscription_connection_factory parameter. Note that under
redis-py's default socket_timeout of five seconds a read
stalled that long now counts as a loss, and that a pre-4.2 holder
on the same channel still resubscribes silently when killed, so the
guarantee covers a channel once every participant runs 4.2+ (#137)RedisLock: a new
portalocker.LockLostError (carrying channel, holder_id
and the causal exception as __cause__), a lost property, an
ensure_held() check for long critical sections, an on_lost
callback invoked exactly once per loss on the keep-alive thread,
and a with block exit that raises LockLostError after
releasing when the body finished cleanly. release() never
raises on account of a loss and leaves the loss observable;
acquire() on a lost instance resets it (#137, #141)RedisLock worker failures to what actually failed: a
waiter whose subscription dies retries within its timeout budget
with no process-wide interrupt, while a held lock's worker death
marks the lock lost, and the escalation now catches
BaseException (a SystemExit or KeyboardInterrupt
landing on the worker no longer dies silently). The
main-thread interrupt is governed by the new interrupt_on_lost
parameter, defaulting to True in 4.2 with a DeprecationWarning
at loss time when left unset; portalocker 5.0.0 flips the default
to False. Acquisition success is confirmed against the worker's
state under a lock, so a subscription dying between the winning
probe and the bookkeeping costs one attempt instead of producing an
imaginary hold (#141)RedisLock teardown fork safe: a forked child inheriting a
held lock now only drops its local references on release() or
garbage collection, instead of sending UNSUBSCRIBE over the
inherited socket and silently releasing the parent's lock while the
parent's own connection stayed healthy and nothing ever told it. The
per-instance mode lock, which the worker thread takes for every ping
answer, is also reinitialized in forked children alongside the state
lock now, so a fork landing inside a ping snapshot no longer hands
the child a permanently locked lock that would hang its first
release() forever. A child that needs the lock must build its
own instance (#137)RedisLock.check_or_kill_lock (removal in 5.0.0): its
reap arm kills connections on a caller-chosen timeout without the
protocol discipline that protects live-but-slow holders inside
acquire. The new read-only RedisLock.probe() answers "who
is on this channel" without side effects (#137)RedisLock non-blocking acquisition raising AlreadyLocked
for the writer that had just won the election. The fail check ran
before the promotion check, so two fail_when_locked writers on a
free channel could both fail. The winner now takes the lock when no
shared holder remains, so exactly one of two non-blocking contenders
succeeds. The pre-existing reply-staleness window around the
uncontended fast path reached non-blocking winners too and is closed
for blocking and non-blocking writers alike by the confirm probe
added for #145 (#143)RedisLock writer being usurped by a later writer
with a lower holder id. Holder records now carry an elected field
and pending writers defer to an advertised incumbent instead of
rerunning the election against it. Because a ping reply is a
snapshot that can predate the election it should have reported, the
incumbent also holds its promotion while a lower-id newcomer whose
record still carries elected: false is visible, since that
record cannot show whether the peer saw the election, rather than
promoting past it into a possible second exclusive holder. Records
keep protocol version 1, 4.0 and 4.1 holders ignore the field and
keep the old election on mixed channels, so no coordinated upgrade
is needed. Protection is complete once every writer on a channel
runs 4.2 or later, at the cost of one extra probe round whenever a
newcomer's reply raced the incumbent's election (#143)RedisLock reply-staleness window that could yield two
exclusive holders. A ping reply is a snapshot that can predate the
answering writer's own fast-path promotion: that writer counted a
single subscriber moments earlier and promoted without ever probing,
so a contender probing inside the window saw only pending holders,
elected itself and promoted too. Under reader-mixed contention at
short check intervals this fired about once per 60 to 200
acquisitions. Every promoted writer, fast path and election alike,
now verifies its promotion with a confirm probe run while its
exclusive record is already visible on the wire. Two freshly
promoted rivals therefore see each other and resolve
deterministically by holder id: the lower id keeps the lock and the
higher id demotes back to a fresh contender, or raises
AlreadyLocked after a full release under fail_when_locked. A
lower-id pending peer that may still be deciding makes the confirm
probe again rather than conclude from noise, and a rival that will
never demote itself - a pre-4.2 exclusive holder, or a reader that
joined on a stale view of its own - demotes the confirming writer
regardless of id. A subscriber count of one settles the confirm in
one extra round trip, keeping the uncontended acquire at a few
milliseconds, and the confirm also catches most promotions built on
count-preserving churn (#139) after the fact, since it sees the real
holder set instead of a count (#145)RedisLock protocol to around a hundred
milliseconds: after collecting a reply the drain polled for the next
one with timeout=0, almost always missed a reply that was
milliseconds away, and then slept a full jittered drain interval (57
of 60 three-holder probes took an interval, median 116ms). A missed
non-blocking read is now followed by one short real poll so replies
in flight are collected in the same pass, and a probe whose
subscriber count moves while replies are still outstanding gives up
at once instead of waiting out the whole reply timeout for a holder
that already left. The same three-holder probe now takes a couple
of milliseconds, the reader-mixed contention soak completes about
twenty times as many acquisitions in the same wall time, and every
staleness window the protocol still has shrinks by two orders of
magnitude (#145)RedisLock with fail_when_locked now raises only on a
conclusive probe showing the channel is held. Inconclusive probes
retry within timeout, which also lets a non-blocking acquire
succeed after reaping a crashed holder instead of failing
spuriously, at the cost of non-blocking latency of up to timeout
on a noisy channel. Pass timeout=0 to keep the strict
single-attempt behaviour (#143)RedisLock.__exit__ on two edges: the lost flag is
read after the release now (the state is sticky through
release, so a revocation landing in the instant the block exits
is raised instead of slipping out silently), and a release error can
no longer replace an exception already leaving the with body -
it is chained onto the body's exception as its __context__ with
a note attached, the same discipline Lock.__exit__ has carried
since 4.2.0on_lost callback to call release() on the lock it
is told about: the callback runs on the keep-alive worker thread and
the teardown joined that same thread, so the obvious reaction to a
loss raised RuntimeError: cannot join current thread after most
of the teardown had already run. The join is skipped on the worker
thread now; the thread exits on its own right after the callback
returns and the instance ends up fully torn down and reusableRedisLock.acquire stranding a live subscription
when the command connection failed after the subscribe but before
the decision (a PUBSUB NUMSUB timeout, for example): the error
propagated while the instance stayed subscribed with its worker
alive, so its pending record blocked every other writer on the
channel and the instance itself refused the next acquire as
already active, until someone called release on it by hand. A
probe failure now gets the same treatment as a subscribe failure:
connection blips burn one attempt and are retried within the
timeout budget, everything else - interrupts included - releases
everything first and then propagates, leaving the channel free and
the instance reusableRedisLock hanging forever in acquire or release
when the keep-alive worker was told to stop before its thread had
started running: redis-py's PubSubWorkerThread.run sets its
running flag from inside the thread and stop() clears that same
flag, so a stop issued in the window between start() and the
thread's first instruction was overwritten and the read loop then
ran forever while the teardown sat in join(). The lock reaches
that window whenever it tears a fresh subscription down immediately
(a refused confirm, a lost election, fail_when_locked) and the
new worker thread has not been scheduled yet. The worker now records
stop requests in its own event, which the read loop consults before
every read, so a stop can never be lostRedisLock
(self_check_interval, default None meaning off): every
interval a held lock publishes a liveness ping to its own channel
and requires its own reply back through the response-channel
machinery within min(self_check_interval, unavailable_timeout)
seconds, run on the keep-alive worker's cadence with the held
subscription still serviced throughout. This closes the half-open
link hole that socket-level detection cannot see (a partition with
no TCP reset delivers nothing and errors never). A failed check is
classified as a connection loss - RedisLockSelfCheckError
becomes the __cause__ of the LockLostError - and surfaces
through exactly the channels a socket-detected loss uses. Costs
two round trips plus one channel-wide reply round per interval per
holder, and a broken command path fails the check too, which is
why it stays opt-in (#146)RedisLock (fencing=True):
every exclusive grant runs INCR on the never-expiring
<channel>-fence key right after the confirm probe and exposes
the result as fence_token, so resources that can check fences
reject writes from a holder revoked inside the detection window -
the one window no lock can close by itself. The token is None
while no fenced grant stands, survives loss and release for
forensic use until the next acquire, and is never drawn for
shared holders. A failed INCR fails the acquire (transient
blips burn one attempt, a wrong-typed key raises), so a
fencing-enabled lock is never held without a token. Only
fencing-enabled 4.2+ writers bump the counter, so mixed channels
narrow the guarantee to the writers that opted in (#146)LockBase base class (the
timeout generator, the context manager protocol and the retry
plumbing), the version discovery fallbacks, the redis-less
RedisLock stub and the pubsub failure escalation were all
excluded wholesale via blanket pragma: no cover comments, so the
gate passed without those regions ever being measured. Platform
splits now use the per-OS conditional coverage rules (measured on
the platform they run on, excluded only where they cannot run), the
policy-wide exemptions for guard raises (raise AssertionError,
raise NotImplementedError, except ImportError: and friends)
are gone from the coverage configuration, and the newly measured
code is exercised by tests on every platform. The fork-safety hook
registration was also tagged for the wrong platform: it was excluded
on POSIX, where it runs, and measured on Windows, where it cannot
run. Two unreachable defensive import msvcrt guards inside the
os.name == 'nt' branch were removed outright: msvcrt ships
with every Windows Python buildrelease() calls on one Lock unlocking a
stranger's lock: both callers passed the held-handle guard, and the
loser then ran the OS unlock on a closed and possibly reused file
descriptor, silently dropping whichever lock that descriptor number
belonged to by then. Every lock now claims its state atomically under
a per-instance reentrant state lock, so exactly one caller tears the
lock down and concurrent or reentrant callers no-oprelease() reentering from a signal handler (the standard
SIGTERM graceful-shutdown idiom) between the ownership guard and the
unlink of TemporaryFileLock.release and PidFileLock.release
unlinking the lock files of whoever acquired the lock in between. The
handle is claimed before the first OS call, so the reentrant release
finds nothing to do and the successor's files surviveKeyboardInterrupt escaping fh.close() during release
leaving the handle stored after the file was unlinked, which let the
next release pass the guard and unlink the successor's file. The
stored handle is cleared before the close is attemptedBoundedSemaphore instance both
taking a slot: the second publication overwrote the first, one exit
then released the other thread's slot and the orphaned slot stayed
locked until garbage collection. The publication re-checks the
already-taken guard in one atomic step now, so the losing thread
gives its extra slot back and gets a LockException instead of
leaking it. The slot sweep itself deliberately runs outside the
instance state lock, so an os.fork in another thread cannot
capture the state lock held across the sweep's OS callsKeyboardInterrupt or SystemExit landing between a
BoundedSemaphore slot lock succeeding and its publication
stranding the OS lock on a traceback-pinned local, where refcount
collection never frees it and the slot stays blocked for every
contender. The sweep now rolls the slot back (un-publishing it
first when the interrupt landed after publication, guarded by
identity so another thread's slot stays untouched) and re-raises,
the same treatment PidFileLock got for its sidecarrelease(), acquire() or
interpreter-exit cleanup: the child inherited the lock in its locked
state, owned by a thread that does not exist there. Every live lock
instance's state lock is reinitialized in the child via
os.register_at_fork, the way the standard library's logging
module protects its handler locksAttributeError when invoked directly on Windows: CPython only
compiles _at_fork_reinit into its lock types on builds with
fork, so the hook now skips state locks without the method and
is a documented no-op on nt, where nothing ever forksPidFileLock.read_pid raising UnicodeDecodeError for a
PID file whose bytes the locale encoding cannot decode (arbitrary
junk on a cp1252 Windows, invalid UTF-8 on POSIX). The file is read
as bytes and validated as ASCII digits now, so undecodable content
reads as None like any other unreadable value, on every platform
alikePidFileLock.read_pid raising ValueError for a PID file
holding more than 4300 digits, CPython's integer-conversion limit.
No real PID needs more than 20 digits, so longer digit runs now read
as None like any other junk instead of leaking an exception the
contract does not allowRLock.release zeroing the count and claiming the handle in
two separate state-lock scopes: an acquire racing into the gap saw
the count at zero with the handle still published, took the fast
path, and was handed the very filehandle the release then closed.
The count transition and the claim are one atomic scope nowPidFileLock.acquire contender's rollback wiping
the instance state a winning thread had published concurrently: the
winner's __exit__ then no-oped and garbage collection of its
orphaned sidecar freed the OS lock in the middle of the guarded
block. The rollback only clears the state when its own failed
sidecar is the published onePidFileLock.acquire crashing with AssertionError (or
returning None under python -O) when a signal handler's
release() landed between publishing the lock and returning: the
return value is the locally bound sidecar handle now, never re-read
from the shared stateLock.acquire on one instance
is unsupported: with a per-process locker (POSIX lockf) both
lock calls succeed, the second publication overwrites the first, and
the overwritten descriptor's eventual close releases the process's
record locks on the file. That is inherent to POSIX record locks
(any descriptor's close drops them), so no publication strategy can
paper over it; use one instance per threadTemporaryFileLock and the
PidFileLock sidecar against reentrant releases: a handle a
signal handler claimed and closed mid-acquire is retried within the
remaining timeout budget instead of failing the inode verification,
and a closed or OS-level-dead handle found by the held-lock
re-acquire reports the documented compromised-lock LockException
instead of leaking a raw ValueError from fileno() or an
EBADF OSError from fstatLock resolves its path with os.path.abspath
at construction, so the filename attribute now holds an absolute
path. A relative path used to be resolved on every later OS call,
and an os.chdir between acquire and release (the daemonize idiom
does chdir('/')) made release and the interpreter-exit cleanup
unlink another process's equally-named lock files at the new working
directory while leaving the lock's own files behindKeyboardInterrupt during Lock.acquire leaking the
opened descriptor for the traceback's lifetime when it landed in the
retry sleep, and leaving the OS lock held by an untracked descriptor
(with release a silent no-op) when it landed between the
successful lock and the publication of the handle. Every failed exit
from acquire, interrupts included, now unlocks and closes the
descriptor first; PidFileLock.acquire rolls its sidecar back the
same wayTemporaryFileLock
or PidFileLock constructed before a fork and acquired inside the
child: the owning pid was recorded at construction only, so the
child's exit left its lock file, and for PidFileLock a stale PID
payload, behind. Ownership is re-recorded on every fresh acquire.
Also documented that a with lock: block entered before a fork
runs __exit__ in both processes, so the daemonize pattern must
fork outside the block or leave the child via os._exitRLock losing acquire counts when two threads nested
acquires on one instance: the bare read-modify-write let one
increment overwrite the other, and the later releases closed the
file while a hold was still outstanding. The counter transitions run
under the instance state lock now, which also closes the equivalent
lost update on free-threaded (no-GIL) buildsPidFileLock.__exit__ replacing the with body's own
exception with a release error and ignoring
raise_on_release_error in both directions: the POSIX release
leaked unlink errors with the flag unset and the Windows release
swallowed them with it set. The exit path routes through
Lock.__exit__ now (release failures are chained onto the body's
exception instead of masking it) and PidFileLock.release follows
the flag: unlink failures are logged by default and raised in strict
modeTemporaryFileLock and PidFileLock rejecting the
raise_on_release_error keyword their documentation described:
both constructors accept and forward it nowTemporaryFileLock.release
letting every non-PermissionError failure escape regardless of
raise_on_release_error, unlike the POSIX path, and sleeping once
more after its final failed attempt. Non-retryable errors follow the
flag contract now and the trailing sleep is gonePidFileLock.acquire no longer normalizes plain
LockException failures from the sidecar to AlreadyLocked.
AlreadyLocked means contention and nothing else; a terminal
backend failure (ENOLCK, an unsupported filesystem) propagates
as itself instead of telling callers to retry a failure retrying
cannot fixfh, which made every contention raised inside a
multiprocessing worker crash the result pipe with
MaybeEncodingError: ... cannot pickle 'TextIOWrapper' instead of
delivering AlreadyLocked to the parent. Pickling now drops the
handle (an integer descriptor is kept) and the new fh_name
attribute preserves the file's name as a plain string, recursively
for wrapped lock exceptions. copy.deepcopy drops the handle the
same way, while copy.copy keeps fh shared with the original
via an explicit __copy__, since a shallow copy never leaves the
process where the handle is valid. A handle whose name lookup
raises (a detached io.TextIOWrapper) no longer breaks exception
constructionAlreadyLocked raised by Lock.acquire with
fail_when_locked=True having strerror=None with the OS message
buried inside a wrapped inner exception. The wrap now propagates the
locker's own arguments, so .strerror is populated at the Lock
level as the migration guide promises. args[0] is therefore now
the original OSError (POSIX) or error code (Windows) instead of
the inner lock exception, which stays reachable as __cause__.
The wrap also forwards fh and holder_pid from the inner
exception, so fh_name and the holder PID survive a pickle across
a multiprocessing boundary, where __cause__ does notunlock now raises
portalocker.LockException instead of leaking the raw OSError,
matching what the Windows unlock has always done. The OSError
(and its errno) stays reachable through args[0] and
__cause__. The NFS-specific EOFError is wrapped as well,
matching what lock already didexceptions.FileToLarge: no version of this package has
ever raised it, so code catching it catches nothing. The class stays
for backwards compatibility and now emits a DeprecationWarning on
instantiationLOCK_FAILED code as args[0], but the POSIX lockers
put the originating OSError there. Both real shapes are now
described, the doctests build the honest POSIX shape, the module-level
POSIX lock/unlock docstrings note that a raw
(lock, unlock) callable tuple owns its own error translation, and
the README 'r+' example now creates its file firstRedisLock stale-holder cleanup killing healthy holders of
other channels. The cleanup prefix-matched CLIENT LIST names, so a
probe on channel a matched the holders of a channel named
a-lock-b (whose connections are named a-lock-b-lock-<id>) and
killed them, along with any unrelated client whose name happened to
start with a-lock-. Client names are now matched exactly against
the <channel>-lock-<32 character hex holder id> shape, and the
bare legacy <channel>-lock name is still reaped as before (#142)RedisLock sleeping out a jittered check_interval before its
first acquisition attempt, which cost an uncontended acquire roughly
250ms for nothing. The retry generator now yields immediately and only
sleeps between attempts. The probe poll loops stay paced because their
get_message(timeout=...) calls block on their own (#144)RedisLock instance that is already
holding a lock now raises portalocker.LockException instead of
AssertionError. The assert was the only re-acquire guard and
python -O strips asserts, which silently orphaned the worker thread
and left a phantom holder on the channel (#144)RedisLock: holders on
portalocker 3.2.0 and older share one connection name, so one live plus
one crashed legacy holder on a channel cannot be told apart and block
waiters until the crashed holder's TCP connection dies on its own (#144)RedisLock teardown exception safe. release now runs every
teardown step even when an earlier one fails, clears thread,
pubsub and a self-created connection regardless, and re-raises only
the first error, so a failing UNSUBSCRIBE (Redis unreachable while
the lock was held) no longer leaves a stale pubsub behind that made
every later acquire on the instance fail its already-active guard
(#140)RedisLock rollback for a worker thread that fails to
start: the never-started thread is no longer joined, so the original
error propagates out of acquire instead of RuntimeError: cannot join thread before it is started, and the subscribed pubsub no longer
leaks. A rollback that fails as well is logged instead of replacing the
original error (#140)RedisLock.release no longer checks a fresh connection out of the
pool purely to send UNSUBSCRIBE for a subscription the worker
thread already discarded when it stopped. The unsubscribe now only runs
when the pubsub still owns a connection, which is also what made
RedisLock.__del__ fail loudly at interpreter shutdown (#140)RedisLock.__del__ is now best effort and suppresses all errors
instead of surfacing them as interpreter-level "Exception ignored in"
messages during garbage collection or shutdown (#140)RedisLock with a self-created connection (no
connection= argument) killing its own worker thread and delivering a
KeyboardInterrupt to the main thread. The release between retries
closed and cleared the connection while acquire kept resubscribing on
a stale reference, so channel_handler failed its connection assert
and the failure was escalated to the main thread. Retries now drop only
the subscription and keep the connection; the connection is closed on
final release or when acquire gives up (#136)RedisLock probe reading at most one reply per polling
interval, which capped a probe at roughly ten replies inside the default
one second unavailable_timeout no matter how fast the holders
answered. On a channel with more holders than that every probe came up
short and killed healthy holders whose replies were sitting unread in
the prober's own buffer. The reply loop now drains all buffered replies
within each interval, so the interval paces the polling instead of
capping the throughput (#138)RedisLock.acquire races that could let two writers both
conclude they held the lock exclusively. Subscribing now waits for the
server's subscribe confirmation instead of sleeping 10ms, so a subscriber
count can no longer run before the server registered the subscription.
Mode promotions and ping answers now serialize on a threading.Lock,
so a probe can no longer read a torn or stale pending from a writer
mid-promotion. A probe now re-checks the subscriber count immediately
before pinging as well as after collecting replies. Count-preserving
churn between those two checks remains undetectable because PUBSUB NUMSUB reports counts rather than identities, and is tolerated because
losing waiters retry. Also documented that RedisLock requires a
single standalone Redis endpoint, since PUBSUB NUMSUB is node-local
in cluster and replica setups (#139)LockBase.__del__ released the OS lock, closed the
filehandle and, for TemporaryFileLock and PidFileLock, unlinked
the lock file the moment the wrapper was collected. The throwaway idiom
fh = Lock(path).acquire() therefore lost mutual exclusion instantly,
since only the filehandle stays referenced. The finalizer is removed,
restoring the 3.2.0 semantics, and TemporaryFileLock still cleans
up a lock held at interpreter exit through its atexit handler.
That handler resolves a weak reference, so the exit cleanup needs the
wrapper to still be referenced. A wrapper discarded mid-run leaves
the lock file behind at exit, with the lock itself released once the
filehandle is closed or collectedrelease() now honours raise_on_release_error=False on the
Lock and TemporaryFileLock teardown paths:
TemporaryFileLock.release() suppressed only FileNotFoundError
from the unlink, so for example a PermissionError from a read-only
directory escaped despite the default and could replace an exception
already leaving a with block. Suppressed release errors are now
logged at warning level instead of disappearing, which also means
that with no logging configured they print to stderr through Python's
last-resort handler. That is intentional visibility for previously
silent failures, not a new bug. Lock.__exit__ guarantees the
block's own exception wins whether or not raise_on_release_error
is set, with the release error chained on as its __context__, and
the chain is kept free of the reference cycle that a release error
raised while the body exception was in flight used to create.
PidFileLock overrides __exit__ but routes it through
Lock.__exit__ and its release honours the flag as well, both
fixed in this release by the PidFileLock.__exit__ bullet aboveLockBase.__delete__ releasing the wrong object: deleting a
lock stored as a class attribute (del owner.attribute) called
release() on the owner instead of the lock, raising
AttributeError and leaving the lock held. The lock now releases
itselfLock.release()
"continues suppressing unlock and close errors by default": 3.x
propagated those errors, so the suppression was a 4.0.0 behaviour
change. The default stays as documented in 4.0.0, now with the
warning-level logging described abovelock() now validates its flags
on every platform, before any system call. Flags carrying
LockFlags.UNBLOCK raise RuntimeError (on POSIX they used to
silently release the held lock, since the bit went straight through
to fcntl). SHARED | EXCLUSIVE raises RuntimeError. A flag
set naming no lock type at all (LockFlags(0) or NON_BLOCKING
alone) raises RuntimeError on every platform instead of on POSIX
onlyMsvcrtLocker fallback table for LK_* constants
missing from msvcrt. The old values were shifted against the real
<sys/locking.h> numbers, so a "blocking lock" through the fallback
would have issued an unlock (LK_LOCK fell back to the
LK_UNLCK value). The corrected values also now live on the locker
instance instead of being setattr'd onto the shared stdlib
msvcrt moduleWin32Locker.lock now wraps OSError (for example a stale file
descriptor handed to msvcrt.get_osfhandle) in LockException,
matching the unlock path. Previously the raw OSError escaped
lock()Win32Locker now creates a fresh OVERLAPPED structure for every
LockFileEx/UnlockFileEx call instead of reusing one cached
instance across calls and threads, which the Win32 API contract
forbidspython -m portalocker combine now reads and assembles all of its
inputs before opening --output-file. It used to truncate the
output file first, so a non-ASCII byte in an input destroyed a
pre-existing build and died with a raw traceback. Decode failures in
README.rst and LICENSE now log the same snippet, naming the
offending file, that the source modules already gotportalocker.RedisLock is now a stub class whose constructor raises
ImportError naming the dependency and the install command
(pip install "portalocker[redis]"). It used to be None, so
constructing it failed with TypeError: 'NoneType' object is not callable. Code that compared RedisLock is None to detect the
extra should try constructing it and catch ImportError insteadU) mode strings from the
portalocker.types.Mode literal. Python 3.11 removed them, and 3.10
only accepted them with a warning, so this narrows the static typing
contract only and changes nothing at runtimemsvcrt lock retries ten times at one
second intervals and then raises, instead of blocking indefinitely
like POSIX, and added the missing 4.0.0 migration note for
LockfLocker: it silently used flock up to 3.2.0, and the
switch to real lockf changes same-process contention, makes
closing any descriptor for the file drop the locks, and leaves a 3.x
holder and a 4.x holder unable to exclude each other on LinuxLock.acquire leaking an open, still locked filehandle when
preparing the file failed after the lock was taken, for example mode
w on a macOS append-only (chflags uappnd) file, where the
deferred truncate raises EPERM. self.fh was never assigned, so
release was a no-op while the escaping traceback pinned the handle
alive and the file stayed locked indefinitely. The handle is now
unlocked and closed before the original error escapesLock.acquire now retries only contention, which
the locking backend reports as AlreadyLocked. A plain
LockException, such as flock refusing a FIFO or an NFS/SMB
mount without locking support, ENOLCK, or the EOFError some
NFS setups raise from fcntl, is permanent: it is now raised
immediately instead of being retried for the whole timeout, because
retrying cannot make a filesystem grow locking support. With
fail_when_locked=True it is no longer wrapped in
AlreadyLocked, which claimed somebody held a lock on a filesystem
that cannot lock at all. The same classification reaches
BoundedSemaphore: a plain LockException while probing a slot
used to be mistaken for a taken slot and skipped, it now propagates
and aborts the acquire. Custom lockers must raise AlreadyLocked
for contention to keep being retried, as the bundled lockers already
doLockBase._timeout_generator sleeping past its deadline by up
to one full check_interval: a contended Lock(timeout=0.5, check_interval=3) gave up after roughly 3 seconds instead of 0.5.
Every sleep is now capped at the time remaining until the deadline.
RedisLock is unaffected, it overrides the generator with its ownLock built with an explicit timeout (at construction
and again on every acquire), pointing at portalocker's own source
instead of the caller, and firing for RLock,
TemporaryFileLock and PidFileLock instances constructed
without any timeout argument, which failed user suites running with
filterwarnings = error. The subclasses now forward None so the
default timeout no longer counts as caller-provided, and the warning
fires at most once per lock instance, with a stacklevel computed by
walking past portalocker's internal frames so it names the caller's
file from every entry point, subclass constructors includedRLock.acquire on an instance whose acquire count
claims the lock is held while no filehandle exists now raises
portalocker.LockException instead of relying on a bare assert,
which python -O strips, silently handing the caller None as
the filehandleLock modes containing w on POSIX.
The deferred-truncation a substitution left O_APPEND set, so
the kernel ignored seek positions and fh.write('x'); fh.seek(0); fh.write('y') produced 'xy' where the builtin open(mode='w')
produces 'y'. The append flag is now cleared once the truncation
is done. Windows offers no way to drop the flag from an open handle,
so there the append semantics remain and are documentedTemporaryFileLock.acquire destroying a held
lock when a third party unlinked or replaced the lock file (a tmp
cleaner sweeping /tmp is enough). The inode re-check introduced with
the 4.0.0 split-brain fix released and closed the caller's live
filehandle on the mismatch. With the default timeout it then silently
re-acquired a new inode (an unlocked window a competitor could win,
with the caller's original handle left closed), and with timeout=0
it raised AlreadyLocked after having dropped the lock it actually
held. Re-acquiring while holding a still-valid lock file is now an
idempotent no-op returning the held filehandle, and a held lock whose
path was unlinked or replaced externally now raises LockException
and leaves the held filehandle untouched instead of closing it. A
PidFileLock re-acquire runs the same verification on its sidecar.
On both classes release now also skips the unlink, with a warning
in the log, when the held handle no longer names the path, so a
compromised holder cannot delete the lock file a competitor has since
created. The inode comparison uses os.path.samestat, which checks
the device as well as the inodeTemporaryFileLock.acquire verification retry restarting
the full timeout for every attempt, which compounded the worst-case
wall time to roughly timeout**2 / check_interval. The retries now
share a single deadline and every retry is only handed the remaining
budgetPidFileLock.acquire on an instance that already holds the
lock dropping the held OS lock mid-call: the old sidecar Lock was
overwritten, and the discarded object's teardown released the lock
before the replacement re-acquired it, a window another process could
win. A second acquire on a holding instance is now an idempotent no-op
that touches neither the sidecar lock nor the PID filePidFileLock ignoring its instance-level timeout and
check_interval when acquiring with fail_when_locked=False: the
sidecar Lock was built from the per-call arguments only, so a
None argument silently selected the five second module default
instead of the instance attribute, making
PidFileLock(path, timeout=0.4).acquire() block for five seconds
while acquire(timeout=0.4) behaved. The call arguments are now
coalesced with the instance attributes first, per the documented
LockBase contractPidFileLock
destroying the live holder's lock on its own exit. acquire stored
the sidecar Lock before taking it and only except Exception
cleared it, so a KeyboardInterrupt or SystemExit (a SIGTERM
handler calling sys.exit is the usual daemon idiom) left the
instance claiming a lock it never took, and its release, explicit or
via the exit handler, unlinked the PID and sidecar files belonging to
the actual holder, letting the next acquirer create a second holder.
The sidecar reference is now only published after a fully successful
acquire, and release additionally refuses to unlink anything when
the sidecar Lock no longer holds a filehandle. An interrupt
arriving between taking the sidecar lock and publishing it now rolls
the sidecar back as well, where it previously stranded the OS lock on
a local variable that only garbage collection could release, so a
pinned traceback kept every contender blockedPidFileLock used as a context manager now raises
AlreadyLocked on entry when another process holds the lock but its
PID cannot be read (missing, unreadable or invalid PID file). It used
to return None in that case, which the documented contract defines
as "this process is the holder", so a chmod'ed or deleted PID file made
callers run their exclusive block next to a live holderPidFileLock.read_pid now only accepts a plain positive ASCII
decimal and reports anything else as unreadable (None). It used to
parse everything int accepts, including -1, 0, +7,
1_000 and non-ASCII digits, and the obvious consumer feeds the
result to os.kill, where -1 signals every process the user ownsPidFileLock publishing the PID by truncating the PID file in
place, which let a concurrent reader observe the previous (possibly
dead) holder's PID or an empty file mid-write. The PID is now written
to a temporary file next to the PID file and moved over it with
os.replace, so readers see either the old complete PID or the new
complete PIDPidFileLock.release path unlinking the PID file
after releasing the sidecar lock, which could delete the PID a fast
successor had already published. The PID file, which carries no OS lock
on any platform, is now unlinked before the sidecar release, mirroring
the POSIX orderingTemporaryFileLock and PidFileLock now annotate filename as
types.Filename like Lock does, so passing a pathlib.Path,
which always worked at runtime, no longer fails static type checkingBoundedSemaphore
two contradicting fail_when_locked contracts. The constructor
docstring promised that a full semaphore raises AlreadyLocked
straight away, while acquire documented what the code has
actually done since 3.2.0: the flag is consulted only once the
timeout has expired. The runtime behaviour is unchanged and the
constructor docstring was the one corrected. A full semaphore retries
for the whole timeout and then raises AlreadyLocked, or returns
None with fail_when_locked=False. Both the timing and that
None return diverge from the other lock classes and are now
called out loudly in the documentationBoundedSemaphore or
NamedBoundedSemaphore instance that already holds a slot now
raises portalocker.LockException instead of AssertionError.
The assert was the only re-acquire guard and python -O strips
asserts, so a second acquire silently consumed a second slot,
overwrote the reference to the first and starved competitors of a
slot nobody could release anymoreBoundedSemaphore default-name DeprecationWarning
being attributed to portalocker's own source (stacklevel=1). It
now points at the constructing caller, so it names the code to fix
and deduplicates per call site instead of once globallyTemporaryFileLock and PidFileLock registering one
atexit callback per constructed instance and never unregistering
it, which grew without bound in long-running processes churning
through short-lived locks. A single module level hook registered once
at import now releases whichever locks are still held at interpreter
exitTemporaryFileLock and
PidFileLock no longer releases locks a forked child inherited
from its parent: the exit hook now only releases locks constructed by
the exiting process itself. The child inherits the live lock objects,
and its normal exit unlinked the parent's lock files while the parent
still believed it held them, breaking the classic acquire-then-fork
daemonize sequence. Together with 4.2.0's removal of lock teardown at
garbage collection time this closes that fork hole for locks acquired
before forking. A lock constructed in the parent but acquired inside
a forked child belongs to the child: ownership is re-recorded on
every fresh acquire (fixed in this release as well), so that child's
exit cleans its lock upportalocker.open_atomic now raises
FileExistsError when the destination already exists on entry,
matching its documentation and the publication-time race. It raised
AssertionError beforeportalocker.open_atomic: publication
uses a hard link on POSIX, which hard-failed on filesystems without
hard link support (exFAT and some SMB, NFS and FUSE mounts) where
3.2.0's rename worked, and the cleanup then deleted the freshly
written payload as well. Publication now falls back to an existence
check plus rename on those filesystems. The fallback still publishes
content atomically but cannot reliably refuse concurrent publishers,
so the strong no-replace guarantee continues to require hard link
support, as the documentation now statesopen_atomic fails to publish, for any
reason, the temporary file is now kept and the raised exception names
its path, where the payload was previously deleted without a trace.
An exception from the caller's body, on the other hand, now removes
the temporary file that used to be leaked, and a body that closes the
handle itself no longer breaks publication because the payload is
synchronized through a fresh descriptoropen_atomic publishing destinations with the private
0o600 permissions of its temporary file. The temporary file is
now created with mode 0o666 so the kernel applies the process
umask at creation, and the destination carries the permissions a
plain open would have produced, without portalocker ever touching
the process-wide umaskBoundedSemaphore operational hazards: a slot file
deleted externally mid-hold silently admits an extra holder, and the
default directory is the tmp-cleaner-patrolled system temporary
directory, so long-running semaphores need a private directory exempt
from cleanup. Also documented that open_atomic does not fsync the
directory entry, so the published name itself is not guaranteed
durable across power loss<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Fixed the README demonstrating BoundedSemaphore without a name, which the library itself deprecates in favour of NamedBoundedSemaphore
4.1.0:
... bodies on the abstract
LockBase.acquire/LockBase.release stubs with docstrings.ruff's pydocstyle rules
are enabled for portalocker/ with no exemptionscombine CLI, troubleshooting, and a 3.x to 4.0.0
migration guide. The API reference moved under docs/api/ and a
changelog page was addeddocs/platforms.rst documents the advisory-versus-mandatory
distinction, flock versus lockf, msvcrt versus pywin32, and the
networked-filesystem caveats that cause most locking confusiondocs/cli.rst documents the combiner's ASCII-only requirement on
portalocker/*.py, README.rst and LICENSE, which was previously
only discoverable by reading __main__.pydocs/*.rst and README.rst as well as the
package, so every documented example is executed on each supported
platform and interpreter. No # doctest: +SKIP remains anywhereValueError: I/O operation on closed fileBoundedSemaphore without a name,
which the library itself deprecates in favour of NamedBoundedSemaphore<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Fixed open_atomic() replacing a destination created while its context was open on POSIX; publication now raises FileExistsError and preserves the conc
4.0.0:
open_atomic() replacing a destination created while its context
was open on POSIX; publication now raises FileExistsError and preserves
the concurrent winner (#114)pywin32 is no longer installed by default on Windows; the msvcrt-based
locker is the default and works dependency-free for exclusive locks.
Shared locks on Windows require portalocker[win32], and an informative
ImportError is raised otherwise (#104).strerror and pass the message as
a second positional argument, matching the Windows exception contract.
This changes the str() output of these exceptions on POSIX from the
bare OSError text to a 2-tuple reprLockBase is now generic over the acquire return type (typing-only
change; downstream Lock subclasses are unaffected)PidFileLock for pidfile-based locking (#106)PidFileLock.fail_closed() for ownership-only contexts; contention
raises AlreadyLocked before entering the body and exposes the competing
PID through AlreadyLocked.holder_pid when readable (#118)uv_build backend; releases are published to
PyPI through GitHub Actions Trusted Publishingpython -m portalocker combine: --output-file now opens lazily;
the vendored single-file output correctly includes RedisLock (it was
always None before); the smoke-run now uses sys.executable
(fixes Windows)PidFileLock ignoring timeout when fail_when_locked=False;
all PID-publication failures now transactionally release the sidecar and
preserve the publication error if cleanup also fails (#116)TemporaryFileLock/PidFileLock unlock-then-unlink race that
could let two processes hold the same lock (split-brain); release now
unlinks before unlocking on POSIX and acquire re-verifies file identity
(inode) after locking (#115)BoundedSemaphore staying permanently "Already locked" after a
non-contention error (e.g. a missing directory)RedisLock crashed-holder detection: the liveness check was
always satisfied by its own subscribe confirmation, so dead holders were
never reaped; the ping is now published only after the subscription is
confirmed active, pubsub connections no longer leak on the reap path,
fail_when_locked=True fails fast instead of polling the full timeout,
internally-created connections are closed on release, and a failed
acquire() rolls back cleanly so the lock can be retriedRedisLock readers through LockFlags.SHARED. Waiting
writers gate new readers to prevent starvation, holder-specific heartbeats
preserve stale-client cleanup, and legacy Redis lock responses are treated
as exclusive for mixed-version safety (#124)FlockLocker/LockfLocker on POSIX to use their named syscall
(previously silently used the global LOCKER); the module-level
lock()/unlock() on POSIX now accept all documented LOCKER
forms (tuple/instance/class)LockException per the documented contractRedisLock tests now run everywhere via fakeredis, with a live
Redis server still tested in CILock.release() continues suppressing unlock and close errors by default;
closing is always attempted and the file handle reference is cleared.
Callers can opt into reporting cleanup failures with
Lock(..., raise_on_release_error=True) (#117)TemporaryFileLock.release() and PidFileLock.release() are now
no-ops when the object does not hold the lock, so a stale object (double
release, or garbage collection of a failed acquire) can no longer unlink
the lock file out from under the current holderTemporaryFileLock no longer keeps a strong atexit reference to
itself, so unused instances can be garbage collected; cleanup at
interpreter exit still happens via a weak referenceNamedBoundedSemaphore is now exported from the top-level
portalocker namespace<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Rewrote locking mechanism to allow for custom locking classes so both Windows and Posix (Linux/Mac/BSD) systems have configurable locking options for
Rewrote locking mechanism to allow for custom locking classes so both Windows and Posix (Linux/Mac/BSD) systems have configurable locking options for both exclusive and shared locking.
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
removed accidental toml requirements
removed accidental toml requirements
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Improved type hints thanks to @jonde94 and modernised CI setup.
Improved type hints thanks to @jonde94 and modernised CI setup.
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
…formatting and checking. Dropped support for deprecated Python versions, only 3.9 and up are supported now.
Completely modernized portalocker build system and added fully strict pyright and mypy compliance with ruff formatting and checking. Dropped support for deprecated Python versions, only 3.9 and up are supported now.
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
fixed typo thanks to @harmstyler
fixed typo thanks to @harmstyler
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Properly propagating exceptions for NFS read-only lock issues and added support for being able to choose between lockf and flock thanks to @oliver-s-l
Properly propagating exceptions for NFS read-only lock issues and added support for being able to choose between lockf and flock thanks to @oliver-s-lee
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Removed docs from build to fix #88 again
Removed docs from build to fix #88 again
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Removed docs from build to fix #88
Removed docs from build to fix #88
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Added support for Python 3.11 and 3.12 thanks to @hugovk. Made the package fully ruff, pyright and mypy compliant with automated testsing using both t
Added support for Python 3.11 and 3.12 thanks to @hugovk. Made the package fully ruff, pyright and mypy compliant with automated testsing using both tox and Github actions
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Added fail_when_locked=False support to BoundedSemaphore thanks to @flaviens
Added fail_when_locked=False support to BoundedSemaphore thanks to @flaviens
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Added fileno() support. Fixes #80 on posix systems
Added fileno() support. Fixes #80 on posix systems
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Added clear warning when locking in non-blocking mode without specifying either EXCLUSIVE or SHARED mode. Fixes #77
Added clear warning when locking in non-blocking mode without specifying either EXCLUSIVE or SHARED mode. Fixes #77
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Fixed shared locks on Windows and simplified locking mechanism
Fixed shared locks on Windows and simplified locking mechanism
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Added warning when trying to use a timeout in blocking mode. And removed deprecated testing code and checks
Added warning when trying to use a timeout in blocking mode. And removed deprecated testing code and checks
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
commit 5590a941f915904846593745ec632d2e42259534 Merge: 4257ced 0806422 Author: Rick van Hattem Date: Fri Aug 27 15:44:10 2021 +0200
commit 5590a941f915904846593745ec632d2e42259534 Merge: 4257ced 0806422 Author: Rick van Hattem Wolph@wol.ph Date: Fri Aug 27 15:44:10 2021 +0200
Merge tag 'v2.3.2' into develop
Added semver indicator and specified needed Python release thanks to @rayluo v2.3.2
# -----BEGIN PGP SIGNATURE-----
#
# iQIzBAABCgAdFiEEFJMl/RWQTpxOuJ6V6BRE6c4faV0FAmEo7CoACgkQ6BRE6c4f
# aV3OJA/+O4ck6qU/Tf7yudYCYK+xh+dpZ4A3kfxX/Ed5K0Q/1CQhQee1hqO7p4NE
# aTQbLpjsIBrpNNKjgHkz7qKXFDLhjygji0R6YRE4dxXbEbEdC98NY907FMOEO0kM
# cKZt/3FFBpW/LgTYnJ12cIw5Cwh+kHGnRIyisdUZuMcp3sTpANhMZ9eySyhrdh5k
# T3eROMZ+b0qItGnJcMPcyGz/UkkyKWdFH9cN63wMq1doh3nETdib761h47p/hmBz
# FYuYb5rmA9O2OORLJ1D06Q5d/KxIWG5u4XNYoNQ3BWBIPf53bcqkvcnztu5IyJmd
# ojEW8WAMRPp5m4tdS1Y/DrsplQxU5A83VW7Hu0DGB3xv4y0vsO9TIlEPgKCMu/jG
# Je2RQOMJarmLNin4MYs8DCn4p97mQBOyX+HKr4wa2IV+0lJd0+TaTqtKAx626HMQ
# Dq/d58g2n+F0vTjr0+2VeJAhsIXdbgDyAC2NN8rS6DEInmLZgDnHmu57VomEeR7Q
# NcClcO5O2dEtjBLt1SnKkXpjc8VqU1yHMwCnI8KUo40Iq7hLrSBqBGbHP7Jp7rRz
# cWuNdRtRmWTjHnA9JeH327ScC6Ikzuv7rbPRZttHliuGMxxHSLKc48S2xL1k7Cq4
# 5edh7gW5VDvA6e5cevt9PAHLeQRECecWEASkd1ca8AUNkZ+dheE=
# =FmXv
# -----END PGP SIGNATURE-----
# gpg: Signature made Fri Aug 27 15:44:10 2021 CEST
# gpg: using RSA key 149325FD15904E9C4EB89E95E81444E9CE1F695D
# gpg: Good signature from "/Rick van Hattem <wolph@wol.ph>"/ [ultimate]
# gpg: aka "/[jpeg image of size 9662]"/ [ultimate]
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
commit d0eab0512b6640beca9f702f9ea6965ac9d686d5 Merge: 90d267a 248e450 Author: Rick van Hattem Date: Sat Aug 21 11:22:36 2021 +0200
commit d0eab0512b6640beca9f702f9ea6965ac9d686d5 Merge: 90d267a 248e450 Author: Rick van Hattem Wolph@wol.ph Date: Sat Aug 21 11:22:36 2021 +0200
Merge tag 'v2.3.1' into develop
Removed Python 2 classifier thanks to @rayluo v2.3.1
# -----BEGIN PGP SIGNATURE-----
#
# iQIzBAABCgAdFiEEFJMl/RWQTpxOuJ6V6BRE6c4faV0FAmEgxdwACgkQ6BRE6c4f
# aV28wA/+I2QuCx+G+Dqqo6ofvaSVe41f9nkgq+ce8v0guaLXptsZ478uuRMPG+1E
# 6TnuIb4bi0nUJp0C4Qj5ET5554OoD+wEE9t77H8Z18pYMT3Jdm6ZqSAAN+Hrl50/
# AtcP9B3l32Bj9wViaoo/9xt4vL0EDBPqpDo6q/xB/0OPUfMcWAvYky3yIGs61rLQ
# nQIlTqEFjz12dHCh+0uBTJ5AUbKRGYDj5VMufXS56U5jSMcAaIgTRAtPjbJJHTAL
# xoVcO7zgz/4uoAUtEuw+VEqVYMWE88hxnl9jS/KNyZv+QANA0vkRsiEssRw5QFh+
# ftzxZ4PzXDv7WzwF82XVU2c7JwPX9PxlZhtwSRZ00q3Uit2fhTVRXPwbPQ7rb3Is
# tUcT0wxYuIarA53iQEgbfeyWz3Hhi6ayBJeap/OC9KfyXBZiic2tOTTwhOXkBGw6
# w3uJdj8ZDhOLJbtnOaJi51xwlmA861YJODkr3vP2HjjgepgCcQMK0nLPnYHUXYe/
# qKFC9Z1CArgA+1lic4pKC402gpGoG7tJgyldoagKsbDgbz5nTKt/BQLhjT3vPavJ
# bYTphyQ4H3WUkK6ac5M6gN4exSBACYaKWyL7DltPoBrP8CyOzFexTCkoUw9WYCwv
# 8ut8Y7cqN9Da++Xgnfj6sdrY9IuCpPQJZCWJ1NOhMAORN1sMw+g=
# =YDYj
# -----END PGP SIGNATURE-----
# gpg: Signature made Sat Aug 21 11:22:36 2021 CEST
# gpg: using RSA key 149325FD15904E9C4EB89E95E81444E9CE1F695D
# gpg: Good signature from "/Rick van Hattem <wolph@wol.ph>"/ [ultimate]
# gpg: aka "/[jpeg image of size 9662]"/ [ultimate]
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
commit 631352fbfd9f2b780a6d5f9da39646f4088910aa Merge: e99c2d6 ec9f5da Author: Rick van Hattem Date: Sun Mar 28 04:18:59 2021 +0200
commit 631352fbfd9f2b780a6d5f9da39646f4088910aa Merge: e99c2d6 ec9f5da Author: Rick van Hattem Wolph@wol.ph Date: Sun Mar 28 04:18:59 2021 +0200
Merge tag 'v2.3.0' into develop
enabled PEP 561 compliance v2.3.0
# gpg: Signature made Sun 28 Mar 04:18:59 2021 CEST
# gpg: using RSA key 149325FD15904E9C4EB89E95E81444E9CE1F695D
# gpg: Good signature from "/Rick van Hattem <wolph@wol.ph>"/ [ultimate]
# gpg: aka "/[jpeg image of size 9662]"/ [ultimate]
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
commit 638f67af428413ef6b2a45633b6e4f034b11f272 Merge: ad33bc1 061837e Author: Rick van Hattem Date: Wed Feb 3 02:10:59 2021 +0100
commit 638f67af428413ef6b2a45633b6e4f034b11f272 Merge: ad33bc1 061837e Author: Rick van Hattem Wolph@wol.ph Date: Wed Feb 3 02:10:59 2021 +0100
Merge tag 'v2.2.1' into develop
removed debug statement v2.2.1
# gpg: Signature made Wed Feb 3 02:10:59 2021 CET
# gpg: using RSA key 149325FD15904E9C4EB89E95E81444E9CE1F695D
# gpg: Good signature from Rick van Hattem <wolph@wol.ph> [ultimate]
# gpg: aka [jpeg image of size 9662] [ultimate]
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
commit 3c5ea798a5bb8163a5deabc866934ff3d08b3191 Author: Rick van Hattem Date: Sat Jan 30 02:27:50 2021 +0100
commit 3c5ea798a5bb8163a5deabc866934ff3d08b3191 Author: Rick van Hattem Wolph@wol.ph Date: Sat Jan 30 02:27:50 2021 +0100
updated travis location
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v2.1.0 Added Redis based distributed lock which gracefully handles connection loss and dying applications. Added full type hinting support. Fixed bug
v2.1.0 Added Redis based distributed lock which gracefully handles connection loss and dying applications. Added full type hinting support. Fixed bug where the file handle was not always explicitly closed with errors
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v2.0.0 Removed support for old Python versions. Versions 3.5 and above are supported. Added BoundedSemaphore class
v2.0.0 Removed support for old Python versions. Versions 3.5 and above are supported. Added BoundedSemaphore class
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.7.1 removed tests from wheel file
v1.7.1 removed tests from wheel file
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.7.0 Fix ResourceWarning unclosed file if LockException is raised. Thanks to @ahauan4
v1.7.0 Fix ResourceWarning unclosed file if LockException is raised. Thanks to @ahauan4
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.6.0 Fixed unlocking bug on Windows. Fixes #49
v1.6.0 Fixed unlocking bug on Windows. Fixes #49
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.5.2 Aded workaround for broken pywin32 226 release. Fixes #48
v1.5.2 Aded workaround for broken pywin32 226 release. Fixes #48
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.5.1 Exclude portalocker_tests from installed packages
v1.5.1 Exclude portalocker_tests from installed packages
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.5.0 Renamed tests to prevent collisions with other packages
v1.5.0 Renamed tests to prevent collisions with other packages
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.4.0 Fixed #42. Added support for file open kwargs
v1.4.0 Fixed #42. Added support for file open **kwargs
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.3.0 Added fh attribute to LockExceptions which contain the file handle
v1.3.0 Added fh attribute to LockExceptions which contain the file handle
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
<!-- ppt-signed --> Signed on 2026-11-12 with ppt sign, after the release. The files above are the exact PyPI uploads for this version, verified by sh
v1.2.1 Modernized requirements
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.2.0 Finally got windows working with both python 2 and python 3?
v1.2.0 Finally got windows working with both python 2 and python 3?
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.1.0 Fixed crash with python 3.6 (#32) and using real time to calculate timeout (#33) thanks to @TWAC
v1.1.0 Fixed crash with python 3.6 (#32) and using real time to calculate timeout (#33) thanks to @TWAC
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.0.1 Changed default for fail_when_locked to be more logical
v1.0.1 Changed default for fail_when_locked to be more logical
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v1.0.0 1.0.0 changes the default behaviour of the Lock class from truncate to append which makes it safer for new users. Additionally it features much
v1.0.0 1.0.0 changes the default behaviour of the Lock class from truncate to append which makes it safer for new users. Additionally it features much improved documentation, restructured code, 100% test coverage and a single combined file for easy integration with other projects.
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
<!-- ppt-signed --> Signed on 2026-11-12 with ppt sign, after the release. The files above are the exact PyPI uploads for this version, verified by sh
v0.6.1 Updated wheel
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Nothing published for this version
Release 0.5.7. No changelog section was found at tag v0.5.7.
Release 0.5.7. No changelog section was found at tag v0.5.7.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
v0.5.6 Added atomic_write utility function
v0.5.6 Added atomic_write utility function
<!-- ppt-signed -->
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Release 0.5.5. No changelog section was found at tag v0.5.5.
Release 0.5.5. No changelog section was found at tag v0.5.5.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Release 0.5.4. No changelog section was found at tag v0.5.4.
Release 0.5.4. No changelog section was found at tag v0.5.4.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Nothing published for this version
Release 0.5.1. No changelog section was found at tag v0.5.1.
Release 0.5.1. No changelog section was found at tag v0.5.1.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Nothing published for this version
Release 0.4. No changelog section was found at tag v0.4.
Release 0.4. No changelog section was found at tag v0.4.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Release 0.3. No changelog section was found at tag v0.3.
Release 0.3. No changelog section was found at tag v0.3.
Signed on 2026-11-12 with ppt sign, after the release.
The files above are the exact PyPI uploads for this version, verified by sha256 against PyPI before signing.
Each file has a GPG signature (.asc, key 149325FD15904E9C4EB89E95E81444E9CE1F695D) and a Sigstore bundle (.sigstore.json).
SHA256SUMS.asc signs the checksum list.
Rebuilt files, if any: none.
How to verify: https://github.com/WoLpH/python-project-tools/blob/master/VERIFY.md
Nothing published for this version
Nothing published for this version
One column per quarter.