limits 4.7.2__py3-none-any.whl → 5.0.0rc1__py3-none-any.whl

limits/resources/redis/lua_scripts/acquire_moving_window.lua

@@ -12,11 +12,14 @@ local entry = redis.call('lindex', KEYS[1], limit - amount)
 if entry and tonumber(entry) >= timestamp - expiry then
     return false
 end
-
+local entries = {}
 for i = 1, amount do
-    redis.call('lpush', KEYS[1], timestamp)
+    entries[i] = timestamp
 end
 
+for i=1,#entries,5000 do
+    redis.call('lpush', KEYS[1], unpack(entries, i, math.min(i+4999, #entries)))
+end
 redis.call('ltrim', KEYS[1], 0, limit - 1)
 redis.call('expire', KEYS[1], expiry)
 

limits/resources/redis/lua_scripts/moving_window.lua

@@ -1,21 +1,30 @@
-local items = redis.call('lrange', KEYS[1], 0, tonumber(ARGV[2]))
+local len = tonumber(ARGV[2])
 local expiry = tonumber(ARGV[1])
-local a = 0
-local oldest = nil
 
-for idx=1,#items do
-    if tonumber(items[idx]) >= expiry then
-        a = a + 1
+-- Binary search to find the oldest valid entry in the window
+local function oldest_entry(high, target)
+    local low = 0
+    local result = nil
 
-        local value = tonumber(items[idx])
-        if oldest == nil or value < oldest then
-            oldest = value
+    while low <= high do
+        local mid = math.floor((low + high) / 2)
+        local val = tonumber(redis.call('lindex', KEYS[1], mid))
+
+        if val and val >= target then
+            result = mid
+            low = mid + 1
+        else
+            high = mid - 1
         end
-    else
-        break
     end
+
+    return result
 end
 
-if oldest then
-    return {tostring(oldest), a}
-end
+local index = oldest_entry(len - 1, expiry)
+
+if index then
+    local count = index + 1
+    local oldest = tonumber(redis.call('lindex', KEYS[1], index))
+    return {tostring(oldest), count}
+end

limits/storage/__init__.py

@@ -12,7 +12,6 @@ import limits  # noqa
 from ..errors import ConfigurationError
 from ..typing import TypeAlias, cast
 from .base import MovingWindowSupport, SlidingWindowCounterSupport, Storage
-from .etcd import EtcdStorage
 from .memcached import MemcachedStorage
 from .memory import MemoryStorage
 from .mongodb import MongoDBStorage, MongoDBStorageBase
@@ -67,7 +66,6 @@ def storage_from_string(
 
 
 __all__ = [
-    "EtcdStorage",
     "MemcachedStorage",
     "MemoryStorage",
     "MongoDBStorage",

limits/storage/base.py

@@ -71,16 +71,12 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
         raise NotImplementedError
 
     @abstractmethod
-    def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    def incr(self, key: str, expiry: int, amount: int = 1) -> int:
         """
         increments the counter for a given rate limit key
 
         :param key: the key to increment
         :param expiry: amount in seconds for the key to expire in
-        :param elastic_expiry: whether to keep extending the rate limit
-         window every hit.
         :param amount: the number to increment by
         """
         raise NotImplementedError

limits/storage/memcached.py

@@ -166,7 +166,6 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         self,
         key: str,
         expiry: float,
-        elastic_expiry: bool = False,
         amount: int = 1,
         set_expiration_key: bool = True,
     ) -> int:
@@ -175,43 +174,21 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
 
         :param key: the key to increment
         :param expiry: amount in seconds for the key to expire in
-        :param elastic_expiry: whether to keep extending the rate limit
          window every hit.
         :param amount: the number to increment by
         :param set_expiration_key: set the expiration key with the expiration time if needed. If set to False, the key will still expire, but memcached cannot provide the expiration time.
         """
-        value = self.call_memcached_func(self.storage.incr, key, amount, noreply=False)
-        if value is not None:
-            if elastic_expiry:
-                self.call_memcached_func(self.storage.touch, key, ceil(expiry))
-                if set_expiration_key:
-                    self.call_memcached_func(
-                        self.storage.set,
-                        self._expiration_key(key),
-                        expiry + time.time(),
-                        expire=ceil(expiry),
-                        noreply=False,
-                    )
-
+        if (
+            value := self.call_memcached_func(
+                self.storage.incr, key, amount, noreply=False
+            )
+        ) is not None:
             return value
         else:
             if not self.call_memcached_func(
                 self.storage.add, key, amount, ceil(expiry), noreply=False
             ):
-                value = self.storage.incr(key, amount) or amount
-
-                if elastic_expiry:
-                    self.call_memcached_func(self.storage.touch, key, ceil(expiry))
-                    if set_expiration_key:
-                        self.call_memcached_func(
-                            self.storage.set,
-                            self._expiration_key(key),
-                            expiry + time.time(),
-                            expire=ceil(expiry),
-                            noreply=False,
-                        )
-
-                return value
+                return self.storage.incr(key, amount) or amount
             else:
                 if set_expiration_key:
                     self.call_memcached_func(

limits/storage/memory.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import bisect
 import threading
 import time
 from collections import Counter, defaultdict
@@ -25,7 +26,7 @@ class MemoryStorage(
 ):
     """
     rate limit storage using :class:`collections.Counter`
-    as an in memory storage for fixed and elastic window strategies,
+    as an in memory storage for fixed and sliding window strategies,
     and a simple list to implement moving window strategy.
 
     """
@@ -56,9 +57,11 @@ class MemoryStorage(
     def __expire_events(self) -> None:
         for key in list(self.events.keys()):
             with self.locks[key]:
-                for event in list(self.events[key]):
-                    if event.expiry <= time.time() and event in self.events[key]:
-                        self.events[key].remove(event)
+                events = self.events.get(key, [])
+                oldest = bisect.bisect_left(
+                    events, -time.time(), key=lambda event: -event.expiry
+                )
+                self.events[key] = self.events[key][:oldest]
                 if not self.events.get(key, None):
                     self.locks.pop(key, None)
         for key in list(self.expirations.keys()):
@@ -78,26 +81,20 @@ class MemoryStorage(
     ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
         return ValueError
 
-    def incr(
-        self, key: str, expiry: float, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    def incr(self, key: str, expiry: float, amount: int = 1) -> int:
         """
         increments the counter for a given rate limit key
 
         :param key: the key to increment
         :param expiry: amount in seconds for the key to expire in
-        :param elastic_expiry: whether to keep extending the rate limit
-         window every hit.
         :param amount: the number to increment by
         """
         self.get(key)
         self.__schedule_expiry()
         with self.locks[key]:
             self.storage[key] += amount
-
-            if elastic_expiry or self.storage[key] == amount:
+            if self.storage[key] == amount:
                 self.expirations[key] = time.time() + expiry
-
         return self.storage.get(key, 0)
 
     def decr(self, key: str, amount: int = 1) -> int:
@@ -157,7 +154,7 @@ class MemoryStorage(
             if entry and entry.atime >= timestamp - expiry:
                 return False
             else:
-                self.events[key][:0] = [Entry(expiry) for _ in range(amount)]
+                self.events[key][:0] = [Entry(expiry)] * amount
                 return True
 
     def get_expiry(self, key: str) -> float:
@@ -167,21 +164,6 @@ class MemoryStorage(
 
         return self.expirations.get(key, time.time())
 
-    def get_num_acquired(self, key: str, expiry: int) -> int:
-        """
-        returns the number of entries already acquired
-
-        :param key: rate limit key to acquire an entry in
-        :param expiry: expiry of the entry
-        """
-        timestamp = time.time()
-
-        return (
-            len([k for k in self.events.get(key, []) if k.atime >= timestamp - expiry])
-            if self.events.get(key)
-            else 0
-        )
-
     def get_moving_window(self, key: str, limit: int, expiry: int) -> tuple[float, int]:
         """
         returns the starting point and the number of entries in the moving
@@ -192,13 +174,12 @@ class MemoryStorage(
         :return: (start of window, number of acquired entries)
         """
         timestamp = time.time()
-        acquired = self.get_num_acquired(key, expiry)
-
-        for item in self.events.get(key, [])[::-1]:
-            if item.atime >= timestamp - expiry:
-                return item.atime, acquired
-
-        return timestamp, acquired
+        if events := self.events.get(key, []):
+            oldest = bisect.bisect_left(
+                events, -(timestamp - expiry), key=lambda entry: -entry.atime
+            )
+            return events[oldest - 1].atime, oldest
+        return timestamp, 0
 
     def acquire_sliding_window_entry(
         self,

limits/storage/mongodb.py

@@ -144,9 +144,7 @@ class MongoDBStorageBase(
 
         return counter and counter["count"] or 0
 
-    def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    def incr(self, key: str, expiry: int, amount: int = 1) -> int:
         """
         increments the counter for a given rate limit key
 
@@ -175,9 +173,7 @@ class MongoDBStorageBase(
                                 "$cond": {
                                     "if": {"$lt": ["$expireAt", "$$NOW"]},
                                     "then": expiration,
-                                    "else": (
-                                        expiration if elastic_expiry else "$expireAt"
-                                    ),
+                                    "else": "$expireAt",
                                 }
                             },
                         }
@@ -210,13 +206,13 @@ class MongoDBStorageBase(
         :return: (start of window, number of acquired entries)
         """
         timestamp = time.time()
-        result = list(
+        if result := list(
             self.windows.aggregate(
                 [
                     {"$match": {"_id": key}},
                     {
                         "$project": {
-                            "entries": {
+                            "filteredEntries": {
                                 "$filter": {
                                     "input": "$entries",
                                     "as": "entry",
@@ -225,21 +221,16 @@ class MongoDBStorageBase(
                             }
                         }
                     },
-                    {"$unwind": "$entries"},
                     {
-                        "$group": {
-                            "_id": "$_id",
-                            "min": {"$min": "$entries"},
-                            "count": {"$sum": 1},
+                        "$project": {
+                            "min": {"$min": "$filteredEntries"},
+                            "count": {"$size": "$filteredEntries"},
                         }
                     },
                 ]
             )
-        )
-
-        if result:
+        ):
             return result[0]["min"], result[0]["count"]
-
         return timestamp, 0
 
     def acquire_entry(self, key: str, limit: int, expiry: int, amount: int = 1) -> bool:
@@ -299,7 +290,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -311,7 +302,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -319,29 +310,29 @@ class MongoDBStorageBase(
                                 "else": {"$ifNull": ["$currentCount", 0]},
                             }
                         },
-                        "expiresAt": {
+                        "expireAt": {
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
                                 "then": {
-                                    "$add": ["$expiresAt", expiry_ms],
+                                    "$add": ["$expireAt", expiry_ms],
                                 },
-                                "else": "$expiresAt",
+                                "else": "$expireAt",
                             }
                         },
                     }
                 }
             ],
             return_document=self.lib.ReturnDocument.AFTER,
-            projection=["currentCount", "previousCount", "expiresAt"],
+            projection=["currentCount", "previousCount", "expireAt"],
         ):
             expires_at = (
-                (result["expiresAt"].replace(tzinfo=datetime.timezone.utc).timestamp())
-                if result.get("expiresAt")
+                (result["expireAt"].replace(tzinfo=datetime.timezone.utc).timestamp())
+                if result.get("expireAt")
                 else time.time()
             )
             current_ttl = max(0, expires_at - time.time())
@@ -368,7 +359,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -384,7 +375,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -392,22 +383,22 @@ class MongoDBStorageBase(
                                 "else": {"$ifNull": ["$currentCount", 0]},
                             }
                         },
-                        "expiresAt": {
+                        "expireAt": {
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
                                 "then": {
                                     "$cond": {
-                                        "if": {"$gt": ["$expiresAt", 0]},
-                                        "then": {"$add": ["$expiresAt", expiry_ms]},
+                                        "if": {"$gt": ["$expireAt", 0]},
+                                        "then": {"$add": ["$expireAt", expiry_ms]},
                                         "else": {"$add": ["$$NOW", 2 * expiry_ms]},
                                     }
                                 },
-                                "else": "$expiresAt",
+                                "else": "$expireAt",
                             }
                         },
                     }
@@ -427,7 +418,7 @@ class MongoDBStorageBase(
                                                             0,
                                                             {
                                                                 "$subtract": [
-                                                                    "$expiresAt",
+                                                                    "$expireAt",
                                                                     {
                                                                         "$add": [
                                                                             "$$NOW",

limits/storage/redis.py

@@ -201,7 +201,6 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         self,
         key: str,
         expiry: int,
-        elastic_expiry: bool = False,
         amount: int = 1,
     ) -> int:
         """
@@ -213,12 +212,7 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         :param amount: the number to increment by
         """
         key = self.prefixed_key(key)
-        if elastic_expiry:
-            value = self.get_connection().incrby(key, amount)
-            self.get_connection().expire(key, expiry)
-            return value
-        else:
-            return int(self.lua_incr_expire([key], [expiry, amount]))
+        return int(self.lua_incr_expire([key], [expiry, amount]))
 
     def get(self, key: str) -> int:
         """

limits/strategies.py

@@ -8,7 +8,7 @@ import time
 from abc import ABCMeta, abstractmethod
 from math import floor, inf
 
-from deprecated.sphinx import deprecated, versionadded
+from deprecated.sphinx import versionadded
 
 from limits.storage.base import SlidingWindowCounterSupport
 
@@ -148,7 +148,6 @@ class FixedWindowRateLimiter(RateLimiter):
             self.storage.incr(
                 item.key_for(*identifiers),
                 item.get_expiry(),
-                elastic_expiry=False,
                 amount=cost,
             )
             <= item.amount
@@ -286,43 +285,14 @@ class SlidingWindowCounterRateLimiter(RateLimiter):
         return WindowStats(now + min(previous_reset_in, current_reset_in), remaining)
 
 
-@deprecated(version="4.1", action="always")
-class FixedWindowElasticExpiryRateLimiter(FixedWindowRateLimiter):
-    """
-    Reference: :ref:`strategies:fixed window with elastic expiry`
-    """
-
-    def hit(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
-        """
-        Consume the rate limit
-
-        :param item: The rate limit item
-        :param identifiers: variable list of strings to uniquely identify this
-         instance of the limit
-        :param cost: The cost of this hit, default 1
-        """
-
-        return (
-            self.storage.incr(
-                item.key_for(*identifiers),
-                item.get_expiry(),
-                elastic_expiry=True,
-                amount=cost,
-            )
-            <= item.amount
-        )
-
-
 KnownStrategy = (
     type[SlidingWindowCounterRateLimiter]
     | type[FixedWindowRateLimiter]
-    | type[FixedWindowElasticExpiryRateLimiter]
     | type[MovingWindowRateLimiter]
 )
 
 STRATEGIES: dict[str, KnownStrategy] = {
     "sliding-window-counter": SlidingWindowCounterRateLimiter,
     "fixed-window": FixedWindowRateLimiter,
-    "fixed-window-elastic-expiry": FixedWindowElasticExpiryRateLimiter,
     "moving-window": MovingWindowRateLimiter,
 }

limits/typing.py

@@ -30,54 +30,6 @@ if TYPE_CHECKING:
     import redis
 
 
-class ItemP(Protocol):
-    value: bytes
-    flags: int | None
-    cas: int | None
-
-
-class EmcacheClientP(Protocol):
-    async def add(
-        self,
-        key: bytes,
-        value: bytes,
-        *,
-        flags: int = 0,
-        exptime: int = 0,
-        noreply: bool = False,
-    ) -> None: ...
-
-    async def get(self, key: bytes, return_flags: bool = False) -> ItemP | None: ...
-
-    async def get_many(self, keys: Iterable[bytes]) -> dict[bytes, ItemP]: ...
-
-    async def gets(self, key: bytes, return_flags: bool = False) -> ItemP | None: ...
-
-    async def increment(
-        self, key: bytes, value: int, *, noreply: bool = False
-    ) -> int | None: ...
-
-    async def decrement(
-        self, key: bytes, value: int, *, noreply: bool = False
-    ) -> int | None: ...
-
-    async def delete(self, key: bytes, *, noreply: bool = False) -> None: ...
-
-    async def set(
-        self,
-        key: bytes,
-        value: bytes,
-        *,
-        flags: int = 0,
-        exptime: int = 0,
-        noreply: bool = False,
-    ) -> None: ...
-
-    async def touch(
-        self, key: bytes, exptime: int, *, noreply: bool = False
-    ) -> None: ...
-
-
 class MemcachedClientP(Protocol):
     def add(
         self,
@@ -155,8 +107,6 @@ __all__ = [
     "Callable",
     "ClassVar",
     "Counter",
-    "EmcacheClientP",
-    "ItemP",
     "Literal",
     "MemcachedClientP",
     "MongoClient",

{limits-4.7.2.dist-info → limits-5.0.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: limits
-Version: 4.7.2
+Version: 5.0.0rc1
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -32,19 +32,14 @@ Provides-Extra: memcached
 Requires-Dist: pymemcache<5.0.0,>3; extra == "memcached"
 Provides-Extra: mongodb
 Requires-Dist: pymongo<5,>4.1; extra == "mongodb"
-Provides-Extra: etcd
-Requires-Dist: etcd3; extra == "etcd"
 Provides-Extra: valkey
 Requires-Dist: valkey>=6; extra == "valkey"
 Provides-Extra: async-redis
 Requires-Dist: coredis<5,>=3.4.0; extra == "async-redis"
 Provides-Extra: async-memcached
-Requires-Dist: emcache>=0.6.1; python_version < "3.11" and extra == "async-memcached"
-Requires-Dist: emcache>=1; (python_version >= "3.11" and python_version < "3.13.0") and extra == "async-memcached"
+Requires-Dist: memcachio>=0.3; extra == "async-memcached"
 Provides-Extra: async-mongodb
 Requires-Dist: motor<4,>=3; extra == "async-mongodb"
-Provides-Extra: async-etcd
-Requires-Dist: aetcd; extra == "async-etcd"
 Provides-Extra: async-valkey
 Requires-Dist: valkey>=6; extra == "async-valkey"
 Provides-Extra: all
@@ -52,13 +47,10 @@ Requires-Dist: redis!=4.5.2,!=4.5.3,<6.0.0,>3; extra == "all"
 Requires-Dist: redis!=4.5.2,!=4.5.3,>=4.2.0; extra == "all"
 Requires-Dist: pymemcache<5.0.0,>3; extra == "all"
 Requires-Dist: pymongo<5,>4.1; extra == "all"
-Requires-Dist: etcd3; extra == "all"
 Requires-Dist: valkey>=6; extra == "all"
 Requires-Dist: coredis<5,>=3.4.0; extra == "all"
-Requires-Dist: emcache>=0.6.1; python_version < "3.11" and extra == "all"
-Requires-Dist: emcache>=1; (python_version >= "3.11" and python_version < "3.13.0") and extra == "all"
+Requires-Dist: memcachio>=0.3; extra == "all"
 Requires-Dist: motor<4,>=3; extra == "all"
-Requires-Dist: aetcd; extra == "all"
 Requires-Dist: valkey>=6; extra == "all"
 Dynamic: author
 Dynamic: author-email
@@ -86,13 +78,14 @@ Dynamic: summary
 .. |docs| image:: https://readthedocs.org/projects/limits/badge/?version=latest
    :target: https://limits.readthedocs.org
 
+######
 limits
-------
+######
 |docs| |ci| |codecov| |pypi| |pypi-versions| |license|
 
 
 **limits** is a python library for rate limiting via multiple strategies
-with commonly used storage backends (Redis, Memcached, MongoDB & Etcd).
+with commonly used storage backends (Redis, Memcached & MongoDB).
 
 The library provides identical APIs for use in sync and
 `async <https://limits.readthedocs.io/en/stable/async.html>`_ codebases.
@@ -188,13 +181,13 @@ Scenario 2:
 - ``weighted_count = floor(8 + (4 * 0.33)) = floor(8 + 1.32) = 9``.
 - Since the weighted count is below the limit, the request is allowed.
 
+
 Storage backends
 ================
 
 - `Redis <https://limits.readthedocs.io/en/latest/storage.html#redis-storage>`_
 - `Memcached <https://limits.readthedocs.io/en/latest/storage.html#memcached-storage>`_
 - `MongoDB <https://limits.readthedocs.io/en/latest/storage.html#mongodb-storage>`_
-- `Etcd <https://limits.readthedocs.io/en/latest/storage.html#etcd-storage>`_
 - `In-Memory <https://limits.readthedocs.io/en/latest/storage.html#in-memory-storage>`_
 
 Dive right in