China Stock Analysis

#!/usr/bin/env python3
"""
A股数据获取模块
使用akshare获取股票财务数据、行情数据、股东信息等

依赖: pip install akshare pandas
"""

import argparse
import json
import sys
import time
import os
from datetime import datetime, timedelta
from typing import Optional, Callable
from functools import wraps

try:
    import akshare as ak
    import pandas as pd
except ImportError:
    print("错误: 请先安装依赖库")
    print("pip install akshare pandas")
    sys.exit(1)


def retry_on_failure(max_retries: int = 3, delay: float = 1.0):
    """网络请求重试装饰器"""
    def decorator(func: Callable):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    if attempt < max_retries - 1:
                        time.sleep(delay * (attempt + 1))  # 递增等待
            return {"error": f"重试{max_retries}次后失败: {str(last_error)}"}
        return wrapper
    return decorator


def safe_float(value) -> Optional[float]:
    """安全转换为浮点数"""
    if value is None or value == '' or value == '--':
        return None
    try:
        if pd.isna(value):
            return None
        if isinstance(value, str):
            value = value.replace('%', '').replace(',', '').replace('亿', '')
        return float(value)
    except (ValueError, TypeError):
        return None


def get_cache_path(code: str, data_type: str) -> str:
    """获取缓存文件路径"""
    cache_dir = os.path.join(os.path.dirname(__file__), '.cache')
    os.makedirs(cache_dir, exist_ok=True)
    today = datetime.now().strftime('%Y%m%d')
    return os.path.join(cache_dir, f"{code}_{data_type}_{today}.json")


def load_cache(code: str, data_type: str) -> Optional[dict]:
    """加载缓存数据（当天有效）"""
    cache_path = get_cache_path(code, data_type)
    if os.path.exists(cache_path):
        try:
            with open(cache_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except (json.JSONDecodeError, IOError):
            return None
    return None


def save_cache(code: str, data_type: str, data: dict):
    """保存缓存数据"""
    cache_path = get_cache_path(code, data_type)
    try:
        with open(cache_path, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, default=str)
    except IOError:
        pass


@retry_on_failure(max_retries=2, delay=1.0)
def get_stock_info(code: str) -> dict:
    """获取股票基本信息"""
    try:
        df = ak.stock_individual_info_em(symbol=code)
        info = {}
        for _, row in df.iterrows():
            info[row['item']] = row['value']
        return {
            "code": code,
            "name": info.get("股票简称", ""),
            "industry": info.get("行业", ""),
            "market_cap": safe_float(info.get("总市值")),
            "float_cap": safe_float(info.get("流通市值")),
            "total_shares": safe_float(info.get("总股本")),
            "float_shares": safe_float(info.get("流通股")),
            "pe_ttm": safe_float(info.get("市盈率(动态)")),
            "pb": safe_float(info.get("市净率")),
            "listing_date": info.get("上市时间", "")
        }
    except Exception as e:
        return {"code": code, "error": str(e)}


@retry_on_failure(max_retries=2, delay=1.0)
def get_financial_data(code: str, years: int = 3) -> dict:
    """获取财务数据（资产负债表、利润表、现金流量表）"""
    max_records = min(years * 4, 12)
    result = {
        "balance_sheet": [],
        "income_statement": [],
        "cash_flow": []
    }

    fetch_configs = [
        ("balance_sheet", ak.stock_balance_sheet_by_report_em),
        ("income_statement", ak.stock_profit_sheet_by_report_em),
        ("cash_flow", ak.stock_cash_flow_sheet_by_report_em),
    ]

    for key, fetch_func in fetch_configs:
        try:
            df = fetch_func(symbol=code)
            if df is not None and not df.empty:
                result[key] = df.head(max_records).to_dict(orient='records')
        except Exception as e:
            result[f"{key}_error"] = str(e)

    return result


def get_financial_indicators(code: str, limit: int = 8) -> dict:
    """获取财务指标，优先使用快速API，失败时降级到备用API"""
    apis = [ak.stock_financial_abstract, ak.stock_financial_analysis_indicator]

    for api in apis:
        try:
            df = api(symbol=code)
            if df is not None and not df.empty:
                return df.head(limit).to_dict(orient='records')
        except Exception:
            continue

    return []


def get_valuation_data(code: str) -> dict:
    """获取估值数据"""
    result = {}

    try:
        df = ak.stock_a_ttm_lyr(symbol=code)
        if df is None or df.empty:
            return result

        latest = df.iloc[-1].to_dict()
        result["latest"] = latest
        result["history_count"] = len(df)

        for col in ['pe_ttm', 'pb']:
            val = latest.get(col)
            if val and not pd.isna(val):
                result[f"{col}_percentile"] = (df[col].dropna() < val).mean() * 100

    except Exception as e:
        result["error"] = str(e)
        result["note"] = "估值历史数据获取失败，将使用基本信息中的估值"

    return result


@retry_on_failure(max_retries=2, delay=1.0)
def get_holder_data(code: str) -> dict:
    """获取股东信息"""
    result = {}

    try:
        df_top10 = ak.stock_gdfx_top_10_em(symbol=code)
        if df_top10 is not None and not df_top10.empty:
            result["top_10_holders"] = df_top10.head(10).to_dict(orient='records')
    except Exception as e:
        result["top_10_holders_error"] = str(e)

    try:
        df_holder_num = ak.stock_zh_a_gdhs(symbol=code)
        if df_holder_num is not None and not df_holder_num.empty:
            result["holder_count_history"] = df_holder_num.head(10).to_dict(orient='records')
    except Exception as e:
        result["holder_count_error"] = str(e)

    return result


@retry_on_failure(max_retries=2, delay=1.0)
def get_dividend_data(code: str) -> dict:
    """获取分红数据，优先使用主API，失败时降级到备用API"""
    apis = [
        lambda c: ak.stock_dividend_cninfo(symbol=c),
        lambda c: ak.stock_history_dividend_detail(symbol=c, indicator="分红"),
    ]

    for api in apis:
        try:
            df = api(code)
            if df is not None and not df.empty:
                return {
                    "dividend_history": df.to_dict(orient='records'),
                    "dividend_count": len(df)
                }
        except Exception:
            continue

    return {"dividend_history": [], "dividend_count": 0}


@retry_on_failure(max_retries=2, delay=1.0)
def get_price_data(code: str, days: int = 60) -> dict:
    """获取价格数据"""
    try:
        end_date = datetime.now().strftime('%Y%m%d')
        start_date = (datetime.now() - timedelta(days=days)).strftime('%Y%m%d')

        df = ak.stock_zh_a_hist(symbol=code, period="daily",
                                start_date=start_date, end_date=end_date, adjust="qfq")
        if df is not None and not df.empty:
            latest = df.iloc[-1]
            return {
                "latest_price": safe_float(latest['收盘']),
                "latest_date": str(latest['日期']),
                "price_change_pct": safe_float(latest['涨跌幅']),
                "volume": safe_float(latest['成交量']),
                "turnover": safe_float(latest['成交额']),
                "high_60d": safe_float(df['最高'].max()),
                "low_60d": safe_float(df['最低'].min()),
                "avg_volume_20d": safe_float(df.tail(20)['成交量'].mean()),
                "price_data": df.tail(30).to_dict(orient='records')  # 只保留30天
            }
        return {}
    except Exception as e:
        return {"error": str(e)}


@retry_on_failure(max_retries=2, delay=1.0)
def get_index_constituents(index_name: str) -> list:
    """获取指数成分股"""
    index_map = {
        "hs300": "000300",
        "zz500": "000905",
        "zz1000": "000852",
        "cyb": "399006",
        "kcb": "000688"
    }

    index_code = index_map.get(index_name)
    if not index_code:
        return []

    try:
        df = ak.index_stock_cons(symbol=index_code)
        if df is not None and not df.empty:
            return df['品种代码'].tolist()
        return []
    except Exception as e:
        print(f"获取指数成分股失败: {e}")
        return []


def get_all_a_stocks() -> list:
    """获取全部A股代码"""
    try:
        df = ak.stock_zh_a_spot_em()
        if df is not None and not df.empty:
            return df['代码'].tolist()
        return []
    except Exception as e:
        print(f"获取全部A股失败: {e}")
        return []


def fetch_stock_data(code: str, data_type: str = "all", years: int = 3, use_cache: bool = True) -> dict:
    """获取单只股票的数据"""
    # 尝试加载缓存
    if use_cache:
        cached = load_cache(code, data_type)
        if cached:
            print(f"使用缓存数据: {code}")
            return cached

    result = {
        "code": code,
        "fetch_time": datetime.now().isoformat(),
        "data_type": data_type
    }

    print(f"正在获取 {code} 的数据...")

    if data_type in ["all", "basic"]:
        print("  - 获取基本信息...")
        result["basic_info"] = get_stock_info(code)

    if data_type in ["all", "financial"]:
        print("  - 获取财务数据...")
        result["financial_data"] = get_financial_data(code, years)
        print("  - 获取财务指标...")
        result["financial_indicators"] = get_financial_indicators(code)

    if data_type in ["all", "valuation"]:
        print("  - 获取估值数据...")
        result["valuation"] = get_valuation_data(code)
        print("  - 获取价格数据...")
        result["price"] = get_price_data(code)

    if data_type in ["all", "holder"]:
        print("  - 获取股东数据...")
        result["holder"] = get_holder_data(code)
        print("  - 获取分红数据...")
        result["dividend"] = get_dividend_data(code)

    # 保存缓存
    if use_cache:
        save_cache(code, data_type, result)

    print(f"数据获取完成: {code}")
    return result


def fetch_multiple_stocks(codes: list, data_type: str = "basic") -> dict:
    """获取多只股票数据"""
    result = {
        "fetch_time": datetime.now().isoformat(),
        "stocks": [],
        "success_count": 0,
        "fail_count": 0
    }

    total = len(codes)
    for i, code in enumerate(codes):
        print(f"[{i+1}/{total}] 获取 {code}...")
        try:
            stock_data = fetch_stock_data(code, data_type, use_cache=True)
            if "error" not in stock_data.get("basic_info", {}):
                result["stocks"].append(stock_data)
                result["success_count"] += 1
            else:
                result["fail_count"] += 1
        except Exception as e:
            print(f"  获取失败: {e}")
            result["fail_count"] += 1

        # 避免请求过快
        if i < total - 1:
            time.sleep(0.5)

    return result


def main():
    parser = argparse.ArgumentParser(description="A股数据获取工具")
    parser.add_argument("--code", type=str, help="股票代码 (如: 600519)")
    parser.add_argument("--codes", type=str, help="多个股票代码，逗号分隔 (如: 600519,000858)")
    parser.add_argument("--data-type", type=str, default="basic",
                       choices=["all", "basic", "financial", "valuation", "holder"],
                       help="数据类型 (默认: basic)")
    parser.add_argument("--years", type=int, default=3, help="获取多少年的历史数据 (默认: 3)")
    parser.add_argument("--scope", type=str, help="筛选范围: hs300/zz500/cyb/kcb/all")
    parser.add_argument("--no-cache", action="store_true", help="不使用缓存")
    parser.add_argument("--output", type=str, help="输出文件路径 (JSON)")

    args = parser.parse_args()

    result = {}

    if args.code:
        result = fetch_stock_data(args.code, args.data_type, args.years,
                                   use_cache=not args.no_cache)
    elif args.codes:
        codes = [c.strip() for c in args.codes.split(",")]
        result = fetch_multiple_stocks(codes, args.data_type)
    elif args.scope:
        if args.scope == "all":
            codes = get_all_a_stocks()
        else:
            codes = get_index_constituents(args.scope)
        result = {"scope": args.scope, "stocks": codes, "count": len(codes)}
    else:
        print("请提供 --code, --codes 或 --scope 参数")
        sys.exit(1)

    # 输出结果
    output = json.dumps(result, ensure_ascii=False, indent=2, default=str)

    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            f.write(output)
        print(f"\n数据已保存到: {args.output}")
    else:
        print(output)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
A股财务分析模块
提供财务健康度分析、杜邦分析、异常检测等功能

依赖: pip install akshare pandas numpy
"""

import argparse
import json
import sys
from datetime import datetime
from typing import Optional, List, Dict

try:
    import pandas as pd
    import numpy as np
except ImportError:
    print("错误: 请先安装依赖库")
    print("pip install pandas numpy")
    sys.exit(1)


class FinancialAnalyzer:
    """财务分析器"""

    def __init__(self, stock_data: Dict = None):
        self.stock_data = stock_data or {}
        self.analysis_result = {}

    def load_data(self, file_path: str):
        """从JSON文件加载股票数据"""
        with open(file_path, 'r', encoding='utf-8') as f:
            self.stock_data = json.load(f)

    def _assess_roe(self, roe: float) -> str:
        """根据ROE评估盈利能力"""
        if roe > 20:
            return "优秀 - ROE超过20%，盈利能力很强"
        elif roe > 15:
            return "良好 - ROE在15-20%之间，盈利能力较强"
        elif roe > 10:
            return "一般 - ROE在10-15%之间，盈利能力中等"
        return "较弱 - ROE低于10%，盈利能力需要改善"

    def analyze_profitability(self) -> Dict:
        """盈利能力分析"""
        result = {
            "category": "盈利能力",
            "metrics": {},
            "trend": [],
            "assessment": ""
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if not indicators:
            return result

        metrics = {}
        for indicator in indicators[:8]:
            period = indicator.get('日期', '')
            if period:
                metrics[period] = {
                    "ROE": self._safe_float(indicator.get('净资产收益率', indicator.get('加权净资产收益率'))),
                    "ROA": self._safe_float(indicator.get('总资产报酬率')),
                    "毛利率": self._safe_float(indicator.get('销售毛利率')),
                    "净利率": self._safe_float(indicator.get('销售净利率'))
                }

        if not metrics:
            return result

        latest = list(metrics.values())[0]
        result["metrics"] = {
            "当前ROE": latest.get("ROE"),
            "当前ROA": latest.get("ROA"),
            "当前毛利率": latest.get("毛利率"),
            "当前净利率": latest.get("净利率")
        }

        roe_values = [v.get("ROE") for v in metrics.values() if v.get("ROE") is not None]
        if len(roe_values) >= 2:
            trend = "上升" if roe_values[0] > roe_values[-1] else "下降"
            result["trend"].append(f"ROE呈{trend}趋势")

        roe = latest.get("ROE")
        if roe:
            result["assessment"] = self._assess_roe(roe)

        return result

    def analyze_solvency(self) -> Dict:
        """偿债能力分析"""
        result = {
            "category": "偿债能力",
            "metrics": {},
            "risks": [],
            "assessment": ""
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if not indicators:
            return result

        latest = indicators[0]

        debt_ratio = self._safe_float(latest.get('资产负债率'))
        current_ratio = self._safe_float(latest.get('流动比率'))
        quick_ratio = self._safe_float(latest.get('速动比率'))

        result["metrics"] = {
            "资产负债率": debt_ratio,
            "流动比率": current_ratio,
            "速动比率": quick_ratio
        }

        # 风险评估
        risk_checks = [
            (debt_ratio and debt_ratio > 70, f"资产负债率偏高 ({debt_ratio:.1f}%)，需关注偿债压力"),
            (current_ratio and current_ratio < 1, f"流动比率偏低 ({current_ratio:.2f})，短期偿债能力较弱"),
            (quick_ratio and quick_ratio < 0.8, f"速动比率偏低 ({quick_ratio:.2f})，短期流动性风险"),
        ]
        result["risks"] = [msg for condition, msg in risk_checks if condition]

        # 综合评估
        risk_count = len(result["risks"])
        if risk_count == 0:
            result["assessment"] = "良好 - 偿债能力指标正常，财务结构稳健"
        elif risk_count == 1:
            result["assessment"] = "一般 - 存在一项风险指标，需持续关注"
        else:
            result["assessment"] = "较弱 - 存在多项风险指标，偿债压力较大"

        return result

    def analyze_operation(self) -> Dict:
        """运营效率分析"""
        result = {
            "category": "运营效率",
            "metrics": {},
            "observations": [],
            "assessment": ""
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if not indicators:
            return result

        latest = indicators[0]

        ar_days = self._safe_float(latest.get('应收账款周转天数'))
        inventory_days = self._safe_float(latest.get('存货周转天数'))
        asset_turnover = self._safe_float(latest.get('总资产周转率'))

        result["metrics"] = {
            "应收账款周转率": self._safe_float(latest.get('应收账款周转率')),
            "应收账款周转天数": ar_days,
            "存货周转率": self._safe_float(latest.get('存货周转率')),
            "存货周转天数": inventory_days,
            "总资产周转率": asset_turnover
        }

        # 观察分析
        observation_checks = [
            (ar_days and ar_days > 90, f"应收账款周转天数较长 ({ar_days:.0f}天)，回款较慢"),
            (inventory_days and inventory_days > 180, f"存货周转天数较长 ({inventory_days:.0f}天)，库存管理需关注"),
            (asset_turnover and asset_turnover < 0.5, f"总资产周转率较低 ({asset_turnover:.2f})，资产利用效率有待提高"),
        ]
        result["observations"] = [msg for condition, msg in observation_checks if condition]

        if not result["observations"]:
            result["assessment"] = "良好 - 运营效率指标正常"
        else:
            result["assessment"] = "需关注 - " + "；".join(result["observations"])

        return result

    def _assess_growth_rate(self, avg_growth: float) -> str:
        """评估增长率"""
        if avg_growth > 20:
            return "高成长 - 平均增长率超过20%"
        elif avg_growth > 10:
            return "稳定成长 - 平均增长率10-20%"
        elif avg_growth > 0:
            return "低速成长 - 平均增长率0-10%"
        return "负增长 - 需要深入分析原因"

    def _analyze_growth_trend(self, values: List[float], name: str) -> Optional[str]:
        """分析增长趋势"""
        if not values:
            return None
        if all(g > 0 for g in values[:4]):
            return f"{name}持续正增长"
        elif values[0] < 0:
            return f"{name}负增长，需关注"
        return None

    def analyze_growth(self) -> Dict:
        """成长性分析"""
        result = {
            "category": "成长性",
            "metrics": {},
            "trend": [],
            "assessment": ""
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if not indicators:
            return result

        revenue_growth = []
        profit_growth = []

        for indicator in indicators[:8]:
            rev = self._safe_float(indicator.get('主营业务收入增长率', indicator.get('营业收入增长率')))
            net = self._safe_float(indicator.get('净利润增长率'))
            if rev is not None:
                revenue_growth.append(rev)
            if net is not None:
                profit_growth.append(net)

        if revenue_growth:
            result["metrics"]["最近营收增长率"] = revenue_growth[0]
            result["metrics"]["平均营收增长率"] = sum(revenue_growth) / len(revenue_growth)

        if profit_growth:
            result["metrics"]["最近净利润增长率"] = profit_growth[0]
            result["metrics"]["平均净利润增长率"] = sum(profit_growth) / len(profit_growth)

        # 趋势判断
        for values, name in [(revenue_growth, "营收"), (profit_growth, "净利润")]:
            trend = self._analyze_growth_trend(values, name)
            if trend:
                result["trend"].append(trend)

        avg_growth = result["metrics"].get("平均净利润增长率", 0) or 0
        result["assessment"] = self._assess_growth_rate(avg_growth)

        return result

    def analyze_dupont(self) -> Dict:
        """杜邦分析"""
        result = {
            "category": "杜邦分析",
            "decomposition": {},
            "driver": "",
            "assessment": ""
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if not indicators:
            return result

        latest = indicators[0] if indicators else {}

        # 杜邦分解: ROE = 净利率 × 资产周转率 × 权益乘数
        net_margin = self._safe_float(latest.get('销售净利率'))
        asset_turnover = self._safe_float(latest.get('总资产周转率'))
        equity_multiplier = self._safe_float(latest.get('权益乘数'))
        roe = self._safe_float(latest.get('净资产收益率', latest.get('加权净资产收益率')))

        result["decomposition"] = {
            "ROE": roe,
            "净利率": net_margin,
            "资产周转率": asset_turnover,
            "权益乘数": equity_multiplier
        }

        # 判断ROE驱动因素
        if net_margin and asset_turnover and equity_multiplier:
            drivers = []
            if net_margin > 15:
                drivers.append("高净利率")
            if asset_turnover > 1:
                drivers.append("高周转")
            if equity_multiplier > 2.5:
                drivers.append("高杠杆")

            if drivers:
                result["driver"] = "ROE主要由" + "、".join(drivers) + "驱动"
            else:
                result["driver"] = "ROE驱动因素较为均衡"

        return result

    def detect_anomalies(self) -> Dict:
        """财务异常检测"""
        result = {
            "category": "财务异常检测",
            "signals": [],
            "risk_level": "低",
            "details": []
        }

        indicators = self.stock_data.get('financial_indicators', [])
        if len(indicators) < 2:
            return result

        current = indicators[0]
        previous = indicators[1] if len(indicators) > 1 else {}

        # 1. 应收账款异常
        ar_growth = self._safe_float(current.get('应收账款增长率'))
        revenue_growth = self._safe_float(current.get('营业收入增长率', current.get('主营业务收入增长率')))
        if ar_growth and revenue_growth and ar_growth > revenue_growth * 1.5:
            result["signals"].append({
                "type": "应收账款增速异常",
                "description": f"应收账款增速({ar_growth:.1f}%)显著高于营收增速({revenue_growth:.1f}%)",
                "severity": "中"
            })

        # 2. 存货异常
        inventory_growth = self._safe_float(current.get('存货增长率'))
        if inventory_growth and revenue_growth and inventory_growth > revenue_growth * 2:
            result["signals"].append({
                "type": "存货增速异常",
                "description": f"存货增速({inventory_growth:.1f}%)远高于营收增速({revenue_growth:.1f}%)",
                "severity": "中"
            })

        # 3. 毛利率异常波动
        current_gm = self._safe_float(current.get('销售毛利率'))
        previous_gm = self._safe_float(previous.get('销售毛利率'))
        if current_gm and previous_gm:
            gm_change = abs(current_gm - previous_gm)
            if gm_change > 10:
                result["signals"].append({
                    "type": "毛利率大幅波动",
                    "description": f"毛利率变动{gm_change:.1f}个百分点，需关注原因",
                    "severity": "中"
                })

        # 4. 经营现金流与净利润背离 (需要现金流数据)
        cash_flow = self.stock_data.get('financial_data', {}).get('cash_flow', [])
        income = self.stock_data.get('financial_data', {}).get('income_statement', [])
        if cash_flow and income:
            try:
                ocf = self._safe_float(cash_flow[0].get('经营活动产生的现金流量净额'))
                net_profit = self._safe_float(income[0].get('净利润'))
                if ocf and net_profit and net_profit > 0:
                    ocf_ratio = ocf / net_profit
                    if ocf_ratio < 0.5:
                        result["signals"].append({
                            "type": "现金流与利润背离",
                            "description": f"经营现金流/净利润 = {ocf_ratio:.1%}，盈利质量存疑",
                            "severity": "高"
                        })
            except (IndexError, KeyError):
                pass

        # 确定风险等级
        high_severity = sum(1 for s in result["signals"] if s.get("severity") == "高")
        medium_severity = sum(1 for s in result["signals"] if s.get("severity") == "中")

        if high_severity > 0:
            result["risk_level"] = "高"
        elif medium_severity >= 2:
            result["risk_level"] = "中"
        else:
            result["risk_level"] = "低"

        return result

    def generate_summary(self, level: str = "standard") -> Dict:
        """生成分析摘要"""
        summary = {
            "code": self.stock_data.get('code', ''),
            "name": self.stock_data.get('basic_info', {}).get('name', ''),
            "analysis_date": datetime.now().isoformat(),
            "level": level
        }

        profitability = self.analyze_profitability()
        solvency = self.analyze_solvency()
        operation = self.analyze_operation()
        growth = self.analyze_growth()
        anomalies = self.detect_anomalies()

        if level == "summary":
            summary["profitability"] = profitability["assessment"]
            summary["solvency"] = solvency["assessment"]
            summary["growth"] = growth["assessment"]
            summary["risk_level"] = anomalies["risk_level"]
        else:
            # standard 和 deep 级别共享基础分析结果
            summary["profitability"] = profitability
            summary["solvency"] = solvency
            summary["operation"] = operation
            summary["growth"] = growth
            summary["dupont"] = self.analyze_dupont()
            summary["anomalies"] = anomalies

            if level == "deep":
                summary["historical_indicators"] = self.stock_data.get('financial_indicators', [])

        summary["score"] = self._calculate_score(profitability, solvency, growth, anomalies)

        return summary

    def _calculate_score(self, profitability, solvency, growth, anomalies) -> int:
        """计算综合评分 (0-100)"""
        score = 50

        # 盈利能力评分
        roe = profitability.get("metrics", {}).get("当前ROE")
        if roe:
            if roe > 20:
                score += 15
            elif roe > 15:
                score += 10
            elif roe > 10:
                score += 5
            elif roe < 5:
                score -= 5

        # 偿债能力评分
        risks = solvency.get("risks", [])
        score += 10 if not risks else -len(risks) * 3

        # 成长性评分
        avg_growth = growth.get("metrics", {}).get("平均净利润增长率", 0) or 0
        if avg_growth > 20:
            score += 15
        elif avg_growth > 10:
            score += 10
        elif avg_growth > 0:
            score += 5
        else:
            score -= 5

        # 风险扣分
        risk_penalties = {"高": 15, "中": 8}
        score -= risk_penalties.get(anomalies.get("risk_level", "低"), 0)

        return max(0, min(100, score))

    def compare_stocks(self, stocks_data: List[Dict]) -> Dict:
        """对比多只股票"""
        comparison = {
            "comparison_date": datetime.now().isoformat(),
            "stocks": [],
            "ranking": {}
        }

        stock_scores = []
        for stock in stocks_data:
            self.stock_data = stock
            summary = self.generate_summary(level="summary")
            comparison["stocks"].append({
                "code": stock.get('code', ''),
                "name": stock.get('basic_info', {}).get('name', ''),
                "score": summary.get("score", 50),
                "profitability": summary.get("profitability"),
                "solvency": summary.get("solvency"),
                "growth": summary.get("growth"),
                "risk_level": summary.get("risk_level")
            })
            stock_scores.append((stock.get('code', ''), summary.get("score", 50)))

        # 排名
        stock_scores.sort(key=lambda x: x[1], reverse=True)
        comparison["ranking"] = {code: rank + 1 for rank, (code, _) in enumerate(stock_scores)}

        return comparison

    @staticmethod
    def _safe_float(value) -> Optional[float]:
        """安全转换为浮点数"""
        if value is None or value == '' or value == '--':
            return None
        try:
            if isinstance(value, str):
                value = value.replace('%', '').replace(',', '')
            return float(value)
        except (ValueError, TypeError):
            return None


def main():
    parser = argparse.ArgumentParser(description="A股财务分析器")
    parser.add_argument("--input", type=str, required=True, help="输入数据文件 (JSON)")
    parser.add_argument("--level", type=str, default="standard",
                       choices=["summary", "standard", "deep"],
                       help="分析深度级别")
    parser.add_argument("--mode", type=str, default="single",
                       choices=["single", "comparison"],
                       help="分析模式: single(单只)/comparison(对比)")
    parser.add_argument("--output", type=str, help="输出文件路径 (JSON)")

    args = parser.parse_args()

    # 加载数据
    with open(args.input, 'r', encoding='utf-8') as f:
        data = json.load(f)

    analyzer = FinancialAnalyzer()

    if args.mode == "single":
        analyzer.stock_data = data
        result = analyzer.generate_summary(level=args.level)
    else:
        # 对比模式
        stocks = data.get('stocks', [data])
        result = analyzer.compare_stocks(stocks)

    # 输出
    output_json = json.dumps(result, ensure_ascii=False, indent=2, default=str)

    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            f.write(output_json)
        print(f"分析结果已保存到: {args.output}")
    else:
        print(output_json)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
A股股票筛选器
根据多种财务指标筛选符合条件的股票

依赖: pip install akshare pandas numpy
"""

import argparse
import json
import sys
import time
from datetime import datetime
from typing import List, Dict
from functools import wraps

try:
    import akshare as ak
    import pandas as pd
    import numpy as np
except ImportError:
    print("错误: 请先安装依赖库")
    print("pip install akshare pandas numpy")
    sys.exit(1)


def retry_on_failure(max_retries: int = 3, delay: float = 1.0):
    """网络请求重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    if attempt < max_retries - 1:
                        print(f"  重试 ({attempt + 1}/{max_retries})...")
                        time.sleep(delay * (attempt + 1))
            raise last_error
        return wrapper
    return decorator


INDEX_CODE_MAP = {
    "hs300": "000300",
    "zz500": "000905",
    "zz1000": "000852",
    "cyb": "399006",
    "kcb": "000688"
}


class StockScreener:
    """股票筛选器"""

    def __init__(self):
        self.all_stocks_data = None

    def load_stock_data(self, scope: str = "hs300", custom_codes: List[str] = None) -> pd.DataFrame:
        """加载股票数据"""
        print(f"正在加载股票数据 (范围: {scope})...")

        try:
            if scope == "all":
                df = ak.stock_zh_a_spot_em()
            elif scope in INDEX_CODE_MAP:
                df = self._get_index_stocks_data(INDEX_CODE_MAP[scope])
            elif scope.startswith("custom:") or custom_codes:
                codes = custom_codes or scope.replace("custom:", "").split(",")
                df = self._get_custom_stocks_data(codes)
            else:
                df = ak.stock_zh_a_spot_em()

            self.all_stocks_data = df
            print(f"已加载 {len(df)} 只股票数据")
            return df

        except Exception as e:
            print(f"加载数据失败: {e}")
            return pd.DataFrame()

    @retry_on_failure(max_retries=3, delay=2.0)
    def _get_all_stocks_realtime(self) -> pd.DataFrame:
        """获取全部A股实时数据（带重试）"""
        return ak.stock_zh_a_spot_em()

    @retry_on_failure(max_retries=3, delay=2.0)
    def _get_index_constituents(self, index_code: str) -> list:
        """获取指数成分股列表（带重试）"""
        df = ak.index_stock_cons(symbol=index_code)
        return df['品种代码'].tolist()

    def _get_index_stocks_data(self, index_code: str) -> pd.DataFrame:
        """获取指数成分股数据"""
        try:
            # 获取成分股列表
            print(f"  获取指数 {index_code} 成分股...")
            codes = self._get_index_constituents(index_code)
            print(f"  成分股数量: {len(codes)}")

            # 获取实时数据
            print("  获取实时行情...")
            all_stocks = self._get_all_stocks_realtime()
            df = all_stocks[all_stocks['代码'].isin(codes)]
            return df
        except Exception as e:
            print(f"获取指数成分股失败: {e}")
            return pd.DataFrame()

    def _get_custom_stocks_data(self, codes: List[str]) -> pd.DataFrame:
        """获取自定义股票列表数据"""
        try:
            all_stocks = self._get_all_stocks_realtime()
            df = all_stocks[all_stocks['代码'].isin(codes)]
            return df
        except Exception as e:
            print(f"获取自定义股票数据失败: {e}")
            return pd.DataFrame()

    def _apply_numeric_filter(self, df: pd.DataFrame, column: str,
                               min_val: float = None, max_val: float = None) -> pd.DataFrame:
        """应用数值筛选条件"""
        if column not in df.columns:
            return df

        numeric_col = pd.to_numeric(df[column], errors='coerce')
        if min_val is not None:
            df = df[numeric_col >= min_val]
        if max_val is not None:
            df = df[numeric_col <= max_val]
        return df

    def _find_column(self, df: pd.DataFrame, candidates: List[str]) -> str:
        """从候选列名中找到存在的列"""
        for col in candidates:
            if col in df.columns:
                return col
        return None

    def apply_filters(self, df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
        """应用筛选条件"""
        filtered = df.copy()

        # PE筛选
        filtered = self._apply_numeric_filter(
            filtered, '市盈率-动态',
            min_val=filters.get('pe_min'),
            max_val=filters.get('pe_max')
        )

        # PB筛选
        filtered = self._apply_numeric_filter(
            filtered, '市净率',
            min_val=filters.get('pb_min'),
            max_val=filters.get('pb_max')
        )

        # ROE筛选
        if filters.get('roe_min') is not None:
            roe_col = self._find_column(filtered, ['净资产收益率', 'ROE', '加权净资产收益率'])
            if roe_col:
                filtered = self._apply_numeric_filter(filtered, roe_col, min_val=filters['roe_min'])

        # 资产负债率筛选
        filtered = self._apply_numeric_filter(
            filtered, '资产负债率',
            max_val=filters.get('debt_ratio_max')
        )

        # 总市值筛选（转换为亿）
        if '总市值' in filtered.columns:
            if filters.get('market_cap_min') is not None or filters.get('market_cap_max') is not None:
                filtered['总市值_亿'] = pd.to_numeric(filtered['总市值'], errors='coerce') / 1e8
                filtered = self._apply_numeric_filter(
                    filtered, '总市值_亿',
                    min_val=filters.get('market_cap_min'),
                    max_val=filters.get('market_cap_max')
                )

        return filtered

    def _get_numeric_value(self, row: pd.Series, column: str) -> float:
        """从行中获取数值，无效返回 NaN"""
        return pd.to_numeric(row.get(column, np.nan), errors='coerce')

    def calculate_score(self, row: pd.Series) -> float:
        """计算综合评分 (0-100)"""
        score = 50

        try:
            # PE评分 (越低越好, 负数除外)
            pe = self._get_numeric_value(row, '市盈率-动态')
            if not np.isnan(pe) and pe > 0:
                if pe < 10:
                    score += 15
                elif pe < 15:
                    score += 10
                elif pe < 20:
                    score += 5
                elif pe > 50:
                    score -= 10

            # PB评分
            pb = self._get_numeric_value(row, '市净率')
            if not np.isnan(pb) and pb > 0:
                if 0.5 < pb < 1.5:
                    score += 10
                elif 1.5 <= pb < 3:
                    score += 5
                elif pb > 5:
                    score -= 5

            # ROE评分
            roe_col = self._find_column(row.index.to_frame(), ['净资产收益率', 'ROE', '加权净资产收益率'])
            if roe_col:
                roe = self._get_numeric_value(row, roe_col)
                if not np.isnan(roe):
                    if roe > 20:
                        score += 15
                    elif roe > 15:
                        score += 10
                    elif roe > 10:
                        score += 5
                    elif roe < 5:
                        score -= 5

            # 涨跌幅评分 (下跌可能是机会)
            change = self._get_numeric_value(row, '涨跌幅')
            if not np.isnan(change):
                if -5 < change < 0:
                    score += 3
                elif change < -5:
                    score += 5

        except Exception:
            pass

        return max(0, min(100, score))

    def screen(self, scope: str = "hs300", filters: Dict = None,
              sort_by: str = "score", top_n: int = None) -> List[Dict]:
        """执行筛选"""
        # 加载数据
        if scope.startswith("custom:"):
            codes = scope.replace("custom:", "").split(",")
            df = self.load_stock_data(scope="custom", custom_codes=codes)
        else:
            df = self.load_stock_data(scope=scope)

        if df.empty:
            return []

        # 应用筛选条件
        if filters:
            df = self.apply_filters(df, filters)

        if df.empty:
            return []

        # 计算评分
        df['评分'] = df.apply(self.calculate_score, axis=1)

        # 排序
        if sort_by == "score":
            df = df.sort_values('评分', ascending=False)
        elif sort_by == "pe":
            pe_col = '市盈率-动态' if '市盈率-动态' in df.columns else None
            if pe_col:
                df = df.sort_values(pe_col, ascending=True)
        elif sort_by == "pb":
            if '市净率' in df.columns:
                df = df.sort_values('市净率', ascending=True)
        elif sort_by == "market_cap":
            if '总市值' in df.columns:
                df = df.sort_values('总市值', ascending=False)

        # 限制数量
        if top_n:
            df = df.head(top_n)

        # 转换为结果列表
        results = []
        for _, row in df.iterrows():
            result = {
                "代码": row.get('代码', ''),
                "名称": row.get('名称', ''),
                "最新价": row.get('最新价', ''),
                "涨跌幅": row.get('涨跌幅', ''),
                "市盈率": row.get('市盈率-动态', ''),
                "市净率": row.get('市净率', ''),
                "总市值(亿)": round(float(row.get('总市值', 0)) / 100000000, 2) if row.get('总市值') else '',
                "评分": row.get('评分', 50)
            }
            results.append(result)

        return results


def main():
    parser = argparse.ArgumentParser(description="A股股票筛选器")
    parser.add_argument("--scope", type=str, default="hs300",
                       help="筛选范围: all/hs300/zz500/zz1000/cyb/kcb/custom:代码1,代码2")
    parser.add_argument("--pe-max", type=float, help="最大PE")
    parser.add_argument("--pe-min", type=float, help="最小PE")
    parser.add_argument("--pb-max", type=float, help="最大PB")
    parser.add_argument("--pb-min", type=float, help="最小PB")
    parser.add_argument("--roe-min", type=float, help="最小ROE (%)")
    parser.add_argument("--debt-ratio-max", type=float, help="最大资产负债率 (%)")
    parser.add_argument("--dividend-min", type=float, help="最小股息率 (%)")
    parser.add_argument("--market-cap-min", type=float, help="最小市值 (亿)")
    parser.add_argument("--market-cap-max", type=float, help="最大市值 (亿)")
    parser.add_argument("--sort-by", type=str, default="score",
                       choices=["score", "pe", "pb", "market_cap"],
                       help="排序方式")
    parser.add_argument("--top", type=int, default=50, help="返回前N只股票")
    parser.add_argument("--output", type=str, help="输出文件路径 (JSON)")

    args = parser.parse_args()

    # 构建筛选条件
    filter_keys = [
        'pe_max', 'pe_min', 'pb_max', 'pb_min', 'roe_min',
        'debt_ratio_max', 'dividend_min', 'market_cap_min', 'market_cap_max'
    ]
    filters = {
        k: getattr(args, k.replace('-', '_'))
        for k in filter_keys
        if getattr(args, k.replace('-', '_')) is not None
    }

    # 执行筛选
    screener = StockScreener()
    results = screener.screen(
        scope=args.scope,
        filters=filters if filters else None,
        sort_by=args.sort_by,
        top_n=args.top
    )

    # 输出结果
    output = {
        "screen_time": datetime.now().isoformat(),
        "scope": args.scope,
        "filters": filters,
        "count": len(results),
        "results": results
    }

    output_json = json.dumps(output, ensure_ascii=False, indent=2, default=str)

    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            f.write(output_json)
        print(f"筛选结果已保存到: {args.output}")
        print(f"共筛选出 {len(results)} 只股票")
    else:
        print(output_json)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
A股估值计算器
提供DCF、DDM、相对估值等多种估值方法

依赖: pip install pandas numpy
"""

import argparse
import json
import sys
from datetime import datetime
from typing import Optional, Dict

try:
    import pandas as pd
    import numpy as np
except ImportError:
    print("错误: 请先安装依赖库")
    print("pip install pandas numpy")
    sys.exit(1)


class ValuationCalculator:
    """估值计算器"""

    def __init__(self, stock_data: Dict = None):
        self.stock_data = stock_data or {}
        self.results = {}

    def load_data(self, file_path: str):
        """从JSON文件加载股票数据"""
        with open(file_path, 'r', encoding='utf-8') as f:
            self.stock_data = json.load(f)

    def dcf_valuation(self, discount_rate: float = 10,
                      forecast_years: int = 5,
                      terminal_growth: float = 3) -> Dict:
        """
        DCF现金流折现估值

        参数:
            discount_rate: 折现率 (%)
            forecast_years: 预测期年数
            terminal_growth: 永续增长率 (%)
        """
        result = {
            "method": "DCF现金流折现",
            "parameters": {
                "discount_rate": discount_rate,
                "forecast_years": forecast_years,
                "terminal_growth": terminal_growth
            },
            "calculation": {},
            "intrinsic_value": None,
            "per_share_value": None
        }

        # 获取现金流数据
        cash_flow = self.stock_data.get('financial_data', {}).get('cash_flow', [])
        basic_info = self.stock_data.get('basic_info', {})

        if not cash_flow:
            result["error"] = "无法获取现金流数据"
            return result

        try:
            # 计算历史自由现金流
            fcf_history = []
            for cf in cash_flow[:4]:  # 最近4个季度
                ocf = self._safe_float(cf.get('经营活动产生的现金流量净额', 0))
                capex = abs(self._safe_float(cf.get('购建固定资产、无形资产和其他长期资产支付的现金', 0)))
                if ocf is not None:
                    fcf = ocf - capex
                    fcf_history.append(fcf)

            if not fcf_history:
                result["error"] = "无法计算自由现金流"
                return result

            # 年化FCF (简单年化)
            annual_fcf = sum(fcf_history)
            result["calculation"]["当前年化FCF"] = annual_fcf

            # 估算增长率 (使用历史净利润增长率)
            indicators = self.stock_data.get('financial_indicators', [])
            growth_rate = 10  # 默认10%
            if indicators:
                hist_growth = self._safe_float(indicators[0].get('净利润增长率'))
                if hist_growth and -50 < hist_growth < 100:
                    growth_rate = min(max(hist_growth, 0), 30)  # 限制在0-30%之间

            result["calculation"]["预计增长率"] = growth_rate

            # 预测未来现金流
            r = discount_rate / 100
            g = growth_rate / 100
            tg = terminal_growth / 100

            pv_fcf = 0
            future_fcf = []
            for year in range(1, forecast_years + 1):
                fcf = annual_fcf * ((1 + g) ** year)
                pv = fcf / ((1 + r) ** year)
                pv_fcf += pv
                future_fcf.append({"year": year, "fcf": fcf, "pv": pv})

            result["calculation"]["预测期现金流现值"] = pv_fcf
            result["calculation"]["future_fcf"] = future_fcf

            # 终值计算 (Gordon模型)
            terminal_fcf = annual_fcf * ((1 + g) ** forecast_years) * (1 + tg)
            terminal_value = terminal_fcf / (r - tg)
            pv_terminal = terminal_value / ((1 + r) ** forecast_years)

            result["calculation"]["终值"] = terminal_value
            result["calculation"]["终值现值"] = pv_terminal

            # 总价值
            total_value = pv_fcf + pv_terminal
            result["intrinsic_value"] = total_value

            # 每股价值
            total_shares = self._parse_shares(basic_info.get('total_shares', ''))
            if total_shares:
                per_share = total_value / total_shares
                result["per_share_value"] = per_share

        except Exception as e:
            result["error"] = str(e)

        return result

    def ddm_valuation(self, required_return: float = 10,
                      dividend_growth: float = None) -> Dict:
        """
        DDM股息折现估值 (Gordon模型)

        参数:
            required_return: 要求回报率 (%)
            dividend_growth: 股息增长率 (%)，如果为None则自动计算
        """
        result = {
            "method": "DDM股息折现",
            "parameters": {
                "required_return": required_return
            },
            "calculation": {},
            "intrinsic_value": None,
            "per_share_value": None
        }

        # 获取分红数据
        dividend = self.stock_data.get('dividend', {})
        dividend_history = dividend.get('dividend_history', [])
        basic_info = self.stock_data.get('basic_info', {})

        if not dividend_history:
            result["error"] = "无分红历史数据"
            result["note"] = "该公司可能分红较少或不稳定，不适合DDM估值"
            return result

        try:
            # 计算最近股息
            recent_dividends = []
            for d in dividend_history[:5]:  # 最近5年
                div = self._safe_float(d.get('每股股利', d.get('派息', 0)))
                if div and div > 0:
                    recent_dividends.append(div)

            if len(recent_dividends) < 2:
                result["error"] = "分红数据不足，无法使用DDM"
                return result

            current_dividend = recent_dividends[0]
            result["calculation"]["当前每股股息"] = current_dividend

            # 计算股息增长率
            if dividend_growth is None:
                if len(recent_dividends) >= 2:
                    # 计算复合增长率
                    years = len(recent_dividends) - 1
                    cagr = (recent_dividends[0] / recent_dividends[-1]) ** (1 / years) - 1
                    dividend_growth = cagr * 100
                else:
                    dividend_growth = 3  # 默认3%

            # 限制增长率
            dividend_growth = min(max(dividend_growth, 0), required_return - 1)
            result["parameters"]["dividend_growth"] = dividend_growth
            result["calculation"]["股息增长率"] = dividend_growth

            # Gordon模型: P = D1 / (r - g)
            r = required_return / 100
            g = dividend_growth / 100
            d1 = current_dividend * (1 + g)

            if r <= g:
                result["error"] = "增长率不能大于或等于要求回报率"
                return result

            per_share_value = d1 / (r - g)
            result["per_share_value"] = per_share_value
            result["calculation"]["下期预期股息(D1)"] = d1

            # 总价值
            total_shares = self._parse_shares(basic_info.get('total_shares', ''))
            if total_shares:
                result["intrinsic_value"] = per_share_value * total_shares

        except Exception as e:
            result["error"] = str(e)

        return result

    def _assess_percentile(self, percentile: float) -> str:
        """根据分位数评估估值水平"""
        if percentile < 20:
            return "处于历史低位，可能被低估"
        elif percentile < 40:
            return "处于历史较低水平"
        elif percentile < 60:
            return "处于历史中等水平"
        elif percentile < 80:
            return "处于历史较高水平"
        return "处于历史高位，估值偏贵"

    def relative_valuation(self) -> Dict:
        """相对估值法，与行业均值和历史均值对比"""
        result = {
            "method": "相对估值",
            "current_valuation": {},
            "comparison": {},
            "assessment": {}
        }

        valuation = self.stock_data.get('valuation', {})
        price = self.stock_data.get('price', {})
        basic_info = self.stock_data.get('basic_info', {})

        try:
            current_pe = self._safe_float(basic_info.get('pe_ttm'))
            current_pb = self._safe_float(basic_info.get('pb'))

            if not current_pe and valuation.get('latest'):
                current_pe = self._safe_float(valuation['latest'].get('pe'))
                current_pb = self._safe_float(valuation['latest'].get('pb'))

            result["current_valuation"] = {
                "PE_TTM": current_pe,
                "PB": current_pb,
                "当前价格": price.get('latest_price')
            }

            pe_percentile = valuation.get('pe_percentile')
            pb_percentile = valuation.get('pb_percentile')

            result["comparison"]["PE历史分位数"] = pe_percentile
            result["comparison"]["PB历史分位数"] = pb_percentile

            # 估值评估
            if pe_percentile is not None:
                result["assessment"]["PE评估"] = self._assess_percentile(pe_percentile)
            if pb_percentile is not None:
                result["assessment"]["PB评估"] = self._assess_percentile(pb_percentile)

            # 计算基于历史均值的合理价格
            current_price = price.get('latest_price', 0)
            if current_pe and pe_percentile and pe_percentile > 0 and current_price and current_pe > 0:
                fair_pe = current_pe * (50 / pe_percentile)
                fair_price_pe = current_price * (fair_pe / current_pe)
                result["comparison"]["基于PE的合理价格"] = round(fair_price_pe, 2)

        except Exception as e:
            result["error"] = str(e)

        return result

    def calculate_margin_of_safety(self, intrinsic_value: float,
                                    current_price: float,
                                    margin_pct: float = 30) -> Dict:
        """计算安全边际"""
        result = {
            "intrinsic_value": intrinsic_value,
            "current_price": current_price,
            "margin_of_safety_required": margin_pct
        }

        if not (intrinsic_value and current_price):
            return result

        actual_margin = (intrinsic_value - current_price) / intrinsic_value * 100
        safety_price = intrinsic_value * (1 - margin_pct / 100)

        result["actual_margin_of_safety"] = round(actual_margin, 2)
        result["safety_price"] = round(safety_price, 2)

        if current_price < safety_price:
            result["conclusion"] = "低估 - 当前价格低于安全边际价格，具有投资价值"
        elif current_price < intrinsic_value:
            result["conclusion"] = "合理偏低 - 当前价格低于内在价值，但未达到安全边际"
        else:
            result["conclusion"] = "高估 - 当前价格高于内在价值"

        return result

    def comprehensive_valuation(self, discount_rate: float = 10,
                                 terminal_growth: float = 3,
                                 margin_of_safety: float = 30) -> Dict:
        """综合估值，结合多种方法得出估值结论"""
        result = {
            "code": self.stock_data.get('code', ''),
            "name": self.stock_data.get('basic_info', {}).get('name', ''),
            "valuation_date": datetime.now().isoformat(),
            "methods": {},
            "summary": {}
        }

        # 获取当前价格
        current_price = self.stock_data.get('price', {}).get('latest_price')

        # DCF估值
        dcf = self.dcf_valuation(discount_rate=discount_rate,
                                  terminal_growth=terminal_growth)
        result["methods"]["DCF"] = dcf

        # DDM估值
        ddm = self.ddm_valuation()
        result["methods"]["DDM"] = ddm

        # 相对估值
        relative = self.relative_valuation()
        result["methods"]["相对估值"] = relative

        # 汇总估值结果
        valuations = []
        if dcf.get('per_share_value'):
            valuations.append(("DCF", dcf['per_share_value']))
        if ddm.get('per_share_value'):
            valuations.append(("DDM", ddm['per_share_value']))
        if relative.get('comparison', {}).get('基于PE的合理价格'):
            valuations.append(("相对估值", relative['comparison']['基于PE的合理价格']))

        if valuations:
            avg_value = sum(v[1] for v in valuations) / len(valuations)
            result["summary"]["平均内在价值"] = round(avg_value, 2)
            result["summary"]["估值方法数"] = len(valuations)
            result["summary"]["各方法估值"] = {k: round(v, 2) for k, v in valuations}

            # 安全边际计算
            if current_price:
                margin = self.calculate_margin_of_safety(
                    avg_value, current_price, margin_of_safety
                )
                result["summary"]["安全边际分析"] = margin
                result["summary"]["当前价格"] = current_price
                result["summary"]["建议买入价"] = margin.get('safety_price')
                result["summary"]["投资结论"] = margin.get('conclusion')

        return result

    def _safe_float(self, value) -> Optional[float]:
        """安全转换为浮点数"""
        if value is None or value == '' or value == '--':
            return None
        try:
            if isinstance(value, str):
                value = value.replace('%', '').replace(',', '').replace('亿', '')
            return float(value)
        except (ValueError, TypeError):
            return None

    def _parse_shares(self, shares_str: str) -> Optional[float]:
        """解析股份数"""
        if not shares_str:
            return None
        try:
            if '亿' in str(shares_str):
                return float(shares_str.replace('亿', '')) * 100000000
            elif '万' in str(shares_str):
                return float(shares_str.replace('万', '')) * 10000
            else:
                return float(shares_str)
        except (ValueError, TypeError):
            return None


def main():
    parser = argparse.ArgumentParser(description="A股估值计算器")
    parser.add_argument("--input", type=str, help="输入数据文件 (JSON)")
    parser.add_argument("--code", type=str, help="股票代码 (如果不提供input)")
    parser.add_argument("--methods", type=str, default="all",
                       help="估值方法: dcf/ddm/relative/all")
    parser.add_argument("--discount-rate", type=float, default=10,
                       help="折现率 (%)")
    parser.add_argument("--terminal-growth", type=float, default=3,
                       help="永续增长率 (%)")
    parser.add_argument("--margin-of-safety", type=float, default=30,
                       help="安全边际要求 (%)")
    parser.add_argument("--output", type=str, help="输出文件路径 (JSON)")

    args = parser.parse_args()

    calculator = ValuationCalculator()

    if args.input:
        calculator.load_data(args.input)
    elif args.code:
        # 如果只提供代码，需要先获取数据
        print("请先使用 data_fetcher.py 获取数据，然后使用 --input 参数")
        sys.exit(1)
    else:
        print("请提供 --input 或 --code 参数")
        sys.exit(1)

    # 执行估值
    valuation_methods = {
        "dcf": lambda: calculator.dcf_valuation(
            discount_rate=args.discount_rate,
            terminal_growth=args.terminal_growth
        ),
        "ddm": calculator.ddm_valuation,
        "relative": calculator.relative_valuation,
    }

    if args.methods in valuation_methods:
        result = valuation_methods[args.methods]()
    else:
        result = calculator.comprehensive_valuation(
            discount_rate=args.discount_rate,
            terminal_growth=args.terminal_growth,
            margin_of_safety=args.margin_of_safety
        )

    # 输出
    output_json = json.dumps(result, ensure_ascii=False, indent=2, default=str)

    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            f.write(output_json)
        print(f"估值结果已保存到: {args.output}")
    else:
        print(output_json)


if __name__ == "__main__":
    main()