✨ 重构Caller类，移除泛型参数；添加函数签名复制装饰器

nonebot_plugin_marshoai/plugin/func_call/caller.py

@@ -1,36 +1,34 @@
-from typing import Generic, TypeVar
+import inspect
+from typing import Any
 
 from nonebot import logger
+from nonebot.adapters import Event
 
-from ..typing import FUNCTION_CALL_FUNC
-from .params import P
+from ..typing import ASYNC_FUNCTION_CALL_FUNC, F
+from .utils import async_wrap, is_coroutine_callable
 
-F = TypeVar("F", bound=FUNCTION_CALL_FUNC)
+_caller_data: dict[str, "Caller"] = {}
 
 
-class Caller(Generic[P]):
+class Caller:
     def __init__(self, name: str | None = None, description: str | None = None):
         self._name = name
         self._description = description
-        self._parameters: dict[str, P] = {}
-        self.func: FUNCTION_CALL_FUNC | None = None
+        self.func: ASYNC_FUNCTION_CALL_FUNC | None = None
+        self._parameters: dict[str, Any] = {}
+        """依赖注入的参数"""
+        self.event: Event | None = None
 
-    def params(self, **kwargs: P) -> "Caller":
-        """设置多个函数参数
-        Args:
-            **kwargs: 参数字典
-        Returns:
-            Caller: Caller对象
-        """
+    def params(self, **kwargs: Any) -> "Caller":
         self._parameters.update(kwargs)
         return self
 
-    def param(self, name: str, param: P) -> "Caller":
+    def param(self, name: str, param: Any) -> "Caller":
         """设置一个函数参数
 
         Args:
             name (str): 参数名
-            param (P): 参数对象
+            param (Any): 参数对象
 
         Returns:
             Caller: Caller对象
@@ -51,14 +49,6 @@ class Caller(Generic[P]):
         return self
 
     def description(self, description: str) -> "Caller":
-        """设置函数描述
-
-        Args:
-            description (str): 函数描述
-
-        Returns:
-            Caller: Caller对象
-        """
         self._description = description
         return self
 
@@ -71,12 +61,78 @@ class Caller(Generic[P]):
         Returns:
             F: 函数对象
         """
+        global _caller_data
+        if self._name is None:
+            if module := inspect.getmodule(func):
+                module_name = module.__name__.split(".")[-1]
+            else:
+                module_name = "global"
+            self._name = f"{module_name}-{func.__name__}"
+        _caller_data[self._name] = self
+
+        if is_coroutine_callable(func):
+            self.func = func  # type: ignore
+        else:
+            self.func = async_wrap(func)  # type: ignore
+
+        if module := inspect.getmodule(func):
+            module_name = module.__name__ + "."
+        else:
+            module_name = ""
         logger.opt(colors=True).info(
-            f"<y>加载函数 {func.__name__} {self._description}</y>"
+            f"<y>加载函数 {module_name}{func.__name__}: {self._description}</y>"
         )
-        self.func = func
+
         return func
 
+    def data(self) -> dict[str, Any]:
+        """返回函数的json数据
+
+        Returns:
+            dict[str, Any]: 函数的json数据
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": self._name,
+                "description": self._description,
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        key: value.data() for key, value in self._parameters.items()
+                    },
+                },
+                "required": [
+                    key
+                    for key, value in self._parameters.items()
+                    if value.default is None
+                ],
+            },
+        }
+
+    def set_event(self, event: Event):
+        self.event = event
+
+    async def call(self, *args: Any, **kwargs: Any) -> Any:
+        """调用函数
+
+        Returns:
+            Any: 函数返回值
+        """
+        if self.func is None:
+            raise ValueError("未注册函数对象")
+        sig = inspect.signature(self.func)
+        for name, param in sig.parameters.items():
+            if issubclass(param.annotation, Event) or isinstance(
+                param.annotation, Event
+            ):
+                kwargs[name] = self.event
+            if issubclass(param.annotation, Caller) or isinstance(
+                param.annotation, Caller
+            ):
+                kwargs[name] = self
+        return await self.func(*args, **kwargs)
+
 
 def on_function_call(name: str | None = None, description: str | None = None) -> Caller:
     """返回一个Caller类，可用于装饰一个函数，使其注册为一个可被AI调用的function call函数
@@ -87,5 +143,14 @@ def on_function_call(name: str | None = None, description: str | None = None) ->
     Returns:
         Caller: Caller对象
     """
+    caller = Caller(name=name, description=description)
+    return caller
 
-    return Caller(name=name, description=description)
+
+def get_function_calls() -> dict[str, Caller]:
+    """获取所有已注册的function call函数
+
+    Returns:
+        dict[str, Caller]: 所有已注册的function call函数
+    """
+    return _caller_data

nonebot_plugin_marshoai/plugin/func_call/utils.py

@@ -0,0 +1,52 @@
+import inspect
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable
+
+from ..typing import F
+
+
+def copy_signature(func: F) -> Callable[[Callable[..., Any]], F]:
+    """复制函数签名和文档字符串的装饰器"""
+
+    def decorator(wrapper: Callable[..., Any]) -> F:
+        @wraps(func)
+        def wrapped(*args: Any, **kwargs: Any) -> Any:
+            return wrapper(*args, **kwargs)
+
+        return wrapped  # type: ignore
+
+    return decorator
+
+
+def async_wrap(func: F) -> F:
+    """装饰器，将同步函数包装为异步函数
+
+    Args:
+        func (F): 函数对象
+
+    Returns:
+        F: 包装后的函数对象
+    """
+
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        return func(*args, **kwargs)
+
+    return wrapper  # type: ignore
+
+
+def is_coroutine_callable(call: Callable[..., Any]) -> bool:
+    """
+    判断是否为async def 函数
+    请注意：是否为 async def 函数与该函数是否能被await调用是两个不同的概念，具体取决于函数返回值是否为awaitable对象
+    Args:
+        call: 可调用对象
+    Returns:
+        bool: 是否为async def函数
+    """
+    if inspect.isroutine(call):
+        return inspect.iscoroutinefunction(call)
+    if inspect.isclass(call):
+        return False
+    func_ = getattr(call, "__call__", None)
+    return inspect.iscoroutinefunction(func_)

nonebot_plugin_marshoai/plugin/typing.py

@@ -1,5 +1,7 @@
-from typing import Any, Callable, Coroutine, TypeAlias
+from typing import Any, Callable, Coroutine, TypeAlias, TypeVar
 
 SYNC_FUNCTION_CALL_FUNC: TypeAlias = Callable[..., str]
 ASYNC_FUNCTION_CALL_FUNC: TypeAlias = Callable[..., Coroutine[str, Any, str]]
 FUNCTION_CALL_FUNC: TypeAlias = SYNC_FUNCTION_CALL_FUNC | ASYNC_FUNCTION_CALL_FUNC
+
+F = TypeVar("F", bound=FUNCTION_CALL_FUNC)

nonebot_plugin_marshoai/plugin/utils.py

@@ -18,21 +18,5 @@ def path_to_module_name(path: Path) -> str:
         return ".".join(rel_path.parts[:-1] + (rel_path.stem,))
 
 
-def is_coroutine_callable(call: Callable[..., Any]) -> bool:
-    """
-    判断是否为async def 函数
-    Args:
-        call: 可调用对象
-    Returns:
-        bool: 是否为协程可调用对象
-    """
-    if inspect.isroutine(call):
-        return inspect.iscoroutinefunction(call)
-    if inspect.isclass(call):
-        return False
-    func_ = getattr(call, "__call__", None)
-    return inspect.iscoroutinefunction(func_)
-
-
 def parse_function_docsring():
     pass