pythonboot-redis 0.1.0__tar.gz

pythonboot_redis-0.1.0/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Tools
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Node.js and VitePress generated files
+node_modules/
+viteDocs/docs/.vitepress/cache/
+viteDocs/docs/.vitepress/dist/
+
+# IDE and OS
+.idea/
+.vscode/
+.DS_Store

pythonboot_redis-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: pythonboot-redis
+Version: 0.1.0
+Summary: Native redis-py clients, utilities and distributed locks for PythonBoot
+Requires-Python: >=3.12
+Requires-Dist: pydantic-settings<3,>=2.7
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pythonboot<0.2,>=0.1.0
+Requires-Dist: redis<8,>=5.0
+Description-Content-Type: text/markdown
+
+# pythonboot-redis
+
+PythonBoot 的 redis-py 集成实现包。分发名为 `pythonboot-redis`，导入名为
+`pythonboot_redis`；应用推荐安装依赖聚合包 `pythonboot-starter-redis`。
+
+- Configuration Properties 绑定 `pythonboot.redis` 并注册 `RedisProperties` Bean。
+- 默认同步模式，可选择异步；自动注入原生 `RedisClient` / `AsyncRedisClient`。
+- 客户端类别名直接指向 redis-py 的 Redis 类，没有模板或代理包装。
+- `RedisUtil` / `AsyncRedisUtil` 提供字符串、TTL、计数器、Hash、List、Set、有序集合操作。
+- 原生分布式锁支持获取、释放、续期及归属判断；不通过直接删除键解锁。
+- 工具类从当前 ContextVar 绑定的容器解析客户端，不持有全局客户端；支持命名 Bean。
+- 默认池和客户端接入容器生命周期，异步关闭由容器等待。应用 Bean 优先。
+- 创建对象不连接 Redis；首次命令才连接。异常按原生语义抛出，不静默返回默认值。
+
+```yaml
+pythonboot:
+  redis:
+    url: redis://localhost:6379/0
+    mode: sync
+    decode_responses: true
+```
+
+```python
+from pythonboot import autowired, service
+from pythonboot_redis import RedisClient, RedisUtil
+
+@service
+class CacheService:
+    redis_client: RedisClient = autowired()
+
+    def save(self, value: str) -> None:
+        self.redis_client.set("example:value", value, ex=60)
+
+RedisUtil.set("example:value", "hello", ex=60)
+value = RedisUtil.get("example:value")
+RedisUtil.rpush("example:list", "a", "b")
+values = RedisUtil.lrange("example:list")
+client = RedisUtil.get_client()
+```
+
+静态调用需要在已绑定容器的请求／生命周期中，独立任务使用 `ContextUtil.use(context)`。
+异步模式注入 `AsyncRedisClient`，使用 `await AsyncRedisUtil.get(...)`；
+不要在异步方法中直接执行同步客户端命令。
+工具锁默认租期 30 秒、获取等待 5 秒；每次操作创建独立锁对象，成功获取后在 finally 中释放。
+没有自动续期，超过租期需要业务显式续期；释放过期或非本方持有的锁会抛出原生异常。
+
+完整配置、公共 API 和锁示例见 [中文文档](../../viteDocs/docs/zh/redis.md)、
+[English documentation](../../viteDocs/docs/en/redis.md) 和 [示例](../../examples/redis/README.md)。
+
+## English
+
+The implementation distribution is `pythonboot-redis`; import `pythonboot_redis`.
+Install `pythonboot-starter-redis` in applications. Configuration Properties bind `pythonboot.redis`.
+Native client aliases support concrete-class Bean injection; sync is the default, async is optional.
+Static utilities resolve the current application context and provide common commands and native locks.
+Default clients and pools are lifecycle-managed without connecting during import or construction.
+Application Beans override defaults; providers declare cleanup for custom resources.
+Locks use native ownership tokens, bounded acquisition, explicit renewal, and atomic release.
+There is no automatic renewal. Use a distinct lock object per task or thread and release in finally.
+Standalone tasks bind their container through `ContextUtil.use(context)`.
+
+
+完整分层应用见 [全量 Starter 示例](../../example/README.md)，包含全部 Starter、PostgreSQL／Redis 和同步／异步 HTTP 用法。
+See the [complete Starter application](../../example/README.md) for all Starters and sync/async HTTP examples.

pythonboot_redis-0.1.0/README.md

@@ -0,0 +1,64 @@
+# pythonboot-redis
+
+PythonBoot 的 redis-py 集成实现包。分发名为 `pythonboot-redis`，导入名为
+`pythonboot_redis`；应用推荐安装依赖聚合包 `pythonboot-starter-redis`。
+
+- Configuration Properties 绑定 `pythonboot.redis` 并注册 `RedisProperties` Bean。
+- 默认同步模式，可选择异步；自动注入原生 `RedisClient` / `AsyncRedisClient`。
+- 客户端类别名直接指向 redis-py 的 Redis 类，没有模板或代理包装。
+- `RedisUtil` / `AsyncRedisUtil` 提供字符串、TTL、计数器、Hash、List、Set、有序集合操作。
+- 原生分布式锁支持获取、释放、续期及归属判断；不通过直接删除键解锁。
+- 工具类从当前 ContextVar 绑定的容器解析客户端，不持有全局客户端；支持命名 Bean。
+- 默认池和客户端接入容器生命周期，异步关闭由容器等待。应用 Bean 优先。
+- 创建对象不连接 Redis；首次命令才连接。异常按原生语义抛出，不静默返回默认值。
+
+```yaml
+pythonboot:
+  redis:
+    url: redis://localhost:6379/0
+    mode: sync
+    decode_responses: true
+```
+
+```python
+from pythonboot import autowired, service
+from pythonboot_redis import RedisClient, RedisUtil
+
+@service
+class CacheService:
+    redis_client: RedisClient = autowired()
+
+    def save(self, value: str) -> None:
+        self.redis_client.set("example:value", value, ex=60)
+
+RedisUtil.set("example:value", "hello", ex=60)
+value = RedisUtil.get("example:value")
+RedisUtil.rpush("example:list", "a", "b")
+values = RedisUtil.lrange("example:list")
+client = RedisUtil.get_client()
+```
+
+静态调用需要在已绑定容器的请求／生命周期中，独立任务使用 `ContextUtil.use(context)`。
+异步模式注入 `AsyncRedisClient`，使用 `await AsyncRedisUtil.get(...)`；
+不要在异步方法中直接执行同步客户端命令。
+工具锁默认租期 30 秒、获取等待 5 秒；每次操作创建独立锁对象，成功获取后在 finally 中释放。
+没有自动续期，超过租期需要业务显式续期；释放过期或非本方持有的锁会抛出原生异常。
+
+完整配置、公共 API 和锁示例见 [中文文档](../../viteDocs/docs/zh/redis.md)、
+[English documentation](../../viteDocs/docs/en/redis.md) 和 [示例](../../examples/redis/README.md)。
+
+## English
+
+The implementation distribution is `pythonboot-redis`; import `pythonboot_redis`.
+Install `pythonboot-starter-redis` in applications. Configuration Properties bind `pythonboot.redis`.
+Native client aliases support concrete-class Bean injection; sync is the default, async is optional.
+Static utilities resolve the current application context and provide common commands and native locks.
+Default clients and pools are lifecycle-managed without connecting during import or construction.
+Application Beans override defaults; providers declare cleanup for custom resources.
+Locks use native ownership tokens, bounded acquisition, explicit renewal, and atomic release.
+There is no automatic renewal. Use a distinct lock object per task or thread and release in finally.
+Standalone tasks bind their container through `ContextUtil.use(context)`.
+
+
+完整分层应用见 [全量 Starter 示例](../../example/README.md)，包含全部 Starter、PostgreSQL／Redis 和同步／异步 HTTP 用法。
+See the [complete Starter application](../../example/README.md) for all Starters and sync/async HTTP examples.

pythonboot_redis-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pythonboot-redis"
+version = "0.1.0"
+description = "Native redis-py clients, utilities and distributed locks for PythonBoot"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pythonboot>=0.1.0,<0.2",
+    "redis>=5.0,<8",
+    "pydantic>=2.10,<3",
+    "pydantic-settings>=2.7,<3",
+]
+
+[project.entry-points."pythonboot.autoconfigure"]
+redis = "pythonboot_redis.configuration"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pythonboot_redis"]

pythonboot_redis-0.1.0/src/pythonboot_redis/__init__.py

@@ -0,0 +1,8 @@
+"""Public native Redis clients, configuration properties, and static utilities."""
+
+from pythonboot_redis.async_util import AsyncRedisUtil
+from pythonboot_redis.client import AsyncRedisClient, RedisClient
+from pythonboot_redis.properties import RedisProperties
+from pythonboot_redis.util import RedisUtil
+
+__all__ = ["RedisClient", "AsyncRedisClient", "RedisProperties", "RedisUtil", "AsyncRedisUtil"]

pythonboot_redis-0.1.0/src/pythonboot_redis/async_util.py

@@ -0,0 +1,151 @@
+"""Asynchronous static Redis operations resolved against the current application context."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import timedelta
+from math import isfinite
+
+from redis.asyncio.lock import Lock
+
+from pythonboot import ContextUtil
+from pythonboot_redis.client import AsyncRedisClient, RedisKey, RedisResult, RedisValue
+from pythonboot_redis.util import validate_lock_options
+
+
+class AsyncRedisUtil:
+    """Awaitable Redis helpers without blocking calls or globally cached clients."""
+
+    @staticmethod
+    async def get_client(*, name: str | None = None, qualifier: str | None = None) -> AsyncRedisClient:
+        return await ContextUtil.aget_bean(AsyncRedisClient, name=name, qualifier=qualifier)
+
+    @staticmethod
+    async def get(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return await (await AsyncRedisUtil.get_client(name=name)).get(key)
+
+    @staticmethod
+    async def set(
+        key: RedisKey, value: RedisValue, *, ex: int | timedelta | None = None,
+        px: int | timedelta | None = None, nx: bool = False, xx: bool = False,
+        keepttl: bool = False, name: str | None = None,
+    ) -> bool | None:
+        client = await AsyncRedisUtil.get_client(name=name)
+        return await client.set(key, value, ex=ex, px=px, nx=nx, xx=xx, keepttl=keepttl)
+
+    @staticmethod
+    async def delete(*keys: RedisKey, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).delete(*keys)
+
+    @staticmethod
+    async def exists(*keys: RedisKey, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).exists(*keys)
+
+    @staticmethod
+    async def expire(key: RedisKey, seconds: int | timedelta, *, name: str | None = None) -> bool:
+        return await (await AsyncRedisUtil.get_client(name=name)).expire(key, seconds)
+
+    @staticmethod
+    async def ttl(key: RedisKey, *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).ttl(key)
+
+    @staticmethod
+    async def incr(key: RedisKey, amount: int = 1, *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).incr(key, amount)
+
+    @staticmethod
+    async def decr(key: RedisKey, amount: int = 1, *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).decr(key, amount)
+
+    @staticmethod
+    async def hset(key: RedisKey, mapping: Mapping[RedisKey, RedisValue], *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).hset(key, mapping=mapping)
+
+    @staticmethod
+    async def hget(key: RedisKey, field: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return await (await AsyncRedisUtil.get_client(name=name)).hget(key, field)
+
+    @staticmethod
+    async def hgetall(key: RedisKey, *, name: str | None = None) -> dict[RedisResult, RedisResult]:
+        return await (await AsyncRedisUtil.get_client(name=name)).hgetall(key)
+
+    @staticmethod
+    async def hdel(key: RedisKey, *fields: RedisKey, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).hdel(key, *fields)
+
+    @staticmethod
+    async def lpush(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).lpush(key, *values)
+
+    @staticmethod
+    async def rpush(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).rpush(key, *values)
+
+    @staticmethod
+    async def lpop(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return await (await AsyncRedisUtil.get_client(name=name)).lpop(key)
+
+    @staticmethod
+    async def rpop(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return await (await AsyncRedisUtil.get_client(name=name)).rpop(key)
+
+    @staticmethod
+    async def lrange(key: RedisKey, start: int = 0, end: int = -1, *, name: str | None = None) -> list[RedisResult]:
+        return await (await AsyncRedisUtil.get_client(name=name)).lrange(key, start, end)
+
+    @staticmethod
+    async def llen(key: RedisKey, *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).llen(key)
+
+    @staticmethod
+    async def sadd(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).sadd(key, *values)
+
+    @staticmethod
+    async def smembers(key: RedisKey, *, name: str | None = None) -> set[RedisResult]:
+        return await (await AsyncRedisUtil.get_client(name=name)).smembers(key)
+
+    @staticmethod
+    async def srem(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).srem(key, *values)
+
+    @staticmethod
+    async def zadd(key: RedisKey, mapping: Mapping[RedisKey, float], *, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).zadd(key, mapping)
+
+    @staticmethod
+    async def zrange(key: RedisKey, start: int = 0, end: int = -1, *, name: str | None = None) -> list[RedisResult]:
+        return await (await AsyncRedisUtil.get_client(name=name)).zrange(key, start, end)
+
+    @staticmethod
+    async def zrem(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return await (await AsyncRedisUtil.get_client(name=name)).zrem(key, *values)
+
+    @staticmethod
+    async def get_lock(
+        key: RedisKey, *, timeout: float = 30, blocking_timeout: float = 5,
+        sleep: float = 0.1, thread_local: bool = True, name: str | None = None,
+    ) -> Lock:
+        validate_lock_options(timeout, blocking_timeout, sleep)
+        client = await AsyncRedisUtil.get_client(name=name)
+        return client.lock(
+            key, timeout=timeout, blocking_timeout=blocking_timeout, sleep=sleep, thread_local=thread_local,
+        )
+
+    @staticmethod
+    async def acquire_lock(lock: Lock, *, blocking: bool = True) -> bool:
+        return await lock.acquire(blocking=blocking)
+
+    @staticmethod
+    async def release_lock(lock: Lock) -> None:
+        await lock.release()
+
+    @staticmethod
+    async def extend_lock(lock: Lock, seconds: float, *, replace_ttl: bool = False) -> bool:
+        if not isfinite(seconds) or seconds <= 0:
+            raise ValueError("Lock extension must be positive")
+        return await lock.extend(seconds, replace_ttl=replace_ttl)
+
+    @staticmethod
+    async def lock_owned(lock: Lock) -> bool:
+        return await lock.owned()

pythonboot_redis-0.1.0/src/pythonboot_redis/client.py

@@ -0,0 +1,11 @@
+"""Concrete aliases of native redis-py client classes for Bean injection."""
+
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
+
+RedisClient = Redis
+AsyncRedisClient = AsyncRedis
+
+RedisKey = str | bytes
+RedisValue = str | bytes | int | float
+RedisResult = str | bytes

pythonboot_redis-0.1.0/src/pythonboot_redis/configuration.py

@@ -0,0 +1,72 @@
+"""Conditional native Redis clients and application-owned pool lifecycle."""
+
+import logging
+
+from redis import ConnectionPool
+from redis.asyncio import ConnectionPool as AsyncConnectionPool
+
+from pythonboot import auto_configuration, bean, conditional_on_missing_bean, conditional_on_property
+from pythonboot_redis.client import AsyncRedisClient, RedisClient
+from pythonboot_redis.properties import RedisProperties
+
+logger = logging.getLogger(__name__)
+
+
+@auto_configuration(order=2900, imports=(RedisProperties,))
+@conditional_on_property("pythonboot.redis.enabled", having_value=True, match_if_missing=True)
+class RedisPropertiesAutoConfiguration:
+    """Register typed Redis connection configuration before resource factories."""
+
+
+@auto_configuration(order=3000)
+@conditional_on_property("pythonboot.redis.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.redis.mode", having_value="sync", match_if_missing=True)
+class RedisSyncPoolAutoConfiguration:
+    """Create a pool only when neither an application client nor a pool is available."""
+
+    @bean(name="redisConnectionPool", destroy_method="disconnect")
+    @conditional_on_missing_bean(ConnectionPool, RedisClient, "redisConnectionPool", "redisClient")
+    def connection_pool(self, properties: RedisProperties) -> ConnectionPool:
+        logger.info("Creating synchronous Redis connection pool with max_connections=%d.", properties.max_connections)
+        return ConnectionPool.from_url(properties.connection_url("sync"), **properties.connection_options())
+
+
+@auto_configuration(order=3000)
+@conditional_on_property("pythonboot.redis.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.redis.mode", having_value="async")
+class RedisAsyncPoolAutoConfiguration:
+    """Create an asynchronous pool with awaited shutdown."""
+
+    @bean(name="redisAsyncConnectionPool", destroy_method="disconnect")
+    @conditional_on_missing_bean(
+        AsyncConnectionPool, AsyncRedisClient, "redisAsyncConnectionPool", "redisAsyncClient",
+    )
+    def connection_pool(self, properties: RedisProperties) -> AsyncConnectionPool:
+        logger.info("Creating asynchronous Redis connection pool with max_connections=%d.", properties.max_connections)
+        return AsyncConnectionPool.from_url(properties.connection_url("async"), **properties.connection_options())
+
+
+@auto_configuration(order=3100)
+@conditional_on_property("pythonboot.redis.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.redis.mode", having_value="sync", match_if_missing=True)
+class RedisSyncClientAutoConfiguration:
+    """Register a native synchronous Redis client using the selected pool."""
+
+    @bean(name="redisClient", destroy_method="close")
+    @conditional_on_missing_bean(RedisClient, "redisClient")
+    def client(self, pool: ConnectionPool) -> RedisClient:
+        logger.info("Creating synchronous Redis client from the managed connection pool.")
+        return RedisClient(connection_pool=pool)
+
+
+@auto_configuration(order=3100)
+@conditional_on_property("pythonboot.redis.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.redis.mode", having_value="async")
+class RedisAsyncClientAutoConfiguration:
+    """Register a native asynchronous Redis client without opening connections during import."""
+
+    @bean(name="redisAsyncClient", destroy_method="aclose")
+    @conditional_on_missing_bean(AsyncRedisClient, "redisAsyncClient")
+    def client(self, pool: AsyncConnectionPool) -> AsyncRedisClient:
+        logger.info("Creating asynchronous Redis client from the managed connection pool.")
+        return AsyncRedisClient(connection_pool=pool)

pythonboot_redis-0.1.0/src/pythonboot_redis/properties.py

@@ -0,0 +1,52 @@
+"""Connection settings bound through PythonBoot Configuration Properties."""
+
+from typing import Any, Literal
+
+from pydantic import Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from pythonboot import configuration_properties
+
+
+@configuration_properties("pythonboot.redis")
+class RedisProperties(BaseSettings):
+    """Native standalone Redis connection options; connections open on first command."""
+
+    model_config = SettingsConfigDict(env_prefix="PYTHONBOOT_REDIS_", extra="forbid")
+
+    enabled: bool = True
+    mode: Literal["sync", "async"] = "sync"
+    url: SecretStr = SecretStr("redis://localhost:6379/0")
+    username: str | None = None
+    password: SecretStr | None = None
+    decode_responses: bool = True
+    encoding: str = Field(default="utf-8", min_length=1)
+    max_connections: int = Field(default=50, ge=1)
+    socket_timeout: float = Field(default=5, gt=0, allow_inf_nan=False)
+    socket_connect_timeout: float = Field(default=5, gt=0, allow_inf_nan=False)
+    health_check_interval: int = Field(default=30, ge=0)
+
+    def connection_options(self) -> dict[str, Any]:
+        """Return keyword options without exposing secret representations."""
+        options: dict[str, Any] = {
+            "decode_responses": self.decode_responses,
+            "encoding": self.encoding,
+            "max_connections": self.max_connections,
+            "socket_timeout": self.socket_timeout,
+            "socket_connect_timeout": self.socket_connect_timeout,
+            "health_check_interval": self.health_check_interval,
+        }
+        if self.username is not None:
+            options["username"] = self.username
+        if self.password is not None:
+            options["password"] = self.password.get_secret_value()
+        return options
+
+    def connection_url(self, mode: Literal["sync", "async"]) -> str:
+        """Validate selection before constructing a default connection pool."""
+        if not self.enabled or self.mode != mode:
+            raise ValueError("Redis enabled and mode must be selected in application YAML")
+        url = self.url.get_secret_value()
+        if not url.strip():
+            raise ValueError("pythonboot.redis.url must not be empty")
+        return url

pythonboot_redis-0.1.0/src/pythonboot_redis/util.py

@@ -0,0 +1,158 @@
+"""Synchronous static Redis operations resolved against the current application context."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import timedelta
+from math import isfinite
+
+from redis.lock import Lock
+
+from pythonboot import ContextUtil
+from pythonboot_redis.client import RedisClient, RedisKey, RedisResult, RedisValue
+
+
+def validate_lock_options(timeout: float, blocking_timeout: float, sleep: float) -> None:
+    """Require bounded acquisition and a positive finite lease."""
+    if not isfinite(timeout) or timeout <= 0:
+        raise ValueError("Lock timeout must be finite and positive")
+    if not isfinite(blocking_timeout) or blocking_timeout < 0:
+        raise ValueError("Lock blocking_timeout must be finite and non-negative")
+    if not isfinite(sleep) or sleep <= 0:
+        raise ValueError("Lock sleep must be finite and positive")
+
+
+class RedisUtil:
+    """Convenience methods backed by native RedisClient Beans, never a global client."""
+
+    @staticmethod
+    def get_client(*, name: str | None = None, qualifier: str | None = None) -> RedisClient:
+        return ContextUtil.get_bean(RedisClient, name=name, qualifier=qualifier)
+
+    @staticmethod
+    def get(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return RedisUtil.get_client(name=name).get(key)
+
+    @staticmethod
+    def set(
+        key: RedisKey, value: RedisValue, *, ex: int | timedelta | None = None,
+        px: int | timedelta | None = None, nx: bool = False, xx: bool = False,
+        keepttl: bool = False, name: str | None = None,
+    ) -> bool | None:
+        return RedisUtil.get_client(name=name).set(key, value, ex=ex, px=px, nx=nx, xx=xx, keepttl=keepttl)
+
+    @staticmethod
+    def delete(*keys: RedisKey, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).delete(*keys)
+
+    @staticmethod
+    def exists(*keys: RedisKey, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).exists(*keys)
+
+    @staticmethod
+    def expire(key: RedisKey, seconds: int | timedelta, *, name: str | None = None) -> bool:
+        return RedisUtil.get_client(name=name).expire(key, seconds)
+
+    @staticmethod
+    def ttl(key: RedisKey, *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).ttl(key)
+
+    @staticmethod
+    def incr(key: RedisKey, amount: int = 1, *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).incr(key, amount)
+
+    @staticmethod
+    def decr(key: RedisKey, amount: int = 1, *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).decr(key, amount)
+
+    @staticmethod
+    def hset(key: RedisKey, mapping: Mapping[RedisKey, RedisValue], *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).hset(key, mapping=mapping)
+
+    @staticmethod
+    def hget(key: RedisKey, field: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return RedisUtil.get_client(name=name).hget(key, field)
+
+    @staticmethod
+    def hgetall(key: RedisKey, *, name: str | None = None) -> dict[RedisResult, RedisResult]:
+        return RedisUtil.get_client(name=name).hgetall(key)
+
+    @staticmethod
+    def hdel(key: RedisKey, *fields: RedisKey, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).hdel(key, *fields)
+
+    @staticmethod
+    def lpush(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).lpush(key, *values)
+
+    @staticmethod
+    def rpush(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).rpush(key, *values)
+
+    @staticmethod
+    def lpop(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return RedisUtil.get_client(name=name).lpop(key)
+
+    @staticmethod
+    def rpop(key: RedisKey, *, name: str | None = None) -> RedisResult | None:
+        return RedisUtil.get_client(name=name).rpop(key)
+
+    @staticmethod
+    def lrange(key: RedisKey, start: int = 0, end: int = -1, *, name: str | None = None) -> list[RedisResult]:
+        return RedisUtil.get_client(name=name).lrange(key, start, end)
+
+    @staticmethod
+    def llen(key: RedisKey, *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).llen(key)
+
+    @staticmethod
+    def sadd(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).sadd(key, *values)
+
+    @staticmethod
+    def smembers(key: RedisKey, *, name: str | None = None) -> set[RedisResult]:
+        return RedisUtil.get_client(name=name).smembers(key)
+
+    @staticmethod
+    def srem(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).srem(key, *values)
+
+    @staticmethod
+    def zadd(key: RedisKey, mapping: Mapping[RedisKey, float], *, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).zadd(key, mapping)
+
+    @staticmethod
+    def zrange(key: RedisKey, start: int = 0, end: int = -1, *, name: str | None = None) -> list[RedisResult]:
+        return RedisUtil.get_client(name=name).zrange(key, start, end)
+
+    @staticmethod
+    def zrem(key: RedisKey, *values: RedisValue, name: str | None = None) -> int:
+        return RedisUtil.get_client(name=name).zrem(key, *values)
+
+    @staticmethod
+    def get_lock(
+        key: RedisKey, *, timeout: float = 30, blocking_timeout: float = 5,
+        sleep: float = 0.1, thread_local: bool = True, name: str | None = None,
+    ) -> Lock:
+        validate_lock_options(timeout, blocking_timeout, sleep)
+        return RedisUtil.get_client(name=name).lock(
+            key, timeout=timeout, blocking_timeout=blocking_timeout, sleep=sleep, thread_local=thread_local,
+        )
+
+    @staticmethod
+    def acquire_lock(lock: Lock, *, blocking: bool = True) -> bool:
+        return lock.acquire(blocking=blocking)
+
+    @staticmethod
+    def release_lock(lock: Lock) -> None:
+        lock.release()
+
+    @staticmethod
+    def extend_lock(lock: Lock, seconds: float, *, replace_ttl: bool = False) -> bool:
+        if not isfinite(seconds) or seconds <= 0:
+            raise ValueError("Lock extension must be positive")
+        return lock.extend(seconds, replace_ttl=replace_ttl)
+
+    @staticmethod
+    def lock_owned(lock: Lock) -> bool:
+        return lock.owned()