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

limits/storage/memcached.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import inspect
 import threading
 import time
@@ -16,11 +18,8 @@ from limits.typing import (
     Any,
     Callable,
     MemcachedClientP,
-    Optional,
     P,
     R,
-    Type,
-    Union,
     cast,
 )
 from limits.util import get_dependency
@@ -41,7 +40,7 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         self,
         uri: str,
         wrap_exceptions: bool = False,
-        **options: Union[str, Callable[[], MemcachedClientP]],
+        **options: str | Callable[[], MemcachedClientP],
     ) -> None:
         """
         :param uri: memcached location of the form
@@ -82,7 +81,7 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
 
         if not get_dependency(self.library):
             raise ConfigurationError(
-                "memcached prerequisite not available. please install %s" % self.library
+                f"memcached prerequisite not available. please install {self.library}"
             )  # pragma: no cover
         self.local_storage = threading.local()
         self.local_storage.storage = None
@@ -91,7 +90,7 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
     @property
     def base_exceptions(
         self,
-    ) -> Union[Type[Exception], tuple[Type[Exception], ...]]:  # pragma: no cover
+    ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
         return self.dependency.MemcacheError  # type: ignore[no-any-return]
 
     def get_client(
@@ -253,7 +252,7 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         except:  # noqa
             return False
 
-    def reset(self) -> Optional[int]:
+    def reset(self) -> int | None:
         raise NotImplementedError
 
     def acquire_sliding_window_entry(

limits/storage/memory.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import threading
 import time
 from collections import Counter, defaultdict
@@ -10,14 +12,12 @@ from limits.storage.base import (
     Storage,
     TimestampedSlidingWindow,
 )
-from limits.typing import Optional, Type, Union
 
 
-class LockableEntry(threading._RLock):  # type: ignore
+class Entry:
     def __init__(self, expiry: float) -> None:
         self.atime = time.time()
         self.expiry = self.atime + expiry
-        super().__init__()
 
 
 class MemoryStorage(
@@ -32,30 +32,35 @@ class MemoryStorage(
 
     STORAGE_SCHEME = ["memory"]
 
-    def __init__(
-        self, uri: Optional[str] = None, wrap_exceptions: bool = False, **_: str
-    ):
+    def __init__(self, uri: str | None = None, wrap_exceptions: bool = False, **_: str):
         self.storage: limits.typing.Counter[str] = Counter()
         self.locks: defaultdict[str, threading.RLock] = defaultdict(threading.RLock)
         self.expirations: dict[str, float] = {}
-        self.events: dict[str, list[LockableEntry]] = {}
-        self.timer = threading.Timer(0.01, self.__expire_events)
+        self.events: dict[str, list[Entry]] = {}
+        self.timer: threading.Timer = threading.Timer(0.01, self.__expire_events)
         self.timer.start()
         super().__init__(uri, wrap_exceptions=wrap_exceptions, **_)
 
-    @property
-    def base_exceptions(
-        self,
-    ) -> Union[Type[Exception], tuple[Type[Exception], ...]]:  # pragma: no cover
-        return ValueError
+    def __getstate__(self) -> dict[str, limits.typing.Any]:  # type: ignore[explicit-any]
+        state = self.__dict__.copy()
+        del state["timer"]
+        del state["locks"]
+        return state
+
+    def __setstate__(self, state: dict[str, limits.typing.Any]) -> None:  # type: ignore[explicit-any]
+        self.__dict__.update(state)
+        self.locks = defaultdict(threading.RLock)
+        self.timer = threading.Timer(0.01, self.__expire_events)
+        self.timer.start()
 
     def __expire_events(self) -> None:
         for key in list(self.events.keys()):
-            for event in list(self.events[key]):
-                with event:
+            with self.locks[key]:
+                for event in list(self.events[key]):
                     if event.expiry <= time.time() and event in self.events[key]:
                         self.events[key].remove(event)
-
+                if not self.events.get(key, None):
+                    self.locks.pop(key, None)
         for key in list(self.expirations.keys()):
             if self.expirations[key] <= time.time():
                 self.storage.pop(key, None)
@@ -67,6 +72,12 @@ class MemoryStorage(
             self.timer = threading.Timer(0.01, self.__expire_events)
             self.timer.start()
 
+    @property
+    def base_exceptions(
+        self,
+    ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
+        return ValueError
+
     def incr(
         self, key: str, expiry: float, elastic_expiry: bool = False, amount: int = 1
     ) -> int:
@@ -134,19 +145,20 @@ class MemoryStorage(
         if amount > limit:
             return False
 
-        self.events.setdefault(key, [])
         self.__schedule_expiry()
-        timestamp = time.time()
-        try:
-            entry = self.events[key][limit - amount]
-        except IndexError:
-            entry = None
-
-        if entry and entry.atime >= timestamp - expiry:
-            return False
-        else:
-            self.events[key][:0] = [LockableEntry(expiry) for _ in range(amount)]
-            return True
+        with self.locks[key]:
+            self.events.setdefault(key, [])
+            timestamp = time.time()
+            try:
+                entry = self.events[key][limit - amount]
+            except IndexError:
+                entry = None
+
+            if entry and entry.atime >= timestamp - expiry:
+                return False
+            else:
+                self.events[key][:0] = [Entry(expiry) for _ in range(amount)]
+                return True
 
     def get_expiry(self, key: str) -> float:
         """
@@ -165,7 +177,7 @@ class MemoryStorage(
         timestamp = time.time()
 
         return (
-            len([k for k in self.events[key] if k.atime >= timestamp - expiry])
+            len([k for k in self.events.get(key, []) if k.atime >= timestamp - expiry])
             if self.events.get(key)
             else 0
         )
@@ -218,7 +230,6 @@ class MemoryStorage(
                 # Limitation: during high concurrency at the end of the window,
                 # the counter is shifted and cannot be decremented, so less requests than expected are allowed.
                 self.decr(current_key, amount)
-                # print("Concurrent call, reverting the counter increase")
                 return False
             return True
 
@@ -252,7 +263,7 @@ class MemoryStorage(
 
         return True
 
-    def reset(self) -> Optional[int]:
+    def reset(self) -> int | None:
         num_items = max(len(self.storage), len(self.events))
         self.storage.clear()
         self.expirations.clear()

limits/storage/mongodb.py

@@ -10,9 +10,6 @@ from limits.typing import (
     MongoClient,
     MongoCollection,
     MongoDatabase,
-    Optional,
-    Type,
-    Union,
     cast,
 )
 
@@ -38,7 +35,7 @@ class MongoDBStorageBase(
         counter_collection_name: str = "counters",
         window_collection_name: str = "windows",
         wrap_exceptions: bool = False,
-        **options: Union[int, str, bool],
+        **options: int | str | bool,
     ) -> None:
         """
         :param uri: uri of the form ``mongodb://[user:password]@host:port?...``,
@@ -66,7 +63,7 @@ class MongoDBStorageBase(
         self.lib_errors, _ = get_dependency("pymongo.errors")
         self._storage_uri = uri
         self._storage_options = options
-        self._storage: Optional[MongoClient] = None
+        self._storage: MongoClient | None = None
 
     @property
     def storage(self) -> MongoClient:
@@ -91,21 +88,21 @@ class MongoDBStorageBase(
 
     @abstractmethod
     def _init_mongo_client(
-        self, uri: Optional[str], **options: Union[int, str, bool]
+        self, uri: str | None, **options: int | str | bool
     ) -> MongoClient:
         raise NotImplementedError()
 
     @property
     def base_exceptions(
         self,
-    ) -> Union[Type[Exception], tuple[Type[Exception], ...]]:  # pragma: no cover
+    ) -> 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)
 
-    def reset(self) -> Optional[int]:
+    def reset(self) -> int | None:
         """
         Delete all rate limit keys in the rate limit collections (counters, windows)
         """
@@ -259,7 +256,7 @@ class MongoDBStorageBase(
         try:
             updates: dict[
                 str,
-                dict[str, Union[datetime.datetime, dict[str, Union[list[float], int]]]],
+                dict[str, datetime.datetime | dict[str, list[float] | int]],
             ] = {
                 "$push": {
                     "entries": {
@@ -492,6 +489,6 @@ class MongoDBStorage(MongoDBStorageBase):
     STORAGE_SCHEME = ["mongodb", "mongodb+srv"]
 
     def _init_mongo_client(
-        self, uri: Optional[str], **options: Union[int, str, bool]
+        self, uri: str | None, **options: int | str | bool
     ) -> MongoClient:
         return cast(MongoClient, self.lib.MongoClient(uri, **options))

limits/storage/redis.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import time
 from typing import TYPE_CHECKING, cast
 
+from deprecated.sphinx import versionchanged
 from packaging.version import Version
 
-from limits.typing import Optional, RedisClient, Type, Union
+from limits.typing import Literal, RedisClient
 
 from ..util import get_package_data
 from .base import MovingWindowSupport, SlidingWindowCounterSupport, Storage
@@ -14,17 +15,32 @@ if TYPE_CHECKING:
     import redis
 
 
+@versionchanged(
+    version="4.3",
+    reason=(
+        "Added support for using the redis client from :pypi:`valkey`"
+        " if :paramref:`uri` has the ``valkey://`` schema"
+    ),
+)
 class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
     """
     Rate limit storage with redis as backend.
 
-    Depends on :pypi:`redis`.
+    Depends on :pypi:`redis` (or :pypi:`valkey` if :paramref:`uri` starts with
+    ``valkey://``)
     """
 
-    STORAGE_SCHEME = ["redis", "rediss", "redis+unix"]
+    STORAGE_SCHEME = [
+        "redis",
+        "rediss",
+        "redis+unix",
+        "valkey",
+        "valkeys",
+        "valkey+unix",
+    ]
     """The storage scheme for redis"""
 
-    DEPENDENCIES = {"redis": Version("3.0")}
+    DEPENDENCIES = {"redis": Version("3.0"), "valkey": Version("6.0")}
 
     RES_DIR = "resources/redis/lua_scripts"
 
@@ -40,19 +56,20 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         f"{RES_DIR}/acquire_sliding_window.lua"
     )
 
-    lua_moving_window: "redis.commands.core.Script"
-    lua_acquire_moving_window: "redis.commands.core.Script"
-    lua_sliding_window: "redis.commands.core.Script"
-    lua_acquire_sliding_window: "redis.commands.core.Script"
+    lua_moving_window: redis.commands.core.Script
+    lua_acquire_moving_window: redis.commands.core.Script
+    lua_sliding_window: redis.commands.core.Script
+    lua_acquire_sliding_window: redis.commands.core.Script
 
     PREFIX = "LIMITS"
+    target_server: Literal["redis", "valkey"]
 
     def __init__(
         self,
         uri: str,
-        connection_pool: Optional[redis.connection.ConnectionPool] = None,
+        connection_pool: redis.connection.ConnectionPool | None = None,
         wrap_exceptions: bool = False,
-        **options: Union[float, str, bool],
+        **options: float | str | bool,
     ) -> None:
         """
         :param uri: uri of the form ``redis://[:password]@host:port``,
@@ -60,6 +77,9 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
          ``rediss://[:password]@host:port``, ``redis+unix:///path/to/sock`` etc.
          This uri is passed directly to :func:`redis.from_url` except for the
          case of ``redis+unix://`` where it is replaced with ``unix://``.
+
+         If the uri scheme is ``valkey`` the implementation used will be from
+         :pypi:`valkey`.
         :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
@@ -69,23 +89,33 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         :raise ConfigurationError: when the :pypi:`redis` library is not available
         """
         super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
-        self.dependency = self.dependencies["redis"].module
+        self.target_server = "valkey" if uri.startswith("valkey") else "redis"
+        self.dependency = self.dependencies[self.target_server].module
 
-        uri = uri.replace("redis+unix", "unix")
+        uri = uri.replace(f"{self.target_server}+unix", "unix")
 
         if not connection_pool:
             self.storage = self.dependency.from_url(uri, **options)
         else:
-            self.storage = self.dependency.Redis(
-                connection_pool=connection_pool, **options
-            )
+            if self.target_server == "redis":
+                self.storage = self.dependency.Redis(
+                    connection_pool=connection_pool, **options
+                )
+            else:
+                self.storage = self.dependency.Valkey(
+                    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]
+    ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
+        return (  # type: ignore[no-any-return]
+            self.dependency.RedisError
+            if self.target_server == "redis"
+            else self.dependency.ValkeyError
+        )
 
     def initialize_storage(self, _uri: str) -> None:
         self.lua_moving_window = self.get_connection().register_script(
@@ -268,7 +298,7 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         except:  # noqa
             return False
 
-    def reset(self) -> Optional[int]:
+    def reset(self) -> int | None:
         """
         This function calls a Lua Script to delete keys prefixed with
         ``self.PREFIX`` in blocks of 5000.

limits/storage/redis_cluster.py

@@ -1,10 +1,11 @@
+from __future__ import annotations
+
 import urllib
 
 from deprecated.sphinx import versionchanged
 from packaging.version import Version
 
 from limits.storage.redis import RedisStorage
-from limits.typing import Optional, Union
 
 
 @versionchanged(
@@ -24,34 +25,46 @@ however if the version of the package is lower than ``4.2.0`` the implementation
 will fallback to trying to use :class:`rediscluster.RedisCluster`.
 """,
 )
+@versionchanged(
+    version="4.3",
+    reason=(
+        "Added support for using the redis client from :pypi:`valkey`"
+        " if :paramref:`uri` has the ``valkey+cluster://`` schema"
+    ),
+)
 class RedisClusterStorage(RedisStorage):
     """
     Rate limit storage with redis cluster as backend
 
-    Depends on :pypi:`redis`.
+    Depends on :pypi:`redis` (or :pypi:`valkey` if :paramref:`uri`
+    starts with ``valkey+cluster://``).
     """
 
-    STORAGE_SCHEME = ["redis+cluster"]
+    STORAGE_SCHEME = ["redis+cluster", "valkey+cluster"]
     """The storage scheme for redis cluster"""
 
-    DEFAULT_OPTIONS: dict[str, Union[float, str, bool]] = {
+    DEFAULT_OPTIONS: dict[str, float | str | bool] = {
         "max_connections": 1000,
     }
     "Default options passed to the :class:`~redis.cluster.RedisCluster`"
 
     DEPENDENCIES = {
         "redis": Version("4.2.0"),
+        "valkey": Version("6.0"),
     }
 
     def __init__(
         self,
         uri: str,
         wrap_exceptions: bool = False,
-        **options: Union[float, str, bool],
+        **options: float | str | bool,
     ) -> None:
         """
         :param uri: url of the form
          ``redis+cluster://[:password]@host:port,host:port``
+
+         If the uri scheme is ``valkey+cluster`` the implementation used will be from
+         :pypi:`valkey`.
         :param wrap_exceptions: Whether to wrap storage exceptions in
          :exc:`limits.errors.StorageError` before raising it.
         :param options: all remaining keyword arguments are passed
@@ -60,7 +73,7 @@ class RedisClusterStorage(RedisStorage):
          available or if the redis cluster cannot be reached.
         """
         parsed = urllib.parse.urlparse(uri)
-        parsed_auth: dict[str, Union[float, str, bool]] = {}
+        parsed_auth: dict[str, float | str | bool] = {}
 
         if parsed.username:
             parsed_auth["username"] = parsed.username
@@ -74,17 +87,24 @@ class RedisClusterStorage(RedisStorage):
             cluster_hosts.append((host, int(port)))
 
         self.storage = None
+        self.target_server = "valkey" if uri.startswith("valkey") else "redis"
         merged_options = {**self.DEFAULT_OPTIONS, **parsed_auth, **options}
-        self.dependency = self.dependencies["redis"].module
+        self.dependency = self.dependencies[self.target_server].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
-        )
+        if self.target_server == "redis":
+            self.storage = self.dependency.cluster.RedisCluster(
+                startup_nodes=startup_nodes, **merged_options
+            )
+        else:
+            self.storage = self.dependency.cluster.ValkeyCluster(
+                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]:
+    def reset(self) -> int | None:
         """
         Redis Clusters are sharded and deleting across shards
         can't be done atomically. Because of this, this reset loops over all

limits/storage/redis_sentinel.py

@@ -1,40 +1,59 @@
+from __future__ import annotations
+
 import urllib.parse
 from typing import TYPE_CHECKING
 
+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 Optional, RedisClient, Type, Union
+from limits.typing import RedisClient
 
 if TYPE_CHECKING:
     pass
 
 
+@versionchanged(
+    version="4.3",
+    reason=(
+        "Added support for using the redis client from :pypi:`valkey`"
+        " if :paramref:`uri` has the ``valkey+sentinel://`` schema"
+    ),
+)
 class RedisSentinelStorage(RedisStorage):
     """
     Rate limit storage with redis sentinel as backend
 
-    Depends on :pypi:`redis` package
+    Depends on :pypi:`redis` package (or :pypi:`valkey` if :paramref:`uri` starts with
+    ``valkey+sentinel://``)
     """
 
-    STORAGE_SCHEME = ["redis+sentinel"]
+    STORAGE_SCHEME = ["redis+sentinel", "valkey+sentinel"]
     """The storage scheme for redis accessed via a redis sentinel installation"""
 
-    DEPENDENCIES = {"redis": Version("3.0"), "redis.sentinel": Version("3.0")}
+    DEPENDENCIES = {
+        "redis": Version("3.0"),
+        "redis.sentinel": Version("3.0"),
+        "valkey": Version("6.0"),
+        "valkey.sentinel": Version("6.0"),
+    }
 
     def __init__(
         self,
         uri: str,
-        service_name: Optional[str] = None,
+        service_name: str | None = None,
         use_replicas: bool = True,
-        sentinel_kwargs: Optional[dict[str, Union[float, str, bool]]] = None,
+        sentinel_kwargs: dict[str, float | str | bool] | None = None,
         wrap_exceptions: bool = False,
-        **options: Union[float, str, bool],
+        **options: float | str | bool,
     ) -> None:
         """
         :param uri: url of the form
          ``redis+sentinel://host:port,host:port/service_name``
+
+         If the uri scheme is ``valkey+sentinel`` the implementation used will be from
+         :pypi:`valkey`.
         :param service_name: sentinel service name
          (if not provided in :attr:`uri`)
         :param use_replicas: Whether to use replicas for read only operations
@@ -56,7 +75,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, float | str | bool] = {}
 
         if parsed.username:
             parsed_auth["username"] = parsed.username
@@ -75,7 +94,8 @@ class RedisSentinelStorage(RedisStorage):
         if self.service_name is None:
             raise ConfigurationError("'service_name' not provided")
 
-        sentinel_dep = self.dependencies["redis.sentinel"].module
+        self.target_server = "valkey" if uri.startswith("valkey") else "redis"
+        sentinel_dep = self.dependencies[f"{self.target_server}.sentinel"].module
         self.sentinel = sentinel_dep.Sentinel(
             sentinel_configuration,
             sentinel_kwargs={**parsed_auth, **sentinel_options},
@@ -89,8 +109,12 @@ class RedisSentinelStorage(RedisStorage):
     @property
     def base_exceptions(
         self,
-    ) -> Union[Type[Exception], tuple[Type[Exception], ...]]:  # pragma: no cover
-        return self.dependencies["redis"].module.RedisError  # type: ignore[no-any-return]
+    ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
+        return (  # type: ignore[no-any-return]
+            self.dependencies["redis"].module.RedisError
+            if self.target_server == "redis"
+            else self.dependencies["valkey"].module.ValkeyError
+        )
 
     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,12 @@ from __future__ import annotations
 
 from abc import ABCMeta
 
-from limits.typing import Union
-
 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, str | list[str]]
     ) -> StorageRegistry:
         storage_scheme = dct.get("STORAGE_SCHEME", None)
         cls = super().__new__(mcs, name, bases, dct)

limits/strategies.py

@@ -2,6 +2,8 @@
 Rate limiting strategies
 """
 
+from __future__ import annotations
+
 import time
 from abc import ABCMeta, abstractmethod
 from math import floor, inf
@@ -12,7 +14,7 @@ from limits.storage.base import SlidingWindowCounterSupport
 
 from .limits import RateLimitItem
 from .storage import MovingWindowSupport, Storage, StorageTypes
-from .typing import Union, cast
+from .typing import cast
 from .util import WindowStats
 
 
@@ -72,7 +74,7 @@ class MovingWindowRateLimiter(RateLimiter):
         ):
             raise NotImplementedError(
                 "MovingWindowRateLimiting is not implemented for storage "
-                "of type %s" % storage.__class__
+                f"of type {storage.__class__}"
             )
         super().__init__(storage)
 
@@ -191,7 +193,7 @@ class SlidingWindowCounterRateLimiter(RateLimiter):
         ):
             raise NotImplementedError(
                 "SlidingWindowCounterRateLimiting is not implemented for storage "
-                "of type %s" % storage.__class__
+                f"of type {storage.__class__}"
             )
         super().__init__(storage)
 
@@ -311,12 +313,12 @@ class FixedWindowElasticExpiryRateLimiter(FixedWindowRateLimiter):
         )
 
 
-KnownStrategy = Union[
-    type[SlidingWindowCounterRateLimiter],
-    type[FixedWindowRateLimiter],
-    type[FixedWindowElasticExpiryRateLimiter],
-    type[MovingWindowRateLimiter],
-]
+KnownStrategy = (
+    type[SlidingWindowCounterRateLimiter]
+    | type[FixedWindowRateLimiter]
+    | type[FixedWindowElasticExpiryRateLimiter]
+    | type[MovingWindowRateLimiter]
+)
 
 STRATEGIES: dict[str, KnownStrategy] = {
     "sliding-window-counter": SlidingWindowCounterRateLimiter,