mqttxx 3.1.2__py3-none-any.whl → 3.2.1__py3-none-any.whl

mqttxx/protocol.py

@@ -2,106 +2,31 @@
 
 import json
 from dataclasses import dataclass
-from typing import Any, Optional, Literal, Protocol as TypingProtocol, Type, runtime_checkable
-
+from dataclasses import asdict, is_dataclass
+from typing import Any, Optional, Literal
 from .exceptions import MessageError, ErrorCode
 
 
-# ============================================================================
-# 编解码器接口（可插拔协议支持）
-# ============================================================================
-
-@runtime_checkable
-class Codec(TypingProtocol):
-    """编解码器接口（协议无关）
-
-    实现此接口可支持不同的序列化协议（JSON、MessagePack、Protobuf 等）
-    """
-
-    @staticmethod
-    def encode(obj: Any) -> bytes:
-        """对象 → bytes
-
-        Args:
-            obj: 要编码的对象（RPCRequest/RPCResponse/EventMessage/dict）
-
-        Returns:
-            编码后的 bytes
-
-        Raises:
-            ValueError: 无法编码的类型
-        """
-        ...
-
-    @staticmethod
-    def decode(data: bytes) -> dict:
-        """bytes → dict
-
-        Args:
-            data: 原始 bytes 数据
-
-        Returns:
-            解码后的 dict
-
-        Raises:
-            UnicodeDecodeError: UTF-8 解码失败
-            JSONDecodeError: JSON 解析失败（或其他格式解析失败）
-        """
-        ...
-
-
-class JSONCodec:
-    """JSON 编解码器（默认实现）
-
-    使用标准 JSON 格式进行序列化/反序列化
-    支持 Pydantic BaseModel 自动序列化
-    """
-
-    @staticmethod
-    def encode(obj: Any) -> bytes:
-        """对象 → bytes
-
-        支持：
-        - 有 to_dict() 方法的对象（RPCRequest/RPCResponse/EventMessage）
-        - Pydantic BaseModel（自动调用 model_dump()）
-        - dict 对象
-
-        Args:
-            obj: 要编码的对象
-
-        Returns:
-            UTF-8 编码的 JSON bytes
+def _to_jsonable(obj: Any) -> Any:
+    if obj is None:
+        return None
 
-        Raises:
-            ValueError: 无法编码的类型
-        """
-        if hasattr(obj, 'to_dict'):
-            data = obj.to_dict()
-        elif hasattr(obj, 'model_dump'):
-            data = obj.model_dump()
-        elif isinstance(obj, dict):
-            data = obj
-        else:
-            raise ValueError(f"无法编码类型: {type(obj)}")
+    if is_dataclass(obj):
+        return _to_jsonable(asdict(obj))
 
-        return json.dumps(data).encode('utf-8')
+    if isinstance(obj, dict):
+        return {k: _to_jsonable(v) for k, v in obj.items()}
 
-    @staticmethod
-    def decode(data: bytes) -> dict:
-        """bytes → dict
+    if isinstance(obj, (list, tuple, set)):
+        return [_to_jsonable(v) for v in obj]
 
-        Args:
-            data: UTF-8 编码的 JSON bytes
+    if hasattr(obj, "model_dump") and callable(getattr(obj, "model_dump")):
+        return _to_jsonable(obj.model_dump(mode="json"))
 
-        Returns:
-            解码后的 dict
+    if hasattr(obj, "dict") and callable(getattr(obj, "dict")):
+        return _to_jsonable(obj.dict())
 
-        Raises:
-            UnicodeDecodeError: UTF-8 解码失败
-            json.JSONDecodeError: JSON 解析失败
-        """
-        text = data.decode('utf-8')
-        return json.loads(text)
+    return obj
 
 
 @dataclass
@@ -146,16 +71,11 @@ class RPCRequest:
         Returns:
             包含所有字段的字典
         """
-        # 处理 Pydantic 模型
-        params = self.params
-        if hasattr(params, 'model_dump'):
-            params = params.model_dump()
-
         return {
             "type": self.type,
             "request_id": self.request_id,
             "method": self.method,
-            "params": params,
+            "params": _to_jsonable(self.params),
             "reply_to": self.reply_to,
             "caller_id": self.caller_id,
         }
@@ -183,46 +103,33 @@ class RPCRequest:
             )
         except KeyError as e:
             raise MessageError(
-                f"RPC 请求缺少必需字段: {e}",
-                ErrorCode.MISSING_REQUIRED_FIELD
+                f"RPC 请求缺少必需字段: {e}", ErrorCode.MISSING_REQUIRED_FIELD
             )
 
-    def encode(self, codec: Type[Codec] = JSONCodec) -> bytes:
-        """编码为 bytes
-
-        Args:
-            codec: 编解码器（默认 JSONCodec）
+    def encode(self) -> bytes:
+        """编码为 bytes（JSON 格式）
 
         Returns:
-            编码后的 bytes
-
-        示例:
-            request = RPCRequest(request_id="123", method="test")
-            payload = request.encode()  # 使用默认 JSONCodec
-            # 或自定义 codec
-            payload = request.encode(MessagePackCodec)
+            UTF-8 编码的 JSON bytes
         """
-        return codec.encode(self)
+        return json.dumps(self.to_dict()).encode("utf-8")
 
     @classmethod
-    def decode(cls, data: bytes, codec: Type[Codec] = JSONCodec) -> "RPCRequest":
-        """从 bytes 解码
+    def decode(cls, data: bytes) -> "RPCRequest":
+        """从 bytes 解码（JSON 格式）
 
         Args:
-            data: 原始 bytes 数据
-            codec: 编解码器（默认 JSONCodec）
+            data: UTF-8 编码的 JSON bytes
 
         Returns:
             RPCRequest 对象
 
         Raises:
             MessageError: 解码失败或缺少必需字段
-
-        示例:
-            payload = b'{"type":"rpc_request","request_id":"123",...}'
-            request = RPCRequest.decode(payload)
+            UnicodeDecodeError: UTF-8 解码失败
+            json.JSONDecodeError: JSON 解析失败
         """
-        obj = codec.decode(data)
+        obj = json.loads(data.decode("utf-8"))
         return cls.from_dict(obj)
 
 
@@ -274,11 +181,7 @@ class RPCResponse:
         if self.error is not None:
             data["error"] = self.error
         else:
-            # 处理 Pydantic 模型
-            result = self.result
-            if hasattr(result, 'model_dump'):
-                result = result.model_dump()
-            data["result"] = result
+            data["result"] = _to_jsonable(self.result)
 
         return data
 
@@ -303,45 +206,41 @@ class RPCResponse:
             )
         except KeyError as e:
             raise MessageError(
-                f"RPC 响应缺少必需字段: {e}",
-                ErrorCode.MISSING_REQUIRED_FIELD
+                f"RPC 响应缺少必需字段: {e}", ErrorCode.MISSING_REQUIRED_FIELD
             )
 
-    def encode(self, codec: Type[Codec] = JSONCodec) -> bytes:
-        """编码为 bytes
-
-        Args:
-            codec: 编解码器（默认 JSONCodec）
+    def encode(self) -> bytes:
+        """编码为 bytes（JSON 格式）
 
         Returns:
-            编码后的 bytes
+            UTF-8 编码的 JSON bytes
         """
-        return codec.encode(self)
+        return json.dumps(self.to_dict()).encode("utf-8")
 
     @classmethod
-    def decode(cls, data: bytes, codec: Type[Codec] = JSONCodec) -> "RPCResponse":
-        """从 bytes 解码
+    def decode(cls, data: bytes) -> "RPCResponse":
+        """从 bytes 解码（JSON 格式）
 
         Args:
-            data: 原始 bytes 数据
-            codec: 编解码器（默认 JSONCodec）
+            data: UTF-8 编码的 JSON bytes
 
         Returns:
             RPCResponse 对象
 
         Raises:
             MessageError: 解码失败或缺少必需字段
+            UnicodeDecodeError: UTF-8 解码失败
+            json.JSONDecodeError: JSON 解析失败
         """
-        obj = codec.decode(data)
+        obj = json.loads(data.decode("utf-8"))
         return cls.from_dict(obj)
 
 
-def parse_message_from_bytes(data: bytes, codec: Type[Codec] = JSONCodec) -> RPCRequest | RPCResponse:
-    """从 bytes 解析 RPC 消息
+def parse_message_from_bytes(data: bytes) -> RPCRequest | RPCResponse:
+    """从 bytes 解析 RPC 消息（JSON 格式）
 
     Args:
-        data: 原始 bytes 数据
-        codec: 编解码器（默认 JSONCodec）
+        data: UTF-8 编码的 JSON bytes
 
     Returns:
         RPCRequest 或 RPCResponse 对象
@@ -362,7 +261,7 @@ def parse_message_from_bytes(data: bytes, codec: Type[Codec] = JSONCodec) -> RPC
             # 处理响应
             pass
     """
-    obj = codec.decode(data)
+    obj = json.loads(data.decode("utf-8"))
     msg_type = obj.get("type")
 
     if msg_type == "rpc_request":
@@ -370,7 +269,4 @@ def parse_message_from_bytes(data: bytes, codec: Type[Codec] = JSONCodec) -> RPC
     elif msg_type == "rpc_response":
         return RPCResponse.from_dict(obj)
     else:
-        raise MessageError(
-            f"未知消息类型: {msg_type}",
-            ErrorCode.INVALID_MESSAGE_TYPE
-        )
+        raise MessageError(f"未知消息类型: {msg_type}", ErrorCode.INVALID_MESSAGE_TYPE)

mqttxx/rpc.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import uuid
-from typing import Any, Callable, Optional, Type
+from typing import Any, Callable, Optional
 from loguru import logger
 
 from .client import MQTTClient
@@ -15,7 +15,11 @@ from .exceptions import (
     ErrorCode,
     MessageError,
 )
-from .protocol import RPCRequest, RPCResponse, parse_message_from_bytes, Codec, JSONCodec
+from .protocol import (
+    RPCRequest,
+    RPCResponse,
+    parse_message_from_bytes,
+)
 
 
 # 权限检查回调类型
@@ -74,14 +78,15 @@ class RPCManager:
     def __init__(
         self,
         client: MQTTClient,
+        my_topic: Optional[str] = None,
         config: Optional[RPCConfig] = None,
         auth_callback: Optional[AuthCallback] = None,
-        codec: Type[Codec] = JSONCodec,  # 新增：可插拔编解码器
     ):
         """初始化 RPC 管理器
 
         Args:
             client: MQTTClient 实例（用于底层消息收发）
+            my_topic: 本节点的响应主题（可选，提供后自动订阅并注入到 reply_to）
             config: RPC 配置（可选，默认使用标准配置）
             auth_callback: 权限检查回调函数（可选）
                 签名：async def auth_callback(caller_id: str, method: str, request: RPCRequest) -> bool
@@ -92,29 +97,38 @@ class RPCManager:
             client = MQTTClient(...)
             await client.connect()
 
-            # 基础用法（无权限控制）
+            # 约定式用法（推荐）
+            rpc = RPCManager(client, my_topic="edge/device_123")
+            # 自动订阅 edge/device_123，调用时自动注入 reply_to
+
+            # 手动设置响应主题
             rpc = RPCManager(client)
-            rpc.setup("my/rpc/responses")  # 设置响应主题
+            rpc.setup("my/rpc/responses")
 
             # 带权限控制
             async def auth_check(caller_id, method, request):
                 return caller_id in ALLOWED_CLIENTS
 
-            rpc = RPCManager(client, auth_callback=auth_check)
+            rpc = RPCManager(client, my_topic="server/node", auth_callback=auth_check)
         """
         self._client = client
+        self._my_topic = my_topic
         self.config = config or RPCConfig()
         self._auth_callback = auth_callback
-        self._codec = codec  # 保存编解码器
 
         # RPC 状态
         self._pending_calls: dict[str, asyncio.Future] = {}  # request_id → Future
         self._handlers: dict[str, Callable] = {}  # method_name → handler
-        self._pending_calls_lock = (
-            asyncio.Lock()
-        )  # 修复 P0-1：保护 _pending_calls 并发访问
+        self._pending_calls_lock = asyncio.Lock()  # 保护 _pending_calls 并发访问
 
-        logger.info("RPCManager 已初始化")
+        # 如果提供了 my_topic，自动订阅
+        if my_topic:
+            self.setup(my_topic)
+
+    @property
+    def my_topic(self) -> Optional[str]:
+        """获取本节点的响应主题"""
+        return self._my_topic
 
     def setup(self, reply_topic: str):
         """设置 RPC 响应主题并自动订阅
@@ -130,11 +144,12 @@ class RPCManager:
             rpc = RPCManager(client)
             rpc.setup("my/rpc/responses")
         """
+
         async def handle_bytes(topic: str, payload: bytes):
             """bytes → RPC message → handle"""
             try:
                 # 解码
-                message = parse_message_from_bytes(payload, self._codec)
+                message = parse_message_from_bytes(payload)
 
                 # 路由
                 if isinstance(message, RPCRequest):
@@ -147,8 +162,7 @@ class RPCManager:
                 logger.exception(f"RPC 消息处理失败: {e}")
 
         # 订阅 raw bytes
-        self._client.raw.subscribe(reply_topic, handle_bytes)
-
+        self._client.subscribe(reply_topic, handle_bytes)
 
     def register(self, method_name: str):
         """装饰器：注册本地 RPC 方法供远程调用
@@ -226,52 +240,57 @@ class RPCManager:
         method: str,
         params: Any = None,
         timeout: Optional[float] = None,
-        reply_to: str = None,
+        reply_to: Optional[str] = None,
     ) -> Any:
         """远程调用 RPC 方法
 
         修复点：
         - ✅ 新增并发限制检查
+        - ✅ 自动注入 reply_to（如果初始化时提供了 my_topic）
 
         Args:
             topic: 目标 MQTT 主题（例如：bots/456）
             method: 远程方法名
             params: 方法参数（可选）
             timeout: 超时时间（秒，None 则使用配置的默认值）
-            reply_to: 响应主题（必需，例如：server/device_123）
+            reply_to: 响应主题（可选，默认使用初始化时的 my_topic）
 
         Returns:
             远程方法的返回值
 
         Raises:
             MQTTXError: 客户端未连接
-            ValueError: reply_to 参数缺失
+            ValueError: reply_to 参数缺失且初始化时未提供 my_topic
             TooManyConcurrentCallsError: 并发调用超限
             RPCTimeoutError: 调用超时
             RPCRemoteError: 远程执行失败
 
         使用示例：
-            # 基础调用
-            result = await rpc.call(
-                topic="bots/456",
-                method="get_status",
-                reply_to="server/device_123"
-            )
+            # 约定式用法（推荐）
+            rpc = RPCManager(client, my_topic="server/device_123")
+            result = await rpc.call("bots/456", "get_status")
+            # reply_to 自动注入为 "server/device_123"
 
-            # 带参数调用
+            # 手动指定 reply_to
             result = await rpc.call(
                 topic="bots/456",
                 method="process_command",
                 params={"command": "restart"},
-                reply_to="server/device_123",
+                reply_to="custom/reply/topic",
                 timeout=60.0
             )
         """
         if not self._client.is_connected:
             raise MQTTXError("MQTT 客户端未连接", ErrorCode.NOT_CONNECTED)
 
+        # 自动注入 reply_to
         if reply_to is None:
-            raise ValueError("reply_to 参数是必需的，不能为 None")
+            reply_to = self._my_topic
+
+        if reply_to is None:
+            raise ValueError(
+                "reply_to 参数是必需的，或在初始化时提供 my_topic"
+            )
 
         # 生成请求
         request_id = str(uuid.uuid4())
@@ -295,8 +314,8 @@ class RPCManager:
             future = asyncio.get_event_loop().create_future()
             self._pending_calls[request_id] = future
 
-        # 发送请求（使用编解码器）
-        payload = request.encode(self._codec)
+        # 发送请求
+        payload = request.encode()
         await self._client.raw.publish(topic, payload, qos=1)
         logger.debug(f"RPC 请求已发送 - method: {method}, request_id: {request_id[:8]}")
 
@@ -445,6 +464,6 @@ class RPCManager:
             topic: 响应主题
             response: RPC 响应消息
         """
-        payload = response.encode(self._codec)
+        payload = response.encode()
         await self._client.raw.publish(topic, payload, qos=1)
         logger.debug(f"RPC 响应已发送 - request_id: {response.request_id[:8]}")