limits 3.13.0__tar.gz → 3.14.1__tar.gz

{limits-3.13.0 → limits-3.14.1}/HISTORY.rst

@@ -3,6 +3,32 @@
 Changelog
 =========
 
+v3.14.1
+-------
+Release Date: 2024-11-30
+
+* Chore
+
+  * Fix benchmark artifact upload/download issue during release
+    creation
+
+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
@@ -715,6 +741,8 @@ Release Date: 2015-01-08
 
 
 
+
+
 
 
 

{limits-3.13.0 → limits-3.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: limits
-Version: 3.13.0
+Version: 3.14.1
 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.13.0 → limits-3.14.1}/limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-06-22T18:39:54-0700",
+ "date": "2024-11-30T11:04:11-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "7b87c4d37659ae5fe0a8bf7216bfff789facd5f3",
- "version": "3.13.0"
+ "full-revisionid": "0671723f54aed5692d4c9d9b47cf0326d5263de5",
+ "version": "3.14.1"
 }
 '''  # END VERSION_JSON
 

{limits-3.13.0 → limits-3.14.1}/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.13.0 → limits-3.14.1}/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.1/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.13.0 → limits-3.14.1}/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.13.0 → limits-3.14.1}/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.13.0 → limits-3.14.1}/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.13.0 → limits-3.14.1}/limits.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: limits
-Version: 3.13.0
+Version: 3.14.1
 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.13.0 → limits-3.14.1}/limits.egg-info/requires.txt

@@ -1,5 +1,4 @@
 deprecated>=1.2
-importlib_resources>=1.3
 packaging<25,>=21
 typing_extensions
 
@@ -16,7 +15,7 @@ aetcd
 [all:python_version < "3.11"]
 emcache>=0.6.1
 
-[all:python_version >= "3.11"]
+[all:python_version >= "3.11" and python_version < "3.13.0"]
 emcache>=1
 
 [async-etcd]
@@ -27,7 +26,7 @@ aetcd
 [async-memcached:python_version < "3.11"]
 emcache>=0.6.1
 
-[async-memcached:python_version >= "3.11"]
+[async-memcached:python_version >= "3.11" and python_version < "3.13.0"]
 emcache>=1
 
 [async-mongodb]

{limits-3.13.0 → limits-3.14.1}/requirements/docs.txt

@@ -1,8 +1,8 @@
 -r main.txt
-furo==2024.5.6
-Sphinx>=4,<8
+furo==2024.8.6
+Sphinx>=4,<9
 sphinx-copybutton==0.5.2
-sphinx-autobuild==2021.3.14
+sphinx-autobuild==2024.10.3
 sphinxext-opengraph==0.9.1
 sphinx-inline-tabs==2023.4.21
 sphinx-paramlinks==0.6.0

{limits-3.13.0 → limits-3.14.1}/requirements/main.txt

@@ -1,4 +1,3 @@
 deprecated>=1.2
-importlib_resources>=1.3
 packaging>=21,<25
 typing_extensions

limits-3.14.1/requirements/storage/async-memcached.txt

@@ -0,0 +1,2 @@
+emcache>=0.6.1;python_version<"3.11"
+emcache>=1;python_version>="3.11" and python_version<"3.13.0"

{limits-3.13.0 → limits-3.14.1}/requirements/test.txt

@@ -17,10 +17,10 @@ coverage
 hiro>0.1.6
 flaky
 lovely-pytest-docker
-pytest<8
+pytest<9
 pytest-asyncio==0.21.2
 pytest-benchmark[histogram]
 pytest-cov
-pytest-lazy-fixture
+pytest-lazy-fixtures
 pytest-mock
 PyYAML

{limits-3.13.0 → limits-3.14.1}/setup.py

@@ -58,7 +58,7 @@ setup(
     description="Rate limiting utilities",
     long_description=open("README.rst").read(),
     packages=find_packages(exclude=["tests*"]),
-    python_requires=">=3.8",
+    python_requires=">=3.9",
     extras_require=EXTRA_REQUIREMENTS,
     include_package_data=True,
     package_data={

{limits-3.13.0 → limits-3.14.1}/tests/test_storage.py

@@ -1,6 +1,7 @@
 import time
 
 import pytest
+from pytest_lazy_fixtures import lf
 
 from limits import RateLimitItemPerMinute, RateLimitItemPerSecond
 from limits.errors import ConfigurationError, StorageError
@@ -104,7 +105,7 @@ class TestBaseStorage:
             "redis://localhost:7379",
             {},
             RedisStorage,
-            pytest.lazy_fixture("redis_basic"),
+            lf("redis_basic"),
             marks=pytest.mark.redis,
             id="redis",
         ),
@@ -112,7 +113,7 @@ class TestBaseStorage:
             "redis+unix:///tmp/limits.redis.sock",
             {},
             RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
+            lf("redis_uds"),
             marks=pytest.mark.redis,
             id="redis-uds",
         ),
@@ -120,7 +121,7 @@ class TestBaseStorage:
             "redis+unix://:password/tmp/limits.redis.sock",
             {},
             RedisStorage,
-            pytest.lazy_fixture("redis_uds"),
+            lf("redis_uds"),
             marks=pytest.mark.redis,
             id="redis-uds-auth",
         ),
@@ -128,7 +129,7 @@ class TestBaseStorage:
             "memcached://localhost:22122",
             {},
             MemcachedStorage,
-            pytest.lazy_fixture("memcached"),
+            lf("memcached"),
             marks=pytest.mark.memcached,
             id="memcached",
         ),
@@ -136,7 +137,7 @@ class TestBaseStorage:
             "memcached://localhost:22122,localhost:22123",
             {},
             MemcachedStorage,
-            pytest.lazy_fixture("memcached_cluster"),
+            lf("memcached_cluster"),
             marks=pytest.mark.memcached,
             id="memcached-cluster",
         ),
@@ -144,7 +145,7 @@ class TestBaseStorage:
             "memcached:///tmp/limits.memcached.sock",
             {},
             MemcachedStorage,
-            pytest.lazy_fixture("memcached_uds"),
+            lf("memcached_uds"),
             marks=pytest.mark.memcached,
             id="memcached-uds",
         ),
@@ -152,7 +153,7 @@ class TestBaseStorage:
             "redis+sentinel://localhost:26379",
             {"service_name": "mymaster"},
             RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
+            lf("redis_sentinel"),
             marks=pytest.mark.redis_sentinel,
             id="redis-sentinel",
         ),
@@ -160,7 +161,7 @@ class TestBaseStorage:
             "redis+sentinel://localhost:26379/mymaster",
             {},
             RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel"),
+            lf("redis_sentinel"),
             marks=pytest.mark.redis_sentinel,
             id="redis-sentinel-service-name-url",
         ),
@@ -168,7 +169,7 @@ class TestBaseStorage:
             "redis+sentinel://:sekret@localhost:36379/mymaster",
             {"password": "sekret"},
             RedisSentinelStorage,
-            pytest.lazy_fixture("redis_sentinel_auth"),
+            lf("redis_sentinel_auth"),
             marks=pytest.mark.redis_sentinel,
             id="redis-sentinel-auth",
         ),
@@ -176,7 +177,7 @@ class TestBaseStorage:
             "redis+cluster://localhost:7001/",
             {},
             RedisClusterStorage,
-            pytest.lazy_fixture("redis_cluster"),
+            lf("redis_cluster"),
             marks=pytest.mark.redis_cluster,
             id="redis-cluster",
         ),
@@ -184,7 +185,7 @@ class TestBaseStorage:
             "redis+cluster://:sekret@localhost:8400/",
             {},
             RedisClusterStorage,
-            pytest.lazy_fixture("redis_auth_cluster"),
+            lf("redis_auth_cluster"),
             marks=pytest.mark.redis_cluster,
             id="redis-cluster-auth",
         ),
@@ -192,7 +193,7 @@ class TestBaseStorage:
             "mongodb://localhost:37017/",
             {},
             MongoDBStorage,
-            pytest.lazy_fixture("mongodb"),
+            lf("mongodb"),
             marks=pytest.mark.mongodb,
             id="mongodb",
         ),
@@ -200,7 +201,7 @@ class TestBaseStorage:
             "etcd://localhost:2379",
             {},
             EtcdStorage,
-            pytest.lazy_fixture("etcd"),
+            lf("etcd"),
             marks=pytest.mark.etcd,
             id="etcd",
         ),

limits-3.13.0/limits/storage/redis_cluster.py

@@ -1,139 +0,0 @@
-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
-
-
-@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"),
-        "rediscluster": Version("2.0.0"),  # Deprecated since 2.6.0
-    }
-
-    def __init__(self, uri: str, **options: Union[float, str, bool]) -> None:
-        """
-        :param uri: url of the form
-         ``redis+cluster://[:password]@host:port,host:port``
-        :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
-        self.using_redis_py = False
-        self.__pick_storage(
-            cluster_hosts, **{**self.DEFAULT_OPTIONS, **parsed_auth, **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,
-        )
-
-    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("*")
-        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])
-            )

limits-3.13.0/requirements/storage/async-memcached.txt

@@ -1,2 +0,0 @@
-emcache>=0.6.1;python_version<"3.11" # not yet supported
-emcache>=1;python_version>="3.11" # not yet supported