✨ Feature: 依赖注入支持 Generic TypeVar 和 Matcher 重载 (#2089)

tests/plugins/param/param_bot.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Union, TypeVar
 
 from nonebot.adapters import Bot
 
@@ -31,5 +31,19 @@ async def union_bot(b: Union[FooBot, BarBot]) -> Union[FooBot, BarBot]:
     return b
 
 
+B = TypeVar("B", bound=Bot)
+
+
+async def generic_bot(b: B) -> B:
+    return b
+
+
+CB = TypeVar("CB", Bot, None)
+
+
+async def generic_bot_none(b: CB) -> CB:
+    return b
+
+
 async def not_bot(b: Union[int, Bot]):
     ...

tests/plugins/param/param_event.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Union, TypeVar
 
 from nonebot.adapters import Event, Message
 from nonebot.params import EventToMe, EventType, EventMessage, EventPlainText
@@ -32,6 +32,20 @@ async def union_event(e: Union[FooEvent, BarEvent]) -> Union[FooEvent, BarEvent]
     return e
 
 
+E = TypeVar("E", bound=Event)
+
+
+async def generic_event(e: E) -> E:
+    return e
+
+
+CE = TypeVar("CE", Event, None)
+
+
+async def generic_event_none(e: CE) -> CE:
+    return e
+
+
 async def not_event(e: Union[int, Event]):
     ...
 

tests/plugins/param/param_matcher.py

@@ -1,3 +1,5 @@
+from typing import Union, TypeVar
+
 from nonebot.adapters import Event
 from nonebot.matcher import Matcher
 from nonebot.params import Received, LastReceived
@@ -7,6 +9,50 @@ async def matcher(m: Matcher) -> Matcher:
     return m
 
 
+async def legacy_matcher(matcher):
+    return matcher
+
+
+async def not_legacy_matcher(matcher: int):
+    ...
+
+
+class FooMatcher(Matcher):
+    ...
+
+
+async def sub_matcher(m: FooMatcher) -> FooMatcher:
+    return m
+
+
+class BarMatcher(Matcher):
+    ...
+
+
+async def union_matcher(
+    m: Union[FooMatcher, BarMatcher]
+) -> Union[FooMatcher, BarMatcher]:
+    return m
+
+
+M = TypeVar("M", bound=Matcher)
+
+
+async def generic_matcher(m: M) -> M:
+    return m
+
+
+CM = TypeVar("CM", Matcher, None)
+
+
+async def generic_matcher_none(m: CM) -> CM:
+    return m
+
+
+async def not_matcher(m: Union[int, Matcher]):
+    ...
+
+
 async def receive(e: Event = Received("test")) -> Event:
     return e
 

tests/test_param.py

@@ -90,7 +90,9 @@ async def test_bot(app: App):
         sub_bot,
         union_bot,
         legacy_bot,
+        generic_bot,
         not_legacy_bot,
+        generic_bot_none,
     )
 
     async with app.test_dependent(get_bot, allow_types=[BotParam]) as ctx:
@@ -122,6 +124,16 @@ async def test_bot(app: App):
         ctx.pass_params(bot=bot)
         ctx.should_return(bot)
 
+    async with app.test_dependent(generic_bot, allow_types=[BotParam]) as ctx:
+        bot = ctx.create_bot()
+        ctx.pass_params(bot=bot)
+        ctx.should_return(bot)
+
+    async with app.test_dependent(generic_bot_none, allow_types=[BotParam]) as ctx:
+        bot = ctx.create_bot()
+        ctx.pass_params(bot=bot)
+        ctx.should_return(bot)
+
     with pytest.raises(ValueError):
         async with app.test_dependent(not_bot, allow_types=[BotParam]) as ctx:
             ...
@@ -139,8 +151,10 @@ async def test_event(app: App):
         union_event,
         legacy_event,
         event_message,
+        generic_event,
         event_plain_text,
         not_legacy_event,
+        generic_event_none,
     )
 
     fake_message = make_fake_message()("text")
@@ -173,6 +187,14 @@ async def test_event(app: App):
         ctx.pass_params(event=fake_fooevent)
         ctx.should_return(fake_event)
 
+    async with app.test_dependent(generic_event, allow_types=[EventParam]) as ctx:
+        ctx.pass_params(event=fake_event)
+        ctx.should_return(fake_event)
+
+    async with app.test_dependent(generic_event_none, allow_types=[EventParam]) as ctx:
+        ctx.pass_params(event=fake_event)
+        ctx.should_return(fake_event)
+
     with pytest.raises(ValueError):
         async with app.test_dependent(not_event, allow_types=[EventParam]) as ctx:
             ...
@@ -351,14 +373,63 @@ async def test_state(app: App):
 
 @pytest.mark.asyncio
 async def test_matcher(app: App):
-    from plugins.param.param_matcher import matcher, receive, last_receive
+    from plugins.param.param_matcher import (
+        FooMatcher,
+        matcher,
+        receive,
+        not_matcher,
+        sub_matcher,
+        last_receive,
+        union_matcher,
+        legacy_matcher,
+        generic_matcher,
+        not_legacy_matcher,
+        generic_matcher_none,
+    )
 
     fake_matcher = Matcher()
+    foo_matcher = FooMatcher()
 
     async with app.test_dependent(matcher, allow_types=[MatcherParam]) as ctx:
         ctx.pass_params(matcher=fake_matcher)
         ctx.should_return(fake_matcher)
 
+    async with app.test_dependent(legacy_matcher, allow_types=[MatcherParam]) as ctx:
+        ctx.pass_params(matcher=fake_matcher)
+        ctx.should_return(fake_matcher)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(
+            not_legacy_matcher, allow_types=[MatcherParam]
+        ) as ctx:
+            ...
+
+    async with app.test_dependent(sub_matcher, allow_types=[MatcherParam]) as ctx:
+        ctx.pass_params(matcher=foo_matcher)
+        ctx.should_return(foo_matcher)
+
+    with pytest.raises(TypeMisMatch):
+        async with app.test_dependent(sub_matcher, allow_types=[MatcherParam]) as ctx:
+            ctx.pass_params(matcher=fake_matcher)
+
+    async with app.test_dependent(union_matcher, allow_types=[MatcherParam]) as ctx:
+        ctx.pass_params(matcher=foo_matcher)
+        ctx.should_return(foo_matcher)
+
+    async with app.test_dependent(generic_matcher, allow_types=[MatcherParam]) as ctx:
+        ctx.pass_params(matcher=fake_matcher)
+        ctx.should_return(fake_matcher)
+
+    async with app.test_dependent(
+        generic_matcher_none, allow_types=[MatcherParam]
+    ) as ctx:
+        ctx.pass_params(matcher=fake_matcher)
+        ctx.should_return(fake_matcher)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(not_matcher, allow_types=[MatcherParam]) as ctx:
+            ...
+
     event = make_fake_event()()
     fake_matcher.set_receive("test", event)
     event_next = make_fake_event()()