🐛 version 0.57.2

fix template args in got

Author: RF-Tar-Railt

src/nonebot_plugin_alconna/consts.py

@@ -7,7 +7,7 @@
 ALCONNA_RESULT: Literal["_alc_result"] = "_alc_result"
 ALCONNA_EXEC_RESULT: Literal["_alc_exec_result"] = "_alc_exec_result"
 ALCONNA_ARG_KEY: Literal["_alc_arg_{key}"] = "_alc_arg_{key}"
-ALCONNA_ARG_PATH: Literal["_alc_arg_path"] = "_alc_arg_path"
+ALCONNA_ARG_KEYS: Literal["_alc_arg_keys"] = "_alc_arg_keys"
 ALCONNA_EXTENSION: Literal["_alc_extension"] = "_alc_extension"
 
 log = logger_wrapper("Plugin-Alconna")

src/nonebot_plugin_alconna/matcher.py

@@ -41,7 +41,7 @@
 from .uniseg.message import current_send_wrapper
 from .extension import Extension, ExtensionExecutor
 from .uniseg import Text, Segment, UniMessage, get_target, get_message_id
-from .consts import ALCONNA_RESULT, ALCONNA_ARG_KEY, ALCONNA_ARG_PATH, log
+from .consts import ALCONNA_RESULT, ALCONNA_ARG_KEY, ALCONNA_ARG_KEYS, log
 from .params import CHECK, MIDDLEWARE, Check, AlconnaParam, ExtensionParam, assign, _seminal, _Dispatch, merge_path
 
 _M = Union[str, Message, MessageSegment, MessageTemplate, Segment, UniMessage, UniMessageTemplate]
@@ -219,7 +219,7 @@ def set_path_arg(cls_or_self, path: str, content: Any) -> None:
                 state = current_matcher.get().state
             key = merge_path(path, cls_or_self.basepath)
             state[ALCONNA_ARG_KEY.format(key=key)] = content
-            state[ALCONNA_ARG_PATH] = key
+            state.setdefault(ALCONNA_ARG_KEYS, []).append(key)
 
         @_method
         def get_path_arg(cls_or_self, path: str, default: Any) -> Any:
@@ -228,7 +228,8 @@ def get_path_arg(cls_or_self, path: str, default: Any) -> Any:
                 state = cls_or_self.state
             else:
                 state = current_matcher.get().state
-            return state.get(ALCONNA_ARG_KEY.format(key=merge_path(path, cls_or_self.basepath)), default)
+            key = merge_path(path, cls_or_self.basepath)
+            return state.get(ALCONNA_ARG_KEY.format(key), default)
 
     @classmethod
     def assign(
@@ -620,6 +621,9 @@ def convert(cls, message: _M) -> Message | UniMessage | str:
             return message.format(**state[ALCONNA_RESULT].result.all_matched_args, **state)
         if isinstance(message, UniMessageTemplate):
             extra = {"$event": event, "$target": get_target(event, bot)}
+            if keys := state.get(ALCONNA_ARG_KEYS, []):
+                for key in keys:
+                    extra[key.split(".")[-1]] = state.get(ALCONNA_ARG_KEY.format(key=key))
             try:
                 msg_id = get_message_id(event, bot)
             except Exception:

src/nonebot_plugin_alconna/params.py

@@ -17,7 +17,7 @@
 from .typings import CHECK, MIDDLEWARE
 from .model import T, Match, Query, CommandResult
 from .extension import Extension, ExtensionExecutor, SelectedExtensions
-from .consts import ALCONNA_RESULT, ALCONNA_ARG_KEY, ALCONNA_ARG_PATH, ALCONNA_EXTENSION, ALCONNA_EXEC_RESULT
+from .consts import ALCONNA_RESULT, ALCONNA_ARG_KEY, ALCONNA_ARG_KEYS, ALCONNA_EXTENSION, ALCONNA_EXEC_RESULT
 
 T_Duplication = TypeVar("T_Duplication", bound=Duplication)
 T_Extension = TypeVar("T_Extension", bound=Extension)
@@ -310,10 +310,11 @@ async def _solve(self, matcher: Matcher, event: Event, state: T_State, **kwargs:
             return q
         if t == Literal["context"]:
             return res.result.context
-        if (key := ALCONNA_ARG_KEY.format(key=self.extra["name"])) in state:
-            return state[key]
-        if (path := state.get(ALCONNA_ARG_PATH)) and path.endswith(f".{self.extra['name']}"):
-            return state[ALCONNA_ARG_KEY.format(key=path)]
+        keys: list[str] = state.get(ALCONNA_ARG_KEYS, [])
+        if (key := self.extra["name"]) in keys:
+            return state[ALCONNA_ARG_KEY.format(key=key)]
+        if any(k := key for key in keys if key.endswith(f".{self.extra['name']}")):
+            return state[ALCONNA_ARG_KEY.format(key=k)]
         if self.extra["name"] in res.result.all_matched_args:
             return res.result.all_matched_args[self.extra["name"]]
         if (

tests/test_uniseg.py

@@ -1,7 +1,7 @@
 import pytest
 from nonebug import App
 from nonebot import get_adapter
-from arclet.alconna import Alconna
+from arclet.alconna import Args, Alconna
 from nonebot.adapters.onebot.v11.event import Reply
 from nonebot.compat import model_dump, type_validate_python
 from nonebot.adapters.onebot.v11 import Bot, Adapter, Message, MessageSegment
@@ -135,7 +135,7 @@ async def test_fallback(app: App):
 @pytest.mark.asyncio()
 async def test_unimsg_template(app: App):
     from nonebot_plugin_alconna.uniseg import FallbackSegment
-    from nonebot_plugin_alconna import At, Text, Other, UniMessage, on_alconna
+    from nonebot_plugin_alconna import At, Text, Match, Other, UniMessage, on_alconna
 
     assert UniMessage.template("{} {}").format("hello", Other(FallbackSegment.text("123"))) == UniMessage(
         [Text("hello "), Other(FallbackSegment.text("123"))]
@@ -159,6 +159,43 @@ async def _():
         ctx.should_call_send(event, MessageSegment.reply(event.message_id) + MessageSegment.at(23))
         ctx.should_finished(matcher)
 
+    matcher1 = on_alconna(Alconna("test_unimsg_template1", Args["foo?", str]["bar?", str]))
+
+    @matcher1.handle()
+    async def _(foo: Match[str], bar: Match[str]):
+        if foo.available:
+            matcher1.set_path_arg("foo", foo.result)
+        if bar.available:
+            matcher1.set_path_arg("bar", bar.result)
+
+    @matcher1.got_path(
+        "foo",
+        prompt=UniMessage.template("{:At(user, $event.get_user_id())} 请确认目标 foo"),
+    )
+    @matcher1.got_path(
+        "bar",
+        prompt=UniMessage.template("{:At(user, $event.get_user_id())} 请确认目标 bar"),
+    )
+    async def _():
+        await matcher1.send(
+            UniMessage.template("{:At(user, $event.get_user_id())} 已确认目标为 {foo}, {bar}"),
+        )
+
+    async with app.test_matcher(matcher1) as ctx1:
+        adapter = get_adapter(Adapter)
+        bot = ctx1.create_bot(base=Bot, adapter=adapter)
+        event = fake_group_message_event_v11(message=Message("test_unimsg_template1"), user_id=123)
+        ctx1.receive_event(bot, event)
+        ctx1.should_call_send(event, MessageSegment.at(123) + " 请确认目标 foo")
+        ctx1.should_rejected(matcher1)
+        event1 = fake_group_message_event_v11(message=Message("123"), user_id=123)
+        ctx1.receive_event(bot, event1)
+        ctx1.should_call_send(event1, MessageSegment.at(123) + " 请确认目标 bar")
+        ctx1.should_rejected(matcher1)
+        event2 = fake_group_message_event_v11(message=Message("456"), user_id=123)
+        ctx1.receive_event(bot, event2)
+        ctx1.should_call_send(event2, MessageSegment.at(123) + " 已确认目标为 123, 456")
+
 
 @pytest.mark.asyncio()
 async def test_uniseg_recv(app: App):