ratelimiter-keshav 0.1.0__tar.gz

ratelimiter_keshav-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,48 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+      - master
+
+  pull_request:
+    branches:
+      - main
+      - master
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Upgrade pip
+        run: |
+          python -m pip install --upgrade pip
+
+      - name: Install Dependencies
+        run: |
+          pip install pytest pytest-cov
+          pip install flask fastapi uvicorn redis httpx
+
+      - name: Run Tests
+        run: |
+          pytest
+
+      - name: Run Coverage
+        run: |
+          pytest --cov=rate_limiter

ratelimiter_keshav-0.1.0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## v0.1.0
+
+### Added
+
+- Fixed Window Algorithm
+- Sliding Window Log
+- Sliding Window Counter
+- Token Bucket
+- InMemoryStorage
+- RedisStorage
+- Flask Middleware
+- FastAPI Middleware
+- Concurrency Tests
+- Integration Tests

ratelimiter_keshav-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: ratelimiter-keshav
+Version: 0.1.0
+Summary: A pluggable rate limiting library for Python web frameworks
+Author: Keshav Sharma
+Requires-Python: >=3.10
+Requires-Dist: redis>=4.0
+Provides-Extra: dev
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.95; extra == 'fastapi'
+Requires-Dist: starlette; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=2.0; extra == 'flask'
+Description-Content-Type: text/markdown
+
+# API Rate Limiter
+
+A pluggable rate limiting library for Python web frameworks.
+
+## Features
+
+- Fixed Window
+- Sliding Window Log
+- Sliding Window Counter
+- Token Bucket
+- Flask Middleware
+- FastAPI Middleware
+
+## Installation
+
+```bash
+pip install ratelimiter-keshav

ratelimiter_keshav-0.1.0/README.md

@@ -0,0 +1,17 @@
+# API Rate Limiter
+
+A pluggable rate limiting library for Python web frameworks.
+
+## Features
+
+- Fixed Window
+- Sliding Window Log
+- Sliding Window Counter
+- Token Bucket
+- Flask Middleware
+- FastAPI Middleware
+
+## Installation
+
+```bash
+pip install ratelimiter-keshav

ratelimiter_keshav-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ratelimiter-keshav"
+version = "0.1.0"
+description = "A pluggable rate limiting library for Python web frameworks"
+readme = "README.md"
+requires-python = ">=3.10"
+
+dependencies = [
+    "redis>=4.0"
+]
+
+authors = [
+    {name = "Keshav Sharma"}
+]
+
+[project.optional-dependencies]
+
+flask = [
+    "flask>=2.0"
+]
+
+fastapi = [
+    "fastapi>=0.95",
+    "starlette"
+]
+
+dev = [
+    "pytest",
+    "pytest-cov",
+    "httpx"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["rate_limiter"]

ratelimiter_keshav-0.1.0/rate_limiter/DESIGN.md

@@ -0,0 +1,31 @@
+# Design Decisions
+
+## Storage
+
+Supported:
+- InMemoryStorage
+- RedisStorage
+
+Future:
+- PostgreSQL
+- DynamoDB
+
+## Thread Safety
+
+InMemoryStorage will use threading.Lock.
+
+Redis relies on atomic operations.
+
+## Clock Source
+
+Server time is authoritative.
+
+Client timestamps are ignored.
+
+## Rate Limits
+
+Supports:
+- Global limits
+- Route-specific limits
+
+Route-specific limits override global limits.

ratelimiter_keshav-0.1.0/rate_limiter/__init__.py

@@ -0,0 +1,4 @@
+from .core.limiter import RateLimiter
+from .algorithms.token_bucket import TokenBucket
+
+from .algorithms.fixed_window import FixedWindow

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/__init__.py

@@ -0,0 +1,4 @@
+from .fixed_window import FixedWindow
+from .token_bucket import TokenBucket
+from .sliding_window_log import SlidingWindowLog
+from .sliding_window_counter import SlidingWindowCounter

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class RateLimitAlgorithm(ABC):
+
+    @abstractmethod
+    def is_allowed(
+        self,
+        key: str,
+        store: Any
+    ) -> tuple[bool, dict[str, Any]]:
+        pass

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/fixed_window.py

@@ -0,0 +1,31 @@
+import time
+
+from .base import RateLimitAlgorithm
+
+
+class FixedWindow(RateLimitAlgorithm):
+
+    def __init__(
+        self,
+        limit: int,
+        window_seconds: int
+    ):
+        self.limit = limit
+        self.window = window_seconds
+
+    def is_allowed(
+        self,
+        key: str,
+        store
+    ) -> tuple[bool, dict]:
+        now = int(time.time())
+        window_key = f"{key}:{now // self.window}"
+        count = store.increment(window_key, ttl=self.window)
+        remaining = max(0, self.limit - count)
+        return count <= self.limit, {
+            "limit": self.limit,
+            "remaining": remaining,
+            "reset": (now // self.window + 1) * self.window
+        }
+    
+

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/sliding_window_counter.py

@@ -0,0 +1,90 @@
+import time
+
+from .base import RateLimitAlgorithm
+
+
+class SlidingWindowCounter(RateLimitAlgorithm):
+
+    def __init__(
+        self,
+        limit: int,
+        window_seconds: int
+    ):
+        self.limit = limit
+        self.window = window_seconds
+
+    def is_allowed(
+        self,
+        key: str,
+        store
+    ) -> tuple[bool, dict]:
+
+        now = time.time()
+
+        current_window = int(
+            now // self.window
+        )
+
+        current_key = (
+            f"{key}:{current_window}"
+        )
+
+        previous_key = (
+            f"{key}:{current_window - 1}"
+        )
+
+        current_count = (
+            store.get(current_key)
+            or 0
+        )
+
+        previous_count = (
+            store.get(previous_key)
+            or 0
+        )
+
+        elapsed = (
+            now % self.window
+        )
+
+        weight = (
+            self.window - elapsed
+        ) / self.window
+
+        estimated_count = (
+            current_count +
+            previous_count * weight
+        )
+
+        if estimated_count >= self.limit:
+
+            return False, {
+                "limit": self.limit,
+                "remaining": 0,
+                "reset":
+                (
+                    current_window + 1
+                ) * self.window
+            }
+
+        current_count = store.increment(
+            current_key,
+            ttl=self.window * 2
+        )
+
+        return True, {
+            "limit": self.limit,
+            "remaining":
+            max(
+                0,
+                int(
+                    self.limit -
+                    estimated_count -
+                    1
+                )
+            ),
+            "reset":
+            (
+                current_window + 1
+            ) * self.window
+        }

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/sliding_window_log.py

@@ -0,0 +1,67 @@
+import time
+
+from .base import RateLimitAlgorithm
+
+
+class SlidingWindowLog(RateLimitAlgorithm):
+
+    def __init__(
+        self,
+        limit: int,
+        window_seconds: int
+    ):
+        self.limit = limit
+        self.window = window_seconds
+
+    def is_allowed(
+        self,
+        key: str,
+        store
+    ) -> tuple[bool, dict]:
+
+        now = time.time()
+
+        timestamps = store.get(key)
+
+        if timestamps is None:
+            timestamps = []
+
+        timestamps = [
+            ts
+            for ts in timestamps
+            if now - ts < self.window
+        ]
+
+        if len(timestamps) >= self.limit:
+
+            store.set(
+                key,
+                timestamps,
+                ttl=self.window
+            )
+
+            return False, {
+                "limit": self.limit,
+                "remaining": 0,
+                "reset": int(
+                    timestamps[0] +
+                    self.window
+                )
+            }
+
+        timestamps.append(now)
+
+        store.set(
+            key,
+            timestamps,
+            ttl=self.window
+        )
+
+        return True, {
+            "limit": self.limit,
+            "remaining":
+                self.limit -
+                len(timestamps),
+            "reset":
+                int(now + self.window)
+        }

ratelimiter_keshav-0.1.0/rate_limiter/algorithms/token_bucket.py

@@ -0,0 +1,71 @@
+import time
+
+
+class TokenBucket:
+
+    def __init__(
+        self,
+        capacity: int,
+        refill_rate: float
+    ):
+        self.capacity = capacity
+        self.refill_rate = refill_rate
+
+    def is_allowed(
+        self,
+        key: str,
+        store
+    ) -> tuple[bool, dict]:
+
+        now = time.time()
+
+        bucket = store.get(key)
+
+        if bucket is None:
+            bucket = {
+                "tokens": self.capacity,
+                "last": now
+            }
+
+        elapsed = now - bucket["last"]
+
+        bucket["tokens"] = min(
+            self.capacity,
+            bucket["tokens"] +
+            elapsed * self.refill_rate
+        )
+
+        bucket["last"] = now
+
+        if bucket["tokens"] >= 1:
+
+            bucket["tokens"] -= 1
+
+            store.set(
+                key,
+                bucket
+            )
+
+            return True, {
+                "remaining":
+                int(bucket["tokens"])
+            }
+
+        store.set(
+            key,
+            bucket
+        )
+
+        retry_after = None
+
+        if self.refill_rate > 0:
+
+            retry_after = (
+                (1 - bucket["tokens"])
+                / self.refill_rate
+            )
+
+        return False, {
+            "retry_after":
+            retry_after
+        }

ratelimiter_keshav-0.1.0/rate_limiter/core/exceptions.py

@@ -0,0 +1,5 @@
+class RateLimitExceeded(Exception):
+
+    def __init__(self, info):
+        self.info = info
+        super().__init__("Rate limit exceeded")

ratelimiter_keshav-0.1.0/rate_limiter/core/limiter.py

@@ -0,0 +1,39 @@
+from functools import wraps
+class RateLimiter:
+
+    def __init__(
+        self,
+        algorithm,
+        storage,
+        key_func=None
+    ):
+        self.algorithm = algorithm
+        self.storage = storage
+        self.key_func = key_func
+
+    def check(self, key):
+        return self.algorithm.is_allowed(
+            key,
+            self.storage
+        )
+
+
+    def limit(self):
+
+        def decorator(func):
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+
+                allowed, meta = self.check("global")
+
+                if not allowed:
+                    raise Exception(
+                        "Rate limit exceeded"
+                    )
+
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator

ratelimiter_keshav-0.1.0/rate_limiter/core/models.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+@dataclass
+class RateLimitInfo:
+    allowed: bool
+    limit: int
+    remaining: int
+    reset: int | None = None
+    retry_after: float | None = None

ratelimiter_keshav-0.1.0/rate_limiter/examples/fastapi_demo.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+
+from rate_limiter.storage import (
+    InMemoryStorage
+)
+
+from rate_limiter.algorithms import (
+    FixedWindow
+)
+
+from rate_limiter.middleware import (
+    FastAPIRateLimiter
+)
+
+
+app = FastAPI()
+
+app.add_middleware(
+    FastAPIRateLimiter,
+    algorithm=FixedWindow(
+        limit=3,
+        window_seconds=60
+    ),
+    storage=InMemoryStorage()
+)
+
+
+@app.get("/")
+def home():
+
+    return {
+        "message":
+        "hello fastapi"
+    }

ratelimiter_keshav-0.1.0/rate_limiter/examples/flask_demo.py

@@ -0,0 +1,38 @@
+from flask import Flask
+
+from rate_limiter.storage import (
+    InMemoryStorage
+)
+
+from rate_limiter.algorithms import (
+    FixedWindow
+)
+
+from rate_limiter.middleware import (
+    FlaskRateLimiter
+)
+
+
+app = Flask(__name__)
+
+limiter = FlaskRateLimiter(
+    algorithm=FixedWindow(
+        limit=3,
+        window_seconds=60
+    ),
+    storage=InMemoryStorage()
+)
+
+
+@app.route("/")
+@limiter.limit()
+def home():
+
+    return {
+        "message":
+        "hello world"
+    }
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

ratelimiter_keshav-0.1.0/rate_limiter/middleware/__init__.py

@@ -0,0 +1,2 @@
+from .flask_middleware import FlaskRateLimiter
+from .fastapi_middleware import FastAPIRateLimiter