limits 3.12.0__tar.gz → 3.14.0__tar.gz

{limits-3.12.0 → limits-3.14.0}/HISTORY.rst

@@ -3,6 +3,31 @@
 Changelog
 =========
 
+v3.14.0
+-------
+Release Date: 2024-11-29
+
+* Feature
+
+  * Allow custom collection names in mongodb storage
+
+* Compatibility
+
+  * Add support for python 3.13
+  * Drop support for python 3.8
+
+* Deprecations
+
+  * Remove fallback support to use redis-py-cluster
+
+v3.13.0
+-------
+Release Date: 2024-06-22
+
+* Feature
+
+  * Add ``cost`` parameter to ``test`` methods in strategies.
+
 v3.12.0
 -------
 Release Date: 2024-05-12
@@ -706,6 +731,8 @@ Release Date: 2015-01-08
 
 
 
+
+
 
 
 

{limits-3.12.0 → limits-3.14.0}/PKG-INFO

@@ -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: redis
@@ -40,7 +39,7 @@ 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 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-etcd
@@ -53,7 +52,7 @@ Requires-Dist: pymongo<5,>4.1; extra == "all"
 Requires-Dist: etcd3; 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 extra == "all"
+Requires-Dist: emcache>=1; (python_version >= "3.11" and python_version < "3.13.0") and extra == "all"
 Requires-Dist: motor<4,>=3; extra == "all"
 Requires-Dist: aetcd; extra == "all"
 

{limits-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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-3.14.0/limits/storage/redis_cluster.py

@@ -0,0 +1,105 @@
+import urllib
+
+from deprecated.sphinx import versionchanged
+from packaging.version import Version
+
+from limits.storage.redis import RedisStorage
+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="""
+Cluster support was provided by the :pypi:`redis-py-cluster` library
+which has been absorbed into the official :pypi:`redis` client. By
+default the :class:`redis.cluster.RedisCluster` client will be used
+however if the version of the package is lower than ``4.2.0`` the implementation
+will fallback to trying to use :class:`rediscluster.RedisCluster`.
+""",
+)
+class RedisClusterStorage(RedisStorage):
+    """
+    Rate limit storage with redis cluster as backend
+
+    Depends on :pypi:`redis`.
+    """
+
+    STORAGE_SCHEME = ["redis+cluster"]
+    """The storage scheme for redis cluster"""
+
+    DEFAULT_OPTIONS: Dict[str, Union[float, str, bool]] = {
+        "max_connections": 1000,
+    }
+    "Default options passed to the :class:`~redis.cluster.RedisCluster`"
+
+    DEPENDENCIES = {
+        "redis": Version("4.2.0"),
+    }
+
+    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
+         available or if the redis cluster cannot be reached.
+        """
+        parsed = urllib.parse.urlparse(uri)
+        parsed_auth: Dict[str, Union[float, str, bool]] = {}
+
+        if parsed.username:
+            parsed_auth["username"] = parsed.username
+        if parsed.password:
+            parsed_auth["password"] = parsed.password
+
+        sep = parsed.netloc.find("@") + 1
+        cluster_hosts = []
+        for loc in parsed.netloc[sep:].split(","):
+            host, port = loc.split(":")
+            cluster_hosts.append((host, int(port)))
+
+        self.storage = None
+        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, wrap_exceptions, **options)
+
+    def reset(self) -> Optional[int]:
+        """
+        Redis Clusters are sharded and deleting across shards
+        can't be done atomically. Because of this, this reset loops over all
+        keys that are prefixed with ``self.PREFIX`` and calls delete on them,
+        one at a time.
+
+        .. warning::
+         This operation was not tested with extremely large data sets.
+         On a large production based system, care should be taken with its
+         usage as it could be slow on very large data sets"""
+
+        prefix = self.prefixed_key("*")
+        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-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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-3.12.0 → limits-3.14.0}/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 → limits-3.14.0}/limits.egg-info/PKG-INFO

@@ -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: redis
@@ -40,7 +39,7 @@ 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 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-etcd
@@ -53,7 +52,7 @@ Requires-Dist: pymongo<5,>4.1; extra == "all"
 Requires-Dist: etcd3; 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 extra == "all"
+Requires-Dist: emcache>=1; (python_version >= "3.11" and python_version < "3.13.0") and extra == "all"
 Requires-Dist: motor<4,>=3; extra == "all"
 Requires-Dist: aetcd; extra == "all"