Analysis_Multi/app/routers/health.py

import math
from datetime import datetime
from typing import List

from fastapi import HTTPException, APIRouter

from app.logger import logger
from app.models.HealthEvaluationReqAndResp import AssessmentResult, AssessmentRequest, SubsystemResult

from app.services.HealthAssessor import HealthAssessor
from app.services.HealthDataFetcher import DataFetcher

router = APIRouter()


@router.post("/health_assess", response_model=List[AssessmentResult])
async def assess_windfarm(request: AssessmentRequest):
    try:
        datetime.strptime(request.month, "%Y-%m")
    except ValueError:
        raise HTTPException(status_code=400, detail="无效时间格式，使用YYYY-MM格式")
    logger.info(f"开始处理风场评估请求 - 风场编码: {request.windcode}, 月份: {request.month}")

    fetcher = DataFetcher()
    assessor = HealthAssessor()
    turbines = fetcher.get_turbines(request.windcode)
    print(turbines)
    if turbines.empty:
        raise HTTPException(status_code=404, detail="未找到风场数据")

    results: List[AssessmentResult] = []  # 显式声明列表类型并初始化
    all_turbines = len(turbines)
    processed_count = 0

    for idx, row in turbines.iterrows():
        try:
            engine_code = row['engine_code']
            mill_type_code = row['mill_type_code']
            wind_turbine_name = row['engine_name']
            # 获取机型类型
            mill_type_num = fetcher.get_mill_type(mill_type_code)
            mill_type = {1: 'dfig', 2: 'direct', 3: 'semi_direct'}.get(mill_type_num, 'unknown')

            if mill_type == 'unknown':
                logger.warning(f"{engine_code}机型未知，跳过处理")
                continue

            # 获取特征与数据
            # 先获取该风场所有可用列名
            available_columns = fetcher.get_turbine_columns(request.windcode)
            if not available_columns:
                continue
                # 获取有效特征列（基于实际列名）
            valid_features = assessor._get_all_possible_features(assessor, mill_type, available_columns)
            # 获取数据
            data = fetcher.fetch_turbine_data(request.windcode, engine_code, request.month, valid_features)
            print(data)

            if data is None or data.empty:  # 增加对None的检查
                logger.warning(f"{engine_code}在{request.month}无有效数据")
                # 创建空评估结果，所有评分为-1
                empty_assessment = {
                    'engine_code': engine_code,
                    'wind_turbine_name': wind_turbine_name,
                    'mill_type': mill_type,
                    'total_health_score': -1,
                    'subsystems': {
                        'generator': {
                            'health_score': -1,
                            'weights': {},
                            'message': None
                        },
                        'nacelle': {
                            'health_score': -1,
                            'weights': {},
                            'message': None
                        },
                        'grid': {
                            'health_score': -1,
                            'weights': {},
                            'message': None
                        },
                        'drive_train': {
                            'health_score': -1,
                            'weights': {},
                            'message': None
                        }
                    },
                    'assessed_subsystems': ['generator', 'nacelle', 'grid', 'drive_train']
                }
                formatted_result = _format_result(empty_assessment)
                results.append(formatted_result)
                processed_count += 1
                logger.info(f"处理无数据风机{engine_code}（已处理{processed_count}/{all_turbines}台）")
                continue

            # 执行评估并格式化结果
            assessment = assessor.assess_turbine(engine_code, data, mill_type, wind_turbine_name)
            if not assessment:  # 检查评估结果有效性
                logger.warning(f"{engine_code}评估结果为空")
                continue

            formatted_result = _format_result(assessment)
            if isinstance(formatted_result, AssessmentResult):  # 严格类型检查
                results.append(formatted_result)
                processed_count += 1
                logger.info(f"成功处理{engine_code}（已处理{processed_count}/{all_turbines}台）")
            else:
                logger.error(f"{engine_code}结果格式化失败，类型错误: {type(formatted_result)}")

        except Exception as e:
            logger.error(f"处理{engine_code}时发生异常: {str(e)}", exc_info=True)
            continue

    # 最终返回处理 - 强制转换为列表并确保类型正确
    if not results:
        logger.warning(f"风场{request.windcode}在{request.month}无有效评估结果，返回空列表")
        return []

    cleaned_results = [clean_nans(result.dict()) for result in results]

    # 防御性类型检查（生产环境可移除）
    if not isinstance(cleaned_results, list):
        logger.error(f"结果类型错误，期望list但得到{type(results)}，强制转换为列表")
        cleaned_results = [cleaned_results] if cleaned_results is not None else []

    return cleaned_results


def _format_result(assessment):
    """格式化评估结果"""
    return AssessmentResult(
        engine_code=assessment['engine_code'],
        wind_turbine_name=assessment['wind_turbine_name'],
        mill_type=assessment['mill_type'],
        total_health_score=assessment.get('total_health_score'),
        subsystems={
            k: SubsystemResult(**v)
            for k, v in assessment['subsystems'].items()
        },
        assessed_subsystems=assessment.get('assessed_subsystems', [])
    )


def clean_nans(obj):
    """递归清理字典和列表中的NaN值"""
    if isinstance(obj, dict):
        return {k: clean_nans(v) for k, v in obj.items()}
    elif isinstance(obj, list):
        return [clean_nans(item) for item in obj]
    elif isinstance(obj, float) and math.isnan(obj):
        return -1.0  # 替换为-1表示无效值
    elif isinstance(obj, float) and not math.isfinite(obj):
        return -1.0  # 处理无穷大值
    else:
        return obj