limits 3.7.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-11-24T14:02:38-0800",
+ "date": "2024-02-14T15:45:28-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "0946fdcd3b9509041a823d3bb1b63ea1de9ab6ee",
- "version": "3.7.0"
+ "full-revisionid": "f1fe9f3efffef2f4c5975a93a069a8b759d3a240",
+ "version": "3.8.0"
 }
 '''  # END VERSION_JSON
 

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/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/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/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/aio/storage/mongodb.py

@@ -9,7 +9,8 @@ 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")
@@ -40,6 +41,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         self,
         uri: str,
         database_name: str = "limits",
+        wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
         """
@@ -47,6 +49,8 @@ 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 wrap_exceptions: Whether to wrap storage exceptions in
+         :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are merged with
          :data:`DEFAULT_OPTIONS` and passed to the constructor of
          :class:`~motor.motor_asyncio.AsyncIOMotorClient`
@@ -58,10 +62,11 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         [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)
         # TODO: Fix this hack. It was noticed when running a benchmark
@@ -72,6 +77,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)
@@ -257,8 +268,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/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:
@@ -159,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:
         """
@@ -167,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
@@ -181,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
 
@@ -194,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)
@@ -268,8 +277,8 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
     async def reset(self) -> Optional[int]:
         """
-        This function calls a Lua Script to delete keys prefixed with `self.PREFIX`
-        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
@@ -298,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``
@@ -322,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
 
@@ -336,7 +352,7 @@ 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 `self.PREFIX` and calls delete on them,
+        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.

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/limits.py

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

limits/storage/base.py

@@ -1,11 +1,38 @@
+from __future__ import annotations
+
+import functools
 import threading
 from abc import ABC, abstractmethod
+from typing import Any, cast
 
+from limits import errors
 from limits.storage.registry import StorageRegistry
-from limits.typing import List, Optional, Tuple, Union
+from limits.typing import (
+    Callable,
+    List,
+    Optional,
+    P,
+    R,
+    Tuple,
+    Type,
+    Union,
+)
 from limits.util import LazyDependency
 
 
+def _wrap_errors(storage: Storage, fn: Callable[P, R]) -> Callable[P, R]:
+    @functools.wraps(fn)
+    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return fn(*args, **kwargs)
+        except storage.base_exceptions as exc:
+            if storage.wrap_exceptions:
+                raise errors.StorageError(exc) from exc
+            raise
+
+    return inner
+
+
 class Storage(LazyDependency, metaclass=StorageRegistry):
     """
     Base class to extend when implementing a storage backend.
@@ -14,9 +41,40 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
     STORAGE_SCHEME: Optional[List[str]]
     """The storage schemes to register against this implementation"""
 
-    def __init__(self, uri: Optional[str] = None, **options: Union[float, str, bool]):
+    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,
+        wrap_exceptions: bool = False,
+        **options: Union[float, str, bool],
+    ):
+        """
+        :param wrap_exceptions: Whether to wrap storage exceptions in
+         :exc:`limits.errors.StorageError` before raising it.
+        """
+
         self.lock = threading.RLock()
         super().__init__()
+        self.wrap_exceptions = wrap_exceptions
+
+    @property
+    @abstractmethod
+    def base_exceptions(self) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:
+        raise NotImplementedError
 
     @abstractmethod
     def incr(
@@ -77,6 +135,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
     def acquire_entry(self, key: str, limit: int, expiry: int, amount: int = 1) -> bool:
         """
         :param key: rate limit key to acquire an entry in
@@ -86,6 +160,7 @@ class MovingWindowSupport(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
     def get_moving_window(self, key: str, limit: int, expiry: int) -> Tuple[int, int]:
         """
         returns the starting point and the number of entries in the moving

limits/storage/etcd.py

@@ -1,6 +1,6 @@
 import time
 import urllib.parse
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Tuple, Type, Union
 
 from limits.errors import ConcurrentUpdateError
 from limits.storage.base import Storage
@@ -44,6 +44,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.Etcd3Exception  # type: ignore[no-any-return]
+
     def prefixed_key(self, key: str) -> bytes:
         return f"{self.PREFIX}/{key}".encode()
 

limits/storage/memcached.py

@@ -7,7 +7,17 @@ from typing import cast
 
 from limits.errors import ConfigurationError
 from limits.storage.base import Storage
-from limits.typing import Callable, List, MemcachedClientP, Optional, P, R, Tuple, Union
+from limits.typing import (
+    Callable,
+    List,
+    MemcachedClientP,
+    Optional,
+    P,
+    R,
+    Tuple,
+    Type,
+    Union,
+)
 from limits.util import get_dependency
 
 
@@ -20,16 +30,20 @@ class MemcachedStorage(Storage):
 
     STORAGE_SCHEME = ["memcached"]
     """The storage scheme for memcached"""
+    DEPENDENCIES = ["pymemcache"]
 
     def __init__(
         self,
         uri: str,
+        wrap_exceptions: bool = False,
         **options: Union[str, Callable[[], MemcachedClientP]],
     ) -> None:
         """
         :param uri: memcached location of the form
          ``memcached://host:port,host:port``,
          ``memcached:///var/tmp/path/to/sock``
+        :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:`pymemcache.client.base.PooledClient`
          or :class:`pymemcache.client.hash.HashClient` (if there are more than
@@ -50,6 +64,7 @@ class MemcachedStorage(Storage):
             if parsed.path and not parsed.netloc and not parsed.port:
                 self.hosts = [parsed.path]  # type: ignore
 
+        self.dependency = self.dependencies["pymemcache"].module
         self.library = str(options.pop("library", "pymemcache.client"))
         self.cluster_library = str(
             options.pop("cluster_library", "pymemcache.client.hash")
@@ -67,6 +82,13 @@ class MemcachedStorage(Storage):
             )  # pragma: no cover
         self.local_storage = threading.local()
         self.local_storage.storage = None
+        super().__init__(uri, wrap_exceptions=wrap_exceptions)
+
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.dependency.MemcacheError  # type: ignore[no-any-return]
 
     def get_client(
         self, module: ModuleType, hosts: List[Tuple[str, int]], **kwargs: str
@@ -77,11 +99,14 @@ class MemcachedStorage(Storage):
         :param module: the memcached module
         :param hosts: list of memcached hosts
         """
+
         return cast(
             MemcachedClientP,
-            module.HashClient(hosts, **kwargs)
-            if len(hosts) > 1
-            else module.PooledClient(*hosts, **kwargs),
+            (
+                module.HashClient(hosts, **kwargs)
+                if len(hosts) > 1
+                else module.PooledClient(*hosts, **kwargs)
+            ),
         )
 
     def call_memcached_func(
@@ -89,6 +114,7 @@ class MemcachedStorage(Storage):
     ) -> R:
         if "noreply" in kwargs:
             argspec = inspect.getfullargspec(func)
+
             if not ("noreply" in argspec.args or argspec.varkw):
                 kwargs.pop("noreply")
 
@@ -104,6 +130,7 @@ class MemcachedStorage(Storage):
             dependency = get_dependency(
                 self.cluster_library if len(self.hosts) > 1 else self.library
             )[0]
+
             if not dependency:
                 raise ConfigurationError(f"Unable to import {self.cluster_library}")
             self.local_storage.storage = self.client_getter(

limits/storage/memory.py

@@ -4,7 +4,7 @@ from collections import Counter
 
 import limits.typing
 from limits.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(threading._RLock):  # type: ignore
@@ -24,13 +24,21 @@ class MemoryStorage(Storage, MovingWindowSupport):
 
     STORAGE_SCHEME = ["memory"]
 
-    def __init__(self, uri: Optional[str] = None, **_: str):
+    def __init__(
+        self, uri: Optional[str] = None, wrap_exceptions: bool = False, **_: str
+    ):
         self.storage: limits.typing.Counter[str] = Counter()
         self.expirations: Dict[str, float] = {}
         self.events: Dict[str, List[LockableEntry]] = {}
         self.timer = threading.Timer(0.01, self.__expire_events)
         self.timer.start()
-        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
 
     def __expire_events(self) -> None:
         for key in list(self.events.keys()):

limits/storage/mongodb.py

@@ -7,8 +7,9 @@ from typing import TYPE_CHECKING, Any
 
 from deprecated.sphinx import versionadded
 
-from limits.typing import Dict, Optional, Tuple, Union
+from limits.typing import Dict, Optional, Tuple, Type, Union
 
+from ..util import get_dependency
 from .base import MovingWindowSupport, Storage
 
 if TYPE_CHECKING:
@@ -33,22 +34,29 @@ class MongoDBStorage(Storage, MovingWindowSupport):
     DEPENDENCIES = ["pymongo"]
 
     def __init__(
-        self, uri: str, database_name: str = "limits", **options: Union[int, str, bool]
+        self,
+        uri: str,
+        database_name: str = "limits",
+        wrap_exceptions: bool = False,
+        **options: Union[int, str, bool],
     ) -> None:
         """
         :param uri: uri of the form ``mongodb://[user:password]@host:port?...``,
          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 wrap_exceptions: Whether to wrap storage exceptions in
+         :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are merged with
          :data:`DEFAULT_OPTIONS` and passed to the constructor of
          :class:`~pymongo.mongo_client.MongoClient`
         :raise ConfigurationError: when the :pypi:`pymongo` library is not available
         """
 
-        super().__init__(uri, **options)
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
 
         self.lib = self.dependencies["pymongo"].module
+        self.lib_errors, _ = get_dependency("pymongo.errors")
 
         mongo_opts = options.copy()
         [mongo_opts.setdefault(k, v) for k, v in self.DEFAULT_OPTIONS.items()]
@@ -60,6 +68,12 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         self.windows = self.storage.get_database(database_name).windows
         self.__initialize_database()
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.lib_errors.PyMongoError  # type: ignore
+
     def __initialize_database(self) -> None:
         self.counters.create_index("expireAt", expireAfterSeconds=0)
         self.windows.create_index("expireAt", expireAfterSeconds=0)
@@ -222,8 +236,9 @@ class MongoDBStorage(Storage, MovingWindowSupport):
             self.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/storage/redis.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 from packaging.version import Version
 
-from limits.typing import Optional, RedisClient, ScriptP, Tuple, Union
+from limits.typing import Optional, RedisClient, ScriptP, Tuple, Type, Union
 
 from ..util import get_package_data
 from .base import MovingWindowSupport, Storage
@@ -145,6 +145,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
         self,
         uri: str,
         connection_pool: Optional[redis.connection.ConnectionPool] = None,
+        wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
         """
@@ -155,21 +156,31 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
          case of ``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:`redis.Redis`
         :raise ConfigurationError: when the :pypi:`redis` library is not available
         """
-        super().__init__(uri, **options)
-        redis = self.dependencies["redis"].module
+        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
+        self.dependency = self.dependencies["redis"].module
 
         uri = uri.replace("redis+unix", "unix")
 
         if not connection_pool:
-            self.storage = redis.from_url(uri, **options)
+            self.storage = self.dependency.from_url(uri, **options)
         else:
-            self.storage = redis.Redis(connection_pool=connection_pool, **options)
+            self.storage = self.dependency.Redis(
+                connection_pool=connection_pool, **options
+            )
         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:
         self.lua_moving_window = self.storage.register_script(self.SCRIPT_MOVING_WINDOW)
         self.lua_acquire_window = self.storage.register_script(
@@ -237,8 +248,8 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
     def reset(self) -> Optional[int]:
         """
-        This function calls a Lua Script to delete keys prefixed with `self.PREFIX`
-        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

limits/storage/redis_cluster.py

@@ -116,7 +116,7 @@ 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 `self.PREFIX` and calls delete on them,
+        keys that are prefixed with ``self.PREFIX`` and calls delete on them,
         one at a time.
 
         .. warning::

limits/storage/redis_sentinel.py

@@ -29,7 +29,8 @@ class RedisSentinelStorage(RedisStorage):
         service_name: Optional[str] = None,
         use_replicas: bool = True,
         sentinel_kwargs: Optional[Dict[str, Union[float, str, bool]]] = None,
-        **options: Union[float, str, bool]
+        wrap_exceptions: bool = False,
+        **options: Union[float, str, bool],
     ) -> None:
         """
         :param uri: url of the form
@@ -39,13 +40,17 @@ class RedisSentinelStorage(RedisStorage):
         :param use_replicas: Whether to use replicas for read only operations
         :param sentinel_kwargs: kwargs to pass as
          :attr:`sentinel_kwargs` to :class:`redis.sentinel.Sentinel`
+        :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.sentinel.Sentinel`
         :raise ConfigurationError: when the redis library is not available
          or if the redis master host cannot be pinged.
         """
 
-        super(RedisStorage, self).__init__(uri, **options)
+        super(RedisStorage, self).__init__(
+            uri, wrap_exceptions=wrap_exceptions, **options
+        )
 
         parsed = urllib.parse.urlparse(uri)
         sentinel_configuration = []
@@ -74,7 +79,7 @@ class RedisSentinelStorage(RedisStorage):
         self.sentinel: "redis.sentinel.Sentinel" = sentinel_dep.Sentinel(
             sentinel_configuration,
             sentinel_kwargs={**parsed_auth, **sentinel_options},
-            **{**parsed_auth, **options}
+            **{**parsed_auth, **options},
         )
         self.storage = self.sentinel.master_for(self.service_name)
         self.storage_slave = self.sentinel.slave_for(self.service_name)

limits/typing.py

@@ -1,5 +1,6 @@
 from typing import (
     TYPE_CHECKING,
+    Awaitable,
     Callable,
     Dict,
     List,
@@ -120,6 +121,7 @@ class ScriptP(Protocol[R_co]):
 
 __all__ = [
     "AsyncRedisClient",
+    "Awaitable",
     "Callable",
     "ClassVar",
     "Counter",

limits/util.py

@@ -1,6 +1,7 @@
 """
 
 """
+
 import dataclasses
 import re
 import sys

{limits-3.7.0.dist-info → limits-3.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: limits
-Version: 3.7.0
+Version: 3.8.0
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -76,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.8.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+limits/__init__.py,sha256=j_yVhgN9pdz8o5rQjVwdJTBSq8F-CTzof9kkiYgjRbw,728
+limits/_version.py,sha256=VSokpHoRkI7WgCt1pxQTeRNyLsvBlTcgUT3Hkqv48Aw,497
+limits/errors.py,sha256=xCKGOVJiD-g8FlsQQb17AW2pTUvalYSuizPpvEVoYJE,626
+limits/limits.py,sha256=bkPQ_gtkggwqYO6QiLLiaSBKUOJTjDzzELIVQiOWYt4,4944
+limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+limits/strategies.py,sha256=7pr2V34KdOEfxnYOf882Cl2qKY-KK6HwKjdYo_IsD4c,6690
+limits/typing.py,sha256=RNfTbaRV5LGHdwM2KPcqH6gwep_SEMka9dPpOcw1wjs,3008
+limits/util.py,sha256=9bSmdtiQnai4FHJ8yN4s6dpT0n5BPiDr6tXnqGhYmIw,5744
+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/storage/__init__.py,sha256=CbtuSlVl1jPyN_vsEI_ApWblDblVaL46xcZ2M_oM0V8,595
+limits/aio/storage/base.py,sha256=dSM39OguwdLdBIHaz98eWljHzxUfgcatweNSeo9d8OQ,4795
+limits/aio/storage/etcd.py,sha256=Rjb_EYKFRr4F2Z6zvAPP9vQOyXJQHaju3VjxxUs75_c,4791
+limits/aio/storage/memcached.py,sha256=6aTlACfCtchdcZqoisnei0MOlCH7yLV9A1yCjOE5f9g,4802
+limits/aio/storage/memory.py,sha256=DT8GzExZsN0hKitS2HP-eiJfHYYJ9W_IRwGOj56uChY,5850
+limits/aio/storage/mongodb.py,sha256=RrNtUdG0_yVcb3TV7BdG5idX8vM_ckvC4Sc7zrJvI0Y,9574
+limits/aio/storage/redis.py,sha256=aY_WtwB6x_2p_5NkO8d7I5Mi2lZlHSHC70u1qB0Tuus,15640
+limits/resources/redis/lua_scripts/acquire_moving_window.lua,sha256=5CFJX7D6T6RG5SFr6eVZ6zepmI1EkGWmKeVEO4QNrWo,483
+limits/resources/redis/lua_scripts/clear_keys.lua,sha256=zU0cVfLGmapRQF9x9u0GclapM_IB2pJLszNzVQ1QRK4,184
+limits/resources/redis/lua_scripts/incr_expire.lua,sha256=Uq9NcrrcDI-F87TDAJexoSJn2SDgeXIUEYozCp9S3oA,195
+limits/resources/redis/lua_scripts/moving_window.lua,sha256=ir0SkuRVnrqkVSFNIuedTV_KW6zG70Z56u6-_FpR_20,352
+limits/storage/__init__.py,sha256=8i1-SoTEV_XGAMYDepcLra7do-Tx4rUPbPrUQVVJgTw,2518
+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=sFBS8nYSxKFBCSXzhbK1YlX9BKc4whpjlyLbgrCnPsw,5555
+limits/storage/mongodb.py,sha256=aK7PABV_3enpzq1wmlX0N2YOxLTpj-H7-3XHrs0vb84,8462
+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/registry.py,sha256=xcBcxuu6srqmoS4WqDpkCXnRLB19ctH98v21P8S9kS8,708
+limits-3.8.0.dist-info/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
+limits-3.8.0.dist-info/METADATA,sha256=TZ-3C78WxvC03_NNRgit9qvd9NxVActX3k5ByYWMsXo,7118
+limits-3.8.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+limits-3.8.0.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
+limits-3.8.0.dist-info/RECORD,,

{limits-3.7.0.dist-info → limits-3.8.0.dist-info}/WHEEL

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

limits-3.7.0.dist-info/RECORD

@@ -1,37 +0,0 @@
-limits/__init__.py,sha256=j_yVhgN9pdz8o5rQjVwdJTBSq8F-CTzof9kkiYgjRbw,728
-limits/_version.py,sha256=-BJDgGzH-CbJma8-Y_Y0s314aB1Y3YzjezQxt_8tfDw,497
-limits/errors.py,sha256=sUolBUfTFLQSzo6dfE2E9j_0K7_8Nr9_Hx-v5C4D0EU,416
-limits/limits.py,sha256=lwQnA5wegkW_AXtplOH3tLuQ1LByMX9hqHJquYVYdTs,4943
-limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-limits/strategies.py,sha256=7pr2V34KdOEfxnYOf882Cl2qKY-KK6HwKjdYo_IsD4c,6690
-limits/typing.py,sha256=h6K8fbmgCyJih2qJFq52_6Ic1WmFNDQx1UbdEGHCD5o,2976
-limits/util.py,sha256=LRsn6i3KmQE33Ea4FTf4IxD9SMtwiKVXN5iDxTEuOuc,5743
-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/storage/__init__.py,sha256=CbtuSlVl1jPyN_vsEI_ApWblDblVaL46xcZ2M_oM0V8,595
-limits/aio/storage/base.py,sha256=gsy_91lvm53AoAKi1plaegcEOSZXK3OiMP0mxA6lPAw,2941
-limits/aio/storage/etcd.py,sha256=iGGuKHN5cCW9r4nLeiZ4TnoU1pfSXXLZhS2YOWznryw,4568
-limits/aio/storage/memcached.py,sha256=aR7f5NY-mXtFFjphbaxoL7z1cAHZuRYjpGUVOktoI4A,4296
-limits/aio/storage/memory.py,sha256=A506i0vncBmsaL9GGAqepQkPAXyc-HxmJ8gS8kJtqpE,5597
-limits/aio/storage/mongodb.py,sha256=xnZTyogdLdYir5xQMs_yQTBJt6B5P1pJx0VYBAo_Ndc,9041
-limits/aio/storage/redis.py,sha256=k0YgeXlvITUZEjql32KNm1vhN73zZHCcx0QJyK_Gg94,15080
-limits/resources/redis/lua_scripts/acquire_moving_window.lua,sha256=5CFJX7D6T6RG5SFr6eVZ6zepmI1EkGWmKeVEO4QNrWo,483
-limits/resources/redis/lua_scripts/clear_keys.lua,sha256=zU0cVfLGmapRQF9x9u0GclapM_IB2pJLszNzVQ1QRK4,184
-limits/resources/redis/lua_scripts/incr_expire.lua,sha256=Uq9NcrrcDI-F87TDAJexoSJn2SDgeXIUEYozCp9S3oA,195
-limits/resources/redis/lua_scripts/moving_window.lua,sha256=ir0SkuRVnrqkVSFNIuedTV_KW6zG70Z56u6-_FpR_20,352
-limits/storage/__init__.py,sha256=8i1-SoTEV_XGAMYDepcLra7do-Tx4rUPbPrUQVVJgTw,2518
-limits/storage/base.py,sha256=-JV-zAkss7pOETZyPYjo8ZZqTMGs-DPqgz_gcfArXfs,2818
-limits/storage/etcd.py,sha256=SlDHRItliRaR2j5Rf_v_oQ57ITpmNMYQJSamM3SbwCA,4258
-limits/storage/memcached.py,sha256=qMvRIEtRRzZXSgcZSUTBgUlBDeNOpIr_gDTV2r5SPak,6005
-limits/storage/memory.py,sha256=plPsyLB26QN9I6jQq00fra-cdh8xoDAgaoM-kWuECtk,5302
-limits/storage/mongodb.py,sha256=Z4_Og2Ys6uwQT_D4dUDdDAEndBY7UfCh_LiHgZf8IUk,7909
-limits/storage/redis.py,sha256=-5_kQuvC6tjMUgDoYAsANqMouu0PujE-jocRqmxXvsc,7970
-limits/storage/redis_cluster.py,sha256=fINAmdZSs_0lAr3p_TdZtpWAUqmiWmKFNKyfRcMkSTQ,5378
-limits/storage/redis_sentinel.py,sha256=AxbtYZQXCNL-4yu7dQ8i6MhwO2PNLMRLHe3JcHkMKvA,3647
-limits/storage/registry.py,sha256=xcBcxuu6srqmoS4WqDpkCXnRLB19ctH98v21P8S9kS8,708
-limits-3.7.0.dist-info/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
-limits-3.7.0.dist-info/METADATA,sha256=EUabf_Y_kURN4qtkyeguZu_rlNI38lQUB1PgKPEvv1s,7314
-limits-3.7.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-limits-3.7.0.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
-limits-3.7.0.dist-info/RECORD,,