import os import tempfile from pathlib import Path from typing import List, Dict, Any from datetime import datetime # 导入 DeepSeek 健康内容生成服务 from services.deepseek_health_service import DeepSeekHealthService class BatchReportService: """批量报告处理服务""" def __init__(self, ocr_service, llm_service, pdf_service, template_service): self.ocr_service = ocr_service self.llm_service = llm_service self.pdf_service = pdf_service self.template_service = template_service # 初始化 DeepSeek 健康内容生成服务 self.deepseek_health_service = DeepSeekHealthService() # 临时文件目录 self.temp_dir = Path(tempfile.gettempdir()) / "medical_reports_temp" self.temp_dir.mkdir(exist_ok=True) def process_multiple_reports( self, file_paths: List[str], patient_name: str = "患者" ) -> Dict[str, Any]: """ 处理多个报告文件并生成综合健康报告 新流程：直接将文件传给 Coze 工作流处理 Args: file_paths: 临时上传的多个PDF文件路径列表 patient_name: 患者姓名 Returns: 包含分析结果和生成的PDF路径的字典 """ try: print(f"正在处理 {len(file_paths)} 份报告...") # 准备文件信息列表 file_infos = [] for idx, file_path in enumerate(file_paths, 1): filename = Path(file_path).name print(f" [{idx}/{len(file_paths)}] 准备文件: {filename}") file_infos.append({ "filename": filename, "filepath": file_path }) # 调用分析（会根据 LLM 类型选择不同的处理方式） print("正在进行综合分析...") combined_analysis = self._analyze_with_files(file_infos) # 使用 DeepSeek 生成健康评估和建议内容 if self.deepseek_health_service.is_available(): health_content = self.deepseek_health_service.generate_health_content(combined_analysis) if health_content: combined_analysis["health_assessment"] = health_content.get("health_assessment", {}) combined_analysis["health_advice"] = health_content.get("health_advice", {}) # 更新异常项（DeepSeek 可能提供更详细的信息） if health_content.get("abnormal_items"): combined_analysis["abnormal_items_detailed"] = health_content["abnormal_items"] else: print("\n ⚠️ DeepSeek API Key 未配置，跳过健康评估和建议生成") # 生成综合报告 PDF print("\n正在生成健康报告...") pdf_path = self._generate_comprehensive_report( patient_name=patient_name, reports=file_infos, analysis=combined_analysis ) # 清理临时文件 print("正在清理临时文件...") self._cleanup_temp_files(file_paths) return { "success": True, "patient_name": patient_name, "report_count": len(file_paths), "analysis": combined_analysis, "pdf_path": pdf_path, "generated_at": datetime.now().isoformat() } except Exception as e: # 即使出错也要清理临时文件 self._cleanup_temp_files(file_paths) raise Exception(f"批量处理失败: {str(e)}") def _analyze_with_files(self, file_infos: List[Dict[str, str]]) -> Dict[str, Any]: """ 综合分析流程（两阶段处理）： 1. OCR 提取所有文件的文本 2. Coze 分析文本 → 返回 JSON 3. Ollama 处理 Coze JSON → 生成 Be.U 风格报告 """ # 第1步：OCR 提取文本 print(" [步骤1] OCR 提取文本...") extracted_texts = [] for idx, file_info in enumerate(file_infos, 1): print(f" [{idx}/{len(file_infos)}] 识别: {file_info['filename']}") text = self.ocr_service.extract_text(file_info["filepath"]) extracted_texts.append({ "filename": file_info["filename"], "text": text }) # 第2-3步：LLM 分析（Coze → Ollama 或 纯 Ollama） print(" [步骤2-3] 综合分析与报告生成...") return self._analyze_combined_reports(extracted_texts) def _analyze_with_coze_files(self, file_infos: List[Dict[str, str]]) -> Dict[str, Any]: """ 使用 Coze 文件上传 + 工作流处理 1. 上传文件到 Coze 获取 file_id 2. 分批调用工作流（每批最多 3 个文件） 3. 合并结果 """ import requests import json import time api_key = os.getenv("COZE_API_KEY") workflow_id = os.getenv("COZE_WORKFLOW_ID") if not api_key or not workflow_id: raise ValueError("未配置 Coze API 所需的 COZE_API_KEY 或 COZE_WORKFLOW_ID") # 第1步：上传所有文件获取 file_id file_ids = [] for idx, file_info in enumerate(file_infos, 1): print(f" [{idx}/{len(file_infos)}] 上传: {file_info['filename']}") try: file_id = self._upload_file_to_coze( file_path=file_info['filepath'], api_key=api_key ) file_ids.append({ "filename": file_info['filename'], "file_id": file_id }) print(f" ✓ File ID: {file_id}") except Exception as e: print(f" ✗ 上传失败: {e}") raise Exception(f"文件上传失败: {file_info['filename']}, {e}") # 第2步：一次性调用工作流处理所有文件 print(f"\n [步骤2] 调用 Coze 工作流分析 {len(file_ids)} 个文件...") # 构造请求参数：input 是字符串数组，每个元素是 JSON 字符串 input_params = [] for file_data in file_ids: # 每个元素是 JSON 字符串格式："{\"file_id\":\"xxx\"}" json_str = json.dumps({"file_id": file_data["file_id"]}, ensure_ascii=False) input_params.append(json_str) print(f" - {file_data['filename']}: {file_data['file_id']}") # 调用工作流 try: final_result = self._call_coze_workflow( workflow_id=workflow_id, api_key=api_key, input_params=input_params ) print(f" ✓ 工作流处理完成") except Exception as e: print(f" ✗ 工作流调用失败: {e}") raise # 保存结果缓存 try: cache_file = Path("coze_result_cache.json") cache_data = { "timestamp": time.strftime('%Y-%m-%d %H:%M:%S'), "report_count": len(file_ids), "coze_result": final_result, "file_ids": file_ids } cache_file.write_text(json.dumps(cache_data, ensure_ascii=False, indent=2), encoding='utf-8') print(f" → Coze 结果已缓存到: {cache_file.absolute()}") except Exception as e: print(f" ⚠️ 缓存保存失败: {e}") return final_result def _upload_file_to_coze(self, file_path: str, api_key: str) -> str: """ 上传文件到 Coze 获取 file_id """ import requests upload_url = "https://api.coze.cn/v1/files/upload" headers = { "Authorization": f"Bearer {api_key}" } with open(file_path, 'rb') as f: files = { 'file': (Path(file_path).name, f, 'application/octet-stream') } response = requests.post( upload_url, headers=headers, files=files, timeout=60 ) if response.status_code != 200: raise Exception(f"上传失败 (HTTP {response.status_code}): {response.text}") data = response.json() # 解析返回的 file_id if data.get("code") == 0 and data.get("data"): file_id = data["data"].get("id") or data["data"].get("file_id") if file_id: return file_id raise Exception(f"未能获取 file_id: {data}") def _call_coze_workflow(self, workflow_id: str, api_key: str, input_params: List[str]) -> Dict[str, Any]: """ 调用 Coze 工作流（使用流式接口） input_params: 字符串数组，每个元素是 JSON 字符串格式的 file_id """ from cozepy import Coze, TokenAuth, COZE_CN_BASE_URL, WorkflowEventType # 初始化 Coze 客户端 coze = Coze(auth=TokenAuth(token=api_key), base_url=COZE_CN_BASE_URL) print(f" → 调用工作流 (file_id 数量: {len(input_params)})...") # 调用流式工作流 import time as time_module start = time_module.time() stream = coze.workflows.stream_run( workflow_id=workflow_id, parameters={"input": input_params} ) content_result = None for event in stream: if event.event == WorkflowEventType.MESSAGE: if hasattr(event, 'message'): msg = event.message node_title = getattr(msg, 'node_title', None) node_is_finish = getattr(msg, 'node_is_finish', None) content = getattr(msg, 'content', None) if node_title == "End" and node_is_finish and content: content_result = content break elif event.event == WorkflowEventType.ERROR: error_msg = str(event.error) if hasattr(event, 'error') else "Unknown error" raise Exception(f"工作流执行错误: {error_msg}") elapsed = time_module.time() - start if not content_result: raise Exception("未获取到工作流执行结果") print(f" ✓ 工作流完成 (耗时: {elapsed:.1f}秒)") # 解析结果 import json try: if isinstance(content_result, str): result_data = json.loads(content_result) else: result_data = content_result # 提取 output if isinstance(result_data, dict) and "output" in result_data: output = result_data["output"] if isinstance(output, str): output = json.loads(output) return output return result_data except json.JSONDecodeError as e: raise Exception(f"解析工作流结果失败: {e}") def _call_coze_with_files(self, file_infos: List[Dict[str, str]]) -> Dict[str, Any]: """ 直接将文件传给 Coze 工作流处理 """ try: import requests import json # 读取 Coze 配置 api_url = os.getenv("COZE_API_URL", "https://api.coze.cn/v1/workflow/run") api_key = os.getenv("COZE_API_KEY") workflow_id = os.getenv("COZE_WORKFLOW_ID") max_retries = int(os.getenv("COZE_MAX_RETRIES", "3")) if not api_key or not workflow_id: raise ValueError("未配置 Coze API 所需的 COZE_API_KEY 或 COZE_WORKFLOW_ID") # 准备文件数据（根据 Coze API 要求构造） # 如果 Coze 需要文件内容，读取并转换为 base64 files_data = [] for file_info in file_infos: filepath = file_info["filepath"] filename = file_info["filename"] # 读取文件内容并转换为 base64 with open(filepath, 'rb') as f: import base64 file_content = base64.b64encode(f.read()).decode('utf-8') files_data.append({ "filename": filename, "content": file_content, "type": "application/pdf" if filename.endswith('.pdf') else "image/jpeg" }) headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json" } # 构造请求体 payload = { "workflow_id": workflow_id, "parameters": { "input": files_data # 传递文件数组 } } print(f" 正在调用 Coze 工作流处理 {len(files_data)} 个文件...") last_error = None for attempt in range(max_retries): try: response = requests.post(api_url, headers=headers, json=payload, timeout=300) response.raise_for_status() data = response.json() # 解析 Coze 返回结果 if isinstance(data, dict) and data.get("code") == 0: raw_data = data.get("data", {}) if isinstance(raw_data, str): try: raw_data = json.loads(raw_data) except json.JSONDecodeError: pass output = raw_data.get("output", raw_data) # 使用 Ollama 增强 Coze 结果 print(" [阶段2] 使用 Ollama 优化报告内容...") final_result = self._enhance_with_ollama(output, f"处理了 {len(files_data)} 个文件") return final_result last_error = f"Coze API 返回非0 code: {data}" except Exception as e: last_error = str(e) if attempt < max_retries - 1: wait_time = (attempt + 1) * 3 print(f" 重试 {attempt + 1}/{max_retries}...") import time time.sleep(wait_time) else: break raise Exception(last_error or "Coze API 调用失败") except Exception as e: print(f" ⚠ Coze 处理失败: {e}") # 降级到 OCR + Ollama 方式 print(" 降级到 OCR + Ollama 处理...") extracted_texts = [] for file_info in file_infos: text = self.ocr_service.extract_text(file_info["filepath"]) extracted_texts.append({ "filename": file_info["filename"], "text": text }) return self._analyze_combined_reports(extracted_texts) def _analyze_combined_reports(self, reports: List[Dict[str, str]]) -> Dict[str, Any]: """ 综合分析流程（两阶段处理）： - 如果使用 Coze： 阶段1: Coze 工作流处理数据 → 返回结构化 JSON 阶段2: Ollama 分析 JSON → 生成适配 Be.U 模板的专业报告 - 如果使用其他LLM： 直接使用该 LLM 生成报告 """ if self.llm_service.llm_type == "coze": # === 两阶段处理：Coze + Ollama === # 【阶段1】Coze 工作流分析 print(" [阶段1/2] Coze 工作流分析中...") print(f" - 处理 {len(reports)} 份报告") # Coze 工作流有执行超时限制，超过阈值时分批处理 BATCH_SIZE = 3 # 每批最多 3 个报告 import json # 原始文本列表（给 Ollama 使用） original_texts: List[str] = [] # 所有批次的 Coze 结果 all_coze_results: List[Dict[str, Any]] = [] # 分批处理 total_batches = (len(reports) + BATCH_SIZE - 1) // BATCH_SIZE if total_batches > 1: print(f" - 报告数量较多，将分 {total_batches} 批处理（每批 {BATCH_SIZE} 个）") for batch_idx in range(total_batches): start_idx = batch_idx * BATCH_SIZE end_idx = min(start_idx + BATCH_SIZE, len(reports)) batch_reports = reports[start_idx:end_idx] if total_batches > 1: print(f"\n [批次 {batch_idx + 1}/{total_batches}] 处理报告 {start_idx + 1}-{end_idx}") # 准备当前批次的数据 coze_inputs: List[Dict[str, str]] = [] for report in batch_reports: filename = report["filename"] text = report["text"] # 保留一份可读的原始文本 original_text = f"【文件名】{filename}\n【内容】\n{text}" original_texts.append(original_text) # 构造传给 Coze 的 JSON 对象 coze_obj = { "filename": filename, "text": text, } coze_inputs.append(coze_obj) print(f" - {filename}: {len(text)} 字符") print(f" - 本批次元素个数: {len(coze_inputs)}") # 保存当前批次的调试信息 if total_batches > 1: debug_file = Path(f"debug_batch_{batch_idx + 1}.json") else: debug_file = Path("debug_ocr_texts.json") try: final_payload = { "workflow_id": os.getenv("COZE_WORKFLOW_ID", ""), "parameters": { "input": coze_inputs } } debug_file.write_text(json.dumps(final_payload, ensure_ascii=False, indent=2), encoding='utf-8') print(f" → Payload 已保存: {debug_file.name}") except Exception as e: print(f" ⚠️ 保存调试文件失败: {e}") # 调用 Coze 处理当前批次 print(f" → 调用 Coze 工作流...") batch_result = self.llm_service.analyze_multiple_reports(coze_inputs) # 检查当前批次是否成功 if batch_result.get("error"): error_msg = batch_result.get('error') print(f" ✗ 批次 {batch_idx + 1} 失败: {error_msg}") raise Exception(f"Coze 工作流调用失败: {error_msg}") print(f" ✓ 批次 {batch_idx + 1} 完成") all_coze_results.append(batch_result) # 合并所有批次的结果 print(f"\n ✓ 所有批次处理完成，合并结果...") coze_result = self._merge_batch_results(all_coze_results) # 保存 Coze 返回结果用于后续测试 try: import time cache_file = Path("coze_result_cache.json") cache_data = { "timestamp": time.strftime('%Y-%m-%d %H:%M:%S'), "report_count": len(reports), "coze_result": coze_result, "original_texts": original_texts } cache_file.write_text(json.dumps(cache_data, ensure_ascii=False, indent=2), encoding='utf-8') print(f" → Coze 结果已缓存到: {cache_file.absolute()}") except Exception as e: print(f" ⚠️ 缓存保存失败: {e}") # 【阶段2】Ollama 优化生成 print(" [阶段2/2] Ollama 生成 Be.U 风格报告...") print(" - 将 Coze JSON 转换为专业报告内容") print(" - 适配 Be.U Wellness Center 模板") # 合并原始文本供 Ollama 参考（仍然使用人类可读的文本，而不是 JSON 字符串） combined_text = "\n\n".join(original_texts) final_analysis = self._enhance_with_ollama(coze_result, combined_text) print(" ✓ 综合报告生成完成") return final_analysis else: # === 单阶段：直接使用当前 LLM === print(f" 使用 {self.llm_service.llm_type} 直接生成报告...") print(f" - 处理 {len(reports)} 份报告") # 合并所有报告文本 combined_text = "\n\n=== 报告分隔 ===\n\n".join([ f"【文件名】{report['filename']}\n【内容】\n{report['text']}" for report in reports ]) analysis = self.llm_service.analyze_single_report(combined_text) print(" ✓ 报告生成完成") return analysis def _merge_batch_results(self, batch_results: List[Dict[str, Any]]) -> Dict[str, Any]: """ 合并多个批次的 Coze 结果 """ if len(batch_results) == 1: return batch_results[0] print(f" - 合并 {len(batch_results)} 个批次的结果...") # 合并结果 merged = { "summary": "", "key_findings": [], "abnormal_items": [], "risk_assessment": "", "recommendations": [] } # 收集所有字段 summaries = [] risk_assessments = [] for idx, result in enumerate(batch_results, 1): # 摘要 if result.get("summary"): summaries.append(f"批次{idx}: {result['summary']}") # 关键发现 if result.get("key_findings"): merged["key_findings"].extend(result["key_findings"]) # 异常指标 if result.get("abnormal_items"): merged["abnormal_items"].extend(result["abnormal_items"]) # 风险评估 if result.get("risk_assessment"): risk_assessments.append(f"批次{idx}: {result['risk_assessment']}") # 建议 if result.get("recommendations"): merged["recommendations"].extend(result["recommendations"]) # 合并摘要和风险评估 merged["summary"] = "\n\n".join(summaries) if summaries else "未提供摘要" merged["risk_assessment"] = "\n\n".join(risk_assessments) if risk_assessments else "未提供风险评估" print(f" - 合并后: 关键发现 {len(merged['key_findings'])} 项, " f"异常指标 {len(merged['abnormal_items'])} 项, " f"建议 {len(merged['recommendations'])} 项") return merged def _enhance_with_ollama(self, coze_result: Dict[str, Any], original_text: str) -> Dict[str, Any]: """ 使用 Ollama 分析 Coze 返回的 JSON，生成适配 Be.U 模板的最终报告内容 """ try: import requests import json # 构建给 Ollama 的提示词 prompt = f"""你是一位专业的医疗报告撰写专家。现在需要基于 Coze 工作流返回的结构化数据，生成一份适合 Be.U Wellness Center 风格的功能医学健康报告。 Coze 工作流返回的数据： {json.dumps(coze_result, ensure_ascii=False, indent=2)} 原始检测报告文本： {original_text} 请基于以上信息，生成一份专业的综合健康报告，包含以下部分（JSON格式）： 1. summary: 综合健康摘要（整体评估，语言专业且易懂） 2. key_findings: 关键发现列表（提取最重要的检测结果） 3. abnormal_items: 异常指标详情（包含 name, value, reference, level） 4. risk_assessment: 健康风险评估（基于所有指标的综合分析） 5. recommendations: 个性化健康建议（具体可执行的建议） 要求： - 语言专业但易于理解 - 突出重点和异常项 - 提供可操作的健康建议 - 使用 Be.U Wellness Center 的专业风格 - 必须返回完整的 JSON 格式 请直接返回 JSON，不要有其他文字：""" # 调用 Ollama ollama_host = os.getenv("OLLAMA_HOST", "http://localhost:11434") ollama_model = os.getenv("OLLAMA_MODEL", "qwen2.5:7b") response = requests.post( f"{ollama_host}/api/generate", json={ "model": ollama_model, "prompt": prompt, "stream": False }, timeout=300 ) if response.status_code == 200: content = response.json().get("response", "") # 解析 Ollama 返回的 JSON return self._parse_ollama_response(content) else: print(f" ⚠ Ollama 调用失败，使用 Coze 原始结果") return coze_result except Exception as e: print(f" ⚠ Ollama 增强失败: {e}，使用 Coze 原始结果") return coze_result def _parse_ollama_response(self, response: str) -> Dict[str, Any]: """解析 Ollama 返回的 JSON""" try: import re import json # 尝试提取 JSON json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', response, re.DOTALL) if json_match: json_str = json_match.group(1) else: json_match = re.search(r'\{.*\}', response, re.DOTALL) if json_match: json_str = json_match.group(0) else: json_str = response result = json.loads(json_str) # 确保必需字段存在 required_fields = ["summary", "key_findings", "abnormal_items", "risk_assessment", "recommendations"] for field in required_fields: if field not in result: result[field] = [] if field in ["key_findings", "abnormal_items", "recommendations"] else "未提供" return result except Exception as e: print(f" ⚠ JSON 解析失败: {e}") return { "summary": "解析失败", "key_findings": [], "abnormal_items": [], "risk_assessment": "无法生成", "recommendations": [] } def _direct_ollama_analysis(self, combined_text: str) -> Dict[str, Any]: """ Coze 失败后的降级方案：直接使用 Ollama 生成完整报告 """ try: import requests import json print(" → 使用 Ollama 模型生成完整报告...") # 构建 Ollama 提示词 prompt = f"""你是一位专业的医疗报告分析助手。请分析以下医疗报告，提供专业的综合健康评估。 医疗报告内容： {combined_text} 请按以下 JSON 格式返回分析结果： {{ "summary": "综合健康摘要（2-3句话）", "key_findings": ["关键发现1", "关键发现2", "..."], "abnormal_items": [ {{ "name": "指标名称", "result": "测量值", "reference": "参考范围", "level": "high/low/normal" }} ], "risk_assessment": "健康风险评估（综合说明）", "recommendations": ["建议1", "建议2", "..."] }} 请严格按照 JSON 格式返回，不要添加其他说明文字。""" # 调用 Ollama response = requests.post( "http://localhost:11434/api/generate", json={ "model": "qwen2.5:7b", "prompt": prompt, "stream": False }, timeout=180 ) if response.status_code == 200: ollama_response = response.json().get("response", "") print(f" ✓ Ollama 响应完成") # 解析 JSON import re json_match = re.search(r'\{.*\}', ollama_response, re.DOTALL) if json_match: result = json.loads(json_match.group(0)) # 确保必需字段存在 required_fields = ["summary", "key_findings", "abnormal_items", "risk_assessment", "recommendations"] for field in required_fields: if field not in result: result[field] = [] if field in ["key_findings", "abnormal_items", "recommendations"] else "未提供" return result else: raise ValueError("无法解析 Ollama 返回的 JSON") else: raise Exception(f"Ollama API 返回错误: {response.status_code}") except Exception as e: print(f" ⚠️ Ollama 降级方案也失败: {e}") return { "summary": "由于系统问题，暂时无法生成完整分析", "key_findings": ["OCR 文本提取完成", "分析服务暂时不可用"], "abnormal_items": [], "risk_assessment": "建议稍后重试或使用其他方式分析", "recommendations": ["联系技术支持", "检查系统配置"] } def _generate_comprehensive_report( self, patient_name: str, reports: List[Dict[str, str]], analysis: Dict[str, Any] ) -> str: """生成综合健康报告 PDF""" # 准备扩展的模板数据 template_data = { "patient_name": patient_name, "report_count": len(reports), "report_list": [r["filename"] for r in reports], "analysis": analysis, "generation_date": datetime.now().strftime("%Y年%m月%d日") } # 生成 PDF（使用增强的模板） pdf_path = self.pdf_service.generate_comprehensive_report( patient_name=patient_name, template_data=template_data ) return pdf_path def _cleanup_temp_files(self, file_paths: List[str]): """清理临时文件""" for file_path in file_paths: try: if os.path.exists(file_path): os.remove(file_path) print(f" ✓ 已删除临时文件: {Path(file_path).name}") except Exception as e: print(f" ⚠ 删除临时文件失败 {Path(file_path).name}: {e}")