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

limits/aio/storage/redis.py

@@ -1,470 +0,0 @@
-import time
-import urllib
-from typing import TYPE_CHECKING, cast
-
-from deprecated.sphinx import versionadded
-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, Type, Union
-from limits.util import get_package_data
-
-if TYPE_CHECKING:
-    import coredis
-    import coredis.commands
-
-
-class RedisInteractor:
-    RES_DIR = "resources/redis/lua_scripts"
-
-    SCRIPT_MOVING_WINDOW = get_package_data(f"{RES_DIR}/moving_window.lua")
-    SCRIPT_ACQUIRE_MOVING_WINDOW = get_package_data(
-        f"{RES_DIR}/acquire_moving_window.lua"
-    )
-    SCRIPT_CLEAR_KEYS = get_package_data(f"{RES_DIR}/clear_keys.lua")
-    SCRIPT_INCR_EXPIRE = get_package_data(f"{RES_DIR}/incr_expire.lua")
-
-    lua_moving_window: "coredis.commands.Script[bytes]"
-    lua_acquire_window: "coredis.commands.Script[bytes]"
-    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,
-        expiry: int,
-        connection: AsyncRedisClient,
-        elastic_expiry: bool = False,
-        amount: int = 1,
-    ) -> int:
-        """
-        increments the counter for a given rate limit key
-
-        :param connection: Redis connection
-        :param key: the key to increment
-        :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:
-            await connection.expire(key, expiry)
-
-        return value
-
-    async def _get(self, key: str, connection: AsyncRedisClient) -> int:
-        """
-        :param connection: Redis connection
-        :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:
-        """
-        :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(
-        self, key: str, limit: int, expiry: int
-    ) -> Tuple[float, int]:
-        """
-        returns the starting point and the number of entries in the moving
-        window
-
-        :param key: rate limit key
-        :param expiry: expiry of entry
-        :return: (start of window, number of acquired entries)
-        """
-        key = self.prefixed_key(key)
-        timestamp = time.time()
-        window = await self.lua_moving_window.execute(
-            [key], [timestamp - expiry, limit]
-        )
-        if window:
-            return float(window[0]), window[1]  # type: ignore
-        return timestamp, 0
-
-    async def _acquire_entry(
-        self,
-        key: str,
-        limit: int,
-        expiry: int,
-        connection: AsyncRedisClient,
-        amount: int = 1,
-    ) -> bool:
-        """
-        :param key: rate limit key to acquire an entry in
-        :param limit: amount of entries allowed
-        :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]
-        )
-
-        return bool(acquired)
-
-    async def _get_expiry(self, key: str, connection: AsyncRedisClient) -> float:
-        """
-        :param key: the key to get the expiry for
-        :param connection: Redis connection
-        """
-
-        key = self.prefixed_key(key)
-        return max(await connection.ttl(key), 0) + time.time()
-
-    async def _check(self, connection: AsyncRedisClient) -> bool:
-        """
-        check if storage is healthy
-
-        :param connection: Redis connection
-        """
-        try:
-            await connection.ping()
-
-            return True
-        except:  # noqa
-            return False
-
-
-@versionadded(version="2.1")
-class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
-    """
-    Rate limit storage with redis as backend.
-
-    Depends on :pypi:`coredis`
-    """
-
-    STORAGE_SCHEME = ["async+redis", "async+rediss", "async+redis+unix"]
-    """
-    The storage schemes for redis to be used in an async context
-    """
-    DEPENDENCIES = {"coredis": Version("3.4.0")}
-
-    def __init__(
-        self,
-        uri: str,
-        connection_pool: Optional["coredis.ConnectionPool"] = None,
-        wrap_exceptions: bool = False,
-        **options: Union[float, str, bool],
-    ) -> None:
-        """
-        :param uri: uri of the form:
-
-         - ``async+redis://[:password]@host:port``
-         - ``async+redis://[:password]@host:port/db``
-         - ``async+rediss://[:password]@host:port``
-         - ``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
-        """
-        uri = uri.replace("async+redis", "redis", 1)
-        uri = uri.replace("redis+unix", "unix")
-
-        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
-
-        self.dependency = self.dependencies["coredis"].module
-
-        if connection_pool:
-            self.storage = self.dependency.Redis(
-                connection_pool=connection_pool, **options
-            )
-        else:
-            self.storage = self.dependency.Redis.from_url(uri, **options)
-
-        self.initialize_storage(uri)
-
-    @property
-    def base_exceptions(
-        self,
-    ) -> Union[Type[Exception], Tuple[Type[Exception], ...]]:  # pragma: no cover
-        return self.dependency.exceptions.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)
-        self.lua_acquire_window = self.storage.register_script(
-            self.SCRIPT_ACQUIRE_MOVING_WINDOW
-        )
-        self.lua_clear_keys = self.storage.register_script(self.SCRIPT_CLEAR_KEYS)
-        self.lua_incr_expire = self.storage.register_script(
-            RedisStorage.SCRIPT_INCR_EXPIRE
-        )
-
-    async def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
-        """
-        increments the counter for a given rate limit key
-
-        :param key: the key to increment
-        :param expiry: amount in seconds for the key to expire in
-        :param amount: the number to increment by
-        """
-
-        if elastic_expiry:
-            return await super()._incr(
-                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])
-            )
-
-    async def get(self, key: str) -> int:
-        """
-        :param key: the key to get the counter value for
-        """
-
-        return await super()._get(key, self.storage)
-
-    async def clear(self, key: str) -> None:
-        """
-        :param key: the key to clear rate limits for
-        """
-
-        return await super()._clear(key, self.storage)
-
-    async def acquire_entry(
-        self, key: str, limit: int, expiry: int, amount: int = 1
-    ) -> bool:
-        """
-        :param key: rate limit key to acquire an entry in
-        :param limit: amount of entries allowed
-        :param expiry: expiry of the entry
-        :param amount: the number of entries to acquire
-        """
-
-        return await super()._acquire_entry(key, limit, expiry, self.storage, amount)
-
-    async def get_expiry(self, key: str) -> float:
-        """
-        :param key: the key to get the expiry for
-        """
-
-        return await super()._get_expiry(key, self.storage)
-
-    async def check(self) -> bool:
-        """
-        Check if storage is healthy by calling :meth:`coredis.Redis.ping`
-        """
-
-        return await super()._check(self.storage)
-
-    async def reset(self) -> Optional[int]:
-        """
-        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.
-        """
-
-        prefix = self.prefixed_key("*")
-        return cast(int, await self.lua_clear_keys.execute([prefix]))
-
-
-@versionadded(version="2.1")
-class RedisClusterStorage(RedisStorage):
-    """
-    Rate limit storage with redis cluster as backend
-
-    Depends on :pypi:`coredis`
-    """
-
-    STORAGE_SCHEME = ["async+redis+cluster"]
-    """
-    The storage schemes for redis cluster to be used in an async context
-    """
-
-    DEFAULT_OPTIONS: Dict[str, Union[float, str, bool]] = {
-        "max_connections": 1000,
-    }
-    "Default options passed to :class:`coredis.RedisCluster`"
-
-    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``
-        :param options: all remaining keyword arguments are passed
-         directly to the constructor of :class:`coredis.RedisCluster`
-        :raise ConfigurationError: when the coredis library is not
-         available or if the redis host cannot be pinged.
-        """
-        parsed = urllib.parse.urlparse(uri)
-        parsed_auth: Dict[str, Union[float, str, bool]] = {}
-
-        if parsed.username:
-            parsed_auth["username"] = parsed.username
-        if parsed.password:
-            parsed_auth["password"] = parsed.password
-
-        sep = parsed.netloc.find("@") + 1
-        cluster_hosts = []
-
-        for loc in parsed.netloc[sep:].split(","):
-            host, port = loc.split(":")
-            cluster_hosts.append({"host": host, "port": int(port)})
-
-        super(RedisStorage, self).__init__(
-            uri, wrap_exceptions=wrap_exceptions, **options
-        )
-
-        self.dependency = self.dependencies["coredis"].module
-
-        self.storage: "coredis.RedisCluster[str]" = self.dependency.RedisCluster(
-            startup_nodes=cluster_hosts,
-            **{**self.DEFAULT_OPTIONS, **parsed_auth, **options},
-        )
-        self.initialize_storage(uri)
-
-    async def reset(self) -> Optional[int]:
-        """
-        Redis Clusters are sharded and deleting across shards
-        can't be done atomically. Because of this, this reset loops over all
-        keys that are prefixed with ``self.PREFIX`` and calls delete on them,
-        one at a time.
-
-        .. warning:: This operation was not tested with extremely large data sets.
-           On a large production based system, care should be taken with its
-           usage as it could be slow on very large data sets
-        """
-
-        prefix = self.prefixed_key("*")
-        keys = await self.storage.keys(prefix)
-        count = 0
-        for key in keys:
-            count += await self.storage.delete([key])
-        return count
-
-
-@versionadded(version="2.1")
-class RedisSentinelStorage(RedisStorage):
-    """
-    Rate limit storage with redis sentinel as backend
-
-    Depends on :pypi:`coredis`
-    """
-
-    STORAGE_SCHEME = ["async+redis+sentinel"]
-    """The storage scheme for redis accessed via a redis sentinel installation"""
-
-    DEPENDENCIES = {"coredis.sentinel": Version("3.4.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,
-        **options: Union[float, str, bool],
-    ):
-        """
-        :param uri: url of the form
-         ``async+redis+sentinel://host:port,host:port/service_name``
-        :param service_name, optional: sentinel service name
-         (if not provided in `uri`)
-        :param use_replicas: Whether to use replicas for read only operations
-        :param sentinel_kwargs, optional: kwargs to pass as
-         ``sentinel_kwargs`` to :class:`coredis.sentinel.Sentinel`
-        :param options: all remaining keyword arguments are passed
-         directly to the constructor of :class:`coredis.sentinel.Sentinel`
-        :raise ConfigurationError: when the coredis library is not available
-         or if the redis primary host cannot be pinged.
-        """
-
-        parsed = urllib.parse.urlparse(uri)
-        sentinel_configuration = []
-        connection_options = options.copy()
-        sentinel_options = sentinel_kwargs.copy() if sentinel_kwargs else {}
-        parsed_auth: Dict[str, Union[float, str, bool]] = {}
-
-        if parsed.username:
-            parsed_auth["username"] = parsed.username
-
-        if parsed.password:
-            parsed_auth["password"] = parsed.password
-
-        sep = parsed.netloc.find("@") + 1
-
-        for loc in parsed.netloc[sep:].split(","):
-            host, port = loc.split(":")
-            sentinel_configuration.append((host, int(port)))
-        self.service_name = (
-            parsed.path.replace("/", "") if parsed.path else service_name
-        )
-
-        if self.service_name is None:
-            raise ConfigurationError("'service_name' not provided")
-
-        super(RedisStorage, self).__init__()
-
-        self.dependency = self.dependencies["coredis.sentinel"].module
-
-        self.sentinel = self.dependency.Sentinel(
-            sentinel_configuration,
-            sentinel_kwargs={**parsed_auth, **sentinel_options},
-            **{**parsed_auth, **connection_options},
-        )
-        self.storage = self.sentinel.primary_for(self.service_name)
-        self.storage_replica = self.sentinel.replica_for(self.service_name)
-        self.use_replicas = use_replicas
-        self.initialize_storage(uri)
-
-    async def get(self, key: str) -> int:
-        """
-        :param key: the key to get the counter value for
-        """
-
-        return await super()._get(
-            key, self.storage_replica if self.use_replicas else self.storage
-        )
-
-    async def get_expiry(self, key: str) -> float:
-        """
-        :param key: the key to get the expiry for
-        """
-
-        return await super()._get_expiry(
-            key, self.storage_replica if self.use_replicas else self.storage
-        )
-
-    async def check(self) -> bool:
-        """
-        Check if storage is healthy by calling :meth:`coredis.Redis.ping`
-        on the replica.
-        """
-
-        return await super()._check(
-            self.storage_replica if self.use_replicas else self.storage
-        )

limits-4.0.1.dist-info/METADATA

@@ -1,192 +0,0 @@
-Metadata-Version: 2.1
-Name: limits
-Version: 4.0.1
-Summary: Rate limiting utilities
-Home-page: https://limits.readthedocs.org
-Author: Ali-Akber Saifee
-Author-email: ali@indydevs.org
-License: MIT
-Project-URL: Source, https://github.com/alisaifee/limits
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
-License-File: LICENSE.txt
-Requires-Dist: deprecated >=1.2
-Requires-Dist: packaging <25,>=21
-Requires-Dist: typing-extensions
-Provides-Extra: all
-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: motor <4,>=3 ; extra == 'all'
-Requires-Dist: aetcd ; extra == 'all'
-Requires-Dist: emcache >=0.6.1 ; (python_version < "3.11") and extra == 'all'
-Requires-Dist: emcache >=1 ; (python_version >= "3.11" and python_version < "3.13.0") and extra == 'all'
-Provides-Extra: async-etcd
-Requires-Dist: aetcd ; extra == 'async-etcd'
-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 python_version < "3.13.0") and extra == 'async-memcached'
-Provides-Extra: async-mongodb
-Requires-Dist: motor <4,>=3 ; extra == 'async-mongodb'
-Provides-Extra: async-redis
-Requires-Dist: coredis <5,>=3.4.0 ; extra == 'async-redis'
-Provides-Extra: etcd
-Requires-Dist: etcd3 ; extra == 'etcd'
-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: 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'
-
-.. |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
-.. |codecov| image:: https://codecov.io/gh/alisaifee/limits/branch/master/graph/badge.svg
-   :target: https://codecov.io/gh/alisaifee/limits
-.. |pypi| image:: https://img.shields.io/pypi/v/limits.svg?style=flat-square
-    :target: https://pypi.python.org/pypi/limits
-.. |pypi-versions| image:: https://img.shields.io/pypi/pyversions/limits?style=flat-square
-    :target: https://pypi.python.org/pypi/limits
-.. |license| image:: https://img.shields.io/pypi/l/limits.svg?style=flat-square
-    :target: https://pypi.python.org/pypi/limits
-.. |docs| image:: https://readthedocs.org/projects/limits/badge/?version=latest
-   :target: https://limits.readthedocs.org
-
-limits
-------
-|docs| |ci| |codecov| |pypi| |pypi-versions| |license|
-
-
-**limits** is a python library to perform rate limiting with commonly used storage backends (Redis, Memcached, MongoDB & Etcd).
-
-
-Supported Strategies
-====================
-`Fixed Window <https://limits.readthedocs.io/en/latest/strategies.html#fixed-window>`_
-   This strategy resets at a fixed interval (start of minute, hour, day etc).
-   For example, given a rate limit of ``10/minute`` the strategy will:
-
-   - Allow 10 requests between ``00:01:00`` and ``00:02:00``
-   - Allow 10 requests at ``00:00:59`` and 10 more requests at ``00:01:00``
-
-
-`Fixed Window (Elastic) <https://limits.readthedocs.io/en/latest/strategies.html#fixed-window-with-elastic-expiry>`_
-   Identical to Fixed window, except every breach of rate limit results in an extension
-   to the time out. For example a rate limit of `1/minute` hit twice within a minute will
-   result in a lock-out for two minutes.
-
-`Moving Window <https://limits.readthedocs.io/en/latest/strategies.html#moving-window>`_
-   Sliding window strategy enforces a rate limit of N/(m time units)
-   on the **last m** time units at the second granularity.
-
-   For example, with a rate limit of ``10/minute``:
-
-   - Allow 9 requests that arrive at ``00:00:59``
-   - Allow another request that arrives at ``00:01:00``
-   - Reject the request that arrives at ``00:01:01``
-
-Storage backends
-================
-
-- `Redis <https://limits.readthedocs.io/en/latest/storage.html#redis-storage>`_
-- `Memcached <https://limits.readthedocs.io/en/latest/storage.html#memcached-storage>`_
-- `MongoDB <https://limits.readthedocs.io/en/latest/storage.html#mongodb-storage>`_
-- `Etcd <https://limits.readthedocs.io/en/latest/storage.html#etcd-storage>`_
-- `In-Memory <https://limits.readthedocs.io/en/latest/storage.html#in-memory-storage>`_
-
-Dive right in
-=============
-
-Initialize the storage backend
-
-.. code-block:: python
-
-   from limits import storage
-   memory_storage = storage.MemoryStorage()
-   # or memcached
-   memcached_storage = storage.MemcachedStorage("memcached://localhost:11211")
-   # or redis
-   redis_storage = storage.RedisStorage("redis://localhost:6379")
-   # or use the factory
-   storage_uri = "memcached://localhost:11211"
-   some_storage = storage.storage_from_string(storage_uri)
-
-Initialize a rate limiter with the Moving Window Strategy
-
-.. code-block:: python
-
-   from limits import strategies
-   moving_window = strategies.MovingWindowRateLimiter(memory_storage)
-
-
-Initialize a rate limit
-
-.. code-block:: python
-
-    from limits import parse
-    one_per_minute = parse("1/minute")
-
-Initialize a rate limit explicitly
-
-.. code-block:: python
-
-    from limits import RateLimitItemPerSecond
-    one_per_second = RateLimitItemPerSecond(1, 1)
-
-Test the limits
-
-.. code-block:: python
-
-    assert True == moving_window.hit(one_per_minute, "test_namespace", "foo")
-    assert False == moving_window.hit(one_per_minute, "test_namespace", "foo")
-    assert True == moving_window.hit(one_per_minute, "test_namespace", "bar")
-
-    assert True == moving_window.hit(one_per_second, "test_namespace", "foo")
-    assert False == moving_window.hit(one_per_second, "test_namespace", "foo")
-    time.sleep(1)
-    assert True == moving_window.hit(one_per_second, "test_namespace", "foo")
-
-Check specific limits without hitting them
-
-.. code-block:: python
-
-    assert True == moving_window.hit(one_per_second, "test_namespace", "foo")
-    while not moving_window.test(one_per_second, "test_namespace", "foo"):
-        time.sleep(0.01)
-    assert True == moving_window.hit(one_per_second, "test_namespace", "foo")
-
-Query available capacity and reset time for a limit
-
-.. code-block:: python
-
-   assert True == moving_window.hit(one_per_minute, "test_namespace", "foo")
-   window = moving_window.get_window_stats(one_per_minute, "test_namespace", "foo")
-   assert window.remaining == 0
-   assert False == moving_window.hit(one_per_minute, "test_namespace", "foo")
-   time.sleep(window.reset_time - time.time())
-   assert True == moving_window.hit(one_per_minute, "test_namespace", "foo")
-
-
-Links
-=====
-
-* `Documentation <http://limits.readthedocs.org/en/latest>`_
-* `Changelog <http://limits.readthedocs.org/en/stable/changelog.html>`_
-

limits-4.0.1.dist-info/RECORD

@@ -1,37 +0,0 @@
-limits/__init__.py,sha256=j_yVhgN9pdz8o5rQjVwdJTBSq8F-CTzof9kkiYgjRbw,728
-limits/_version.py,sha256=pB8_a1HHuX7Bo8LVuoQ_8GjLU5i4z56J1tr986TiLUA,497
-limits/errors.py,sha256=xCKGOVJiD-g8FlsQQb17AW2pTUvalYSuizPpvEVoYJE,626
-limits/limits.py,sha256=ZsXESq2e1ji7c2ZKjSkIAasCjiLdjVLPUa9oah_I8U4,4943
-limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-limits/strategies.py,sha256=Zy6PIhkysPbxnMzFjyXEsxMM6jhRoQ5XT5WskTNruK0,6949
-limits/typing.py,sha256=4yitf6iwDK-QEfSxv3EbTdGLOrqowLFffHAqYRUqiYY,3275
-limits/util.py,sha256=fTx0JQBT6ZY3fxGefjT07CLimUVCFjS1jLqskXmb7Eo,5726
-limits/version.py,sha256=YwkF3dtq1KGzvmL3iVGctA8NNtGlK_0arrzZkZGVjUs,47
-limits/aio/__init__.py,sha256=IOetunwQy1c5GefzitK8lewbTzHGiE-kmE9NlqSdr3U,82
-limits/aio/strategies.py,sha256=SHjmJnmy7Nh4tBydkA-0qPaULYcLOAM91T4RPybq0Sg,6768
-limits/aio/storage/__init__.py,sha256=CbtuSlVl1jPyN_vsEI_ApWblDblVaL46xcZ2M_oM0V8,595
-limits/aio/storage/base.py,sha256=V1Ur9Cu29_vP5IYBIsWHTgrc4riW8FEyz5Dcvv6fPoc,4821
-limits/aio/storage/etcd.py,sha256=krqjWujvybuaFa2g_FkPr2ZtX9Ac1-oJzErfGW3h27o,4783
-limits/aio/storage/memcached.py,sha256=n8b9GVtXMWdc-w4-xP1_MPJ9dgVcgoJ5j53mTdU6E3E,4799
-limits/aio/storage/memory.py,sha256=4ah9RpE5r7Q2yOLT-OndhP4ZHmvcwV3rKvCicnK2CJc,5845
-limits/aio/storage/mongodb.py,sha256=pC5Ng-5PlV5u1EQlgITfetLvpL4mitcxaaZ_uokwUs0,10846
-limits/aio/storage/redis.py,sha256=JQm4pkwynSo1k6wFVB7SyRsh7yav0_61Px1FqUwuGl4,15658
-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=5hUZghISDh8Cbg8HJediM_OKjjNMF-0CBywWmsc93vA,430
-limits/storage/__init__.py,sha256=_ozbLZtZDVRamfNe4clxcmYbM9Gbu8FzuuAeWQAi_ZA,2588
-limits/storage/base.py,sha256=E7ZInoGZqoM1QIpd1f8lvytlic4sMOQdl_eTzD-mlWk,4631
-limits/storage/etcd.py,sha256=Q1tndCAAJp0jnir-b-ZBN3-7Kf3v_uwNAqQJLmqB96Q,4440
-limits/storage/memcached.py,sha256=4xgcSI7l02KbHP0P_ChFgx5ytDqiby6-kwfJ6_5lua4,6618
-limits/storage/memory.py,sha256=ButyS6v7o7DB55bwM3CltFK4Fc5mwKuFEBPgat51CXU,5550
-limits/storage/mongodb.py,sha256=LmrkLOlMMveI4hnv69yMOQhrXUqp6RMvdjXkvTiE4DY,9979
-limits/storage/redis.py,sha256=R7UbE5ng1NjIHEO17gu-vIZ4qgy91JctbPYGEkZ2iM0,8483
-limits/storage/redis_cluster.py,sha256=MsiEpwHphQd0P88AwGw1NVSi3UwVrhsg-pvzkHxU2kw,3739
-limits/storage/redis_sentinel.py,sha256=665CvL3UZYB2sB_vVkZ4CCaPKcbIXvQUWuDWnBoSOLU,4124
-limits/storage/registry.py,sha256=xcBcxuu6srqmoS4WqDpkCXnRLB19ctH98v21P8S9kS8,708
-limits-4.0.1.dist-info/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
-limits-4.0.1.dist-info/METADATA,sha256=EzpDuoZfOrB3xjvhv-IHK5Q6-R_6-vH5FnUEoJ-ohdI,7662
-limits-4.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-limits-4.0.1.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
-limits-4.0.1.dist-info/RECORD,,