limits 4.0.1__py3-none-any.whl → 4.1__py3-none-any.whl

limits/storage/redis_sentinel.py

@@ -5,10 +5,10 @@ from packaging.version import Version
 
 from limits.errors import ConfigurationError
 from limits.storage.redis import RedisStorage
-from limits.typing import Dict, Optional, Tuple, Type, Union
+from limits.typing import Optional, RedisClient, Type, Union
 
 if TYPE_CHECKING:
-    import redis.sentinel
+    pass
 
 
 class RedisSentinelStorage(RedisStorage):
@@ -21,14 +21,14 @@ class RedisSentinelStorage(RedisStorage):
     STORAGE_SCHEME = ["redis+sentinel"]
     """The storage scheme for redis accessed via a redis sentinel installation"""
 
-    DEPENDENCIES = {"redis.sentinel": Version("3.0")}
+    DEPENDENCIES = {"redis": Version("3.0"), "redis.sentinel": Version("3.0")}
 
     def __init__(
         self,
         uri: str,
         service_name: Optional[str] = None,
         use_replicas: bool = True,
-        sentinel_kwargs: Optional[Dict[str, Union[float, str, bool]]] = None,
+        sentinel_kwargs: Optional[dict[str, Union[float, str, bool]]] = None,
         wrap_exceptions: bool = False,
         **options: Union[float, str, bool],
     ) -> None:
@@ -56,7 +56,7 @@ class RedisSentinelStorage(RedisStorage):
         sentinel_configuration = []
         sentinel_options = sentinel_kwargs.copy() if sentinel_kwargs else {}
 
-        parsed_auth: Dict[str, Union[float, str, bool]] = {}
+        parsed_auth: dict[str, Union[float, str, bool]] = {}
 
         if parsed.username:
             parsed_auth["username"] = parsed.username
@@ -76,44 +76,21 @@ class RedisSentinelStorage(RedisStorage):
             raise ConfigurationError("'service_name' not provided")
 
         sentinel_dep = self.dependencies["redis.sentinel"].module
-        self.sentinel: "redis.sentinel.Sentinel" = sentinel_dep.Sentinel(
+        self.sentinel = sentinel_dep.Sentinel(
             sentinel_configuration,
             sentinel_kwargs={**parsed_auth, **sentinel_options},
             **{**parsed_auth, **options},
         )
-        self.storage = self.sentinel.master_for(self.service_name)
-        self.storage_slave = self.sentinel.slave_for(self.service_name)
+        self.storage: RedisClient = self.sentinel.master_for(self.service_name)
+        self.storage_slave: RedisClient = self.sentinel.slave_for(self.service_name)
         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]
+    ) -> Union[Type[Exception], tuple[Type[Exception], ...]]:  # pragma: no cover
+        return self.dependencies["redis"].module.RedisError  # type: ignore[no-any-return]
 
-    def get(self, key: str) -> int:
-        """
-        :param key: the key to get the counter value for
-        """
-
-        return super()._get(
-            key, self.storage_slave if self.use_replicas else self.storage
-        )
-
-    def get_expiry(self, key: str) -> float:
-        """
-        :param key: the key to get the expiry for
-        """
-
-        return super()._get_expiry(
-            key, self.storage_slave if self.use_replicas else self.storage
-        )
-
-    def check(self) -> bool:
-        """
-        Check if storage is healthy by calling :class:`aredis.StrictRedis.ping`
-        on the slave.
-        """
-
-        return super()._check(self.storage_slave if self.use_replicas else self.storage)
+    def get_connection(self, readonly: bool = False) -> RedisClient:
+        return self.storage_slave if (readonly and self.use_replicas) else self.storage

limits/storage/registry.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 
 from abc import ABCMeta
 
-from limits.typing import Dict, List, Tuple, Union
+from limits.typing import Union
 
-SCHEMES: Dict[str, StorageRegistry] = {}
+SCHEMES: dict[str, StorageRegistry] = {}
 
 
 class StorageRegistry(ABCMeta):
     def __new__(
-        mcs, name: str, bases: Tuple[type, ...], dct: Dict[str, Union[str, List[str]]]
+        mcs, name: str, bases: tuple[type, ...], dct: dict[str, Union[str, list[str]]]
     ) -> StorageRegistry:
         storage_scheme = dct.get("STORAGE_SCHEME", None)
         cls = super().__new__(mcs, name, bases, dct)

limits/strategies.py

@@ -2,11 +2,17 @@
 Rate limiting strategies
 """
 
+import time
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Type, Union, cast
+from math import floor, inf
+
+from deprecated.sphinx import deprecated, versionadded
+
+from limits.storage.base import SlidingWindowCounterSupport
 
 from .limits import RateLimitItem
 from .storage import MovingWindowSupport, Storage, StorageTypes
+from .typing import Union, cast
 from .util import WindowStats
 
 
@@ -173,6 +179,112 @@ class FixedWindowRateLimiter(RateLimiter):
         return WindowStats(reset, remaining)
 
 
+@versionadded(version="4.1")
+class SlidingWindowCounterRateLimiter(RateLimiter):
+    """
+    Reference: :ref:`strategies:sliding window counter`
+    """
+
+    def __init__(self, storage: StorageTypes):
+        if not hasattr(storage, "get_sliding_window") or not hasattr(
+            storage, "acquire_sliding_window_entry"
+        ):
+            raise NotImplementedError(
+                "SlidingWindowCounterRateLimiting is not implemented for storage "
+                "of type %s" % storage.__class__
+            )
+        super().__init__(storage)
+
+    def _weighted_count(
+        self,
+        item: RateLimitItem,
+        previous_count: int,
+        previous_expires_in: float,
+        current_count: int,
+    ) -> float:
+        """
+        Return the approximated by weighting the previous window count and adding the current window count.
+        """
+        return previous_count * previous_expires_in / item.get_expiry() + current_count
+
+    def hit(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
+        """
+        Consume the rate limit
+
+        :param item: The rate limit item
+        :param identifiers: variable list of strings to uniquely identify this
+         instance of the limit
+        :param cost: The cost of this hit, default 1
+        """
+        return cast(
+            SlidingWindowCounterSupport, self.storage
+        ).acquire_sliding_window_entry(
+            item.key_for(*identifiers),
+            item.amount,
+            item.get_expiry(),
+            cost,
+        )
+
+    def test(self, item: RateLimitItem, *identifiers: str, cost: int = 1) -> bool:
+        """
+        Check if the rate limit can be consumed
+
+        :param item: The rate limit item
+        :param identifiers: variable list of strings to uniquely identify this
+         instance of the limit
+        :param cost: The expected cost to be consumed, default 1
+        """
+        previous_count, previous_expires_in, current_count, _ = cast(
+            SlidingWindowCounterSupport, self.storage
+        ).get_sliding_window(item.key_for(*identifiers), item.get_expiry())
+
+        return (
+            self._weighted_count(
+                item, previous_count, previous_expires_in, current_count
+            )
+            < item.amount - cost + 1
+        )
+
+    def get_window_stats(self, item: RateLimitItem, *identifiers: str) -> WindowStats:
+        """
+        Query the reset time and remaining amount for the limit.
+
+        :param item: The rate limit item
+        :param identifiers: variable list of strings to uniquely identify this
+         instance of the limit
+        :return: WindowStats(reset time, remaining)
+        """
+        previous_count, previous_expires_in, current_count, current_expires_in = cast(
+            SlidingWindowCounterSupport, self.storage
+        ).get_sliding_window(item.key_for(*identifiers), item.get_expiry())
+
+        remaining = max(
+            0,
+            item.amount
+            - floor(
+                self._weighted_count(
+                    item, previous_count, previous_expires_in, current_count
+                )
+            ),
+        )
+
+        now = time.time()
+
+        if not (previous_count or current_count):
+            return WindowStats(now, remaining)
+
+        expiry = item.get_expiry()
+
+        previous_reset_in, current_reset_in = inf, inf
+        if previous_count:
+            previous_reset_in = previous_expires_in % (expiry / previous_count)
+        if current_count:
+            current_reset_in = current_expires_in % expiry
+
+        return WindowStats(now + min(previous_reset_in, current_reset_in), remaining)
+
+
+@deprecated(version="4.1", action="always")
 class FixedWindowElasticExpiryRateLimiter(FixedWindowRateLimiter):
     """
     Reference: :ref:`strategies:fixed window with elastic expiry`
@@ -200,12 +312,14 @@ class FixedWindowElasticExpiryRateLimiter(FixedWindowRateLimiter):
 
 
 KnownStrategy = Union[
-    Type[FixedWindowRateLimiter],
-    Type[FixedWindowElasticExpiryRateLimiter],
-    Type[MovingWindowRateLimiter],
+    type[SlidingWindowCounterRateLimiter],
+    type[FixedWindowRateLimiter],
+    type[FixedWindowElasticExpiryRateLimiter],
+    type[MovingWindowRateLimiter],
 ]
 
-STRATEGIES: Dict[str, KnownStrategy] = {
+STRATEGIES: dict[str, KnownStrategy] = {
+    "sliding-window-counter": SlidingWindowCounterRateLimiter,
     "fixed-window": FixedWindowRateLimiter,
     "fixed-window-elastic-expiry": FixedWindowElasticExpiryRateLimiter,
     "moving-window": MovingWindowRateLimiter,

limits/typing.py

@@ -1,19 +1,19 @@
+from collections import Counter
+from collections.abc import Awaitable, Iterable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
     Callable,
-    Dict,
-    List,
+    ClassVar,
     NamedTuple,
     Optional,
-    Tuple,
     Type,
     TypeVar,
     Union,
+    cast,
 )
 
-from typing_extensions import ClassVar, Counter, ParamSpec, Protocol, TypeAlias
+from typing_extensions import ParamSpec, Protocol, TypeAlias
 
 Serializable = Union[int, str, float]
 
@@ -25,7 +25,8 @@ P = ParamSpec("P")
 if TYPE_CHECKING:
     import coredis
     import coredis.commands.script
-    import pymongo
+    import pymongo.collection
+    import pymongo.database
     import redis
 
 
@@ -48,12 +49,18 @@ class EmcacheClientP(Protocol):
 
     async def get(self, key: bytes, return_flags: bool = False) -> Optional[ItemP]: ...
 
+    async def get_many(self, keys: Iterable[bytes]) -> dict[bytes, ItemP]: ...
+
     async def gets(self, key: bytes, return_flags: bool = False) -> Optional[ItemP]: ...
 
     async def increment(
         self, key: bytes, value: int, *, noreply: bool = False
     ) -> Optional[int]: ...
 
+    async def decrement(
+        self, key: bytes, value: int, *, noreply: bool = False
+    ) -> Optional[int]: ...
+
     async def delete(self, key: bytes, *, noreply: bool = False) -> None: ...
 
     async def set(
@@ -83,7 +90,18 @@ class MemcachedClientP(Protocol):
 
     def get(self, key: str, default: Optional[str] = None) -> bytes: ...
 
-    def incr(self, key: str, value: int, noreply: Optional[bool] = False) -> int: ...
+    def get_many(self, keys: Iterable[str]) -> dict[str, Any]: ...  # type:ignore[explicit-any]
+
+    def incr(
+        self, key: str, value: int, noreply: Optional[bool] = False
+    ) -> Optional[int]: ...
+
+    def decr(
+        self,
+        key: str,
+        value: int,
+        noreply: Optional[bool] = False,
+    ) -> Optional[int]: ...
 
     def delete(self, key: str, noreply: Optional[bool] = None) -> Optional[bool]: ...
 
@@ -101,28 +119,37 @@ class MemcachedClientP(Protocol):
     ) -> bool: ...
 
 
+class RedisClientP(Protocol):
+    def incrby(self, key: str, amount: int) -> int: ...
+    def get(self, key: str) -> Optional[bytes]: ...
+    def delete(self, key: str) -> int: ...
+    def ttl(self, key: str) -> int: ...
+    def expire(self, key: str, seconds: int) -> bool: ...
+    def ping(self) -> bool: ...
+    def register_script(self, script: bytes) -> "redis.commands.core.Script": ...
+
+
 AsyncRedisClient = Union["coredis.Redis[bytes]", "coredis.RedisCluster[bytes]"]
-RedisClient = Union["redis.Redis[bytes]", "redis.cluster.RedisCluster[bytes]"]
+RedisClient = RedisClientP
 
 
 class ScriptP(Protocol[R_co]):
-    def __call__(self, keys: List[Serializable], args: List[Serializable]) -> R_co: ...
+    def __call__(self, keys: list[Serializable], args: list[Serializable]) -> R_co: ...
 
 
-MongoClient: TypeAlias = "pymongo.MongoClient[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
+MongoClient: TypeAlias = "pymongo.MongoClient[dict[str, Any]]"  # type:ignore[explicit-any]
+MongoDatabase: TypeAlias = "pymongo.database.Database[dict[str, Any]]"  # type:ignore[explicit-any]
+MongoCollection: TypeAlias = "pymongo.collection.Collection[dict[str, Any]]"  # type:ignore[explicit-any]
 
 __all__ = [
+    "Any",
     "AsyncRedisClient",
     "Awaitable",
     "Callable",
     "ClassVar",
     "Counter",
-    "Dict",
     "EmcacheClientP",
     "ItemP",
-    "List",
     "MemcachedClientP",
     "MongoClient",
     "MongoCollection",
@@ -138,8 +165,9 @@ __all__ = [
     "R",
     "R_co",
     "RedisClient",
-    "Tuple",
     "Type",
     "TypeVar",
+    "TYPE_CHECKING",
     "Union",
+    "cast",
 ]

limits/util.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 
 from packaging.version import Version
 
-from limits.typing import Dict, List, NamedTuple, Optional, Tuple, Type, Union
+from limits.typing import NamedTuple, Optional, Type, Union
 
 from .errors import ConfigurationError
 from .limits import GRANULARITIES, RateLimitItem
@@ -34,7 +34,7 @@ EXPR = re.compile(
 
 class WindowStats(NamedTuple):
     """
-    Tuple to describe a rate limited window
+    tuple to describe a rate limited window
     """
 
     #: Time as seconds since the Epoch when this window will be reset
@@ -51,6 +51,9 @@ class Dependency:
     module: ModuleType
 
 
+MissingModule = ModuleType("Missing")
+
+
 if TYPE_CHECKING:
     _UserDict = UserDict[str, Dependency]
 else:
@@ -58,20 +61,29 @@ else:
 
 
 class DependencyDict(_UserDict):
-    Missing = Dependency("Missing", None, None, ModuleType("Missing"))
-
     def __getitem__(self, key: str) -> Dependency:
         dependency = super().__getitem__(key)
 
-        if dependency == DependencyDict.Missing:
-            raise ConfigurationError(f"{key} prerequisite not available")
+        if dependency.module is MissingModule:
+            message = f"'{dependency.name}' prerequisite not available."
+            if dependency.version_required:
+                message += (
+                    f" A minimum version of {dependency.version_required} is required."
+                    if dependency.version_required
+                    else ""
+                )
+            message += (
+                " See https://limits.readthedocs.io/en/stable/storage.html#supported-versions"
+                " for more details."
+            )
+            raise ConfigurationError(message)
         elif dependency.version_required and (
             not dependency.version_found
             or dependency.version_found < dependency.version_required
         ):
             raise ConfigurationError(
                 f"The minimum version of {dependency.version_required}"
-                f" of {dependency.name} could not be found"
+                f" for '{dependency.name}' could not be found. Found version: {dependency.version_found}"
             )
 
         return dependency
@@ -84,7 +96,7 @@ class LazyDependency:
     without having to import them explicitly.
     """
 
-    DEPENDENCIES: Union[Dict[str, Optional[Version]], List[str]] = []
+    DEPENDENCIES: Union[dict[str, Optional[Version]], list[str]] = []
     """
     The python modules this class has a dependency on.
     Used to lazily populate the :attr:`dependencies`
@@ -105,7 +117,7 @@ class LazyDependency:
 
         if not getattr(self, "_dependencies", None):
             dependencies = DependencyDict()
-            mapping: Dict[str, Optional[Version]]
+            mapping: dict[str, Optional[Version]]
 
             if isinstance(self.DEPENDENCIES, list):
                 mapping = {dependency: None for dependency in self.DEPENDENCIES}
@@ -115,18 +127,15 @@ class LazyDependency:
             for name, minimum_version in mapping.items():
                 dependency, version = get_dependency(name)
 
-                if not dependency:
-                    dependencies[name] = DependencyDict.Missing
-                else:
-                    dependencies[name] = Dependency(
-                        name, minimum_version, version, dependency
-                    )
+                dependencies[name] = Dependency(
+                    name, minimum_version, version, dependency
+                )
             self._dependencies = dependencies
 
         return self._dependencies
 
 
-def get_dependency(module_path: str) -> Tuple[Optional[ModuleType], Optional[Version]]:
+def get_dependency(module_path: str) -> tuple[ModuleType, Optional[Version]]:
     """
     safe function to import a module at runtime
     """
@@ -138,14 +147,14 @@ def get_dependency(module_path: str) -> Tuple[Optional[ModuleType], Optional[Ver
 
         return sys.modules[module_path], Version(version)
     except ImportError:  # pragma: no cover
-        return None, None
+        return MissingModule, None
 
 
 def get_package_data(path: str) -> bytes:
     return importlib.resources.files("limits").joinpath(path).read_bytes()
 
 
-def parse_many(limit_string: str) -> List[RateLimitItem]:
+def parse_many(limit_string: str) -> list[RateLimitItem]:
     """
     parses rate limits in string notation containing multiple rate limits
     (e.g. ``1/second; 5/minute``)