openubmc-bingo 0.5.275__py3-none-any.whl → 0.6.0__py3-none-any.whl

bmcgo/utils/config.py

@@ -13,6 +13,7 @@
 import json
 import os
 import sys
+import re
 import copy
 import hashlib
 import stat
@@ -40,6 +41,7 @@ log = Logger("config")
 VERSION = "Version"
 BUILD_NUMBER = "BuildNum"
 VERSION_LEN = 5
+BMCSDKVERSION = "BMCSDKVersion"
 
 
 class Config:
@@ -63,11 +65,11 @@ class Config:
     _profile = ""
     conan_index_options = []
     _manifest_data = {}
-    schema_file = f"{misc.SCHEMA_FILE_PATH}/manifest.schema.json"
+    schema_file = f"{misc.schema_path()}/manifest.schema.json"
     schema_need_validate = False # 由frame.py或target文件配置是否启用
     enable_debug_model = False # # 是否启用调测模式，默认为false，个人构建启用
 
-    def __init__(self, bconfig: BmcgoConfig, board_name="openUBMC", target="target_personal"):
+    def __init__(self, bconfig: BmcgoConfig, board_name=misc.boardname_default(), target="target_personal"):
         self.bconfig = bconfig
 
         # 单板名
@@ -130,15 +132,20 @@ class Config:
         self.docker_tag = None
         # 伙伴/开源远端相关
         self.open_remote = None
+        self.platform_package = None
 
     @property
     def partner_mode(self):
         """是否是伙伴模式"""
         return self.bconfig.partner_mode
 
+    @property
+    def rtos_path(self):
+        return f"/opt/{self.rtos_offering}/{self.rtos_version}"
+
     @property
     def sysroot(self):
-        return f"/opt/{self.rtos_offering}/{self.rtos_version}/arm64le_{self.rtos_kernel}/sdk"
+        return f"{self.rtos_path}/arm64le_{self.rtos_kernel}/sdk"
 
     @property
     def self_sign(self):
@@ -207,15 +214,16 @@ class Config:
 
     @staticmethod
     def argparser(code_path, partner_mode=False):
-        parser = argparse.ArgumentParser(description="构建openUBMC", formatter_class=argparse.RawTextHelpFormatter)
+        parser = argparse.ArgumentParser(description="构建" + misc.boardname_default(),
+                                         formatter_class=argparse.RawTextHelpFormatter)
         boards = Config.get_all_board(code_path)
-        help_txt = "单板包，可选值为build/product/<Kunpeng|...>/下的目录名\n默认：openUBMC"
+        help_txt = "单板包，可选值为build/product/<Kunpeng|...>/下的目录名\n默认：" + misc.boardname_default()
         help_txt += "\n支持的单板列表："
         for board, _ in boards.items():
             help_txt += "\n" + board
-        parser.add_argument("-b", "--board_name", help=help_txt, default="openUBMC")
-        parser.add_argument("-bt", "--build_type", 
-                            help="构建类型，可选：debug（调试包）, release（正式包）, dt（开发者测试包）", default="debug")
+        parser.add_argument("-b", "--board_name", help=help_txt, default=misc.boardname_default())
+        parser.add_argument("-bt", "--build_type",
+                            help="构建类型，可选：debug（调试包）, release（正式包）", default="debug")
         parser.add_argument(
             "-s",
             "--from_source",
@@ -329,6 +337,14 @@ class Config:
         template_sha256 = template_hash.hexdigest()
         return sha256 + template_sha256
 
+    @staticmethod
+    def _get_number_version(version):
+        if "B" in version:
+            version = version.rsplit(".", 1)[0]
+        elif "b" in version:
+            version = version.rsplit(".", 1)[0]
+        return version
+
     @functools.cached_property
     def rtos_offering(self):
         return self.get_manufacture_config("base/rtos_offering", "RTOS")
@@ -406,7 +422,7 @@ class Config:
         """
         if self.version == "":
             return self.version
-        version = self.version.rsplit(".", 1)[0] if "B" in self.version else self.version
+        version = self._get_number_version(self.version)
         correction_version = str(int(version.rsplit(".", 1)[-1]) + 1)
         version = "{}.{}".format(version.rsplit(".", 1)[0], correction_version.zfill(2))
         return version
@@ -420,7 +436,7 @@ class Config:
 
     # 模板化，manifest.yml替换时使用
     def get_template(self) -> dict:
-        version = self.version.rsplit(".", 1)[0] if "B" in self.version else self.version
+        version = self._get_number_version(self.version)
         template = {
             "code_root": self.code_root,
             "product": f"{self.code_path}/product",
@@ -554,12 +570,12 @@ class Config:
     def set_build_type(self, arg_build_type="debug"):
         '''
         这只编译app的cmake编译选项
-        参数：arg_build_type 可选值："debug";"release";"dt"
+        参数：arg_build_type 可选值："debug";"release"
         '''
         # 可以编译的版本
-        build_type_turple = ("debug", "release", "dt")
+        build_type_turple = misc.build_type()
         if arg_build_type not in build_type_turple:
-            log.info("不支持的构建类型, 请从以下构建类型中输入: [debug release dt]")
+            log.info(f"不支持的构建类型, 请从以下构建类型中输入: [{misc.build_type_str()}]")
             return
 
         self.build_type = arg_build_type
@@ -599,7 +615,7 @@ class Config:
 
     def set_common_params(self):
         # conan仓
-        self.remote = None
+        self.remote = misc.conan_remote()
         self.remote_list = []
         self.temp_platform_dir_name = f"temp/board_{self.board_name}_platform"
         self.temp_platform_build_dir = os.path.join(self.code_path, self.temp_platform_dir_name)
@@ -632,6 +648,8 @@ class Config:
         boards = self.get_all_board(self.code_path)
         # 单板配置路径
         self.ori_board_path = boards.get(self.board_name)
+        if not self.ori_board_path:
+            raise errors.ConfigException(f"未知的单板 {self.board_name}，请检查参数配置是否正确")
         log.info(f"单板源配置路径: {self.ori_board_path}")
         # openUBMC get Kunpeng
         self.productline = os.path.abspath(self.ori_board_path).split('/')[-2]
@@ -646,7 +664,7 @@ class Config:
         tools.run_command(f"cp -rf {self.ori_board_path} {self.board_path}")
 
     def set_enable_luajit(self, enable):
-        if self.build_type == "Dt":
+        if misc.conan_v1() and self.build_type == "Dt":
             self.enable_luajit = False
         self.enable_luajit = enable
 
@@ -671,7 +689,10 @@ class Config:
         self.enable_qemu = True if enable_qemu is True else self.enable_qemu
 
     def set_stage(self, stage: str):
-        in_stage = [member.value for member in misc.StageEnum if member is not misc.StageEnum.STAGE_PRE]
+        if misc.conan_v2():
+            in_stage = [member.value for member in misc.StageEnum]
+        else:
+            in_stage = [member.value for member in misc.StageEnum if member is not misc.StageEnum.STAGE_PRE]
         if stage not in in_stage:
             raise errors.ConfigException(f"stage 参数错误, 可用选项为: {in_stage}, 请检查参数")
         self.stage = stage
@@ -761,11 +782,11 @@ class Config:
         com_package_split = com_package[index].split("/")
         if len(com_package_split) == 1:
             com_package[index] = sub_name
-        elif len(com_package_split) == 2:
+        elif len(com_package_split) == 2 and "@" not in com_package[index]:
             stage = self.stage
             if stage != misc.StageEnum.STAGE_STABLE.value:
                 stage = misc.StageEnum.STAGE_RC.value
-            user_channel = f"@{tools.conan_user}/{stage}"
+            user_channel = f"@{misc.conan_user()}/{stage}"
             com_package[index] += user_channel
 
     def get_subsys_coms(self):
@@ -781,7 +802,10 @@ class Config:
         return comps
 
     def load_platform_manifest(self, package):
-        package_conan_dir = tools.install_platform(package, self.stage, self.remote)
+        self.platform_package = package[misc.CONAN]
+        if misc.conan_v2():
+            self.platform_package = self.platform_package.lower()
+        package_conan_dir = tools.install_platform(package, self.stage, self.remote, self.update_conan_cache)
         if os.path.isdir(self.temp_platform_build_dir):
             shutil.rmtree(self.temp_platform_build_dir)
         os.makedirs(os.path.join(self.code_path, "temp"), exist_ok=True)
@@ -850,6 +874,11 @@ class Config:
         if template is None:
             template = self.get_template()
         mani = self._load_manifest_with_template(filename, template)
+        schema_file = mani.get("schema", "")
+        if schema_file:
+            self.schema_file = schema_file
+        else:
+            self.schema_file = misc.get_decleared_schema_file(filename)
         inc_filename = mani.get("include")
         if not inc_filename:
             return mani
@@ -865,17 +894,13 @@ class Config:
         mani_inc = self.load_manifest_yml(inc_filename, template)
         self.merge_manifest_yml(mani, mani_inc, "")
         if top_manifest and self.schema_need_validate:
-            schema_file = mani.get("schema", self.schema_file)
-            if not schema_file:
-                schema_file = misc.get_decleared_schema_file(filename)
-                # 获取产品配置的schema，已通过schema校验，必然存在
-            if schema_file is None:
+            # 获取产品配置的schema，已通过schema校验，必然存在
+            if self.schema_file is None:
                 raise errors.BmcGoException("未找到应该遵循的manifest规范，无法校验manifest.yml文件正确性，" +
                                             "请检查配置项yaml-language-server或schema配置项是否正确")
-            if not os.path.isfile(schema_file):
-                raise errors.BmcGoException(f"产品配置了一个不存在的manifest规范文件{schema_file}，" +
-                                            "无法校验manifest.yml文件正确性，请检查bingo是否正确安装")
-            self.schema_file = schema_file
+            if not os.path.isfile(self.schema_file):
+                raise errors.BmcGoException(f"产品配置了一个不存在的manifest规范文件{self.schema_file}，" +
+                                            f"无法校验manifest.yml文件正确性，请检查{misc.tool_name()}是否正确安装")
             with open(self.schema_file, "rb") as fp:
                 schema = json.load(fp)
             log.debug(f"使用规范配置文件{self.schema_file}校验{filename}配置项")
@@ -886,7 +911,7 @@ class Config:
         self.archive_conf = self.get_manufacture_config("archive")
         self.archive_path = self.get_manufacture_config("archive/archive_path")
         if self.target == "docker_build":
-            self.archive_path = "openUBMC/ToCommunity"
+            self.archive_path = f"{misc.logo()}/ToCommunity"
         self.partner_docker = self.get_manufacture_config("archive/partner_docker")
 
     def version_split(self):
@@ -922,7 +947,9 @@ class Config:
         with open(manifest_file, "r", encoding="utf-8") as fp:
             mani = yaml.safe_load(fp)
         mani["base"]["version"] = self.version
-        schema_file = misc.get_decleared_schema_file(manifest_file)
+        schema_file = mani.get("schema", "")
+        if not schema_file:
+            schema_file = misc.get_decleared_schema_file(manifest_file)
         with os.fdopen(os.open(manifest_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
                                stat.S_IWUSR | stat.S_IRUSR), 'w+') as file_handler:
             if schema_file != "":
@@ -961,6 +988,9 @@ class Config:
 
         with open(dest_file, "r") as dst:
             ver_dst_data = json.load(dst)
+            if self.platform_package:
+                version_temp = re.split("/|@", self.platform_package)[1].split(".")[:4]
+                ver_dst_data[BMCSDKVERSION] = ".".join(version_temp)
             # 大版本字段为空，自动填充
             if ver_dst_data[VERSION] == "":
                 real_version = ""
@@ -968,7 +998,10 @@ class Config:
                     real_version = fixed_version
                 else:
                     real_version = version
-                ver_dst_data[VERSION] = real_version.rsplit(".", 1)[0] if "B" in real_version else real_version
+                if misc.conan_v2():
+                    ver_dst_data[VERSION] = self._get_number_version(real_version)
+                else:
+                    ver_dst_data[VERSION] = real_version.rsplit(".", 1)[0] if "B" in real_version else real_version
                 # 如果包名中有manufacture字段，则自动加1
                 if "manufacture" in package_name:
                     version_list = ver_dst_data[VERSION].rsplit(".", 1)
@@ -976,10 +1009,10 @@ class Config:
 
             # 小版本为空，则填充
             if ver_dst_data[BUILD_NUMBER] == "":
-                if fixed_version is not None and "B" in fixed_version:
-                    ver_dst_data[BUILD_NUMBER] = fixed_version.rsplit(".", 1)[1].strip("B")
+                if fixed_version is not None and ("B" in fixed_version or "b" in fixed_version):
+                    ver_dst_data[BUILD_NUMBER] = fixed_version.rsplit(".", 1)[1].strip("B").strip("b")
                 else:
-                    ver_dst_data[BUILD_NUMBER] = version.rsplit(".", 1)[1].strip("B")
+                    ver_dst_data[BUILD_NUMBER] = version.rsplit(".", 1)[1].strip("B").strip("b")
 
             # 填充构建日期
             if ver_dst_data['ReleaseDate'] == "":
@@ -1027,9 +1060,6 @@ class Config:
         self.set_build_type(args.build_type)
         self.set_stage(args.stage)
         self.set_board_name(args.board_name)
-        self.asan = args.asan
-        self.remote = args.remote
-        self.remote_list = tools.get_conan_remote_list(self.remote)
         self.verbose = args.verbose
         if os.environ.get("LOG"):
             self.verbose = True
@@ -1041,19 +1071,25 @@ class Config:
         self.set_enable_arm_gcov(args.coverage)
         self.set_enable_luajit(args.enable_luajit)
         self.set_show_version()
+        self.asan = args.asan
+        self.remote = args.remote
+        self.remote_list = tools.get_conan_remote_list(self.remote)
         self.get_archive()
         self.init_conan_profile(args.profile)
 
         # 构建阶段检查
-        bt = ["dt", "debug", "release"]
+        bt = misc.build_type()
         if args.build_type not in bt:
-            raise errors.ConfigException("构建类型 build_type 错误, 可用选项为: [debug, release, dt], 请检查参数")
+            raise errors.ConfigException(f"构建类型 build_type 错误, 可用选项为: {misc.build_type_str()}, 请检查参数")
 
         hpm_encrypt = self.bconfig.hpm_encrypt
-        if hpm_encrypt and hpm_encrypt.need_encrypt:
+        if misc.need_encrypt_hpm() or (hpm_encrypt and hpm_encrypt.need_encrypt):
             if not shutil.which("crypto_tool"):
                 raise errors.BmcGoException(f"开启了hpm加密配置, 在环境中未找到 'crypto_tool', 请确认环境配置是否正确.")
             os.environ["HPM_ENCRYPT"] = "true"
+        else:
+            log.info(f"未开启hpm加密配置")
+
 
     def _load_manifest_with_template(self, filename, template):
         try:

bmcgo/utils/fetch_component_code.py

@@ -19,7 +19,7 @@ import patch_ng
 import yaml
 from git import Repo
 
-from bmcgo.misc import errors
+from bmcgo import errors
 from bmcgo import misc
 from bmcgo.utils.tools import Tools
 
@@ -44,7 +44,7 @@ class FetchComponentCode:
     @staticmethod
     def resolve_version_range(component_name, version_range):
         cmd = f"conan info '{version_range}' --package-filter={component_name}/*" \
-             f" -r {misc.CONAN_REPO} --only None 2>/dev/null"
+             f" -r {misc.conan_remote()} --only None 2>/dev/null"
         ret, output = subprocess.getstatusoutput(cmd)
         output = output.strip()
         if ret != 0 or not output:
@@ -93,7 +93,10 @@ class FetchComponentCode:
     @staticmethod
     def __apply_patches(conandata_file, patches, code_dir):
         cwd = os.getcwd()
-        recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "export_source")
+        if misc.conan_v1():
+            recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "export_source")
+        else:
+            recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "es")
         recipe_folder = os.path.realpath(recipe_folder)
         os.chdir(os.path.join(cwd, code_dir))
         for patch in patches:
@@ -136,17 +139,20 @@ class FetchComponentCode:
     @staticmethod
     def __update_code_by_branch(code_dir, deps):
         url = deps['url']
-        branch = deps['branch'].split('/')[-1]
-
+        branch = deps.get("branch", "").split('/')[-1] or deps.get("commit", "")
         if os.path.exists(code_dir):
             repo = Repo(code_dir)
-            repo.git.fetch('origin', branch)
-            repo.git.pull('origin', branch)
-            repo.git.checkout(branch)
+            repo.git.fetch('origin')
         else:
-            Repo.clone_from(url, to_path=code_dir, branch=branch)
+            Repo.clone_from(url, to_path=code_dir)
             repo = Repo(code_dir)
-        log.info("更新代码(组件: %s, 地址: %s, 分支: %s)", code_dir, url, branch)
+        if re.match(r"^[0-9a-f]{40}$", branch):
+            repo.head.reset(branch, working_tree=True)
+        elif branch.startswith("refs/tags/"):
+            repo.head.reset(branch[len("refs/tags/"):], working_tree=True)
+        else:
+            repo.git.checkout(branch)
+        log.info("更新代码(组件: %s, 地址: %s, 节点: %s)", code_dir, url, branch)
 
     @staticmethod
     def __update_component_code_by_conandata(name, version, conandata_file):
@@ -207,26 +213,39 @@ class FetchComponentCode:
         try:
             os.chdir(self.target_dir)
             log.info("更新 %s 组件代码到 %s 开始", component_name, conan_version)
-
-            version_split = re.split(r'[/, @]', conan_version)
-            conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
-            conandata = os.path.join(conan_dir, 'conandata.yml')
-            if not os.path.exists(conan_dir):
+            if misc.conan_v1():
+                version_split = re.split(r'[/, @]', conan_version)
+                conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
+                conandata = os.path.join(conan_dir, 'conandata.yml')
+                if not os.path.exists(conan_dir):
+                    conan_remote_list = tools.get_conan_remote_list(self.remote)
+                    tools.download_conan_recipes(conan_version, conan_remote_list)
+                if os.path.exists(conandata):
+                    self.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
+                    return
+
+                conanfile = os.path.join(conan_dir, 'conanfile.py')
+                if os.path.exists(conanfile):
+                    revision, url = self.__getinfo_from_conanfile(conanfile)
+                    self.__update_code_by_commit_id(component_name, url, revision)
+                    return
+                log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
+            else:
                 conan_remote_list = tools.get_conan_remote_list(self.remote)
                 tools.download_conan_recipes(conan_version, conan_remote_list)
-            if os.path.exists(conandata):
-                FetchComponentCode.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
-                return
+                path_cmd = f"conan cache path {conan_version}"
+                path_cmd_info = Tools().run_command(path_cmd, capture_output=True)
 
-            conanfile = os.path.join(conan_dir, 'conanfile.py')
-            if os.path.exists(conanfile):
-                revision, url = FetchComponentCode.__getinfo_from_conanfile(conanfile)
-                FetchComponentCode.__update_code_by_commit_id(component_name, url, revision)
-                return
+                version_split = re.split(r'[/, @]', conan_version)
+                conan_dir = path_cmd_info.stdout.strip()
+                conandata = os.path.join(conan_dir, 'conandata.yml')
+                if os.path.exists(conandata):
+                    self.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
+                    return
 
-            log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
+                log.error("conandata(%s) 没有找到", conandata)
             log.info("更新组件 %s 代码到 %s 失败, 无法获取到 conan 信息", component_name,
                      conan_version)
         except Exception as exp:
             log.error("工作状态错误: %s", exp)
-            log.error("更新组件代码到 %s 失败", conan_version)
+            log.error("更新组件代码到 %s 失败", conan_version)

bmcgo/utils/installations/install_plans/qemu.yml

@@ -0,0 +1,6 @@
+version_homogeneous: true
+install_steps:
+  - type: apt
+    package_name: openubmc-qemu
+    doc: https://www.openubmc.cn/marketplace/QEMU
+

bmcgo/utils/installations/install_plans/studio.yml

@@ -0,0 +1,6 @@
+version_homogeneous: true
+install_steps:
+  - type: apt
+    package_name: bmc-studio
+    doc: https://www.openubmc.cn/marketplace/BMC%20Studio
+

bmcgo/utils/installations/install_workflow.py

@@ -26,6 +26,20 @@ class InstallWorkflow:
     _workflows: Dict[str, List[str]] = {}
     search_paths: List[Path] = [Path(__file__).resolve().parent / install_consts.PLUGIN_INSTALL_PLAN_PATH]
 
+    @staticmethod
+    def tool_exists(tool_name: str, install_type: str):
+        try:
+            if install_type == "pip":
+                ret = tools.run_command(f"pip show {tool_name}", capture_output=True, ignore_error=True)
+                return ret.returncode == 0
+            if install_type == "apt":
+                ret = tools.run_command(f"dpkg -s {tool_name}", capture_output=True, ignore_error=True)
+                return "Status: install ok installed" in ret.stdout
+        except Exception as e:
+            tools.log.info(f"校验工具存在性时报错：{str(e)}")
+
+        return False
+    
     @classmethod
     def discover_workflows(cls):
         for path in cls.search_paths:
@@ -35,7 +49,8 @@ class InstallWorkflow:
 
             for yml_file in path.glob("*.yml"):
                 with open(yml_file) as conf:
-                    cls._workflows[yml_file.stem] = yaml.safe_load(conf)
+                    file_content = yaml.safe_load(conf)
+                    cls._register_workflows(yml_file=yml_file, file_content=file_content)
 
     @classmethod
     def parse(cls, name: str) -> List[str]:
@@ -51,4 +66,15 @@ class InstallWorkflow:
 
     @classmethod
     def get_all_plans(cls):
-        return cls._workflows.keys()
+        return cls._workflows.keys()
+    
+    @classmethod
+    def _register_workflows(cls, yml_file, file_content):
+        plans = file_content.get(install_consts.PLAN_STEPS, [])
+        for plan in plans:
+            inst_type = plan.get(install_consts.PLAN_INSTALL_TYPE)
+            if not inst_type:
+                raise ValueError(f"未配置 {yml_file}/{install_consts.PLAN_STEPS}/{install_consts.PLAN_INSTALL_TYPE}")
+            package_name = plan.get(install_consts.PLAN_PACKAGE_NAME)
+            if cls.tool_exists(package_name, inst_type): # 未安装的工具不加入_workflows
+                cls._workflows[yml_file.stem] = file_content

bmcgo/utils/merge_csr.py

@@ -0,0 +1,124 @@
+# coding: utf-8
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+import json
+import re
+import os
+from pathlib import Path
+from bmcgo.utils.tools import Tools
+
+tools = Tools("bmcgo_config")
+log = tools.log
+
+
+class Merger():
+    def __init__(self, output_dir):
+        self.output_dir = output_dir
+        self.special_suffix = ("_basic_info", "_mgmt_model", "_version")
+        self.tmp_dir = None
+
+    @staticmethod
+    def remove_json5_comments(text):
+        pattern = r"""
+            ("(?:\\.|[^"\\])*"
+            |'(?:\\.|[^'\\])*'
+            )
+            |(/\*[\s\S]*?\*/
+            |//[^\n]*
+            )
+        """
+
+        def replacer(match):
+            if match.group(1):
+                return match.group(1)
+            else:
+                return ''
+        return json.loads(re.sub(pattern, replacer, text, flags=re.VERBOSE))
+
+    def merge_json(self, dict1, dict2, is_top_level=True, path=None):
+        if path is None:
+            path = []
+        if not isinstance(dict1, dict) or not isinstance(dict2, dict):
+            if dict1 != dict2:
+                raise ValueError(f"字段冲突，路径{'/'.join(path)}的值不一致：{dict1} vs {dict2}")
+            return dict1
+        for key, value in dict2.items():
+            if key in dict1:
+                if is_top_level:
+                    _ = self.merge_json(dict1[key], value, is_top_level=False, path=path + [key])
+                else:
+                    raise ValueError(f"字段冲突：路径 {'/'.join(path + [key])} 在多个文件中重复出现")
+            else:
+                dict1[key] = value
+        return dict1
+
+    def generate_csr(self, filelist, csr_path):
+        log.info(f"正在创建临时csr文件")
+        merged = {}
+        for file_path in filelist:
+            p = Path(file_path)
+            if not p.exists():
+                raise FileNotFoundError(f"文件不存在：{file_path}")
+            with open(p, "r", encoding="utf-8") as fp:
+                content = self.remove_json5_comments(fp.read())
+                merged = self.merge_json(merged, content)
+        with open(csr_path, "w") as f:
+            json.dump(merged, f)
+        log.info(f"临时文件创建成功")
+
+    def update_tmp_dir(self, tmp_dir):
+        self.tmp_dir = tmp_dir
+
+    def get_single_csr(self, csr_path):
+        if os.path.exists(csr_path):
+            return csr_path
+        name, ext = os.path.splitext(csr_path)
+        modularize_csr = []
+        for suffix in self.special_suffix:
+            new_path = f"{name}{suffix}{ext}"
+            if not os.path.exists(new_path):
+                raise FileNotFoundError(f"路径 {new_path} 不存在")
+            modularize_csr.append(new_path)
+        csr_path = os.path.join(self.tmp_dir, os.path.basename(csr_path))
+        self.generate_csr(modularize_csr, csr_path)
+        return csr_path
+
+    def get_multi_files(self, dir_path):
+        srs = list(dir_path.glob("*.sr"))
+        stem_to_path = {p.stem: p for p in srs}
+        special_by_base = {}
+        for p in srs:
+            stem = p.stem
+            for suf in self.special_suffix:
+                if not stem.endswith(suf):
+                    continue
+                base = stem.removesuffix(suf)
+                if base:
+                    special_by_base.setdefault(base, {})[suf] = p
+                break
+        to_skip = set()
+        to_create = []
+        for base, mod_path in special_by_base.items():
+            if base in stem_to_path:
+                to_skip.update(mod_path.values())
+            else:
+                if not all(s in mod_path for s in self.special_suffix):
+                    continue
+                plain = dir_path / f"{base}.sr"
+                if not plain.exists():
+                    plain = os.path.join(self.tmp_dir, f"{base}.sr")
+                    self.generate_csr([mod_path[s] for s in self.special_suffix], plain)
+                to_create.append(plain)
+                to_skip.update(mod_path.values())
+        res = [p for p in srs if p not in to_skip]
+        res.extend(to_create)
+        log.info(res)
+        return res