798 lines
31 KiB
Python
798 lines
31 KiB
Python
"""
|
||
API router for financial data (Tushare for China market)
|
||
"""
|
||
import json
|
||
import os
|
||
import time
|
||
from datetime import datetime, timezone, timedelta
|
||
from typing import Dict, List
|
||
|
||
from fastapi import APIRouter, HTTPException, Query
|
||
from fastapi.responses import StreamingResponse
|
||
|
||
from app.core.config import settings
|
||
from app.schemas.financial import (
|
||
BatchFinancialDataResponse,
|
||
FinancialConfigResponse,
|
||
FinancialMeta,
|
||
StepRecord,
|
||
CompanyProfileResponse,
|
||
AnalysisResponse,
|
||
AnalysisConfigResponse
|
||
)
|
||
from app.services.company_profile_client import CompanyProfileClient
|
||
from app.services.analysis_client import AnalysisClient, load_analysis_config, get_analysis_config
|
||
from app.services.financial_calculator import calculate_derived_metrics
|
||
|
||
# Lazy DataManager loader to avoid import-time failures when optional providers/config are missing
|
||
_dm = None
|
||
def get_dm():
|
||
global _dm
|
||
if _dm is not None:
|
||
return _dm
|
||
try:
|
||
from app.data_manager import data_manager as real_dm
|
||
_dm = real_dm
|
||
return _dm
|
||
except Exception:
|
||
class _StubDM:
|
||
config = {}
|
||
async def get_stock_basic(self, stock_code: str):
|
||
return None
|
||
async def get_financial_statements(self, stock_code: str, report_dates):
|
||
return []
|
||
_dm = _StubDM()
|
||
return _dm
|
||
|
||
router = APIRouter()
|
||
|
||
# Load metric config from file (project root is repo root, not backend/)
|
||
# routers/ -> app/ -> backend/ -> repo root
|
||
REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
|
||
FINANCIAL_CONFIG_PATH = os.path.join(REPO_ROOT, "config", "financial-tushare.json")
|
||
BASE_CONFIG_PATH = os.path.join(REPO_ROOT, "config", "config.json")
|
||
ANALYSIS_CONFIG_PATH = os.path.join(REPO_ROOT, "config", "analysis-config.json")
|
||
|
||
|
||
def _load_json(path: str) -> Dict:
|
||
if not os.path.exists(path):
|
||
return {}
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
return json.load(f)
|
||
except Exception:
|
||
return {}
|
||
|
||
|
||
@router.get("/data-sources", response_model=Dict[str, List[str]])
|
||
async def get_data_sources():
|
||
"""
|
||
Get the list of data sources that require an API key from the config.
|
||
"""
|
||
try:
|
||
data_sources_config = get_dm().config.get("data_sources", {})
|
||
sources_requiring_keys = [
|
||
source for source, config in data_sources_config.items()
|
||
if config.get("api_key_env")
|
||
]
|
||
return {"sources": sources_requiring_keys}
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"Failed to load data sources configuration: {e}")
|
||
|
||
|
||
@router.post("/china/{ts_code}/analysis", response_model=List[AnalysisResponse])
|
||
async def generate_full_analysis(
|
||
ts_code: str,
|
||
company_name: str = Query(None, description="Company name for better context"),
|
||
):
|
||
"""
|
||
Generate a full analysis report by orchestrating multiple analysis modules
|
||
based on dependencies defined in the configuration.
|
||
"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
logger.info(f"[API] Full analysis requested for {ts_code}")
|
||
|
||
# Load base and analysis configurations
|
||
base_cfg = _load_json(BASE_CONFIG_PATH)
|
||
llm_provider = base_cfg.get("llm", {}).get("provider", "gemini")
|
||
llm_config = base_cfg.get("llm", {}).get(llm_provider, {})
|
||
|
||
api_key = llm_config.get("api_key")
|
||
base_url = llm_config.get("base_url")
|
||
|
||
if not api_key:
|
||
logger.error(f"[API] API key for {llm_provider} not configured")
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"API key for {llm_provider} not configured."
|
||
)
|
||
|
||
analysis_config_full = load_analysis_config()
|
||
modules_config = analysis_config_full.get("analysis_modules", {})
|
||
if not modules_config:
|
||
raise HTTPException(status_code=404, detail="Analysis modules configuration not found.")
|
||
|
||
# --- Dependency Resolution (Topological Sort) ---
|
||
def topological_sort(graph):
|
||
in_degree = {u: 0 for u in graph}
|
||
for u in graph:
|
||
for v in graph[u]:
|
||
in_degree[v] += 1
|
||
|
||
queue = [u for u in graph if in_degree[u] == 0]
|
||
sorted_order = []
|
||
|
||
while queue:
|
||
u = queue.pop(0)
|
||
sorted_order.append(u)
|
||
for v in graph.get(u, []):
|
||
in_degree[v] -= 1
|
||
if in_degree[v] == 0:
|
||
queue.append(v)
|
||
|
||
if len(sorted_order) == len(graph):
|
||
return sorted_order
|
||
else:
|
||
# Detect cycles and provide a meaningful error
|
||
cycles = []
|
||
visited = set()
|
||
path = []
|
||
|
||
def find_cycle_util(node):
|
||
visited.add(node)
|
||
path.append(node)
|
||
for neighbor in graph.get(node, []):
|
||
if neighbor in path:
|
||
cycle_start_index = path.index(neighbor)
|
||
cycles.append(path[cycle_start_index:] + [neighbor])
|
||
return
|
||
if neighbor not in visited:
|
||
find_cycle_util(neighbor)
|
||
path.pop()
|
||
|
||
for node in graph:
|
||
if node not in visited:
|
||
find_cycle_util(node)
|
||
|
||
return None, cycles
|
||
|
||
|
||
# Build dependency graph
|
||
dependency_graph = {
|
||
name: config.get("dependencies", [])
|
||
for name, config in modules_config.items()
|
||
}
|
||
|
||
# Invert graph for topological sort (from dependency to dependent)
|
||
adj_list = {u: [] for u in dependency_graph}
|
||
for u, dependencies in dependency_graph.items():
|
||
for dep in dependencies:
|
||
if dep in adj_list:
|
||
adj_list[dep].append(u)
|
||
|
||
sorted_modules, cycle = topological_sort(adj_list)
|
||
if not sorted_modules:
|
||
raise HTTPException(
|
||
status_code=400,
|
||
detail=f"Circular dependency detected in analysis modules configuration. Cycle: {cycle}"
|
||
)
|
||
|
||
# --- Fetch common data (company name, financial data) ---
|
||
# This logic is duplicated, could be refactored into a helper
|
||
financial_data = None
|
||
if not company_name:
|
||
logger.info(f"[API] Fetching company name for {ts_code}")
|
||
try:
|
||
basic_data = await get_dm().get_stock_basic(stock_code=ts_code)
|
||
if basic_data:
|
||
company_name = basic_data.get("name", ts_code)
|
||
logger.info(f"[API] Got company name: {company_name}")
|
||
else:
|
||
company_name = ts_code
|
||
except Exception as e:
|
||
logger.warning(f"Failed to get company name, proceeding with ts_code. Error: {e}")
|
||
company_name = ts_code
|
||
|
||
# --- Execute modules in order ---
|
||
analysis_results = []
|
||
completed_modules_content = {}
|
||
|
||
for module_type in sorted_modules:
|
||
module_config = modules_config[module_type]
|
||
logger.info(f"[Orchestrator] Starting analysis for module: {module_type}")
|
||
|
||
client = AnalysisClient(
|
||
api_key=api_key,
|
||
base_url=base_url,
|
||
model=module_config.get("model", "gemini-1.5-flash")
|
||
)
|
||
|
||
# Gather context from completed dependencies
|
||
context = {
|
||
dep: completed_modules_content.get(dep, "")
|
||
for dep in module_config.get("dependencies", [])
|
||
}
|
||
|
||
result = await client.generate_analysis(
|
||
analysis_type=module_type,
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
prompt_template=module_config.get("prompt_template", ""),
|
||
financial_data=financial_data,
|
||
context=context,
|
||
)
|
||
|
||
response = AnalysisResponse(
|
||
ts_code=ts_code,
|
||
company_name=company_name,
|
||
analysis_type=module_type,
|
||
content=result.get("content", ""),
|
||
model=result.get("model", module_config.get("model")),
|
||
tokens=result.get("tokens", {}),
|
||
elapsed_ms=result.get("elapsed_ms", 0),
|
||
success=result.get("success", False),
|
||
error=result.get("error")
|
||
)
|
||
|
||
analysis_results.append(response)
|
||
|
||
if response.success:
|
||
completed_modules_content[module_type] = response.content
|
||
else:
|
||
# If a module fails, subsequent dependent modules will get an empty string for its context.
|
||
# This prevents total failure but may affect quality.
|
||
completed_modules_content[module_type] = f"Error: Analysis for {module_type} failed."
|
||
logger.error(f"[Orchestrator] Module {module_type} failed: {response.error}")
|
||
|
||
logger.info(f"[API] Full analysis for {ts_code} completed.")
|
||
return analysis_results
|
||
|
||
|
||
@router.get("/config", response_model=FinancialConfigResponse)
|
||
async def get_financial_config():
|
||
data = _load_json(FINANCIAL_CONFIG_PATH)
|
||
api_groups = data.get("api_groups", {})
|
||
return FinancialConfigResponse(api_groups=api_groups)
|
||
|
||
|
||
@router.get("/china/{ts_code}", response_model=BatchFinancialDataResponse)
|
||
async def get_china_financials(
|
||
ts_code: str,
|
||
years: int = Query(5, ge=1, le=15),
|
||
):
|
||
# Load metric config
|
||
fin_cfg = _load_json(FINANCIAL_CONFIG_PATH)
|
||
api_groups: Dict[str, List[Dict]] = fin_cfg.get("api_groups", {})
|
||
|
||
# Meta tracking
|
||
started_real = datetime.now(timezone.utc)
|
||
started = time.perf_counter_ns()
|
||
api_calls_total = 0 # This will be harder to track now, maybe DataManager should provide it
|
||
api_calls_by_group: Dict[str, int] = {}
|
||
steps: List[StepRecord] = []
|
||
|
||
# Get company name
|
||
company_name = ts_code
|
||
try:
|
||
basic_data = await get_dm().get_stock_basic(stock_code=ts_code)
|
||
if basic_data:
|
||
company_name = basic_data.get("name", ts_code)
|
||
except Exception:
|
||
pass # Continue without it
|
||
|
||
# Collect series per metric key
|
||
series: Dict[str, List[Dict]] = {}
|
||
errors: Dict[str, str] = {}
|
||
|
||
# Generate date range for financial statements
|
||
current_year = datetime.now().year
|
||
report_dates = [f"{year}1231" for year in range(current_year - years, current_year + 1)]
|
||
|
||
# Fetch all financial statements at once
|
||
step_financials = StepRecord(name="拉取财务报表", start_ts=started_real.isoformat(), status="running")
|
||
steps.append(step_financials)
|
||
|
||
# Fetch all financial statements at once (already in series format from provider)
|
||
series = await get_dm().get_financial_statements(stock_code=ts_code, report_dates=report_dates)
|
||
|
||
if not series:
|
||
errors["financial_statements"] = "Failed to fetch from all providers."
|
||
|
||
step_financials.status = "done"
|
||
step_financials.end_ts = datetime.now(timezone.utc).isoformat()
|
||
step_financials.duration_ms = int((time.perf_counter_ns() - started) / 1_000_000)
|
||
|
||
# --- 拉取市值/估值（daily_basic）与股价（daily）按年度末日期 ---
|
||
try:
|
||
# 仅当配置包含相应分组时再尝试拉取
|
||
has_daily_basic = bool(api_groups.get("daily_basic"))
|
||
has_daily = bool(api_groups.get("daily"))
|
||
|
||
if has_daily_basic or has_daily:
|
||
step_market = StepRecord(name="拉取市值与股价", start_ts=datetime.now(timezone.utc).isoformat(), status="running")
|
||
steps.append(step_market)
|
||
|
||
try:
|
||
if has_daily_basic:
|
||
db_rows = await get_dm().get_data('get_daily_basic_points', stock_code=ts_code, trade_dates=report_dates)
|
||
if isinstance(db_rows, list):
|
||
for row in db_rows:
|
||
trade_date = row.get('trade_date') or row.get('trade_dt') or row.get('date')
|
||
if not trade_date:
|
||
continue
|
||
year = str(trade_date)[:4]
|
||
for key, value in row.items():
|
||
if key in ['ts_code', 'trade_date', 'trade_dt', 'date']:
|
||
continue
|
||
if isinstance(value, (int, float)) and value is not None:
|
||
if key not in series:
|
||
series[key] = []
|
||
if not any(d['year'] == year for d in series[key]):
|
||
series[key].append({"year": year, "value": value})
|
||
if has_daily:
|
||
d_rows = await get_dm().get_data('get_daily_points', stock_code=ts_code, trade_dates=report_dates)
|
||
if isinstance(d_rows, list):
|
||
for row in d_rows:
|
||
trade_date = row.get('trade_date') or row.get('trade_dt') or row.get('date')
|
||
if not trade_date:
|
||
continue
|
||
year = str(trade_date)[:4]
|
||
for key, value in row.items():
|
||
if key in ['ts_code', 'trade_date', 'trade_dt', 'date']:
|
||
continue
|
||
if isinstance(value, (int, float)) and value is not None:
|
||
if key not in series:
|
||
series[key] = []
|
||
if not any(d['year'] == year for d in series[key]):
|
||
series[key].append({"year": year, "value": value})
|
||
except Exception as e:
|
||
errors["market_data"] = f"Failed to fetch market data: {e}"
|
||
finally:
|
||
step_market.status = "done"
|
||
step_market.end_ts = datetime.now(timezone.utc).isoformat()
|
||
step_market.duration_ms = int((time.perf_counter_ns() - started) / 1_000_000)
|
||
except Exception as e:
|
||
errors["market_data_init"] = f"Market data init failed: {e}"
|
||
|
||
finished_real = datetime.now(timezone.utc)
|
||
elapsed_ms = int((time.perf_counter_ns() - started) / 1_000_000)
|
||
|
||
if not series:
|
||
raise HTTPException(status_code=502, detail={"message": "No data returned from any data source", "errors": errors})
|
||
|
||
# Truncate years and sort (the data should already be mostly correct, but we ensure)
|
||
for key, arr in series.items():
|
||
# Deduplicate and sort desc by year, then cut to requested years, and return asc
|
||
uniq = {item["year"]: item for item in arr}
|
||
arr_sorted_desc = sorted(uniq.values(), key=lambda x: x["year"], reverse=True)
|
||
arr_limited = arr_sorted_desc[:years]
|
||
arr_sorted = sorted(arr_limited, key=lambda x: x["year"])
|
||
series[key] = arr_sorted
|
||
|
||
# Calculate derived financial metrics
|
||
series = calculate_derived_metrics(series, years_list)
|
||
|
||
meta = FinancialMeta(
|
||
started_at=started_real.isoformat(),
|
||
finished_at=finished_real.isoformat(),
|
||
elapsed_ms=elapsed_ms,
|
||
api_calls_total=api_calls_total,
|
||
api_calls_by_group=api_calls_by_group,
|
||
current_action=None,
|
||
steps=steps,
|
||
)
|
||
|
||
return BatchFinancialDataResponse(ts_code=ts_code, name=company_name, series=series, meta=meta)
|
||
|
||
|
||
@router.get("/china/{ts_code}/company-profile", response_model=CompanyProfileResponse)
|
||
async def get_company_profile(
|
||
ts_code: str,
|
||
company_name: str = Query(None, description="Company name for better context"),
|
||
):
|
||
"""
|
||
Get company profile for a company using Gemini AI (non-streaming, single response)
|
||
"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
logger.info(f"[API] Company profile requested for {ts_code}")
|
||
|
||
# Load config
|
||
base_cfg = _load_json(BASE_CONFIG_PATH)
|
||
llm_provider = base_cfg.get("llm", {}).get("provider", "gemini")
|
||
llm_config = base_cfg.get("llm", {}).get(llm_provider, {})
|
||
|
||
api_key = llm_config.get("api_key")
|
||
base_url = llm_config.get("base_url") # Will be None if not set, handled by client
|
||
|
||
if not api_key:
|
||
logger.error(f"[API] API key for {llm_provider} not configured")
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"API key for {llm_provider} not configured."
|
||
)
|
||
|
||
client = CompanyProfileClient(
|
||
api_key=api_key,
|
||
base_url=base_url,
|
||
model="gemini-1.5-flash"
|
||
)
|
||
|
||
# Get company name from ts_code if not provided
|
||
if not company_name:
|
||
logger.info(f"[API] Fetching company name for {ts_code}")
|
||
# Try to get from stock_basic API
|
||
try:
|
||
basic_data = await get_dm().get_stock_basic(stock_code=ts_code)
|
||
if basic_data:
|
||
company_name = basic_data.get("name", ts_code)
|
||
logger.info(f"[API] Got company name: {company_name}")
|
||
else:
|
||
company_name = ts_code
|
||
except Exception as e:
|
||
logger.warning(f"[API] Failed to get company name: {e}")
|
||
company_name = ts_code
|
||
|
||
logger.info(f"[API] Generating profile for {company_name}")
|
||
|
||
# Generate profile using non-streaming API
|
||
result = await client.generate_profile(
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
financial_data=None
|
||
)
|
||
|
||
logger.info(f"[API] Profile generation completed, success={result.get('success')}")
|
||
|
||
return CompanyProfileResponse(
|
||
ts_code=ts_code,
|
||
company_name=company_name,
|
||
content=result.get("content", ""),
|
||
model=result.get("model", "gemini-2.5-flash"),
|
||
tokens=result.get("tokens", {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}),
|
||
elapsed_ms=result.get("elapsed_ms", 0),
|
||
success=result.get("success", False),
|
||
error=result.get("error")
|
||
)
|
||
|
||
|
||
@router.get("/analysis-config", response_model=AnalysisConfigResponse)
|
||
async def get_analysis_config_endpoint():
|
||
"""Get analysis configuration"""
|
||
config = load_analysis_config()
|
||
return AnalysisConfigResponse(analysis_modules=config.get("analysis_modules", {}))
|
||
|
||
|
||
@router.put("/analysis-config", response_model=AnalysisConfigResponse)
|
||
async def update_analysis_config_endpoint(analysis_config: AnalysisConfigResponse):
|
||
"""Update analysis configuration"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
try:
|
||
# 保存到文件
|
||
config_data = {
|
||
"analysis_modules": analysis_config.analysis_modules
|
||
}
|
||
|
||
with open(ANALYSIS_CONFIG_PATH, "w", encoding="utf-8") as f:
|
||
json.dump(config_data, f, ensure_ascii=False, indent=2)
|
||
|
||
logger.info(f"[API] Analysis config updated successfully")
|
||
return AnalysisConfigResponse(analysis_modules=analysis_config.analysis_modules)
|
||
except Exception as e:
|
||
logger.error(f"[API] Failed to update analysis config: {e}")
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"Failed to update analysis config: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.get("/china/{ts_code}/analysis/{analysis_type}", response_model=AnalysisResponse)
|
||
async def generate_analysis(
|
||
ts_code: str,
|
||
analysis_type: str,
|
||
company_name: str = Query(None, description="Company name for better context"),
|
||
):
|
||
"""
|
||
Generate analysis for a company using Gemini AI
|
||
Supported analysis types:
|
||
- fundamental_analysis (基本面分析)
|
||
- bull_case (看涨分析)
|
||
- bear_case (看跌分析)
|
||
- market_analysis (市场分析)
|
||
- news_analysis (新闻分析)
|
||
- trading_analysis (交易分析)
|
||
- insider_institutional (内部人与机构动向分析)
|
||
- final_conclusion (最终结论)
|
||
"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
logger.info(f"[API] Analysis requested for {ts_code}, type: {analysis_type}")
|
||
|
||
# Load config
|
||
base_cfg = _load_json(BASE_CONFIG_PATH)
|
||
llm_provider = base_cfg.get("llm", {}).get("provider", "gemini")
|
||
llm_config = base_cfg.get("llm", {}).get(llm_provider, {})
|
||
|
||
api_key = llm_config.get("api_key")
|
||
base_url = llm_config.get("base_url")
|
||
|
||
if not api_key:
|
||
logger.error(f"[API] API key for {llm_provider} not configured")
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"API key for {llm_provider} not configured."
|
||
)
|
||
|
||
# Get analysis configuration
|
||
analysis_cfg = get_analysis_config(analysis_type)
|
||
if not analysis_cfg:
|
||
raise HTTPException(
|
||
status_code=404,
|
||
detail=f"Analysis type '{analysis_type}' not found in configuration"
|
||
)
|
||
|
||
model = analysis_cfg.get("model", "gemini-2.5-flash")
|
||
prompt_template = analysis_cfg.get("prompt_template", "")
|
||
|
||
if not prompt_template:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"Prompt template not found for analysis type '{analysis_type}'"
|
||
)
|
||
|
||
# Get company name from ts_code if not provided
|
||
financial_data = None
|
||
if not company_name:
|
||
logger.info(f"[API] Fetching company name and financial data for {ts_code}")
|
||
try:
|
||
basic_data = await get_dm().get_stock_basic(stock_code=ts_code)
|
||
if basic_data:
|
||
company_name = basic_data.get("name", ts_code)
|
||
logger.info(f"[API] Got company name: {company_name}")
|
||
|
||
# Try to get financial data for context
|
||
try:
|
||
# A simplified approach to get a single financial report
|
||
current_year = datetime.now().year
|
||
report_dates = [f"{current_year-1}1231"] # Get last year's report
|
||
# Use get_financial_statement which is designed to return a single flat report
|
||
latest_financials_report = await get_dm().get_financial_statement(
|
||
stock_code=ts_code,
|
||
report_dates=report_dates[0]
|
||
)
|
||
if latest_financials_report:
|
||
financial_data = {"series": latest_financials_report}
|
||
except Exception as e:
|
||
logger.warning(f"[API] Failed to get financial data: {e}")
|
||
financial_data = None
|
||
else:
|
||
company_name = ts_code
|
||
except Exception as e:
|
||
logger.warning(f"[API] Failed to get company name: {e}")
|
||
company_name = ts_code
|
||
|
||
logger.info(f"[API] Generating {analysis_type} for {company_name}")
|
||
|
||
# Initialize analysis client with configured model
|
||
client = AnalysisClient(api_key=api_key, base_url=base_url, model=model)
|
||
|
||
# Prepare dependency context for single-module generation
|
||
# If the requested module declares dependencies, generate them first and inject their outputs
|
||
context = {}
|
||
try:
|
||
dependencies = analysis_cfg.get("dependencies", []) or []
|
||
if dependencies:
|
||
# Load full modules config to resolve dependency graph
|
||
analysis_config_full = load_analysis_config()
|
||
modules_config = analysis_config_full.get("analysis_modules", {})
|
||
|
||
# Collect all transitive dependencies
|
||
all_required = set()
|
||
|
||
def collect_all_deps(mod_name: str):
|
||
for dep in modules_config.get(mod_name, {}).get("dependencies", []) or []:
|
||
if dep not in all_required:
|
||
all_required.add(dep)
|
||
collect_all_deps(dep)
|
||
|
||
for dep in dependencies:
|
||
all_required.add(dep)
|
||
collect_all_deps(dep)
|
||
|
||
# Build subgraph and topologically sort
|
||
graph = {name: [d for d in (modules_config.get(name, {}).get("dependencies", []) or []) if d in all_required] for name in all_required}
|
||
in_degree = {u: 0 for u in graph}
|
||
for u, deps in graph.items():
|
||
for v in deps:
|
||
in_degree[v] += 1
|
||
queue = [u for u, deg in in_degree.items() if deg == 0]
|
||
order = []
|
||
while queue:
|
||
u = queue.pop(0)
|
||
order.append(u)
|
||
for v in graph.get(u, []):
|
||
in_degree[v] -= 1
|
||
if in_degree[v] == 0:
|
||
queue.append(v)
|
||
if len(order) != len(graph):
|
||
# Fallback: if cycle detected, just use any order
|
||
order = list(all_required)
|
||
|
||
# Generate dependencies in order
|
||
completed = {}
|
||
for mod in order:
|
||
cfg = modules_config.get(mod, {})
|
||
dep_ctx = {d: completed.get(d, "") for d in (cfg.get("dependencies", []) or [])}
|
||
dep_client = AnalysisClient(api_key=api_key, base_url=base_url, model=cfg.get("model", model))
|
||
dep_result = await dep_client.generate_analysis(
|
||
analysis_type=mod,
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
prompt_template=cfg.get("prompt_template", ""),
|
||
financial_data=financial_data,
|
||
context=dep_ctx,
|
||
)
|
||
completed[mod] = dep_result.get("content", "") if dep_result.get("success") else ""
|
||
|
||
context = {dep: completed.get(dep, "") for dep in dependencies}
|
||
except Exception:
|
||
# Best-effort context; if anything goes wrong, continue without it
|
||
context = {}
|
||
|
||
# Generate analysis
|
||
result = await client.generate_analysis(
|
||
analysis_type=analysis_type,
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
prompt_template=prompt_template,
|
||
financial_data=financial_data,
|
||
context=context,
|
||
)
|
||
|
||
logger.info(f"[API] Analysis generation completed, success={result.get('success')}")
|
||
|
||
return AnalysisResponse(
|
||
ts_code=ts_code,
|
||
company_name=company_name,
|
||
analysis_type=analysis_type,
|
||
content=result.get("content", ""),
|
||
model=result.get("model", model),
|
||
tokens=result.get("tokens", {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}),
|
||
elapsed_ms=result.get("elapsed_ms", 0),
|
||
success=result.get("success", False),
|
||
error=result.get("error")
|
||
)
|
||
|
||
|
||
@router.get("/china/{ts_code}/analysis/{analysis_type}/stream")
|
||
async def stream_analysis(
|
||
ts_code: str,
|
||
analysis_type: str,
|
||
company_name: str = Query(None, description="Company name for better context"),
|
||
):
|
||
"""
|
||
Stream analysis content chunks for a given module using OpenAI-compatible streaming.
|
||
Plain text streaming (text/plain; utf-8). Dependencies are resolved first (non-stream),
|
||
then the target module content is streamed.
|
||
"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
logger.info(f"[API] Streaming analysis requested for {ts_code}, type: {analysis_type}")
|
||
|
||
# Load config
|
||
base_cfg = _load_json(BASE_CONFIG_PATH)
|
||
llm_provider = base_cfg.get("llm", {}).get("provider", "gemini")
|
||
llm_config = base_cfg.get("llm", {}).get(llm_provider, {})
|
||
|
||
api_key = llm_config.get("api_key")
|
||
base_url = llm_config.get("base_url")
|
||
|
||
if not api_key:
|
||
logger.error(f"[API] API key for {llm_provider} not configured")
|
||
raise HTTPException(status_code=500, detail=f"API key for {llm_provider} not configured.")
|
||
|
||
# Get analysis configuration
|
||
analysis_cfg = get_analysis_config(analysis_type)
|
||
if not analysis_cfg:
|
||
raise HTTPException(status_code=404, detail=f"Analysis type '{analysis_type}' not found in configuration")
|
||
|
||
model = analysis_cfg.get("model", "gemini-2.5-flash")
|
||
prompt_template = analysis_cfg.get("prompt_template", "")
|
||
if not prompt_template:
|
||
raise HTTPException(status_code=500, detail=f"Prompt template not found for analysis type '{analysis_type}'")
|
||
|
||
# Get company name from ts_code if not provided; we don't need full financials here
|
||
financial_data = None
|
||
if not company_name:
|
||
try:
|
||
basic_data = await get_dm().get_stock_basic(stock_code=ts_code)
|
||
if basic_data:
|
||
company_name = basic_data.get("name", ts_code)
|
||
else:
|
||
company_name = ts_code
|
||
except Exception:
|
||
company_name = ts_code
|
||
|
||
# Resolve dependency context (non-streaming)
|
||
context = {}
|
||
try:
|
||
dependencies = analysis_cfg.get("dependencies", []) or []
|
||
if dependencies:
|
||
analysis_config_full = load_analysis_config()
|
||
modules_config = analysis_config_full.get("analysis_modules", {})
|
||
|
||
all_required = set()
|
||
def collect_all(mod_name: str):
|
||
for dep in modules_config.get(mod_name, {}).get("dependencies", []) or []:
|
||
if dep not in all_required:
|
||
all_required.add(dep)
|
||
collect_all(dep)
|
||
for dep in dependencies:
|
||
all_required.add(dep)
|
||
collect_all(dep)
|
||
|
||
graph = {name: [d for d in (modules_config.get(name, {}).get("dependencies", []) or []) if d in all_required] for name in all_required}
|
||
in_degree = {u: 0 for u in graph}
|
||
for u, deps in graph.items():
|
||
for v in deps:
|
||
in_degree[v] += 1
|
||
queue = [u for u, deg in in_degree.items() if deg == 0]
|
||
order = []
|
||
while queue:
|
||
u = queue.pop(0)
|
||
order.append(u)
|
||
for v in graph.get(u, []):
|
||
in_degree[v] -= 1
|
||
if in_degree[v] == 0:
|
||
queue.append(v)
|
||
if len(order) != len(graph):
|
||
order = list(all_required)
|
||
|
||
completed = {}
|
||
for mod in order:
|
||
cfg = modules_config.get(mod, {})
|
||
dep_ctx = {d: completed.get(d, "") for d in (cfg.get("dependencies", []) or [])}
|
||
dep_client = AnalysisClient(api_key=api_key, base_url=base_url, model=cfg.get("model", model))
|
||
dep_result = await dep_client.generate_analysis(
|
||
analysis_type=mod,
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
prompt_template=cfg.get("prompt_template", ""),
|
||
financial_data=financial_data,
|
||
context=dep_ctx,
|
||
)
|
||
completed[mod] = dep_result.get("content", "") if dep_result.get("success") else ""
|
||
context = {dep: completed.get(dep, "") for dep in dependencies}
|
||
except Exception:
|
||
context = {}
|
||
|
||
client = AnalysisClient(api_key=api_key, base_url=base_url, model=model)
|
||
|
||
async def streamer():
|
||
# Optional header line to help client-side UI
|
||
header = f"# {analysis_cfg.get('name', analysis_type)}\n\n"
|
||
yield header
|
||
async for chunk in client.generate_analysis_stream(
|
||
analysis_type=analysis_type,
|
||
company_name=company_name,
|
||
ts_code=ts_code,
|
||
prompt_template=prompt_template,
|
||
financial_data=financial_data,
|
||
context=context,
|
||
):
|
||
yield chunk
|
||
|
||
headers = {
|
||
# 禁止中间层缓冲，确保尽快把分块推送给客户端
|
||
"Cache-Control": "no-cache, no-transform",
|
||
"X-Accel-Buffering": "no",
|
||
}
|
||
return StreamingResponse(streamer(), media_type="text/plain; charset=utf-8", headers=headers)
|