knowledge/agent/cdss/libs/cdss_helper.py

import copy
from hmac import new
import os
import sys
import logging
import json
import time

from service.kg_edge_service import KGEdgeService
from db.session import get_db
from service.kg_node_service import KGNodeService
from service.kg_prop_service import KGPropService
from cachetools import TTLCache
from cachetools.keys import hashkey

current_path = os.getcwd()
sys.path.append(current_path)

from community.graph_helper import GraphHelper
from typing import List
from agent.cdss.models.schemas import CDSSInput
from config.site import SiteConfig
import networkx as nx
import pandas as pd

logger = logging.getLogger(__name__)

current_path = os.getcwd()
sys.path.append(current_path)

# 图谱数据缓存路径（由dump_graph_data.py生成）
CACHED_DATA_PATH = os.path.join(current_path, 'community', 'web', 'cached_data')


class CDSSHelper(GraphHelper):

    def node_search(self, node_id=None, node_type=None, filters=None, limit=1, min_degree=None):

        kg_node_service = KGNodeService(next(get_db()))
        es_result = kg_node_service.search_title_index("graph_entity_index", node_id, limit)
        results = []
        for item in es_result:
            n = self.graph.nodes.get(item["id"])
            score = item["score"]
            if n:
                results.append({
                    'id': item["title"],
                    'score': score,
                    "name": item["title"],
                })
        return results

    def _load_entity_data(self):
        config = SiteConfig()
        # CACHED_DATA_PATH = config.get_config("CACHED_DATA_PATH")
        print("load entity data")
        # 这里设置了读取的属性
        data = {"id": [], "name": [], "type": [],"is_symptom": [], "sex": [], "age": [],"score": []}
        if not os.path.exists(os.path.join(CACHED_DATA_PATH, 'entities_med.json')):
            return []
        with open(os.path.join(CACHED_DATA_PATH, 'entities_med.json'), "r", encoding="utf-8") as f:
            entities = json.load(f)
            for item in entities:
                #如果id已经存在，则跳过
                # if item[0] in data["id"]:
                #     print(f"skip {item[0]}")
                #     continue
                data["id"].append(int(item[0]))
                data["name"].append(item[1]["name"])
                data["type"].append(item[1]["type"])
                self._append_entity_attribute(data, item, "sex")
                self._append_entity_attribute(data, item, "age")
                self._append_entity_attribute(data, item, "is_symptom")
                self._append_entity_attribute(data, item, "score")
                # item[1]["id"] = item[0]
                # item[1]["name"] = item[0]
                # attrs = item[1]
                # self.graph.add_node(item[0], **attrs)
        self.entity_data = pd.DataFrame(data)
        self.entity_data.set_index("id", inplace=True)
        print("load entity data finished")

    def _append_entity_attribute(self, data, item, attr_name):
        if attr_name in item[1]:
            value = item[1][attr_name].split(":")
            if len(value) < 2:
                data[attr_name].append(value[0])
            else:
                data[attr_name].append(value[1])
        else:
            data[attr_name].append("")

    def _load_relation_data(self):
        config = SiteConfig()
        # CACHED_DATA_PATH = config.get_config("CACHED_DATA_PATH")
        print("load relationship data")

        for i in range(47):
            if not os.path.exists(os.path.join(CACHED_DATA_PATH, f"relationship_med_{i}.json")):
                continue
            if os.path.exists(os.path.join(CACHED_DATA_PATH, f"relationship_med_{i}.json")):
                print(f"load entity data {CACHED_DATA_PATH}\\relationship_med_{i}.json")
                with open(os.path.join(CACHED_DATA_PATH, f"relationship_med_{i}.json"), "r", encoding="utf-8") as f:
                    data = {"src": [], "dest": [], "type": [], "weight": []}
                    relations = json.load(f)
                    for item in relations:
                        data["src"].append(int(item[0]))
                        data["dest"].append(int(item[2]))
                        data["type"].append(item[4]["type"])
                        if "order" in item[4]:
                            order = item[4]["order"].split(":")
                            if len(order) < 2:
                                data["weight"].append(order[0])
                            else:
                                data["weight"].append(order[1])
                        else:
                            data["weight"].append(1)

                    self.relation_data = pd.concat([self.relation_data, pd.DataFrame(data)], ignore_index=True)

    def build_graph(self):
        self.entity_data = pd.DataFrame(
            {"id": [], "name": [], "type": [], "sex": [], "allowed_age_range": []})
        self.relation_data = pd.DataFrame({"src": [], "dest": [], "type": [], "weight": []})
        self._load_entity_data()
        self._load_relation_data()
        self._load_local_data()

        self.graph = nx.from_pandas_edgelist(self.relation_data, "src", "dest", edge_attr=True,
                                             create_using=nx.DiGraph())

        nx.set_node_attributes(self.graph, self.entity_data.to_dict(orient="index"))
        # print(self.graph.in_edges('1257357',data=True))

    def _load_local_data(self):
        # 这里加载update数据和权重数据
        config = SiteConfig()
        self.update_data_path = config.get_config('UPDATE_DATA_PATH')
        self.factor_data_path = config.get_config('FACTOR_DATA_PATH')
        print(f"load update data from {self.update_data_path}")
        for root, dirs, files in os.walk(self.update_data_path):
            for file in files:
                file_path = os.path.join(root, file)
                if file_path.endswith(".json") and file.startswith("ent"):
                    self._load_update_entity_json(file_path)
                if file_path.endswith(".json") and file.startswith("rel"):
                    self._load_update_relationship_json(file_path)

    def _load_update_entity_json(self, file):
        '''load json data from file'''
        print(f"load entity update data from {file}")

        # 这里加载update数据，update数据是一个json文件，格式同cached data如下：

        with open(file, "r", encoding="utf-8") as f:
            entities = json.load(f)
            for item in entities:
                original_data = self.entity_data[self.entity_data.index == item[0]]
                if original_data.empty:
                    continue
                original_data = original_data.iloc[0]
                id = int(item[0])
                name = item[1]["name"] if "name" in item[1] else original_data['name']
                type = item[1]["type"] if "type" in item[1] else original_data['type']
                allowed_sex_list = item[1]["allowed_sex_list"] if "allowed_sex_list" in item[1] else original_data[
                    'allowed_sex_list']
                allowed_age_range = item[1]["allowed_age_range"] if "allowed_age_range" in item[1] else original_data[
                    'allowed_age_range']

                self.entity_data.loc[id, ["name", "type", "allowed_sex_list", "allowed_age_range"]] = [name, type,
                                                                                                       allowed_sex_list,
                                                                                                       allowed_age_range]

    def _load_update_relationship_json(self, file):
        '''load json data from file'''
        print(f"load relationship update data from {file}")

        with open(file, "r", encoding="utf-8") as f:
            relations = json.load(f)
            for item in relations:
                data = {}
                original_data = self.relation_data[(self.relation_data['src'] == data['src']) &
                                                   (self.relation_data['dest'] == data['dest']) &
                                                   (self.relation_data['type'] == data['type'])]
                if original_data.empty:
                    continue
                original_data = original_data.iloc[0]
                data["src"] = int(item[0])
                data["dest"] = int(item[2])
                data["type"] = item[4]["type"]
                data["weight"] = item[4]["weight"] if "weight" in item[4] else original_data['weight']

                self.relation_data.loc[(self.relation_data['src'] == data['src']) &
                                       (self.relation_data['dest'] == data['dest']) &
                                       (self.relation_data['type'] == data['type']), 'weight'] = data["weight"]

    def check_sex_allowed(self, node, sex):

        # 性别过滤，假设疾病节点有一个属性叫做allowed_sex_type，值为“0,1,2”，分别代表未知，男，女
        sex_allowed = self.graph.nodes[node].get('sex', None)
        #sexProps = self.propService.get_props_by_ref_id(node, 'sex')
        #if len(sexProps) > 0 and sexProps[0]['prop_value'] is not None and sexProps[0][
            #'prop_value'] != input.pat_sex.value:
            #continue
        if sex_allowed:
            if len(sex_allowed) == 0:
                # 如果性别列表为空，那么默认允许所有性别
                return True
            sex_allowed_list = sex_allowed.split(',')
            if sex not in sex_allowed_list:
                # 如果性别不匹配，跳过
                return False
        return True

    def check_age_allowed(self, node, age):
        # 年龄过滤，假设疾病节点有一个属性叫做allowed_age_range，值为“6-88”，代表年龄在0-88月之间是允许的
        # 如果说年龄小于6岁，那么我们就认为是儿童，所以儿童的年龄范围是0-6月
        age_allowed = self.graph.nodes[node].get('age', None)
        if age_allowed:
            if len(age_allowed) == 0:
                # 如果年龄范围为空，那么默认允许所有年龄
                return True
            age_allowed_list = age_allowed.split('-')
            age_min = int(age_allowed_list[0])
            age_max = int(age_allowed_list[-1])
            if age_max ==0:
                return True
            if age >= age_min and age < age_max:
                # 如果年龄范围正常，那么返回True
                return True
        else:
            # 如果没有设置年龄范围，那么默认返回True
            return True
        return False

    def check_diease_allowed(self, node):
        is_symptom = self.graph.nodes[node].get('is_symptom', None)
        if is_symptom == "是":
            return False
        return True

    propService = KGPropService(next(get_db()))
    cache = TTLCache(maxsize=100000, ttl=60*60*24*30)
    def cdss_travel(self, input: CDSSInput, start_nodes: List, max_hops=3):
        """
        基于输入的症状节点，在知识图谱中进行遍历，查找相关疾病、科室、检查和药品

        参数:
            input: CDSSInput对象，包含患者的基本信息（年龄、性别等）
            start_nodes: 症状节点名称列表，作为遍历的起点
            max_hops: 最大遍历深度，默认为3

        返回值:
            返回一个包含以下信息的字典:
                - details: 按科室汇总的结果
                - diags: 按相关性排序的疾病列表
                - checks: 按出现频率排序的检查列表
                - drugs: 按出现频率排序的药品列表
                - total_diags: 疾病总数
                - total_checks: 检查总数
                - total_drugs: 药品总数

        主要步骤:
            1. 初始化允许的节点类型和关系类型
            2. 将症状名称转换为节点ID
            3. 遍历图谱查找相关疾病（STEP 1）
            4. 查找疾病对应的科室、检查和药品（STEP 2）
            5. 按科室汇总结果（STEP 3）
            6. 对结果进行排序和统计（STEP 4-6）
        """
        # 定义允许的节点类型，包括科室、疾病、药品、检查和症状
        # 这些类型用于后续的节点过滤和路径查找
        DEPARTMENT = ['科室', 'Department']
        DIESEASE = ['疾病', 'Disease']
        DRUG = ['药品', 'Drug']
        CHECK = ['检查', 'Check']
        SYMPTOM = ['症状', 'Symptom']
        #allowed_types = DEPARTMENT + DIESEASE + DRUG + CHECK + SYMPTOM
        allowed_types = DEPARTMENT + DIESEASE + SYMPTOM
        # 定义允许的关系类型，包括has_symptom、need_check、recommend_drug、belongs_to
        # 这些关系类型用于后续的路径查找和过滤
        allowed_links = ['has_symptom','疾病相关症状','belongs_to','所属科室']
        # 将输入的症状名称转换为节点ID
        # 由于可能存在同名节点，转换后的节点ID数量可能大于输入的症状数量
        node_ids = []
        node_id_names = {}

        # start_nodes里面重复的症状，去重同样的症状
        start_nodes = list(set(start_nodes))
        for node in start_nodes:
            #print(f"searching for node {node}")
            result = self.entity_data[self.entity_data['name'] == node]
            #print(f"searching for node {result}")
            for index, data in result.iterrows():
                node_id_names[index] = data["name"]
                node_ids = node_ids + [index]
        #print(f"start travel from {node_id_names}")

        # 这里是一个队列，用于存储待遍历的症状：
        node_ids_filtered = []
        for node in node_ids:
            if self.graph.has_node(node):
                node_ids_filtered.append(node)
            else:
                logger.debug(f"node {node} not found")
        node_ids = node_ids_filtered

        results = self.step1(node_ids,node_id_names, input, allowed_types, allowed_links,max_hops,DIESEASE)

        #self.validDisease(results, start_nodes)
        results = self.validDisease(results, start_nodes)

        # 调用step2方法处理科室、检查和药品信息
        results = self.step2(results)

        # STEP 3: 对于结果按照科室维度进行汇总
        final_results = self.step3(results)

        sorted_final_results = self.step4(final_results)
        sorted_final_results = sorted_final_results[:10]
        departments = []

        for temp in sorted_final_results:
            departments.append({"name": temp[0], "count": temp[1]["count"]})
        
        # STEP 5: 对于final_results里面的diseases, checks和durgs统计全局出现的次数并且按照次数降序排序
        sorted_score_diags,total_diags = self.step5(final_results, input)

        # STEP 6: 整合数据并返回
        # if "department" in item.keys():
        #     final_results["department"] = list(set(final_results["department"]+item["department"]))
        # if "diseases" in item.keys():
        #     final_results["diseases"] = list(set(final_results["diseases"]+item["diseases"]))
        # if "checks" in item.keys():
        #     final_results["checks"] = list(set(final_results["checks"]+item["checks"]))
        # if "drugs" in item.keys():
        #     final_results["drugs"] = list(set(final_results["drugs"]+item["drugs"]))
        # if "symptoms" in item.keys():
        #     final_results["symptoms"] = list(set(final_results["symptoms"]+item["symptoms"]))

        return {"details": sorted_final_results,
                "score_diags": sorted_score_diags,"total_diags": total_diags,
                "departments":departments
                # "checks":sorted_checks, "drugs":sorted_drugs,
                # "total_checks":total_check, "total_drugs":total_drug
                }

    def validDisease(self, results, start_nodes):
        """
        输出有效的疾病信息为Markdown格式
        :param results: 疾病结果字典
        :param start_nodes: 起始症状节点列表
        :return: 格式化后的Markdown字符串
        """
        log_data = ["|疾病|症状|出现次数|是否相关"]
        log_data.append("|--|--|--|--|")
        filtered_results = {}
        for item in results:
            data = results[item]
            data['relevant'] = False
            if data["count"] / len(start_nodes) > 0.5:
                #cache_key = f'disease_name_ref_id_{data['name']}'
                data['relevant'] = True
                filtered_results[item] = data
                # 初始化疾病的父类疾病
                # disease_name = data["name"]
                # key = 'disease_name_parent_' +disease_name
                # cached_value = self.cache.get(key)
                # if cached_value is None:
                #     out_edges = self.graph.out_edges(item, data=True)
                #
                #     for edge in out_edges:
                #         src, dest, edge_data = edge
                #         if edge_data["type"] != '疾病相关父类':
                #             continue
                #         dest_data = self.entity_data[self.entity_data.index == dest]
                #         if dest_data.empty:
                #             continue
                #         dest_name = self.entity_data[self.entity_data.index == dest]['name'].tolist()[0]
                #         self.cache.set(key, dest_name)
                #         break
            if data['relevant'] == False:
                continue

            log_data.append(f"|{data['name']}|{','.join(data['path'])}|{data['count']}|{data['relevant']}|")

        content = "疾病和症状相关性统计表格\n" + "\n".join(log_data)
        print(f"\n{content}")
        return filtered_results

    def step1(self, node_ids,node_id_names, input, allowed_types, allowed_links,max_hops,DIESEASE):
        """
        根据症状节点查找相关疾病
        :param node_ids: 症状节点ID列表
        :param input: 患者信息输入
        :param allowed_types: 允许的节点类型
        :param allowed_links: 允许的关系类型
        :return: 过滤后的疾病结果
        """
        start_time = time.time()
        results = {}
        for node in node_ids:
            visited = set()
            temp_results = {}
            cache_key = f"symptom_ref_disease_{str(node)}"
            cache_data = self.cache[cache_key] if cache_key in self.cache else None
            if cache_data:
                temp_results = copy.deepcopy(cache_data)
                print(cache_key+":"+node_id_names[node] +':'+ str(len(temp_results)))
                if results=={}:
                    results = temp_results
                else:
                    for disease_id in temp_results:
                        path = temp_results[disease_id]["path"][0]
                        if disease_id in results.keys():
                            results[disease_id]["count"] = results[disease_id]["count"] + 1
                            results[disease_id]["path"].append(path)
                        else:
                            results[disease_id] = temp_results[disease_id]


                continue
            queue = [(node, 0, node_id_names[node],{'allowed_types': allowed_types, 'allowed_links': allowed_links})]

            # 整理input的数据，这里主要是要检查输入数据是否正确，也需要做转换
            if input.pat_age and input.pat_age.value is not None and input.pat_age.value > 0 and input.pat_age.type == 'year':
                # 这里将年龄从年转换为月，因为我们的图里面的年龄都是以月为单位的
                input.pat_age.value = input.pat_age.value * 12
                input.pat_age.type = 'month'

            # STEP 1: 假设start_nodes里面都是症状，第一步我们先找到这些症状对应的疾病
            # TODO 由于这部分是按照症状逐一去寻找疾病，所以实际应用中可以缓存这些结果
            while queue:
                temp_node, depth, path, data = queue.pop(0)
                temp_node = int(temp_node)
                # 这里是通过id去获取节点的name和type
                entity_data = self.entity_data[self.entity_data.index == temp_node]
                # 如果节点不存在，那么跳过
                if entity_data.empty:
                    continue
                if self.graph.nodes.get(temp_node) is None:
                    continue
                node_type = self.entity_data[self.entity_data.index == temp_node]['type'].tolist()[0]
                node_name = self.entity_data[self.entity_data.index == temp_node]['name'].tolist()[0]
                # print(f"node {node} type {node_type}")
                if node_type in DIESEASE:
                    # print(f"node {node} type {node_type} is a disease")
                    if self.check_diease_allowed(temp_node) == False:
                        continue
                    if temp_node in temp_results.keys():
                        temp_results[temp_node]["count"] = temp_results[temp_node]["count"] + 1
                        temp_results[temp_node]["path"].append(path)
                    else:
                        temp_results[temp_node] = {"type": node_type, "count": 1, "name": node_name, 'path': [path]}

                    continue

                if temp_node in visited or depth > max_hops:
                    # print(f"{node} already visited or reach max hops")
                    continue

                visited.add(temp_node)
                # print(f"check edges from {node}")
                if temp_node not in self.graph:
                    # print(f"node {node} not found in graph")
                    continue
                # todo 目前是取入边，出边是不是也有用？
                for edge in self.graph.in_edges(temp_node, data=True):
                    src, dest, edge_data = edge
                    if src not in visited and depth + 1 < max_hops:
                        # print(f"put into queue travel from {src} to {dest}")
                        queue.append((src, depth + 1, path, data))
                    # else:
                    # print(f"skip travel from {src} to {dest}")
            print(cache_key+":"+node_id_names[node]+':'+ str(len(temp_results)))
            #对temp_results进行深拷贝，然后再进行处理
            self.cache[cache_key] = copy.deepcopy(temp_results)
            if results == {}:
                results = temp_results
            else:
                for disease_id in temp_results:
                    path = temp_results[disease_id]["path"][0]
                    if disease_id in results.keys():
                        results[disease_id]["count"] = results[disease_id]["count"] + 1
                        results[disease_id]["path"].append(path)
                    else:
                        results[disease_id] = temp_results[disease_id]

        end_time = time.time()

        # 这里我们需要对结果进行过滤，过滤掉不满足条件的疾病
        new_results = {}

        for item in results:
            if input.pat_sex and input.pat_sex.value is not None  and self.check_sex_allowed(item, input.pat_sex.value) == False:
                continue
            if input.pat_age and input.pat_age.value is not None and self.check_age_allowed(item, input.pat_age.value) == False:
                continue
            new_results[item] = results[item]
        results = new_results
        print('STEP 1 '+str(len(results)))
        print(f"STEP 1 执行完成，耗时：{end_time - start_time:.2f}秒")
        print(f"STEP 1 遍历图谱查找相关疾病 finished")
        return results

    def step2(self, results):
        """
        查找疾病对应的科室、检查和药品信息
        :param results: 包含疾病信息的字典
        :return: 更新后的results字典
        """
        start_time = time.time()
        print("STEP 2 查找疾病对应的科室、检查和药品 start")

        for disease in results.keys():
            # cache_key = f"disease_department_{disease}"
            # cached_data = self.cache.get(cache_key)
            # if cached_data:
            #     results[disease]["department"] = cached_data
            #     continue

            if results[disease]["relevant"] == False:
                continue

            department_data = []
            out_edges = self.graph.out_edges(disease, data=True)
            for edge in out_edges:
                src, dest, edge_data = edge
                if edge_data["type"] != 'belongs_to' and edge_data["type"] != 'belongs_to':
                    continue
                dest_data = self.entity_data[self.entity_data.index == dest]
                if dest_data.empty:
                    continue
                department_name = self.entity_data[self.entity_data.index == dest]['name'].tolist()[0]
                department_data.extend([department_name] * results[disease]["count"])

            if department_data:
                results[disease]["department"] = department_data
                #self.cache.set(cache_key, department_data)

        print(f"STEP 2 finished")
        end_time = time.time()
        print(f"STEP 2 执行完成，耗时：{end_time - start_time:.2f}秒")

        # 输出日志
        log_data = ["|disease|count|department|check|drug|"]
        log_data.append("|--|--|--|--|--|")
        for item in results.keys():
            department_data = results[item].get("department", [])
            count_data = results[item].get("count")
            check_data = results[item].get("check", [])
            drug_data = results[item].get("drug", [])
            log_data.append(
                f"|{results[item].get("name", item)}|{count_data}|{','.join(department_data)}|{','.join(check_data)}|{','.join(drug_data)}|")

        print("疾病科室检查药品相关统计\n" + "\n".join(log_data))
        return results

    def step3(self, results):
        print(f"STEP 3 对于结果按照科室维度进行汇总 start")
        final_results = {}
        total = 0
        for disease in results.keys():
            disease = int(disease)
            # 由于存在有些疾病没有科室的情况，所以这里需要做一下处理
            departments = ['DEFAULT']
            if 'department' in results[disease].keys():
                departments = results[disease]["department"]
            else:
                edges = KGEdgeService(next(get_db())).get_edges_by_nodes(src_id=disease, category='所属科室')
                #edges有可能为空，这里需要做一下处理
                if len(edges) == 0:
                    continue
                departments = [edge['dest_node']['name'] for edge in edges]
            # 处理查询结果
            for department in departments:
                total += 1
                if not department in final_results.keys():
                    final_results[department] = {
                        "diseases": [str(disease)+":"+results[disease].get("name", disease)],
                        "checks": results[disease].get("check", []),
                        "drugs": results[disease].get("drug", []),
                        "count": 1
                    }
                else:
                    final_results[department]["diseases"] = final_results[department]["diseases"] + [str(disease)+":"+
                        results[disease].get("name", disease)]
                    final_results[department]["checks"] = final_results[department]["checks"] + results[disease].get(
                        "check", [])
                    final_results[department]["drugs"] = final_results[department]["drugs"] + results[disease].get(
                        "drug", [])
                    final_results[department]["count"] += 1

        # 这里是统计科室出现的分布
        for department in final_results.keys():
            final_results[department]["score"] = final_results[department]["count"] / total

        print(f"STEP 3 finished")
        # 这里输出日志
        log_data = ["|department|disease|check|drug|count|score"]
        log_data.append("|--|--|--|--|--|--|")
        for department in final_results.keys():
            diesease_data = final_results[department].get("diseases", [])
            check_data = final_results[department].get("checks", [])
            drug_data = final_results[department].get("drugs", [])
            count_data = final_results[department].get("count", 0)
            score_data = final_results[department].get("score", 0)
            log_data.append(
                f"|{department}|{','.join(diesease_data)}|{','.join(check_data)}|{','.join(drug_data)}|{count_data}|{score_data}|")

        print("\n" + "\n".join(log_data))
        return final_results

    def step4(self, final_results):
        """
        对final_results中的疾病、检查和药品进行统计和排序
        
        参数:
            final_results: 包含科室、疾病、检查和药品的字典
        
        返回值:
            排序后的final_results
        """
        print(f"STEP 4 start")
        start_time = time.time()

        def sort_data(data, count=10):
            tmp = {}
            for item in data:
                if item in tmp.keys():
                    tmp[item]["count"] += 1
                else:
                    tmp[item] = {"count": 1}
            sorted_data = sorted(tmp.items(), key=lambda x: x[1]["count"], reverse=True)
            return sorted_data[:count]

        for department in final_results.keys():
            final_results[department]['name'] = department
            final_results[department]["diseases"] = sort_data(final_results[department]["diseases"])
            #final_results[department]["checks"] = sort_data(final_results[department]["checks"])
            #final_results[department]["drugs"] = sort_data(final_results[department]["drugs"])

        # 这里把科室做一个排序，按照出现的次数降序排序
        sorted_final_results = sorted(final_results.items(), key=lambda x: x[1]["count"], reverse=True)
  
        print(f"STEP 4 finished")
        end_time = time.time()
        print(f"STEP 4 执行完成，耗时：{end_time - start_time:.2f}秒")
        # 这里输出markdown日志
        log_data = ["|department|disease|check|drug|count|score"]
        log_data.append("|--|--|--|--|--|--|")
        for department in final_results.keys():
            diesease_data = final_results[department].get("diseases")
            check_data = final_results[department].get("checks")
            drug_data = final_results[department].get("drugs")
            count_data = final_results[department].get("count", 0)
            score_data = final_results[department].get("score", 0)
            log_data.append(f"|{department}|{diesease_data}|{check_data}|{drug_data}|{count_data}|{score_data}|")

        print("\n" + "\n".join(log_data))
        return sorted_final_results

    def step5(self, final_results, input):
        """
        按科室汇总结果并排序

        参数:
            final_results: 各科室的初步结果
            input: 患者输入信息

        返回值:
            返回排序后的诊断结果
        """
        print(f"STEP 5 start")
        start_time = time.time()
        diags = {}
        total_diags = 0

        for department in final_results.keys():
            department_factor = 0.1 if department == 'DEFAULT' else final_results[department]["score"]
            #当前科室权重增加0.1
            if input.department.value == department:
            #if '急诊医学科' == department:
                department_factor = department_factor * 1.001

            for disease, data in final_results[department]["diseases"]:
                total_diags += 1
                #key = 'disease_name_parent_' + disease
                # cached_data = self.cache.get(key)
                # if cached_data:
                #     disease = cached_data
                if disease in diags.keys():
                    diags[disease]["count"] += data["count"]
                    diags[disease]["score"] += data["count"] * department_factor
                else:
                    diags[disease] = {"count": data["count"], "score": data["count"] * department_factor}
  
        sorted_score_diags = sorted(diags.items(), key=lambda x: x[1]["score"], reverse=True)[:10]

        #循环sorted_score_diags，把disease现在是id:name替换name
        # diags = {}
        # for item in sorted_score_diags:
        #     diseaseinfos = item[0].split(":")
        #     diseaseId = diseaseinfos[0]
        #     diseaseName = diseaseinfos[1]
        #     diseaseScore = self.graph.nodes[int(diseaseId)].get('score', None)
        #     if diseaseScore:
        #         try:
        #             # 创建新字典替换原元组
        #             new_item = {"count": item[1]["count"], "score": float(diseaseScore)*0.1}
        #             diags[diseaseName] = new_item
        #         except (ValueError, TypeError):
        #             # 如果转换失败，直接使用原元组
        #             diags[diseaseName] = item[1]
        #     else:
        #         # 如果没有找到对应的score，直接使用原元组
        #         diags[diseaseName] = item[1]
        # sorted_score_diags = sorted(diags.items(), key=lambda x: x[1]["score"], reverse=True)
        print(f"STEP 5 finished")
        end_time = time.time()
        print(f"STEP 5 执行完成，耗时：{end_time - start_time:.2f}秒")

        log_data = ["|department|disease|count|score"]
        log_data.append("|--|--|--|--|")
        for department in final_results.keys():
            diesease_data = final_results[department].get("diseases")
            count_data = final_results[department].get("count", 0)
            score_data = final_results[department].get("score", 0)
            log_data.append(f"|{department}|{diesease_data}|{count_data}|{score_data}|")

        print("这里是经过排序的数据\n" + "\n".join(log_data))
        return sorted_score_diags, total_diags