✨ 分离magicoca和croterline

liteyuki/comm/channel.py

@@ -4,20 +4,31 @@
 """
 import asyncio
 from multiprocessing import Pipe
-from typing import Any, Callable, Coroutine, Generic, Optional, TypeAlias, TypeVar, get_args
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Generic,
+    Optional,
+    TypeAlias,
+    TypeVar,
+    get_args,
+)
 
 from liteyuki.log import logger
 from liteyuki.utils import IS_MAIN_PROCESS, is_coroutine_callable
 
 T = TypeVar("T")
 
-SYNC_ON_RECEIVE_FUNC: TypeAlias = Callable[[T], Any]    # 同步接收函数
-ASYNC_ON_RECEIVE_FUNC: TypeAlias = Callable[[T], Coroutine[Any, Any, Any]]  # 异步接收函数
-ON_RECEIVE_FUNC: TypeAlias = SYNC_ON_RECEIVE_FUNC | ASYNC_ON_RECEIVE_FUNC   # 接收函数
+SYNC_ON_RECEIVE_FUNC: TypeAlias = Callable[[T], Any]  # 同步接收函数
+ASYNC_ON_RECEIVE_FUNC: TypeAlias = Callable[
+    [T], Coroutine[Any, Any, Any]
+]  # 异步接收函数
+ON_RECEIVE_FUNC: TypeAlias = SYNC_ON_RECEIVE_FUNC | ASYNC_ON_RECEIVE_FUNC  # 接收函数
 
-SYNC_FILTER_FUNC: TypeAlias = Callable[[T], bool]   # 同步过滤函数
-ASYNC_FILTER_FUNC: TypeAlias = Callable[[T], Coroutine[Any, Any, bool]] # 异步过滤函数
-FILTER_FUNC: TypeAlias = SYNC_FILTER_FUNC | ASYNC_FILTER_FUNC   # 过滤函数
+SYNC_FILTER_FUNC: TypeAlias = Callable[[T], bool]  # 同步过滤函数
+ASYNC_FILTER_FUNC: TypeAlias = Callable[[T], Coroutine[Any, Any, bool]]  # 异步过滤函数
+FILTER_FUNC: TypeAlias = SYNC_FILTER_FUNC | ASYNC_FILTER_FUNC  # 过滤函数
 
 _func_id: int = 0
 _channel: dict[str, "Channel"] = {}
@@ -39,7 +50,9 @@ class Channel(Generic[T]):
         """
 
         self.conn_send, self.conn_recv = Pipe()
-        self._conn_send_inner, self._conn_recv_inner = Pipe()   # 内部通道，用于子进程通信
+        self._conn_send_inner, self._conn_recv_inner = (
+            Pipe()
+        )  # 内部通道，用于子进程通信
         self._closed = False
         self._on_main_receive_func_ids: list[int] = []
         self._on_sub_receive_func_ids: list[int] = []
@@ -64,7 +77,9 @@ class Channel(Generic[T]):
             _channel[name] = self
             logger.debug(f"Channel {name} initialized in main process")
         else:
-            logger.debug(f"Channel {name} initialized in sub process, should manually set in main process")
+            logger.debug(
+                f"Channel {name} initialized in sub process, should manually set in main process"
+            )
 
     def _get_generic_type(self) -> Optional[type]:
         """
@@ -72,7 +87,7 @@ class Channel(Generic[T]):
         Returns:
             Optional[type]: 泛型类型
         """
-        if hasattr(self, '__orig_class__'):
+        if hasattr(self, "__orig_class__"):
             return get_args(self.__orig_class__)[0]
         return None
 
@@ -98,7 +113,10 @@ class Channel(Generic[T]):
         elif isinstance(structure, dict):
             if not isinstance(data, dict):
                 return False
-            return all(k in data and self._validate_structure(data[k], structure[k]) for k in structure)
+            return all(
+                k in data and self._validate_structure(data[k], structure[k])
+                for k in structure
+            )
         return False
 
     def __str__(self):
@@ -113,10 +131,12 @@ class Channel(Generic[T]):
         if self.type_check:
             _type = self._get_generic_type()
             if _type is not None and not self._validate_structure(data, _type):
-                raise TypeError(f"Data must be an instance of {_type}, {type(data)} found")
+                raise TypeError(
+                    f"Data must be an instance of {_type}, {type(data)} found"
+                )
 
         if self._closed:
-            raise RuntimeError("Cannot send to a closed channel_")
+            raise RuntimeError("Cannot send to a closed channel")
         self.conn_send.send(data)
 
     def receive(self) -> T:
@@ -126,7 +146,7 @@ class Channel(Generic[T]):
             T: 数据
         """
         if self._closed:
-            raise RuntimeError("Cannot receive from a closed channel_")
+            raise RuntimeError("Cannot receive from a closed channel")
 
         while True:
             data = self.conn_recv.recv()
@@ -142,7 +162,9 @@ class Channel(Generic[T]):
         data = await loop.run_in_executor(None, self.receive)
         return data
 
-    def on_receive(self, filter_func: Optional[FILTER_FUNC] = None) -> Callable[[Callable[[T], Any]], Callable[[T], Any]]:
+    def on_receive(
+        self, filter_func: Optional[FILTER_FUNC] = None
+    ) -> Callable[[Callable[[T], Any]], Callable[[T], Any]]:
         """
         接收数据并执行函数
         Args:
@@ -187,37 +209,52 @@ class Channel(Generic[T]):
             data: 数据
         """
         if IS_MAIN_PROCESS:
-            [asyncio.create_task(_callback_funcs[func_id](data)) for func_id in self._on_main_receive_func_ids]
+            [
+                asyncio.create_task(_callback_funcs[func_id](data))
+                for func_id in self._on_main_receive_func_ids
+            ]
         else:
-            [asyncio.create_task(_callback_funcs[func_id](data)) for func_id in self._on_sub_receive_func_ids]
+            [
+                asyncio.create_task(_callback_funcs[func_id](data))
+                for func_id in self._on_sub_receive_func_ids
+            ]
 
 
 """子进程可用的主动和被动通道"""
-active_channel: Channel = Channel(name="active_channel")    # 主动通道
+active_channel: Channel = Channel(name="active_channel")  # 主动通道
 passive_channel: Channel = Channel(name="passive_channel")  # 被动通道
-publish_channel: Channel[tuple[str, dict[str, Any]]] = Channel(name="publish_channel")  # 发布通道
+publish_channel: Channel[tuple[str, dict[str, Any]]] = Channel(
+    name="publish_channel"
+)  # 发布通道
 """通道传递通道，主进程创建单例，子进程初始化时实例化"""
-channel_deliver_active_channel: Channel[Channel[Any]]   # 主动通道传递通道
-channel_deliver_passive_channel: Channel[tuple[str, dict[str, Any]]]    # 被动通道传递通道
+channel_deliver_active_channel: Channel[Channel[Any]]  # 主动通道传递通道
+channel_deliver_passive_channel: Channel[tuple[str, dict[str, Any]]]  # 被动通道传递通道
 
 if IS_MAIN_PROCESS:
-    channel_deliver_active_channel = Channel(name="channel_deliver_active_channel") # 主动通道传递通道
-    channel_deliver_passive_channel = Channel(name="channel_deliver_passive_channel")   # 被动通道传递通道
+    channel_deliver_active_channel = Channel(
+        name="channel_deliver_active_channel"
+    )  # 主动通道传递通道
+    channel_deliver_passive_channel = Channel(
+        name="channel_deliver_passive_channel"
+    )  # 被动通道传递通道
 
-
-    @channel_deliver_passive_channel.on_receive(filter_func=lambda data: data[0] == "set_channel")
+    @channel_deliver_passive_channel.on_receive(
+        filter_func=lambda data: data[0] == "set_channel"
+    )
     def on_set_channel(data: tuple[str, dict[str, Any]]):
         name, channel = data[1]["name"], data[1]["channel_"]
         set_channel(name, channel)
 
-
-    @channel_deliver_passive_channel.on_receive(filter_func=lambda data: data[0] == "get_channel")
+    @channel_deliver_passive_channel.on_receive(
+        filter_func=lambda data: data[0] == "get_channel"
+    )
     def on_get_channel(data: tuple[str, dict[str, Any]]):
         name, recv_chan = data[1]["name"], data[1]["recv_chan"]
         recv_chan.send(get_channel(name))
 
-
-    @channel_deliver_passive_channel.on_receive(filter_func=lambda data: data[0] == "get_channels")
+    @channel_deliver_passive_channel.on_receive(
+        filter_func=lambda data: data[0] == "get_channels"
+    )
     def on_get_channels(data: tuple[str, dict[str, Any]]):
         recv_chan = data[1]["recv_chan"]
         recv_chan.send(get_channels())
@@ -231,7 +268,9 @@ def set_channel(name: str, channel: "Channel"):
         channel ([`Channel`](#class-channel-generic-t)): 通道实例
     """
     if not isinstance(channel, Channel):
-        raise TypeError(f"channel_ must be an instance of Channel, {type(channel)} found")
+        raise TypeError(
+            f"channel_ must be an instance of Channel, {type(channel)} found"
+        )
 
     if IS_MAIN_PROCESS:
         if name in _channel:
@@ -241,10 +280,11 @@ def set_channel(name: str, channel: "Channel"):
         # 请求主进程设置通道
         channel_deliver_passive_channel.send(
             (
-                    "set_channel", {
-                            "name"    : name,
-                            "channel_": channel,
-                    }
+                "set_channel",
+                {
+                    "name": name,
+                    "channel_": channel,
+                },
             )
         )
 
@@ -273,13 +313,7 @@ def get_channel(name: str) -> "Channel":
     else:
         recv_chan = Channel[Channel[Any]]("recv_chan")
         channel_deliver_passive_channel.send(
-            (
-                    "get_channel",
-                    {
-                            "name"     : name,
-                            "recv_chan": recv_chan
-                    }
-            )
+            ("get_channel", {"name": name, "recv_chan": recv_chan})
         )
         return recv_chan.receive()
 
@@ -294,12 +328,5 @@ def get_channels() -> dict[str, "Channel"]:
         return _channel
     else:
         recv_chan = Channel[dict[str, Channel[Any]]]("recv_chan")
-        channel_deliver_passive_channel.send(
-            (
-                    "get_channels",
-                    {
-                            "recv_chan": recv_chan
-                    }
-            )
-        )
+        channel_deliver_passive_channel.send(("get_channels", {"recv_chan": recv_chan}))
         return recv_chan.receive()

liteyuki/comm/rpc.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-本模块用于实现RPC(基于IPC)通信
-"""
-
-from typing import TypeAlias, Callable, Any
-
-from liteyuki.comm.channel import Channel
-
-ON_CALLING_FUNC: TypeAlias = Callable[[tuple, dict], Any]
-
-
-class RPC:
-    """
-    RPC类
-    """
-
-    def __init__(self, on_calling: ON_CALLING_FUNC) -> None:
-        self.on_calling = on_calling
-
-    def call(self, args: tuple, kwargs: dict) -> Any:
-        """
-        调用
-        """
-        # 获取self.calling函数名
-        return self.on_calling(args, kwargs)