ratelimiter_lite 0.1.0__tar.gz

ratelimiter_lite-0.1.0/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright <2026> <JackCizon>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ratelimiter_lite-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ratelimiter_lite
+Version: 0.1.0
+Summary: Rate Limit Components
+License: MIT
+License-File: LICENSE.txt
+Author: jackcizon
+Author-email: jack20021213cn@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: coverage (>=7.13.2,<8.0.0)
+Requires-Dist: mypy (>=1.19.1,<2.0.0)
+Requires-Dist: pre-commit (>=4.5.1,<5.0.0)
+Requires-Dist: pytest (>=9.0.2,<10.0.0)
+Requires-Dist: ruff (>=0.14.14,<0.15.0)
+Requires-Dist: sphinx (>=9.1.0,<10.0.0)
+Requires-Dist: sphinx-autobuild (>=2025.8.25,<2026.0.0)

ratelimiter_lite-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "ratelimiter_lite"
+version = "0.1.0"
+description = "Rate Limit Components"
+authors = [
+    { name = "jackcizon", email = "jack20021213cn@gmail.com" }
+]
+license = { text = "MIT" }
+requires-python = ">=3.12"
+dependencies = [
+    "pytest (>=9.0.2,<10.0.0)",
+    "coverage (>=7.13.2,<8.0.0)",
+    "ruff (>=0.14.14,<0.15.0)",
+    "mypy (>=1.19.1,<2.0.0)",
+    "pre-commit (>=4.5.1,<5.0.0)",
+    "sphinx (>=9.1.0,<10.0.0)",
+    "sphinx-autobuild (>=2025.8.25,<2026.0.0)",
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

ratelimiter_lite-0.1.0/ratelimiter_lite/base.py

@@ -0,0 +1,61 @@
+class Baseratelimiter_lite:  # pragma: no cover
+    """single-process rate limiting"""
+
+    def __init__(self, limit: int, period: float) -> None:
+        """
+        This is a state machine that maintains ratelimiter_lite invariants.
+
+        Rate limiter algorithms are widely used, but they are not difficult to implement.
+
+        The algorithm for a rate limiter is much simpler than that for a red-black tree,
+        if you have implemented a red-black tree before.
+        """
+        self._limit = limit
+        self._period = period
+
+    def allow(self) -> bool:
+        """
+        Do Not Use `__call__`.
+
+        e.g: A ratelimiter_lite prototype via `__call__`.
+
+        class ratelimiter_lite:
+            def __init__(self, func: Callable = None, limit=2, period=1.0):
+                self._func = func
+                self._counter = 0
+                self._last_reset = time.monotonic()
+                self._lock = threading.RLock()
+                self._limit = limit
+                self._period = period
+
+            def __call__(self, *args, **kwargs):
+                with self._lock:
+                    now = time.monotonic()
+                    if now - self._last_reset >= self._period:
+                        self._counter = 0
+                        self._last_reset = now
+                    if self._counter >= self._limit:
+                        print(">>> [Rate Limited!]")
+                        raise Exception
+                    self._counter += 1
+                return self._func(*args, **kwargs)
+
+
+        @ratelimiter_lite(limit=3, period=0.5)
+        def aaa(args):
+            print(args)
+            time.sleep(0.1)
+
+        issues:
+            1. limiter params cannot change.
+            2. where is the function?(can slove it by writing function into `__call__`)
+            3. if write function into `__call__`, the code logic is bad.
+
+        If you cram all your algorithmic logic into `__call__`,
+        your code will become increasingly bloated.
+
+        click internal uses class to define Command, Parameter, etc....
+        then use a wrapper function, like commond(args, ...) factory,
+        used by decorator @commond()
+        """
+        raise NotImplementedError

ratelimiter_lite-0.1.0/ratelimiter_lite/factory.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+from ratelimiter_lite.base import Baseratelimiter_lite
+
+
+def ratelimiter_lite_factory[T: Baseratelimiter_lite](cls: type[T], limit: int, period: float) -> Callable:
+    limiter = cls(limit, period)
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Callable | None:
+            if limiter.allow():
+                return func(*args, **kwargs)
+            else:
+                print(f"[{func.__name__}] Rate limit exceeded")
+                return None
+
+        return wrapper
+
+    return decorator

ratelimiter_lite-0.1.0/ratelimiter_lite/fixed_window.py

@@ -0,0 +1,28 @@
+import time
+import threading
+
+from ratelimiter_lite.base import Baseratelimiter_lite
+
+
+class FixedWindowratelimiter_lite(Baseratelimiter_lite):
+    """only valid in"""
+
+    def __init__(self, limit: int, period: float):
+        super().__init__(limit, period)
+        self._counter = 0
+        self._last_reset = time.monotonic()
+        self._lock = threading.Lock()
+
+    def allow(self) -> bool:
+        with self._lock:
+            now = time.monotonic()
+
+            if now - self._last_reset >= self._period:
+                self._counter = 0
+                self._last_reset = now
+
+            if self._counter < self._limit:
+                self._counter += 1
+                return True
+
+            return False