✨ OriginalUniMsg Depends

resolve #106

Author: RF-Tar-Railt

src/nonebot_plugin_alconna/__init__.py

@@ -101,20 +101,19 @@
 from .params import match_value as match_value
 from .shortcut import funcommand as funcommand
 from .uniseg import image_fetch as image_fetch
-from .pattern import select_last as select_last
 from .params import AlconnaMatch as AlconnaMatch
 from .params import AlconnaQuery as AlconnaQuery
 from .uniseg import SupportScope as SupportScope
 from .uniseg import message_edit as message_edit
 from .model import CommandResult as CommandResult
-from .pattern import select_first as select_first
 from .params import AlcExecResult as AlcExecResult
 from .params import AlconnaResult as AlconnaResult
 from .uniseg import MessageTarget as MessageTarget
 from .typings import Strikethrough as Strikethrough
 from .consts import ALCONNA_RESULT as ALCONNA_RESULT
 from .params import AlconnaContext as AlconnaContext
 from .params import AlconnaMatches as AlconnaMatches
+from .uniseg import OriginalUniMsg as OriginalUniMsg
 from .uniseg import SupportAdapter as SupportAdapter
 from .uniseg import apply_filehost as apply_filehost
 from .uniseg import custom_handler as custom_handler

src/nonebot_plugin_alconna/argv.py

@@ -54,7 +54,7 @@ def build(self, data: str | list[str] | Message | UniMessage) -> Self:
         """
         self.reset()
         if isinstance(data, Message):
-            data = UniMessage.generate_sync(message=data, adapter=self.context.get("$adapter.name"))
+            data = UniMessage.of(data, adapter=self.context.get("$adapter.name"))
         else:
             data = UniMessage(data)
         self.origin = data

src/nonebot_plugin_alconna/builtins/extensions/onebot11.py

@@ -48,7 +48,7 @@ async def message_provider(
             if cache_msg and (uni_msg := self.cache.get(msg_id)) is not None:
                 return uni_msg
             msg = Message._validate(event.message)  # type: ignore
-            uni_msg = UniMessage.generate_without_reply(message=msg, bot=bot)
+            uni_msg = UniMessage.of(message=msg, bot=bot)
             self.cache[msg_id] = uni_msg
             return uni_msg
         return None

src/nonebot_plugin_alconna/builtins/extensions/reply.py

@@ -97,7 +97,7 @@ async def message_provider(self, event, state, bot, use_origin: bool = False):
         msg_id = get_message_id(event, bot)
         if cache_msg and msg_id in self.cache:
             return self.cache[msg_id]
-        uni_msg = UniMessage.generate_sync(message=msg, bot=bot)
+        uni_msg = UniMessage.of(msg, bot=bot)
         self.cache[msg_id] = uni_msg
         if not (reply := await reply_fetch(event, bot)):
             return uni_msg
@@ -106,7 +106,7 @@ async def message_provider(self, event, state, bot, use_origin: bool = False):
         reply_msg = reply.msg
         if isinstance(reply_msg, str):
             reply_msg = msg.__class__(reply_msg)
-        uni_msg_reply = UniMessage.generate_sync(message=reply_msg, bot=bot)
+        uni_msg_reply = UniMessage.of(reply_msg, bot=bot)
         if self.add_left:
             uni_msg_reply += self.sep
             uni_msg_reply.extend(uni_msg)

src/nonebot_plugin_alconna/extension.py

@@ -161,10 +161,10 @@ async def message_provider(
             if cache_msg and (uni_msg := unimsg_cache.get(msg_id)) is not None:
                 return uni_msg
             msg = event.get_message()
-            uni_msg = UniMessage.generate_without_reply(message=msg, bot=bot)
+            uni_msg = UniMessage.of(message=msg, bot=bot)
             unimsg_cache[msg_id] = uni_msg
             if (ori_msg := getattr(event, "original_message", None)) is not None:
-                ori_uni_msg = UniMessage.generate_without_reply(message=ori_msg, bot=bot)
+                ori_uni_msg = await UniMessage.of(message=ori_msg, bot=bot).attach_reply(event=event, bot=bot)
                 unimsg_origin_cache[msg_id] = ori_uni_msg
                 if use_origin:
                     return ori_uni_msg

src/nonebot_plugin_alconna/matcher.py

@@ -545,7 +545,7 @@ async def _key_getter(event: Event, bot: Bot, matcher: AlconnaMatcher, state: T_
                 if not msg:
                     await matcher.reject(prompt, fallback=fallback)
                 if not isinstance(msg, UniMessage):
-                    msg = await UniMessage.generate(message=msg, event=event, bot=bot)
+                    msg = UniMessage.of(message=msg, bot=bot)
                 if arg.value.alias == "*":
                     if TYPE_CHECKING:
                         assert isinstance(arg.value, _AllParamPattern)
@@ -846,7 +846,7 @@ async def wrapper(event: Event):
         res = await wait.wait(timeout=timeout)
         if res is None:
             return None
-        return await UniMessage.generate(message=cast(Message, res))
+        return UniMessage.of(message=cast(Message, res))
 
     @classmethod
     def test(cls, message: str | UniMessage, expected: dict[str, Any] | None = None, prefix: bool = True):

src/nonebot_plugin_alconna/uniseg/__init__.py

@@ -47,6 +47,7 @@
 from .params import MessageTarget as MessageTarget
 from .functions import message_edit as message_edit
 from .constraint import SupportScope as SupportScope
+from .params import OriginalUniMsg as OriginalUniMsg
 from .segment import custom_handler as custom_handler
 from .functions import get_message_id as get_message_id
 from .functions import message_recall as message_recall

src/nonebot_plugin_alconna/uniseg/adapters/heybox/builder.py

@@ -1,4 +1,4 @@
-from nonebot.adapters.heybox.message import MessageSegment
+from nonebot.adapters.heybox.message import MessageSegment  # type: ignore
 
 from nonebot_plugin_alconna.uniseg.segment import Text
 from nonebot_plugin_alconna.uniseg.constraint import SupportAdapter

src/nonebot_plugin_alconna/uniseg/adapters/heybox/exporter.py

@@ -3,9 +3,9 @@
 
 from tarina import lang
 from nonebot.adapters import Bot, Event
-from nonebot.adapters.heybox.bot import Bot as HeyboxBot
-from nonebot.adapters.heybox.event import UserIMMessageEvent
-from nonebot.adapters.heybox.message import Message, MessageSegment
+from nonebot.adapters.heybox.bot import Bot as HeyboxBot  # type: ignore
+from nonebot.adapters.heybox.event import UserIMMessageEvent  # type: ignore
+from nonebot.adapters.heybox.message import Message, MessageSegment  # type: ignore
 
 from nonebot_plugin_alconna.uniseg.constraint import SupportScope
 from nonebot_plugin_alconna.uniseg.segment import At, Text, Image, Reply
@@ -23,8 +23,8 @@ def get_message_type(self):
     def get_target(self, event: Event, bot: Union[Bot, None] = None) -> Target:
         if isinstance(event, UserIMMessageEvent):
             return Target(
-                event.channel_id,
-                parent_id=event.room_id,
+                event.channel_id,  # type: ignore
+                parent_id=event.room_id,  # type: ignore
                 channel=True,
                 adapter=self.get_adapter(),
                 self_id=bot.self_id if bot else None,
@@ -34,7 +34,7 @@ def get_target(self, event: Event, bot: Union[Bot, None] = None) -> Target:
 
     def get_message_id(self, event: Event) -> str:
         if isinstance(event, UserIMMessageEvent):
-            return str(event.im_seq)
+            return str(event.im_seq)  # type: ignore
         raise NotImplementedError
 
     @export
@@ -84,7 +84,7 @@ async def send_to(self, target: Union[Target, Event], bot: Bot, message: Message
                 assert isinstance(target, UserIMMessageEvent)
             return await bot.send(event=target, message=message, **kwargs, is_reply=reply_id is not None)
         return await bot.send_to_channel(
-            target.parent_id,
+            target.parent_id,  # type: ignore
             target.id,
             message,
             reply_id=reply_id,

src/nonebot_plugin_alconna/uniseg/message.py

@@ -6,7 +6,7 @@
 from json import dumps, loads
 from types import FunctionType
 from collections.abc import Iterable, Sequence, Awaitable
-from typing_extensions import Self, TypeAlias, SupportsIndex
+from typing_extensions import Self, TypeAlias, SupportsIndex, deprecated
 from typing import TYPE_CHECKING, Any, Union, Literal, TypeVar, Callable, NoReturn, Protocol, overload
 
 from tarina import lang
@@ -1212,6 +1212,7 @@ def rstrip(self, *segments: str | Segment | type[Segment]) -> Self:
                 break
         return self.__class__(copy)
 
+    @deprecated("`UniMessage.generate` is deprecated, use `UniMessage.of()` and `await msg.attach_reply()` instead")
     @staticmethod
     async def generate(
         *,
@@ -1230,23 +1231,9 @@ async def generate(
                 message = event.get_message()
             except Exception:
                 return UniMessage()
-        if not adapter:
-            if not bot:
-                try:
-                    bot = current_bot.get()
-                except LookupError as e:
-                    raise SerializeFailed(lang.require("nbp-uniseg", "bot_missing")) from e
-            _adapter = bot.adapter
-            adapter = _adapter.get_name()
-        if not (fn := alter_get_builder(adapter)):
-            raise SerializeFailed(lang.require("nbp-uniseg", "unsupported").format(adapter=adapter))
-        result = UniMessage(fn.generate(message))
-        if (event and bot) and (_reply := await fn.extract_reply(event, bot)):
-            if result.has(Reply) and result.index(Reply) == 0:
-                result.pop(0)
-            result.insert(0, _reply)
-        return result
+        return await UniMessage.of(message, bot=bot, adapter=adapter).attach_reply(event, bot)
 
+    @deprecated("`UniMessage.generate_sync` is deprecated, use `UniMessage.of` instead")
     @staticmethod
     def generate_sync(
         *,
@@ -1265,6 +1252,17 @@ def generate_sync(
                 message = event.get_message()
             except Exception:
                 return UniMessage()
+        return UniMessage.of(message, bot=bot, adapter=adapter)
+
+    generate_without_reply = generate_sync
+
+    @classmethod
+    def of(
+        cls,
+        message: Message,
+        bot: Bot | None = None,
+        adapter: str | None = None,
+    ):
         if not adapter:
             if not bot:
                 try:
@@ -1277,7 +1275,24 @@ def generate_sync(
             raise SerializeFailed(lang.require("nbp-uniseg", "unsupported").format(adapter=adapter))
         return UniMessage(fn.generate(message))
 
-    generate_without_reply = generate_sync
+    async def attach_reply(self, event: Event | None = None, bot: Bot | None = None) -> Self:
+        if not event:
+            try:
+                event = current_event.get()
+            except LookupError as e:
+                raise SerializeFailed(lang.require("nbp-uniseg", "event_missing")) from e
+        if not bot:
+            try:
+                bot = current_bot.get()
+            except LookupError as e:
+                raise SerializeFailed(lang.require("nbp-uniseg", "bot_missing")) from e
+        if not (fn := alter_get_builder(bot.adapter.get_name())):
+            raise SerializeFailed(lang.require("nbp-uniseg", "unsupported").format(adapter=bot.adapter.get_name()))
+        if _reply := await fn.extract_reply(event, bot):
+            if self.has(Reply) and self.index(Reply) == 0:
+                self.pop(0)
+            self.insert(0, _reply)  # type: ignore
+        return self
 
     def _handle_i18n(self, extra: dict, *args, **kwargs):
         segments = [*self]