limits 3.12.0__py3-none-any.whl → 3.14.0__py3-none-any.whl

limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-12T10:01:06-0700",
+ "date": "2024-11-29T18:35:52-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "ff28751a2326de0ad6a978e316397534acf29b81",
- "version": "3.12.0"
+ "full-revisionid": "68e30b16c1b081d837e0050929de63f38ea3ca38",
+ "version": "3.14.0"
 }
 '''  # END VERSION_JSON
 

limits/aio/storage/mongodb.py

@@ -6,7 +6,7 @@ import datetime
 import time
 from typing import Any, cast
 
-from deprecated.sphinx import versionadded
+from deprecated.sphinx import versionadded, versionchanged
 
 from limits.aio.storage.base import MovingWindowSupport, Storage
 from limits.typing import Dict, Optional, ParamSpec, Tuple, Type, TypeVar, Union
@@ -17,6 +17,10 @@ R = TypeVar("R")
 
 
 @versionadded(version="2.1")
+@versionchanged(
+    version="3.14.0",
+    reason="Added option to select custom collection names for windows & counters",
+)
 class MongoDBStorage(Storage, MovingWindowSupport):
     """
     Rate limit storage with MongoDB as backend.
@@ -35,6 +39,8 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         self,
         uri: str,
         database_name: str = "limits",
+        counter_collection_name: str = "counters",
+        window_collection_name: str = "windows",
         wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
@@ -43,6 +49,9 @@ class MongoDBStorage(Storage, MovingWindowSupport):
          This uri is passed directly to :class:`~motor.motor_asyncio.AsyncIOMotorClient`
         :param database_name: The database to use for storing the rate limit
          collections.
+        :param counter_collection_name: The collection name to use for individual counters
+         used in fixed window strategies
+        :param window_collection_name: The collection name to use for moving window storage
         :param wrap_exceptions: Whether to wrap storage exceptions in
          :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are passed
@@ -66,6 +75,10 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         self.storage.get_io_loop = asyncio.get_running_loop
 
         self.__database_name = database_name
+        self.__collection_mapping = {
+            "counters": counter_collection_name,
+            "windows": window_collection_name,
+        }
         self.__indices_created = False
 
     @property
@@ -81,8 +94,12 @@ class MongoDBStorage(Storage, MovingWindowSupport):
     async def create_indices(self) -> None:
         if not self.__indices_created:
             await asyncio.gather(
-                self.database.counters.create_index("expireAt", expireAfterSeconds=0),
-                self.database.windows.create_index("expireAt", expireAfterSeconds=0),
+                self.database[self.__collection_mapping["counters"]].create_index(
+                    "expireAt", expireAfterSeconds=0
+                ),
+                self.database[self.__collection_mapping["windows"]].create_index(
+                    "expireAt", expireAfterSeconds=0
+                ),
             )
         self.__indices_created = True
 
@@ -92,12 +109,15 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         """
         num_keys = sum(
             await asyncio.gather(
-                self.database.counters.count_documents({}),
-                self.database.windows.count_documents({}),
+                self.database[self.__collection_mapping["counters"]].count_documents(
+                    {}
+                ),
+                self.database[self.__collection_mapping["windows"]].count_documents({}),
             )
         )
         await asyncio.gather(
-            self.database.counters.drop(), self.database.windows.drop()
+            self.database[self.__collection_mapping["counters"]].drop(),
+            self.database[self.__collection_mapping["windows"]].drop(),
         )
 
         return cast(int, num_keys)
@@ -107,15 +127,21 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         :param key: the key to clear rate limits for
         """
         await asyncio.gather(
-            self.database.counters.find_one_and_delete({"_id": key}),
-            self.database.windows.find_one_and_delete({"_id": key}),
+            self.database[self.__collection_mapping["counters"]].find_one_and_delete(
+                {"_id": key}
+            ),
+            self.database[self.__collection_mapping["windows"]].find_one_and_delete(
+                {"_id": key}
+            ),
         )
 
     async def get_expiry(self, key: str) -> int:
         """
         :param key: the key to get the expiry for
         """
-        counter = await self.database.counters.find_one({"_id": key})
+        counter = await self.database[self.__collection_mapping["counters"]].find_one(
+            {"_id": key}
+        )
         expiry = (
             counter["expireAt"]
             if counter
@@ -128,7 +154,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         """
         :param key: the key to get the counter value for
         """
-        counter = await self.database.counters.find_one(
+        counter = await self.database[self.__collection_mapping["counters"]].find_one(
             {
                 "_id": key,
                 "expireAt": {"$gte": datetime.datetime.now(datetime.timezone.utc)},
@@ -156,7 +182,9 @@ class MongoDBStorage(Storage, MovingWindowSupport):
             seconds=expiry
         )
 
-        response = await self.database.counters.find_one_and_update(
+        response = await self.database[
+            self.__collection_mapping["counters"]
+        ].find_one_and_update(
             {"_id": key},
             [
                 {
@@ -209,30 +237,34 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         :return: (start of window, number of acquired entries)
         """
         timestamp = time.time()
-        result = await self.database.windows.aggregate(
-            [
-                {"$match": {"_id": key}},
-                {
-                    "$project": {
-                        "entries": {
-                            "$filter": {
-                                "input": "$entries",
-                                "as": "entry",
-                                "cond": {"$gte": ["$$entry", timestamp - expiry]},
+        result = (
+            await self.database[self.__collection_mapping["windows"]]
+            .aggregate(
+                [
+                    {"$match": {"_id": key}},
+                    {
+                        "$project": {
+                            "entries": {
+                                "$filter": {
+                                    "input": "$entries",
+                                    "as": "entry",
+                                    "cond": {"$gte": ["$$entry", timestamp - expiry]},
+                                }
                             }
                         }
-                    }
-                },
-                {"$unwind": "$entries"},
-                {
-                    "$group": {
-                        "_id": "$_id",
-                        "min": {"$min": "$entries"},
-                        "count": {"$sum": 1},
-                    }
-                },
-            ]
-        ).to_list(length=1)
+                    },
+                    {"$unwind": "$entries"},
+                    {
+                        "$group": {
+                            "_id": "$_id",
+                            "min": {"$min": "$entries"},
+                            "count": {"$sum": 1},
+                        }
+                    },
+                ]
+            )
+            .to_list(length=1)
+        )
 
         if result:
             return (int(result[0]["min"]), result[0]["count"])
@@ -266,7 +298,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
                 )
             }
             updates["$push"]["entries"]["$each"] = [timestamp] * amount
-            await self.database.windows.update_one(
+            await self.database[self.__collection_mapping["windows"]].update_one(
                 {
                     "_id": key,
                     "entries.%d" % (limit - amount): {

limits/aio/strategies.py

@@ -29,13 +29,14 @@ class RateLimiter(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    async def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check if the rate limit can be consumed
 
         :param item: the rate limit item
         :param identifiers: variable list of strings to uniquely identify the
          limit
+        :param cost: The expected cost to be consumed, default 1
         """
         raise NotImplementedError
 
@@ -86,13 +87,14 @@ class MovingWindowRateLimiter(RateLimiter):
             item.key_for(*identifiers), item.amount, item.get_expiry(), amount=cost
         )
 
-    async def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    async def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check if the rate limit can be consumed
 
         :param item: the rate limit item
         :param identifiers: variable list of strings to uniquely identify the
          limit
+        :param cost: The expected cost to be consumed, default 1
         """
         res = await cast(MovingWindowSupport, self.storage).get_moving_window(
             item.key_for(*identifiers),
@@ -101,7 +103,7 @@ class MovingWindowRateLimiter(RateLimiter):
         )
         amount = res[1]
 
-        return amount < item.amount
+        return amount <= item.amount - cost
 
     async def get_window_stats(
         self, item: RateLimitItem, *identifiers: str
@@ -147,16 +149,19 @@ class FixedWindowRateLimiter(RateLimiter):
             <= item.amount
         )
 
-    async def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    async def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check if the rate limit can be consumed
 
         :param item: the rate limit item
         :param identifiers: variable list of strings to uniquely identify the
          limit
+        :param cost: The expected cost to be consumed, default 1
         """
 
-        return await self.storage.get(item.key_for(*identifiers)) < item.amount
+        return (
+            await self.storage.get(item.key_for(*identifiers)) < item.amount - cost + 1
+        )
 
     async def get_window_stats(
         self, item: RateLimitItem, *identifiers: str

limits/storage/mongodb.py

@@ -6,7 +6,7 @@ import time
 from abc import ABC, abstractmethod
 from typing import Any, cast
 
-from deprecated.sphinx import versionadded
+from deprecated.sphinx import versionadded, versionchanged
 
 from limits.typing import (
     Dict,
@@ -36,6 +36,8 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
         self,
         uri: str,
         database_name: str = "limits",
+        counter_collection_name: str = "counters",
+        window_collection_name: str = "windows",
         wrap_exceptions: bool = False,
         **options: Union[int, str, bool],
     ) -> None:
@@ -44,6 +46,9 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
          This uri is passed directly to :class:`~pymongo.mongo_client.MongoClient`
         :param database_name: The database to use for storing the rate limit
          collections.
+        :param counter_collection_name: The collection name to use for individual counters
+         used in fixed window strategies
+        :param window_collection_name: The collection name to use for moving window storage
         :param wrap_exceptions: Whether to wrap storage exceptions in
          :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are passed to the
@@ -53,6 +58,10 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
 
         super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
         self._database_name = database_name
+        self._collection_mapping = {
+            "counters": counter_collection_name,
+            "windows": window_collection_name,
+        }
         self.lib = self.dependencies["pymongo"].module
         self.lib_errors, _ = get_dependency("pymongo.errors")
         self._storage_uri = uri
@@ -74,11 +83,11 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
 
     @property
     def counters(self) -> MongoCollection:
-        return self._database["counters"]
+        return self._database[self._collection_mapping["counters"]]
 
     @property
     def windows(self) -> MongoCollection:
-        return self._database["windows"]
+        return self._database[self._collection_mapping["windows"]]
 
     @abstractmethod
     def _init_mongo_client(
@@ -278,6 +287,10 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
 
 
 @versionadded(version="2.1")
+@versionchanged(
+    version="3.14.0",
+    reason="Added option to select custom collection names for windows & counters",
+)
 class MongoDBStorage(MongoDBStorageBase):
     STORAGE_SCHEME = ["mongodb", "mongodb+srv"]
 

limits/storage/redis_cluster.py

@@ -1,15 +1,19 @@
 import urllib
-import warnings
-from typing import cast
 
 from deprecated.sphinx import versionchanged
 from packaging.version import Version
 
-from limits.errors import ConfigurationError
 from limits.storage.redis import RedisStorage
-from limits.typing import Dict, List, Optional, Tuple, Union
+from limits.typing import Dict, Optional, Union
 
 
+@versionchanged(
+    version="3.14.0",
+    reason="""
+Dropped support for the :pypi:`redis-py-cluster` library
+which has been abandoned/deprecated.
+""",
+)
 @versionchanged(
     version="2.5.0",
     reason="""
@@ -37,13 +41,19 @@ class RedisClusterStorage(RedisStorage):
 
     DEPENDENCIES = {
         "redis": Version("4.2.0"),
-        "rediscluster": Version("2.0.0"),  # Deprecated since 2.6.0
     }
 
-    def __init__(self, uri: str, **options: Union[float, str, bool]) -> None:
+    def __init__(
+        self,
+        uri: str,
+        wrap_exceptions: bool = False,
+        **options: Union[float, str, bool],
+    ) -> None:
         """
         :param uri: url of the form
          ``redis+cluster://[:password]@host:port,host:port``
+        :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:`redis.cluster.RedisCluster`
         :raise ConfigurationError: when the :pypi:`redis` library is not
@@ -64,53 +74,15 @@ class RedisClusterStorage(RedisStorage):
             cluster_hosts.append((host, int(port)))
 
         self.storage = None
-        self.using_redis_py = False
-        self.__pick_storage(
-            cluster_hosts, **{**self.DEFAULT_OPTIONS, **parsed_auth, **options}
+        merged_options = {**self.DEFAULT_OPTIONS, **parsed_auth, **options}
+        self.dependency = self.dependencies["redis"].module
+        startup_nodes = [self.dependency.cluster.ClusterNode(*c) for c in cluster_hosts]
+        self.storage = self.dependency.cluster.RedisCluster(
+            startup_nodes=startup_nodes, **merged_options
         )
         assert self.storage
         self.initialize_storage(uri)
-        super(RedisStorage, self).__init__(uri, **options)
-
-    def __pick_storage(
-        self, cluster_hosts: List[Tuple[str, int]], **options: Union[float, str, bool]
-    ) -> None:
-        try:
-            redis_py = self.dependencies["redis"].module
-            startup_nodes = [redis_py.cluster.ClusterNode(*c) for c in cluster_hosts]
-            self.storage = redis_py.cluster.RedisCluster(
-                startup_nodes=startup_nodes, **options
-            )
-            self.using_redis_py = True
-            return
-        except ConfigurationError:  # pragma: no cover
-            self.__use_legacy_cluster_implementation(cluster_hosts, **options)
-            if not self.storage:
-                raise ConfigurationError(
-                    (
-                        "Unable to find an implementation for redis cluster"
-                        " Cluster support requires either redis-py>=4.2 or"
-                        " redis-py-cluster"
-                    )
-                )
-
-    def __use_legacy_cluster_implementation(
-        self, cluster_hosts: List[Tuple[str, int]], **options: Union[float, str, bool]
-    ) -> None:  # pragma: no cover
-        redis_cluster = self.dependencies["rediscluster"].module
-        warnings.warn(
-            (
-                "Using redis-py-cluster is deprecated as the library has been"
-                " absorbed by redis-py (>=4.2). The support will be eventually "
-                " removed from the limits library and is no longer tested "
-                " against since version: 2.6. To get rid of this warning, "
-                " uninstall redis-py-cluster and ensure redis-py>=4.2.0 is installed"
-            )
-        )
-        self.storage = redis_cluster.RedisCluster(
-            startup_nodes=[{"host": c[0], "port": c[1]} for c in cluster_hosts],
-            **options,
-        )
+        super(RedisStorage, self).__init__(uri, wrap_exceptions, **options)
 
     def reset(self) -> Optional[int]:
         """
@@ -125,15 +97,9 @@ class RedisClusterStorage(RedisStorage):
          usage as it could be slow on very large data sets"""
 
         prefix = self.prefixed_key("*")
-        if self.using_redis_py:
-            count = 0
-            for primary in self.storage.get_primaries():
-                node = self.storage.get_redis_connection(primary)
-                keys = node.keys(prefix)
-                count += sum([node.delete(k.decode("utf-8")) for k in keys])
-            return count
-        else:  # pragma: no cover
-            keys = self.storage.keys(prefix)
-            return cast(
-                int, sum([self.storage.delete(k.decode("utf-8")) for k in keys])
-            )
+        count = 0
+        for primary in self.storage.get_primaries():
+            node = self.storage.get_redis_connection(primary)
+            keys = node.keys(prefix)
+            count += sum([node.delete(k.decode("utf-8")) for k in keys])
+        return count

limits/storage/redis_sentinel.py

@@ -5,7 +5,7 @@ from packaging.version import Version
 
 from limits.errors import ConfigurationError
 from limits.storage.redis import RedisStorage
-from limits.typing import Dict, Optional, Union
+from limits.typing import Dict, Optional, Tuple, Type, Union
 
 if TYPE_CHECKING:
     import redis.sentinel
@@ -86,6 +86,12 @@ class RedisSentinelStorage(RedisStorage):
         self.use_replicas = use_replicas
         self.initialize_storage(uri)
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.dependencies["redis"].RedisError  # type: ignore[no-any-return, attr-defined]
+
     def get(self, key: str) -> int:
         """
         :param key: the key to get the counter value for

limits/strategies.py

@@ -28,13 +28,14 @@ class RateLimiter(metaclass=ABCMeta):
         raise NotImplementedError
 
     @abstractmethod
-    def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check the rate limit without consuming from it.
 
         :param item: The rate limit item
         :param identifiers: variable list of strings to uniquely identify this
           instance of the limit
+        :param cost: The expected cost to be consumed, default 1
         """
         raise NotImplementedError
 
@@ -84,13 +85,14 @@ class MovingWindowRateLimiter(RateLimiter):
             item.key_for(*identifiers), item.amount, item.get_expiry(), amount=cost
         )
 
-    def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check if the rate limit can be consumed
 
         :param item: The rate limit item
         :param identifiers: variable list of strings to uniquely identify this
          instance of the limit
+        :param cost: The expected cost to be consumed, default 1
         """
 
         return (
@@ -99,7 +101,7 @@ class MovingWindowRateLimiter(RateLimiter):
                 item.amount,
                 item.get_expiry(),
             )[1]
-            < item.amount
+            <= item.amount - cost
         )
 
     def get_window_stats(self, item: RateLimitItem, *identifiers: str) -> WindowStats:
@@ -144,16 +146,17 @@ class FixedWindowRateLimiter(RateLimiter):
             <= item.amount
         )
 
-    def test(self, item: RateLimitItem, *identifiers: str) -> bool:
+    def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
         """
         Check if the rate limit can be consumed
 
         :param item: The rate limit item
         :param identifiers: variable list of strings to uniquely identify this
          instance of the limit
+        :param cost: The expected cost to be consumed, default 1
         """
 
-        return self.storage.get(item.key_for(*identifiers)) < item.amount
+        return self.storage.get(item.key_for(*identifiers)) < item.amount - cost + 1
 
     def get_window_stats(self, item: RateLimitItem, *identifiers: str) -> WindowStats:
         """

limits/typing.py

@@ -110,8 +110,8 @@ class ScriptP(Protocol[R_co]):
 
 
 MongoClient: TypeAlias = "pymongo.MongoClient[Dict[str, Any]]"  # type:ignore[misc]
-MongoDatabase: TypeAlias = "pymongo.database.Database[Dict[str, Any]]"  # type:ignore[misc]
-MongoCollection: TypeAlias = "pymongo.collection.Collection[Dict[str, Any]]"  # type:ignore[misc]
+MongoDatabase: TypeAlias = "pymongo.database.Database[Dict[str, Any]]"  # type:ignore
+MongoCollection: TypeAlias = "pymongo.collection.Collection[Dict[str, Any]]"  # type:ignore
 
 __all__ = [
     "AsyncRedisClient",

limits/util.py

@@ -1,13 +1,13 @@
 """ """
 
 import dataclasses
+import importlib.resources
 import re
 import sys
 from collections import UserDict
 from types import ModuleType
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
-import importlib_resources
 from packaging.version import Version
 
 from limits.typing import Dict, List, NamedTuple, Optional, Tuple, Type, Union
@@ -142,7 +142,7 @@ def get_dependency(module_path: str) -> Tuple[Optional[ModuleType], Optional[Ver
 
 
 def get_package_data(path: str) -> bytes:
-    return cast(bytes, importlib_resources.files("limits").joinpath(path).read_bytes())
+    return importlib.resources.files("limits").joinpath(path).read_bytes()
 
 
 def parse_many(limit_string: str) -> List[RateLimitItem]:

{limits-3.12.0.dist-info → limits-3.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: limits
-Version: 3.12.0
+Version: 3.14.0
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -20,10 +20,9 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 License-File: LICENSE.txt
 Requires-Dist: deprecated >=1.2
-Requires-Dist: importlib-resources >=1.3
 Requires-Dist: packaging <25,>=21
 Requires-Dist: typing-extensions
 Provides-Extra: all
@@ -36,12 +35,12 @@ Requires-Dist: coredis <5,>=3.4.0 ; extra == 'all'
 Requires-Dist: motor <4,>=3 ; extra == 'all'
 Requires-Dist: aetcd ; extra == 'all'
 Requires-Dist: emcache >=0.6.1 ; (python_version < "3.11") and extra == 'all'
-Requires-Dist: emcache >=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'
 Provides-Extra: async-etcd
 Requires-Dist: aetcd ; extra == 'async-etcd'
 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 extra == 'async-memcached'
+Requires-Dist: emcache >=1 ; (python_version >= "3.11" and python_version < "3.13.0") and extra == 'async-memcached'
 Provides-Extra: async-mongodb
 Requires-Dist: motor <4,>=3 ; extra == 'async-mongodb'
 Provides-Extra: async-redis

{limits-3.12.0.dist-info → limits-3.14.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
 limits/__init__.py,sha256=j_yVhgN9pdz8o5rQjVwdJTBSq8F-CTzof9kkiYgjRbw,728
-limits/_version.py,sha256=hEL57l9rkTEoBd9jvOB4z-OkCjpEs9jAM_ocoojdL6k,498
+limits/_version.py,sha256=xQZScpdLAtlbMB-VTWYGmvTmdMnGvXsZY1qG4iWHZKo,498
 limits/errors.py,sha256=xCKGOVJiD-g8FlsQQb17AW2pTUvalYSuizPpvEVoYJE,626
 limits/limits.py,sha256=ZsXESq2e1ji7c2ZKjSkIAasCjiLdjVLPUa9oah_I8U4,4943
 limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-limits/strategies.py,sha256=7pr2V34KdOEfxnYOf882Cl2qKY-KK6HwKjdYo_IsD4c,6690
-limits/typing.py,sha256=nwJLek44QIg3869AbOSvPwotfp6JR7vEHz_UgZBiqgg,3287
-limits/util.py,sha256=xMRR5bKksYcnzY0H0xORDGvRFF5btiBognY2sSd38NE,5743
+limits/strategies.py,sha256=Zy6PIhkysPbxnMzFjyXEsxMM6jhRoQ5XT5WskTNruK0,6949
+limits/typing.py,sha256=4yitf6iwDK-QEfSxv3EbTdGLOrqowLFffHAqYRUqiYY,3275
+limits/util.py,sha256=fi2XoUBoEk0T-le41VQn3x-BJ3QqrLeIcP52Bj-qwpg,5724
 limits/version.py,sha256=YwkF3dtq1KGzvmL3iVGctA8NNtGlK_0arrzZkZGVjUs,47
 limits/aio/__init__.py,sha256=IOetunwQy1c5GefzitK8lewbTzHGiE-kmE9NlqSdr3U,82
-limits/aio/strategies.py,sha256=REaQ-lqgqkN5wrFZ26AZ3sCHO8oZBL_mWhI6nMRaBz8,6485
+limits/aio/strategies.py,sha256=SHjmJnmy7Nh4tBydkA-0qPaULYcLOAM91T4RPybq0Sg,6768
 limits/aio/storage/__init__.py,sha256=CbtuSlVl1jPyN_vsEI_ApWblDblVaL46xcZ2M_oM0V8,595
 limits/aio/storage/base.py,sha256=xdYpBBonyMjxE9iT-2oZjm6x29aDU6Xd09MeBYbZcMo,4817
 limits/aio/storage/etcd.py,sha256=Rjb_EYKFRr4F2Z6zvAPP9vQOyXJQHaju3VjxxUs75_c,4791
 limits/aio/storage/memcached.py,sha256=6aTlACfCtchdcZqoisnei0MOlCH7yLV9A1yCjOE5f9g,4802
 limits/aio/storage/memory.py,sha256=DlmWluqUwBUWQIQ6XZi-mPrb15vfzBhA4iAKhBELDnE,5856
-limits/aio/storage/mongodb.py,sha256=sFQQK-JuInGEXC5Upjk_9NBe9hoNhgxQYimdRraXxQ8,9392
+limits/aio/storage/mongodb.py,sha256=gZq9Ky3J7j0xfqIqB3ULBbQ5VjHzIyT1c7aNFp01VKk,10764
 limits/aio/storage/redis.py,sha256=jkqtdIwTpfXTXwgTWTA1Jlc3Lpc-vnu4XRy6CIptiZA,15651
 limits/resources/redis/lua_scripts/acquire_moving_window.lua,sha256=5CFJX7D6T6RG5SFr6eVZ6zepmI1EkGWmKeVEO4QNrWo,483
 limits/resources/redis/lua_scripts/clear_keys.lua,sha256=zU0cVfLGmapRQF9x9u0GclapM_IB2pJLszNzVQ1QRK4,184
@@ -25,13 +25,13 @@ limits/storage/base.py,sha256=fDdYLa-RrnjhBTO1hE5aTTM8q8n3M5HD-65KyWWXBtg,4627
 limits/storage/etcd.py,sha256=wkC_mj4Tsf2nwUKByMiHiGzA40N3mDepEwdLmvH8wmw,4484
 limits/storage/memcached.py,sha256=bMzfZgYa_EWcZAjSZLcygpk3hpeOAErBpRE8dVwyXQs,6640
 limits/storage/memory.py,sha256=R16E-Ccnmn1-LlolkFf-kB1-QHh8eiwFFLYVv0PuFD0,5561
-limits/storage/mongodb.py,sha256=QWd_SW--P86SMPDrDrBQS-2xKbWY3cw9x71KsI506zY,9213
+limits/storage/mongodb.py,sha256=t8ey5-gYrJcmyvwJkqje0-TR-UMYvBF900a_zEXAYPI,9873
 limits/storage/redis.py,sha256=3zJ1gDMDepT_pGN9d2aAN7Pea7tMBI49VK60IHv-Ooc,8452
-limits/storage/redis_cluster.py,sha256=KwhWV0v3_TliRyS3OU15IlpeC8gRQr29U4FkcME01fo,5380
-limits/storage/redis_sentinel.py,sha256=7PVB0hBl0I_enhN_h9QSJTE7zGuYtjkebotTqxm2iZo,3875
+limits/storage/redis_cluster.py,sha256=MsiEpwHphQd0P88AwGw1NVSi3UwVrhsg-pvzkHxU2kw,3739
+limits/storage/redis_sentinel.py,sha256=lI7y7x9VGDCGq_-WRb6jR6cDgnzsOC1KGaRbwE69DNk,4122
 limits/storage/registry.py,sha256=xcBcxuu6srqmoS4WqDpkCXnRLB19ctH98v21P8S9kS8,708
-limits-3.12.0.dist-info/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
-limits-3.12.0.dist-info/METADATA,sha256=Evty_7zeDjM5XTCfNpdERwhzmfMnOU36NdkHiQE841s,7170
-limits-3.12.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-limits-3.12.0.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
-limits-3.12.0.dist-info/RECORD,,
+limits-3.14.0.dist-info/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
+limits-3.14.0.dist-info/METADATA,sha256=52wQlpKMn5JwhkgyJN-FDcGgUnImn7Ce2j5yz2BqGKg,7189
+limits-3.14.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+limits-3.14.0.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
+limits-3.14.0.dist-info/RECORD,,

{limits-3.12.0.dist-info → limits-3.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any