Skip to content

fix(deps): update dependency pyrate-limiter to v4 - #2144

Open
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/pyrate-limiter-4.x
Open

renovate[bot] wants to merge 1 commit into
mainfrom
renovate/pyrate-limiter-4.x

Conversation

@renovate

@renovate renovate Bot commented Nov 10, 2026

Copy link
Copy Markdown
Contributor

This PR contains the following updates:

Package Change Age Confidence
pyrate-limiter >= 3, < 4 → >=3, <5 age confidence

Release Notes

vutran1710/PyrateLimiter (pyrate-limiter)

v4.5.1

Compare Source

Bug fixes only. One behaviour change to note: a decorated call that the limiter
can never admit now raises instead of running (see the first entry).

Fixed
  • as_decorator ran the wrapped function even when denied. Both the sync
    and async wrappers discarded the result of try_acquire() and called the
    function unconditionally. With the default blocking=True, timeout=-1 that
    result is only False when the weight can never be admitted under the
    configured rates (e.g. weight=5 on Rate(2, Duration.SECOND)), so the
    limiter's verdict was silently bypassed. Such calls now raise RuntimeError.
  • Limiter.close() never closed its buckets. BucketFactory.close() read
    the bucket list off the leaker after tearing the leaker down, so it always
    iterated an empty list: SQLite connections and Postgres connection pools
    stayed open. It now snapshots the buckets first. SingleBucketFactory also
    closes its bucket when no leak was ever scheduled; factories that hold buckets
    outside the leaker can extend the new BucketFactory.owned_buckets().
  • Async wrappers lost StateBucket waits. BucketAsyncWrapper.waiting()
    called the generic log-bucket implementation instead of the wrapped bucket's,
    so GCRA / TokenBucket waits came back as -1 or 0. An admissible request
    could be rejected outright, or a blocking limiter could retry without waiting.
  • Async blocking retries recorded stale timestamps. After an async wait the
    retry loop advanced the item's timestamp by the requested delay only. A late
    wake-up therefore recorded the acquisition in the past and let later requests
    through early. The timestamp is now re-read from the bucket factory's clock,
    and the deadline is enforced around the whole retry loop.
  • PostgresBucket: the advisory lock that serialises table creation is now
    keyed by a CRC-32 of the table name rather than hash(), which Python salts
    per interpreter. Processes sharing a database took different locks, so their
    concurrent CREATE TABLE IF NOT EXISTS could fail with UniqueViolation on
    pg_type_typname_nsp_index.
  • PostgresBucket.peek read timestamps as UTC. The item_timestamp column
    is a TIMESTAMP that TO_TIMESTAMP fills through the session time zone, but
    peek took its epoch as if it were UTC. Outside UTC every peeked item sat the
    zone's offset in the future, so a full bucket computed a wait of that many
    hours and blocking callers slept through it. peek now casts the column back
    through the session zone.

v4.5.0

Compare Source

Pluggable rate-limiting algorithms. Additive — no breaking public API changes;
the default behaviour of every existing bucket is unchanged.

Added
  • GCRA / TokenBucket algorithms, and StateBucket to run them. These
    keep a couple of numbers per key instead of one entry per consumed unit, so
    storage does not grow with traffic and the wait is exact without any lookup.
    TokenBucket is GCRA under a familiar name — one implementation, not two.

    from pyrate_limiter import Duration, Limiter, Rate, StateBucket, TokenBucket
    
    limiter = Limiter(StateBucket([Rate(5, Duration.SECOND, burst=10)], algorithm=TokenBucket()))

    Stores: InMemoryStateStore, MultiprocessStateStore, and RedisStateStore
    (transition runs as a Lua script, so the read-modify-write is atomic across
    clients; keys carry a TTL and need no leak()). For a 1000/minute limit at
    saturation the Redis state is ~100 bytes against roughly 89 KB of sorted set.
    GCRA's state is integer microseconds rather than fractional milliseconds:
    accumulating a fractional emission interval onto an absolute timestamp loses
    the low bits, which would reject the last unit of a full burst.

  • Rate(..., burst=N) — how many units may be spent at once. Read only by
    the constant-state algorithms; defaults to limit, which is classic
    token-bucket behaviour. burst=1 is a perfectly smooth drip.

  • WallClock — epoch-millisecond clock, for state compared across machines
    where a monotonic clock is meaningless. RedisStateStore defaults to it.

  • limiter_factory.create_token_bucket_limiter().

  • FixedWindow algorithm. Counts within a wall-clock-aligned window that
    resets every interval, rather than a rolling one. Pass it to any built-in
    bucket: InMemoryBucket(rates, algorithm=FixedWindow()). Cheaper and coarser
    than the default — up to 2 * limit can pass across a boundary — and the
    right choice for mirroring an upstream API that genuinely resets on the hour.
    Works on all five backends.

  • Every built-in bucket now takes an algorithm= argument, defaulting to
    SlidingWindowLog(). Existing code is unaffected.

  • Decision now carries retry_after_ms alongside the verdict, and put()
    records it. AbstractBucket.waiting() reads that recording instead of
    deriving the wait from storage a second time. Custom buckets that record
    nothing keep working: waiting() falls back to the previous peek()-based
    derivation.

  • AbstractBucket.put_decision() returns the full Decision for a put, so the
    verdict and the retry-after arrive together rather than via the
    failing_rate attribute plus a follow-up waiting() call.

  • Algorithm, LogAlgorithm, Decision and SlidingWindowLog are exported
    from the package root.

Fixed
  • Packaging: the optional backends are now real, pip-installable extras.
    pip install "pyrate-limiter[all]" — the command the README has always
    documented — previously resolved to nothing: the project declared only PEP 735
    [dependency-groups], which pip cannot reach through extras syntax, so the
    install emitted WARNING: does not provide the extra 'all' and then failed at
    import redis. redis, postgres, filelock and all now all work.
  • SQLiteBucket: a successful put() now clears failing_rate. Every other
    backend already did; SQLite left the last denial standing indefinitely.
Performance
  • RedisBucket: the Lua script returns the blocking item's timestamp with the
    verdict, so a rate-limited request no longer needs a second ZRANGE round
    trip to learn how long to wait — and the wait can no longer be computed
    against a sorted set that moved in between.
  • PostgresBucket: the retry-after is resolved inside the same EXCLUSIVE
    table lock as the check, removing both a round trip and that same race.
  • SQLiteBucket: likewise resolved inside put()'s existing lock hold, so
    the background Leaker cannot delete rows between the verdict and the wait.
  • InMemoryBucket / MultiprocessBucket: the wait falls out of the bisect
    put() already performs — no second scan, and no allocation on the admit path.
Documentation
  • The README and package description no longer describe the library as
    implementing "the Leaky-Bucket algorithm". The default has always been a
    sliding-window log; the leaky-bucket meter is now genuinely available as
    GCRA, so the term is reserved for it.
Internal / Refactor
  • StateAlgorithm declares redis_args(rates) so a policy's Lua script and its
    arguments stay a matched pair it owns. RedisStateStore passes them through
    without inspecting them, rather than assuming GCRA's shape.
  • Algorithm.max_weight(rate) is the one place asking whether a weight can ever
    be admitted — rate.limit for the window algorithms, rate.burst for GCRA.
  • Algorithm now has two sub-interfaces: LogAlgorithm (an entry per consumed
    unit) and StateAlgorithm (a fixed tuple of numbers). StateAlgorithm.step()
    must evaluate every rate before committing any of them, so a rate failing late
    never leaves an earlier one debited.
  • Split LogAlgorithm out of Algorithm for policies whose state is a log of
    timestamped items. leak_bound() and the new blocking_offset() /
    retry_after() hooks live there; constant-state policies (token bucket, GCRA)
    will not implement it.
  • The inclusive-window +1 boundary correction now lives in exactly one place
    (SlidingWindowLog.retry_after) instead of being inlined in waiting().

v4.4.0

Compare Source

Bug-fix, scalability, and internal-refactor release. No public API changes
(the new AbstractBucket.is_async attribute is additive).

Fixed
  • InMemoryBucket: guard the internal item list with a lock so the
    background Leaker thread can no longer race put/peek/leak. This was a
    data race in the default configuration (in-memory bucket + scheduled leak).
    MultiprocessBucket aliases this lock to its shared cross-process lock. (#​302)
  • PostgresClock: when the DB time query fails, fall back to local
    wall-clock epoch time instead of monotonic time. The monotonic fallback
    was ~5 orders of magnitude smaller than the stored epoch-ms timestamps and
    would corrupt every window comparison and leak bound. (#​302)
  • Leaker: make the background sync-leak worker restartable. Re-registering a
    bucket after every bucket had been disposed previously raised
    RuntimeError: threads can only be started once. (#​302)
  • Keep Limiter picklable after the InMemoryBucket lock addition. (#​302)
Performance & Scalability
  • Limiter: release the limiter lock during the synchronous blocking wait, so
    a long wait on one key no longer serializes acquisitions for every other key
    sharing the limiter. (#​304)
  • RedisBucket: batch weighted ZADDs in bounded chunks inside the atomic
    Lua script, lowering latency for high-weight puts. (#​284)
Internal / Refactor
  • Unify the limiter's sync/async acquire plumbing into a single coroutine and
    share the delay-step decision across the sync and async branches. (#​303)
  • Add a declarative is_async bucket attribute so the Leaker no longer detects
    async by executing a side-effecting leak(0) probe. RedisBucket still probes
    because it may wrap either a sync or an async client. (#​305)
  • Introduce an internal Algorithm/Decision seam (SlidingWindowLog) that the
    built-in buckets delegate their per-rate admit decision and leak bound to —
    the foundation for pluggable algorithms (e.g. GCRA, sliding-window-counter) in
    a future release. (#​307)
Documentation
  • Document that RedisBucket keeps one sorted-set member per consumed unit, and
    that long-window / high-volume quotas may want a coarser counter-based backend
    for bounded memory. (#​284)
CI
  • The release workflow now also creates a GitHub Release for the pushed tag and
    attaches the built dist/* artifacts, in addition to publishing to PyPI.

v4.3.1

Compare Source

Performance and maintenance release. No API or behavior changes.

Performance
  • PostgresBucket: insert all weight unit-rows in a single statement
    (SELECT … FROM generate_series) instead of one INSERT per unit — ~3.4×
    faster weighted puts and a shorter EXCLUSIVE lock hold. (#​296)
  • PostgresBucket: compute every rate's windowed count in one query
    (COUNT(*) FILTER) instead of one round trip per rate — ~2× faster
    multi-rate checks, fewer round trips under the lock. (#​297)
  • SingleBucketFactory.wrap_item: inline the sync fast path (no
    per-acquire closures) — ~23% faster item wrapping on the hot path. (#​296)
  • Deduplicate the sync/async deadline math in _delay_waiter into a single
    shared helper. (#​294)
Documentation
  • Rewrite the README for accuracy, structure, and presentation, and replace the
    outdated architecture image with a component-level Mermaid diagram that
    renders on both GitHub and ReadTheDocs. (#​293, #​295)
CI
  • Move GitHub Actions off the deprecated Node-20 runtime to Node-24
    (checkout@v5, setup-python@v6, setup-uv@v7, upload-artifact@v6,
    download-artifact@v7). (#​295)

v4.3.0

Compare Source

Bug-fix and hardening release. It contains a few breaking changes that affect
only edge or undocumented usage — see Breaking Changes below.

Breaking Changes
  • Ill-formed rate lists now raise ValueError at bucket construction instead
    of being silently mis-enforced. A valid list is ordered by strictly
    increasing interval, with strictly increasing limits and non-increasing
    density (the "generous-before-tight" contract). (#​239)
  • binary_search has been removed from the public API. It was an undocumented
    internal helper, now replaced internally by the standard library bisect. (#​290)
  • PgQueries SQL templates now use bound %s parameters instead of the
    {offset} / {timestamp} format placeholders. (#​233)
Security
  • SQLite and Postgres backends no longer build SQL through string
    interpolation. The user-supplied item name (SQLite) and the table name
    (Postgres) are now bound/quoted, closing a SQL-injection vector and fixing
    crashes on names containing quotes or other metacharacters. (#​233, #​244)
Fixed
  • Blocking try_acquire no longer busy-spins (burning CPU until the next
    background leak) or spuriously times out when buffer_ms=0; waiting() now
    clears the inclusive window lower bound correctly. (#​289)
  • try_acquire_async(timeout=0) now succeeds when capacity is available
    instead of always returning False. (#​289)
  • SQLite leak() no longer raises AttributeError when invoked on a closed
    connection during teardown (fixes the unstable test_sqlite_filelock_bucket). (#​244)
  • Rate lists are now consistently sorted by interval across all backends,
    fixing a latent leak() bug when unsorted rates were passed to the Redis,
    SQLite, or Postgres buckets. (#​239)
Changed
  • Replaced the custom binary_search with the standard library bisect. (#​290)
Documentation
  • Fixed stale v4 examples in the README (removed the long-gone clock=,
    raise_when_fail, and max_delay parameters) and documented how to use a
    custom / distributed clock in v4. (#​261)

v4.2.0

Compare Source

What's Changed

New Contributors

Full Changelog: vutran1710/PyrateLimiter@v4.1.0...v4.2.0

v4.1.0

Compare Source

What's Changed

New Contributors

Full Changelog: vutran1710/PyrateLimiter@v4.0.2...v4.1.0

v4.0.2

Compare Source

Include missing docs & tests

What's Changed

Full Changelog: vutran1710/PyrateLimiter@v4.0.1...v4.0.2

v4.0.1

Compare Source

Nothing, just the same as v4.0.0


Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.


  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate Bot changed the title fix(deps): update dependency pyrate-limiter to v4 fix(deps): update dependency pyrate-limiter to v4 - autoclosed Nov 21, 2026
@renovate renovate Bot closed this Nov 21, 2026
@renovate
renovate Bot deleted the renovate/pyrate-limiter-4.x branch November 21, 2026 04:30
@renovate renovate Bot changed the title fix(deps): update dependency pyrate-limiter to v4 - autoclosed fix(deps): update dependency pyrate-limiter to v4 Nov 21, 2026
@renovate renovate Bot reopened this Nov 21, 2026
@renovate
renovate Bot force-pushed the renovate/pyrate-limiter-4.x branch 2 times, most recently from 6f6c9e6 to 51ceb5a Compare November 21, 2026 06:14

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

0 participants