limits 3.14.1__tar.gz → 4.0.1__tar.gz

{limits-3.14.1 → limits-4.0.1}/HISTORY.rst

@@ -3,6 +3,25 @@
 Changelog
 =========
 
+v4.0.1
+------
+Release Date: 2025-01-16
+
+Security
+
+  * Change pypi release to use trusted publishing
+
+v4.0.0
+------
+Release Date: 2025-01-05
+
+* Breaking change
+
+  * Change definition of ``reset_time`` in ``get_window_stats``
+    to use a precise floating point value instead of truncating
+    to the previous second.
+
+
 v3.14.1
 -------
 Release Date: 2024-11-30
@@ -743,6 +762,8 @@ Release Date: 2015-01-08
 
 
 
+
+
 
 
 

{limits-3.14.1 → limits-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: limits
-Version: 3.14.1
+Version: 4.0.1
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -55,6 +55,17 @@ 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: motor<4,>=3; extra == "all"
 Requires-Dist: aetcd; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 .. |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
@@ -172,6 +183,18 @@ Check specific limits without hitting them
         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
 =====
 

{limits-3.14.1 → limits-4.0.1}/README.rst

@@ -114,6 +114,18 @@ Check specific limits without hitting them
         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
 =====
 

{limits-3.14.1 → limits-4.0.1}/doc/source/quickstart.rst

@@ -13,14 +13,14 @@ Initialize the storage backend
     .. code::
 
         from limits import storage
-        memory_storage = storage.MemoryStorage()
+        limits_storage = storage.MemoryStorage()
 
 .. tab:: Memcached
 
     .. code::
 
         from limits import storage
-        memory_storage = storage.MemcachedStorage(
+        limits_storage = storage.MemcachedStorage(
             "memcached://localhost:11211"
         )
 
@@ -29,7 +29,7 @@ Initialize the storage backend
     .. code::
 
         from limits import storage
-        memory_storage = storage.RedisStorage("redis://localhost:6379/1")
+        limits_storage = storage.RedisStorage("redis://localhost:6379/1")
 
 Initialize a rate limiter with the :ref:`Moving Window<strategies:moving window>` Strategy
 ------------------------------------------------------------------------------------------
@@ -37,7 +37,7 @@ Initialize a rate limiter with the :ref:`Moving Window<strategies:moving window>
 .. code::
 
     from limits import strategies
-    moving_window = strategies.MovingWindowRateLimiter(memory_storage)
+    moving_window = strategies.MovingWindowRateLimiter(limits_storage)
 
 
 Describe the rate limit
@@ -87,6 +87,19 @@ Check without consuming
         time.sleep(0.01)
     assert True == moving_window.hit(one_per_second, "test_namespace", "foo")
 
+Query available capacity and reset time
+-----------------------------------------
+
+.. code::
+
+   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")
+
+
 Clear a limit
 =============
 

{limits-3.14.1 → limits-4.0.1}/doc/source/strategies.rst

@@ -35,7 +35,7 @@ Moving Window
 =============
 
 .. warning:: The moving window strategy is not implemented for the ``memcached``
-    storage backend.
+    and ``etcd`` storage backends.
 
 This strategy is the most effective for preventing bursts from by-passing the
 rate limit as the window for each limit is not fixed at the start and end of each time unit

{limits-3.14.1 → limits-4.0.1}/limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-30T11:04:11-0800",
+ "date": "2025-01-16T11:38:03-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "0671723f54aed5692d4c9d9b47cf0326d5263de5",
- "version": "3.14.1"
+ "full-revisionid": "074be17ab3008f50de700e996d243ba85580b058",
+ "version": "4.0.1"
 }
 '''  # END VERSION_JSON
 

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/base.py

@@ -103,7 +103,7 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
         raise NotImplementedError
 
     @abstractmethod
-    async def get_expiry(self, key: str) -> int:
+    async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
@@ -169,7 +169,7 @@ class MovingWindowSupport(ABC):
     @abstractmethod
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int]:
         """
         returns the starting point and the number of entries in the moving
         window

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/etcd.py

@@ -116,12 +116,12 @@ class EtcdStorage(Storage):
                 return int(amount)
         return 0
 
-    async def get_expiry(self, key: str) -> int:
+    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 int(window_end)
-        return int(time.time())
+            return window_end
+        return time.time()
 
     async def check(self) -> bool:
         try:

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/memcached.py

@@ -126,14 +126,14 @@ class MemcachedStorage(Storage):
 
         return amount
 
-    async def get_expiry(self, key: str) -> int:
+    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(f"{key}/expires".encode())
 
-        return int(item and float(item.value) or time.time())
+        return item and float(item.value) or time.time()
 
     async def check(self) -> bool:
         """

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/memory.py

@@ -128,12 +128,12 @@ class MemoryStorage(Storage, MovingWindowSupport):
 
             return True
 
-    async def get_expiry(self, key: str) -> int:
+    async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
 
-        return int(self.expirations.get(key, time.time()))
+        return self.expirations.get(key, time.time())
 
     async def get_num_acquired(self, key: str, expiry: int) -> int:
         """
@@ -153,7 +153,7 @@ class MemoryStorage(Storage, MovingWindowSupport):
     # FIXME: arg limit is not used
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int]:
         """
         returns the starting point and the number of entries in the moving
         window
@@ -167,9 +167,9 @@ class MemoryStorage(Storage, MovingWindowSupport):
 
         for item in self.events.get(key, [])[::-1]:
             if item.atime >= timestamp - expiry:
-                return int(item.atime), acquired
+                return item.atime, acquired
 
-        return int(timestamp), acquired
+        return timestamp, acquired
 
     async def check(self) -> bool:
         """

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/mongodb.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
 import asyncio
-import calendar
 import datetime
 import time
-from typing import Any, cast
+from typing import cast
 
 from deprecated.sphinx import versionadded, versionchanged
 
 from limits.aio.storage.base import MovingWindowSupport, Storage
-from limits.typing import Dict, Optional, ParamSpec, Tuple, Type, TypeVar, Union
+from limits.typing import Dict, List, Optional, ParamSpec, Tuple, Type, TypeVar, Union
 from limits.util import get_dependency
 
 P = ParamSpec("P")
@@ -135,21 +134,19 @@ class MongoDBStorage(Storage, MovingWindowSupport):
             ),
         )
 
-    async def get_expiry(self, key: str) -> int:
+    async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
         counter = await self.database[self.__collection_mapping["counters"]].find_one(
             {"_id": key}
         )
-        expiry = (
-            counter["expireAt"]
-            if counter
-            else datetime.datetime.now(datetime.timezone.utc)
+        return (
+            (counter["expireAt"] if counter else datetime.datetime.now())
+            .replace(tzinfo=datetime.timezone.utc)
+            .timestamp()
         )
 
-        return calendar.timegm(expiry.timetuple())
-
     async def get(self, key: str) -> int:
         """
         :param key: the key to get the counter value for
@@ -227,7 +224,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
 
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int]:
         """
         returns the starting point and the number of entries in the moving
         window
@@ -237,7 +234,7 @@ class MongoDBStorage(Storage, MovingWindowSupport):
         :return: (start of window, number of acquired entries)
         """
         timestamp = time.time()
-        result = (
+        if result := (
             await self.database[self.__collection_mapping["windows"]]
             .aggregate(
                 [
@@ -264,12 +261,9 @@ class MongoDBStorage(Storage, MovingWindowSupport):
                 ]
             )
             .to_list(length=1)
-        )
-
-        if result:
-            return (int(result[0]["min"]), result[0]["count"])
-
-        return (int(timestamp), 0)
+        ):
+            return result[0]["min"], result[0]["count"]
+        return timestamp, 0
 
     async def acquire_entry(
         self, key: str, limit: int, expiry: int, amount: int = 1
@@ -287,23 +281,29 @@ class MongoDBStorage(Storage, MovingWindowSupport):
 
         timestamp = time.time()
         try:
-            updates: Dict[str, Any] = {  # type: ignore
-                "$push": {"entries": {"$each": [], "$position": 0, "$slice": limit}}
+            updates: Dict[
+                str,
+                Dict[str, Union[datetime.datetime, Dict[str, Union[List[float], int]]]],
+            ] = {
+                "$push": {
+                    "entries": {
+                        "$each": [timestamp] * amount,
+                        "$position": 0,
+                        "$slice": limit,
+                    }
+                },
+                "$set": {
+                    "expireAt": (
+                        datetime.datetime.now(datetime.timezone.utc)
+                        + datetime.timedelta(seconds=expiry)
+                    )
+                },
             }
 
-            updates["$set"] = {
-                "expireAt": (
-                    datetime.datetime.now(datetime.timezone.utc)
-                    + datetime.timedelta(seconds=expiry)
-                )
-            }
-            updates["$push"]["entries"]["$each"] = [timestamp] * amount
             await self.database[self.__collection_mapping["windows"]].update_one(
                 {
                     "_id": key,
-                    "entries.%d" % (limit - amount): {
-                        "$not": {"$gte": timestamp - expiry}
-                    },
+                    f"entries.{limit - amount}": {"$not": {"$gte": timestamp - expiry}},
                 },
                 updates,
                 upsert=True,

{limits-3.14.1 → limits-4.0.1}/limits/aio/storage/redis.py

@@ -78,7 +78,7 @@ class RedisInteractor:
 
     async def get_moving_window(
         self, key: str, limit: int, expiry: int
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int]:
         """
         returns the starting point and the number of entries in the moving
         window
@@ -88,12 +88,12 @@ class RedisInteractor:
         :return: (start of window, number of acquired entries)
         """
         key = self.prefixed_key(key)
-        timestamp = int(time.time())
+        timestamp = time.time()
         window = await self.lua_moving_window.execute(
-            [key], [int(timestamp - expiry), limit]
+            [key], [timestamp - expiry, limit]
         )
         if window:
-            return tuple(window)  # type: ignore
+            return float(window[0]), window[1]  # type: ignore
         return timestamp, 0
 
     async def _acquire_entry(
@@ -118,14 +118,14 @@ class RedisInteractor:
 
         return bool(acquired)
 
-    async def _get_expiry(self, key: str, connection: AsyncRedisClient) -> int:
+    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 int(max(await connection.ttl(key), 0) + time.time())
+        return max(await connection.ttl(key), 0) + time.time()
 
     async def _check(self, connection: AsyncRedisClient) -> bool:
         """
@@ -261,7 +261,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
         return await super()._acquire_entry(key, limit, expiry, self.storage, amount)
 
-    async def get_expiry(self, key: str) -> int:
+    async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
@@ -450,7 +450,7 @@ class RedisSentinelStorage(RedisStorage):
             key, self.storage_replica if self.use_replicas else self.storage
         )
 
-    async def get_expiry(self, key: str) -> int:
+    async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """

{limits-3.14.1 → limits-4.0.1}/limits/resources/redis/lua_scripts/moving_window.lua

@@ -16,4 +16,6 @@ for idx=1,#items do
     end
 end
 
-return {oldest, a}
+if oldest then
+    return {tostring(oldest), a}
+end

{limits-3.14.1 → limits-4.0.1}/limits/storage/__init__.py

@@ -32,9 +32,9 @@ def storage_from_string(
 
         from limits.storage import storage_from_string
 
-        memory = from_string("memory://")
-        memcached = from_string("memcached://localhost:11211")
-        redis = from_string("redis://localhost:6379")
+        memory = storage_from_string("memory://")
+        memcached = storage_from_string("memcached://localhost:11211")
+        redis = storage_from_string("redis://localhost:6379")
 
     The same function can be used to construct the :ref:`storage:async storage`
     variants, for example::

{limits-3.14.1 → limits-4.0.1}/limits/storage/base.py

@@ -99,7 +99,7 @@ class Storage(LazyDependency, metaclass=StorageRegistry):
         raise NotImplementedError
 
     @abstractmethod
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
@@ -161,7 +161,7 @@ class MovingWindowSupport(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_moving_window(self, key: str, limit: int, expiry: int) -> Tuple[int, int]:
+    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

{limits-3.14.1 → limits-4.0.1}/limits/storage/etcd.py

@@ -110,12 +110,11 @@ class EtcdStorage(Storage):
                 return int(amount)
         return 0
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         value, _ = self.storage.get(self.prefixed_key(key))
         if value:
-            window_end = float(value.split(b":")[1])
-            return int(window_end)
-        return int(time.time())
+            return float(value.split(b":")[1])
+        return time.time()
 
     def check(self) -> bool:
         try:

{limits-3.14.1 → limits-4.0.1}/limits/storage/memcached.py

@@ -77,8 +77,7 @@ class MemcachedStorage(Storage):
 
         if not get_dependency(self.library):
             raise ConfigurationError(
-                "memcached prerequisite not available."
-                " please install %s" % self.library
+                "memcached prerequisite not available. please install %s" % self.library
             )  # pragma: no cover
         self.local_storage = threading.local()
         self.local_storage.storage = None
@@ -192,12 +191,12 @@ class MemcachedStorage(Storage):
 
         return amount
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
 
-        return int(float(self.storage.get(key + "/expires") or time.time()))
+        return float(self.storage.get(key + "/expires") or time.time())
 
     def check(self) -> bool:
         """

{limits-3.14.1 → limits-4.0.1}/limits/storage/memory.py

@@ -121,12 +121,12 @@ class MemoryStorage(Storage, MovingWindowSupport):
             self.events[key][:0] = [LockableEntry(expiry) for _ in range(amount)]
             return True
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
 
-        return int(self.expirations.get(key, time.time()))
+        return self.expirations.get(key, time.time())
 
     def get_num_acquired(self, key: str, expiry: int) -> int:
         """
@@ -143,7 +143,7 @@ class MemoryStorage(Storage, MovingWindowSupport):
             else 0
         )
 
-    def get_moving_window(self, key: str, limit: int, expiry: int) -> Tuple[int, int]:
+    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
@@ -157,9 +157,9 @@ class MemoryStorage(Storage, MovingWindowSupport):
 
         for item in self.events.get(key, [])[::-1]:
             if item.atime >= timestamp - expiry:
-                return int(item.atime), acquired
+                return item.atime, acquired
 
-        return int(timestamp), acquired
+        return timestamp, acquired
 
     def check(self) -> bool:
         """

{limits-3.14.1 → limits-4.0.1}/limits/storage/mongodb.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-import calendar
 import datetime
 import time
 from abc import ABC, abstractmethod
-from typing import Any, cast
+from typing import cast
 
 from deprecated.sphinx import versionadded, versionchanged
 
 from limits.typing import (
     Dict,
+    List,
     MongoClient,
     MongoCollection,
     MongoDatabase,
@@ -122,19 +122,17 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
         self.counters.find_one_and_delete({"_id": key})
         self.windows.find_one_and_delete({"_id": key})
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
         counter = self.counters.find_one({"_id": key})
-        expiry = (
-            counter["expireAt"]
-            if counter
-            else datetime.datetime.now(datetime.timezone.utc)
+        return (
+            (counter["expireAt"] if counter else datetime.datetime.now())
+            .replace(tzinfo=datetime.timezone.utc)
+            .timestamp()
         )
 
-        return calendar.timegm(expiry.timetuple())
-
     def get(self, key: str) -> int:
         """
         :param key: the key to get the counter value for
@@ -205,7 +203,7 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
         except:  # noqa: E722
             return False
 
-    def get_moving_window(self, key: str, limit: int, expiry: int) -> Tuple[int, int]:
+    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
@@ -243,9 +241,9 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
         )
 
         if result:
-            return int(result[0]["min"]), result[0]["count"]
+            return result[0]["min"], result[0]["count"]
 
-        return int(timestamp), 0
+        return timestamp, 0
 
     def acquire_entry(self, key: str, limit: int, expiry: int, amount: int = 1) -> bool:
         """
@@ -259,23 +257,29 @@ class MongoDBStorageBase(Storage, MovingWindowSupport, ABC):
 
         timestamp = time.time()
         try:
-            updates: Dict[str, Any] = {  # type: ignore
-                "$push": {"entries": {"$each": [], "$position": 0, "$slice": limit}}
+            updates: Dict[
+                str,
+                Dict[str, Union[datetime.datetime, Dict[str, Union[List[float], int]]]],
+            ] = {
+                "$push": {
+                    "entries": {
+                        "$each": [timestamp] * amount,
+                        "$position": 0,
+                        "$slice": limit,
+                    }
+                },
+                "$set": {
+                    "expireAt": (
+                        datetime.datetime.now(datetime.timezone.utc)
+                        + datetime.timedelta(seconds=expiry)
+                    )
+                },
             }
 
-            updates["$set"] = {
-                "expireAt": (
-                    datetime.datetime.now(datetime.timezone.utc)
-                    + datetime.timedelta(seconds=expiry)
-                )
-            }
-            updates["$push"]["entries"]["$each"] = [timestamp] * amount
             self.windows.update_one(
                 {
                     "_id": key,
-                    "entries.%d" % (limit - amount): {
-                        "$not": {"$gte": timestamp - expiry}
-                    },
+                    f"entries.{limit - amount}": {"$not": {"$gte": timestamp - expiry}},
                 },
                 updates,
                 upsert=True,

{limits-3.14.1 → limits-4.0.1}/limits/storage/redis.py

@@ -32,7 +32,7 @@ class RedisInteractor:
     def prefixed_key(self, key: str) -> str:
         return f"{self.PREFIX}:{key}"
 
-    def get_moving_window(self, key: str, limit: int, expiry: int) -> Tuple[int, int]:
+    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
@@ -43,9 +43,10 @@ class RedisInteractor:
         """
         key = self.prefixed_key(key)
         timestamp = time.time()
-        window = self.lua_moving_window([key], [int(timestamp - expiry), limit])
+        if window := self.lua_moving_window([key], [timestamp - expiry, limit]):
+            return float(window[0]), window[1]
 
-        return window or (int(timestamp), 0)
+        return timestamp, 0
 
     def _incr(
         self,
@@ -109,14 +110,14 @@ class RedisInteractor:
 
         return bool(acquired)
 
-    def _get_expiry(self, key: str, connection: RedisClient) -> int:
+    def _get_expiry(self, key: str, connection: RedisClient) -> float:
         """
         :param key: the key to get the expiry for
         :param connection: Redis connection
         """
 
         key = self.prefixed_key(key)
-        return int(max(connection.ttl(key), 0) + time.time())
+        return max(connection.ttl(key), 0) + time.time()
 
     def _check(self, connection: RedisClient) -> bool:
         """
@@ -232,7 +233,7 @@ class RedisStorage(RedisInteractor, Storage, MovingWindowSupport):
 
         return super()._acquire_entry(key, limit, expiry, self.storage, amount)
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """

{limits-3.14.1 → limits-4.0.1}/limits/storage/redis_sentinel.py

@@ -101,7 +101,7 @@ class RedisSentinelStorage(RedisStorage):
             key, self.storage_slave if self.use_replicas else self.storage
         )
 
-    def get_expiry(self, key: str) -> int:
+    def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """

{limits-3.14.1 → limits-4.0.1}/limits/util.py

@@ -38,7 +38,7 @@ class WindowStats(NamedTuple):
     """
 
     #: Time as seconds since the Epoch when this window will be reset
-    reset_time: int
+    reset_time: float
     #: Quantity remaining in this window
     remaining: int
 

{limits-3.14.1 → limits-4.0.1}/limits.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: limits
-Version: 3.14.1
+Version: 4.0.1
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -55,6 +55,17 @@ 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: motor<4,>=3; extra == "all"
 Requires-Dist: aetcd; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 .. |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
@@ -172,6 +183,18 @@ Check specific limits without hitting them
         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
 =====
 

{limits-3.14.1 → limits-4.0.1}/requirements/test.txt

@@ -18,7 +18,7 @@ hiro>0.1.6
 flaky
 lovely-pytest-docker
 pytest<9
-pytest-asyncio==0.21.2
+pytest-asyncio<0.26
 pytest-benchmark[histogram]
 pytest-cov
 pytest-lazy-fixtures

{limits-3.14.1 → limits-4.0.1}/tests/test_strategy.py

@@ -1,4 +1,3 @@
-import math
 import time
 
 import pytest
@@ -28,7 +27,9 @@ class TestWindow:
             assert all([limiter.hit(limit) for _ in range(0, 10)])
         assert not limiter.hit(limit)
         assert limiter.get_window_stats(limit).remaining == 0
-        assert limiter.get_window_stats(limit).reset_time == math.floor(start + 2)
+        assert limiter.get_window_stats(limit).reset_time == pytest.approx(
+            start + 2, 1e-2
+        )
 
     @all_storage
     @fixed_start
@@ -37,7 +38,9 @@ class TestWindow:
         limiter = FixedWindowRateLimiter(storage)
         limit = RateLimitItemPerSecond(10, 2)
         assert limiter.get_window_stats(limit).remaining == 10
-        assert limiter.get_window_stats(limit).reset_time == int(time.time())
+        assert limiter.get_window_stats(limit).reset_time == pytest.approx(
+            time.time(), 1e-2
+        )
 
     @all_storage
     @fixed_start
@@ -61,12 +64,16 @@ class TestWindow:
             assert all([limiter.hit(limit) for _ in range(0, 10)])
             assert not limiter.hit(limit)
         assert limiter.get_window_stats(limit).remaining == 0
-        assert limiter.get_window_stats(limit).reset_time == start + 2
+        assert limiter.get_window_stats(limit).reset_time == pytest.approx(
+            start + 2, 1e-2
+        )
         with window(3) as (start, end):
             assert not limiter.hit(limit)
         assert limiter.hit(limit)
         assert limiter.get_window_stats(limit).remaining == 9
-        assert limiter.get_window_stats(limit).reset_time == end + 2
+        assert limiter.get_window_stats(limit).reset_time == pytest.approx(
+            end + 2, 1e-2
+        )
 
     @all_storage
     @fixed_start
@@ -78,7 +85,9 @@ class TestWindow:
         with window(0) as (start, end):
             assert limiter.hit(limit, "k2", cost=5)
         assert limiter.get_window_stats(limit, "k2").remaining == 5
-        assert limiter.get_window_stats(limit, "k2").reset_time == end + 2
+        assert limiter.get_window_stats(limit, "k2").reset_time == pytest.approx(
+            end + 2, 1e-2
+        )
         assert not limiter.hit(limit, "k2", cost=6)
 
     @moving_window_storage
@@ -87,7 +96,9 @@ class TestWindow:
         limiter = MovingWindowRateLimiter(storage)
         limit = RateLimitItemPerSecond(10, 2)
         assert limiter.get_window_stats(limit).remaining == 10
-        assert limiter.get_window_stats(limit).reset_time == int(time.time() + 2)
+        assert limiter.get_window_stats(limit).reset_time == pytest.approx(
+            time.time() + 2, 1e-2
+        )
 
     @moving_window_storage
     def test_moving_window_stats(self, uri, args, fixture):
@@ -100,9 +111,9 @@ class TestWindow:
         time.sleep(1)
         assert not limiter.hit(limit, "key")
         assert limiter.get_window_stats(limit, "key").remaining == 0
-        assert (
-            limiter.get_window_stats(limit, "key").reset_time - int(time.time()) == 58
-        )
+        assert limiter.get_window_stats(
+            limit, "key"
+        ).reset_time - time.time() == pytest.approx(58, 1e-2)
 
     @moving_window_storage
     def test_moving_window(self, uri, args, fixture):