CheeseSignal 1.2.1__py2.py3-none-any.whl → 2.0.0__py2.py3-none-any.whl

CheeseSignal/signal.py

@@ -1,362 +1,414 @@
-import asyncio
-from typing import List, Callable, overload, Any, TYPE_CHECKING, Literal, Tuple
-
-if TYPE_CHECKING:
-    class Signal:
-        ...
+import uuid, concurrent.futures, asyncio
+from typing import Callable, Iterable, overload, Literal
+from collections import OrderedDict
 
 class Receiver:
-    def __init__(self, signal: 'Signal', fn: Callable, *, expected_receive_num: int, auto_remove: bool, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED'):
+    __slots__ = ('_key', 'fn', 'runType', '_receiveNum_expected', 'autoRemove', '_receiveNum')
+
+    def __init__(self, fn: Callable, key: str | None = None, *, runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = 'SEQUENTIAL', receiveNum_expected: int = 0, autoRemove: bool = False):
         '''
         - Args
-            - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-            - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
+            - fn: 接收函数
+            - key: 若不设置则自动生成一个uuid格式的字符串
+            - runType: 运行方式
+                - SEQUENTIAL: 顺序执行，等待函数执行完成后再执行下一个函数
+                - PARALLEL: 并行执行，等待所有函数执行完成后再继续
+                - NO_BLOCK: 非阻塞执行，函数在后台执行，不等待函数执行完成
+            - receiveNum_expected: 期望接收总数
+            - autoRemove: 是否在达到期望接收总数后自动移除接收器
         '''
 
-        self._signal: 'Signal' = signal
+        self._key: str = key or str(uuid.uuid4())
         self.fn: Callable = fn
-        self._expected_receive_num: int = expected_receive_num
-        self._auto_remove: bool = auto_remove
-        self._total_receive_num: int = 0
-        self._active: bool = True
-        self._runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = runType
-
-    def reset(self):
-        '''
-        重统计置数据。
-
-        在有期望信号接受次数的情况下，`auto_remove is False`的接收器会重新开始计数并接收信号。
-        '''
-
-        self._total_receive_num = 0
-
-    @property
-    def expected_receive_num(self) -> int:
+        self.runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = runType
         '''
-        期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-        设置值小于`total_receive_num`且`auto_remove is True`，则会立刻删除。
+        运行方式
+        - SEQUENTIAL: 顺序执行，等待函数执行完成后再执行下一个函数
+        - PARALLEL: 并行执行，等待所有函数执行完成后再继续
+        - NO_BLOCK: 非阻塞执行，函数在后台执行，不等待函数执行完成
         '''
+        self._receiveNum_expected: int = receiveNum_expected
+        ''' 期望接收总数 '''
+        self.autoRemove: bool = autoRemove
+        ''' 是否在达到期望接收总数后自动移除接收器 '''
 
-        return self._expected_receive_num
+        self._receiveNum: int = 0
+        ''' 接收总数 '''
 
-    @expected_receive_num.setter
-    def expected_receive_num(self, value: int):
-        self._expected_receive_num = value
+    def reset(self):
+        ''' 重置统计数据 '''
 
-        if self._auto_remove and self.is_expired:
-            self._signal.receivers.remove(self)
+        self._receiveNum = 0
 
     @property
-    def auto_remove(self) -> bool:
-        '''
-        是否自动删除响应次数超出期望次数的接收器。
-
-        设置为`True`时若该receiver过期，则会立刻删除。
-        '''
-
-        return self._auto_remove
-
-    @auto_remove.setter
-    def auto_remove(self, value: bool):
-        self._auto_remove = value
-
-        if self._auto_remove and self.is_expired:
-            self._signal.receivers.remove(self)
+    def key(self) -> str:
+        return self._key
 
     @property
-    def active(self) -> bool:
-        '''
-        是否激活；未激活将忽略信号。
-        '''
-
-        return self._active
+    def receiveNum(self) -> int:
+        ''' 接收总数 '''
 
-    @active.setter
-    def active(self, value: bool):
-        self._active = value
+        return self._receiveNum
 
     @property
-    def total_receive_num(self) -> int:
-        '''
-        【只读】 总计信号接受次数。
-        '''
+    def receiveNum_expected(self) -> int:
+        ''' 期望接收总数 '''
 
-        return self._total_receive_num
+        return self._receiveNum_expected
 
     @property
-    def remaining_receive_num(self) -> int:
-        '''
-        【只读】 剩余的期望信号接受次数；返回为-1代表无期望信号接受次数。
-        '''
+    def receiveNum_remaining(self) -> int | None:
+        ''' 剩余接收总数 '''
 
-        if not self.expected_receive_num:
-            return -1
-        return self.expected_receive_num - self.total_receive_num
+        return self._receiveNum_expected - self._receiveNum if self._receiveNum_expected > 0 else None
 
     @property
-    def is_expired(self) -> bool:
-        '''
-        【只读】 是否过期。
-        '''
-
-        return not self.is_unexpired
+    def is_active(self) -> bool:
+        ''' 是否处于激活状态 '''
 
-    @property
-    def is_unexpired(self) -> bool:
-        '''
-        【只读】 是否未过期。
-        '''
+        return self._receiveNum_expected == 0 or self.receiveNum_remaining > 0
 
-        if self.remaining_receive_num == -1:
-            return True
-        return True if self.remaining_receive_num else False
+class Signal:
+    __slots__ = ('receivers', '_sendNum')
 
-    @property
-    def runType(self) -> Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']:
+    def __init__(self):
         '''
-        【只读】 运行的方式，仅在`async_send`时有效。
+        - Examples
+```python
+""" 基础用法 """
+from CheeseSignal import Signal
 
-        - ORDERED: 按顺序执行，返回结果。
+signal = Signal()
 
-        - CONCURRENT: 并行执行，返回结果。
+def handle_1():
+    print('Handler 1 executed')
+signal.connect(handle_1)
 
-        - NO_WAIT: 并行执行，不阻塞代码。
-        '''
+@signal.connect()
+def handle_2():
+    print('Handler 2 executed')
 
-        return self._runType
+if __name__ == '__main__':
+    signal.send()
 
-    @runType.setter
-    def runType(self, value: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']):
-        self._runType = value
 
-class Signal:
-    def __init__(self):
-        self._receivers: List[Receiver] = []
-        self._total_send_num: int = 0
+""" 异步用法 """
+import asyncio
 
-    @overload
-    def connect(self, fn: Callable, *, expected_receive_num: int = 0, auto_remove: bool = False, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED'):
-        '''
-        通过函数注册响应函数。
+from CheeseSignal import Signal
 
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> def receiver(*args, **kwargs):
-        ...     ...
-        >>>
-        >>> signal = Signal()
-        >>> signal.connect(receiver)
+signal = Signal()
 
-        - Args
-            - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
+async def handle_1():
+    print('Handler 1 executed')
+signal.connect(handle_1)
 
-            - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
-        '''
+@signal.connect()
+async def handle_2():
+    print('Handler 2 executed')
 
-    @overload
-    def connect(self, *, expected_receive_num: int = 0, auto_remove: bool = False):
-        '''
-        通过装饰器注册响应函数。
+if __name__ == '__main__':
+    asyncio.run(signal.async_send())
 
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> signal = Signal()
-        >>>
-        >>> @signal.connect()
-        >>> def receiver(*args, **kwargs):
-        ...     ...
 
-        - Args
-            - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
+""" 期望接收数与自动删除 """
+from CheeseSignal import Signal
 
-            - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
-        '''
+signal = Signal()
 
-    def connect(self, arg1: Callable | None = None, *, expected_receive_num: int = 0, auto_remove: bool = False, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED'):
-        if not arg1:
-            def wrapper(fn):
-                self._connect(fn, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType)
-                return fn
-            return wrapper
+@signal.connect(receiveNum_expected = 3)
+def handle_1():
+    print('Handler 1 executed')
 
-        self._connect(arg1, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType)
+@signal.connect(receiveNum_expected = 3, autoRemove = True)
+def handle_2():
+    print('Handler 2 executed')
 
-    def _connect(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']):
-        if any(receiver.fn == fn for receiver in self.receivers):
-            raise ValueError('已有重复的函数接收器')
+if __name__ == '__main__':
+    for i in range(5):
+        signal.send()
+        print(list(signal.receivers.keys()))
+```
+'''
 
-        self.receivers.append(Receiver(self, fn, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType))
+        self.receivers: OrderedDict[str, Receiver] = OrderedDict()
+        ''' 连接的接收器'''
+        self._sendNum: int = 0
+        ''' 发送总数 '''
 
-    def send(self, *args, **kwargs) -> List[Any]:
-        '''
-        发送信号。
-
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> signal = Signal()
-        >>> signal.send('data1', 'data2', **{
-        ...     'key1': 'value1',
-        ...     'key2': 'value2'
-        >>> })
-        '''
-
-        self._total_send_num += 1
-
-        if not self.receivers:
-            return []
-
-        results = []
-        for receiver in self.receivers[:]:
-            if receiver.active and receiver.is_unexpired:
-                receiver._total_receive_num += 1
-                results.append(receiver.fn(*args, **kwargs))
+    @overload
+    def getReceiver(self, key: str) -> Receiver | None:
+        ''' 获取接收器 '''
 
-                if receiver.is_expired:
-                    self.receivers.remove(receiver)
-        return results
+    @overload
+    def getReceiver(self, fn: Callable) -> Receiver | None:
+        ''' 获取接收器 '''
+
+    def getReceiver(self, arg: str | Callable) -> Receiver | None:
+        if type(arg) == str:
+            return self.receivers.get(arg, None)
+        elif callable(arg):
+            for receiver in self.receivers.values():
+                if receiver.fn == arg:
+                    return receiver
+
+    def _connect(self, fn: Callable, key: str | None = None, *, index: int = -1, insert: tuple[str | Callable | Receiver, Literal['BEFORE', 'AFTER']] | None = None, runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = 'SEQUENTIAL', receiveNum_expected: int = 0, autoRemove: bool = False):
+        if key in self.receivers:
+            raise ValueError(f'Receiver "{key}" already exists')
+
+        receiver = Receiver(fn, key, runType = runType, receiveNum_expected = receiveNum_expected, autoRemove = autoRemove)
+        items = list(self.receivers.items())
+        if index > -1:
+            items.insert(index, (receiver.key, receiver))
+            self.receivers.clear()
+            self.receivers.update(items)
+        elif insert:
+            if isinstance(insert[0], Receiver):
+                key = insert[0].key
+                if key not in self.receivers:
+                    raise ValueError(f'Receiver "{key}" does not exist')
+            elif callable(insert[0]):
+                _receiver = self.getReceiver(insert[0])
+                if not _receiver:
+                    raise ValueError(f'Receiver "{insert[0]}" does not exist')
+                key = _receiver.key
+            elif isinstance(insert[0], str):
+                key = insert[0]
+                if key not in self.receivers:
+                    raise ValueError(f'Receiver "{key}" does not exist')
+
+            for i, (_key, _) in enumerate(items):
+                if _key == key:
+                    if insert[1] == 'BEFORE':
+                        items.insert(i, (receiver.key, receiver))
+                    elif insert[1] == 'AFTER':
+                        items.insert(i + 1, (receiver.key, receiver))
+                    break
+        else:
+            self.receivers[receiver.key] = receiver
 
-    async def async_send(self, *args, **kwargs) -> Tuple[List[Any], List[Any]]:
-        '''
-        在协程环境中发送信号，并请保证所有接收函数都是协程函数。
-
-        >>> import asyncio
-        >>>
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> async def run_asyncio():
-        ...     signal = Signal()
-        ...     await signal.async_send('data1', 'data2', **{
-        ...         'key1': 'value1',
-        ...         'key2': 'value2'
-        ...     })
-        >>>
-        >>> asyncio.run(run_asyncio())
-
-        - Returns
-            返回长度为2的元祖，分别为ORDERED类型和CONCURRENT类型的结果。
+    @overload
+    def connect(self, fn: Callable, key: str | None = None, *, index: int = -1, insert: tuple[str | Callable | Receiver, Literal['BEFORE', 'AFTER']] | None = None, runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = 'SEQUENTIAL', receiveNum_expected: int = 0, autoRemove: bool = False):
         '''
+        连接接收器
 
-        self._total_send_num += 1
-
-        if not self.receivers:
-            return [], []
-
-        receivers = [receiver for receiver in self.receivers.copy() if receiver.active and receiver.is_unexpired]
+        - Args
+            - key: 接收器键值，若不设置则自动生成一个uuid格式的字符串
+            - runType: 运行类型
+                - SEQUENTIAL: 顺序执行，等待函数执行完成后再执行下一个函数
+                - PARALLEL: 并行执行，等待所有函数执行完成后再继续
+                - NO_BLOCK: 非阻塞执行，函数在后台执行，不等待函数执行完成
+            - receiveNum_expected: 期望接收总数
+            - autoRemove: 是否在达到期望接收总数后自动移除接收器
+            - index: 插入位置索引（仅对runType为SEQUENTIAL的接收器有效）
+            - insert: 插入位置；若设置index，则忽略此参数（仅对runType为SEQUENTIAL的接收器有效）
+                - BEFORE: 插入到指定接收器之前
+                - AFTER: 插入到指定接收器之后
+
+        - Examples
+```python
+from CheeseSignal import Signal
+
+signal = Signal()
+
+def handler():
+    print('Handler executed')
+signal.connect(handler)
+```
+        '''
 
-        [asyncio.create_task(receiver.fn(*args, **kwargs)) for receiver in receivers if receiver.runType == 'NO_WAIT']
-        concurrent_tasks = [receiver.fn(*args, **kwargs) for receiver in receivers if receiver.runType == 'CONCURRENT']
-        concurrent_results = await asyncio.gather(*concurrent_tasks) if concurrent_tasks else []
-        ordered_results = [await receiver.fn(*args, **kwargs) for receiver in receivers if receiver.runType == 'ORDERED']
+    @overload
+    def connect(self, key: str | None = None, *, index: int = -1, insert: tuple[str | Callable | Receiver, Literal['BEFORE', 'AFTER']] | None = None, runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = 'SEQUENTIAL', receiveNum_expected: int = 0, autoRemove: bool = False):
+        '''
+        连接接收器
 
-        for receiver in receivers:
-            receiver._total_receive_num += 1
-            if receiver.is_expired:
-                self.receivers.remove(receiver)
+        - Args
+            - key: 接收器键值，若不设置则自动生成一个uuid格式的字符串
+            - runType: 运行类型
+                - SEQUENTIAL: 顺序执行，等待函数执行完成后再执行下一个函数
+                - PARALLEL: 并行执行，等待所有函数执行完成后再继续
+                - NO_BLOCK: 非阻塞执行，函数在后台执行，不等待函数执行完成
+            - receiveNum_expected: 期望接收总数
+            - autoRemove: 是否在达到期望接收总数后自动移除接收器
+            - index: 插入位置索引（仅对runType为SEQUENTIAL的接收器有效）
+            - insert: 插入位置；若设置index，则忽略此参数（仅对runType为SEQUENTIAL的接收器有效）
+                - BEFORE: 插入到指定接收器之前
+                - AFTER: 插入到指定接收器之后
+
+        - Examples
+```python
+from CheeseSignal import Signal
+
+signal = Signal()
+
+@signal.connect()
+def handler():
+    print('Handler executed')
+```
+        '''
+
+    def connect(self, arg1: Callable | str | None = None, *args, index: int = -1, insert: tuple[str | Callable | Receiver, Literal['BEFORE', 'AFTER']] | None = None, runType: Literal['SEQUENTIAL', 'PARALLEL', 'NO_BLOCK'] = 'SEQUENTIAL', receiveNum_expected: int = 0, autoRemove: bool = False):
+        def decorator(fn: Callable):
+            self._connect(fn, arg1, index = index, insert = insert, runType = runType, receiveNum_expected = receiveNum_expected, autoRemove = autoRemove)
+            return fn
+
+        if callable(arg1):
+            self._connect(arg1, *args, index = index, insert = insert, runType = runType, receiveNum_expected = receiveNum_expected, autoRemove = autoRemove)
+        else:
+            return decorator
 
-        return concurrent_results, ordered_results
+    @overload
+    def disconnect(self, key: str):
+        ''' 断开接收器 '''
 
+    @overload
     def disconnect(self, fn: Callable):
-        '''
-        断开接收器。
-
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> def receiver(*args, **kwargs):
-        ...     ...
-        >>>
-        >>> signal = Signal()
-        >>> signal.connect(receiver)
-        >>> signal.disconnect(receiver)
-
-        - Raise
-            - ValueError: 未找到该函数的接收器。
-        '''
-
-        for receiver in self.receivers:
-            if receiver.fn == fn:
-                self.receivers.remove(receiver)
-                return
+        ''' 断开接收器 '''
 
-        raise ValueError('未找到该函数的接收器')
+    @overload
+    def disconnect(self, receiver: Receiver):
+        ''' 断开接收器 '''
+
+    def disconnect(self, arg):
+        if isinstance(arg, str):
+            key = arg
+            if key in self.receivers:
+                del self.receivers[key]
+        elif callable(arg):
+            for key in [key for key, receiver in self.receivers.items() if receiver.fn == arg]:
+                del self.receivers[key]
+        elif isinstance(arg, Receiver):
+            if arg.key in self.receivers:
+                del self.receivers[arg.key]
+
+    def disconnectAll(self):
+        ''' 断开所有接收器 '''
+
+        self.receivers.clear()
 
     def reset(self):
-        '''
-        重置统计数据；所有的接收器的统计数据也会同步清空。
-        '''
+        ''' 重置统计数据 '''
 
-        self._total_send_num = 0
-        for receiver in self.receivers:
+        self._sendNum = 0
+        for receiver in self.receivers.values():
             receiver.reset()
 
-    def disconnect_all(self):
-        '''
-        断开所有接收器。
+    @overload
+    def send(self, key: str, *, args: tuple[any, ...], kwargs: dict[str, any]):
         '''
+        发送信号
 
-        self._receivers = []
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
+        '''
 
-    def get_receiver(self, fn: Callable) -> Receiver:
+    @overload
+    def send(self, keys: Iterable[str], *, args: tuple[any, ...], kwargs: dict[str, any]):
         '''
-        获取接收器。
-
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> def receiver(*args, **kwargs):
-        ...     ...
-        >>>
-        >>> signal = Signal()
-        >>> signal.connect(receiver)
-        >>>
-        >>> print(signal.get_receiver(receiver))
-
-        - Raise
-            - ValueError: 未找到该函数的接收器。
+        发送信号
+
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
         '''
 
-        for receiver in self.receivers:
-            if receiver.fn == fn:
-                return receiver
+    @overload
+    def send(self, *, args: tuple[any, ...], kwargs: dict[str, any]):
+        '''
+        发送信号
 
-        raise ValueError('未找到该函数的接收器')
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
+        '''
+
+    def send(self, arg: str | list[str] | None = None, **kwargs):
+        if type(arg) == str:
+            self.send([arg], **kwargs)
+        elif isinstance(arg, Iterable):
+            sequential_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'SEQUENTIAL' and self.receivers[key].is_active]
+            if sequential_receivers:
+                for receiver in sequential_receivers:
+                    self._sendHandle(receiver, **kwargs)
+
+            parallel_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'PARALLEL' and self.receivers[key].is_active]
+            if parallel_receivers:
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    concurrent.futures.as_completed([executor.submit(self._sendHandle, receiver, **kwargs) for receiver in parallel_receivers])
+
+            noBlock_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'NO_BLOCK' and self.receivers[key].is_active]
+            if noBlock_receivers:
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    for receiver in noBlock_receivers:
+                        executor.submit(self._sendHandle, receiver, **kwargs)
+        else:
+            self.send(self.receivers.keys(), **kwargs)
+
+    def _sendHandle(self, receiver: Receiver, **kwargs):
+        receiver.fn(*kwargs.get('args', ()), **kwargs.get('kwargs', {}))
+        receiver._receiveNum += 1
+        if receiver.autoRemove and not receiver.is_active:
+            self.disconnect(receiver.key)
 
-    def index(self, fn: Callable) -> int:
-        '''
-        获取接收器的顺序位置；若`runType != 'ORDERED'`，则为-1。
-
-        >>> from CheeseSignal import Signal
-        >>>
-        >>> def receiver(*args, **kwargs):
-        ...     ...
-        >>>
-        >>> signal = Signal()
-        >>> signal.connect(receiver)
-        >>>
-        >>> print(signal.index(receiver))
-
-        - Raise
-            - ValueError: 未找到该函数的接收器。
+    @overload
+    def async_send(self, key: str, *, args: tuple[any, ...], kwargs: dict[str, any]):
         '''
+        发送信号
 
-        for i, receiver in enumerate(self.receivers):
-            if receiver.fn == fn:
-                return i + 1 if receiver.runType == 'ORDERED' else -1
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
+        '''
 
-        raise ValueError('未找到该函数的接收器')
+    @overload
+    def async_send(self, keys: Iterable[str], *, args: tuple[any, ...], kwargs: dict[str, any]):
+        '''
+        发送信号
 
-    @property
-    def receivers(self) -> List[Receiver]:
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
         '''
-        【只读】 接收器的列表，按注册顺序排序。
+
+    @overload
+    def async_send(self, *, args: tuple[any, ...], kwargs: dict[str, any]):
         '''
+        发送信号
 
-        return self._receivers
+        - Args
+            - args: *args参数
+            - kwargs: **kwargs参数
+        '''
+
+    async def async_send(self, arg: str | list[str] | None = None, **kwargs):
+        if type(arg) == str:
+            await self.async_send([arg], **kwargs)
+        elif isinstance(arg, Iterable):
+            sequential_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'SEQUENTIAL' and self.receivers[key].is_active]
+            if sequential_receivers:
+                for receiver in sequential_receivers:
+                    await self._async_sendHandle(receiver, **kwargs)
+
+            parallel_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'PARALLEL' and self.receivers[key].is_active]
+            if parallel_receivers:
+                await asyncio.gather(*[asyncio.create_task(self._async_sendHandle(receiver, **kwargs)) for receiver in parallel_receivers])
+
+            noBlock_receivers = [self.receivers[key] for key in arg if key in self.receivers and self.receivers[key].runType == 'NO_BLOCK' and self.receivers[key].is_active]
+            if noBlock_receivers:
+                for receiver in noBlock_receivers:
+                    asyncio.create_task(self._async_sendHandle(receiver, **kwargs))
+        else:
+            await self.async_send(self.receivers.keys(), **kwargs)
+
+    async def _async_sendHandle(self, receiver: Receiver, **kwargs):
+        await receiver.fn(*kwargs.get('args', ()), **kwargs.get('kwargs', {}))
+        receiver._receiveNum += 1
+        if receiver.autoRemove and receiver.receiveNum_remaining == 0:
+            self.disconnect(receiver.key)
 
     @property
-    def total_send_num(self) -> int:
-        '''
-        【只读】 总计信号发送次数。
-        '''
+    def sendNum(self) -> int:
+        ''' 发送总数 '''
 
-        return self._total_send_num
+        return self._sendNum

cheesesignal-2.0.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: CheeseSignal
+Version: 2.0.0
+Summary: 一款简约的信号系统。
+Project-URL: Source, https://github.com/CheeseUnknown/CheeseSignal
+Author-email: Cheese Unknown <cheese@cheese.ren>
+License-File: LICENSE
+Keywords: Signal
+Description-Content-Type: text/markdown
+
+# **CheeseSignal**
+
+一款简单的信号系统。
+
+## **示例**
+
+### **基础用法**
+
+```python
+from CheeseSignal import Signal
+
+signal = Signal()
+
+def handle_1():
+    print('Handler 1 executed')
+signal.connect(handle_1)
+
+@signal.connect()
+def handle_2():
+    print('Handler 2 executed')
+
+if __name__ == '__main__':
+    signal.send()
+```
+
+### **异步用法**
+
+```python
+import asyncio
+
+from CheeseSignal import Signal
+
+signal = Signal()
+
+async def handle_1():
+    print('Handler 1 executed')
+signal.connect(handle_1)
+
+@signal.connect()
+async def handle_2():
+    print('Handler 2 executed')
+
+if __name__ == '__main__':
+    asyncio.run(signal.async_send())
+```
+
+### **期望接收数与自动删除**
+
+```python
+from CheeseSignal import Signal
+
+signal = Signal()
+
+@signal.connect(receiveNum_expected = 3)
+def handle_1():
+    print('Handler 1 executed')
+
+@signal.connect(receiveNum_expected = 3, autoRemove = True)
+def handle_2():
+    print('Handler 2 executed')
+
+if __name__ == '__main__':
+    for i in range(5):
+        signal.send()
+        print(list(signal.receivers.keys()))
+```
+
+## **更多...**
+
+### 1. [**Signal**](https://github.com/CheeseUnknown/CheeseSignal/blob/master/documents/Signal.md)
+
+### 2. [**Receiver**](https://github.com/CheeseUnknown/CheeseSignal/blob/master/documents/Receiver.md)

cheesesignal-2.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+CheeseSignal/__init__.py,sha256=--LvG_YyRo9N3ubHlhunm4FiiMD60hM2LsdB9uiprPM,49
+CheeseSignal/signal.py,sha256=Sh4s2d1SEaG9cgX0EP1jO42KVcAaywJKVomhN55KO30,15380
+cheesesignal-2.0.0.dist-info/METADATA,sha256=fVIWqdeQmQG6KZAJeBI4nuAEcehpfiWunFqHiPamzvw,1600
+cheesesignal-2.0.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+cheesesignal-2.0.0.dist-info/licenses/LICENSE,sha256=5vFb3i4UDlskszJ3jGPh8bXrM_axJfDRRuvLu1M3bIs,1070
+cheesesignal-2.0.0.dist-info/RECORD,,

{cheesesignal-1.2.1.dist-info → cheesesignal-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

cheesesignal-1.2.1.dist-info/METADATA

@@ -1,273 +0,0 @@
-Metadata-Version: 2.3
-Name: CheeseSignal
-Version: 1.2.1
-Summary: 一款简约的信号系统。
-Project-URL: Source, https://github.com/CheeseUnknown/CheeseSignal
-Author-email: Cheese Unknown <cheese@cheese.ren>
-License-File: LICENSE
-Keywords: Signal
-Description-Content-Type: text/markdown
-
-# **CheeseSignal**
-
-一款简单的信号系统。
-
-## **安装**
-
-系统要求：Linux。
-
-Python要求：目前仅保证支持3.11及以上版本的Python，新版本会优先支持Python的最新稳定版本。
-
-```
-pip install CheeseSignal
-```
-
-## **使用**
-
-使用方式较为简单，通过函数或装饰件连接至某个信号，随后等待信号发送。
-
-```python
-import time
-
-from CheeseSignal import signal
-
-signal = Signal()
-
-def receiver1(*args, **kwargs):
-    print(arg, kwargs)
-signal.connect(receiver1)
-
-@signal.connect()
-def receiver2(*args, **kwargs):
-    return args, kwargs
-
-while True:
-    print(signal.send('Hello', 'World', {
-        'Cheese': 'Signal'
-    }))
-    time.sleep(1)
-```
-
-## **接口文档**
-
-### **`class Signal`**
-
-```python
-from CheeseSignal import Signal
-
-signal = Signal()
-```
-
-#### **`self.receivers: List[Receiver]`**
-
-【只读】 接收器的列表，按注册顺序排序。
-
-#### **`self.total_send_num: int`**
-
-【只读】 总计信号发送次数。
-
-#### **`def connect(self, fn: Callable, *, expected_receive_num: int = 0, auto_remove: bool = False, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED')`**
-
-通过函数注册响应函数。
-
-- **参数**
-
-    - `expected_receive_num`: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-    - `auto_remove`: 是否自动删除响应次数超出期望次数的接收器。
-
-    - `runType`: 运行的方式，仅在`async_send`时有效。
-
-        - ORDERED: 按顺序执行，返回结果。
-
-        - CONCURRENT: 并行执行，返回结果。
-
-        - NO_WAIT: 并行执行，不阻塞代码。
-
-- **报错**
-
-    - `ValueError`: 已有重复的函数接收器。
-
-#### **`def connect(self, *, expected_receive_num: int = 0, auto_remove: bool = False, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED')`**
-
-通过装饰器注册响应函数。
-
-- **参数**
-
-    - `expected_receive_num`: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-    - `auto_remove`: 是否自动删除响应次数超出期望次数的接收器。
-
-    - `runType`: 运行的方式，仅在`async_send`时有效。
-
-        - ORDERED: 按顺序执行，返回结果。
-
-        - CONCURRENT: 并行执行，返回结果。
-
-        - NO_WAIT: 并行执行，不阻塞代码。
-
-- **报错**
-
-    - `ValueError`: 已有重复的函数接收器。
-
-#### **`def send(self, *args, **kwargs) -> List[Any]`**
-
-发送信号。
-
-#### **`async def async_send(self, *args, **kwargs) -> List[Any]`**
-
-在协程环境中发送信号，并请保证所有接收函数都是协程函数。
-
-```python
-import asyncio
-
-from CheeseSignal import Signal
-
-async def run_asyncio():
-    signal = Signal()
-    await signal.async_send('data1', 'data2', **{
-        'key1': 'value1',
-        'key2': 'value2'
-    })
-
-asyncio.run(run_asyncio())
-```
-
-#### **`def disconnect(self, fn: Callable)`**
-
-断开接收器。
-
-```python
-from CheeseSignal import Signal
-
-def receiver(*args, **kwargs):
-    ...
-
-signal = Signal()
-signal.connect(receiver)
-signal.disconnect(receiver)
-```
-
-- **报错**
-
-    - `ValueError`: 未找到该函数的接收器。
-
-#### **`def reset(self)`**
-
-重置统计数据；所有的接收器的统计数据也会同步清空。
-
-#### **`def disconnect_all(self)`**
-
-断开所有接收器。
-
-#### **`def get_receiver(self, fn: Callable) -> Receiver`**
-
-获取接收器。
-
-```python
-from CheeseSignal import Signal
-
-def receiver(*args, **kwargs):
-    ...
-
-signal = Signal()
-signal.connect(receiver)
-
-print(signal.get_receiver(receiver))
-```
-
-- **报错**
-
-    - `ValueError`: 未找到该函数的接收器。
-
-#### **`def index(self, fn: Callable) -> int`**
-
-获取接收器的顺序位置；若`runType != 'ORDERED'`，则为-1。
-
-```python
-from CheeseSignal import Signal
-
-def receiver(*args, **kwargs):
-    ...
-
-signal = Signal()
-signal.connect(receiver)
-
-print(signal.index(receiver))
-```
-
-- **报错**
-
-    - `ValueError`: 未找到该函数的接收器。
-
-### **`class Receiver`**
-
-正常使用并不需要手动创建该类。
-
-```python
-from CheeseSignal import Receiver
-```
-
-#### **`def __init__(self, signal: Signal, fn: Callable, *, expected_receive_num: int, auto_remove: bool, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED')`**
-
-- **参数**
-
-    - `expected_receive_num`: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-    - `auto_remove`: 是否自动删除响应次数超出期望次数的接收器。
-
-    - `runType`: 运行的方式，仅在`async_send`时有效。
-
-        - ORDERED: 按顺序执行，返回结果。
-
-        - CONCURRENT: 并行执行，返回结果。
-
-        - NO_WAIT: 并行执行，不阻塞代码。
-
-#### **`self.expected_receive_num: int`**
-
-期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
-
-设置值小于`total_receive_num`且`auto_remove is True`，则会立刻删除。
-
-#### **`self.auto_remove: bool`**
-
-是否自动删除响应次数超出期望次数的接收器。
-
-设置为`True`且`is_expired is True`，则会立刻删除。
-
-#### **`self.active: bool`**
-
-是否激活；未激活将忽略信号。
-
-#### **`self.total_receive_num: int`**
-
-【只读】 总计信号接受次数。
-
-#### **`self.remaining_receive_num: int`**
-
-【只读】 剩余的期望信号接受次数；返回为-1代表无期望信号接受次数。
-
-#### **`self.is_expired: bool`**
-
-【只读】 是否过期。
-
-#### **`self.is_unexpired: bool`**
-
-【只读】 是否未过期。
-
-#### **`self.runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']`**
-
-【只读】 运行的方式，仅在`async_send`时有效。
-
-- ORDERED: 按顺序执行，返回结果。
-
-- CONCURRENT: 并行执行，返回结果。
-
-- NO_WAIT: 并行执行，不阻塞代码。
-
-#### **`def reset(self)`**
-
-重统计置数据。
-
-在有期望信号接受次数的情况下，`auto_remove is False`的接收器会重新开始计数并接收信号。

cheesesignal-1.2.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-CheeseSignal/__init__.py,sha256=--LvG_YyRo9N3ubHlhunm4FiiMD60hM2LsdB9uiprPM,49
-CheeseSignal/signal.py,sha256=EqI99dbN7Wyxb7hvd3h9JQWruHeRHOKcHbXp4DwSfqs,11019
-cheesesignal-1.2.1.dist-info/METADATA,sha256=3obooywZfLiOHcegmLzSU1tqml1ZrIZfklxI9aniaf4,6334
-cheesesignal-1.2.1.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
-cheesesignal-1.2.1.dist-info/licenses/LICENSE,sha256=5vFb3i4UDlskszJ3jGPh8bXrM_axJfDRRuvLu1M3bIs,1070
-cheesesignal-1.2.1.dist-info/RECORD,,