python-library-callback 0.1.1__tar.gz

python_library_callback-0.1.1/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.pytest_cache/
+config.yaml
+logs/

python_library_callback-0.1.1/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: python-library-callback
+Version: 0.1.1
+Requires-Python: >=3.10

python_library_callback-0.1.1/callback/__init__.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+from typing import ClassVar, Callable, TypeVar
+import asyncio
+import logging
+import inspect
+from concurrent.futures import ThreadPoolExecutor
+
+logger = logging.getLogger(__name__)
+T = TypeVar("T", bound="Callback")
+
+class Callback():
+    """
+    回调
+
+    定义回调结构时：
+        class A(Callback):
+            attr: type
+
+    触发回调时：
+        cb = A.trigger(attr=value) # 同步
+        cb = await A.atrigger(attr=value) # 异步
+
+    为函数注册回调时：
+        @A
+        def func(cb:A):
+            pass
+    """
+    function_registry: ClassVar[dict[str, list[Callable]]] = {}
+    """注册的函数列表"""
+    _async: ClassVar[bool] = False
+    """是否异步"""
+
+    def __new__(cls, *args, **kwargs):
+        """支持把 Callback 子类直接当装饰器使用"""
+        if len(args) == 1 and not kwargs and callable(args[0]):
+            func = args[0]
+            if cls._async != asyncio.iscoroutinefunction(func):
+                raise ValueError(
+                    f"函数{func}是{'异步' if asyncio.iscoroutinefunction(func) else '同步'}，"
+                    f"但回调{cls.__name__}是{'异步' if cls._async else '同步'}"
+                )
+            cls.register(func)
+            return func
+        return super().__new__(cls)
+
+    def __init__(self, *args, **kwargs):
+        """初始化事件实例"""
+        field_names = list(self.__class__.__annotations__.keys())
+        for i, arg in enumerate(args):
+            if i < len(field_names):
+                setattr(self, field_names[i], arg)
+            else:
+                raise ValueError(f"参数过多[{i}]: {arg}")
+        for key, value in kwargs.items():
+            if key in field_names:
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"未知属性[{key}]: {value}")
+
+    @classmethod
+    def register(cls, func: Callable):
+        """注册函数"""
+        try:
+            if cls.__name__ not in cls.function_registry:
+                cls.function_registry[cls.__name__] = []
+            if func not in cls.function_registry[cls.__name__]:
+                cls.function_registry[cls.__name__].append(func)
+        except Exception as e:
+            logger.exception(f"注册函数{func}失败: {e}")
+            raise e
+
+    @classmethod
+    def trigger(cls:type[T],*args,**kwargs) -> T:
+        """同步触发回调"""
+        try:
+            self = cls(*args, **kwargs)
+
+            self.before_trigger()
+            funcs = cls.function_registry.get(cls.__name__, [])
+            with ThreadPoolExecutor() as executor:
+                futures = [executor.submit(self._call_registered, func, self) for func in funcs]
+                for future in futures:
+                    future.result()
+            self.after_trigger()
+
+            return self
+        except Exception as e:
+            logger.exception(f"触发回调{cls}失败: {e}")
+            raise e
+
+    @classmethod
+    async def atrigger(cls:type[T],*args,**kwargs) -> T:
+        """异步触发回调"""
+        try:
+            self = cls(*args, **kwargs)
+
+            await self.before_atrigger()
+            funcs = cls.function_registry.get(cls.__name__, [])
+            tasks = [self._acall_registered(func, self) for func in funcs]
+            if tasks:
+                await asyncio.gather(*tasks)
+            await self.after_atrigger()
+
+            return self
+        except Exception as e:
+            logger.exception(f"异步触发回调{cls}失败: {e}")
+            raise e
+
+    def before_trigger(self) -> None:
+        """同步触发前钩子"""
+        pass
+
+    async def before_atrigger(self) -> None:
+        """异步触发前钩子"""
+        pass
+
+    def after_trigger(self) -> None:
+        """同步触发后钩子"""
+        pass
+
+    async def after_atrigger(self) -> None:
+        """异步触发后钩子"""
+        pass
+
+    @staticmethod
+    def _call_registered(func: Callable, cb: "Callback"):
+        """同步调用注册的函数，支持不传参数"""
+        try:
+            sig = inspect.signature(func)
+        except (TypeError, ValueError):
+            return func(cb)
+
+        params = list(sig.parameters.values())
+        positional = [
+            p for p in params
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            )
+        ]
+        has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
+
+        if has_varargs or len(positional) >= 1:
+            return func(cb)
+        return func()
+
+    @staticmethod
+    async def _acall_registered(func: Callable, cb: "Callback"):
+        """异步调用注册的函数，支持不传参数"""
+        try:
+            sig = inspect.signature(func)
+        except (TypeError, ValueError):
+            return await func(cb)
+
+        params = list(sig.parameters.values())
+        positional = [
+            p for p in params
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            )
+        ]
+        has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
+
+        if has_varargs or len(positional) >= 1:
+            return await func(cb)
+        return await func()
+
+    @classmethod
+    def get_all(cls) -> list[type[Callback]]:
+        """获取所有回调"""
+        return list(cls.__subclasses__())
+
+__all__ = [
+    "Callback",
+]

python_library_callback-0.1.1/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python-library-callback"
+version = "0.1.1"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.hatch.build.targets.wheel]
+packages = ["callback"]

python_library_callback-0.1.1/test.bat

@@ -0,0 +1,10 @@
+@echo off
+cd /d %~dp0
+
+if not exist .venv (
+    python -m venv .venv
+)
+
+call .venv\Scripts\activate.bat
+python -m pip install -e .
+python -m unittest discover -s tests -p "test_*.py"

python_library_callback-0.1.1/tests/test_callback.py

@@ -0,0 +1,28 @@
+import unittest
+
+from callback import Callback
+
+
+class CallbackTests(unittest.TestCase):
+    def tearDown(self) -> None:
+        Callback.function_registry.clear()
+
+    def test_trigger_invokes_registered_handler(self) -> None:
+        class Inc(Callback):
+            callback_name: str = "Inc"
+            name: str
+            data: int
+
+        class Holder:
+            def __init__(self) -> None:
+                @Inc
+                def _(cb: Inc) -> None:
+                    cb.data += 1
+
+        Holder()
+        cb = Inc.trigger(name="test", data=1)
+        self.assertEqual(cb.data, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()