union-app-chat-stream 1.0.3

package/app/manager/runtime_manager.py

@@ -0,0 +1,552 @@
+from __future__ import annotations
+
+import json
+from typing import Generator, Dict, Any, Optional, List
+from collections import defaultdict
+from decimal import Decimal
+
+from loguru import logger
+
+from app.models.schemas import ChatResponse
+from app.utils import common_utils
+from app.manager.prompts import (
+    PROMPT_EXTRACT_TIME_RANGE_SYSTEM,
+    PROMPT_EXTRACT_TIME_RANGE_USER,
+    PROMPT_QUALITY_DECLINE_MONTHS,
+    PROMPT_FAULT_DETAILS_BY_ORG,
+    PROMPT_FAILURE_PATTERNS_BY_ORG
+)
+
+
+class RuntimeManager:
+    """运行时分析业务管理器"""
+
+    # 常量定义
+    LARGE_SCALE_THRESHOLD = 20000000  # 大规模交易量阈值
+    MEDIUM_SCALE_THRESHOLD = 5000000  # 中等规模交易量阈值
+    TOP_INFLUENCE_COUNT = 10  # 影响度排名前N的数量
+    TOP_FAULT_CAUSE_COUNT = 5  # 故障原因前N的数量
+    TOP_ORG_COUNT = 3  # 机构前N的数量
+
+    def __init__(self, union_service, llm_service):
+        self._union_service = union_service
+        self._llm_service = llm_service
+
+    def extract_time_range_from_query(self, query_content: str) -> Optional[Dict[str, Any]]:
+        """
+        从用户查询中提取时间范围
+
+        Args:
+            query_content: 用户查询文本
+
+        Returns:
+            包含 queryTimeBegin 和 queryTimeEnd 的字典，失败返回None
+        """
+        logger.info("开始从查询中提取时间范围")
+        current_time = common_utils.current_time_format_by('%Y-%m-%d')
+        system_prompt = PROMPT_EXTRACT_TIME_RANGE_SYSTEM.format(current_time=current_time)
+        user_prompt = PROMPT_EXTRACT_TIME_RANGE_USER
+
+        time_range = self._llm_service.execute_llm(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            query_text=query_content,
+            temperature=0.3,
+            use_json_format=True
+        )
+
+        if time_range:
+            logger.info(f"时间范围提取成功: {time_range}")
+        else:
+            logger.warning("时间范围提取失败")
+        return time_range
+
+    def query_fulllink_data(
+        self,
+        query_time_begin: str,
+        query_time_end: str,
+        jsessionid: str
+    ) -> tuple[Optional[list[Dict[str, Any]]], str]:
+        """
+        查询全链路数据
+
+        Args:
+            query_time_begin: 查询开始时间（格式：yyyy-MM-dd）
+            query_time_end: 查询结束时间（格式：yyyy-MM-dd）
+            jsessionid: 登录态ID，用于外部接口鉴权
+
+        Returns:
+            (数据列表, 消息)元组
+        """
+        logger.info(f"查询全链路数据: {query_time_begin} ~ {query_time_end}")
+
+        # 参数校验
+        if not query_time_begin and not query_time_end:
+            return None, "success"
+
+        # 解析时间参数
+        start_int = common_utils.parse_month(query_time_begin) if query_time_begin else None
+        end_int = common_utils.parse_month(query_time_end) if query_time_end else None
+
+        # 构建查询参数,月度数据ymd为yyyyMM01字符串格式
+        params = {
+            'startDate': f"{start_int}01",
+            'endDate': f"{end_int}01"
+        }
+
+        # 调用通用大数据查询方法
+        data, message = self._union_service.query_bigdata(
+            interface_name=self._union_service.BIGDATA_INTERFACE_FULL_LINK,
+            params=params,
+            jsessionid=jsessionid,
+            description="查询全链路数据"
+        )
+
+        if message == "success":
+            logger.info(f"全链路数据查询成功，共 {len(data) if data else 0} 条记录")
+        else:
+            logger.error(f"全链路数据查询失败: {message}")
+        return data, message
+
+    def analyze_quality_decline_months_stream(
+        self,
+        query_content: str,
+        fulllink_data: list[Dict[str, Any]]
+    ) -> Generator[str, None, None]:
+        """
+        流式分析质量下降月份
+
+        Args:
+            query_content: 用户查询文本
+            fulllink_data: 全链路数据
+
+        Yields:
+            LLM响应的流式内容
+        """
+        logger.info("开始流式分析质量下降月份")
+        system_prompt = PROMPT_QUALITY_DECLINE_MONTHS.format(data_json=str(fulllink_data))
+        yield from self._llm_service.execute_llm_stream(
+            system_prompt=system_prompt,
+            query_text=query_content
+        )
+        logger.info("质量下降月份分析完成")
+
+    def query_bank_running_details(
+        self,
+        decline_months: str,
+        jsessionid: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        查询银行运行详情（包含业务逻辑处理）
+
+        Args:
+            decline_months: 下降月份字符串，逗号分隔
+            jsessionid: 登录态ID，用于外部接口鉴权
+
+        Returns:
+            处理后的银行运行数据
+        """
+        logger.info(f"查询并处理银行运行详情: {decline_months}")
+
+        # 解析时间数组
+        filtered_time_arrays = decline_months.split(",")
+        filtered_time = [f"{common_utils.parse_month(item_time)}" for item_time in filtered_time_arrays]
+
+        # 构建查询参数
+        params = {
+            'monthList': filtered_time
+        }
+
+        # 查询原始数据
+        raw_data, message = self._union_service.query_bigdata(
+            interface_name=self._union_service.BIGDATA_INTERFACE_BANK_MONTHLY,
+            params=params,
+            jsessionid=jsessionid,
+            description="查询银行月度运行数据"
+        )
+
+        if not raw_data:
+            logger.warning(f"银行运行原始数据查询为空: {message}")
+            return None
+
+        # 业务逻辑处理
+        sorted_result = self._process_bank_running_data(raw_data, filtered_time_arrays)
+
+        logger.info("银行运行详情查询和处理完成")
+        return sorted_result
+
+    def _process_bank_running_data(
+        self,
+        raw_data: List[Dict[str, Any]],
+        filtered_time_arrays: List[str]
+    ) -> Dict[str, Any]:
+        """处理银行运行数据（业务逻辑）"""
+        # 分组汇总数据
+        grouped_total_data = defaultdict(lambda: {"totalCnt": 0, "failCnt": 0})
+        for item in raw_data:
+            datetime = item["ym"]
+            grouped_total_data[datetime]["totalCnt"] += item["total_cnt"]
+            grouped_total_data[datetime]["failCnt"] += item["total_cnt_fail"]
+
+            # 设置规模级别
+            item['scale'] = self._calculate_scale(item['total_cnt'], datetime)
+
+        # 计算失败率
+        filtered_data_dict = {}
+        for datetime, cnt in grouped_total_data.items():
+            total_cnt = cnt["totalCnt"]
+            fail_cnt = cnt["failCnt"]
+            fail_rate = self._calculate_fail_rate(fail_cnt, total_cnt)
+            filtered_data_dict[datetime] = {
+                "failRate": fail_rate,
+                "failCnt": fail_cnt,
+                "datetime": datetime
+            }
+
+        # 计算影响度并分组
+        grouped_time_data = defaultdict(list)
+        for item in raw_data:
+            influence = (
+                item['total_cnt_fail'] -
+                filtered_data_dict[item['ym']]['failRate'] * item['total_cnt']
+            )
+            item['influence'] = influence
+            grouped_time_data[item['ym']].append(item)
+
+        # 排序并取前N
+        sorted_result = defaultdict(list)
+        for time in grouped_time_data:
+            sorted_result[time] = sorted(
+                grouped_time_data[time],
+                key=lambda x: x['influence'],
+                reverse=True
+            )[:self.TOP_INFLUENCE_COUNT]
+
+        # 获取故障信息并填充数据
+        fault_infos = self._union_service.query_jirainfo(filtered_time_arrays)
+        flat_result = [item for group in sorted_result.values() for item in group]
+        self._enrich_data_with_fault_info(flat_result, filtered_time_arrays, fault_infos)
+
+        return sorted_result
+
+    def _calculate_scale(self, total_cnt: int, datetime: str) -> str:
+        """根据交易量计算规模级别"""
+        days = common_utils.get_days_in_month(datetime)
+        if total_cnt >= self.LARGE_SCALE_THRESHOLD * days:
+            return 'large'
+        elif total_cnt < self.MEDIUM_SCALE_THRESHOLD * days:
+            return 'small'
+        else:
+            return 'medium'
+
+    def _calculate_fail_rate(self, fail_cnt: int, total_cnt: int) -> float:
+        """计算失败率"""
+        if total_cnt <= 0:
+            return 0.0
+        return float(
+            (Decimal(fail_cnt) / Decimal(total_cnt)).quantize(Decimal("0.00000001"))
+        )
+
+    def _group_fault_info_by_time(
+        self,
+        fault_info_list: List[Dict[str, Any]]
+    ) -> Dict[int, Dict[str, Dict[str, int]]]:
+        """按时间和机构分组故障信息"""
+        time_fault_group = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
+        for item in fault_info_list:
+            time = common_utils.parse_month(item['questionTime'])
+            org_code = item['orgCode']
+            fault_cause = item['faultCause']
+            impact_num = item['impactNum']
+            time_fault_group[time][org_code][fault_cause] += impact_num
+        return time_fault_group
+
+    def _get_top_fault_causes(
+        self,
+        org_fault_dict: Dict[str, int]
+    ) -> List[str]:
+        """获取影响数前N的故障原因"""
+        return sorted(
+            org_fault_dict.keys(),
+            key=lambda x: org_fault_dict[x],
+            reverse=True
+        )[:self.TOP_ORG_COUNT]
+
+    def _enrich_data_with_fault_info(
+        self,
+        data_list: List[Dict[str, Any]],
+        filtered_time_arrays: List[str],
+        fault_info: List[Dict[str, Any]]
+    ) -> None:
+        """为数据列表添加故障信息"""
+        time_fault_group = self._group_fault_info_by_time(fault_info)
+        time_fault_dict = {}
+
+        for time, org_dict in time_fault_group.items():
+            org_code_fault = {}
+            for org_code, fault_dict in org_dict.items():
+                top_fault_causes = self._get_top_fault_causes(fault_dict)
+                org_code_fault[org_code] = ','.join(top_fault_causes)
+            time_fault_dict[str(time)] = org_code_fault
+
+        org_codes = [item['org_code'] for item in data_list]
+        name_dict = self._union_service.query_orginfo(org_codes)
+
+        for item in data_list:
+            item['orgName'] = name_dict.get(item['org_code'], item['org_code'])
+            time_key = item.get('ym', '')
+            item['faultCause'] = time_fault_dict.get(
+                time_key, {}
+            ).get(item['org_code'], "未知原因")
+
+    def generate_fault_details_by_org_stream(
+        self,
+        data: Any
+    ) -> Generator[str, None, None]:
+        """
+        流式生成以机构为维度的故障详情
+
+        Args:
+            data: 数据对象
+
+        Yields:
+            LLM响应的流式内容
+        """
+        logger.info(f"开始生成以机构为维度的故障详情,data:{str(data)}")
+        system_prompt = PROMPT_FAULT_DETAILS_BY_ORG.format(data_json=str(data))
+        yield from self._llm_service.execute_llm_stream(system_prompt=system_prompt)
+        logger.info("机构维度故障详情生成完成")
+
+    def query_fault_details(
+        self,
+        decline_months: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        查询故障详情（包含业务逻辑处理）
+
+        Args:
+            decline_months: 下降月份字符串，逗号分隔
+
+        Returns:
+            按时间分组的故障详情字典
+        """
+        logger.info(f"查询并处理故障详情: {decline_months}")
+
+        filtered_time_arrays = decline_months.split(",")
+        fault_infos = self._union_service.query_jirainfo(filtered_time_arrays)
+
+        if not fault_infos:
+            logger.warning("故障信息查询为空")
+            return {}
+
+        # 业务逻辑处理
+        time_fault_dict = self._process_fault_details(fault_infos)
+        logger.info("故障详情查询和处理完成")
+        return time_fault_dict
+
+    def _process_fault_details(
+        self,
+        fault_infos: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """处理故障详情（业务逻辑）"""
+        # 按时间和故障原因分组
+        time_fault_group = {}
+        all_org_codes = []
+        for item in fault_infos:
+            time = common_utils.parse_month(item['questionTime'])
+            fault_cause = item['faultCause']
+
+            if time not in time_fault_group:
+                time_fault_group[time] = {}
+
+            if fault_cause not in time_fault_group[time]:
+                time_fault_group[time][fault_cause] = {'total': 0, 'orgs': {}}
+
+            fault_group = time_fault_group[time][fault_cause]
+            fault_group['total'] += item['impactNum']
+            fault_group['orgs'][item['orgCode']] = (
+                fault_group['orgs'].get(item['orgCode'], 0) + item['impactNum']
+            )
+            all_org_codes.append(item['orgCode'])
+
+        # 获取机构名称
+        name_dict = self._union_service.query_orginfo(all_org_codes)
+
+        # 构建结果
+        time_fault_dict = {}
+        for time, fc_dict in time_fault_group.items():
+            sorted_fc = sorted(
+                fc_dict.items(),
+                key=lambda x: x[1]['total'],
+                reverse=True
+            )[:self.TOP_FAULT_CAUSE_COUNT]
+
+            fault_orgs_dict = {}
+            for fc, info in sorted_fc:
+                sorted_orgs = sorted(
+                    info['orgs'].keys(),
+                    key=lambda org: info['orgs'][org],
+                    reverse=True
+                )[:self.TOP_ORG_COUNT]
+                fault_orgs_dict[fc] = {
+                    'total': info['total'],
+                    'orgNames': ','.join(name_dict.get(org, org) for org in sorted_orgs)
+                }
+            time_fault_dict[str(time)] = fault_orgs_dict
+
+        return time_fault_dict
+
+    def analyze_failure_patterns_stream(
+        self,
+        bankrunning_data: Dict[str, Any]
+    ) -> Generator[str, None, None]:
+        """
+        流式分析机构失败模式
+
+        Args:
+            bankrunning_data: 银行运行数据
+
+        Yields:
+            LLM响应的流式内容
+        """
+        logger.info("开始分析机构失败模式")
+        system_prompt = PROMPT_FAILURE_PATTERNS_BY_ORG.format(data_json=str(bankrunning_data))
+        yield from self._llm_service.execute_llm_stream(system_prompt=system_prompt)
+        logger.info("机构失败模式分析完成")
+
+    def analyze_runtime_complete_stream(
+        self,
+        query_content: str,
+        conversation_id: str,
+        jsessionid: str
+    ) -> Generator[ChatResponse, None, None]:
+        """
+        完整的运行时分析流式处理
+
+        这是编排了所有业务步骤的高层方法
+
+        Args:
+            query_content: 用户查询文本
+            conversation_id: 对话ID
+            jsessionid: 登录态ID，用于调用外部接口
+
+        Yields:
+            ChatResponse 流式消息
+
+        Raises:
+            RuntimeError: 当任何步骤失败时
+        """
+        logger.info("=" * 60)
+        logger.info("开始完整的运行时分析流程")
+        logger.info("=" * 60)
+
+        # 步骤1：提取时间范围
+        time_range = self.extract_time_range_from_query(query_content)
+        if not time_range:
+            yield self._format_error_message(conversation_id, "提取时间范围失败")
+            return
+
+        # 步骤2：查询全链路数据
+        fulllink_data, msg = self.query_fulllink_data(
+            time_range['queryTimeBegin'],
+            time_range['queryTimeEnd'],
+            jsessionid
+        )
+        if msg != "success":
+            yield self._format_error_message(conversation_id, f"查询全链路数据失败: {msg}")
+            return
+
+        # 步骤3：LLM流式分析质量下降月份
+        response_accumulator = []
+        yield from self._yield_llm_stream_with_accumulation(
+            self.analyze_quality_decline_months_stream(query_content, fulllink_data),
+            response_accumulator,
+            conversation_id,
+        )
+
+        # 解析下降月份
+        decline_months_str = self._parse_decline_months_from_response(response_accumulator)
+        if not decline_months_str:
+            yield self._format_error_message(conversation_id, "解析下降月份失败")
+            return
+
+        logger.info(f"识别到下降月份: {decline_months_str}")
+
+        # 步骤4：查询银行运行详情
+        bankrunning_data = self.query_bank_running_details(decline_months_str, jsessionid)
+
+        # 步骤5：生成机构维度故障详情
+        if bankrunning_data:
+            yield from self._yield_llm_stream(
+                self.generate_fault_details_by_org_stream(bankrunning_data),
+                conversation_id,
+            )
+
+        # 步骤6：查询故障详情并生成报告
+        fault_data = self.query_fault_details(decline_months_str)
+        if fault_data:
+            yield from self._yield_llm_stream(
+                self.generate_fault_details_by_org_stream(fault_data),
+                conversation_id,
+            )
+
+        # 步骤7：分析失败模式
+        if bankrunning_data:
+            yield from self._yield_llm_stream(
+                self.analyze_failure_patterns_stream(bankrunning_data),
+                conversation_id,
+            )
+
+        # 发送完成信号
+        yield ChatResponse(conversationId=conversation_id, finish_reason="done")
+        logger.info("=" * 60)
+        logger.info("运行时分析流程完成")
+        logger.info("=" * 60)
+
+    def _format_error_message(self, conversation_id: str, error_msg: str) -> ChatResponse:
+        return ChatResponse(conversationId=conversation_id, content=error_msg, finish_reason="error")
+
+    def _yield_llm_stream_with_accumulation(
+        self,
+        stream_generator: Generator[str, None, None],
+        accumulator: list[str],
+        conversation_id: str,
+    ) -> Generator[ChatResponse, None, None]:
+        """处理LLM流式响应并累积内容"""
+        for chunk in stream_generator:
+            if chunk.startswith("[ERROR]"):
+                yield ChatResponse(conversationId=conversation_id, content=chunk, finish_reason="error")
+                return
+            else:
+                logger.debug(f"LLM响应: {chunk}")
+                yield ChatResponse(conversationId=conversation_id, content=chunk)
+                accumulator.append(chunk)
+
+    def _yield_llm_stream(
+        self,
+        stream_generator: Generator[str, None, None],
+        conversation_id: str,
+    ) -> Generator[ChatResponse, None, None]:
+        """处理LLM流式响应（不累积内容）"""
+        for chunk in stream_generator:
+            if chunk.startswith("[ERROR]"):
+                yield ChatResponse(conversationId=conversation_id, content=chunk, finish_reason="error")
+                return
+            else:
+                logger.debug(f"LLM响应: {chunk}")
+                yield ChatResponse(conversationId=conversation_id, content=chunk)
+
+    def _parse_decline_months_from_response(
+        self,
+        response_accumulator: list[str]
+    ) -> Optional[str]:
+        """从响应中解析下降月份"""
+        try:
+            total_response = ''.join(response_accumulator)
+            cleaned_response = common_utils.remove_think_tag(total_response)
+            parsed_data = json.loads(cleaned_response)
+            decline_months_str = parsed_data.get("declineMonth")
+            return decline_months_str
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.error(f"解析下降月份失败: {e}")
+            return None

package/app/models/schemas.py

@@ -0,0 +1,30 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ChatRequest(BaseModel):
+    """聊天请求模型"""
+    model_config = ConfigDict(extra="forbid")
+
+    conversation_id: Optional[str] = Field(
+        default=None,
+        alias="conversationId",
+        description="对话ID，用于多轮对话上下文；为空时后端自动创建",
+    )
+    question: str = Field(..., min_length=1, max_length=4096, description="用户问题")
+
+
+class ChatResponse(BaseModel):
+    """聊天流式响应模型"""
+    model_config = ConfigDict(extra="forbid")
+
+    conversation_id: str = Field(..., alias="conversationId", description="对话ID")
+    content: Optional[str] = Field(default=None, description="模型正式回复内容增量")
+    reasoning_content: Optional[str] = Field(default=None, description="模型推理内容增量")
+    tool_call: Optional[str] = Field(default=None, description="工具调用信息")
+    tool_result: Optional[str] = Field(default=None, description="工具执行结果")
+    finish_reason: Optional[Literal["stop", "error", "rejected", "done"]] = Field(
+        default=None,
+        description="结束原因；中间流式增量为空",
+    )

package/app/service/__init__.py

@@ -0,0 +1,4 @@
+from . import union_service
+from . import llm_service
+
+__all__ = ["union_service", "llm_service"]