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

limits/storage/mongodb.py

@@ -144,9 +144,7 @@ class MongoDBStorageBase(
 
         return counter and counter["count"] or 0
 
-    def incr(
-        self, key: str, expiry: int, elastic_expiry: bool = False, amount: int = 1
-    ) -> int:
+    def incr(self, key: str, expiry: int, amount: int = 1) -> int:
         """
         increments the counter for a given rate limit key
 
@@ -175,9 +173,7 @@ class MongoDBStorageBase(
                                 "$cond": {
                                     "if": {"$lt": ["$expireAt", "$$NOW"]},
                                     "then": expiration,
-                                    "else": (
-                                        expiration if elastic_expiry else "$expireAt"
-                                    ),
+                                    "else": "$expireAt",
                                 }
                             },
                         }
@@ -210,13 +206,13 @@ class MongoDBStorageBase(
         :return: (start of window, number of acquired entries)
         """
         timestamp = time.time()
-        result = list(
+        if result := list(
             self.windows.aggregate(
                 [
                     {"$match": {"_id": key}},
                     {
                         "$project": {
-                            "entries": {
+                            "filteredEntries": {
                                 "$filter": {
                                     "input": "$entries",
                                     "as": "entry",
@@ -225,21 +221,16 @@ class MongoDBStorageBase(
                             }
                         }
                     },
-                    {"$unwind": "$entries"},
                     {
-                        "$group": {
-                            "_id": "$_id",
-                            "min": {"$min": "$entries"},
-                            "count": {"$sum": 1},
+                        "$project": {
+                            "min": {"$min": "$filteredEntries"},
+                            "count": {"$size": "$filteredEntries"},
                         }
                     },
                 ]
             )
-        )
-
-        if result:
+        ):
             return result[0]["min"], result[0]["count"]
-
         return timestamp, 0
 
     def acquire_entry(self, key: str, limit: int, expiry: int, amount: int = 1) -> bool:
@@ -299,7 +290,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -311,7 +302,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -319,29 +310,29 @@ class MongoDBStorageBase(
                                 "else": {"$ifNull": ["$currentCount", 0]},
                             }
                         },
-                        "expiresAt": {
+                        "expireAt": {
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
                                 "then": {
-                                    "$add": ["$expiresAt", expiry_ms],
+                                    "$add": ["$expireAt", expiry_ms],
                                 },
-                                "else": "$expiresAt",
+                                "else": "$expireAt",
                             }
                         },
                     }
                 }
             ],
             return_document=self.lib.ReturnDocument.AFTER,
-            projection=["currentCount", "previousCount", "expiresAt"],
+            projection=["currentCount", "previousCount", "expireAt"],
         ):
             expires_at = (
-                (result["expiresAt"].replace(tzinfo=datetime.timezone.utc).timestamp())
-                if result.get("expiresAt")
+                (result["expireAt"].replace(tzinfo=datetime.timezone.utc).timestamp())
+                if result.get("expireAt")
                 else time.time()
             )
             current_ttl = max(0, expires_at - time.time())
@@ -368,7 +359,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -384,7 +375,7 @@ class MongoDBStorageBase(
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
@@ -392,22 +383,22 @@ class MongoDBStorageBase(
                                 "else": {"$ifNull": ["$currentCount", 0]},
                             }
                         },
-                        "expiresAt": {
+                        "expireAt": {
                             "$cond": {
                                 "if": {
                                     "$lte": [
-                                        {"$subtract": ["$expiresAt", "$$NOW"]},
+                                        {"$subtract": ["$expireAt", "$$NOW"]},
                                         expiry_ms,
                                     ]
                                 },
                                 "then": {
                                     "$cond": {
-                                        "if": {"$gt": ["$expiresAt", 0]},
-                                        "then": {"$add": ["$expiresAt", expiry_ms]},
+                                        "if": {"$gt": ["$expireAt", 0]},
+                                        "then": {"$add": ["$expireAt", expiry_ms]},
                                         "else": {"$add": ["$$NOW", 2 * expiry_ms]},
                                     }
                                 },
-                                "else": "$expiresAt",
+                                "else": "$expireAt",
                             }
                         },
                     }
@@ -427,7 +418,7 @@ class MongoDBStorageBase(
                                                             0,
                                                             {
                                                                 "$subtract": [
-                                                                    "$expiresAt",
+                                                                    "$expireAt",
                                                                     {
                                                                         "$add": [
                                                                             "$$NOW",

limits/storage/redis.py

@@ -201,7 +201,6 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         self,
         key: str,
         expiry: int,
-        elastic_expiry: bool = False,
         amount: int = 1,
     ) -> int:
         """
@@ -213,12 +212,7 @@ class RedisStorage(Storage, MovingWindowSupport, SlidingWindowCounterSupport):
         :param amount: the number to increment by
         """
         key = self.prefixed_key(key)
-        if elastic_expiry:
-            value = self.get_connection().incrby(key, amount)
-            self.get_connection().expire(key, expiry)
-            return value
-        else:
-            return int(self.lua_incr_expire([key], [expiry, amount]))
+        return int(self.lua_incr_expire([key], [expiry, amount]))
 
     def get(self, key: str) -> int:
         """

limits/strategies.py

@@ -8,7 +8,7 @@ import time
 from abc import ABCMeta, abstractmethod
 from math import floor, inf
 
-from deprecated.sphinx import deprecated, versionadded
+from deprecated.sphinx import versionadded
 
 from limits.storage.base import SlidingWindowCounterSupport
 
@@ -148,7 +148,6 @@ class FixedWindowRateLimiter(RateLimiter):
             self.storage.incr(
                 item.key_for(*identifiers),
                 item.get_expiry(),
-                elastic_expiry=False,
                 amount=cost,
             )
             <= item.amount
@@ -286,43 +285,14 @@ class SlidingWindowCounterRateLimiter(RateLimiter):
         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`
-    """
-
-    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 (
-            self.storage.incr(
-                item.key_for(*identifiers),
-                item.get_expiry(),
-                elastic_expiry=True,
-                amount=cost,
-            )
-            <= item.amount
-        )
-
-
 KnownStrategy = (
     type[SlidingWindowCounterRateLimiter]
     | type[FixedWindowRateLimiter]
-    | type[FixedWindowElasticExpiryRateLimiter]
     | type[MovingWindowRateLimiter]
 )
 
 STRATEGIES: dict[str, KnownStrategy] = {
     "sliding-window-counter": SlidingWindowCounterRateLimiter,
     "fixed-window": FixedWindowRateLimiter,
-    "fixed-window-elastic-expiry": FixedWindowElasticExpiryRateLimiter,
     "moving-window": MovingWindowRateLimiter,
 }

limits/typing.py

@@ -30,54 +30,6 @@ if TYPE_CHECKING:
     import redis
 
 
-class ItemP(Protocol):
-    value: bytes
-    flags: int | None
-    cas: int | None
-
-
-class EmcacheClientP(Protocol):
-    async def add(
-        self,
-        key: bytes,
-        value: bytes,
-        *,
-        flags: int = 0,
-        exptime: int = 0,
-        noreply: bool = False,
-    ) -> None: ...
-
-    async def get(self, key: bytes, return_flags: bool = False) -> ItemP | None: ...
-
-    async def get_many(self, keys: Iterable[bytes]) -> dict[bytes, ItemP]: ...
-
-    async def gets(self, key: bytes, return_flags: bool = False) -> ItemP | None: ...
-
-    async def increment(
-        self, key: bytes, value: int, *, noreply: bool = False
-    ) -> int | None: ...
-
-    async def decrement(
-        self, key: bytes, value: int, *, noreply: bool = False
-    ) -> int | None: ...
-
-    async def delete(self, key: bytes, *, noreply: bool = False) -> None: ...
-
-    async def set(
-        self,
-        key: bytes,
-        value: bytes,
-        *,
-        flags: int = 0,
-        exptime: int = 0,
-        noreply: bool = False,
-    ) -> None: ...
-
-    async def touch(
-        self, key: bytes, exptime: int, *, noreply: bool = False
-    ) -> None: ...
-
-
 class MemcachedClientP(Protocol):
     def add(
         self,
@@ -155,8 +107,7 @@ __all__ = [
     "Callable",
     "ClassVar",
     "Counter",
-    "EmcacheClientP",
-    "ItemP",
+    "Iterable",
     "Literal",
     "MemcachedClientP",
     "MongoClient",

{limits-4.7.3.dist-info → limits-5.0.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: limits
-Version: 4.7.3
+Version: 5.0.0rc2
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -32,19 +32,14 @@ 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: etcd
-Requires-Dist: etcd3; extra == "etcd"
 Provides-Extra: valkey
 Requires-Dist: valkey>=6; extra == "valkey"
 Provides-Extra: async-redis
 Requires-Dist: coredis<5,>=3.4.0; extra == "async-redis"
 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"
+Requires-Dist: memcachio>=0.3; extra == "async-memcached"
 Provides-Extra: async-mongodb
 Requires-Dist: motor<4,>=3; extra == "async-mongodb"
-Provides-Extra: async-etcd
-Requires-Dist: aetcd; extra == "async-etcd"
 Provides-Extra: async-valkey
 Requires-Dist: valkey>=6; extra == "async-valkey"
 Provides-Extra: all
@@ -52,13 +47,10 @@ 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: valkey>=6; extra == "all"
 Requires-Dist: coredis<5,>=3.4.0; 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"
+Requires-Dist: memcachio>=0.3; extra == "all"
 Requires-Dist: motor<4,>=3; extra == "all"
-Requires-Dist: aetcd; extra == "all"
 Requires-Dist: valkey>=6; extra == "all"
 Dynamic: author
 Dynamic: author-email
@@ -86,13 +78,14 @@ Dynamic: summary
 .. |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 for rate limiting via multiple strategies
-with commonly used storage backends (Redis, Memcached, MongoDB & Etcd).
+with commonly used storage backends (Redis, Memcached & MongoDB).
 
 The library provides identical APIs for use in sync and
 `async <https://limits.readthedocs.io/en/stable/async.html>`_ codebases.
@@ -188,13 +181,13 @@ Scenario 2:
 - ``weighted_count = floor(8 + (4 * 0.33)) = floor(8 + 1.32) = 9``.
 - Since the weighted count is below the limit, the request is allowed.
 
+
 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
@@ -281,5 +274,6 @@ Links
 =====
 
 * `Documentation <http://limits.readthedocs.org/en/latest>`_
+* `Benchmarks <http://limits.readthedocs.org/en/latest/performance.html>`_
 * `Changelog <http://limits.readthedocs.org/en/stable/changelog.html>`_
 

limits-5.0.0rc2.dist-info/RECORD

@@ -0,0 +1,44 @@
+limits/__init__.py,sha256=gPUFrt02kHF_syLjiVRSs-S4UVGpRMcM2VMFNhF6G24,748
+limits/_version.py,sha256=NfHJ8jCFa69gQxFo8GoNxy5o_PAmF3e9sDd1Q4gjLTU,500
+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=LeZ6lnE73EIQqQ8TfKaTzlxNvBMrZOOSXFB0l8D17fI,9946
+limits/typing.py,sha256=pVt5D23MhQSUGqi0MBG5FCSqDwta2ygu18BpKvJFxow,3283
+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=RzZExH2r6jnHra4SpDHqtZCC0Bo3085zUJYo2boAj6Y,9897
+limits/aio/storage/__init__.py,sha256=vKeArUnN1ld_0mQOBBZPCjaQgM5xI1GBPM7_F2Ydz5c,646
+limits/aio/storage/base.py,sha256=VfHpL9Z3RL76eKhoaSQKLKQsqcF5B2bnF6gfa-8ltWA,6296
+limits/aio/storage/memory.py,sha256=sWrDzOe-6Opy9uFmfP1S38IbN2_wNCBaIHTS4UTRy6g,9562
+limits/aio/storage/mongodb.py,sha256=tIMfQrseONRMR2nuRmPO7ocp8dTCABfqBICS_kgp550,19141
+limits/aio/storage/memcached/__init__.py,sha256=VMWsH4XpaPswtPV7cQmsfckhVRbOOrKvoUPYnGt5MRY,6611
+limits/aio/storage/memcached/bridge.py,sha256=3CEruS6LvZWDQPGPLlwY4hemy6oN0WWduUE7t8vyXBI,2017
+limits/aio/storage/memcached/emcache.py,sha256=J01jP-Udd2fLgamCh2CX9NEIvhN8eZVTzUok096Bbe4,3833
+limits/aio/storage/memcached/memcachio.py,sha256=OoGVqOVG0pVX2McFeTGQ_AbiqQUu_FYwWItpQMtNV7g,3491
+limits/aio/storage/redis/__init__.py,sha256=lwoKk91YLEBlZ3W6hCnQ1e7Gc6LxpvSzZZW16saCyR4,14143
+limits/aio/storage/redis/bridge.py,sha256=eoRi9h2bSy194cVwoKgRYQV1HQ7SvwarL-4LeazrxeA,3145
+limits/aio/storage/redis/coredis.py,sha256=IzfEyXBvQbr4QUWML9xAd87a2aHCvglOBEjAg-Vq4z0,7420
+limits/aio/storage/redis/redispy.py,sha256=HS1H6E9g0dP3G-8tSUILIFoc8JWpeRQOiBxcpL3I0gM,8310
+limits/aio/storage/redis/valkey.py,sha256=f_-HPZhzNspywGybMNIL0F5uDZk76v8_K9wuC5ZeKhc,248
+limits/resources/redis/lua_scripts/acquire_moving_window.lua,sha256=Vz0HkI_bSFLW668lEVw8paKlTLEuU4jZk1fpdSuz3zg,594
+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=zlieQwfET0BC7sxpfiOuzPa1wwmrwWLy7IF8LxNa_Lw,717
+limits/resources/redis/lua_scripts/sliding_window.lua,sha256=qG3Yg30Dq54QpRUcR9AOrKQ5bdJiaYpCacTm6Kxblvc,713
+limits/storage/__init__.py,sha256=9iNxIlwzLQw2d54EcMa2LBJ47wiWCPOnHgn6ddqKkDI,2652
+limits/storage/base.py,sha256=IdOL_iqR9KhaJO73M_h9c6OYe8Ox632pxx5uXaL9Dbo,6860
+limits/storage/memcached.py,sha256=5GUKGWS_BYTwUss2WmOlCwBtOieGT7AFUcpX65WYXdQ,10217
+limits/storage/memory.py,sha256=rVlsirSp9LDhuqNFp6KMLR85fJc9xwrU58IHIVz6eq4,8719
+limits/storage/mongodb.py,sha256=V4Ib_AwPFX6JpNI7oUUGJx_3MxD8EmYAi4Q6QcWnQ5U,18071
+limits/storage/redis.py,sha256=i_6qh4S6JQd-lG6eRJdTPxNnZIAkm4G0cA0mfow9OOk,10389
+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-5.0.0rc2.dist-info/licenses/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
+limits-5.0.0rc2.dist-info/METADATA,sha256=0bbBoIEtEg06utKBNEGa7iCNVmbQZ6xLFaIfoxx5aDU,10903
+limits-5.0.0rc2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+limits-5.0.0rc2.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
+limits-5.0.0rc2.dist-info/RECORD,,

limits/aio/storage/etcd.py

@@ -1,146 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import time
-import urllib.parse
-from typing import TYPE_CHECKING
-
-from deprecated.sphinx import deprecated
-
-from limits.aio.storage.base import Storage
-from limits.errors import ConcurrentUpdateError
-
-if TYPE_CHECKING:
-    import aetcd
-
-
-@deprecated(version="4.4")
-class EtcdStorage(Storage):
-    """
-    Rate limit storage with etcd as backend.
-
-    Depends on :pypi:`aetcd`.
-    """
-
-    STORAGE_SCHEME = ["async+etcd"]
-    """The async storage scheme for etcd"""
-    DEPENDENCIES = ["aetcd"]
-
-    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
-         ``async+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:`aetcd.client.Client`
-        :raise ConfigurationError: when :pypi:`aetcd` is not available
-        """
-        parsed = urllib.parse.urlparse(uri)
-        self.lib = self.dependencies["aetcd"].module
-        self.storage: aetcd.Client = self.lib.Client(
-            host=parsed.hostname, port=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.ClientError  # type: ignore[no-any-return]
-
-    def prefixed_key(self, key: str) -> bytes:
-        return f"{self.PREFIX}/{key}".encode()
-
-    async 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 = await self.storage.lease(expiry)
-            window_end = now + expiry
-            create_attempt = await self.storage.transaction(
-                compare=[self.storage.transactions.create(etcd_key) == b"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 = create_attempt[1][0][0][1]
-                cur_value, window_end = cur.value.split(b":")
-                window_end = float(window_end)
-                if window_end <= now:
-                    await asyncio.gather(
-                        self.storage.revoke_lease(cur.lease),
-                        self.storage.delete(etcd_key),
-                    )
-                else:
-                    if elastic_expiry:
-                        await self.storage.refresh_lease(cur.lease)
-                        window_end = now + expiry
-                    new = int(cur_value) + amount
-                    if (
-                        await self.storage.transaction(
-                            compare=[
-                                self.storage.transactions.value(etcd_key) == cur.value
-                            ],
-                            success=[
-                                self.storage.transactions.put(
-                                    etcd_key,
-                                    f"{new}:{window_end}".encode(),
-                                    lease=cur.lease,
-                                )
-                            ],
-                            failure=[],
-                        )
-                    )[0]:
-                        return new
-                retries += 1
-        raise ConcurrentUpdateError(key, retries)
-
-    async def get(self, key: str) -> int:
-        cur = await self.storage.get(self.prefixed_key(key))
-        if cur:
-            amount, expiry = cur.value.split(b":")
-            if float(expiry) > time.time():
-                return int(amount)
-        return 0
-
-    async def get_expiry(self, key: str) -> float:
-        cur = await self.storage.get(self.prefixed_key(key))
-        if cur:
-            window_end = float(cur.value.split(b":")[1])
-            return window_end
-        return time.time()
-
-    async def check(self) -> bool:
-        try:
-            await self.storage.status()
-            return True
-        except:  # noqa
-            return False
-
-    async def reset(self) -> int | None:
-        return (await self.storage.delete_prefix(f"{self.PREFIX}/".encode())).deleted
-
-    async def clear(self, key: str) -> None:
-        await self.storage.delete(self.prefixed_key(key))