CheeseSignal 1.0.0__tar.gz → 1.2.0__tar.gz

cheesesignal-1.2.0/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+__pycache__
+.vscode
+.conda
+dist
+logs

cheesesignal-1.2.0/CheeseSignal/__init__.py

@@ -0,0 +1 @@
+from CheeseSignal.signal import Receiver, Signal

cheesesignal-1.0.0/CheeseSignal/__init__.py → cheesesignal-1.2.0/CheeseSignal/signal.py

@@ -1,18 +1,26 @@
-from typing import List, Callable, overload, Any
+import asyncio
+from typing import List, Callable, overload, Any, TYPE_CHECKING, Literal, Tuple
+
+if TYPE_CHECKING:
+    class Signal:
+        ...
 
 class Receiver:
-    def __init__(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool):
+    def __init__(self, signal: 'Signal', fn: Callable, *, expected_receive_num: int, auto_remove: bool, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED'):
         '''
         - Args
-
             - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
 
             - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
         '''
+
+        self._signal: 'Signal' = signal
         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):
         '''
@@ -27,6 +35,8 @@ class Receiver:
     def expected_receive_num(self) -> int:
         '''
         期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
+
+        设置值小于`total_receive_num`且`auto_remove is True`，则会立刻删除。
         '''
 
         return self._expected_receive_num
@@ -35,10 +45,15 @@ class Receiver:
     def expected_receive_num(self, value: int):
         self._expected_receive_num = value
 
+        if self._auto_remove and self.is_expired:
+            self._signal.receivers.remove(self)
+
     @property
     def auto_remove(self) -> bool:
         '''
         是否自动删除响应次数超出期望次数的接收器。
+
+        设置为`True`时若该receiver过期，则会立刻删除。
         '''
 
         return self._auto_remove
@@ -47,6 +62,21 @@ class Receiver:
     def auto_remove(self, value: bool):
         self._auto_remove = value
 
+        if self._auto_remove and self.is_expired:
+            self._signal.receivers.remove(self)
+
+    @property
+    def active(self) -> bool:
+        '''
+        是否激活；未激活将忽略信号。
+        '''
+
+        return self._active
+
+    @active.setter
+    def active(self, value: bool):
+        self._active = value
+
     @property
     def total_receive_num(self) -> int:
         '''
@@ -66,9 +96,17 @@ class Receiver:
         return self.expected_receive_num - self.total_receive_num
 
     @property
-    def receivable(self) -> bool:
+    def is_expired(self) -> bool:
         '''
-        【只读】 当前Receiver是否处于可接收信号状态。
+        【只读】 是否过期。
+        '''
+
+        return not self.is_unexpired
+
+    @property
+    def is_unexpired(self) -> bool:
+        '''
+        【只读】 是否未过期。
         '''
 
         if self.remaining_receive_num == -1:
@@ -76,12 +114,22 @@ class Receiver:
         return True if self.remaining_receive_num else False
 
     @property
-    def unreceivable(self) -> bool:
+    def runType(self) -> Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']:
         '''
-        【只读】 当前Receiver是否处于不可接收信号状态。
+        【只读】 运行的方式，仅在`async_send`时有效。
+
+        - ORDERED: 按顺序执行，返回结果。
+
+        - CONCURRENT: 并行执行，返回结果。
+
+        - NO_WAIT: 并行执行，不阻塞代码。
         '''
 
-        return not self.receivable
+        return self._runType
+
+    @runType.setter
+    def runType(self, value: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']):
+        self._runType = value
 
 class Signal:
     def __init__(self):
@@ -89,28 +137,24 @@ class Signal:
         self._total_send_num: int = 0
 
     @overload
-    def connect(self, fn: Callable, *, expected_receive_num: int = 0, auto_remove: bool = False):
+    def connect(self, fn: Callable, *, expected_receive_num: int = 0, auto_remove: bool = False, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT'] = 'ORDERED'):
         '''
         通过函数注册响应函数。
 
-        ```python
-        from CheeseSignal import Signal
-
-        def receiver(*args, **kwargs):
-            ...
-
-        signal = Signal()
-        signal.connect(receiver)
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> def receiver(*args, **kwargs):
+        ...     ...
+        >>>
+        >>> signal = Signal()
+        >>> signal.connect(receiver)
 
         - Args
-
             - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
 
             - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
 
         - Raise
-
             - ValueError: 已有重复的函数接收器。
         '''
 
@@ -119,119 +163,109 @@ class Signal:
         '''
         通过装饰器注册响应函数。
 
-        ```python
-        from CheeseSignal import Signal
-
-        signal = Signal()
-
-        @signal.connect()
-        def receiver(*args, **kwargs):
-            ...
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> signal = Signal()
+        >>>
+        >>> @signal.connect()
+        >>> def receiver(*args, **kwargs):
+        ...     ...
 
         - Args
-
             - expected_receive_num: 期望接受信号的次数，超过该次数则不再响应信号；0为无限次。
 
             - auto_remove: 是否自动删除响应次数超出期望次数的接收器。
 
         - Raise
-
             - ValueError: 已有重复的函数接收器。
         '''
 
-    def connect(self, arg1: Callable | None = None, *, expected_receive_num: int = 0, auto_remove: bool = False):
+    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)
+                self._connect(fn, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType)
                 return fn
             return wrapper
 
-        self._connect(arg1, expected_receive_num = expected_receive_num, auto_remove = auto_remove)
+        self._connect(arg1, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType)
 
-    def _connect(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool):
+    def _connect(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool, runType: Literal['ORDERED', 'CONCURRENT', 'NO_WAIT']):
         for receiver in self.receivers:
             if receiver.fn == fn:
                 raise ValueError('已有重复的函数接收器')
 
-        self.receivers.append(Receiver(fn, expected_receive_num = expected_receive_num, auto_remove = auto_remove))
+        self.receivers.append(Receiver(self, fn, expected_receive_num = expected_receive_num, auto_remove = auto_remove, runType = runType))
 
     def send(self, *args, **kwargs) -> List[Any]:
         '''
         发送信号。
 
-        ```python
-        from CheeseSignal import Signal
-
-        signal = Signal()
-        signal.send('data1', 'data2', **{
-            'key1': 'value1',
-            'key2': 'value2'
-        })
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> signal = Signal()
+        >>> signal.send('data1', 'data2', **{
+        ...     'key1': 'value1',
+        ...     'key2': 'value2'
+        >>> })
         '''
 
         self._total_send_num += 1
 
         results = []
         for receiver in self.receivers[:]:
-            if receiver.remaining_receive_num > 0 or receiver.remaining_receive_num == -1:
+            if receiver.active and receiver.is_unexpired:
                 receiver._total_receive_num += 1
                 results.append(receiver.fn(*args, **kwargs))
 
-                if receiver.remaining_receive_num == 0 and receiver.auto_remove:
+                if receiver.is_expired:
                     self.receivers.remove(receiver)
         return results
 
-    async def async_send(self, *args, **kwargs) -> List[Any]:
+    async def async_send(self, *args, **kwargs) -> Tuple[List[Any], List[Any]]:
         '''
         在协程环境中发送信号，并请保证所有接收函数都是协程函数。
 
-        ```python
-        import asyncio
+        >>> 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())
 
-        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类型的结果。
         '''
 
         self._total_send_num += 1
+        receivers = [receiver for receiver in self.receivers.copy() if receiver.active and receiver.is_unexpired]
 
-        results = []
-        for receiver in self.receivers[:]:
-            if receiver.remaining_receive_num > 0 or receiver.remaining_receive_num == -1:
-                receiver._total_receive_num += 1
-                results.append(await receiver.fn(*args, **kwargs))
+        [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']
 
-                if receiver.remaining_receive_num == 0 and receiver.auto_remove:
-                    self.receivers.remove(receiver)
-        return results
+        return concurrent_results, ordered_results
 
     def disconnect(self, fn: Callable):
         '''
         断开接收器。
 
-        ```python
-        from CheeseSignal import Signal
-
-        def receiver(*args, **kwargs):
-            ...
-
-        signal = Signal()
-        signal.connect(receiver)
-        signal.disconnect(receiver)
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> def receiver(*args, **kwargs):
+        ...     ...
+        >>>
+        >>> signal = Signal()
+        >>> signal.connect(receiver)
+        >>> signal.disconnect(receiver)
 
         - Raise
-
             - ValueError: 未找到该函数的接收器。
         '''
 
@@ -262,20 +296,17 @@ class Signal:
         '''
         获取接收器。
 
-        ```python
-        from CheeseSignal import Signal
-
-        def receiver(*args, **kwargs):
-            ...
-
-        signal = Signal()
-        signal.connect(receiver)
-
-        print(signal.get_receiver(receiver))
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> def receiver(*args, **kwargs):
+        ...     ...
+        >>>
+        >>> signal = Signal()
+        >>> signal.connect(receiver)
+        >>>
+        >>> print(signal.get_receiver(receiver))
 
         - Raise
-
             - ValueError: 未找到该函数的接收器。
         '''
 
@@ -289,20 +320,17 @@ class Signal:
         '''
         获取接收器的顺序位置。
 
-        ```python
-        from CheeseSignal import Signal
-
-        def receiver(*args, **kwargs):
-            ...
-
-        signal = Signal()
-        signal.connect(receiver)
-
-        print(signal.index(receiver))
-        ```
+        >>> from CheeseSignal import Signal
+        >>>
+        >>> def receiver(*args, **kwargs):
+        ...     ...
+        >>>
+        >>> signal = Signal()
+        >>> signal.connect(receiver)
+        >>>
+        >>> print(signal.index(receiver))
 
         - Raise
-
             - ValueError: 未找到该函数的接收器。
         '''
 

{cheesesignal-1.0.0 → cheesesignal-1.2.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: CheeseSignal
-Version: 1.0.0
+Version: 1.2.0
 Summary: 一款简约的信号系统。
 Project-URL: Source, https://github.com/CheeseUnknown/CheeseSignal
 Author-email: Cheese Unknown <cheese@cheese.ren>
 License-File: LICENSE
-Keywords: API,BackEnd
+Keywords: Signal
 Description-Content-Type: text/markdown
 
 # **CheeseSignal**
@@ -192,7 +192,7 @@ print(signal.index(receiver))
 from CheeseSignal import Receiver
 ```
 
-#### **`def __init__(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool)`**
+#### **`def __init__(self, signal: Signal, fn: Callable, *, expected_receive_num: int, auto_remove: bool)`**
 
 - **参数**
 
@@ -204,10 +204,18 @@ from CheeseSignal import Receiver
 
 期望接受信号的次数，超过该次数则不再响应信号；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`**
 
 【只读】 总计信号接受次数。
@@ -216,13 +224,13 @@ from CheeseSignal import Receiver
 
 【只读】 剩余的期望信号接受次数；返回为-1代表无期望信号接受次数。
 
-#### **`self.receivable: bool`**
+#### **`self.is_expired: bool`**
 
-【只读】 当前Receiver是否处于可接收信号状态。
+【只读】 是否过期。
 
-#### **`self.unreceivable: bool`**
+#### **`self.is_unexpired: bool`**
 
-【只读】 当前Receiver是否处于不可接收信号状态。
+【只读】 是否未过期。
 
 #### **`def reset(self)`**
 

{cheesesignal-1.0.0 → cheesesignal-1.2.0}/README.md

@@ -182,7 +182,7 @@ print(signal.index(receiver))
 from CheeseSignal import Receiver
 ```
 
-#### **`def __init__(self, fn: Callable, *, expected_receive_num: int, auto_remove: bool)`**
+#### **`def __init__(self, signal: Signal, fn: Callable, *, expected_receive_num: int, auto_remove: bool)`**
 
 - **参数**
 
@@ -194,10 +194,18 @@ from CheeseSignal import Receiver
 
 期望接受信号的次数，超过该次数则不再响应信号；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`**
 
 【只读】 总计信号接受次数。
@@ -206,13 +214,13 @@ from CheeseSignal import Receiver
 
 【只读】 剩余的期望信号接受次数；返回为-1代表无期望信号接受次数。
 
-#### **`self.receivable: bool`**
+#### **`self.is_expired: bool`**
 
-【只读】 当前Receiver是否处于可接收信号状态。
+【只读】 是否过期。
 
-#### **`self.unreceivable: bool`**
+#### **`self.is_unexpired: bool`**
 
-【只读】 当前Receiver是否处于不可接收信号状态。
+【只读】 是否未过期。
 
 #### **`def reset(self)`**
 

{cheesesignal-1.0.0 → cheesesignal-1.2.0}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "CheeseSignal"
-version = "1.0.0"
+version = "1.2.0"
 description = "一款简约的信号系统。"
 readme = "README.md"
 license-files = { paths = [ "LICENSE" ] }
 authors = [
     { name = "Cheese Unknown", email = "cheese@cheese.ren" }
 ]
-keywords = [ 'API', 'BackEnd' ]
+keywords = [ 'Signal' ]
 
 dependencies = []
 

cheesesignal-1.0.0/.gitignore

@@ -1,9 +0,0 @@
-.DS_Store
-
-__pycache__
-
-/.vscode
-/.conda
-/dist
-/test.py
-/logs