refactor: 配置文件均改为json

pkg/pipeline/bansess/bansess.py

@@ -23,54 +23,28 @@ class BanSessionCheckStage(stage.PipelineStage):
         stage_inst_name: str
     ) -> entities.StageProcessResult:
         
-        if not self.banlist_mgr.data['enable']:
-            return entities.StageProcessResult(
-                result_type=entities.ResultType.CONTINUE,
-                new_query=query
-            )
-        
+        found = False
+
+        mode = self.ap.pipeline_cfg.data['access-control']['mode']
+
+        sess_list = self.ap.pipeline_cfg.data['access-control'][mode]
+
+        if (query.launcher_type == 'group' and 'group_*' in sess_list) \
+            or (query.launcher_type == 'person' and 'person_*' in sess_list):
+            found = True
+        else:
+            for sess in sess_list:
+                if sess == f"{query.launcher_type}_{query.launcher_id}":
+                    found = True
+                    break
+
         result = False
 
-        if query.launcher_type == 'group':
-            if not self.banlist_mgr.data['enable_group']:  # 未启用群聊响应
-                result = True
-            # 检查是否显式声明发起人QQ要被person忽略
-            elif query.sender_id in self.banlist_mgr.data['person']:
-                result = True
-            else:
-                for group_rule in self.banlist_mgr.data['group']:
-                    if type(group_rule) == int:
-                        if group_rule == query.launcher_id:
-                            result = True
-                    elif type(group_rule) == str:
-                        if group_rule.startswith('!'):
-                            reg_str = group_rule[1:]
-                            if re.match(reg_str, str(query.launcher_id)):
-                                result = False
-                                break
-                        else:
-                            if re.match(group_rule, str(query.launcher_id)):
-                                result = True
-        elif query.launcher_type == 'person':
-            if not self.banlist_mgr.data['enable_private']:
-                result = True
-            else:
-                for person_rule in self.banlist_mgr.data['person']:
-                    if type(person_rule) == int:
-                        if person_rule == query.launcher_id:
-                            result = True
-                    elif type(person_rule) == str:
-                        if person_rule.startswith('!'):
-                            reg_str = person_rule[1:]
-                            if re.match(reg_str, str(query.launcher_id)):
-                                result = False
-                                break
-                        else:
-                            if re.match(person_rule, str(query.launcher_id)):
-                                result = True
+        if mode == 'blacklist':
+            result = found
 
         return entities.StageProcessResult(
             result_type=entities.ResultType.CONTINUE if not result else entities.ResultType.INTERRUPT,
             new_query=query,
-            debug_notice=f'根据禁用列表忽略消息: {query.launcher_type}_{query.launcher_id}' if result else ''
+            debug_notice=f'根据访问控制忽略消息: {query.launcher_type}_{query.launcher_id}' if result else ''
         )

pkg/pipeline/cntfilter/cntfilter.py

@@ -24,10 +24,10 @@ class ContentFilterStage(stage.PipelineStage):
     async def initialize(self):
         self.filter_chain.append(cntignore.ContentIgnore(self.ap))
 
-        if self.ap.cfg_mgr.data['sensitive_word_filter']:
+        if self.ap.pipeline_cfg.data['check-sensitive-words']:
             self.filter_chain.append(banwords.BanWordFilter(self.ap))
         
-        if self.ap.cfg_mgr.data['baidu_check']:
+        if self.ap.pipeline_cfg.data['baidu-cloud-examine']['enable']:
             self.filter_chain.append(baiduexamine.BaiduCloudExamine(self.ap))
 
         for filter in self.filter_chain:
@@ -41,7 +41,7 @@ class ContentFilterStage(stage.PipelineStage):
         """请求llm前处理消息
         只要有一个不通过就不放行，只放行 PASS 的消息
         """
-        if not self.ap.cfg_mgr.data['income_msg_check']:
+        if not self.ap.pipeline_cfg.data['income-msg-check']:
             return entities.StageProcessResult(
                 result_type=entities.ResultType.CONTINUE,
                 new_query=query

pkg/pipeline/cntfilter/filters/baiduexamine.py

@@ -19,8 +19,8 @@ class BaiduCloudExamine(filter_model.ContentFilter):
                 BAIDU_EXAMINE_TOKEN_URL,
                 params={
                     "grant_type": "client_credentials",
-                    "client_id": self.ap.cfg_mgr.data['baidu_api_key'],
-                    "client_secret": self.ap.cfg_mgr.data['baidu_secret_key']
+                    "client_id": self.ap.pipeline_cfg.data['baidu-cloud-examine']['api-key'],
+                    "client_secret": self.ap.pipeline_cfg.data['baidu-cloud-examine']['api-secret']
                 }
             ) as resp:
                 return (await resp.json())['access_token']
@@ -56,6 +56,6 @@ class BaiduCloudExamine(filter_model.ContentFilter):
                         return entities.FilterResult(
                             level=entities.ResultLevel.BLOCK,
                             replacement=message,
-                            user_notice=self.ap.cfg_mgr.data['inappropriate_message_tips'],
+                            user_notice="消息中存在不合适的内容, 请修改",
                             console_notice=f"百度云判定结果：{conclusion}"
-                        )
+                        )

pkg/pipeline/cntfilter/filters/banwords.py

@@ -13,8 +13,8 @@ class BanWordFilter(filter_model.ContentFilter):
 
     async def initialize(self):
         self.sensitive = await cfg_mgr.load_json_config(
-            "sensitive.json",
-            "res/templates/sensitive-template.json"
+            "data/config/sensitive-words.json",
+            "templates/sensitive-words.json"
         )
 
     async def process(self, message: str) -> entities.FilterResult:
@@ -39,6 +39,6 @@ class BanWordFilter(filter_model.ContentFilter):
         return entities.FilterResult(
             level=entities.ResultLevel.MASKED if found else entities.ResultLevel.PASS,
             replacement=message,
-            user_notice='[bot] 消息中存在不合适的内容, 请更换措辞' if found else '',
+            user_notice='消息中存在不合适的内容, 请修改' if found else '',
             console_notice=''
         )

pkg/pipeline/cntfilter/filters/cntignore.py

@@ -15,8 +15,8 @@ class ContentIgnore(filter_model.ContentFilter):
         ]
 
     async def process(self, message: str) -> entities.FilterResult:
-        if 'prefix' in self.ap.cfg_mgr.data['ignore_rules']:
-            for rule in self.ap.cfg_mgr.data['ignore_rules']['prefix']:
+        if 'prefix' in self.ap.pipeline_cfg.data['ignore-rules']:
+            for rule in self.ap.pipeline_cfg.data['ignore-rules']['prefix']:
                 if message.startswith(rule):
                     return entities.FilterResult(
                         level=entities.ResultLevel.BLOCK,
@@ -25,8 +25,8 @@ class ContentIgnore(filter_model.ContentFilter):
                         console_notice='根据 ignore_rules 中的 prefix 规则，忽略消息'
                     )
         
-        if 'regexp' in self.ap.cfg_mgr.data['ignore_rules']:
-            for rule in self.ap.cfg_mgr.data['ignore_rules']['regexp']:
+        if 'regexp' in self.ap.pipeline_cfg.data['ignore-rules']:
+            for rule in self.ap.pipeline_cfg.data['ignore-rules']['regexp']:
                 if re.search(rule, message):
                     return entities.FilterResult(
                         level=entities.ResultLevel.BLOCK,

pkg/pipeline/longtext/longtext.py

@@ -19,9 +19,9 @@ class LongTextProcessStage(stage.PipelineStage):
     strategy_impl: strategy.LongTextStrategy
 
     async def initialize(self):
-        config = self.ap.cfg_mgr.data
-        if self.ap.cfg_mgr.data['blob_message_strategy'] == 'image':
-            use_font = config['font_path']
+        config = self.ap.platform_cfg.data['long-text-process']
+        if config['strategy'] == 'image':
+            use_font = config['font-path']
             try:
                 # 检查是否存在
                 if not os.path.exists(use_font):
@@ -33,23 +33,25 @@ class LongTextProcessStage(stage.PipelineStage):
                             config['blob_message_strategy'] = "forward"
                         else:
                             self.ap.logger.info("使用Windows自带字体：" + use_font)
-                            self.ap.cfg_mgr.data['font_path'] = use_font
+                            config['font-path'] = use_font
                     else:
                         self.ap.logger.warn("未找到字体文件，且无法使用系统自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
-                        self.ap.cfg_mgr.data['blob_message_strategy'] = "forward"
+
+                        self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
             except:
                 traceback.print_exc()
                 self.ap.logger.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。".format(use_font))
-                self.ap.cfg_mgr.data['blob_message_strategy'] = "forward"
+
+                self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
         
-        if self.ap.cfg_mgr.data['blob_message_strategy'] == 'image':
+        if config['strategy'] == 'image':
             self.strategy_impl = image.Text2ImageStrategy(self.ap)
-        elif self.ap.cfg_mgr.data['blob_message_strategy'] == 'forward':
+        elif config['strategy'] == 'forward':
             self.strategy_impl = forward.ForwardComponentStrategy(self.ap)
         await self.strategy_impl.initialize()
     
     async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
-        if len(str(query.resp_message_chain)) > self.ap.cfg_mgr.data['blob_message_threshold']:
+        if len(str(query.resp_message_chain)) > self.ap.platform_cfg.data['long-text-process']['threshold']:
             query.resp_message_chain = MessageChain(await self.strategy_impl.process(str(query.resp_message_chain)))
         return entities.StageProcessResult(
             result_type=entities.ResultType.CONTINUE,

pkg/pipeline/longtext/strategies/image.py

@@ -19,7 +19,7 @@ class Text2ImageStrategy(strategy_model.LongTextStrategy):
     text_render_font: ImageFont.FreeTypeFont
 
     async def initialize(self):
-        self.text_render_font = ImageFont.truetype(self.ap.cfg_mgr.data['font_path'], 32, encoding="utf-8")
+        self.text_render_font = ImageFont.truetype(self.ap.platform_cfg.data['long-text-process']['font-path'], 32, encoding="utf-8")
     
     async def process(self, message: str) -> list[MessageComponent]:
         img_path = self.text_to_image(

pkg/pipeline/preproc/preproc.py

@@ -52,7 +52,7 @@ class PreProcessor(stage.PipelineStage):
         query.messages = event_ctx.event.prompt
 
         # 根据模型max_tokens剪裁
-        max_tokens = min(query.use_model.max_tokens, self.ap.cfg_mgr.data['prompt_submit_length'])
+        max_tokens = min(query.use_model.max_tokens, self.ap.pipeline_cfg.data['submit-messages-tokens'])
 
         test_messages = query.prompt.messages + query.messages + [query.user_message]
 
@@ -63,7 +63,7 @@ class PreProcessor(stage.PipelineStage):
                     result_type=entities.ResultType.INTERRUPT,
                     new_query=query,
                     user_notice='输入内容过长，请减少情景预设或者输入内容长度',
-                    console_notice='输入内容过长，请减少情景预设或者输入内容长度，或者增大配置文件中的 prompt_submit_length 项（但不能超过所用模型最大tokens数）'
+                    console_notice='输入内容过长，请减少情景预设或者输入内容长度，或者增大配置文件中的 submit-messages-tokens 项（但不能超过所用模型最大tokens数）'
                 )
 
             query.messages.pop(0) # pop第一个肯定是role=user的

pkg/pipeline/process/handlers/chat.py

@@ -54,6 +54,12 @@ class ChatMessageHandler(handler.MessageHandler):
                 )
         else:
 
+            if not self.ap.provider_cfg.data['enable-chat']:
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query,
+                )
+
             if event_ctx.event.alter is not None:
                 query.message_chain = mirai.MessageChain([
                     mirai.Plain(event_ctx.event.alter)
@@ -83,7 +89,7 @@ class ChatMessageHandler(handler.MessageHandler):
                 yield entities.StageProcessResult(
                     result_type=entities.ResultType.INTERRUPT,
                     new_query=query,
-                    user_notice=self.ap.tips_mgr.data['alter_tip_message'] if self.ap.cfg_mgr.data['hide_exce_info_to_user'] else f'{e}',
+                    user_notice='请求失败' if self.ap.platform_cfg.data['hide-exception-info'] else f'{e}',
                     error_notice=f'{e}',
                     debug_notice=traceback.format_exc()
                 )

pkg/pipeline/process/handlers/command.py

@@ -23,8 +23,8 @@ class CommandHandler(handler.MessageHandler):
 
 
         privilege = 1
-        if query.sender_id == self.ap.cfg_mgr.data['admin_qq'] \
-            or query.sender_id in self.ap.cfg_mgr['admin_qq']:
+        
+        if f'{query.launcher_type.value}_{query.launcher_id}' in self.ap.system_cfg.data['admin-sessions']:
             privilege = 2
 
         spt = str(query.message_chain).strip().split(' ')

pkg/pipeline/ratelimit/algos/fixedwin.py

@@ -55,16 +55,16 @@ class FixedWindowAlgo(algo.ReteLimitAlgo):
             # 获取当前分钟的访问次数
             count = container.records.get(now, 0)
 
-            limitation = self.ap.cfg_mgr.data['rate_limitation']['default']
+            limitation = self.ap.pipeline_cfg.data['rate-limit']['fixwin']['default']
 
-            if session_name in self.ap.cfg_mgr.data['rate_limitation']:
-                limitation = self.ap.cfg_mgr.data['rate_limitation'][session_name]
+            if session_name in self.ap.pipeline_cfg.data['rate-limit']['fixwin']:
+                limitation = self.ap.pipeline_cfg.data['rate-limit']['fixwin'][session_name]
 
             # 如果访问次数超过了限制
             if count >= limitation:
-                if self.ap.cfg_mgr.data['rate_limit_strategy'] == 'drop':
+                if self.ap.pipeline_cfg.data['rate-limit']['strategy'] == 'drop':
                     return False
-                elif self.ap.cfg_mgr.data['rate_limit_strategy'] == 'wait':
+                elif self.ap.pipeline_cfg.data['rate-limit']['strategy'] == 'wait':
                     # 等待下一分钟
                     await asyncio.sleep(60 - time.time() % 60)
     

pkg/pipeline/ratelimit/ratelimit.py

@@ -42,7 +42,7 @@ class RateLimit(stage.PipelineStage):
                     result_type=entities.ResultType.INTERRUPT,
                     new_query=query,
                     console_notice=f"根据限速规则忽略 {query.launcher_type.value}:{query.launcher_id} 消息",
-                    user_notice=self.ap.tips_mgr.data['rate_limit_drop_tip']
+                    user_notice=f"请求数超过限速器设定值，已丢弃本消息。"
                 )
         elif stage_inst_name == "ReleaseRateLimitOccupancy":
             await self.algo.release_access(

pkg/pipeline/respback/respback.py

@@ -20,7 +20,7 @@ class SendResponseBackStage(stage.PipelineStage):
     async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
         """处理
         """
-        random_delay = random.uniform(*self.ap.cfg_mgr.data['force_delay_range'])
+        random_delay = random.uniform(*self.ap.platform_cfg.data['force-delay'])
 
         self.ap.logger.debug(
             "根据规则强制延迟回复: %s s",

pkg/pipeline/resprule/resprule.py

@@ -33,13 +33,13 @@ class GroupRespondRuleCheckStage(stage.PipelineStage):
 
     async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
         
-        if query.launcher_type != 'group':
+        if query.launcher_type.value != 'group':
             return entities.StageProcessResult(
                 result_type=entities.ResultType.CONTINUE,
                 new_query=query
             )
 
-        rules = self.ap.cfg_mgr.data['response_rules']
+        rules = self.ap.pipeline_cfg.data['respond-rules']
 
         use_rule = rules['default']
 

pkg/pipeline/resprule/rules/prefix.py

@@ -16,6 +16,7 @@ class PrefixRule(rule_model.GroupRespondRule):
 
         for prefix in prefixes:
             if message_text.startswith(prefix):
+
                 return entities.RuleJudgeResult(
                     matching=True,
                     replacement=mirai.MessageChain([

pkg/pipeline/resprule/rules/random.py

@@ -14,7 +14,7 @@ class RandomRespRule(rule_model.GroupRespondRule):
         message_chain: mirai.MessageChain,
         rule_dict: dict
     ) -> entities.RuleJudgeResult:
-        random_rate = rule_dict['random_rate']
+        random_rate = rule_dict['random']
         
         return entities.RuleJudgeResult(
             matching=random.random() < random_rate,

pkg/pipeline/wrapper/wrapper.py

@@ -85,7 +85,7 @@ class ResponseWrapper(stage.PipelineStage):
 
                     query.resp_message_chain = mirai.MessageChain([mirai.Plain(reply_text)])
 
-                    if self.ap.cfg_mgr.data['trace_function_calls']:
+                    if self.ap.platform_cfg.data['track-function-calls']:
                         
                         event_ctx = await self.ap.plugin_mgr.emit_event(
                             event=events.NormalMessageResponded(