✨ Feature: 支持 PEP 695 类型别名 (#3621)

Author: yanyongyu

nonebot/dependencies/utils.py

@@ -7,13 +7,14 @@
 """
 
 import inspect
-from typing import Any, Callable, ForwardRef
+from typing import Any, Callable, ForwardRef, cast
+from typing_extensions import TypeAliasType
 
 from loguru import logger
 
 from nonebot.compat import ModelField
 from nonebot.exception import TypeMisMatch
-from nonebot.typing import evaluate_forwardref
+from nonebot.typing import evaluate_forwardref, is_type_alias_type
 
 
 def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
@@ -46,6 +47,9 @@ def get_typed_annotation(param: inspect.Parameter, globalns: dict[str, Any]) ->
                 f'Unknown ForwardRef["{param.annotation}"] for parameter {param.name}'
             )
             return inspect.Parameter.empty
+    if is_type_alias_type(annotation):
+        # Python 3.12+ supports PEP 695 TypeAliasType
+        annotation = cast(TypeAliasType, annotation).__value__
     return annotation
 
 

nonebot/typing.py

@@ -99,6 +99,17 @@ def is_none_type(type_: type[t.Any]) -> bool:
     return type_ in NONE_TYPES
 
 
+if sys.version_info < (3, 12):
+
+    def is_type_alias_type(type_: type[t.Any]) -> bool:
+        """判断是否是 TypeAliasType 类型"""
+        return isinstance(type_, t_ext.TypeAliasType)
+else:
+
+    def is_type_alias_type(type_: type[t.Any]) -> bool:
+        return isinstance(type_, (t.TypeAliasType, t_ext.TypeAliasType))
+
+
 def evaluate_forwardref(
     ref: t.ForwardRef, globalns: dict[str, t.Any], localns: dict[str, t.Any]
 ) -> t.Any:

nonebot/utils.py

@@ -89,13 +89,15 @@ def generic_check_issubclass(
 
     特别的：
 
+    - 如果 cls 是 `typing.TypeVar` 类型，
+      则会检查其 `__bound__` 或 `__constraints__`
+      是否是 class_or_tuple 中一个类型的子类或 None。
     - 如果 cls 是 `typing.Union` 或 `types.UnionType` 类型，
       则会检查其中的所有类型是否是 class_or_tuple 中一个类型的子类或 None。
     - 如果 cls 是 `typing.Literal` 类型，
       则会检查其中的所有值是否是 class_or_tuple 中一个类型的实例。
-    - 如果 cls 是 `typing.TypeVar` 类型，
-      则会检查其 `__bound__` 或 `__constraints__`
-      是否是 class_or_tuple 中一个类型的子类或 None。
+    - 如果 cls 是 `typing.List`、`typing.Dict` 等泛型类型，
+      则会检查其原始类型是否是 class_or_tuple 中一个类型的子类。
     """
     # if the target is a TypeVar, we check it first
     if isinstance(cls, TypeVar):

pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
   "pygtrie >=2.4.1, <3.0.0",
   "exceptiongroup >=1.2.2, <2.0.0",
   "python-dotenv >=0.21.0, <2.0.0",
-  "typing-extensions >=4.4.0, <5.0.0",
+  "typing-extensions >=4.6.0, <5.0.0",
   "tomli >=2.0.1, <3.0.0; python_version < '3.11'",
   "pydantic >=1.10.0, <3.0.0, !=2.5.0, !=2.5.1, !=2.10.0, !=2.10.1",
 ]
@@ -129,6 +129,9 @@ pythonVersion = "3.9"
 pythonPlatform = "All"
 defineConstant = { PYDANTIC_V2 = true }
 executionEnvironments = [
+  { root = "./tests/python_3_12", pythonVersion = "3.12", extraPaths = [
+    "./",
+  ] },
   { root = "./tests", extraPaths = [
     "./",
   ] },

tests/conftest.py

@@ -2,6 +2,7 @@
 from functools import wraps
 import os
 from pathlib import Path
+import sys
 import threading
 from typing import TYPE_CHECKING, Callable, TypeVar
 from typing_extensions import ParamSpec
@@ -67,7 +68,14 @@ def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
 @run_once
 def load_plugin(anyio_backend, nonebug_init: None) -> set["Plugin"]:
     # preload global plugins
-    return nonebot.load_plugins(str(Path(__file__).parent / "plugins"))
+    plugins: set["Plugin"] = set()
+    plugins |= nonebot.load_plugins(str(Path(__file__).parent / "plugins"))
+    if sys.version_info >= (3, 12):
+        # preload python 3.12 plugins
+        plugins |= nonebot.load_plugins(
+            str(Path(__file__).parent / "python_3_12" / "plugins")
+        )
+    return plugins
 
 
 @pytest.fixture(scope="session", autouse=True)

tests/python_3_12/plugins/aliased_param/__init__.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+from nonebot import load_plugins
+
+_sub_plugins = set()
+
+_sub_plugins |= load_plugins(str(Path(__file__).parent))

tests/python_3_12/plugins/aliased_param/param_arg.py

@@ -0,0 +1,10 @@
+from typing import Annotated
+
+from nonebot.adapters import Message
+from nonebot.params import Arg
+
+type AliasedArg = Annotated[Message, Arg()]
+
+
+async def aliased_arg(key: AliasedArg) -> Message:
+    return key

tests/python_3_12/plugins/aliased_param/param_bot.py

@@ -0,0 +1,7 @@
+from nonebot.adapters import Bot
+
+type AliasedBot = Bot
+
+
+async def get_aliased_bot(b: AliasedBot) -> Bot:
+    return b

tests/python_3_12/plugins/aliased_param/param_depend.py

@@ -0,0 +1,21 @@
+from typing import Annotated
+
+from nonebot import on_message
+from nonebot.params import Depends
+
+test_depends = on_message()
+
+runned = []
+
+
+def dependency():
+    runned.append(1)
+    return 1
+
+
+type AliasedDepends = Annotated[int, Depends(dependency)]
+
+
+@test_depends.handle()
+async def aliased_depends(x: AliasedDepends):
+    return x

tests/python_3_12/plugins/aliased_param/param_event.py

@@ -0,0 +1,7 @@
+from nonebot.adapters import Event
+
+type AliasedEvent = Event
+
+
+async def aliased_event(e: AliasedEvent) -> Event:
+    return e