limits 3.6.0__tar.gz → 3.9.0__tar.gz

{limits-3.6.0 → limits-3.9.0}/HISTORY.rst

@@ -3,6 +3,37 @@
 Changelog
 =========
 
+v3.9.0
+------
+Release Date: 2024-02-17
+
+* Bug Fix
+
+  * Remove excessively low defaults for mongodb storage and instead
+    delegate to the underlying dependency (pymongo, motor)
+
+
+v3.8.0
+------
+Release Date: 2024-02-14
+
+* Features
+
+  * Add option to wrap storage errors with a ``StorageError``
+    exception
+
+
+v3.7.0
+------
+Release Date: 2023-11-24
+
+* Features
+
+  * Ensure rate limit keys in redis use are prefixed
+    with a `LIMITS` prefix. This allows for resetting
+    all keys generated by the library without implicit
+    knowledge of the key structure.
+
 v3.6.0
 ------
 Release Date: 2023-08-31
@@ -624,6 +655,9 @@ Release Date: 2015-01-08
 
 
 
+
+
+
 
 
 

{limits-3.6.0 → limits-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: limits
-Version: 3.6.0
+Version: 3.9.0
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -20,17 +20,41 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.7
+License-File: LICENSE.txt
+Requires-Dist: deprecated>=1.2
+Requires-Dist: importlib_resources>=1.3
+Requires-Dist: packaging<24,>=21
+Requires-Dist: typing_extensions
 Provides-Extra: redis
+Requires-Dist: redis!=4.5.2,!=4.5.3,<6.0.0,>3; extra == "redis"
 Provides-Extra: rediscluster
+Requires-Dist: redis!=4.5.2,!=4.5.3,>=4.2.0; extra == "rediscluster"
 Provides-Extra: memcached
+Requires-Dist: pymemcache<5.0.0,>3; extra == "memcached"
 Provides-Extra: mongodb
+Requires-Dist: pymongo<5,>4.1; extra == "mongodb"
 Provides-Extra: etcd
+Requires-Dist: etcd3; extra == "etcd"
 Provides-Extra: 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"
 Provides-Extra: async-mongodb
+Requires-Dist: motor<4,>=3; extra == "async-mongodb"
 Provides-Extra: async-etcd
+Requires-Dist: aetcd; extra == "async-etcd"
 Provides-Extra: all
-License-File: LICENSE.txt
+Requires-Dist: redis!=4.5.2,!=4.5.3,<6.0.0,>3; extra == "all"
+Requires-Dist: redis!=4.5.2,!=4.5.3,>=4.2.0; extra == "all"
+Requires-Dist: pymemcache<5.0.0,>3; extra == "all"
+Requires-Dist: pymongo<5,>4.1; extra == "all"
+Requires-Dist: etcd3; extra == "all"
+Requires-Dist: 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: motor<4,>=3; extra == "all"
+Requires-Dist: aetcd; extra == "all"
 
 .. |ci| image:: https://github.com/alisaifee/limits/workflows/CI/badge.svg?branch=master
     :target: https://github.com/alisaifee/limits/actions?query=branch%3Amaster+workflow%3ACI
@@ -52,12 +76,6 @@ limits
 
 **limits** is a python library to perform rate limiting with commonly used storage backends (Redis, Memcached, MongoDB & Etcd).
 
-----
-
-Sponsored by Zuplo - fully-managed, programmable API Management platform.
-Add rate limiting and more to your public API in minutes, try it at `zuplo.com <https://zuplo.link/3DZM9Ej>`_
-
-----
 
 Supported Strategies
 ====================

{limits-3.6.0 → limits-3.9.0}/README.rst

@@ -18,12 +18,6 @@ limits
 
 **limits** is a python library to perform rate limiting with commonly used storage backends (Redis, Memcached, MongoDB & Etcd).
 
-----
-
-Sponsored by Zuplo - fully-managed, programmable API Management platform.
-Add rate limiting and more to your public API in minutes, try it at `zuplo.com <https://zuplo.link/3DZM9Ej>`_
-
-----
 
 Supported Strategies
 ====================

{limits-3.6.0 → limits-3.9.0}/doc/source/api.rst

@@ -203,3 +203,5 @@ Exceptions
    :no-inherited-members:
 .. autoexception:: limits.errors.ConcurrentUpdateError
    :no-inherited-members:
+.. autoexception:: limits.errors.StorageError
+   :no-inherited-members:

{limits-3.6.0 → limits-3.9.0}/limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-08-31T07:36:32-0700",
+ "date": "2024-02-17T17:36:20-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "ada96bb4afc9729b4aac2552209a78428a27c313",
- "version": "3.6.0"
+ "full-revisionid": "7acdd2228f4f414bc411c698875dc24fea2d303b",
+ "version": "3.9.0"
 }
 '''  # END VERSION_JSON
 

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/base.py

@@ -1,12 +1,43 @@
+from __future__ import annotations
+
+import functools
 from abc import ABC, abstractmethod
+from typing import Any, cast
 
 from deprecated.sphinx import versionadded
 
+from limits import errors
 from limits.storage.registry import StorageRegistry
-from limits.typing import List, Optional, Tuple, Union
+from limits.typing import (
+    Awaitable,
+    Callable,
+    List,
+    Optional,
+    P,
+    R,
+    Tuple,
+    Type,
+    Union,
+)
 from limits.util import LazyDependency
 
 
+def _wrap_errors(
+    storage: Storage,
+    fn: Callable[P, Awaitable[R]],
+) -> Callable[P, Awaitable[R]]:
+    @functools.wraps(fn)
+    async def inner(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return await fn(*args, **kwargs)
+        except storage.base_exceptions as exc:
+            if storage.wrap_exceptions:
+                raise errors.StorageError(exc) from exc
+            raise
+
+    return inner
+
+
 @versionadded(version="2.1")
 class Storage(LazyDependency, metaclass=StorageRegistry):
     """
@@ -16,10 +47,38 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
     STORAGE_SCHEME: Optional[List[str]]
     """The storage schemes to register against this implementation"""
 
+    def __new__(cls, *args: Any, **kwargs: Any) -> Storage:  # type: ignore[misc]
+        inst = super().__new__(cls)
+
+        for method in {
+            "incr",
+            "get",
+            "get_expiry",
+            "check",
+            "reset",
+            "clear",
+        }:
+            setattr(inst, method, _wrap_errors(inst, getattr(inst, method)))
+
+        return inst
+
     def __init__(
-        self, uri: Optional[str] = None, **options: Union[float, str, bool]
+        self,
+        uri: Optional[str] = None,
+        wrap_exceptions: bool = False,
+        **options: Union[float, str, bool],
     ) -> None:
+        """
+        :param wrap_exceptions: Whether to wrap storage exceptions in
+         :exc:`limits.errors.StorageError` before raising it.
+        """
         super().__init__()
+        self.wrap_exceptions = wrap_exceptions
+
+    @property
+    @abstractmethod
+    def base_exceptions(self) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:
+        raise NotImplementedError
 
     @abstractmethod
     async def incr(
@@ -80,6 +139,22 @@ class MovingWindowSupport(ABC):
     the moving window strategy
     """
 
+    def __new__(cls, *args: Any, **kwargs: Any) -> MovingWindowSupport:  # type: ignore[misc]
+        inst = super().__new__(cls)
+
+        for method in {
+            "acquire_entry",
+            "get_moving_window",
+        }:
+            setattr(
+                inst,
+                method,
+                _wrap_errors(cast(Storage, inst), getattr(inst, method)),
+            )
+
+        return inst
+
+    @abstractmethod
     async def acquire_entry(
         self, key: str, limit: int, expiry: int, amount: int = 1
     ) -> bool:
@@ -91,6 +166,7 @@ class MovingWindowSupport(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
     ) -> Tuple[int, int]:

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/etcd.py

@@ -1,7 +1,7 @@
 import asyncio
 import time
 import urllib.parse
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Tuple, Type, Union
 
 from limits.aio.storage.base import Storage
 from limits.errors import ConcurrentUpdateError
@@ -46,6 +46,12 @@ class EtcdStorage(Storage):
         )
         self.max_retries = max_retries
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.lib.ClientError  # type: ignore[no-any-return]
+
     def prefixed_key(self, key: str) -> bytes:
         return f"{self.PREFIX}/{key}".encode()
 

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/memcached.py

@@ -4,7 +4,7 @@ import urllib.parse
 from deprecated.sphinx import versionadded
 
 from limits.aio.storage.base import Storage
-from limits.typing import EmcacheClientP, Optional, Union
+from limits.typing import EmcacheClientP, Optional, Tuple, Type, Union
 
 
 @versionadded(version="2.1")
@@ -20,10 +20,17 @@ class MemcachedStorage(Storage):
 
     DEPENDENCIES = ["emcache"]
 
-    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: memcached location of the form
          ``async+memcached://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:`emcache.Client`
         :raise ConfigurationError: when :pypi:`emcache` is not available
@@ -38,9 +45,18 @@ class MemcachedStorage(Storage):
 
         self._options = options
         self._storage = None
-        super().__init__(uri, **options)
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
         self.dependency = self.dependencies["emcache"].module
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return (
+            self.dependency.ClusterNoAvailableNodes,
+            self.dependency.CommandError,
+        )
+
     async def get_storage(self) -> EmcacheClientP:
         if not self._storage:
             self._storage = await self.dependency.create_client(

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/memory.py

@@ -6,7 +6,7 @@ from deprecated.sphinx import versionadded
 
 import limits.typing
 from limits.aio.storage.base import MovingWindowSupport, Storage
-from limits.typing import Dict, List, Optional, Tuple
+from limits.typing import Dict, List, Optional, Tuple, Type, Union
 
 
 class LockableEntry(asyncio.Lock):
@@ -30,12 +30,20 @@ class MemoryStorage(Storage, MovingWindowSupport):
     async context
     """
 
-    def __init__(self, uri: Optional[str] = None, **_: str) -> None:
+    def __init__(
+        self, uri: Optional[str] = None, wrap_exceptions: bool = False, **_: str
+    ) -> None:
         self.storage: limits.typing.Counter[str] = Counter()
         self.expirations: Dict[str, float] = {}
         self.events: Dict[str, List[LockableEntry]] = {}
         self.timer: Optional[asyncio.Task[None]] = None
-        super().__init__(uri, **_)
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **_)
+
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return ValueError
 
     async def __expire_events(self) -> None:
         for key in self.events.keys():

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/mongodb.py

@@ -4,12 +4,13 @@ import asyncio
 import calendar
 import datetime
 import time
-from typing import Any
+from typing import Any, cast
 
 from deprecated.sphinx import versionadded
 
 from limits.aio.storage.base import MovingWindowSupport, Storage
-from limits.typing import Dict, Optional, ParamSpec, Tuple, TypeVar, Union
+from limits.typing import Dict, Optional, ParamSpec, Tuple, Type, TypeVar, Union
+from limits.util import get_dependency
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -28,18 +29,13 @@ class MongoDBStorage(Storage, MovingWindowSupport):
     The storage scheme for MongoDB for use in an async context
     """
 
-    DEFAULT_OPTIONS: Dict[str, Union[float, str, bool]] = {
-        "serverSelectionTimeoutMS": 1000,
-        "connectTimeoutMS": 1000,
-    }
-    "Default options passed to :class:`~motor.motor_asyncio.AsyncIOMotorClient`"
-
     DEPENDENCIES = ["motor.motor_asyncio", "pymongo"]
 
     def __init__(
         self,
         uri: str,
         database_name: str = "limits",
+        wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
         """
@@ -47,23 +43,23 @@ 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 options: all remaining keyword arguments are merged with
-         :data:`DEFAULT_OPTIONS` and passed to the constructor of
-         :class:`~motor.motor_asyncio.AsyncIOMotorClient`
+        :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 constructor of :class:`~motor.motor_asyncio.AsyncIOMotorClient`
         :raise ConfigurationError: when the :pypi:`motor` or :pypi:`pymongo` are
          not available
         """
 
-        mongo_opts = options.copy()
-        [mongo_opts.setdefault(k, v) for k, v in self.DEFAULT_OPTIONS.items()]
         uri = uri.replace("async+mongodb", "mongodb", 1)
 
-        super().__init__(uri, **options)
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
 
         self.dependency = self.dependencies["motor.motor_asyncio"]
         self.proxy_dependency = self.dependencies["pymongo"]
+        self.lib_errors, _ = get_dependency("pymongo.errors")
 
-        self.storage = self.dependency.module.AsyncIOMotorClient(uri, **mongo_opts)
+        self.storage = self.dependency.module.AsyncIOMotorClient(uri, **options)
         # TODO: Fix this hack. It was noticed when running a benchmark
         # with FastAPI - however - doesn't appear in unit tests or in an isolated
         # use. Reference: https://jira.mongodb.org/browse/MOTOR-822
@@ -72,6 +68,12 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         self.__database_name = database_name
         self.__indices_created = False
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.lib_errors.PyMongoError  # type: ignore
+
     @property
     def database(self):  # type: ignore
         return self.storage.get_database(self.__database_name)
@@ -98,7 +100,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
             self.database.counters.drop(), self.database.windows.drop()
         )
 
-        return num_keys
+        return cast(int, num_keys)
 
     async def clear(self, key: str) -> None:
         """
@@ -257,8 +259,9 @@ class MongoDBStorage(Storage, MovingWindowSupport):
             await self.database.windows.update_one(
                 {
                     "_id": key,
-                    "entries.%d"
-                    % (limit - amount): {"$not": {"$gte": timestamp - expiry}},
+                    "entries.%d" % (limit - amount): {
+                        "$not": {"$gte": timestamp - expiry}
+                    },
                 },
                 updates,
                 upsert=True,

{limits-3.6.0 → limits-3.9.0}/limits/aio/storage/redis.py

@@ -7,7 +7,7 @@ from packaging.version import Version
 
 from limits.aio.storage.base import MovingWindowSupport, Storage
 from limits.errors import ConfigurationError
-from limits.typing import AsyncRedisClient, Dict, Optional, Tuple, Union
+from limits.typing import AsyncRedisClient, Dict, Optional, Tuple, Type, Union
 from limits.util import get_package_data
 
 if TYPE_CHECKING:
@@ -30,6 +30,11 @@ class RedisInteractor:
     lua_clear_keys: "coredis.commands.Script[bytes]"
     lua_incr_expire: "coredis.commands.Script[bytes]"
 
+    PREFIX = "LIMITS"
+
+    def prefixed_key(self, key: str) -> str:
+        return f"{self.PREFIX}:{key}"
+
     async def _incr(
         self,
         key: str,
@@ -46,6 +51,7 @@ class RedisInteractor:
         :param expiry: amount in seconds for the key to expire in
         :param amount: the number to increment by
         """
+        key = self.prefixed_key(key)
         value = await connection.incrby(key, amount)
 
         if elastic_expiry or value == amount:
@@ -59,6 +65,7 @@ class RedisInteractor:
         :param key: the key to get the counter value for
         """
 
+        key = self.prefixed_key(key)
         return int(await connection.get(key) or 0)
 
     async def _clear(self, key: str, connection: AsyncRedisClient) -> None:
@@ -66,6 +73,7 @@ class RedisInteractor:
         :param key: the key to clear rate limits for
         :param connection: Redis connection
         """
+        key = self.prefixed_key(key)
         await connection.delete([key])
 
     async def get_moving_window(
@@ -79,6 +87,7 @@ class RedisInteractor:
         :param expiry: expiry of entry
         :return: (start of window, number of acquired entries)
         """
+        key = self.prefixed_key(key)
         timestamp = int(time.time())
         window = await self.lua_moving_window.execute(
             [key], [int(timestamp - expiry), limit]
@@ -101,6 +110,7 @@ class RedisInteractor:
         :param expiry: expiry of the entry
         :param connection: Redis connection
         """
+        key = self.prefixed_key(key)
         timestamp = time.time()
         acquired = await self.lua_acquire_window.execute(
             [key], [timestamp, limit, expiry, amount]
@@ -114,6 +124,7 @@ class RedisInteractor:
         :param connection: Redis connection
         """
 
+        key = self.prefixed_key(key)
         return int(max(await connection.ttl(key), 0) + time.time())
 
     async def _check(self, connection: AsyncRedisClient) -> bool:
@@ -148,6 +159,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
         self,
         uri: str,
         connection_pool: Optional["coredis.ConnectionPool"] = None,
+        wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
         """
@@ -156,13 +168,15 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
          - ``async+redis://[:password]@host:port``
          - ``async+redis://[:password]@host:port/db``
          - ``async+rediss://[:password]@host:port``
-         - ``async+unix:///path/to/sock`` etc...
+         - ``async+redis+unix:///path/to/sock?db=0`` etc...
 
          This uri is passed directly to :meth:`coredis.Redis.from_url` with
          the initial ``async`` removed, except for the case of ``async+redis+unix``
          where it is replaced with ``unix``.
         :param connection_pool: if provided, the redis client is initialized with
          the connection pool and any other params passed as :paramref:`options`
+        :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:`coredis.Redis`
         :raise ConfigurationError: when the redis library is not available
@@ -170,7 +184,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
         uri = uri.replace("async+redis", "redis", 1)
         uri = uri.replace("redis+unix", "unix")
 
-        super().__init__(uri, **options)
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
 
         self.dependency = self.dependencies["coredis"].module
 
@@ -183,6 +197,12 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
         self.initialize_storage(uri)
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.dependency.RedisError  # type: ignore[no-any-return]
+
     def initialize_storage(self, _uri: str) -> None:
         # all these methods are coroutines, so must be called with await
         self.lua_moving_window = self.storage.register_script(self.SCRIPT_MOVING_WINDOW)
@@ -210,6 +230,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
                 key, expiry, self.storage, elastic_expiry, amount
             )
         else:
+            key = self.prefixed_key(key)
             return cast(
                 int, await self.lua_incr_expire.execute([key], [expiry, amount])
             )
@@ -256,15 +277,16 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
     async def reset(self) -> Optional[int]:
         """
-        This function calls a Lua Script to delete keys prefixed with 'LIMITER'
-        in block of 5000.
+        This function calls a Lua Script to delete keys prefixed with
+        ``self.PREFIX`` in blocks of 5000.
 
         .. warning:: This operation was designed to be fast, but was not tested
            on a large production based system. Be careful with its usage as it
            could be slow on very large data sets.
         """
 
-        return cast(int, await self.lua_clear_keys.execute(["LIMITER*"]))
+        prefix = self.prefixed_key("*")
+        return cast(int, await self.lua_clear_keys.execute([prefix]))
 
 
 @versionadded(version="2.1")
@@ -285,7 +307,12 @@ class RedisClusterStorage(RedisStorage):
     }
     "Default options passed to :class:`coredis.RedisCluster`"
 
-    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
          ``async+redis+cluster://[:password]@host:port,host:port``
@@ -309,7 +336,9 @@ class RedisClusterStorage(RedisStorage):
             host, port = loc.split(":")
             cluster_hosts.append({"host": host, "port": int(port)})
 
-        super(RedisStorage, self).__init__(uri, **options)
+        super(RedisStorage, self).__init__(
+            uri, wrap_exceptions=wrap_exceptions, **options
+        )
 
         self.dependency = self.dependencies["coredis"].module
 
@@ -323,15 +352,16 @@ class RedisClusterStorage(RedisStorage):
         """
         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 'LIMITER' and calls delete on them, one at
-        a time.
+        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
         """
 
-        keys = await self.storage.keys("LIMITER*")
+        prefix = self.prefixed_key("*")
+        keys = await self.storage.keys(prefix)
         count = 0
         for key in keys:
             count += await self.storage.delete([key])

{limits-3.6.0 → limits-3.9.0}/limits/errors.py

@@ -17,3 +17,12 @@ class ConcurrentUpdateError(Exception):
 
     def __init__(self, key: str, attempts: int) -> None:
         super().__init__(f"Unable to update {key} after {attempts} retries")
+
+
+class StorageError(Exception):
+    """
+    Error raised when an error is encountered in a storage
+    """
+
+    def __init__(self, storage_error: Exception) -> None:
+        self.storage_error = storage_error

{limits-3.6.0 → limits-3.9.0}/limits/limits.py

@@ -1,6 +1,7 @@
 """
 
 """
+
 from __future__ import annotations
 
 from functools import total_ordering