limits 4.7.3__py3-none-any.whl → 5.0.0__py3-none-any.whl

limits/aio/storage/memcached.py

@@ -1,281 +0,0 @@
-from __future__ import annotations
-
-import time
-import urllib.parse
-from collections.abc import Iterable
-from math import ceil, floor
-
-from deprecated.sphinx import versionadded
-
-from limits.aio.storage.base import SlidingWindowCounterSupport, Storage
-from limits.storage.base import TimestampedSlidingWindow
-from limits.typing import EmcacheClientP, ItemP
-
-
-@versionadded(version="2.1")
-class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingWindow):
-    """
-    Rate limit storage with memcached as backend.
-
-    Depends on :pypi:`emcache`
-    """
-
-    STORAGE_SCHEME = ["async+memcached"]
-    """The storage scheme for memcached to be used in an async context"""
-
-    DEPENDENCIES = ["emcache"]
-
-    def __init__(
-        self,
-        uri: str,
-        wrap_exceptions: bool = False,
-        **options: 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
-        """
-        parsed = urllib.parse.urlparse(uri)
-        self.hosts = []
-
-        for host, port in (
-            loc.split(":") for loc in parsed.netloc.strip().split(",") if loc.strip()
-        ):
-            self.hosts.append((host, int(port)))
-
-        self._options = options
-        self._storage = None
-        super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
-        self.dependency = self.dependencies["emcache"].module
-
-    @property
-    def base_exceptions(
-        self,
-    ) -> 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(
-                [self.dependency.MemcachedHostAddress(h, p) for h, p in self.hosts],
-                **self._options,
-            )
-        assert self._storage
-        return self._storage
-
-    async def get(self, key: str) -> int:
-        """
-        :param key: the key to get the counter value for
-        """
-        item = await (await self.get_storage()).get(key.encode("utf-8"))
-
-        return item and int(item.value) or 0
-
-    async def get_many(self, keys: Iterable[str]) -> dict[bytes, ItemP]:
-        """
-        Return multiple counters at once
-
-        :param keys: the keys to get the counter values for
-        """
-        return await (await self.get_storage()).get_many(
-            [k.encode("utf-8") for k in keys]
-        )
-
-    async def clear(self, key: str) -> None:
-        """
-        :param key: the key to clear rate limits for
-        """
-        try:
-            await (await self.get_storage()).delete(key.encode("utf-8"))
-        except self.dependency.NotFoundCommandError:
-            pass
-
-    async def decr(self, key: str, amount: int = 1, noreply: bool = False) -> int:
-        """
-        decrements the counter for a given rate limit key
-
-        retursn 0 if the key doesn't exist or if noreply is set to True
-
-        :param key: the key to decrement
-        :param amount: the number to decrement by
-        :param noreply: set to True to ignore the memcached response
-        """
-        storage = await self.get_storage()
-        limit_key = key.encode("utf-8")
-        try:
-            value = await storage.decrement(limit_key, amount, noreply=noreply) or 0
-        except self.dependency.NotFoundCommandError:
-            value = 0
-        return value
-
-    async def incr(
-        self,
-        key: str,
-        expiry: float,
-        elastic_expiry: bool = False,
-        amount: int = 1,
-        set_expiration_key: bool = True,
-    ) -> 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 elastic_expiry: whether to keep extending the rate limit
-         window every hit.
-        :param amount: the number to increment by
-        :param set_expiration_key: if set to False, the expiration time won't be stored but the key will still expire
-        """
-        storage = await self.get_storage()
-        limit_key = key.encode("utf-8")
-        expire_key = self._expiration_key(key).encode()
-        value = None
-        try:
-            value = await storage.increment(limit_key, amount) or amount
-            if elastic_expiry:
-                await storage.touch(limit_key, exptime=ceil(expiry))
-                if set_expiration_key:
-                    await storage.set(
-                        expire_key,
-                        str(expiry + time.time()).encode("utf-8"),
-                        exptime=ceil(expiry),
-                        noreply=False,
-                    )
-            return value
-        except self.dependency.NotFoundCommandError:
-            # Incrementation failed because the key doesn't exist
-            storage = await self.get_storage()
-            try:
-                await storage.add(limit_key, f"{amount}".encode(), exptime=ceil(expiry))
-                if set_expiration_key:
-                    await storage.set(
-                        expire_key,
-                        str(expiry + time.time()).encode("utf-8"),
-                        exptime=ceil(expiry),
-                        noreply=False,
-                    )
-                value = amount
-            except self.dependency.NotStoredStorageCommandError:
-                # Coult not add the key, probably because a concurrent call has added it
-                storage = await self.get_storage()
-                value = await storage.increment(limit_key, amount) or amount
-                if elastic_expiry:
-                    await storage.touch(limit_key, exptime=ceil(expiry))
-                    if set_expiration_key:
-                        await storage.set(
-                            expire_key,
-                            str(expiry + time.time()).encode("utf-8"),
-                            exptime=ceil(expiry),
-                            noreply=False,
-                        )
-            return value
-
-    async def get_expiry(self, key: str) -> float:
-        """
-        :param key: the key to get the expiry for
-        """
-        storage = await self.get_storage()
-        item = await storage.get(self._expiration_key(key).encode("utf-8"))
-
-        return item and float(item.value) or time.time()
-
-    def _expiration_key(self, key: str) -> str:
-        """
-        Return the expiration key for the given counter key.
-
-        Memcached doesn't natively return the expiration time or TTL for a given key,
-        so we implement the expiration time on a separate key.
-        """
-        return key + "/expires"
-
-    async def check(self) -> bool:
-        """
-        Check if storage is healthy by calling the ``get`` command
-        on the key ``limiter-check``
-        """
-        try:
-            storage = await self.get_storage()
-            await storage.get(b"limiter-check")
-
-            return True
-        except:  # noqa
-            return False
-
-    async def reset(self) -> int | None:
-        raise NotImplementedError
-
-    async def acquire_sliding_window_entry(
-        self,
-        key: str,
-        limit: int,
-        expiry: int,
-        amount: int = 1,
-    ) -> bool:
-        if amount > limit:
-            return False
-        now = time.time()
-        previous_key, current_key = self.sliding_window_keys(key, expiry, now)
-        (
-            previous_count,
-            previous_ttl,
-            current_count,
-            _,
-        ) = await self._get_sliding_window_info(previous_key, current_key, expiry, now)
-        t0 = time.time()
-        weighted_count = previous_count * previous_ttl / expiry + current_count
-        if floor(weighted_count) + amount > limit:
-            return False
-        else:
-            # Hit, increase the current counter.
-            # If the counter doesn't exist yet, set twice the theorical expiry.
-            # We don't need the expiration key as it is estimated with the timestamps directly.
-            current_count = await self.incr(
-                current_key, 2 * expiry, amount=amount, set_expiration_key=False
-            )
-            t1 = time.time()
-            actualised_previous_ttl = max(0, previous_ttl - (t1 - t0))
-            weighted_count = (
-                previous_count * actualised_previous_ttl / expiry + current_count
-            )
-            if floor(weighted_count) > limit:
-                # Another hit won the race condition: revert the incrementation and refuse this hit
-                # 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.
-                await self.decr(current_key, amount, noreply=True)
-                return False
-            return True
-
-    async def get_sliding_window(
-        self, key: str, expiry: int
-    ) -> tuple[int, float, int, float]:
-        now = time.time()
-        previous_key, current_key = self.sliding_window_keys(key, expiry, now)
-        return await self._get_sliding_window_info(
-            previous_key, current_key, expiry, now
-        )
-
-    async def _get_sliding_window_info(
-        self, previous_key: str, current_key: str, expiry: int, now: float
-    ) -> tuple[int, float, int, float]:
-        result = await self.get_many([previous_key, current_key])
-
-        raw_previous_count = result.get(previous_key.encode("utf-8"))
-        raw_current_count = result.get(current_key.encode("utf-8"))
-
-        current_count = raw_current_count and int(raw_current_count.value) or 0
-        previous_count = raw_previous_count and int(raw_previous_count.value) or 0
-        if previous_count == 0:
-            previous_ttl = float(0)
-        else:
-            previous_ttl = (1 - (((now - expiry) / expiry) % 1)) * expiry
-        current_ttl = (1 - ((now / expiry) % 1)) * expiry + expiry
-
-        return previous_count, previous_ttl, current_count, current_ttl

limits/storage/etcd.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import time
-import urllib.parse
-
-from deprecated.sphinx import deprecated
-
-from limits.errors import ConcurrentUpdateError
-from limits.storage.base import Storage
-from limits.typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import etcd3
-
-
-@deprecated(version="4.4")
-class EtcdStorage(Storage):
-    """
-    Rate limit storage with etcd as backend.
-
-    Depends on :pypi:`etcd3`.
-    """
-
-    STORAGE_SCHEME = ["etcd"]
-    """The storage scheme for etcd"""
-    DEPENDENCIES = ["etcd3"]
-    PREFIX = "limits"
-    MAX_RETRIES = 5
-
-    def __init__(
-        self,
-        uri: str,
-        max_retries: int = MAX_RETRIES,
-        wrap_exceptions: bool = False,
-        **options: str,
-    ) -> None:
-        """
-        :param uri: etcd location of the form
-         ``etcd://host:port``,
-        :param max_retries: Maximum number of attempts to retry
-         in the case of concurrent updates to a rate limit key
-        :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:`etcd3.Etcd3Client`
-        :raise ConfigurationError: when :pypi:`etcd3` is not available
-        """
-        parsed = urllib.parse.urlparse(uri)
-        self.lib = self.dependencies["etcd3"].module
-        self.storage: etcd3.Etcd3Client = self.lib.client(
-            parsed.hostname, parsed.port, **options
-        )
-        self.max_retries = max_retries
-        super().__init__(uri, wrap_exceptions=wrap_exceptions)
-
-    @property
-    def base_exceptions(
-        self,
-    ) -> 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()
-
-    def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
-        retries = 0
-        etcd_key = self.prefixed_key(key)
-        while retries < self.max_retries:
-            now = time.time()
-            lease = self.storage.lease(expiry)
-            window_end = now + expiry
-            create_attempt = self.storage.transaction(
-                compare=[self.storage.transactions.create(etcd_key) == "0"],
-                success=[
-                    self.storage.transactions.put(
-                        etcd_key,
-                        f"{amount}:{window_end}".encode(),
-                        lease=lease.id,
-                    )
-                ],
-                failure=[self.storage.transactions.get(etcd_key)],
-            )
-            if create_attempt[0]:
-                return amount
-            else:
-                cur, meta = create_attempt[1][0][0]
-                cur_value, window_end = cur.split(b":")
-                window_end = float(window_end)
-                if window_end <= now:
-                    self.storage.revoke_lease(meta.lease_id)
-                    self.storage.delete(etcd_key)
-                else:
-                    if elastic_expiry:
-                        self.storage.refresh_lease(meta.lease_id)
-                        window_end = now + expiry
-                    new = int(cur_value) + amount
-                    if self.storage.transaction(
-                        compare=[self.storage.transactions.value(etcd_key) == cur],
-                        success=[
-                            self.storage.transactions.put(
-                                etcd_key,
-                                f"{new}:{window_end}".encode(),
-                                lease=meta.lease_id,
-                            )
-                        ],
-                        failure=[],
-                    )[0]:
-                        return new
-                retries += 1
-        raise ConcurrentUpdateError(key, retries)
-
-    def get(self, key: str) -> int:
-        value, meta = self.storage.get(self.prefixed_key(key))
-        if value:
-            amount, expiry = value.split(b":")
-            if float(expiry) > time.time():
-                return int(amount)
-        return 0
-
-    def get_expiry(self, key: str) -> float:
-        value, _ = self.storage.get(self.prefixed_key(key))
-        if value:
-            return float(value.split(b":")[1])
-        return time.time()
-
-    def check(self) -> bool:
-        try:
-            self.storage.status()
-            return True
-        except:  # noqa
-            return False
-
-    def reset(self) -> int | None:
-        return self.storage.delete_prefix(f"{self.PREFIX}/").deleted
-
-    def clear(self, key: str) -> None:
-        self.storage.delete(self.prefixed_key(key))

limits-4.7.3.dist-info/RECORD

@@ -1,43 +0,0 @@
-limits/__init__.py,sha256=gPUFrt02kHF_syLjiVRSs-S4UVGpRMcM2VMFNhF6G24,748
-limits/_version.py,sha256=jZ64F2cwQ-s302Fiuxp7ygDtnHK_weL0UhvcdhfjUSA,497
-limits/errors.py,sha256=s1el9Vg0ly-z92guvnvYNgKi3_aVqpiw_sufemiLLTI,662
-limits/limits.py,sha256=YzzZP8_ay_zlMMnnY2xhAcFTTFvFe5HEk8NQlvUTru4,4907
-limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-limits/strategies.py,sha256=14k8CFu9mfoVokEVxD48MjF61gBl-hr895brpL4XZUc,10899
-limits/typing.py,sha256=7G4-1MIh0pLOjBMG-gjNhpAqmX-hgQRzhD5_8ROVkls,4459
-limits/util.py,sha256=nk5QYvezFuXPq1OTEj04RrZFSWIH-khT0e_Dim6zGCw,6002
-limits/version.py,sha256=YwkF3dtq1KGzvmL3iVGctA8NNtGlK_0arrzZkZGVjUs,47
-limits/aio/__init__.py,sha256=yxvWb_ZmV245Hg2LqD365WC5IDllcGDMw6udJ1jNp1g,118
-limits/aio/strategies.py,sha256=9jnVU_nynm0zL1EjQLE3fus1vFbLqA-19ZRQhhexAGo,10776
-limits/aio/storage/__init__.py,sha256=gL4DGTV-XDksZxofaP__sGvwehN8MuuJQuRZeuGwiOQ,695
-limits/aio/storage/base.py,sha256=376Bs7l285vRTRa3-DqcVRnqOPdf3BpoCqbJr3XA9u8,6439
-limits/aio/storage/etcd.py,sha256=QJY8B9jNCNZLpo_cEMUyQkYsk4UIfoMhz7lJUl-ROmk,5081
-limits/aio/storage/memcached.py,sha256=elK5XWQr_P1wnWLxSuWQMEBndx0y4VUW0M1kcWJvIYI,10448
-limits/aio/storage/memory.py,sha256=KzpDnr-o3U6Ar2GkhAUTDokQ8tstUFUIe44_rYlMD3k,9765
-limits/aio/storage/mongodb.py,sha256=AyF5CxpuL0-O-PLZPBWPSbyL6JCRpKAlbIfczLSzFFY,19388
-limits/aio/storage/redis/__init__.py,sha256=p6amEcujcImDUxcYCsfBaLBKp1qH9xDXDjv3FWWfGow,14203
-limits/aio/storage/redis/bridge.py,sha256=cKs77RoCxUPfYD6_o1AiHfqpkeq_DFqMtVQKMLhEWdY,3183
-limits/aio/storage/redis/coredis.py,sha256=YT8cBx25MeSy9ApSJBfOK8VKduABTRefsnd9GhWscsI,7494
-limits/aio/storage/redis/redispy.py,sha256=ZAxHOFGAjRHsPzjfLowq5nMlVkK_YhVGHOOV8K4gMmU,8547
-limits/aio/storage/redis/valkey.py,sha256=f_-HPZhzNspywGybMNIL0F5uDZk76v8_K9wuC5ZeKhc,248
-limits/resources/redis/lua_scripts/acquire_moving_window.lua,sha256=5CFJX7D6T6RG5SFr6eVZ6zepmI1EkGWmKeVEO4QNrWo,483
-limits/resources/redis/lua_scripts/acquire_sliding_window.lua,sha256=OhVI1MAN_gT92P6r-2CEmvy1yvQVjYCCZxWIxfXYceY,1329
-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/resources/redis/lua_scripts/sliding_window.lua,sha256=qG3Yg30Dq54QpRUcR9AOrKQ5bdJiaYpCacTm6Kxblvc,713
-limits/storage/__init__.py,sha256=DArgeRfGilHWsfKz5qT_6OimP3S5u2E9lnzVst0n8Bw,2701
-limits/storage/base.py,sha256=6MprvcdNaTIPyN0ei9emcJLajYq07vDGSIKrmiaU6dU,7003
-limits/storage/etcd.py,sha256=oaNYOUryK-YmWKfmPtodRLjJGDMV4lGEYW9PU7FI_Ko,4745
-limits/storage/memcached.py,sha256=NJqHpbfZjT7YpjlK0dUX1-k_nb7HxPMQvBBapgUaHhY,11217
-limits/storage/memory.py,sha256=xLg3NDsnVEI3ds4QGS7MpH-VjjEJqwroOnz3LA8UQQ8,9226
-limits/storage/mongodb.py,sha256=UOn1owOnCJ_HxYQS2A82PKqJ_2gg46yWNBV6S73uVeE,18314
-limits/storage/redis.py,sha256=b2m5TrPNwS7NBY5btwCN0esGyCVQTwwgCn6f-sTcgFQ,10613
-limits/storage/redis_cluster.py,sha256=z6aONMl4p1AY78G3J0BbtK--uztz88krwnpiOsU61BM,4447
-limits/storage/redis_sentinel.py,sha256=AN0WtwHN88TvXk0C2uUE8l5Jhsd1ZxU8XSqrEyQSR20,4327
-limits/storage/registry.py,sha256=CxSaDBGR5aBJPFAIsfX9axCnbcThN3Bu-EH4wHrXtu8,650
-limits-4.7.3.dist-info/licenses/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
-limits-4.7.3.dist-info/METADATA,sha256=YPclKajNJE8T3MSA5Nk2M3Ib3HW7C5W8WbJsAFrkwic,11379
-limits-4.7.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-limits-4.7.3.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
-limits-4.7.3.dist-info/RECORD,,