""" 报告生成服务 处理股票基本面分析报告的生成和管理 """ from typing import Dict, Any, Optional, List from uuid import UUID from datetime import datetime from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select import asyncio import logging from ..models.report import Report from ..models.analysis_module import AnalysisModule from ..schemas.report import ReportResponse, AnalysisModuleSchema from ..core.exceptions import ( ReportGenerationError, DataSourceError, AIAnalysisError, DatabaseError ) from .progress_tracker import ProgressTracker from .data_fetcher import DataFetcherFactory from .ai_analyzer import AIAnalyzerFactory from .config_manager import ConfigManager logger = logging.getLogger(__name__) class AnalysisModuleType: """分析模块类型常量""" TRADING_VIEW_CHART = "trading_view_chart" FINANCIAL_DATA = "financial_data" BUSINESS_INFO = "business_info" FUNDAMENTAL_ANALYSIS = "fundamental_analysis" BULLISH_ANALYSIS = "bullish_analysis" BEARISH_ANALYSIS = "bearish_analysis" MARKET_ANALYSIS = "market_analysis" NEWS_ANALYSIS = "news_analysis" TRADING_ANALYSIS = "trading_analysis" INSIDER_ANALYSIS = "insider_analysis" FINAL_CONCLUSION = "final_conclusion" class ReportGenerator: """报告生成器""" def __init__(self, db_session: AsyncSession, config_manager: ConfigManager): self.db = db_session self.config_manager = config_manager self.progress_tracker = ProgressTracker(db_session) # 定义分析模块配置 self.analysis_modules = [ { "type": AnalysisModuleType.TRADING_VIEW_CHART, "title": "TradingView图表", "order": 1, "step_name": "获取财务数据" }, { "type": AnalysisModuleType.FINANCIAL_DATA, "title": "财务数据分析", "order": 2, "step_name": "获取财务数据" }, { "type": AnalysisModuleType.BUSINESS_INFO, "title": "业务信息分析", "order": 3, "step_name": "生成业务信息" }, { "type": AnalysisModuleType.FUNDAMENTAL_ANALYSIS, "title": "基本面分析（景林模型）", "order": 4, "step_name": "执行基本面分析" }, { "type": AnalysisModuleType.BULLISH_ANALYSIS, "title": "看涨分析师观点", "order": 5, "step_name": "执行看涨分析" }, { "type": AnalysisModuleType.BEARISH_ANALYSIS, "title": "看跌分析师观点", "order": 6, "step_name": "执行看跌分析" }, { "type": AnalysisModuleType.MARKET_ANALYSIS, "title": "市场分析师观点", "order": 7, "step_name": "执行市场分析" }, { "type": AnalysisModuleType.NEWS_ANALYSIS, "title": "新闻分析师观点", "order": 8, "step_name": "执行新闻分析" }, { "type": AnalysisModuleType.TRADING_ANALYSIS, "title": "交易分析师观点", "order": 9, "step_name": "执行交易分析" }, { "type": AnalysisModuleType.INSIDER_ANALYSIS, "title": "内部人与机构动向分析", "order": 10, "step_name": "执行内部人分析" }, { "type": AnalysisModuleType.FINAL_CONCLUSION, "title": "最终结论", "order": 11, "step_name": "生成最终结论" } ] async def generate_report(self, symbol: str, market: str, force_regenerate: bool = False) -> ReportResponse: """生成股票分析报告""" try: # 检查是否存在现有报告 existing_report = await self._get_existing_report(symbol, market) if existing_report and not force_regenerate: if existing_report.status == "completed": logger.info(f"返回现有报告: {symbol} ({market})") return await self._build_report_response(existing_report) elif existing_report.status == "generating": logger.info(f"报告正在生成中: {symbol} ({market})") return await self._build_report_response(existing_report) # 创建新报告或重新生成 if existing_report and force_regenerate: report = existing_report report.status = "generating" report.updated_at = datetime.utcnow() # 清理现有的分析模块 await self._cleanup_existing_modules(report.id) else: report = await self._create_new_report(symbol, market) # 初始化进度追踪 await self.progress_tracker.initialize_progress(report.id) # 异步生成报告内容 asyncio.create_task(self._generate_report_content(report)) return await self._build_report_response(report) except Exception as e: logger.error(f"报告生成失败: {symbol} ({market}) - {str(e)}") if isinstance(e, (ReportGenerationError, DataSourceError, AIAnalysisError)): raise raise ReportGenerationError(f"报告生成失败: {str(e)}") async def get_report(self, symbol: str, market: str) -> Optional[ReportResponse]: """获取现有报告""" try: report = await self._get_existing_report(symbol, market) if report: return await self._build_report_response(report) return None except Exception as e: logger.error(f"获取报告失败: {symbol} ({market}) - {str(e)}") raise ReportGenerationError(f"获取报告失败: {str(e)}") async def get_report_by_id(self, report_id: UUID) -> Optional[ReportResponse]: """根据ID获取报告""" try: result = await self.db.execute( select(Report).where(Report.id == report_id) ) report = result.scalar_one_or_none() if report: return await self._build_report_response(report) return None except Exception as e: logger.error(f"获取报告失败: {report_id} - {str(e)}") raise ReportGenerationError(f"获取报告失败: {str(e)}") async def _get_existing_report(self, symbol: str, market: str) -> Optional[Report]: """获取现有报告""" result = await self.db.execute( select(Report).where( Report.symbol == symbol, Report.market == market ) ) return result.scalar_one_or_none() async def _create_new_report(self, symbol: str, market: str) -> Report: """创建新报告""" report = Report( symbol=symbol, market=market, status="generating" ) self.db.add(report) await self.db.flush() return report async def _cleanup_existing_modules(self, report_id: UUID): """清理现有的分析模块""" result = await self.db.execute( select(AnalysisModule).where(AnalysisModule.report_id == report_id) ) modules = result.scalars().all() for module in modules: await self.db.delete(module) await self.db.flush() async def _generate_report_content(self, report: Report): """生成报告内容（异步执行）""" try: logger.info(f"开始生成报告内容: {report.symbol} ({report.market})") # 开始初始化步骤 await self.progress_tracker.start_step(report.id, "初始化报告") # 创建分析模块记录 await self._create_analysis_modules(report) await self.progress_tracker.complete_step(report.id, "初始化报告", True) # 获取配置 data_source_config = await self.config_manager.get_data_source_config(report.market) gemini_config = await self.config_manager.get_gemini_config() # 创建数据获取器和AI分析器 data_fetcher = DataFetcherFactory.create_fetcher( data_source_config["type"], data_source_config ) ai_analyzer = AIAnalyzerFactory.create_gemini_analyzer( gemini_config["api_key"], gemini_config ) # 存储分析结果的上下文 analysis_context = {} # 按顺序执行各个分析模块 for module_config in self.analysis_modules: try: await self._execute_analysis_module( report, module_config, data_fetcher, ai_analyzer, analysis_context ) except Exception as e: logger.error(f"分析模块执行失败: {module_config['type']} - {str(e)}") # 标记模块为失败，但继续执行其他模块 await self._mark_module_failed(report.id, module_config["type"], str(e)) # 完成报告生成 await self.progress_tracker.start_step(report.id, "保存报告") report.status = "completed" report.updated_at = datetime.utcnow() await self.db.commit() await self.progress_tracker.complete_step(report.id, "保存报告", True) logger.info(f"报告生成完成: {report.symbol} ({report.market})") except Exception as e: logger.error(f"报告生成过程失败: {report.symbol} ({report.market}) - {str(e)}") # 标记报告为失败状态 report.status = "failed" report.updated_at = datetime.utcnow() await self.db.commit() # 标记当前步骤为失败 try: progress = await self.progress_tracker.get_progress(report.id) current_step = progress.current_step_name await self.progress_tracker.complete_step(report.id, current_step, False, str(e)) except Exception: pass # 忽略进度更新失败 async def _create_analysis_modules(self, report: Report): """创建分析模块记录""" for module_config in self.analysis_modules: module = AnalysisModule( report_id=report.id, module_type=module_config["type"], module_order=module_config["order"], title=module_config["title"], status="pending" ) self.db.add(module) await self.db.flush() async def _execute_analysis_module( self, report: Report, module_config: Dict[str, Any], data_fetcher, ai_analyzer, analysis_context: Dict[str, Any] ): """执行单个分析模块""" module_type = module_config["type"] step_name = module_config["step_name"] logger.info(f"执行分析模块: {module_type}") # 开始步骤 await self.progress_tracker.start_step(report.id, step_name) # 标记模块开始 await self._mark_module_started(report.id, module_type) try: # 根据模块类型执行相应的分析 if module_type == AnalysisModuleType.FINANCIAL_DATA: content = await self._execute_financial_data_module( report.symbol, report.market, data_fetcher ) analysis_context["financial_data"] = content elif module_type == AnalysisModuleType.TRADING_VIEW_CHART: content = await self._execute_trading_view_module( report.symbol, report.market ) elif module_type == AnalysisModuleType.BUSINESS_INFO: content = await self._execute_business_info_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["business_info"] = content elif module_type == AnalysisModuleType.FUNDAMENTAL_ANALYSIS: content = await self._execute_fundamental_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["fundamental_analysis"] = content elif module_type == AnalysisModuleType.BULLISH_ANALYSIS: content = await self._execute_bullish_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["bullish_analysis"] = content elif module_type == AnalysisModuleType.BEARISH_ANALYSIS: content = await self._execute_bearish_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["bearish_analysis"] = content elif module_type == AnalysisModuleType.MARKET_ANALYSIS: content = await self._execute_market_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["market_analysis"] = content elif module_type == AnalysisModuleType.NEWS_ANALYSIS: content = await self._execute_news_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["news_analysis"] = content elif module_type == AnalysisModuleType.TRADING_ANALYSIS: content = await self._execute_trading_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["trading_analysis"] = content elif module_type == AnalysisModuleType.INSIDER_ANALYSIS: content = await self._execute_insider_analysis_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["insider_analysis"] = content elif module_type == AnalysisModuleType.FINAL_CONCLUSION: content = await self._execute_final_conclusion_module( report.symbol, report.market, ai_analyzer, analysis_context ) analysis_context["final_conclusion"] = content else: raise ReportGenerationError(f"未知的分析模块类型: {module_type}") # 保存模块内容 await self._save_module_content(report.id, module_type, content) # 标记模块完成 await self._mark_module_completed(report.id, module_type) # 完成步骤 await self.progress_tracker.complete_step(report.id, step_name, True) except Exception as e: logger.error(f"分析模块执行失败: {module_type} - {str(e)}") # 标记模块失败 await self._mark_module_failed(report.id, module_type, str(e)) # 完成步骤（失败） await self.progress_tracker.complete_step(report.id, step_name, False, str(e)) raise e async def _execute_financial_data_module(self, symbol: str, market: str, data_fetcher) -> Dict[str, Any]: """执行财务数据分析模块""" try: # 获取财务数据 financial_data = await data_fetcher.fetch_financial_data(symbol, market) # 获取市场数据 market_data = await data_fetcher.fetch_market_data(symbol, market) return { "financial_data": financial_data.dict(), "market_data": market_data.dict(), "summary": { "data_source": financial_data.data_source, "last_updated": financial_data.last_updated.isoformat(), "data_quality": "good" # 可以添加数据质量评估逻辑 } } except Exception as e: raise DataSourceError(f"财务数据获取失败: {str(e)}") async def _execute_trading_view_module(self, symbol: str, market: str) -> Dict[str, Any]: """执行TradingView图表模块""" # 生成TradingView图表配置 return { "chart_config": { "symbol": symbol, "market": market, "interval": "1D", "theme": "light", "style": "1", # 蜡烛图 "toolbar_bg": "#f1f3f6", "enable_publishing": False, "withdateranges": True, "hide_side_toolbar": False, "allow_symbol_change": False, "studies": [ "MASimple@tv-basicstudies", # 移动平均线 "Volume@tv-basicstudies" # 成交量 ] }, "display_settings": { "width": "100%", "height": 500, "autosize": True } } async def _execute_business_info_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行业务信息分析模块""" try: financial_data = analysis_context.get("financial_data", {}) result = await ai_analyzer.analyze_business_info(symbol, market, financial_data) return result.content except Exception as e: raise AIAnalysisError(f"业务信息分析失败: {str(e)}") async def _execute_fundamental_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行基本面分析模块""" try: financial_data = analysis_context.get("financial_data", {}) business_info = analysis_context.get("business_info", {}) result = await ai_analyzer.analyze_fundamental(symbol, market, financial_data, business_info) return result.content except Exception as e: raise AIAnalysisError(f"基本面分析失败: {str(e)}") async def _execute_bullish_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行看涨分析模块""" try: result = await ai_analyzer.analyze_bullish_case(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"看涨分析失败: {str(e)}") async def _execute_bearish_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行看跌分析模块""" try: result = await ai_analyzer.analyze_bearish_case(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"看跌分析失败: {str(e)}") async def _execute_market_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行市场分析模块""" try: result = await ai_analyzer.analyze_market_sentiment(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"市场分析失败: {str(e)}") async def _execute_news_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行新闻分析模块""" try: result = await ai_analyzer.analyze_news_catalysts(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"新闻分析失败: {str(e)}") async def _execute_trading_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行交易分析模块""" try: result = await ai_analyzer.analyze_trading_dynamics(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"交易分析失败: {str(e)}") async def _execute_insider_analysis_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行内部人分析模块""" try: result = await ai_analyzer.analyze_insider_institutional(symbol, market, analysis_context) return result.content except Exception as e: raise AIAnalysisError(f"内部人分析失败: {str(e)}") async def _execute_final_conclusion_module(self, symbol: str, market: str, ai_analyzer, analysis_context: Dict[str, Any]) -> Dict[str, Any]: """执行最终结论模块""" try: # 收集所有分析结果 all_analyses = [] for key, value in analysis_context.items(): if key != "financial_data": # 排除原始财务数据 all_analyses.append({ "analysis_type": key, "content": value }) result = await ai_analyzer.generate_final_conclusion(symbol, market, all_analyses) return result.content except Exception as e: raise AIAnalysisError(f"最终结论生成失败: {str(e)}") async def _mark_module_started(self, report_id: UUID, module_type: str): """标记模块开始""" result = await self.db.execute( select(AnalysisModule).where( AnalysisModule.report_id == report_id, AnalysisModule.module_type == module_type ) ) module = result.scalar_one_or_none() if module: module.status = "running" module.started_at = datetime.utcnow() await self.db.flush() async def _mark_module_completed(self, report_id: UUID, module_type: str): """标记模块完成""" result = await self.db.execute( select(AnalysisModule).where( AnalysisModule.report_id == report_id, AnalysisModule.module_type == module_type ) ) module = result.scalar_one_or_none() if module: module.status = "completed" module.completed_at = datetime.utcnow() await self.db.flush() async def _mark_module_failed(self, report_id: UUID, module_type: str, error_message: str): """标记模块失败""" result = await self.db.execute( select(AnalysisModule).where( AnalysisModule.report_id == report_id, AnalysisModule.module_type == module_type ) ) module = result.scalar_one_or_none() if module: module.status = "failed" module.completed_at = datetime.utcnow() module.error_message = error_message await self.db.flush() async def _save_module_content(self, report_id: UUID, module_type: str, content: Dict[str, Any]): """保存模块内容""" result = await self.db.execute( select(AnalysisModule).where( AnalysisModule.report_id == report_id, AnalysisModule.module_type == module_type ) ) module = result.scalar_one_or_none() if module: module.content = content await self.db.flush() async def _build_report_response(self, report: Report) -> ReportResponse: """构建报告响应""" # 获取分析模块 result = await self.db.execute( select(AnalysisModule) .where(AnalysisModule.report_id == report.id) .order_by(AnalysisModule.module_order) ) modules = result.scalars().all() # 转换为响应模式 module_schemas = [ AnalysisModuleSchema( id=module.id, module_type=module.module_type, module_order=module.module_order, title=module.title, content=module.content, status=module.status, started_at=module.started_at, completed_at=module.completed_at, error_message=module.error_message ) for module in modules ] return ReportResponse( id=report.id, symbol=report.symbol, market=report.market, status=report.status, created_at=report.created_at, updated_at=report.updated_at, analysis_modules=module_schemas )