将生成DB代码中获取文档的部分调整为从数据库抽取对应章节

YM

7 小时以前 4e0624b8ac6a2547018f70e137ab32baa7941f28

将生成DB代码中获取文档的部分调整为从数据库抽取对应章节

 .gitignore

@@ -7,4 +7,5 @@
/out*
/packages
__pycache__
/static/
/static/
*.log

 db_struct_flow.py

@@ -17,6 +17,8 @@

from knowledgebase.db.models import TProject

from knowledgebase.db.doc_db_helper import doc_dbh

# file_map = {
#     # "遥测源包设计报告": "./doc/HY-4A数管分系统遥测源包设计报告 Z 240824 更改3(内部) .docx.md",
#     # "遥测源包设计报告": "./doc/数管数字量快速源包.md",
@@ -105,13 +107,11 @@
10. 以 JSON 格式组织输出内容，确保数据结构的完整性和可读性，注意：生成的JSON语法格式必须符合json规范，避免出现错误。
    
## 限制：
- id和code的命名规则：英文字母、数字、下划线组成，且以英文字母或下划线开头。
- 所输出的内容必须按照JSON格式进行组织，不能偏离框架要求，且严格遵循文档内容进行输出，只输出 JSON ，不要输出其它文字。
- 不输出任何注释等描述性信息。
"""

g_completion = None


def read_from_file(cache_file):
    with open(cache_file, 'r', encoding='utf-8') as f:
@@ -345,14 +345,22 @@

        self.gen_tc()
        return ''
    
    def get_text_with_entity(self, entity_names: list[str]) -> str:
        """
        根据实体词获取文档文本
        :param entity_names: str - 实体词名称
        :return: str - 文本内容
        """
        return doc_dbh.get_text_with_entities(entity_names)

    def _gen(self, msgs, msg, files=None):
        if files is None:
            files = [file_map['文档合并']]
    def _gen(self, msgs, msg, doc_text):
        # if files is None:
        #     files = [file_map['文档合并']]
        messages = [] if msgs is None else msgs
        doc_text = ''
        for file in files:
            doc_text += '\n' + read_from_file(file)
        # doc_text = ''
        # for file in files:
        #     doc_text += '\n' + read_from_file(file)
        if len(messages) == 0:
            # 如果是第一次提问加入system消息
            messages.append({'role': 'system', 'content': assistant_msg})
@@ -380,14 +388,14 @@
        g_completion = None
        return text

    def generate_text(self, msg, cache_file, msgs=None, files=None, validation=None, try_cnt=5, json_text=False):
    def generate_text(self, msg, cache_file, msgs=None, doc_text=None, validation=None, try_cnt=5, json_text=False):
        if msgs is None:
            msgs = []
        if USE_CACHE and os.path.isfile(cache_file):
            text = read_from_file(cache_file)
        else:
            s = time.time()
            text = self._gen(msgs, msg, files)
            text = self._gen(msgs, msg, doc_text)
            text = remove_think_tag(text)
            if json_text:
                text = get_json_text(text)
@@ -398,39 +406,27 @@
                    print(e)
                    if try_cnt <= 0:
                        raise RuntimeError('生成失败，重试次数太多，强制结束！')
                    return self.generate_text_json(msg, cache_file, msgs, files, validation, try_cnt - 1)
                    return self.generate_text_json(msg, cache_file, msgs, doc_text, validation, try_cnt - 1)
            if cache_file:
                save_to_file(text, cache_file)
            print(f'耗时：{time.time() - s}')
        return text

    def generate_text_json(self, msg, cache_file, msgs=None, files=None, validation=None, try_cnt=5):
        return self.generate_text(msg, cache_file, msgs, files, validation, try_cnt, True)
    def generate_text_json(self, msg, cache_file, msgs=None, doc_text=None, validation=None, try_cnt=5):
        return self.generate_text(msg, cache_file, msgs, doc_text, validation, try_cnt, True)

    def generate_tc_text(self, msg, cache_file, messages=None, files=None, validation=None, try_cnt=5):
        if messages is None:
            messages = []
        doc_text = ''
        for file in files:
            doc_text += '\n' + read_from_file(file)
        if len(messages) == 0:
            # 如果是第一次提问加入system消息
            messages.append({'role': 'user', 'content': "以下是文档内容：\n" + doc_text})
        return self.generate_text_json(msg, cache_file, messages, files, validation, try_cnt)
    def generate_tc_text(self, msg, cache_file, msgs=None, doc_text=None, validation=None, try_cnt=5):
        return self.generate_text(msg, cache_file, msgs, doc_text, validation, try_cnt, True)

    def gen_project(self):
        #         _msg = """
        # 根据文档输出型号信息，型号字段包括：名称和代号。仅输出型号这一级。
        # 例如：{"name":"xxx","id":"xxx"}
        # """
        #         print('型号信息：')
        #         text = self.generate_text(_msg, 'out/型号信息.json', files=[file_map['应用软件用户需求']])
        #         proj_dict = json.loads(text)
        # 工程信息从系统获取
        proj_dict = {
            "id": "JB200001",
            "name": "HY-4A"
        }
        _msg = """
            根据文档内容输出分系统信息，分系统字段包括：名称和型号代号。仅输出分系统这一级。如果型号代号中有符号也要输出，保证输出完整。
            例如：{"name":"xxx","id":"xxx"}
        """
        print('型号信息：')
        doc_text = self.get_text_with_entity(['系统概述'])
        text = self.generate_text_json(_msg, 'out/型号信息.json', doc_text=doc_text)
        proj_dict = json.loads(text)
        code = proj_dict['id']
        name = proj_dict['name']
        proj = create_project(code, name, code, name, "", datetime.now())
@@ -495,7 +491,8 @@
            assert isinstance(_devs, list), '数据结构最外层不是数组'
            assert next(filter(lambda it: it['name'].endswith('管理单元'), _devs), None), '生成的设备列表中没有管理单元'

        text = self.generate_text_json(_msg, cache_file, files=[file_map['应用软件用户需求']], validation=validation)
        doc_text = self.get_text_with_entity(['系统概述','总线管理'])
        text = self.generate_text_json(_msg, cache_file, doc_text=doc_text, validation=validation)
        devs = json.loads(text)

        # 类SMU设备，包含遥测和遥控功能，名称结尾为“管理单元”
@@ -550,9 +547,10 @@
参数信息字段包括：name（参数名称）、id（参数代号）、pos（参数起始bit位置）、length（参数bit长度）、type（类型：para）。
注意：
1个字节的长度为8位，使用B0-B7来表示，请精确计算参数长度。
文档中位置描述信息可能存在跨字节的情况，例如："Byte1_B6~Byte2_B0":表示从第1个字节的第7位到第2个字节的第1位，长度是3;"Byte27_B7~Byte28_B0":表示从第27个字节的第8位到第28个字节的第1位，长度是2。
文档中位置描述信息可能存在跨字节的情况，例如："Byte1_B6~Byte2_B0":表示从第1个字节的第7位到第2个字节的第1位，长度是3;"Byte27_B7~Byte28_B0":表示从第27个字节的第8位到第28个字节的第1位，长度是2;"Byte38~Byte74":表示从第38个字节到第74个字节，中间有37个字节，长度是298。
#约束
- 不要遗漏任何参数；
- 如果有代号严格依照文档中的代号，文档中的代号如果不符合代号命名规则将特殊字符转换为下划线，例如：Rsv-1转换为Rsv_1；
- 数据结构最外层为数组，数组元素为参数信息对象；
- 仅输出JSON文本。
#例子
@@ -567,14 +565,14 @@
]
"""
        print('插入域参数列表：')
        files = [file_map['遥测大纲']]

        def validation(gen_text):
            params = json.loads(gen_text)
            assert isinstance(params, list), '插入域参数列表数据结构最外层必须是数组'
            assert len(params), '插入域参数列表不能为空'

        text = self.generate_text_json(_msg, './out/插入域参数列表.json', files=files, validation=validation)
        doc_text = self.get_text_with_entity(['插入域'])
        text = self.generate_text_json(_msg, './out/插入域参数列表.json', doc_text=doc_text, validation=validation)
        return json.loads(text)

    def gen_tm_frame_data(self):
@@ -623,29 +621,31 @@
            _vc_pkts = filter(lambda it: it['vcs'].__contains__(vc['id']), self.vc_pkts)
            for _pkt in _vc_pkts:
                # 判断遥测包是否有详细定义
                if not next(filter(lambda it: it['name'] == _pkt['name'] and it['hasParams'], self.tm_pkts), None):
                    continue
                # if not next(filter(lambda it: it['name'] == _pkt['name'] and it['hasParams'], self.tm_pkts), None):
                #     continue
                # 获取包详情
                _pkt = self.gen_pkt_details(_pkt['name'], _pkt['id'])
                epdu = next(filter(lambda it: it['name'] == '数据域', vc['children']), None)
                if epdu and _pkt:
                    _pkt['children'] = _pkt['datas']
                    _last_par = _pkt['children'][len(_pkt['children']) - 1]
                    _pkt['length'] = (_last_par['pos'] + _last_par['length'])
                    _pkt['pos'] = 0
                    if 'children' not in epdu:
                        epdu['children'] = []
                    # 添加解析规则后缀防止重复
                    _pkt['id'] = _pkt['id'] + '_' + vc['VCID']
                    # 给包名加代号前缀
                    if not _pkt['name'].startswith(_pkt['id']):
                        _pkt['name'] = _pkt['id'] + '_' + _pkt['name']
                    epdu['children'].append(_pkt)
                    apid_node = next(filter(lambda it: it['name'].__contains__('应用过程'), _pkt['headers']), None)
                    ser_node = next(filter(lambda it: it['name'] == '服务', _pkt['headers']), None)
                    sub_ser_node = next(filter(lambda it: it['name'] == '子服务', _pkt['headers']), None)
                    _pkt['vals'] = \
                        f"{apid_node['content']}/{int(ser_node['content'], 16)}/{int(sub_ser_node['content'], 16)}/"
                    # todo 当数据包获取到东西但不是参数时，获取到的包结构有问题，需要过滤
                    if len(_pkt['children']) > 0:
                        _last_par = _pkt['children'][len(_pkt['children']) - 1]
                        _pkt['length'] = (_last_par['pos'] + _last_par['length'])
                        _pkt['pos'] = 0
                        if 'children' not in epdu:
                            epdu['children'] = []
                        # 添加解析规则后缀防止重复
                        _pkt['id'] = _pkt['id'] + '_' + vc['VCID']
                        # 给包名加代号前缀
                        if not _pkt['name'].startswith(_pkt['id']):
                            _pkt['name'] = _pkt['id'] + '_' + _pkt['name']
                        epdu['children'].append(_pkt)
                        apid_node = next(filter(lambda it: it['name'].__contains__('应用过程'), _pkt['headers']), None)
                        ser_node = next(filter(lambda it: it['name'] == '服务', _pkt['headers']), None)
                        sub_ser_node = next(filter(lambda it: it['name'] == '子服务', _pkt['headers']), None)
                        _pkt['vals'] = \
                            f"{apid_node['content']}/{int(ser_node['content'], 16)}/{int(sub_ser_node['content'], 16)}/"

        # 重新计数起始偏移
        self.compute_length_pos(cadu['children'])
@@ -718,7 +718,8 @@
            assert next(filter(lambda it: re.match('^[0-1]+$', it['VCID']), vcs)), '生成的VCID必须是二进制'

        print('虚拟信道：')
        text = self.generate_text_json(_msg, "out/虚拟信道.json", files=[file_map['遥测大纲']], validation=validation)
        doc_text = self.get_text_with_entity(['虚拟信道定义'])
        text = self.generate_text_json(_msg, "out/虚拟信道.json", doc_text=doc_text, validation=validation)
        vcs = json.loads(text)
        return vcs

@@ -743,131 +744,106 @@
        dev_pkts = json.loads(text)
        return dev_pkts

    def pkt_in_tm_pkts(self, pkt_name):
        cache_file = f'out/数据包-{pkt_name}.json'
        if os.path.isfile(cache_file):
            return True
        files = [file_map['遥测源包设计报告']]
        print(f'文档中有无“{pkt_name}”的字段描述：', end='')
        _msg = f"""
#角色
你是一名资深的软件工程师。
#指令
我需要从文档中分析判读是否有某个遥测包的字段表描述，你要帮助我判断。
#问题
文档中有遥测包“{pkt_name}”的字段表描述吗？
注意：遥测包的字段表紧接着遥测包章节标题，如果章节标题后面省略了或者详见xxx则是没有字段表描述。
#约束
- 根据文档内容输出；
- 遥测包名称必须完全匹配；
- 输出“无”或“有”，不要输出其他任何内容。
#例子
有
"""
        text = self.generate_text(_msg, f'out/pkts/有无数据包-{pkt_name}.txt', [], files)
        return text == '有'

    def gen_pkt_details(self, pkt_name, pkt_id):
        cache_file = f'out/数据包-{pkt_name}.json'
        files = [file_map['遥测源包设计报告']]
        if not os.path.isfile(cache_file):
            # 先问最后一个参数的字节位置
            print(f'遥测源包“{pkt_name}”信息：')
            _msg = f"""
#角色
你是一名资深的软件工程师。
#指令
我需要从文档中提取遥测源包的最后一个参数的bit位置和数据域参数个数，你要帮我完成参数bit位置和数据域参数个数的提取。
#需求
输出文档中描述的名称为“{pkt_name}”代号为“{pkt_id}”遥测包的最后一个参数的bit位置和数据域参数个数。
""" + """
#约束
- 遥测源包的内容在一个表格中定义，表格结束则包内容结束；
- 数据域中每一行对应一个参数；
- 不要跨表格提取；
- 字节位置中字节位置是从1开始的，bit位置是从0开始的；
- bit位置计算公式为：(N-1)*8+B，其中N是字节数，B是bit数；
- 仅输出json，不要输出其他任何字符。
#例子：
{"last_par_pos":128, "par_num": 20}
"""
            text = self.generate_text_json(_msg, '', files=files)
            result = json.loads(text)
            last_par_pos = result['last_par_pos']
            par_num = result['par_num']
        
        # _msg = f"""
        #     #角色
        #     你是一名资深的软件工程师。
        #     #指令
        #     我需要从文档中提取遥测源包的最后一个参数的bit位置和数据域参数个数，你要帮我完成参数bit位置和数据域参数个数的提取。
        #     #需求
        #     输出文档中描述的名称为“{pkt_name}”代号为“{pkt_id}”遥测包的最后一个参数的bit位置和数据域参数个数。
        #     """ + """
        #     #约束
        #     - 遥测源包的内容在一个表格中定义，表格结束则包内容结束；
        #     - 数据域中每一行对应一个参数；
        #     - 不要跨表格提取；
        #     - 字节位置中字节位置是从1开始的，bit位置是从0开始的；
        #     - bit位置计算公式为：(N-1)*8+B，其中N是字节数，B是bit数；
        #     - 仅输出json，不要输出其他任何字符。
        #     #例子：
        #     {"last_par_pos":128, "par_num": 20}
        #     """
        
        # text = self.generate_text_json(_msg, '', doc_text=doc_text)
        # result = json.loads(text)
        # last_par_pos = result['last_par_pos']
        # par_num = result['par_num']

            _msg = f"""
#角色
你是一名资深的软件工程师。
#指令
我需要从文档中提取遥测源包信息列表，你要帮我完成遥测源包信息列表的提取。
#需求
输出文档中描述的名称为“{pkt_name}”代号为“{pkt_id}”遥测包。
注意：最后一个参数的起始bit偏移位置为{last_par_pos}。
""" + """
遥测包字段包括：名称(name)、代号(id)、类型(type)、包头属性列表(headers)、数据域参数列表(datas)，类型为 linear；
包头的属性的字段包括：名称(name)、代号(id)、位置(pos)、定义(content)、长度(length)、类型(type)，类型为 para；
数据域参数字段包括：参数名称(name)、参数代号(id)、位置(pos)、长度(length)、字节顺序(byteOrder)，类型为 para；
        _msg = f"""
            #角色
            你是一名资深的软件工程师。
            #指令
            我需要从文档中提取遥测源包信息列表，你要帮我完成遥测源包信息列表的提取。
            #需求
            输出文档中描述的名称为“{pkt_name}”代号为“{pkt_id}”遥测包。
            """ + """
            遥测包字段包括：名称(name)、代号(id)、类型(type)、包头属性列表(headers)、数据域参数列表(datas)，类型为 linear；
            包头的属性的字段包括：名称(name)、代号(id)、位置(pos)、定义(content)、长度(length)、类型(type)，类型为 para；
            数据域参数字段包括：参数名称(name)、参数代号(id)、位置(pos)、长度(length)、字节顺序(byteOrder)，类型为 para；

包头属性包括：包版本号、包类型、副导头标识、应用过程标识、序列标记、包序列计数、包长、服务、子服务。
包头属性的长度：包版本号（3）、包类型（1）、副导头标识（1）、应用过程标识（11）、序列标记（2）、包序列计数（14）、包长（16）、服务（8）、子服务（8）。
            包头属性包括：包版本号、包类型、副导头标识、应用过程标识、序列标记、包序列计数、包长、服务、子服务。
            包头属性的长度：包版本号（3）、包类型（1）、副导头标识（1）、应用过程标识（11）、序列标记（2）、包序列计数（14）、包长（16）、服务（8）、子服务（8）。

表格单元格合并说明：包格中存在单元格合并的情况，如果水平或垂直相邻的单元格内容一样那么这几个内容一样的单元格有可能是一个合并单元格在分析时应该当作合并单元格分析。
#约束
- 代号命名规则：数字、英文字母和下划线组成且以英文字母和下划线开头；
- 如果没有名称用代号代替，如果没有代号用名称的英文翻译代替，翻译尽量简短；
- 如果有代号严格依照文档中的代号，文档中的代号如果不符合代号命名规则将特殊字符转换为下划线，例如：Rsv-1转换为Rsv_1；
- 你需要理解数据包的位置信息，由位置信息得到长度，并且将所有输出单位统一转换为 bits；
- pos字段：数值类型，从0开始计算，由长度（length）累加得到；
- 应用过程标识：如果不是十六进制转换为十六进制，转换完成后要验证是否正确，以0x开头，；
- 包头后面的每一行都对应一个参数，逐行输出参数，不要遗漏任何参数；
- 类似”保留（Rsv）“的行也要当参数生成；
- 重复的行也要生成；
- 注意包内容的范围，不要提取到其他包中的内容，包内容都在同一个表格中；
- 字节顺序：值为大端“B”，小端“L”，默认为“B”；
- 输出严格按照文档中的内容生成，不要创造文档中不存在的内容；
- 仅输出json，不要输出任何其他内容。
#例子
{
  "name": "数管缓变遥测包",
  "id": "PMS003",
  "type": "linear",
  "headers": [
    {
      "name": "包标识",
      "id": "packetIdentifier",
      "pos": 0,
      "content": "000",
      "length": 8,
      "type": "para"
    }
  ],
  "datas": [
    {
      "name": "XXX包",
      "id": "XXX",
      "pos": 0,
      "length": 8,
      "byteOrder": ""
    }
  ]
"""
            print(f'遥测源包“{pkt_name}”信息：')
            表格单元格合并说明：包格中存在单元格合并的情况，如果水平或垂直相邻的单元格内容一样那么这几个内容一样的单元格有可能是一个合并单元格在分析时应该当作合并单元格分析。
            #约束
            - 代号命名规则：数字、英文字母和下划线组成且以英文字母和下划线开头；
            - 如果没有名称用代号代替，如果没有代号用名称的英文翻译代替，翻译尽量简短；
            - 如果有代号严格依照文档中的代号，文档中的代号如果不符合代号命名规则将特殊字符转换为下划线，例如：Rsv-1转换为Rsv_1；
            - 你需要理解数据包的位置信息，由位置信息得到长度，并且将所有输出单位统一转换为 bits；
            - pos字段：数值类型，从0开始计算，由长度（length）累加得到；
            - 应用过程标识：应用过程标识的定义如果不是十六进制转换为十六进制，转换完成后要验证是否正确，以0x开头；
            - 包头后面的每一行都对应一个参数，逐行输出参数，不要遗漏任何参数；
            - 类似”保留（Rsv）“的行也要当参数生成；
            - 重复的行也要生成；
            - 注意包内容的范围，不要提取到其他包中的内容，包内容都在同一个表格中；
            - 字节顺序：值为大端“B”，小端“L”，默认为“B”；
            - 输出严格按照文档中的内容生成，不要创造文档中不存在的内容；
            - 仅输出json，不要输出任何其他内容。
            #例子
            {
            "name": "数管缓变遥测包",
            "id": "PMS003",
            "type": "linear",
            "headers": [
                {
                "name": "包标识",
                "id": "packetIdentifier",
                "pos": 0,
                "content": "000",
                "length": 8,
                "type": "para"
                }
            ],
            "datas": [
                {
                "name": "XXX包",
                "id": "XXX",
                "pos": 0,
                "length": 8,
                "byteOrder": ""
                }
            ]
            """

            def validation(gen_text):
                _pkt = json.loads(gen_text)
                with open(f'out/tmp/{time.time()}.json', 'w') as f:
                    f.write(gen_text)
                assert 'headers' in _pkt, '包结构中必须包含headers字段'
                assert 'datas' in _pkt, '包结构中必须包含datas字段'
                print(f'参数个数：{len(_pkt["datas"])}')
                # assert par_num == len(_pkt['datas']), f'数据域参数个数不对！预计{par_num}个，实际{len(_pkt["datas"])}'
                assert last_par_pos == _pkt['datas'][-1]['pos'], '最后一个参数的字节位置不对！'
        print(f'遥测源包“{pkt_name}”信息：')

            text = self.generate_text_json(_msg, cache_file, [], files, validation)
            pkt = json.loads(text)
        else:
            pkt = json.loads(read_from_file(cache_file))
        def validation(gen_text):
            _pkt = json.loads(gen_text)
            with open(f'out/tmp/{time.time()}.json', 'w') as f:
                f.write(gen_text)
            assert 'headers' in _pkt, '包结构中必须包含headers字段'
            assert 'datas' in _pkt, '包结构中必须包含datas字段'
            # assert par_num == len(_pkt['datas']), f'数据域参数个数不对！预计{par_num}个，实际{len(_pkt["datas"])}'
            # assert last_par_pos == _pkt['datas'][-1]['pos'], '最后一个参数的字节位置不对！'

        doc_text = self.get_text_with_entity([pkt_id])
        if doc_text == '':
            return None
        text = self.generate_text_json(_msg, cache_file, [], doc_text, validation)
        pkt = json.loads(text)
       
        pkt_len = 0
        for par in pkt['datas']:
            par['pos'] = pkt_len
@@ -882,14 +858,12 @@
#指令
我需要从文档中提取遥测包数据，你要根据文档内容帮我完成遥测包数据的提取。
#需求
输出文档中描述的遥测包列表，遥测包字段包括：名称(name)、代号(id)、是否有参数(hasParams)。
输出文档中描述的遥测包列表，遥测包字段包括：名称(name)、代号(id)。
字段描述：
1.名称：遥测包的名称；
2.代号：遥测包的代号；
3.是否有参数：表示当前遥测包是否有参数列表，遥测包的参数表紧接着遥测包章节标题，如果章节标题后面省略了或者类似”详见xxx“则是没有参数表。
#约束
- name：名称中不要包含代号，仅从文档中提取源包名称；
- hasParams：值为布尔值，true或false；
- 如果没有代号，使用遥测包名称的英文翻译代替；
- 如果没有名称用代号代替；
- 不要漏掉任何遥测包；
@@ -899,13 +873,12 @@
    {
        "name": "数管数字量快速源包",
        "id": "PMS001",
        "hasParams": true
    }
]
"""
        print(f'遥测源包列表：')
        files = [file_map['遥测源包设计报告']]
        text = self.generate_text_json(_msg, 'out/源包列表.json', [], files)
        doc_text = self.get_text_with_entity(['源包列表'])
        text = self.generate_text_json(_msg, 'out/源包列表.json', doc_text=doc_text)
        pkt = json.loads(text)
        return pkt

@@ -914,11 +887,10 @@
#角色
你是一名资深软件工程师。
#指令
我需要从文档中提取遥测源包信息，你要帮助我完成遥测源包信息的提取。
我需要从文档中提取所有遥测源包信息，你要帮助我完成遥测源包信息的提取。
#需求
根据”遥测源包下传时机定义“章节的内容输出各个遥测源包信息列表，顶级结构为数组元素为遥测源包，源包字段包括：包代号(id)，名称(name)，所属虚拟信道(vcs)，下传时机（timeTags）。
根据文档内容输出遥测源包信息，顶级结构为数组，元素为遥测源包，源包字段包括：包代号(id)，名称(name)，所属虚拟信道(vcs)，下传时机（timeTags）。
#约束
- 从”遥测源包下传时机定义“章节中提取遥测源包信息；
- 所属虚拟信道：必须是文档中描述的遥测虚拟信道代号（序号）；
- 下传时机：与表格中定义的一致；
- 不要遗漏任何遥测源包。
@@ -932,14 +904,13 @@
  },
]
        """
        files = [file_map['遥测大纲']]
        print('遥测源包所属虚拟信道：')

        def validation(gen_text):
            pkts = json.loads(gen_text)
            assert len(pkts), 'VC源包列表不能为空'

        text = self.generate_text_json(_msg, 'out/遥测VC源包.json', files=files, validation=validation)
        doc_text = self.get_text_with_entity(['虚拟信道定义','遥测源包下传时机'])
        text = self.generate_text_json(_msg, 'out/遥测VC源包.json', doc_text=doc_text, validation=validation)
        pkt_vcs = json.loads(text)
        return pkt_vcs

@@ -1044,7 +1015,10 @@
        def validation(gen_text):
            json.loads(gen_text)

        text = self.generate_text_json(_msg, 'out/总线.json', files=[file_map['总线传输通信帧分配']],
        

        doc_text = self.get_text_with_entity(['RT地址分配','分系统源包'])
        text = self.generate_text_json(_msg, 'out/总线.json', doc_text=doc_text,
                                       validation=validation)
        pkts = json.loads(text)
        # 筛选经总线的数据包
@@ -1053,11 +1027,7 @@
        # 筛选有apid的数据包
        pkts = list(filter(lambda it: it['apid'], pkts))

        pkts2 = []
        for pkt in pkts:
            if self.pkt_in_tm_pkts(pkt["name"]):
                pkts2.append(pkt)
        for pkt in pkts2:
            _pkt = self.gen_pkt_details(pkt['name'], pkt['id'])
            if _pkt:
                pkt['children'] = []
@@ -1291,7 +1261,8 @@
        def validation(gen_text):
            json.loads(gen_text)

        text = self.generate_tc_text(_msg, 'out/tc_transfer_frame.json', files=[file_map['指令格式']],
        doc_text = self.get_text_with_entity(['遥控帧格式'])
        text = self.generate_tc_text(_msg, 'out/tc_transfer_frame.json', doc_text=doc_text,
                                     validation=validation)
        result: dict = json.loads(text)
        format_text = utils.read_from_file('tpl/tc_transfer_frame.json')
@@ -1332,7 +1303,8 @@
        def validation(gen_text):
            json.loads(gen_text)

        text = self.generate_tc_text(_msg, 'out/tc_transfer_pkt.json', files=[file_map['指令格式']],
        doc_text = self.get_text_with_entity(['遥控包格式'])
        text = self.generate_tc_text(_msg, 'out/tc_transfer_pkt.json', doc_text=doc_text,
                                     validation=validation)
        result = json.loads(text)

@@ -1346,7 +1318,10 @@
# 角色
你是一名资深的软件工程师。
# 指令
分析文档列出所有的遥控源包。
分析文档列出所有的遥控指令。
#  约束
- 应用过程标识：应用过程标识就是APID，一般会在名称后的括号中列出来
- code是指令代号，没有就空着
# 输出例子：
[{
"name": "xxx",
@@ -1360,7 +1335,8 @@
        def validation(gen_text):
            json.loads(gen_text)

        text = self.generate_tc_text(_msg, 'out/tc_transfer_pkts.json', files=[file_map['指令格式']],
        doc_text = self.get_text_with_entity(['APID分配'])
        text = self.generate_tc_text(_msg, 'out/tc_transfer_pkts.json', doc_text=doc_text,
                                     validation=validation)
        pkts = json.loads(text)
        return pkts
@@ -1415,8 +1391,11 @@
        def validation(gen_text):
            json.loads(gen_text)

        doc_text = self.get_text_with_entity([tc_name])
        if doc_text == '':
            return None
        text = self.generate_tc_text(_msg, f'out/遥控指令数据域-{tc_code}-{utils.to_file_name(tc_name)}.json',
                                     files=[file_map['指令格式']],
                                     doc_text=doc_text,
                                     validation=validation)
        result = json.loads(text)
        pkt['children'] = result