trpc-redis-python 1.0.0__py3-none-any.whl

trpc_redis/__init__.py

@@ -0,0 +1,30 @@
+# Tencent is pleased to support the open source community by making tRPC-Python-Database available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Python-Database is licensed under Apache-2.0.
+"""Redis client for the tRPC Python framework.
+
+Importing this package registers the Redis codec and transport plugins and
+re-exports the public client types.
+"""
+
+from ._client import create_rsp_object
+from ._client import get_options
+from ._client import Client
+from ._codec import ClientCodec
+from ._constants import RequestMode
+from ._transport import RedisClientTransport
+from ._types import Request
+from ._types import Response
+
+__all__ = [
+    'Request',
+    'Response',
+    'RequestMode',
+    'create_rsp_object',
+    'get_options',
+    'Client',
+    'RedisClientTransport',
+    'ClientCodec',
+]

trpc_redis/_client.py

@@ -0,0 +1,265 @@
+# Tencent is pleased to support the open source community by making tRPC-Python-Database available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Python-Database is licensed under Apache-2.0.
+"""
+Redis client module for accessing Redis servers via the tRPC framework.
+
+This module provides a Client class that wraps the tRPC client for Redis operations, supporting command, pipeline,
+and pubsub modes. It also provides utilities for configuring Redis client options.
+
+Usage:
+    from trpc_redis import Client as RedisClient
+    client = RedisClient("redis", opts)
+    await client.execute_command(ctx, "set", ["key", "value"])
+    await client.create_pipeline(ctx)
+    await client.create_pubsub(ctx, "channel")
+"""
+
+import threading
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from redis.asyncio.client import Pipeline
+from redis.asyncio.client import PubSub
+from redis.typing import ResponseT as RedisResponse
+from redis.typing import KeyT as RedisKey
+from redis.typing import ChannelT as RedisChannelT
+
+from trpc_sdk.abc import TrpcContext
+from trpc_sdk.client import Client as TrpcClient
+from trpc_sdk.client import Options
+from trpc_sdk.codec import clone_client_message
+from trpc_sdk.config import TrpcConfig
+from trpc_sdk.serialization import SerializationType
+from ._constants import PASSWORD
+from ._constants import REDIS_NAME
+from ._constants import RequestMode
+from ._types import Request
+from ._types import Response
+
+
+def create_rsp_object():
+    """
+    Construct a new response object. This returns None because the transport will override it.
+
+    Returns:
+        None
+    """
+    return None
+
+
+def redis_config_option(redis_config: Dict) -> Callable:
+    """
+    Option setter for specifying Redis backend configuration.
+
+    Args:
+        redis_config (Dict): Redis configuration dictionary.
+
+    Returns:
+        Callable: Option setter function.
+    """
+
+    def func(opts: Options):
+        setattr(opts.call_options, REDIS_NAME, redis_config)
+
+    return func
+
+
+def get_options(opts: List) -> List:
+    """
+    Get options for the Redis client, including required Redis fields.
+
+    Args:
+        opts (List): Additional options to include.
+
+    Returns:
+        List: List of options for the client.
+    """
+    needed = (Options()
+              .set_protocol(REDIS_NAME)
+              .set_serialization_type(SerializationType.Noop)
+              .set_disable_service_router(True))
+    options = [needed]
+    if opts:
+        options.extend(opts)
+    return options
+
+
+class Client:
+    """
+    Redis client wrapper for the tRPC framework.
+
+    This class wraps the tRPC client to provide Redis command, pipeline, and pubsub operations.
+
+    Attributes:
+        client (TrpcClient): The underlying tRPC client object.
+        __service_name (str): The service name.
+        __opts (List): List of client options.
+    """
+
+    def __init__(self, name: str, opts: Optional[List] = None):
+        """
+        Initialize the Redis client.
+
+        Args:
+            name (str): Service name.
+            opts (Optional[List]): List of options.
+        """
+        self.client = TrpcClient()
+        self.__service_name = name
+        self.__opts = get_options(opts or [])
+        self._is_load_config = False
+        self._config_lock = threading.Lock()
+
+    @property
+    def service_name(self):
+        """
+        Get the service name.
+
+        Returns:
+            str: The service name.
+        """
+        return self.__service_name
+
+    def __getattr__(self, item):
+        """
+        Override attribute access to provide dynamic command methods.
+
+        Args:
+            item (str): The attribute name (command name).
+
+        Returns:
+            Callable: An async function that calls execute_command(ctx, item, args).
+        """
+
+        async def func(ctx, *args, **kwargs):
+            return await self.execute_command(ctx, item, *args, **kwargs)
+
+        return func
+
+    def _get_config(self):
+        """
+        Load configuration from global config if available.
+
+        Safe to call from several handler threads at once: the options are
+        appended once, before the loaded flag is set.
+        """
+        if self._is_load_config:
+            return
+        with self._config_lock:
+            if self._is_load_config:
+                return
+            self.__opts.extend(self._config_options())
+            self._is_load_config = True
+
+    def _config_options(self) -> List:
+        """
+        Build the options that the global config adds for this service.
+
+        Returns:
+            List: Password and Redis backend options; empty when not configured.
+        """
+        parser = TrpcConfig.config_parser()
+        if parser is None:
+            return []
+        client_redis_config_dict = {}
+        client_conf_dict = parser.get("client", {}) or {}
+        services = client_conf_dict.get('service', []) or []
+        for service in services:
+            if service.get('name') == self.__service_name:
+                client_redis_config_dict = service
+                break
+        if not client_redis_config_dict:
+            return []
+        options = []
+        password = client_redis_config_dict.get(PASSWORD, None)
+        if password:
+            options.append(Options().set_password(password))
+        redis_config = client_redis_config_dict.get(REDIS_NAME, {})
+        if redis_config:
+            options.append(redis_config_option(redis_config))
+        return options
+
+    async def execute_command(self, ctx: TrpcContext, cmd: str, *args, **kwargs) -> bytes:
+        """
+        Execute a Redis command via tRPC.
+
+        Args:
+            ctx (TrpcContext): The client context.
+            cmd (str): The Redis command.
+            args (Optional[List]): Arguments for the command.
+
+        Returns:
+            bytes: The reply as bytes.
+        """
+        self._get_config()
+        req = Request(command=cmd, mode=RequestMode.COMMAND, args=args, kwargs=kwargs)
+        ctx, msg = clone_client_message(ctx)
+        msg.set_compress_type(0)
+        msg.set_serialization_type(-1)
+        msg.set_client_rpc_name(f"/{self.__service_name}/{cmd}")
+        msg.set_callee_service_name(self.__service_name)
+        msg.set_client_req_head(req)
+
+        await self.client.invoke(ctx, req, create_rsp_object, self.__opts)
+        return msg.client_rsp_head.reply
+
+    async def delete(self, ctx: TrpcContext, *names: RedisKey) -> RedisResponse:
+        """
+        Delete a key from Redis.
+        """
+        return await self.execute_command(ctx, "DEL", *names)
+
+    async def create_pipeline(self, ctx: TrpcContext) -> Pipeline:
+        """
+        Create a Redis pipeline via tRPC.
+
+        Args:
+            ctx (TrpcContext): The client context.
+
+        Returns:
+            Pipeline: The pipeline object.
+        """
+        self._get_config()
+        req = Request(mode=RequestMode.PIPELINE)
+        resp = Response(None)
+        ctx, msg = clone_client_message(ctx)
+        msg.set_compress_type(0)
+        msg.set_serialization_type(-1)
+        msg.set_client_rpc_name(f"/{self.__service_name}/pipeline")
+        msg.set_callee_service_name(self.__service_name)
+        msg.set_client_req_head(req)
+        msg.set_client_rsp_head(resp)
+
+        await self.client.invoke(ctx, req, create_rsp_object, self.__opts)
+        return msg.client_rsp_head.reply
+
+    async def create_pubsub(self, ctx: TrpcContext, *args: RedisChannelT, **kwargs: Callable) -> PubSub:
+        """
+        Create a Redis pubsub object via tRPC and subscribe to the given channels.
+
+        Args:
+            ctx (TrpcContext): The client context.
+            *args (RedisChannelT): Channels to subscribe to.
+            **kwargs (Callable): Channels mapped to their message handlers.
+
+        Returns:
+            PubSub: The pubsub object.
+        """
+        self._get_config()
+        req = Request(mode=RequestMode.PUBSUB, args=args, kwargs=kwargs)
+        resp = Response(None)
+        ctx, msg = clone_client_message(ctx)
+        msg.set_compress_type(0)
+        msg.set_serialization_type(-1)
+        msg.set_client_rpc_name(f"/{self.__service_name}/pubsub")
+        msg.set_callee_service_name(self.__service_name)
+        msg.set_client_req_head(req)
+        msg.set_client_rsp_head(resp)
+
+        await self.client.invoke(ctx, req, create_rsp_object, self.__opts)
+        return msg.client_rsp_head.reply

trpc_redis/_codec.py

@@ -0,0 +1,69 @@
+# Tencent is pleased to support the open source community by making tRPC-Python-Database available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Python-Database is licensed under Apache-2.0.
+"""
+Redis protocol codec module for tRPC framework.
+
+This module provides a codec for encoding and decoding messages using the Redis protocol.
+It registers a custom codec plugin for Redis, which is used by the tRPC client to handle Redis-specific message
+serialization and deserialization.
+
+Usage:
+    The codec is registered automatically as a plugin and is used internally by the tRPC Redis client.
+"""
+
+import os
+from typing import Any
+
+from trpc_sdk.abc import BaseCodec
+from trpc_sdk.abc import PluginInitPos
+from trpc_sdk.abc import PluginType
+from trpc_sdk.abc import TrpcContext
+from trpc_sdk.codec import get_message
+from trpc_sdk.plugin import register_plugin
+
+from ._constants import REDIS_NAME
+
+
+@register_plugin(PluginType.CLIENT_CODEC, REDIS_NAME, init_pos=PluginInitPos.WORKER)
+class ClientCodec(BaseCodec):
+    """Unary client codec for the Redis protocol.
+
+    Redis I/O is done entirely by the Redis transport through ``redis-py``,
+    so this codec produces no wire bytes. It only fills in client metadata on
+    encode and turns the transport reply into bytes on decode.
+    """
+
+    def encode_data(self, context: TrpcContext, body: Any) -> bytes:
+        """Encode a request frame; the entry the client invoke path calls.
+
+        Sets a default caller service name when the message has none.
+
+        Args:
+            context: RPC context whose client message is encoded.
+            body: Request body. Unused, the request lives in
+                ``message.client_req_head``.
+
+        Returns:
+            Empty bytes; the transport sends the actual Redis command.
+        """
+        message = get_message(context)
+        if message.caller_service_name == "":
+            message.set_caller_service_name(f"trpc.redis.{os.path.basename(os.getcwd())}.service")
+        return b""
+
+    def decode_data(self, context: TrpcContext, buffer: Any) -> bytes:
+        """Decode the transport reply into bytes; the entry the client invoke path calls.
+
+        Args:
+            context: RPC context of the call. Unused.
+            buffer: Reply returned by the Redis transport; may be ``None``.
+
+        Returns:
+            ``b""`` for ``None``, otherwise ``str(buffer)`` encoded as UTF-8.
+        """
+        if buffer is None:
+            return b""
+        return bytes(str(buffer), encoding='utf8')

trpc_redis/_constants.py

@@ -0,0 +1,52 @@
+# Tencent is pleased to support the open source community by making tRPC-Python-Database available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Python-Database is licensed under Apache-2.0.
+"""
+Redis constants module for tRPC framework.
+
+This module defines constants used in the Redis client implementation.
+It includes configuration keys and default values for Redis connections.
+
+Usage:
+    The constants are used to configure Redis client options and connection parameters.
+"""
+
+from enum import Enum
+
+# Plugin name of the codec and transport, the client protocol name, and the
+# key of the extra ConnectionPool kwargs in YAML and ``call_options``.
+REDIS_NAME: str = "redis"
+
+# ``redis.asyncio.ConnectionPool`` kwargs the transport fills with a default
+# when the ``redis:`` config block does not set them.
+MAX_CONNECTIONS: str = "max_connections"
+SOCKET_CONNECT_TIMEOUT: str = "socket_connect_timeout"
+DECODE_RESPONSES: str = "decode_responses"
+
+# ConnectionPool kwargs always overwritten from the service target and password.
+# ``PASSWORD`` is also the password key of a client service config entry.
+HOST: str = "host"
+PORT: str = "port"
+PASSWORD: str = "password"
+
+# Maximum number of connections in one pool.
+MAX_CONNECTIONS_DEFAULT: int = 1024
+# Seconds. Used as the default ``socket_connect_timeout``, not as an idle timeout.
+IDLE_TIMEOUT_DEFAULT: float = 3.0 * 60
+# Replies stay bytes unless the config enables decoding.
+DECODE_RESPONSES_DEFAULT: bool = False
+
+
+class RequestMode(Enum):
+    """Dispatch key of a Redis request.
+
+    Attributes:
+        COMMAND: Run one Redis command and return its reply.
+        PUBSUB: Subscribe and return a ``PubSub`` object.
+        PIPELINE: Return a ``Pipeline`` object for batched commands.
+    """
+    COMMAND = "command"
+    PUBSUB = "pubsub"
+    PIPELINE = "pipeline"