3: Make time monotonic (#231)

Author: paultiq

README.md

@@ -193,7 +193,7 @@ from pyrate_limiter import Limiter
 
 # Limiter constructor accepts single bucket as the only parameter,
 # the rest are 3 optional parameters with default values as following
-# Limiter(bucket, clock=TimeClock(), raise_when_fail=True, max_delay=None)
+# Limiter(bucket, clock=MonotonicClock(), raise_when_fail=True, max_delay=None)
 limiter = Limiter(bucket)
 
 # Limiter is now ready to work!
@@ -209,9 +209,9 @@ When multiple bucket types are needed and items must be routed based on certain
 First, define your clock (time source). Most use cases work with the built-in clocks:
 
 ```python
-from pyrate_limiter.clock import TimeClock, MonotonicClock, SQLiteClock
+from pyrate_limiter.clock import MonotonicClock, SQLiteClock
 
-base_clock = TimeClock()
+base_clock = MonotonicClock()
 ```
 
 PyrateLimiter does not assume routing logic, so you implement a custom BucketFactory. At a minimum, these two methods must be defined:
@@ -439,7 +439,7 @@ Here's an example that will raise an exception on the 4th request:
 ```python
 rate = Rate(3, Duration.SECOND)
 bucket = InMemoryBucket([rate])
-clock = TimeClock()
+clock = MonotonicClock()
 
 
 class MyBucketFactory(BucketFactory):
@@ -662,7 +662,7 @@ Multiprocessing: If using MultiprocessBucket, two locks are used in Limiter: a t
 Time source can be anything from anywhere: be it python's built-in time, or monotonic clock, sqliteclock, or crawling from world time server(well we don't have that, but you can!).
 
 ```python
-from pyrate_limiter import TimeClock      # use python' time.time()
+from pyrate_limiter import MonotonicClock      # use python time.monotonic()
 from pyrate_limiter import MonotonicClock # use python time.monotonic()
 ```
 

pyrate_limiter/clocks.py

@@ -4,7 +4,7 @@
 
 import sqlite3
 from contextlib import nullcontext
-from time import monotonic, time
+from time import monotonic
 from typing import TYPE_CHECKING, Optional, Union
 
 from .abstracts import AbstractClock
@@ -25,16 +25,11 @@ def now(self):
         return int(1000 * monotonic())
 
 
-class TimeClock(AbstractClock):
-    def now(self):
-        return int(1000 * time())
-
-
-class TimeAsyncClock(AbstractClock):
-    """Time Async Clock, meant for testing only"""
+class MonotonicAsyncClock(AbstractClock):
+    """Monotonic Async Clock, meant for testing only"""
 
     async def now(self) -> int:
-        return int(1000 * time())
+        return int(1000 * monotonic())
 
 
 class SQLiteClock(AbstractClock):

pyrate_limiter/limiter.py

@@ -11,7 +11,7 @@
 
 from .abstracts import AbstractBucket, AbstractClock, BucketFactory, Duration, Rate, RateItem
 from .buckets import InMemoryBucket
-from .clocks import TimeClock
+from .clocks import MonotonicClock
 from .exceptions import BucketFullException, LimiterDelayException
 
 logger = logging.getLogger("pyrate_limiter")
@@ -94,15 +94,15 @@ def __init__(
 
         Parameters:
             argument (Union[BucketFactory, AbstractBucket, Rate, List[Rate]]): The bucket or rate configuration.
-            clock (AbstractClock, optional): The clock instance to use for rate limiting. Defaults to TimeClock().
+            clock (AbstractClock, optional): The clock instance to use for rate limiting. Defaults to MonotonicClock().
             raise_when_fail (bool, optional): Whether to raise an exception when rate limiting fails. Defaults to True.
             max_delay (Optional[Union[int, Duration]], optional): The maximum delay allowed for rate limiting.
             Defaults to None.
             retry_until_max_delay (bool, optional): If True, retry operations until the maximum delay is reached.
                 Useful for ensuring operations eventually succeed within the allowed delay window. Defaults to False.
         """
         if clock is None:
-            clock = TimeClock()
+            clock = MonotonicClock()
         self.bucket_factory = self._init_bucket_factory(argument, clock=clock)
         self.raise_when_fail = raise_when_fail
         self.retry_until_max_delay = retry_until_max_delay

tests/conftest.py

@@ -18,8 +18,7 @@
 from pyrate_limiter import PostgresBucket
 from pyrate_limiter import Rate
 from pyrate_limiter import RedisBucket
-from pyrate_limiter import TimeAsyncClock
-from pyrate_limiter import TimeClock
+from pyrate_limiter import MonotonicAsyncClock
 
 
 # Make log messages visible on test failure (or with pytest -s)
@@ -32,14 +31,12 @@
 
 clocks = [
     pytest.param(MonotonicClock(), marks=pytest.mark.monotonic),
-    pytest.param(TimeClock(), marks=pytest.mark.timeclock),
-    pytest.param(TimeAsyncClock(), marks=pytest.mark.asyncclock),
+    pytest.param(MonotonicAsyncClock(), marks=pytest.mark.asyncclock),
 ]
 
 ClockSet = Union[
     MonotonicClock,
-    TimeClock,
-    TimeAsyncClock,
+    MonotonicAsyncClock,
 ]
 
 

tests/test_bucket_all.py

@@ -13,7 +13,7 @@
 from pyrate_limiter import BucketAsyncWrapper
 from pyrate_limiter import Rate
 from pyrate_limiter import RateItem
-from pyrate_limiter import TimeClock
+from pyrate_limiter import MonotonicClock
 
 
 async def get_now(clock: AbstractClock) -> int:
@@ -218,7 +218,7 @@ async def test_bucket_flush(create_bucket):
     rates = [Rate(50, 1000)]
     bucket = BucketAsyncWrapper(await create_bucket(rates))
     assert isinstance(bucket.rates[0], Rate)
-    clock = TimeClock()
+    clock = MonotonicClock()
 
     while await bucket.put(RateItem("item", clock.now())):
         pass
@@ -236,7 +236,7 @@ async def test_bucket_performance(create_bucket):
     Putting a very large number of item into bucket
     Only need to test with a single clock type
     """
-    clock = TimeClock()
+    clock = MonotonicClock()
     rates = [Rate(30000, 50000)]
     bucket = BucketAsyncWrapper(await create_bucket(rates))
     before = time()

tests/test_limiter.py

@@ -24,7 +24,7 @@
 from pyrate_limiter import LimiterDelayException
 from pyrate_limiter import Rate
 from pyrate_limiter import SingleBucketFactory
-from pyrate_limiter import TimeClock
+from pyrate_limiter import MonotonicClock
 
 
 @pytest.mark.asyncio
@@ -55,7 +55,7 @@ async def test_limiter_constructor_02(
 
     limiter = Limiter(bucket)
     assert isinstance(limiter.bucket_factory, SingleBucketFactory)
-    assert isinstance(limiter.bucket_factory.clock, TimeClock)
+    assert isinstance(limiter.bucket_factory.clock, MonotonicClock)
     assert limiter.max_delay is None
     assert limiter.raise_when_fail is True
 
@@ -356,7 +356,7 @@ def test_wait_too_long():
 
     rate = Rate(requests_per_second, Duration.SECOND)
     bucket = InMemoryBucket([rate])
-    limiter = Limiter(bucket, raise_when_fail=False, clock=TimeClock(),
+    limiter = Limiter(bucket, raise_when_fail=False, clock=MonotonicClock(),
                       max_delay=Duration.SECOND, retry_until_max_delay=True)
 
     # raise_when_fail = False
@@ -370,7 +370,7 @@ def test_wait_too_long():
     time.sleep(1)
 
     # raise_when_fail = True
-    limiter = Limiter(bucket, raise_when_fail=True, clock=TimeClock(),
+    limiter = Limiter(bucket, raise_when_fail=True, clock=MonotonicClock(),
                       max_delay=Duration.SECOND, retry_until_max_delay=True)
 
     with pytest.raises(LimiterDelayException):

tests/test_multiprocessing.py

@@ -21,7 +21,7 @@
 from pyrate_limiter import Rate
 from pyrate_limiter import SQLiteBucket
 from pyrate_limiter import SQLiteClock
-from pyrate_limiter import TimeClock
+from pyrate_limiter import MonotonicClock
 from pyrate_limiter.buckets.mp_bucket import MultiprocessBucket
 
 MAX_DELAY = Duration.DAY
@@ -46,7 +46,7 @@ def init_process_mp(
         LIMITER = Limiter(
             bucket,
             raise_when_fail=raise_when_fail,
-            clock=TimeClock(),
+            clock=MonotonicClock(),
             max_delay=max_delay,
             retry_until_max_delay=not raise_when_fail,
         )
@@ -286,7 +286,7 @@ def test_limiter_delay():
         limiter = Limiter(
             bucket,
             raise_when_fail=True,
-            clock=TimeClock(),
+            clock=MonotonicClock(),
             max_delay=Duration.SECOND,
             retry_until_max_delay=False,
         )
@@ -318,7 +318,7 @@ def test_bucket_full():
     limiter = Limiter(
         bucket,
         raise_when_fail=True,
-        clock=TimeClock(),
+        clock=MonotonicClock(),
         max_delay=None,
         retry_until_max_delay=False,
     )