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

limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-08T15:55:28-0700",
+ "date": "2025-04-09T18:20:47-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "47c207f7d014fe33f24688ccdff740c1e10654a7",
- "version": "4.7.1"
+ "full-revisionid": "4a01f1090a5accfb05b7db6dc6469f7c51d4fa67",
+ "version": "5.0.0rc1"
 }
 '''  # END VERSION_JSON
 

limits/aio/storage/__init__.py

@@ -6,14 +6,12 @@ Implementations of storage backends to be used with
 from __future__ import annotations
 
 from .base import MovingWindowSupport, SlidingWindowCounterSupport, Storage
-from .etcd import EtcdStorage
 from .memcached import MemcachedStorage
 from .memory import MemoryStorage
 from .mongodb import MongoDBStorage
 from .redis import RedisClusterStorage, RedisSentinelStorage, RedisStorage
 
 __all__ = [
-    "EtcdStorage",
     "MemcachedStorage",
     "MemoryStorage",
     "MongoDBStorage",

limits/aio/storage/base.py

@@ -75,16 +75,12 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
         raise NotImplementedError
 
     @abstractmethod
-    async def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    async 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/aio/storage/memcached.py

@@ -4,26 +4,33 @@ import time
 import urllib.parse
 from collections.abc import Iterable
 from math import ceil, floor
+from typing import TYPE_CHECKING
 
-from deprecated.sphinx import versionadded
+from deprecated.sphinx import versionadded, versionchanged
 
 from limits.aio.storage.base import SlidingWindowCounterSupport, Storage
 from limits.storage.base import TimestampedSlidingWindow
-from limits.typing import EmcacheClientP, ItemP
+
+if TYPE_CHECKING:
+    import memcachio
 
 
 @versionadded(version="2.1")
+@versionchanged(
+    version="5.0",
+    reason="Switched to :pypi:`memcachio` for async memcached support",
+)
 class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingWindow):
     """
     Rate limit storage with memcached as backend.
 
-    Depends on :pypi:`emcache`
+    Depends on :pypi:`memcachio`
     """
 
     STORAGE_SCHEME = ["async+memcached"]
     """The storage scheme for memcached to be used in an async context"""
 
-    DEPENDENCIES = ["emcache"]
+    DEPENDENCIES = ["memcachio"]
 
     def __init__(
         self,
@@ -37,8 +44,8 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         :param wrap_exceptions: Whether to wrap storage exceptions in
          :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are passed
-         directly to the constructor of :class:`emcache.Client`
-        :raise ConfigurationError: when :pypi:`emcache` is not available
+         directly to the constructor of :class:`memcachio.Client`
+        :raise ConfigurationError: when :pypi:`memcachio` is not available
         """
         parsed = urllib.parse.urlparse(uri)
         self.hosts = []
@@ -51,21 +58,21 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         self._options = options
         self._storage = None
         super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
-        self.dependency = self.dependencies["emcache"].module
+        self.dependency = self.dependencies["memcachio"].module
 
     @property
     def base_exceptions(
         self,
     ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
         return (
-            self.dependency.ClusterNoAvailableNodes,
-            self.dependency.CommandError,
+            self.dependency.errors.NoNodeAvailable,
+            self.dependency.errors.MemcachioConnectionError,
         )
 
-    async def get_storage(self) -> EmcacheClientP:
+    async def get_storage(self) -> memcachio.Client[bytes]:
         if not self._storage:
-            self._storage = await self.dependency.create_client(
-                [self.dependency.MemcachedHostAddress(h, p) for h, p in self.hosts],
+            self._storage = self.dependency.Client(
+                [(h, p) for h, p in self.hosts],
                 **self._options,
             )
         assert self._storage
@@ -75,19 +82,18 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         """
         :param key: the key to get the counter value for
         """
-        item = await (await self.get_storage()).get(key.encode("utf-8"))
-
+        item = (await self.get_many([key])).get(key.encode("utf-8"), None)
         return item and int(item.value) or 0
 
-    async def get_many(self, keys: Iterable[str]) -> dict[bytes, ItemP]:
+    async def get_many(
+        self, keys: Iterable[str]
+    ) -> dict[bytes, memcachio.MemcachedItem[bytes]]:
         """
         Return multiple counters at once
 
         :param keys: the keys to get the counter values for
         """
-        return await (await self.get_storage()).get_many(
-            [k.encode("utf-8") for k in keys]
-        )
+        return await (await self.get_storage()).get(*[k.encode("utf-8") for k in keys])
 
     async def clear(self, key: str) -> None:
         """
@@ -107,17 +113,12 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         """
         storage = await self.get_storage()
         limit_key = key.encode("utf-8")
-        try:
-            value = await storage.decrement(limit_key, amount, noreply=noreply) or 0
-        except self.dependency.NotFoundCommandError:
-            value = 0
-        return value
+        return await storage.decr(limit_key, amount, noreply=noreply) or 0
 
     async def incr(
         self,
         key: str,
         expiry: float,
-        elastic_expiry: bool = False,
         amount: int = 1,
         set_expiration_key: bool = True,
     ) -> int:
@@ -126,7 +127,6 @@ 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: if set to False, the expiration time won't be stored but the key will still expire
@@ -134,53 +134,29 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         storage = await self.get_storage()
         limit_key = key.encode("utf-8")
         expire_key = self._expiration_key(key).encode()
-        value = None
-        try:
-            value = await storage.increment(limit_key, amount) or amount
-            if elastic_expiry:
-                await storage.touch(limit_key, exptime=ceil(expiry))
-                if set_expiration_key:
-                    await storage.set(
-                        expire_key,
-                        str(expiry + time.time()).encode("utf-8"),
-                        exptime=ceil(expiry),
-                        noreply=False,
-                    )
-            return value
-        except self.dependency.NotFoundCommandError:
-            # Incrementation failed because the key doesn't exist
+        if (value := (await storage.incr(limit_key, amount))) is None:
             storage = await self.get_storage()
-            try:
-                await storage.add(limit_key, f"{amount}".encode(), exptime=ceil(expiry))
+            if await storage.add(limit_key, f"{amount}".encode(), expiry=ceil(expiry)):
                 if set_expiration_key:
                     await storage.set(
                         expire_key,
                         str(expiry + time.time()).encode("utf-8"),
-                        exptime=ceil(expiry),
+                        expiry=ceil(expiry),
                         noreply=False,
                     )
-                value = amount
-            except self.dependency.NotStoredStorageCommandError:
-                # Coult not add the key, probably because a concurrent call has added it
+                return amount
+            else:
                 storage = await self.get_storage()
-                value = await storage.increment(limit_key, amount) or amount
-                if elastic_expiry:
-                    await storage.touch(limit_key, exptime=ceil(expiry))
-                    if set_expiration_key:
-                        await storage.set(
-                            expire_key,
-                            str(expiry + time.time()).encode("utf-8"),
-                            exptime=ceil(expiry),
-                            noreply=False,
-                        )
-            return value
+                return await storage.incr(limit_key, amount) or amount
+        return value
 
     async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
         storage = await self.get_storage()
-        item = await storage.get(self._expiration_key(key).encode("utf-8"))
+        expiration_key = self._expiration_key(key).encode("utf-8")
+        item = (await storage.get(expiration_key)).get(expiration_key, None)
 
         return item and float(item.value) or time.time()
 

limits/aio/storage/memory.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import bisect
 import time
 from collections import Counter, defaultdict
 from math import floor
@@ -28,7 +29,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 & sliding window strategies,
     and a simple list to implement moving window strategy.
     """
 
@@ -61,11 +62,16 @@ class MemoryStorage(
         asyncio.ensure_future(self.__schedule_expiry())
 
     async def __expire_events(self) -> None:
+        now = time.time()
         for key in list(self.events.keys()):
+            cutoff = await asyncio.to_thread(
+                lambda evts: bisect.bisect_left(
+                    evts, -now, key=lambda event: -event.expiry
+                ),
+                self.events[key],
+            )
             async 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)
+                self.events[key] = self.events[key][:cutoff]
                 if not self.events.get(key, None):
                     self.events.pop(key, None)
                     self.locks.pop(key, None)
@@ -86,26 +92,20 @@ class MemoryStorage(
     ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
         return ValueError
 
-    async def incr(
-        self, key: str, expiry: float, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    async 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
         """
         await self.get(key)
         await self.__schedule_expiry()
         async 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, amount)
 
     async def decr(self, key: str, amount: int = 1) -> int:
@@ -165,8 +165,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
 
     async def get_expiry(self, key: str) -> float:
@@ -176,22 +175,6 @@ class MemoryStorage(
 
         return self.expirations.get(key, time.time())
 
-    async 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
-        )
-
-    # FIXME: arg limit is not used
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
     ) -> tuple[float, int]:
@@ -203,14 +186,14 @@ class MemoryStorage(
         :param expiry: expiry of entry
         :return: (start of window, number of acquired entries)
         """
-        timestamp = time.time()
-        acquired = await 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
+        timestamp = time.time()
+        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
 
     async def acquire_sliding_window_entry(
         self,
@@ -242,7 +225,6 @@ class MemoryStorage(
                 # Limitation: during high concurrency at the end of the window,
                 # the counter is shifted and cannot be decremented, so less requests than expected are allowed.
                 await self.decr(current_key, amount)
-                # print("Concurrent call, reverting the counter increase")
                 return False
             return True
 

limits/aio/storage/mongodb.py

@@ -169,16 +169,12 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
 
         return counter and counter["count"] or 0
 
-    async def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    async 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
         """
         await self.create_indices()
@@ -205,7 +201,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             "$cond": {
                                 "if": {"$lt": ["$expireAt", "$$NOW"]},
                                 "then": expiration,
-                                "else": (expiration if elastic_expiry else "$expireAt"),
+                                "else": "$expireAt",
                             }
                         },
                     }
@@ -241,15 +237,16 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         :param int expiry: expiry of entry
         :return: (start of window, number of acquired entries)
         """
+
         timestamp = time.time()
-        if result := (
-            await self.database[self.__collection_mapping["windows"]]
+        if (
+            result := await self.database[self.__collection_mapping["windows"]]
             .aggregate(
                 [
                     {"$match": {"_id": key}},
                     {
                         "$project": {
-                            "entries": {
+                            "filteredEntries": {
                                 "$filter": {
                                     "input": "$entries",
                                     "as": "entry",
@@ -258,12 +255,10 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             }
                         }
                     },
-                    {"$unwind": "$entries"},
                     {
-                        "$group": {
-                            "_id": "$_id",
-                            "min": {"$min": "$entries"},
-                            "count": {"$sum": 1},
+                        "$project": {
+                            "min": {"$min": "$filteredEntries"},
+                            "count": {"$size": "$filteredEntries"},
                         }
                     },
                 ]
@@ -337,7 +332,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -353,7 +348,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -361,22 +356,22 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                                 "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",
                             }
                         },
                     }
@@ -396,7 +391,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                                                             0,
                                                             {
                                                                 "$subtract": [
-                                                                    "$expiresAt",
+                                                                    "$expireAt",
                                                                     {
                                                                         "$add": [
                                                                             "$$NOW",
@@ -464,7 +459,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -476,7 +471,7 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -484,27 +479,27 @@ class MongoDBStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
                                 "else": {"$ifNull": ["$currentCount", 0]},
                             }
                         },
-                        "expiresAt": {
+                        "expireAt": {
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
-                                "then": {"$add": ["$expiresAt", expiry_ms]},
-                                "else": "$expiresAt",
+                                "then": {"$add": ["$expireAt", expiry_ms]},
+                                "else": "$expireAt",
                             }
                         },
                     }
                 }
             ],
             return_document=self.proxy_dependency.module.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())

limits/aio/storage/redis/__init__.py

@@ -139,9 +139,7 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
     ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
         return self.bridge.base_exceptions
 
-    async def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    async def incr(self, key: str, expiry: int, amount: int = 1) -> int:
         """
         increments the counter for a given rate limit key
 
@@ -150,7 +148,7 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         :param amount: the number to increment by
         """
 
-        return await self.bridge.incr(key, expiry, elastic_expiry, amount)
+        return await self.bridge.incr(key, expiry, amount)
 
     async def get(self, key: str) -> int:
         """

limits/aio/storage/redis/bridge.py

@@ -68,7 +68,6 @@ class RedisBridge(ABC):
         self,
         key: str,
         expiry: int,
-        elastic_expiry: bool = False,
         amount: int = 1,
     ) -> int: ...
 

limits/aio/storage/redis/coredis.py

@@ -112,14 +112,10 @@ class CoredisBridge(RedisBridge):
             self.SCRIPT_ACQUIRE_SLIDING_WINDOW
         )
 
-    async def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    async def incr(self, key: str, expiry: int, amount: int = 1) -> int:
         key = self.prefixed_key(key)
-        value = await self.get_connection().incrby(key, amount)
-        if elastic_expiry or value == amount:
+        if (value := await self.get_connection().incrby(key, amount)) == amount:
             await self.get_connection().expire(key, expiry)
-
         return value
 
     async def get(self, key: str) -> int:

limits/aio/storage/redis/redispy.py

@@ -119,7 +119,6 @@ class RedispyBridge(RedisBridge):
         self,
         key: str,
         expiry: int,
-        elastic_expiry: bool = False,
         amount: int = 1,
     ) -> int:
         """
@@ -131,13 +130,7 @@ class RedispyBridge(RedisBridge):
         :param amount: the number to increment by
         """
         key = self.prefixed_key(key)
-
-        if elastic_expiry:
-            value = await self.get_connection().incrby(key, amount)
-            await self.get_connection().expire(key, expiry)
-            return value
-        else:
-            return cast(int, await self.lua_incr_expire([key], [expiry, amount]))
+        return cast(int, await self.lua_incr_expire([key], [expiry, amount]))
 
     async def get(self, key: str) -> int:
         """

limits/aio/strategies.py

@@ -8,7 +8,7 @@ import time
 from abc import ABC, abstractmethod
 from math import floor, inf
 
-from deprecated.sphinx import deprecated, versionadded
+from deprecated.sphinx import versionadded
 
 from ..limits import RateLimitItem
 from ..storage import StorageTypes
@@ -150,7 +150,6 @@ class FixedWindowRateLimiter(RateLimiter):
             await self.storage.incr(
                 item.key_for(*identifiers),
                 item.get_expiry(),
-                elastic_expiry=False,
                 amount=cost,
             )
             <= item.amount
@@ -304,34 +303,8 @@ class SlidingWindowCounterRateLimiter(RateLimiter):
         return WindowStats(now + min(previous_reset_in, current_reset_in), remaining)
 
 
-@deprecated(version="4.1")
-class FixedWindowElasticExpiryRateLimiter(FixedWindowRateLimiter):
-    """
-    Reference: :ref:`strategies:fixed window with elastic expiry`
-    """
-
-    async def hit(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
-        """
-        Consume the rate limit
-
-        :param item: a :class:`limits.limits.RateLimitItem` instance
-        :param identifiers: variable list of strings to uniquely identify the
-         limit
-        :param cost: The cost of this hit, default 1
-        """
-        amount = await self.storage.incr(
-            item.key_for(*identifiers),
-            item.get_expiry(),
-            elastic_expiry=True,
-            amount=cost,
-        )
-
-        return amount <= item.amount
-
-
 STRATEGIES = {
     "sliding-window-counter": SlidingWindowCounterRateLimiter,
     "fixed-window": FixedWindowRateLimiter,
-    "fixed-window-elastic-expiry": FixedWindowElasticExpiryRateLimiter,
     "moving-window": MovingWindowRateLimiter,
 }