KnowledgeBase.git

			@@ -6,50 +6,66 @@
			import re
			import json

			from langchain_community.chat_models import ChatOpenAI
			from langchain_core.prompts import HumanMessagePromptTemplate, SystemMessagePromptTemplate

			import data_templates
			from knowledgebase import utils
			from knowledgebase.db.db_helper import create_project, create_device, create_data_stream, \
			update_rule_enc, create_extend_info, create_ref_ds_rule_stream, create_ins_format
			update_rule_enc, create_extend_info, create_ref_ds_rule_stream, create_ins_format, make_attr
			from knowledgebase.db.data_creator import create_prop_enc, create_enc_pkt, get_data_ty, create_any_pkt

			from knowledgebase.db.models import TProject

			file_map = {
			"文档合并": "./doc/文档合并.md",
			"遥测源包设计报告": "./doc/XA-5D无人机分系统探测源包设计报告（公开）.md",
			"遥测大纲": "./doc/XA-5D无人机探测大纲（公开）.md",
			"总线传输通信帧分配": "./doc/XA-5D无人机1314A总线传输通信帧分配（公开）.md",
			"应用软件用户需求": "./doc/XA-5D无人机软件用户需求（公开）.docx.md",
			"指令格式": "./doc/ZL格式(公开).docx.md"
			}
			from knowledgebase.db.doc_db_helper import doc_dbh

			# file_map = {
			# # "遥测源包设计报告": "./doc/HY-4A数管分系统遥测源包设计报告 Z 240824 更改3(内部) .docx.md",
			# # "遥测源包设计报告": "./doc/数管数字量快速源包.md",
			# # "遥测源包设计报告": "./doc/数管数字量中速源包.md",
			# # "遥测源包设计报告": "./doc/硬通道设备工作状态数据包.md",
			# # "遥测源包设计报告": "./doc/DIU遥测模块采集的DS量4.md",
			# "遥测源包设计报告": "./doc/DIU遥测模块模拟量.md",
			# "遥测大纲": "./doc/HY-4A卫星遥测大纲 Z 240824 更改3（内部）.docx.md",
			# # "总线传输通信帧分配": "./doc/HY-4A卫星1553B总线传输通信帧分配 Z 240824 更改3（内部）.docx.md",
			# "总线传输通信帧分配": "./doc/总线.md",
			# "应用软件用户需求": "./doc/HY-4A数管分系统应用软件用户需求（星务管理分册） Z 240831 更改4（内部）.docx.md"
			# }
			# file_map = {
			# "遥测源包设计报告": "./docs/HY-4A数管分系统遥测源包设计报告 Z 240824 更改3(内部) .docx.md",
			# "遥测大纲": "./docs/HY-4A卫星遥测大纲 Z 240824 更改3（内部）.docx.md",
			# "总线传输通信帧分配": "./docs/HY-4A卫星1553B总线传输通信帧分配 Z 240824 更改3（内部）.docx.md",
			# "应用软件用户需求": "./docs/HY-4A数管分系统应用软件用户需求（星务管理分册） Z 240831 更改4（内部）.docx.md"
			# }
			# file_map = {
			# "文档合并": "./doc/文档合并.md",
			# "遥测源包设计报告": "./doc/XA-5D无人机分系统探测源包设计报告（公开）.md",
			# "遥测大纲": "./doc/XA-5D无人机探测大纲（公开）.md",
			# "总线传输通信帧分配": "./doc/XA-5D无人机1314A总线传输通信帧分配（公开）.md"
			# }
			file_map = {
			"文档合并": "./doc/文档合并.md",
			"遥测源包设计报告": "./doc/XA-5D无人机分系统探测源包设计报告（公开）.md",
			"遥测大纲": "./doc/XA-5D无人机探测大纲（公开）.md",
			"总线传输通信帧分配": "./doc/XA-5D无人机1314A总线传输通信帧分配（公开）.md",
			"指令格式": "./doc/ZL格式(公开).docx.md"
			}

			BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1'
			API_KEY = 'sk-15ecf7e273ad4b729c7f7f42b542749e'
			MODEL_NAME = 'qwen2.5-14b-instruct-1m'
			MODEL_NAME = 'qwen2.5-72b-instruct'

			# BASE_URL = 'http://10.74.15.164:11434/v1/'
			# API_KEY = 'ollama'
			# MODEL_NAME = 'qwen2.5:32b-128k'

			# BASE_URL = 'http://10.74.15.164:1001/api'
			# API_KEY = 'sk-a909385bc14d4491a718b6ee264c3227'
			# MODEL_NAME = 'qwen2.5:32b-128k'
			# BASE_URL = 'http://chat.com/api'
			# API_KEY = 'sk-49457e83f734475cb4cf7066c649d563'
			# MODEL_NAME = 'qwen2.5:72b-120k'

			# BASE_URL = 'http://10.74.15.171:8000/v1'
			# API_KEY = 'EMPTY'
			# MODEL_NAME = 'QwQ:32b'
			# MODEL_NAME = 'vllm-Qwen-72b-4bit'

			USE_CACHE = True
			assistant_msg = """
			# 角色
			你是一个专业的文档通信分析师，擅长进行文档分析和通信协议分析，同时能够解析 markdown 类型的文档。拥有成熟准确的文档阅读与分析能力，能够妥善处理多文档间存在引用关系的复杂情况。
			你是一名资深的软件工程师，擅长进行文档分析和通信协议分析，同时能够解析 markdown 类型的文档。拥有成熟准确的文档阅读与分析能力，能够妥善处理多文档间存在引用关系的复杂情况。

			## 技能
			### 技能 1：文档分析（包括 markdown 文档）
			@@ -95,6 +111,14 @@
			- 不输出任何注释等描述性信息。
			"""

			tc_system_msg = """
			# 角色
			你是一个资深软件工程师。
			# 约束
			- 输出内容必须根据文档和问题回答，不要创造其他内容；
			- 输出内容必须是，JSON格式，不要输出其他文本。
			"""

			g_completion = None


			@@ -110,10 +134,16 @@
			f.write(text)


			def remove_think_tag(text):
			pattern = r'<think>(.\|\n)*?</think>'
			result = re.sub(pattern, '', text)
			return result


			json_pat = re.compile(r'```json(.*?)```', re.DOTALL)


			def remove_markdown(text):
			def get_json_text(text):
			# 使用正则表达式提取json文本
			try:
			return json_pat.findall(text)[0]
			@@ -310,6 +340,7 @@
			# api_key="ollama",
			# base_url="http://192.168.1.48:11434/v1/",
			)
			# self.llm = ChatOpenAI(model=MODEL_NAME, temperature=0, api_key=API_KEY, base_url=BASE_URL)

			def run(self):
			# 生成型号结构
			@@ -319,18 +350,26 @@
			# 生成遥测数据包结构
			self.proj = self.gen_project()

			devs = self.gen_device(self.proj)
			# devs = self.gen_device(self.proj)

			# self.gen_tc()
			self.gen_tc()
			return ''

			def _gen(self, msgs, msg, files=None):
			if files is None:
			files = [file_map['文档合并']]
			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, 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})
			@@ -341,10 +380,10 @@
			model=MODEL_NAME,
			messages=messages,
			stream=True,
			temperature=0.0,
			top_p=0,
			temperature=0.6,
			# top_p=0,
			timeout=30 * 60000,
			max_completion_tokens=1000000,
			max_completion_tokens=32000,
			seed=0
			# stream_options={"include_usage": True}
			)
			@@ -358,15 +397,17 @@
			g_completion = None
			return text

			def generate_text(self, msg, cache_file, msgs=None, files=None, validation=None, try_cnt=5):
			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 = remove_markdown(text)
			text = self._gen(msgs, msg, doc_text)
			text = remove_think_tag(text)
			if json_text:
			text = get_json_text(text)
			if validation:
			try:
			validation(text)
			@@ -374,35 +415,30 @@
			print(e)
			if try_cnt <= 0:
			raise RuntimeError('生成失败，重试次数太多，强制结束！')
			return self.generate_text(msg, cache_file, msgs, files, validation, try_cnt - 1)
			save_to_file(text, cache_file)
			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_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(msg, cache_file, messages, files, validation, try_cnt)
			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, msgs=None, doc_text=None, validation=None, try_cnt=5):
			msgs = [
			{'role': 'system', 'content': tc_system_msg},
			{'role': 'user', 'content': "以下是文档内容：\n" + doc_text}]
			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())
			@@ -424,13 +460,41 @@
			proj_pk = proj.C_PROJECT_PK
			devices = []

			_msg = f"""
			输出分系统下的硬件产品（设备）列表，字段包括：名称(name)、代号(code)，硬件产品名称一般会包含“管理单元”或者“接口单元”，如果没有代号则使用名称的英文缩写代替缩写长度不超过5个字符;
			并且给每个硬件产品增加三个字段：第一个字段hasTcTm“是否包含遥控遥测”，判断该硬件产品是否包含遥控遥测的功能、
			第二个字段hasTemperatureAnalog“是否包含温度量、模拟量等数据的采集”，判断该硬件产品是否包含温度量等信息的采集功能、
			第三个字段hasBus“是否是总线硬件产品”，判断该设备是否属于总线硬件产品，是否有RT地址；每个字段的值都使用true或false来表示。
			仅输出JSON，结构最外层为数组，数组元素为设备信息，不要输出JSON以外的任何字符。
			"""
			_msg = """
			# 角色
			你是一名资深软件工程师。
			# 指令
			我需要从文档提取设备列表信息，你要帮助我完成设备列表信息提取。
			# 需求
			输出分系统下的硬件产品（设备）列表，硬件产品名称一般会包含“管理单元”或者“接口单元”；
			# 字段包括：
			- 名称(name)：设备名称；
			- 代号(code)：设备代号；
			- 是否包含遥控遥测(hasTcTm)：标识该硬件产品是否包含遥控遥测的功能，布尔值true或false；
			- 是否包含温度量模拟量等数据的采集(hasTemperatureAnalog)：标识该硬件产品是否包含温度量等信息的采集功能，布尔值true或false；
			- 是否有总线硬件产品(hasBus)：标识该设备是否属于总线硬件产品，是否有RT地址，布尔值true或false；
			# 约束
			- 如果没有代号则使用名称的英文缩写代替缩写长度不超过5个字符；
			- 数据结构最外层为数组，数组元素为设备信息
			- 仅输出JSON，不要输出JSON以外的任何字符。
			# 例子
			[
			{
			"name": "系统管理单元",
			"code": "SMU",
			"hasTcTm": true,
			"hasTemperatureAnalog": false,
			"hasBus": true
			},
			{
			"name": "1553B总线",
			"code": "1553",
			"hasTcTm": true,
			"hasTemperatureAnalog": true,
			"hasBus": true
			}
			]
			"""
			print('设备列表：')
			cache_file = 'out/设备列表.json'

			@@ -439,7 +503,8 @@
			assert isinstance(_devs, list), '数据结构最外层不是数组'
			assert next(filter(lambda it: it['name'].endswith('管理单元'), _devs), None), '生成的设备列表中没有管理单元'

			text = self.generate_text(_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设备，包含遥测和遥控功能，名称结尾为“管理单元”
			@@ -485,20 +550,41 @@

			def gen_insert_domain_params(self):
			_msg = """
			分析文档，输出插入域的参数列表，将所有参数全部输出，不要有遗漏。
			数据结构最外层为数组，数组元素为参数信息对象，参数信息字段包括：name、id、pos、length、type。
			1个字节的长度为8位，使用B0-B7来表示，请认真计算参数长度。
			文档中位置描述信息可能存在跨字节的情况，，例如："Byte1_B6~Byte2_B0":表示从第1个字节的第7位到第2个字节的第1位，长度是3;"Byte27_B7~Byte28_B0":表示从第27个字节的第8位到第28个字节的第1位，长度是2。
			#角色
			你是一名资深的软件工程师。
			#指令
			我需要从文档中提取插入域的参数列表，你要帮助我完成插入域参数列表的提取。
			#需求
			分析文档，输出插入域的参数列表，将所有参数全部输出。
			参数信息字段包括：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;"Byte38~Byte74":表示从第38个字节到第74个字节，中间有37个字节，长度是298。
			#约束
			- 不要遗漏任何参数；
			- 如果有代号严格依照文档中的代号，文档中的代号如果不符合代号命名规则将特殊字符转换为下划线，例如：Rsv-1转换为Rsv_1；
			- 数据结构最外层为数组，数组元素为参数信息对象；
			- 仅输出JSON文本。
			#例子
			[
			{
			"name": "遥测模式字",
			"id": "TMS215",
			"pos": 0,
			"length": 8,
			"type": "para"
			}
			]
			"""
			print('插入域参数列表：')
			files = [file_map['遥测大纲']]

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

			text = self.generate_text(_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):
			@@ -547,29 +633,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'])
			@@ -613,12 +701,28 @@

			def gen_vc(self):
			_msg = """
			请分析文档中的遥测包格式，输出遥测虚拟信道的划分，数据结构最外层为数组，数组元素为虚拟信道信息字典，字典包含以下键值对：
			id: 虚拟信道代号
			name: 虚拟信道名称
			VCID: 虚拟信道VCID（二进制）
			format: 根据虚拟信道类型获取对应的数据包的格式的名称
			#角色
			你是一名资深的软件工程师。
			#指令
			我需要从文档中提取虚拟信道列表，你要帮助我完成虚拟信道列表的提取。
			#需求
			请分析文档中的遥测包格式以及遥测虚拟信道，输出遥测虚拟信道列表。
			字段包括：id（虚拟信道代号）、name（虚拟信道名称）、VCID（虚拟信道VCID，二进制）、format（根据虚拟信道类型获取对应的数据包的格式的名称）
			#上下文
			深入理解文档中描述的关系，例如：文档中描述了常规遥测是常规数据的下传信道，并且还描述了分系统常规遥测参数包就是实时遥测参数包，并且文档中对实时遥测参数包的格式进行了描述，所以常规遥测VC应该输出为：{"id": "1", "name": "常规遥测VC", "VCID": "0", "format": "实时遥测参数包"}
			#约束
			- 数据结构最外层为数组，数组元素为虚拟信道信息；
			- format：必须是数据包格式的名称；
			- 仅输出JSON文本。
			#例子：
			[
			{
			"id": "VC0",
			"name": "空闲信道",
			"VCID": "111111",
			"format": "空闲包"
			}
			]
			"""

			def validation(gen_text):
			@@ -626,56 +730,132 @@
			assert next(filter(lambda it: re.match('^[0-1]+$', it['VCID']), vcs)), '生成的VCID必须是二进制'

			print('虚拟信道：')
			text = self.generate_text(_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

			def gen_dev_pkts(self):
			_msg = f"""
			输出文档中遥测源包类型定义描述的设备以及设备下面的遥测包，数据结构：最外层为数组 > 设备 > 遥测包列表(pkts)，设备字段包括：名称(name)、代号(id)，源包字段包括：名称(name)、代号(id)
			"""
			_msg = """
			#角色
			你是一名资深的软件工程师。
			#指令
			我需要从文档中提取设备以及设备下面的遥测包信息，你要帮助我完成提取。
			#需求
			输出文档中遥测源包类型定义描述的设备以及设备下面的遥测包。
			#约束
			- 数据结构：数组 > 设备 > 遥测包列表(pkts)；
			- 设备字段包括：名称(name)、代号(id)；
			- 源包字段包括：名称(name)、代号(id)；
			- 仅输出JSON文本。
			#例子
			"""
			print('设备遥测源包信息：')
			files = [file_map["遥测源包设计报告"]]
			text = self.generate_text(_msg, 'out/设备数据包.json', [], files)
			text = self.generate_text_json(_msg, 'out/设备数据包.json', [], files)
			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):
			_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；
			如果没有名称用代号代替，如果没有代号用名称的英文翻译代替，翻译尽量简短；
			你需要理解数据包的位置信息，并且将所有输出单位统一转换为 bits，位置字段的输出格式必须为数值类型;
			数据结构仅只包含遥测包，仅输出json，不要输出任何其他内容。"""
			print(f'遥测源包“{pkt_name}”信息：')

			def validation(gen_text):
			_pkt = json.loads(gen_text)
			assert 'headers' in _pkt, '包结构中必须包含headers字段'
			assert 'datas' in _pkt, '包结构中必须包含datas字段'
			# _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(_msg, cache_file, [], files, validation)
			pkt = json.loads(text)
			else:
			pkt = json.loads(read_from_file(cache_file))
			# 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}”遥测包。
			""" + """
			遥测包字段包括：名称(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）。

			表格单元格合并说明：包格中存在单元格合并的情况，如果水平或垂直相邻的单元格内容一样那么这几个内容一样的单元格有可能是一个合并单元格在分析时应该当作合并单元格分析。
			#约束
			- 代号命名规则：数字、英文字母和下划线组成且以英文字母和下划线开头；
			- 如果没有名称用代号代替，如果没有代号用名称的英文翻译代替，翻译尽量简短；
			- 如果有代号严格依照文档中的代号，文档中的代号如果不符合代号命名规则将特殊字符转换为下划线，例如：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}”信息：')

			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
			@@ -684,44 +864,110 @@
			return pkt

			def gen_pkts(self):
			_msg = f"""
			输出文档中描述的遥测包。
			遥测包字段包括：名称(name)、代号(id)、hasParams，
			名称中不要包含代号，
			hasParams表示当前遥测包是否有参数列表，遥测包的参数表紧接着遥测包章节标题，如果章节标题后面省略了或者详见xxx则是没有参数表，
			如果没有代号用名称的英文翻译代替，如果没有名称用代号代替，
			数据结构最外层为数组数组元素为遥测包，不包括遥测包下面的参数。
			_msg = """
			#角色
			你是一名资深软件工程师。
			#指令
			我需要从文档中提取遥测包数据，你要根据文档内容帮我完成遥测包数据的提取。
			#需求
			输出文档中描述的遥测包列表，遥测包字段包括：名称(name)、代号(id)。
			字段描述：
			1.名称：遥测包的名称；
			2.代号：遥测包的代号；
			#约束
			- name：名称中不要包含代号，仅从文档中提取源包名称；
			- 如果没有代号，使用遥测包名称的英文翻译代替；
			- 如果没有名称用代号代替；
			- 不要漏掉任何遥测包；
			- 数据结构最外层为数组数组元素为遥测包，不包括遥测包下面的参数。
			#例子
			[
			{
			"name": "数管数字量快速源包",
			"id": "PMS001",
			}
			]
			"""
			print(f'遥测源包列表：')
			files = [file_map['遥测源包设计报告']]
			text = self.generate_text(_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

			def gen_pkt_vc(self):
			_msg = f"""
			根据遥测源包下传时机定义，输出各个遥测源包信息列表，顶级结构为数组元素为遥测源包，源包字段包括：包代号(id)，名称(name)，所属虚拟信道(vcs)，下传时机（timeTags）
			_msg = """
			#角色
			你是一名资深软件工程师。
			#指令
			我需要从文档中提取所有遥测源包信息，你要帮助我完成遥测源包信息的提取。
			#需求
			根据文档内容输出遥测源包信息，顶级结构为数组，元素为遥测源包，源包字段包括：包代号(id)，名称(name)，所属虚拟信道(vcs)，下传时机（timeTags）。
			#约束
			- 所属虚拟信道：必须是文档中描述的遥测虚拟信道代号（序号）；
			- 下传时机：与表格中定义的一致；
			- 不要遗漏任何遥测源包。
			#例子：
			[
			{
			"id": "PMS001",
			"name": "数管数字量快速源包",
			"vcs": ["VC1"],
			"timeTags": ["实时"]
			},
			]
			"""
			files = [file_map['遥测大纲']]
			print('遥测源包所属虚拟信道：')

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

			text = self.generate_text(_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

			def gen_pkt_format(self):
			_msg = f"""
			请仔细分系文档，输出各个数据包的格式，数据结构最外层为数组，数组元素为数据包格式，将主导头的子级提升到主导头这一级并且去除主导头，数据包type为logic，包数据域type为any。
			包格式children包括：版本号(id:Ver)、类型(id:TM_Type)、副导头标志(id:Vice_Head)、应用过程标识符(id:Proc_Sign)、分组标志(id:Group_Sign)、包序列计数(id:Package_Count)、包长(id:Pack_Len)、数据域(id:EPDU_DATA)。
			children元素的字段包括：name、id、pos、length、type
			注意：生成的JSON语法格式要合法。
			_msg = """
			#角色
			你是一名资深软件工程师。
			#指令
			我需要从文档中提取数据包的格式，你要帮助我完成数据包格式的提取。
			#需求
			请仔细分系文档，输出各个数据包的格式。
			数据结构最外层为数组，数组元素为数据包格式，将主导头的子级提升到主导头这一级并且去除主导头，数据包type为logic，包数据域type为any。
			包格式字段包括：名称(name)、代号(id)、类型(type)、子级(children)。
			children元素的字段包括：name、id、pos、length、type。
			children元素包括：版本号(Ver)、类型(TM_Type)、副导头标志(Vice_Head)、应用过程标识符(Proc_Sign)、分组标志(Group_Sign)、包序列计数(Package_Count)、包长(Pack_Len)、数据域(EPDU_DATA)。
			#约束
			- 生成的JSON语法格式要合法。
			#例子
			{
			"name": "实时遥测参数包",
			"id": "EPDU",
			"type": "logic",
			"children": [
			{
			"name": "版本号",
			"id": "Ver",
			"pos": 0,
			"length": 3,
			"type": "para",
			"content": "0",
			"dataTy": "INVAR"
			},
			{
			"name": "数据域",
			"id": "EPDU_DATA",
			"pos": 3,
			"length": "变长",
			"type": "any"
			}
			]
			}
			"""
			print('遥测包格式：')
			text = self.generate_text(_msg, 'out/数据包格式.json', files=[file_map['遥测大纲']])
			text = self.generate_text_json(_msg, 'out/数据包格式.json', files=[file_map['遥测大纲']])
			pkt_formats = json.loads(text)
			return pkt_formats

			@@ -738,24 +984,53 @@
			# node['length'] = length

			def gen_bus(self, proj_pk, rule_enc, rule_id, ds, name_path, dev_name):
			_msg = f"""
			_msg = """
			#角色
			你是一名资深的软件工程师
			#指令
			我需要从文档中提取经总线的数据包列表，你要帮助我完成经总线的数据包列表的提取。
			#需求
			请析文档，列出总线通信包传输约定中描述的所有数据包列表，
			数据包字段包括：id、name、apid(16进制字符串)、service(服务子服务)、length(bit长度)、interval(传输周期)、subAddr(子地址/模式)、frameNum(通信帧号)、
			transSer(传输服务)、note(备注)、rtAddr(所属RT的地址十进制)、rt(所属rt名称)、throughBus(是否经过总线)、burst(是否突发)、transDirect(传输方向)，
			数据结构最外层是数组，数组元素为数据包，以JSON格式输出，不要输出JSON以外的任何文本。
			通信帧号：使用文档中的文本不要做任何转换。
			subAddr：值为“深度”、“平铺”、“数字”或null。
			是否经过总线的判断依据：“备注”列填写了内容类似“不经过总线”的文字表示不经过总线否则经过总线。
			传输服务分三种：SetData(置数)、GetData(取数)、DataBlock(数据块传输)。
			传输方向分：”收“和”发“，传输服务如果是”取数“是”收“，如果是”数据块传输“则根据包所在的分系统以及表格的”传输方向“列进行判断，判断对于SMU来说是收还是发。
			是否突发的判断依据：根据表格中的”传输周期“列进行判断，如果填写了类似”突发“的文字表示是突发否则表示不是突发。
			数据包字段包括：id(数据包代号)、name(数据包名称)、apid(16进制字符串)、service(服务子服务)、length(bit长度)、interval(传输周期)、subAddr(子地址/模式)、frameNum(通信帧号)、
			transSer(传输服务)、note(备注)、rtAddr(所属RT的地址十进制)、rt(所属rt名称)、throughBus(是否经过总线)、burst(是否突发)、transDirect(传输方向)。
			#约束
			- frameNum：使用文档中的文本不要做任何转换；
			- subAddr：值为“深度”、“平铺”、“数字”或null；
			- 是否经过总线的判断依据：“备注”列填写了内容类似“不经过总线”的文字表示不经过总线否则经过总线；
			- 传输服务分三种：SetData(置数)、GetData(取数)、DataBlock(数据块传输)；
			- 传输方向分”收“和”发“，传输服务如果是”取数“是”收“，如果是”数据块传输“则根据包所在的分系统以及表格的”传输方向“列进行判断，判断对于SMU来说是收还是发；
			- 是否突发：根据表格中的”传输周期“列进行判断，如果填写了类似”突发“的文字表示是突发否则表示不是突发；
			- 不要漏掉任何一个数据包；
			- 数据结构最外层是数组，数组元素为数据包，以JSON格式输出，不要输出JSON以外的任何文本。
			#例子
			[
			{
			"id": "PCS005",
			"name": "总线管理（内部指令）",
			"apid": "418",
			"service": "(1, 2)",
			"length": 1,
			"interval": 1000,
			"subAddr": null,
			"frameNum": "1\|2",
			"transSer": "DataBlock",
			"note": "",
			"rtAddr": 28,
			"rt": "数据接口单元XIU",
			"throughBus": true,
			"burst": true,
			"transDirect": "发"
			}
			]
			"""
			print('总线数据包：')

			def validation(gen_text):
			json.loads(gen_text)

			text = self.generate_text(_msg, 'out/总线.json', files=[file_map['总线传输通信帧分配']], validation=validation)
			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)
			# 筛选经总线的数据包
			pkts = list(filter(lambda it: it['throughBus'], pkts))
			@@ -763,11 +1038,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'] = []
			@@ -854,251 +1125,355 @@

			def gen_tc(self):
			# 数据帧格式
			frame = self.gen_tc_transfer_frame()
			# 数据包格式
			pkt_format = self.gen_tc_transfer_pkt()
			# 数据包列表
			pkts = self.gen_tc_transfer_pkts()
			for pkt in pkts:
			pf = json.loads(json.dumps(pkt_format))
			pf['name'] = pkt['name']
			ph = next(filter(lambda x: x['name'] == '主导头', pf['children']), None)
			apid = next(filter(lambda x: x['name'] == '应用进程标识符(APID)', ph['children']), None)
			apid['value'] = pkt['apid']
			apid['type'] = 'const'
			sh = next(filter(lambda x: x['name'] == '副导头', pf['children']), None)
			ser = next(filter(lambda x: x['name'] == '服务类型', sh['children']), None)
			sub_ser = next(filter(lambda x: x['name'] == '服务子类型', sh['children']), None)
			ser['value'] = pkt['server']
			ser['type'] = 'const'
			sub_ser['value'] = pkt['subServer']
			sub_ser['type'] = 'const'
			frame = self.gen_tc_transfer_frame_format()
			# 遥控包格式
			pkt_format = self.gen_tc_pkt_format()
			# 遥控包列表
			instructions = self.gen_tc_transfer_pkts()
			for inst in instructions:
			# 遥控指令数据区内容
			self.gen_tc_pkt_details(inst)
			inst['type'] = 'insUnit'
			format_text = json.dumps(pkt_format, ensure_ascii=False)
			format_text = utils.replace_tpl_paras(format_text, inst)
			pf = json.loads(format_text)
			pf['name'] = inst['name']
			pf['code'] = inst['code']
			data_area = next(filter(lambda x: x['name'] == '应用数据区', pf['children']))
			data_area['children'].append(inst)
			frame['subPkts'].append(pf)
			self.order = 0

			def build_def(item: dict):
			if item['type'] == 'enum':
			return json.dumps({"EnumItems": item['enums'], "CanInput": True})
			if item['type'] in ['enum', 'sendFlag']:
			if isinstance(item['enums'], str):
			enums = json.loads(item['enums'])
			else:
			enums = item['enums']
			return json.dumps({"EnumItems": enums, "CanInput": True}, ensure_ascii=False)
			elif item['type'] == 'length':
			return None
			elif item['type'] == 'checkSum':
			return json.dumps({"ChecksumType": "CRC-CCITT"})
			return json.dumps({"ChecksumType": item['value']['type']})
			elif item['type'] == 'subPkt':
			return json.dumps({"CanInput": False})
			elif item['type'] == 'combPkt':
			elif item['type'] in ['combPkt', 'insUnitList', 'input']:
			return None
			elif item['type'] == 'insUnit':
			return '{"MinLength":null,"MaxLength":null,"IsSubPackage":false,"InputParams":[],"OutPutParams":[],"MatchItems":[]}'
			elif item['type'] == 'pkt':
			return '''{"MaxLength":1024,"IsSplit8":false,"Split8Start":null,"Split8End":null,"PadCode":null,"Alignment":null,"InputParams":[],"OutPutParams":[],"MatchItems":[]}'''
			elif item['type'] == 'pktSeqCnt':
			return json.dumps({"FirstPackValue":"PackCount","MiddlePackValue":"PackIndex","LastPackValue":"PackIndex","IndependPackValue":"InsUnitCount"})
			elif 'value' in item:
			return item['value']

			def create_tc_format(parent_pk, field):
			def create_tc_format(parent_pk, field, parent_parent_pk=None):
			"""
			创建遥控格式

			数据库数据结构：
			帧字段 parent_pk=null, pk=pk_001, type=1
			匿名字段(子包) parent_pk=pk_001, pk=pk_002, type=22
			字段1 parent_pk=pk_002, pk=pk_003, type=15
			字段2 parent_pk=pk_002, pk=pk_004, type=15
			包字段 parent_pk=pk_001, pk=pk_005, type=1
			匿名字段(子包) parent_pk=pk_005, pk=pk_006, type=22
			字段3 parent_pk=pk_006, pk=pk_007, type=15
			指令单元 parent_pk=pk_005, pk=pk_007, type=4
			字段4 parent_pk=pk_007, pk=pk_008, type=15

			:param parent_pk: 父级pk
			:param field: 格式字段
			:param parent_parent_pk: 父级的父级pk
			:return:
			"""
			field['order'] = self.order
			self.order += 1
			field['def'] = build_def(field)
			if 'length' in field:
			field['bitWidth'] = field['length']
			field['bitOrder'] = None
			field['attr'] = 0
			if field['type'] == 'length':
			field['attr'] = make_attr(field)
			if field['type'] == 'length' and 'value' in field and field['value']:
			val = field['value']
			field['range'] = val['start'] + "~" + val['end']
			field['formula'] = val['formula']
			# 即时输入长度为null则是变长字段，需要把类型改为variableLength
			if field['type'] == 'input' and field['length'] is None:
			field['type'] = 'variableLength'
			# 枚举值默认值设置
			if field['type'] == 'enum' and len(field['enums']) and not next(filter(lambda x: 'default' in x and x['default'], field['enums']), None):
			field['enums'][0]['default'] = True
			# 校验和
			if field['type'] == 'checkSum':
			field['range'] = f'{field["value"]["start"]}~{field["value"]["end"]}'
			ins_format = create_ins_format(self.proj.C_PROJECT_PK, parent_pk, field)
			ins_format_pk = ins_format.C_INS_FORMAT_PK
			if 'children' in field:
			autocode = 1
			if field['type'] == 'pkt':
			ins_format = create_ins_format(self.proj.C_PROJECT_PK, ins_format.C_INS_FORMAT_PK,
			{'order': self.order, 'type': 'subPkt',
			'def': json.dumps({"CanInput": False})})
			info = {
			'order': self.order,
			'type': 'subPkt',
			'def': json.dumps({"CanInput": False})
			}
			ins_format = create_ins_format(self.proj.C_PROJECT_PK, ins_format_pk, info)
			self.order += 1
			for child in field['children']:
			child['autocode'] = autocode
			autocode += 1
			create_tc_format(ins_format.C_INS_FORMAT_PK, child)
			# if 'subPkts' in field:
			# for pkt in field['subPkts']:
			# ins_format = create_ins_format(self.proj.C_PROJECT_PK, ins_format.C_INS_FORMAT_PK,
			# {'order': self.order, 'type': 'subPkt',
			# 'def': json.dumps({"CanInput": False})})
			# create_tc_format(ins_format.C_INS_FORMAT_PK, pkt)
			if field['type'] == 'insUnitList':
			_parent_pk = parent_parent_pk
			else:
			_parent_pk = ins_format.C_INS_FORMAT_PK
			create_tc_format(_parent_pk, child, ins_format_pk)
			if 'subPkts' in field:
			for _pkt in field['subPkts']:
			create_tc_format(ins_format_pk, _pkt, parent_pk)

			create_tc_format(None, frame)

			def gen_tc_transfer_frame(self):
			def gen_tc_transfer_frame_format(self):
			_msg = '''
			分析YK传送帧格式，提取YK传送帧的数据结构，不包括数据包的数据结构。
			## 经验：
			字段类型包括：
			1.组合包：combPkt，
			2.固定码字：const，
			3.长度：length，
			4.枚举值：enum，
			5.校验和：checkSum，
			6.数据区：subPkt。

			根据字段描述分析字段的类型，分析方法：
			1.字段描述中明确指定了字段值的，类型为const，
			2.字段中没有明确指定字段值，但是罗列了取值范围的，类型为enum，
			3.字段描述中如果存在多层级描述则父级字段的类型为combPkt，
			4.字段如果是和“长度”有关，类型为length，
			5.如果和数据域有关，类型为subPkt，
			6.字段如果和校验和有关，类型为checkSum。

			字段值提取方法：
			1.字段描述中明确指定了字段值，
			2.长度字段的值要根据描述确定起止字段范围以及计算公式，value格式例如：{"start":"<code>","end":"<code>","formula":"N-1"}，注意：start和end的值为字段code。

			## 限制：
			- length 自动转换为bit长度。
			- value 根据字段描述提取。
			- enums 有些字段是枚举值，根据字段描述提取，枚举元素的数据结构为{"n":"","v":"","c":""}。
			- 输出内容必须为严格的json，不能输出除json以外的任何内容。

			字段数据结构：
			主导头
			版本号、通过标志、控制命令标志、空闲位、HTQ标识、虚拟信道标识、帧长、帧序列号
			传送帧数据域
			帧差错控制域。

			# 输出内容例子：
			# 角色
			你是一名资深的软件工程师。
			# 指令
			分析遥控传送帧格式，提取遥控传送帧格式的字段定义。
			# 需求
			要提取值的帧格式字段：
			- 版本号：const，二进制，以B结尾；
			- 通过标志：const，二进制，以B结尾；
			- 控制命令标志：const，二进制，以B结尾；
			- 空闲位：const，二进制，以B结尾；
			- 航天器标识：const，十六进制，以0x开头，如果是二进制或十进制需要转换为十六进制；
			- 虚拟信道标识：sendFlag，发送标记，默认为“任务注入帧”，所有的值都要列举出来；
			# 数据类型
			- const：固定码字，数值，二进制以B结尾，十进制，十六进制以0x开头；
			- sendFlag：发送标记，类似枚举，定义样例：[{"n":"name","v":"value","c":"code","default":true}]，n表示名称，v表示值，c表示code（没有空着），default表示是默认值；
			- checkSum：校验和，如果是校验和类型还需要分析校验和的算法，并保存在value中，校验和算法包括：字节异或（ByteXOR）、累加和取反（SumNot）、累加和（AddSum）、应用循环冗余（CRC-CCITT）、CRC8（CRC8）、ISO和校验（ISOSum）、奇校验（Odd）、偶校验（Even）、其他（Other）
			# 约束
			- 以JSON格式输出；
			- 仅输出JSON文本，不要输出任何其他文本。
			# 输出例子：
			{
			"name": "YK帧",
			"type": "pkt"
			"children":[
			{
			"name": "主导头",
			"code": "primaryHeader",
			"length": 2,
			"value": "00",
			"type": "combPkt",
			"children": [
			{
			"name": "版本号",
			"code": "verNum"
			"length": 1,
			"value": "00"
			}
			]
			}
			],
			"subPkts":[]
			"版本号": "00B",
			"通过标志": "0",
			...
			}
			'''

			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)
			frame = json.loads(text)
			result: dict = json.loads(text)
			format_text = utils.read_from_file('tpl/tc_transfer_frame.json')
			format_text = utils.replace_tpl_paras(format_text, result)
			frame = json.loads(format_text)
			return frame

			def gen_tc_transfer_pkt(self):
			def gen_tc_pkt_format(self):
			_msg = '''
			仅分析YK包格式，提取YK包数据结构。
			## 经验：

			字段类型包括：
			1.组合包：combPkt，
			2.固定码字：const，
			3.长度：length，
			4.枚举值：enum，
			5.校验和：checkSum，
			6.数据区：subPkt。

			根据字段描述分析字段的类型，分析方法：
			1.字段描述中明确指定了字段值的，类型为const，
			2.字段中没有明确指定字段值，但是罗列了取值范围的，类型为enum，
			3.字段描述中如果存在多层级描述则父级字段的类型为combPkt，
			4.字段如果是和“长度”有关，类型为length，
			5.如果和数据域有关，类型为subPkt，
			6.字段如果和校验和有关，类型为checkSum。

			字段值提取方法：
			1.字段描述中明确指定了字段值，
			2.长度字段的值要根据描述确定起止字段范围以及计算公式，value格式例如：{"start":"<code>","end":"<code>","formula":"N-1"}，注意：start和end的值为字段code。

			## 限制：
			- length 自动转换为bit长度。
			- value 根据字段描述提取。
			- enums 有些字段是枚举值，根据字段描述提取，枚举元素的数据结构为{"n":"","v":"","c":""}。
			- 输出内容必须为严格的json，不能输出除json以外的任何内容。

			字段数据结构：
			主导头
			包识别
			包版本号、包类型、数据区头标志、应用进程标识符(APID)
			包序列控制
			序列标志
			包序列计数
			包长
			副导头
			CCSDS副导头标志
			YK包版本号
			命令正确应答（Ack）
			服务类型
			服务子类型
			源地址
			应用数据区
			帧差错控制域。

			# 输出内容例子：
			# 角色
			你是一名资深的软件工程师。
			# 指令
			分析遥控包格式，提取遥控包格式的字段定义。
			# 需求
			要提取值的包格式字段：
			- 包版本号: const，二进制；
			- 包类型: const，二进制；
			- 数据区头标志: const，二进制；
			- 序列标志: const，二进制；
			- 包长：length，
			- 副导头标志: const，二进制；
			- 遥控包版本号: const，二进制；
			- 命令正确应答: const，二进制；
			- 源地址: const，十六进制。
			# 数据类型
			- 固定码字：const，数值，二进制以B结尾，十进制，十六进制以0x开头；
			- 长度：length，如果字段描述内容为数据区域的长度则表示是长度，长度的value为数值、null或范围定义，
			- 枚举值：enum，
			- 校验和：checkSum，如果是校验和类型还需要分析校验和的算法，并保存在value中，校验和算法包括：字节异或（ByteXOR）、累加和取反（SumNot）、累加和（AddSum）、应用循环冗余（CRC-CCITT）、CRC8（CRC8）、ISO和校验（ISOSum）、奇校验（Odd）、偶校验（Even）、其他（Other）
			- 即时输入：input。
			# 长度类型的范围定义描述
			{"start": "起始字段code", "end": "结束字段code", "formula": "计算公式"}
			- start：起始字段code，长度包括起始字段，字段描述中说明了起始字段，
			- end：结束字段code，长度包括结束字段，字段描述中说明了结束字段，
			- formula：计算公式，如果没有计算相关描述则表示不需要计算公式。
			计算公式定义：
			- BYTES：按字节计算；
			- N-x：总字节数减x，例如总字节数减1的公式为N-1。
			# 约束
			- 以JSON格式输出；
			- 仅输出JSON文本，不要输出任何其他文本。
			# 输出例子：
			{
			"name": "YK包",
			"type": "pkt"
			"children":[
			{
			"name": "主导头",
			"code": "primaryHeader",
			"length": 2,
			"value": "00",
			"type": "combPkt",
			"children": [
			{
			"name": "版本号",
			"code": "verNum"
			"length": 1,
			"value": "00"
			}
			]
			}
			],
			"subPkts":[]
			"包版本号": "00B",
			"包类型": "1B",
			...
			}
			'''

			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)
			pkt_format = json.loads(text)
			result = json.loads(text)

			format_text = utils.read_from_file('tpl/tc_pkt_format.json')
			format_text = utils.replace_tpl_paras(format_text, result)
			pkt_format = json.loads(format_text)
			return pkt_format

			def gen_tc_transfer_pkts(self):
			_msg = '''
			分析文档列出所有的遥控源包。
			## 数据结构如下：
			# 角色
			你是一名资深的软件工程师。
			# 指令
			分析文档列出所有的遥控指令。
			# 约束
			- 应用过程标识：应用过程标识就是APID，一般会在名称后的括号中列出来；
			- code：指令代号，没有就空着；
			- name：指令名称，根据表格内容提取，注意名称需要提取完整，如果有多列则合并用-分割；
			- 应用数据区：提取表格中的应用数据区内容。
			# 输出例子：
			[{
			"name": "xxx",
			"code":"pkt",
			"apid":"0xAA",
			"server":"0x1",
			"subServer":"0x2"
			"应用过程标识符":"0xAA",
			"服务类型":"0x1",
			"服务子类型":"0x2",
			"应用数据区": ""
			}]
			'''

			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

			def gen_tc_pkt_details(self, pkt):
			result = []
			tc_name = pkt['name']
			tc_code = pkt['code']
			pkt['name'] = f'{tc_code} {tc_name}'
			_msg = f"""
			# 角色
			你是一个资深软件工程师。

			# 指令
			分析文档，从文档中提取遥控指令名称为“{tc_name}”代号为“{tc_code}”的指令应用数据区定义。

			有些文档内容非常简单仅仅包含特定字节的内容描述，如果是这种文档，则每个特定字节的内容描述定义为一个字段，字段类型根据字节内容确定。
			""" + """

			# 字段类型
			- 固定码字：const，数值，二进制以B结尾，十进制，十六进制以0x开头；
			- 长度：length，如果字段描述内容为数据区域的长度则表示是长度，长度的value为数值、null或范围定义，
			- 枚举值：enum，
			- 校验和：checkSum，如果是校验和类型还需要分析校验和的算法是什么，并保存在value中，
			- 即时输入：input，如果是即时输入value的值为空字符串。

			# 长度类型的范围定义描述
			{"start": "起始字段code", "end": "结束字段code", "formula": "计算公式"}
			- start：起始字段code，长度包括起始字段，字段描述中说明了起始字段，
			- end：结束字段code，长度包括结束字段，字段描述中说明了结束字段，
			- formula：计算公式，如果没有长度特殊计算相关描述则使用BYTES。
			计算公式定义：
			- BYTES：按字节计算，字节数；
			- N-x：总字节数减x，例如总字节数减1的公式为N-1。

			# 字段类型分析方法
			- 根据字段描述分析字段的类型；
			- 字段描述中明确指定了字段值的，类型为const；
			- 字段描述中没有明确指定字段值，但是罗列了取值范围的，类型为enum；
			- 字段描述中如果没有明确指定字段值也没有罗列取值范围的，类型为input；
			- 字段如果是和“长度”有关，类型为length；
			- 如果和数据域有关，类型为const；
			- 字段如果和校验和有关，类型为checkSum，分析校验和的算法，并保存在value中，校验和算法包括：字节异或（ByteXOR）、累加和取反（SumNot）、累加和（AddSum）、应用循环冗余（CRC-CCITT）、CRC8（CRC8）、ISO和校验（ISOSum）、奇校验（Odd）、偶校验（Even）、其他（Other）。

			# 约束
			- code 如果没有明确定义则使用名称的英文翻译，尽量简短；
			- length 自动转换为bit长度，必须是数值、null或范围定义，不能为0；
			- value 根据字段描述提取字段值，字段值一般为数值类型，需要根据字段类型来分析，如果是length类型value的值为范围定义；
			- enums 枚举类型的字段必须要有enums，根据字段描述提取，枚举元素的数据结构为{"n":"","v":"","c":""}；
			- length类型字段的范围定义中的start和end必须是生成结果中的字段code，长度包括start和end，必须使用长度描述中的字段；
			- 输出数据结构为数组，数组元素为字段信息；
			- 输出内容必须为严格的json，不能输出除json以外的任何内容。

			# 输出例子：
			[
			{
			"name": "para1",
			"code": "para1",
			"length": 8,
			"type": "const",
			"value": "0xAA"
			},
			{
			"name": "para2",
			"code": "para2",
			"length": 8,
			"type": "length",
			"value": {"start": "data", "end": "data", "formula": "BYTES"}
			},
			{
			"name": "数据",
			"code": "data",
			"length": null,
			"type": "input",
			"value": ""
			}
			]
			"""

			def validation(gen_text):
			fields = json.loads(gen_text)
			for field in fields:
			if field['type'] == 'length':
			if field['value'] is None:
			raise Exception('length类型的value不能为空')
			if 'start' not in field['value'] or 'end' not in field['value']:
			raise Exception('length类型的value必须包含start和end')
			if field['value']['start'] not in [f['code'] for f in fields]:
			raise Exception('length类型的value的start字段必须在fields中')
			if field['value']['end'] not in [f['code'] for f in fields]:
			raise Exception('length类型的value的end字段必须在fields中')
			elif field['type'] == 'enum':
			if 'enums' not in field:
			raise Exception('enum类型的field必须包含enums')
			if len(field['enums']) == 0:
			raise Exception('enum类型的field的enums不能为空')
			for enum in field['enums']:
			if 'n' not in enum or 'v' not in enum:
			raise Exception('enum类型的field的enums的元素必须包含n、v、c')
			if enum['n'] == '' or enum['v'] == '':
			raise Exception('enum类型的field的enums的元素不能为空')

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


			if __name__ == '__main__':
			try:
			os.makedirs("./out/pkts", exist_ok=True)
			os.makedirs("./out/tmp", exist_ok=True)
			# 启动大模型处理流程
			ret_text = DbStructFlow().run()
			except KeyboardInterrupt: