ratelimit-io 0.1.0__tar.gz

ratelimit_io-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bogdan
+
+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.

ratelimit_io-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: ratelimit-io
+Version: 0.1.0
+Summary: Flexible bidirectional rate limiting library with redis backend
+Home-page: https://github.com/bagowix/ratelimit-io
+License: MIT
+Keywords: asyncio,rate-limiting,I/O,redis,aioredis
+Author: Galushko Bogdan
+Author-email: galushko355@gmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: redis (>=5.2.1,<6.0.0)
+Project-URL: Repository, https://github.com/bagowix/ratelimit-io
+Description-Content-Type: text/markdown
+
+# RatelimitIO
+
+A Python library for rate limiting, supporting both synchronous and asynchronous paradigms. Built on Redis, this library provides decorators, context managers, and easy integration with APIs to manage incoming and outgoing request limits effectively.
+
+#### Project Information
+[![Tests & Lint](https://github.com/bagowix/ratelimit-io/actions/workflows/actions.yml/badge.svg)](https://github.com/bagowix/ratelimit-io/actions/workflows/actions.yml)
+[![Test Coverage](https://img.shields.io/badge/dynamic/json?color=blueviolet&label=coverage&query=%24.totals.percent_covered_display&suffix=%25&url=https%3A%2F%2Fraw.githubusercontent.com%2Fbagowix%2Fratelimit-io%2Fmain%2Fcoverage.json)](https://github.com/bagowix/ratelimit-io/blob/main/coverage.json)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ratelimit-io)](https://pypi.org/project/ratelimit-io/)
+[![License](https://img.shields.io/pypi/l/ratelimitio)](LICENSE)
+
+---
+
+## Features
+
+- **Synchronous and Asynchronous Support**: Works seamlessly in both paradigms.
+- **Redis Backend**: Leverages Redis for fast and scalable rate limiting.
+- **Flexible API**:
+  - Use as a **decorator** for methods or functions.
+  - Use as a **context manager**.
+  - Integrate directly into API clients or middlewares.
+- **Customizable Rate Limits**: Specify limits per key, time period, and requests.
+- **Robust Lua Script**: Efficient and atomic rate limiting logic.
+
+---
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install ratelimit-io
+```
+
+## Quick Start
+
+### Using as a Synchronous Decorator
+
+```python
+from ratelimit_io import RatelimitIO, LimitSpec
+from redis import Redis
+
+redis_client = Redis(host="localhost", port=6379)
+limiter = RatelimitIO(backend=redis_client)
+
+@limiter(LimitSpec(requests=10, seconds=60), unique_key="user:123")
+def fetch_data():
+    return "Request succeeded!"
+
+# Use the decorated function
+fetch_data()
+```
+
+### Using as a Asynchronous Decorator
+
+```python
+from ratelimit_io import RatelimitIO, LimitSpec
+from redis.asyncio import Redis as AsyncRedis
+
+async_redis_client = AsyncRedis(host="localhost", port=6379)
+async_limiter = RatelimitIO(backend=async_redis_client)
+
+@async_limiter(LimitSpec(requests=10, seconds=60), unique_key="user:123")
+async def fetch_data():
+    return "Request succeeded!"
+
+# Use the decorated function
+await fetch_data()
+```
+
+### Using as a Synchronous Context Manager
+
+```python
+with limiter:
+    limiter.wait("user:456", LimitSpec(requests=5, seconds=10))
+```
+
+### Using as a Asynchronous Context Manager
+
+```python
+async with limiter:
+    await limiter.a_wait("user:456", LimitSpec(requests=5, seconds=10))
+```
+
+## License
+
+[MIT](https://github.com/bagowix/ratelimit-io/blob/main/LICENSE)
+
+## Contribution
+
+Contributions are welcome! Follow the Contribution Guide for details.
+

ratelimit_io-0.1.0/README.md

@@ -0,0 +1,90 @@
+# RatelimitIO
+
+A Python library for rate limiting, supporting both synchronous and asynchronous paradigms. Built on Redis, this library provides decorators, context managers, and easy integration with APIs to manage incoming and outgoing request limits effectively.
+
+#### Project Information
+[![Tests & Lint](https://github.com/bagowix/ratelimit-io/actions/workflows/actions.yml/badge.svg)](https://github.com/bagowix/ratelimit-io/actions/workflows/actions.yml)
+[![Test Coverage](https://img.shields.io/badge/dynamic/json?color=blueviolet&label=coverage&query=%24.totals.percent_covered_display&suffix=%25&url=https%3A%2F%2Fraw.githubusercontent.com%2Fbagowix%2Fratelimit-io%2Fmain%2Fcoverage.json)](https://github.com/bagowix/ratelimit-io/blob/main/coverage.json)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ratelimit-io)](https://pypi.org/project/ratelimit-io/)
+[![License](https://img.shields.io/pypi/l/ratelimitio)](LICENSE)
+
+---
+
+## Features
+
+- **Synchronous and Asynchronous Support**: Works seamlessly in both paradigms.
+- **Redis Backend**: Leverages Redis for fast and scalable rate limiting.
+- **Flexible API**:
+  - Use as a **decorator** for methods or functions.
+  - Use as a **context manager**.
+  - Integrate directly into API clients or middlewares.
+- **Customizable Rate Limits**: Specify limits per key, time period, and requests.
+- **Robust Lua Script**: Efficient and atomic rate limiting logic.
+
+---
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install ratelimit-io
+```
+
+## Quick Start
+
+### Using as a Synchronous Decorator
+
+```python
+from ratelimit_io import RatelimitIO, LimitSpec
+from redis import Redis
+
+redis_client = Redis(host="localhost", port=6379)
+limiter = RatelimitIO(backend=redis_client)
+
+@limiter(LimitSpec(requests=10, seconds=60), unique_key="user:123")
+def fetch_data():
+    return "Request succeeded!"
+
+# Use the decorated function
+fetch_data()
+```
+
+### Using as a Asynchronous Decorator
+
+```python
+from ratelimit_io import RatelimitIO, LimitSpec
+from redis.asyncio import Redis as AsyncRedis
+
+async_redis_client = AsyncRedis(host="localhost", port=6379)
+async_limiter = RatelimitIO(backend=async_redis_client)
+
+@async_limiter(LimitSpec(requests=10, seconds=60), unique_key="user:123")
+async def fetch_data():
+    return "Request succeeded!"
+
+# Use the decorated function
+await fetch_data()
+```
+
+### Using as a Synchronous Context Manager
+
+```python
+with limiter:
+    limiter.wait("user:456", LimitSpec(requests=5, seconds=10))
+```
+
+### Using as a Asynchronous Context Manager
+
+```python
+async with limiter:
+    await limiter.a_wait("user:456", LimitSpec(requests=5, seconds=10))
+```
+
+## License
+
+[MIT](https://github.com/bagowix/ratelimit-io/blob/main/LICENSE)
+
+## Contribution
+
+Contributions are welcome! Follow the Contribution Guide for details.

ratelimit_io-0.1.0/pyproject.toml

@@ -0,0 +1,100 @@
+[tool.poetry]
+name = "ratelimit-io"
+version = "0.1.0"
+description = "Flexible bidirectional rate limiting library with redis backend"
+authors = ["Galushko Bogdan <galushko355@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "ratelimit_io"}]
+
+package-mode = true
+
+repository = "https://github.com/bagowix/ratelimit-io"
+
+keywords = [
+    "asyncio",
+    "rate-limiting",
+    "I/O",
+    "redis",
+    "aioredis",
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+redis = "^5.2.1"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.14.1"
+ruff = "^0.9.1"
+pytest = "^8.3.4"
+pytest-cov = "^5.0.0"
+pytest-asyncio = "^0.18.3"
+pre-commit = "^3.5"
+fakeredis = "^2.26.2"
+
+[tool.ruff]
+line-length = 79
+target-version = "py38"
+
+[tool.ruff.lint]
+    ignore = [
+        "PT001",
+        "PT023",
+        "SIM103",
+    ]
+    select = [
+        "B",    # flake8-bugbear,
+        "C4",   # flake8-comprehensions
+        "E",    # pycodestyle error
+        "F",    # pyflakes
+        "SIM",  # flake8-simplify
+        "T20",  # flake8-print
+        "W",    # pycodestyle warning
+        "UP",   # pyupgrade
+        "I",    # isort
+    ]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 12
+
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = [
+    "F401",
+    "F403",
+]
+"test_*.py" = [
+    "S101",
+    "E501",
+    "ANN201",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = [
+    "ratelimit_io",
+]
+known-third-party = [
+    "asyncio",
+    "hashlib",
+    "redis",
+    "pytest",
+    "pytest-asyncio",
+]
+section-order = [
+    "future",
+    "standard-library",
+    "third-party",
+    "first-party",
+    "local-folder",
+]
+force-single-line = true
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[build-system]
+requires = ["poetry-core<=1.8.5"]
+build-backend = "poetry.core.masonry.api"

ratelimit_io-0.1.0/ratelimit_io/__init__.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from typing import Union
+
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
+from typing_extensions import TypeAlias
+
+from ratelimit_io.rate_limit import RatelimitIO  # noqa
+
+
+class RatelimitIOError(Exception):
+    """Raised when the rate limit is exceeded."""
+
+
+class LimitSpec:
+    """
+    Specifies the number of requests allowed in a time frame.
+
+    Attributes:
+        requests (int): Maximum number of requests.
+        seconds (Optional[int]): Time frame in seconds.
+        minutes (Optional[int]): Time frame in minutes.
+        hours (Optional[int]): Time frame in hours.
+    """
+
+    def __init__(
+        self,
+        requests: int,
+        seconds: Optional[int] = None,
+        minutes: Optional[int] = None,
+        hours: Optional[int] = None,
+    ):
+        if requests <= 0:
+            raise ValueError("Requests must be greater than 0.")
+
+        self.requests = requests
+        self.seconds = seconds
+        self.minutes = minutes
+        self.hours = hours
+
+        if self.total_seconds() == 0:
+            raise ValueError(
+                "At least one time frame "
+                "(seconds, minutes, or hours) must be provided."
+            )
+
+    def total_seconds(self) -> int:
+        """
+        Calculates the total time frame in seconds.
+
+        Returns:
+            int: Total time in seconds.
+        """
+        total = 0
+        if self.seconds:
+            total += self.seconds
+        if self.minutes:
+            total += self.minutes * 60
+        if self.hours:
+            total += self.hours * 3600
+        return total
+
+    def __str__(self) -> str:
+        return f"{self.requests}/{self.total_seconds()}s"
+
+
+RedisBackend: TypeAlias = Union[Redis, AsyncRedis]

ratelimit_io-0.1.0/ratelimit_io/rate_limit.py

@@ -0,0 +1,396 @@
+import time
+from typing import Callable
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import asyncio
+import hashlib
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
+from redis.exceptions import NoScriptError
+from typing_extensions import TypeAlias
+
+
+class RatelimitIOError(Exception):
+    """Raised when the rate limit is exceeded."""
+
+
+class LimitSpec:
+    """
+    Specifies the number of requests allowed in a time frame.
+
+    Attributes:
+        requests (int): Maximum number of requests.
+        seconds (Optional[int]): Time frame in seconds.
+        minutes (Optional[int]): Time frame in minutes.
+        hours (Optional[int]): Time frame in hours.
+    """
+
+    def __init__(
+        self,
+        requests: int,
+        seconds: Optional[int] = None,
+        minutes: Optional[int] = None,
+        hours: Optional[int] = None,
+    ):
+        if requests <= 0:
+            raise ValueError("Requests must be greater than 0.")
+
+        self.requests = requests
+        self.seconds = seconds
+        self.minutes = minutes
+        self.hours = hours
+
+        if self.total_seconds() == 0:
+            raise ValueError(
+                "At least one time frame "
+                "(seconds, minutes, or hours) must be provided."
+            )
+
+    def total_seconds(self) -> int:
+        """
+        Calculates the total time frame in seconds.
+
+        Returns:
+            int: Total time in seconds.
+        """
+        total = 0
+        if self.seconds:
+            total += self.seconds
+        if self.minutes:
+            total += self.minutes * 60
+        if self.hours:
+            total += self.hours * 3600
+        return total
+
+    def __str__(self) -> str:
+        return f"{self.requests}/{self.total_seconds()}s"
+
+
+RedisBackend: TypeAlias = Union[Redis, AsyncRedis]
+
+
+class RatelimitIO:
+    """Rate limiter for managing incoming and outgoing request limits."""
+
+    def __init__(
+        self,
+        backend: RedisBackend,
+        base_url: Optional[str] = None,
+        base_limit: Optional[LimitSpec] = None,
+    ):
+        """
+        Initializes the RatelimitIO instance.
+
+        Args:
+            backend (Redis | AsyncRedis): Redis backend instance.
+            base_url (Optional[str]): Base URL for outgoing request limits.
+            base_limit (Optional[LimitSpec]): Default rate
+                limit for the base URL.
+        """
+        if not isinstance(backend, (Redis, AsyncRedis)):
+            raise RuntimeError("Unsupported Redis backend.")
+
+        self.backend = backend
+        self.base_url = base_url
+        self.base_limit = base_limit
+
+        self._lua_script = b"""
+            local current = redis.call("GET", KEYS[1])
+            local limit = tonumber(ARGV[1])
+            local ttl = tonumber(ARGV[2])
+
+            if current and tonumber(current) >= limit then
+                return 0
+            else
+                local new_count = redis.call("INCR", KEYS[1])
+                if new_count == 1 then
+                    redis.call("EXPIRE", KEYS[1], ttl)
+                end
+                return 1
+            end
+        """
+        self._lua_script_hash = hashlib.sha1(self._lua_script).hexdigest()
+        self._script_loaded = False
+
+    def __call__(
+        self, limit_spec: LimitSpec, unique_key: Optional[str] = None
+    ) -> Callable:
+        """
+        Decorator for applying rate limits to functions.
+
+        Args:
+            limit_spec (LimitSpec): Rate limit specification.
+            unique_key (Optional[str]): Optional unique key for rate limiting.
+
+        Returns:
+            Callable: Decorated function.
+        """
+
+        def decorator(func: Callable) -> Callable:
+            async def async_wrapper(*args, **kwargs):
+                key = unique_key or kwargs.get("ip", "unknown_ip")
+                try:
+                    await self.a_wait(f"incoming:{key}", limit_spec)
+                except RatelimitIOError as exc:
+                    raise RuntimeError(
+                        f"Rate limit exceeded in {func.__name__}: {str(exc)}"
+                    ) from exc
+                return await func(*args, **kwargs)
+
+            def sync_wrapper(*args, **kwargs):
+                key = unique_key or kwargs.get("ip", "unknown_ip")
+                try:
+                    self.wait(f"incoming:{key}", limit_spec)
+                except RatelimitIOError as exc:
+                    raise RuntimeError(
+                        f"Rate limit exceeded in {func.__name__}: {str(exc)}"
+                    ) from exc
+                return func(*args, **kwargs)
+
+            return (
+                async_wrapper
+                if asyncio.iscoroutinefunction(func)
+                else sync_wrapper
+            )
+
+        return decorator
+
+    def __enter__(self) -> "RatelimitIO":
+        """Synchronous context manager."""
+        self._ensure_script_loaded_sync()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        """No cleanup is necessary for this context manager."""
+        pass
+
+    async def __aenter__(self) -> "RatelimitIO":
+        """Context manager for async operations."""
+        await self._ensure_script_loaded_async()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+        """No cleanup is necessary for this context manager."""
+        pass
+
+    def wait(
+        self,
+        key: Optional[str] = None,
+        limit_spec: Optional[LimitSpec] = None,
+        max_wait_time: float = 10.0,
+        backoff_start: float = 0.01,
+        backoff_max: float = 0.1,
+    ) -> None:
+        """
+        Synchronous rate limiting. Waits if the limit is exceeded.
+
+        Args:
+            key (Optional[str]): Unique identifier for the rate limit.
+                Defaults to `base_url`.
+            limit_spec (Optional[LimitSpec]): Rate specification.
+                Defaults to `base_limit`.
+            max_wait_time (float): Maximum wait time in seconds
+                before raising an error.
+            backoff_start (float): Initial backoff delay in seconds.
+            backoff_max (float): Maximum backoff delay in seconds.
+
+        Raises:
+            RatelimitIOError: If the rate limit is exceeded and
+                max wait time is reached.
+        """
+        self._ensure_script_loaded_sync()
+
+        key, limit_spec = self._prepare_key_and_limit(key, limit_spec)
+        start_time = time.time()
+        backoff = backoff_start
+
+        while not self._enforce_limit_sync(key, limit_spec):
+            if time.time() - start_time > max_wait_time:
+                raise RatelimitIOError(
+                    f"Rate limit exceeded for {key}, wait time exceeded."
+                )
+            time.sleep(backoff)
+            backoff = min(backoff * 2, backoff_max)
+
+    async def a_wait(
+        self,
+        key: Optional[str] = None,
+        limit_spec: Optional[LimitSpec] = None,
+        max_wait_time: float = 10.0,
+        backoff_start: float = 0.01,
+        backoff_max: float = 0.1,
+    ) -> None:
+        """
+        Asynchronous rate limiting. Waits if the limit is exceeded.
+
+        Args:
+            key (Optional[str]): Unique identifier for the rate limit.
+                Defaults to `base_url`.
+            limit_spec (Optional[LimitSpec]): Rate specification.
+                Defaults to `base_limit`.
+            max_wait_time (float): Maximum wait time in seconds
+                before raising an error.
+            backoff_start (float): Initial backoff delay in seconds.
+            backoff_max (float): Maximum backoff delay in seconds.
+
+        Raises:
+            RatelimitIOError: If the rate limit is exceeded and
+                max wait time is reached.
+        """
+        await self._ensure_script_loaded_async()
+
+        key, limit_spec = self._prepare_key_and_limit(key, limit_spec)
+        start_time = time.time()
+        backoff = backoff_start
+
+        while not await self._enforce_limit_async(key, limit_spec):
+            if time.time() - start_time > max_wait_time:
+                raise RatelimitIOError(
+                    f"Rate limit exceeded for {key}, wait time exceeded."
+                )
+            await asyncio.sleep(backoff)
+            backoff = min(backoff * 2, backoff_max)
+
+    def _prepare_key_and_limit(
+        self, key: Optional[str] = None, limit_spec: Optional[LimitSpec] = None
+    ) -> Tuple[str, LimitSpec]:
+        """
+        Prepares the key and limit specification, falling back to
+            defaults if needed.
+
+        Args:
+            key (Optional[str]): Unique identifier for the rate limit.
+            limit_spec (Optional[LimitSpec]): Limit specification.
+
+        Returns:
+            tuple[str, LimitSpec]: Prepared key and rate specification.
+
+        Raises:
+            ValueError: If neither key nor base settings are provided.
+        """
+        if not (limit_spec or self.base_limit):
+            raise ValueError("limit_spec or self.base_limit must be provided.")
+
+        requests_for_key: str = (
+            str(limit_spec.requests)
+            if limit_spec
+            else str(self.base_limit.requests)  # type: ignore
+        )
+        time_for_key: str = (
+            str(limit_spec.total_seconds())
+            if limit_spec
+            else str(self.base_limit.total_seconds())  # type: ignore
+        )
+
+        key = key or (
+            f"outgoing:ratelimit-io:{self.base_url}:"
+            f"requests:{requests_for_key}:"
+            f"time:{time_for_key}"
+        )
+        limit_spec = limit_spec or self.base_limit
+
+        if not key or not limit_spec:
+            raise ValueError("Key and limit_spec must be provided.")
+        return key, limit_spec
+
+    def _enforce_limit_sync(self, key: str, limit_spec: LimitSpec) -> bool:
+        """
+        Enforces the rate limit synchronously.
+
+        Args:
+            key (str): Unique identifier for the rate limit.
+            limit_spec (LimitSpec): Limit specification.
+
+        Returns:
+            bool: True if the request is allowed, False otherwise.
+        """
+        try:
+            allowed = self.backend.evalsha(
+                self._lua_script_hash,
+                1,
+                self._generate_key(key),
+                str(limit_spec.requests),
+                str(limit_spec.total_seconds()),
+            )
+            return bool(allowed)
+        except NoScriptError:
+            self._ensure_script_loaded_sync()
+            try:
+                allowed = self.backend.evalsha(
+                    self._lua_script_hash,
+                    1,
+                    self._generate_key(key),
+                    str(limit_spec.requests),
+                    str(limit_spec.total_seconds()),
+                )
+                return bool(allowed)
+            except NoScriptError as exc:
+                raise RuntimeError(
+                    "Failed to load Lua script into Redis."
+                ) from exc
+
+    async def _enforce_limit_async(
+        self, key: str, limit_spec: LimitSpec
+    ) -> bool:
+        """
+        Enforces the rate limit asynchronously.
+
+        Args:
+            key (str): Unique identifier for the rate limit.
+            limit_spec (LimitSpec): Limit specification.
+
+        Returns:
+            bool: True if the request is allowed, False otherwise.
+        """
+        try:
+            allowed = await self.backend.evalsha(
+                self._lua_script_hash,
+                1,
+                self._generate_key(key),
+                str(limit_spec.requests),
+                str(limit_spec.total_seconds()),
+            )
+            return bool(allowed)
+        except NoScriptError:
+            # Attempt to load the script and retry once
+            await self._ensure_script_loaded_async()
+            try:
+                allowed = await self.backend.evalsha(
+                    self._lua_script_hash,
+                    1,
+                    self._generate_key(key),
+                    str(limit_spec.requests),
+                    str(limit_spec.total_seconds()),
+                )
+                return bool(allowed)
+            except NoScriptError as exc:
+                # If script loading fails again, raise an error
+                raise RuntimeError(
+                    "Failed to load Lua script into Redis."
+                ) from exc
+
+    def _generate_key(self, identifier: str) -> str:
+        """
+        Generates a unique Redis key for rate limiting.
+
+        Args:
+            identifier (str): Unique identifier for the rate limit.
+
+        Returns:
+            str: Hashed Redis key.
+        """
+        return hashlib.sha256(identifier.encode("utf-8")).hexdigest()
+
+    def _ensure_script_loaded_sync(self) -> None:
+        """Ensures the Lua script is loaded into Redis (synchronously)."""
+        if not self.backend.script_exists(self._lua_script_hash)[0]:
+            self.backend.script_load(self._lua_script)
+        self._script_loaded = True
+
+    async def _ensure_script_loaded_async(self) -> None:
+        """Ensures the Lua script is loaded into Redis (asynchronously)."""
+        if not (await self.backend.script_exists(self._lua_script_hash))[0]:
+            await self.backend.script_load(self._lua_script)
+        self._script_loaded = True