refactor: 请求处理控制流基础架构

pkg/pipeline/resprule/entities.py

@@ -0,0 +1,9 @@
+import pydantic
+import mirai
+
+
+class RuleJudgeResult(pydantic.BaseModel):
+
+    matching: bool = False
+
+    replacement: mirai.MessageChain = None

pkg/pipeline/resprule/resprule.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import mirai
+
+from ...core import app
+from . import entities as rule_entities, rule
+from .rules import atbot, prefix, regexp, random
+
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...config import manager as cfg_mgr
+
+
+@stage.stage_class("GroupRespondRuleCheckStage")
+class GroupRespondRuleCheckStage(stage.PipelineStage):
+    """群组响应规则检查器
+    """
+
+    rule_matchers: list[rule.GroupRespondRule]
+
+    async def initialize(self):
+        """初始化检查器
+        """
+        self.rule_matchers = [
+            atbot.AtBotRule(self.ap),
+            prefix.PrefixRule(self.ap),
+            regexp.RegExpRule(self.ap),
+            random.RandomRespRule(self.ap),
+        ]
+
+        for rule_matcher in self.rule_matchers:
+            await rule_matcher.initialize()
+
+    async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
+        
+        if query.launcher_type != 'group':
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query
+            )
+
+        rules = self.ap.cfg_mgr.data['response_rules']
+
+        use_rule = rules['default']
+
+        if str(query.launcher_id) in use_rule:
+            use_rule = use_rule[str(query.launcher_id)]
+
+        for rule_matcher in self.rule_matchers:  # 任意一个匹配就放行
+            res = await rule_matcher.match(str(query.message_chain), query.message_chain, use_rule)
+            if res.matching:
+                query.message_chain = res.replacement
+
+                return entities.StageProcessResult(
+                    result_type=entities.ResultType.CONTINUE,
+                    new_query=query,
+                )
+        
+        return entities.StageProcessResult(
+            result_type=entities.ResultType.INTERRUPT,
+            new_query=query
+        )

pkg/pipeline/resprule/rule.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+import abc
+
+import mirai
+
+from ...core import app
+from . import entities
+
+
+class GroupRespondRule(metaclass=abc.ABCMeta):
+    """群组响应规则的抽象类
+    """
+
+    ap: app.Application
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    async def initialize(self):
+        pass
+
+    @abc.abstractmethod
+    async def match(
+        self,
+        message_text: str,
+        message_chain: mirai.MessageChain,
+        rule_dict: dict
+    ) -> entities.RuleJudgeResult:
+        """判断消息是否匹配规则
+        """
+        raise NotImplementedError

pkg/pipeline/resprule/rules/atbot.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import mirai
+
+from .. import rule as rule_model
+from .. import entities
+
+
+class AtBotRule(rule_model.GroupRespondRule):
+
+    async def match(
+        self,
+        message_text: str,
+        message_chain: mirai.MessageChain,
+        rule_dict: dict
+    ) -> entities.RuleJudgeResult:
+        
+        if message_chain.has(mirai.At(self.ap.im_mgr.bot_account_id)) and rule_dict['at']:
+            message_chain.remove(mirai.At(self.ap.im_mgr.bot_account_id))
+            return entities.RuleJudgeResult(
+                matching=True,
+                replacement=message_chain,
+            )
+
+        return entities.RuleJudgeResult(
+            matching=False,
+            replacement = message_chain
+        )

pkg/pipeline/resprule/rules/prefix.py

@@ -0,0 +1,29 @@
+import mirai
+
+from .. import rule as rule_model
+from .. import entities
+
+
+class PrefixRule(rule_model.GroupRespondRule):
+
+    async def match(
+        self,
+        message_text: str,
+        message_chain: mirai.MessageChain,
+        rule_dict: dict
+    ) -> entities.RuleJudgeResult:
+        prefixes = rule_dict['prefix']
+
+        for prefix in prefixes:
+            if message_text.startswith(prefix):
+                return entities.RuleJudgeResult(
+                    matching=True,
+                    replacement=mirai.MessageChain([
+                        mirai.Plain(message_text[len(prefix):])
+                    ]),
+                )
+
+        return entities.RuleJudgeResult(
+            matching=False,
+            replacement=message_chain
+        )

pkg/pipeline/resprule/rules/random.py

@@ -0,0 +1,22 @@
+import random
+
+import mirai
+
+from .. import rule as rule_model
+from .. import entities
+
+
+class RandomRespRule(rule_model.GroupRespondRule):
+
+    async def match(
+        self,
+        message_text: str,
+        message_chain: mirai.MessageChain,
+        rule_dict: dict
+    ) -> entities.RuleJudgeResult:
+        random_rate = rule_dict['random_rate']
+        
+        return entities.RuleJudgeResult(
+            matching=random.random() < random_rate,
+            replacement=message_chain
+        )

pkg/pipeline/resprule/rules/regexp.py

@@ -0,0 +1,31 @@
+import re
+
+import mirai
+
+from .. import rule as rule_model
+from .. import entities
+
+
+class RegExpRule(rule_model.GroupRespondRule):
+
+    async def match(
+        self,
+        message_text: str,
+        message_chain: mirai.MessageChain,
+        rule_dict: dict
+    ) -> entities.RuleJudgeResult:
+        regexps = rule_dict['regexp']
+
+        for regexp in regexps:
+            match = re.match(regexp, message_text)
+
+            if match:
+                return entities.RuleJudgeResult(
+                    matching=True,
+                    replacement=message_chain,
+                )
+        
+        return entities.RuleJudgeResult(
+            matching=False,
+            replacement=message_chain
+        )