ai-station-code/run.py

import sys

from fastapi import FastAPI,File, UploadFile,Form,Query
from fastapi.staticfiles import StaticFiles
from fastapi import FastAPI, HTTPException
from fastapi.responses import FileResponse
import sys
import os
import shutil
from pydantic import BaseModel, validator
from typing import List
import asyncio
import pandas as pd
import numpy as np
from PIL import Image 
# 获取当前脚本所在目录
print("Current working directory:", os.getcwd()) 
current_dir = os.path.dirname(os.path.abspath(__file__))
# 添加环境变量路径
sys.path.append(os.path.join(current_dir))
print("Current sys.path:", sys.path)
import torch
from dimaoshibie import segformer
from wudingpv.taihuyuan_roof.manet.model.resunet import resUnetpamcarb as roof_resUnetpamcarb
from wudingpv.predictandeval_util import segmentation
from guangfufadian import model_base as guangfufadian_model_base
from fenglifadian import model_base as fenglifadian_model_base
from work_util import prepare_data,model_deal,params,data_util,post_model
from work_util.logger import logger
import joblib
import mysql.connector
import uuid
import json
import zipfile
from pathlib import Path

version = f"{sys.version_info.major}.{sys.version_info.minor}"

app = FastAPI()

param = params.ModelParams()
def get_roof_model():
    model_roof =  roof_resUnetpamcarb()
    model_path_roof = os.path.join(current_dir,'wudingpv/models/roof_best.pth')
    model_dict_roof = torch.load(model_path_roof, map_location=torch.device('cpu'))
    model_roof.load_state_dict(model_dict_roof['net'])
    logger.info("屋顶识别权重加载成功")
    model_roof.eval()
    model_roof.cuda()
    return model_roof


def get_pv_model():
    model_roof =  roof_resUnetpamcarb()
    model_path_roof = os.path.join(current_dir,'wudingpv/models/pv_best.pth')
    model_dict_roof = torch.load(model_path_roof, map_location=torch.device('cpu'))
    model_roof.load_state_dict(model_dict_roof['net'])
    logger.info("屋顶识别权重加载成功")
    model_roof.eval()
    model_roof.cuda()
    return model_roof

# 模型实例
dimaoshibie_SegFormer = segformer.SegFormer_Segmentation()
# 模型实例
dimaoshibie_SegFormer = segformer.SegFormer_Segmentation()
roof_model = get_roof_model()
pv_model = get_pv_model()
ch4_model_flow = joblib.load(os.path.join(current_dir,'jiawanyuce/liuliang_model/xgb_model_liuliang.pkl'))
ch4_model_gas = joblib.load(os.path.join(current_dir,'jiawanyuce/qixiangnongdu_model/xgb_model_qixiangnongdu.pkl'))

pvfd_param = guangfufadian_model_base.guangfufadian_Args()
pvfd_model_path = os.path.join(pvfd_param.checkpoints,'Crossformer_station08_il192_ol96_sl6_win2_fa10_dm256_nh4_el3_itr0/checkpoint.pth')  # 修改为实际模型路径
pvfd_model = guangfufadian_model_base.ModelInference(pvfd_model_path, pvfd_param)

windfd_args = fenglifadian_model_base.fenglifadian_Args()
windfd_model_path = os.path.join(windfd_args.checkpoints,'Crossformer_Wind_farm_il192_ol12_sl6_win2_fa10_dm256_nh4_el3_itr0/checkpoint.pth')  # 修改为实际模型路径
windfd_model = fenglifadian_model_base.ModelInference(windfd_model_path, windfd_args)

# 将 /root/app 目录挂载为静态文件
app.mount("/files", StaticFiles(directory="/root/app"), name="files")

@app.get("/")
async def read_root():
    message = f"Hello world! From FastAPI running on Uvicorn with Gunicorn. Using Python {version}"
    return {"message": message}



# 获取数据界面资源信息
@app.get("/ai-station-api/data_source/show")
async def get_data_source_info():
    sql = "SELECT id,application_name, task_type, sample_name, img_url, time, download_url FROM data_samples"
    data = data_util.fetch_data(sql)
    data = data_util.generate_json_data_source(data)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


# 获取应用界面资源信息
@app.get("/ai-station-api/app_source/show")
async def get_app_source_info():
    sql = "SELECT id,application_name, task_type, sample_name, img_url, time FROM app_samples"
    data = data_util.fetch_data(sql)
    data = data_util.generate_json_app_source(data)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}



# 获取煤基碳材料界面资源信息
@app.get("/ai-station-api/mjtcl_source/show")
async def get_mjtcl_source_info():
    sql = "SELECT id,application_name, task_type, sample_name, img_url, time FROM meijitancailiao_samples"
    data = data_util.fetch_data(sql)
    data = data_util.generate_json_meijitancailiao_source(data)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


# 获取煤热解界面资源信息
@app.get("/ai-station-api/mrj_source/show")
async def get_mrj_source_info():
    sql = "SELECT id,application_name, task_type, sample_name, img_url, time FROM meirejie_samples"
    data = data_util.fetch_data(sql)
    data = data_util.generate_json_meirejie_source(data)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}
    

"""煤基碳材料输入特征说明接口列表 
type = {zongkongtiji,zongbiaomianji,tancailiao,meiliqing,moniqi}
"""
@app.get("/ai-station-api/mjt_feature/show")
async def get_mjt_feature_info(type:str = None):
    # if type in ["tancailiao","meiliqing"]:
    #     sql = "SELECT type, chinese_name, col_name, data_type, unit FROM meijitancailiao_features where use_type = %s;"
    # else:
    sql = "SELECT type, chinese_name, col_name, data_type, unit, data_scale,best_data FROM meijitancailiao_features where use_type = %s;"
    data = data_util.fetch_data_with_param(sql,(type,))
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}
    


"""煤热解材料输入特征说明接口列表
type = {tar,char,gas,water}
"""
@app.get("/ai-station-api/mrj_feature/show")
async def get_mrj_feature_info(type:str = None):
    sql = "SELECT type, chinese_name, col_name, data_type, unit, data_scale FROM meirejie_features where use_type = %s;"
    data = data_util.fetch_data_with_param(sql,(type,))
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}
    
#========================================煤基碳材料 ==================================
@app.post("/ai-station-api/mjt/predict")
async def mjt_models_predict(content: post_model.Zongbiaomianji):
    # 处理接收到的字典数据
    meijiegou_test_content = pd.DataFrame([content.model_dump()])
    meijiegou_test_content= meijiegou_test_content.rename(columns={"K_C":"K/C"})
    new_order = ["A", "VM", "K/C", "MM", "AT", "At", "Rt"]
    meijiegou_test_content = meijiegou_test_content.reindex(columns=new_order)
    ssa_result = model_deal.pred_single_ssa(meijiegou_test_content)
    logger.info("Root endpoint was accessed")
    if ssa_result is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":ssa_result}


#==========================煤基碳材料-总表面积细节接口==================================
"""
模型综合分析
"""
@app.post("/ai-station-api/mjt_models_ssa/predict")
async def mjt_models_predict_ssa(content: post_model.Zongbiaomianji):
    # 处理接收到的字典数据
    meijiegou_test_content = pd.DataFrame([content.model_dump()])
    meijiegou_test_content= meijiegou_test_content.rename(columns={"K_C":"K/C"})
    new_order = ["A", "VM", "K/C", "MM", "AT", "At", "Rt"]
    meijiegou_test_content = meijiegou_test_content.reindex(columns=new_order)
    ssa_result = model_deal.pred_single_ssa(meijiegou_test_content)
    logger.info("Root endpoint was accessed")
    if ssa_result is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":ssa_result}
    

"""
上传文件
"""
@app.post("/ai-station-api/document/upload")
async def upload_file(file: UploadFile = File(...),type: str = Form(...), ):
    if not file.filename.endswith('.csv'):
        raise HTTPException(status_code=400, detail="文件类型有误，必须是 CSV 文件")
    upload_dir  = os.path.join(current_dir,'tmp',type, str(uuid.uuid4()))
    if not os.path.exists(upload_dir ):
        os.makedirs(upload_dir )
    # 将文件保存到指定目录
    file_location = os.path.join(upload_dir , file.filename)
    with open(file_location, "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)
    return {"success":True,
            "msg":"获取信息成功",
            "data":{"location": file_location}}


"""
批量预测接口
"""
@app.get("/ai-station-api/mjt_multi_ssa/predict")
async def mjt_multi_ssa_pred(model:str = None, path:str = None):
    data = model_deal.get_excel_ssa(model, path)
    return {"success":True,
            "msg":"获取信息成功",
            "data":data}



#==========================煤基碳材料-总孔体积细节接口==================================
"""
模型综合分析
"""
@app.post("/ai-station-api/mjt_models_tpv/predict")
async def mjt_models_predict_tpv(content: post_model.Zongbiaomianji):
    # 处理接收到的字典数据
    meijiegou_test_content = pd.DataFrame([content.model_dump()])
    meijiegou_test_content= meijiegou_test_content.rename(columns={"K_C":"K/C"})
    new_order = ["A", "VM", "K/C", "MM", "AT", "At", "Rt"]
    meijiegou_test_content = meijiegou_test_content.reindex(columns=new_order)
    tpv_result = model_deal.pred_single_tpv(meijiegou_test_content)
    if tpv_result is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":tpv_result}

"""
批量预测接口
"""
@app.get("/ai-station-api/mjt_multi_tpv/predict")
async def mjt_multi_tpv_pred(model:str = None, path:str = None):
    data = model_deal.get_excel_tpv(model, path)
    return {"success":True,
            "msg":"获取信息成功",
            "data":data}

#==========================煤基碳材料-煤炭材料应用细节接口==================================
@app.post("/ai-station-api/mjt_models_meitan/predict")
async def mjt_models_predict_meitan(content: post_model.Meitan):
    # 处理接收到的字典数据
    meijiegou_test_content = pd.DataFrame([content.model_dump()])
    meijiegou_test_content= meijiegou_test_content.rename(columns={"ID_IG":"ID/IG"})
    new_order = ["SSA", "TPV", "N", "O", "ID/IG", "J"]
    meijiegou_test_content = meijiegou_test_content.reindex(columns=new_order)
    meitan_result = model_deal.pred_single_meitan(meijiegou_test_content)
    if meitan_result is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":meitan_result}


"""
批量预测接口
"""
@app.get("/ai-station-api/mjt_multi_meitan/predict")
async def mjt_multi_meitan_pred(model:str = None, path:str = None):
    data = model_deal.get_excel_meitan(model, path)
    return {"success":True,
            "msg":"获取信息成功",
            "data":data}


#==========================煤基碳材料-煤沥青应用细节接口==================================
@app.post("/ai-station-api/mjt_models_meiliqing/predict")
async def mjt_models_predict_meiliqing(content: post_model.Meitan):
    # 处理接收到的字典数据
    meijiegou_test_content = pd.DataFrame([content.model_dump()])
    meijiegou_test_content= meijiegou_test_content.rename(columns={"ID_IG":"ID/IG"})
    new_order = ["SSA", "TPV", "N", "O", "ID/IG", "J"]
    meijiegou_test_content = meijiegou_test_content.reindex(columns=new_order)
    meitan_result = model_deal.pred_single_meiliqing(meijiegou_test_content)
    if meitan_result is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":meitan_result}


"""
批量预测接口
"""
@app.get("/ai-station-api/mjt_multi_meiliqing/predict")
async def mjt_multi_meiliqing_pred(model:str = None, path:str = None):
    data = model_deal.get_excel_meiliqing(model, path)
    return {"success":True,
            "msg":"获取信息成功",
            "data":data}




#=============================煤基炭材料-制备模拟器================================================
# 正向模拟器
@app.post("/ai-station-api/mnq_model/analysis")
async def mnq_model_predict(return_count: int,  # 返回条数
    model_choice: str,   # 模型选择标记
    form_data: post_model.FormData # 表单数据 
    ):
    form_data = form_data.model_dump()
    params = prepare_data.get_params(form_data)
    pred_data = prepare_data.create_pred_data(params) 
    result = model_deal.pred_func(model_choice,pred_data)
    sorted_result = result.sort_values(by=['SSA', 'TPV'], ascending=[False, False])
    upload_dir  = os.path.join(current_dir,'tmp','moniqi', str(uuid.uuid4()))
    if not os.path.exists(upload_dir):
        os.makedirs(upload_dir )
    # 将文件保存到指定目录
    file_name = model_choice + "_moniqi.csv"
    file_location = os.path.join(upload_dir , file_name)
    sorted_result.to_csv(file_location, index = False)
    # 保留条数
    if return_count is None:
        return {"success":True,
            "msg":"获取信息成功",
            "data":{"result": sorted_result.to_dict(orient='records'), "path":file_location}}
    else:
        data = sorted_result.iloc[:return_count]
        # logger.info(data.to_dict(orient="records"))
        return {"success":True,
            "msg":"获取信息成功",
            "data":{"result":data.to_dict(orient="records"),  "path":file_location}
        }

# 反向模拟器
@app.get("/ai-station-api/mnq_model/reverse_analysis")
async def mjt_multi_meiliqing_pred(model:str = None, path:str = None, type:int = 1, scale:float=None, num:int=5):
    result = prepare_data.moniqi_data_prepare(model,path,type,scale,num)
    if result['status'] == False:
        return  {
            "success":False,
            "msg":result['reason'],
            "data":None
        }
    else:
        return {
            "success":True,
            "msg":"获取信息成功",
            "data":{"data": result['reason']}
        }


#================================ 地貌识别 ====================================================
"""
上传图片 , type = dimaoshibie
"""
@app.post("/ai-station-api/image/upload")
async def upload_image(file: UploadFile = File(...),type: str = Form(...), ):
    if not data_util.allowed_file(file.filename):
        return  {
            "success":False,
            "msg":"图片必须以 '.jpg', '.jpeg', '.png', '.tif' 结尾",
            "data":None
        }
    if file.size > param.MAX_FILE_SIZE:
        return {
            "success":False,
            "msg":"图片大小不能大于100MB",
            "data":None
        }
    upload_dir  = os.path.join(current_dir,'tmp',type, str(uuid.uuid4()))
    if not os.path.exists(upload_dir):
        os.makedirs(upload_dir )
    # 将文件保存到指定目录
    file_location = os.path.join(upload_dir , file.filename)
    with open(file_location, "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)
    file_location = model_deal.get_pic_url(file_location)
    return {"success":True,
            "msg":"获取信息成功",
            "data":{"location": file_location}}

"""
图片地貌识别
"""
@app.get("/ai-station-api/dmsb_image/analysis")
async def dmsb_image_analysis(path:str = None):
    path = model_deal.get_pic_path(path)
    result = model_deal.dimaoshibie_pic(dimaoshibie_SegFormer,path,param.dmsb_count,param.dmsb_name_classes)
    if result['status'] == False:
        return {"success":False,
                "msg":result['reason'],
                "data":None}
    else:
        path = result['reason']
        path= model_deal.get_pic_url(path[0]) # 是一个列表
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": path}}


"""
图片地貌 - 分割结果计算 ,图片demo的是z17
"""
@app.get("/ai-station-api/dmsb_image/calculate")
async def dmsb_image_calculate(path:str = None, scale:float = 1.92*1.92):
    path = model_deal.get_pic_path(path)
    result = model_deal.dimaoshibie_area(path,scale,param.dmsb_colors)
    logger.info(result)
    if result['status'] == True:
        res = result['reason']
        translated_dict = {param.dmsb_type[key]: value for key, value in res.items()}
        # json_data =  json.dumps(translated_dict)
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": translated_dict}}
    else:
        return {"success":False,
                "msg":result['reason'],
                "data":None}


"""
下载
"""
@app.get("/ai-station-api/download")
async def download_zip(path:str = None):
    path = model_deal.get_pic_path(path)
    zip_filename = "download.zip"
    zip_filepath = Path(zip_filename)
    dir_path = os.path.dirname(path)
    # 创建 ZIP 文件
    try:
        with zipfile.ZipFile(zip_filepath, 'w') as zip_file:
            # 遍历文件夹中的所有文件
            for foldername, subfolders, filenames in os.walk(dir_path):
                for filename in filenames:
                    file_path = os.path.join(foldername, filename)
                    # 将文件写入 ZIP 文件
                    zip_file.write(file_path, os.path.relpath(file_path, dir_path))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error creating zip file: {str(e)}")

    # 返回 ZIP 文件作为响应
    return FileResponse(zip_filepath, media_type='application/zip', filename=zip_filename)
#============================屋顶识别======================================
"""
上传图片  type = roof
"""

"""
图片分析
"""
@app.get("/ai-station-api/roof_image/analysis")
async def roof_image_analysis(path:str = None):
    path = model_deal.get_pic_path(path)
    result = model_deal.roof_pic(roof_model,path,param.wdpv_palette)
    
    if result['status'] == False:
        return {"success":False,
                "msg":result['reason'],
                "data":None}
    else:
        path = result['reason']
        path= model_deal.get_pic_url(path[0])
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": path}}


"""
屋顶面积 图 - 分割结果计算 ,图片demo的是z18
"""
@app.get("/ai-station-api/roof_image/calculate")
async def roof_image_calculate(path:str = None, scale:float = 0.92*0.92):
    path = model_deal.get_pic_path(path)
    result = model_deal.roof_area(path,scale,param.wdpv_colors)
    logger.info(result)
    if result['status'] == True:
        res = result['reason']
        translated_dict = {param.wd_type[key]: value for key, value in res.items()}
        del translated_dict['其他']
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": translated_dict}}
    else:
        return {"success":False,
                "msg":result['reason'],
                "data":None}



#============================光伏识别======================================
"""
上传图片  type = pv
"""
"""
图片分析
"""
@app.get("/ai-station-api/pv_image/analysis")
async def pv_image_analysis(path:str = None):
    path = model_deal.get_pic_path(path)
    result = model_deal.roof_pic(pv_model,path,param.wdpv_palette)
    if result['status'] == False:
        return {"success":False,
                "msg":result['reason'],
                "data":None}
    else:
        path = result['reason']
        path= model_deal.get_pic_url(path[0])
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": path}}

"""
光伏面积 图 - 分割结果计算 ,图片demo的是z18
"""
@app.get("/ai-station-api/pv_image/calculate")
async def pv_image_calculate(path:str = None, scale:float = 0.92*0.92):
    path = model_deal.get_pic_path(path)
    result = model_deal.roof_area(path,scale,param.wdpv_colors)
    logger.info(result)
    if result['status'] == True:
        res = result['reason']
        translated_dict = {param.pv_type[key]: value for key, value in res.items()}
        del translated_dict['其他']
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": translated_dict}}
    else:
        return {"success":False,
                "msg":result['reason'],
                "data":None}

#============================屋顶光伏识别======================================
"""
上传图片  type = roofpv
"""

"""
图片分析
"""
@app.get("/ai-station-api/roofpv_image/analysis")
async def roofpv_image_analysis(path:str = None):
    path = model_deal.get_pic_path(path)
    result = model_deal.roofpv_pic(roof_model,pv_model,path,param.wdpv_palette)
    if result['status'] == False:
        return {"success":False,
                "msg":result['reason'],
                "data":None}
    else:
        file_list = result['reason']
        final_path = prepare_data.merge_binary(file_list)
        final_path = model_deal.get_pic_url(final_path) 
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": final_path}}


"""
光伏面积 图 - 分割结果计算 ,图片demo的是z18
"""
@app.get("/ai-station-api/roofpv_image/calculate")
async def roofpv_image_calculate(path:str = None, scale:float = 0.92*0.92):
    path = model_deal.get_pic_path(path)
    result = model_deal.roof_area_roofpv(path,scale,param.wdpv_colors)
    logger.info(result)
    if result['status'] == True:
        res = result['reason']
        translated_dict = {param.wdpv_type[key]: value for key, value in res.items()}
        del translated_dict['其他']
        return {"success":True,
                "msg":"获取信息成功",
                "data":{"result": translated_dict}}
    else:
        return {"success":False,
                "msg":result['reason'],
                "data":None}

# ====================================时序预测类============================================

# ====================================甲烷预测==============================================

"""
返回显示列表
"""
@app.get("/ai-station-api/ch4_features/show")
async def get_ch4_features_info():
    sql = "SELECT chinese_name, col_name,type,data_type,unit,data_sample FROM ch4_features;"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}



@app.get("/ai-station-api/ch4_pic_table/show")
async def get_ch4_pic_table_info():
    sql = "SELECT chinese_name, col_name FROM ch4_features where col_name != 'date_time';"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


"""
针对列表，返回数据，供画图
"""
@app.get("/ai-station-api/ch4_feature_pic/select")
async def get_ch4_feature_pic_select(type:str = None, path:str =None):
    if type == 'date_time':
        return {
            "success":False,
            "msg":"时间列无法展示，请重新选择",
            "data":None
        }
    data = prepare_data.show_data_jiawanyuce(type,path)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}

"""
上传数据分页展示
"""
@app.get("/ai-station-api/ch4_data/show")
async def get_ch4_data(path:str = None, page: int = Query(1, ge=1), page_size: int = Query(10, ge=1)):
    data = prepare_data.get_jiawanyuce_data(path)
    total_items = len(data)  # 获取总条数
    total_pages = (total_items + page_size - 1) // page_size  # 计算总页数
    # 检查请求的页码是否超出范围
    if page > total_pages:
        raise HTTPException(status_code=404, detail="Page not found")
    # 计算起始和结束索引
    start_idx = (page - 1) * page_size
    end_idx = start_idx + page_size

    # 获取当前页的数据
    items = data.iloc[start_idx:end_idx].to_dict(orient="records")

    # 返回数据，包括总条数、总页数和当前页的数据
    return {
        "success":True,
        "msg":"获取信息成功",
        "data":{
        "total_items": total_items,
        "total_pages": total_pages,
        "current_page": page,
        "page_size": page_size,
        "items": items
        }
    }

"""
csv上传
"""
# @app.post("/ai-station-api/document/upload")   type = "ch4"

"""
预测, type 
"""        
@app.get("/ai-station-api/ch4_data/predict")
async def get_ch4_predict(path:str=None,start_time:str=None, end_time:str = None,type:int=1,is_show:bool=True):
    data = model_deal.start_predict_endpoint(ch4_model_flow,ch4_model_gas,path,start_time,end_time,type,is_show)
    if data['status'] ==False:
        return {
            "success":False,
            "msg":data['reason'],
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data['reason']}


#========================================光伏预测==========================================================
"""
返回显示列表
"""
@app.get("/ai-station-api/pvelectric_features/show")
async def get_pvelectric_features_info():
    sql = "SELECT chinese_name, col_name,type,data_type,unit,data_sample FROM pv_electric_features;"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


@app.get("/ai-station-api/pvelectric_pic_table/show")
async def get_pvelectric_pic_table_info():
    sql = "SELECT chinese_name, col_name FROM pv_electric_features where col_name != 'date_time';"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


"""
针对列表，返回数据，供画图
"""
@app.get("/ai-station-api/pvelectric_feature_pic/select")
async def get_pvelectric_feature_pic_select(type:str = None, path:str =None):
    if type == 'date_time':
        return {
            "success":False,
            "msg":"时间列无法展示，请重新选择",
            "data":None
        }
    data = prepare_data.show_data_pvfd(path,type)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


"""
上传数据分页展示
"""
@app.get("/ai-station-api/pvelectric_data/show")
async def get_pvelectric_data(path:str = None, page: int = Query(1, ge=1), page_size: int = Query(10, ge=1)):
    data = prepare_data.show_testdata_pvfd(path)
    total_items = len(data)  # 获取总条数
    total_pages = (total_items + page_size - 1) // page_size  # 计算总页数
    # 检查请求的页码是否超出范围
    if page > total_pages:
        raise HTTPException(status_code=404, detail="Page not found")
    # 计算起始和结束索引
    start_idx = (page - 1) * page_size
    end_idx = start_idx + page_size

    # 获取当前页的数据
    items = data.iloc[start_idx:end_idx].to_dict(orient="records")

    # 返回数据，包括总条数、总页数和当前页的数据
    return {
        "success":True,
        "msg":"获取信息成功",
        "data":{
        "total_items": total_items,
        "total_pages": total_pages,
        "current_page": page,
        "page_size": page_size,
        "items": items
        }
    }

"""
csv上传
"""
# @app.post("/ai-station-api/document/upload")   type = "pvelectric"

"""
预测, type 
"""        
@app.get("/ai-station-api/pvelectric_data/predict")
async def get_pvelectri_predict(path:str=None,start_time:str=None, end_time:str = None,is_show:bool=True):
    data = model_deal.start_pvelectric_predict_endpoint(pvfd_model,path,start_time,end_time,is_show)
    if data['status'] ==False:
        return {
            "success":False,
            "msg":data['reason'],
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data['reason']}


#========================================风力发电预测==========================================================
"""
返回显示列表
"""
@app.get("/ai-station-api/wind_electric_features/show")
async def get_wind_electric_features_info():
    sql = "SELECT chinese_name, col_name,type,data_type,unit,data_sample FROM wind_electric_features;"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


@app.get("/ai-station-api/wind_electric_pic_table/show")
async def get_wind_electric_pic_table_info():
    sql = "SELECT chinese_name, col_name FROM wind_electric_features where col_name != 'date';"
    data = data_util.fetch_data(sql)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


"""
针对列表，返回数据，供画图
"""
@app.get("/ai-station-api/wind_electric_feature_pic/select")
async def get_wind_electric_feature_pic_select(type:str = None, path:str =None):
    if type == 'date':
        return {
            "success":False,
            "msg":"时间列无法展示，请重新选择",
            "data":None
        }
    data = prepare_data.show_data_windfd(path,type)
    if data is None:
        return {
            "success":False,
            "msg":"获取信息列表失败",
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data}


"""
上传数据分页展示
"""
@app.get("/ai-station-api/wind_electric_data/show")
async def get_wind_electric_data(path:str = None, page: int = Query(1, ge=1), page_size: int = Query(10, ge=1)):
    data = prepare_data.show_testdata_windfd(path)
    total_items = len(data)  # 获取总条数
    total_pages = (total_items + page_size - 1) // page_size  # 计算总页数
    # 检查请求的页码是否超出范围
    if page > total_pages:
        raise HTTPException(status_code=404, detail="Page not found")
    # 计算起始和结束索引
    start_idx = (page - 1) * page_size
    end_idx = start_idx + page_size

    # 获取当前页的数据
    items = data.iloc[start_idx:end_idx].to_dict(orient="records")

    # 返回数据，包括总条数、总页数和当前页的数据
    return {
        "success":True,
        "msg":"获取信息成功",
        "data":{
        "total_items": total_items,
        "total_pages": total_pages,
        "current_page": page,
        "page_size": page_size,
        "items": items
        }
    }

"""
csv上传
"""
# @app.post("/ai-station-api/document/upload")   type = "wind_electric"

"""
预测, type 
"""        
@app.get("/ai-station-api/wind_electric_data/predict")
async def get_wind_electri_predict(path:str=None,start_time:str=None, end_time:str = None,is_show:bool=True):
    data = model_deal.start_wind_electric_predict_endpoint(windfd_model,path,start_time,end_time,is_show)
    if data['status'] ==False:
        return {
            "success":False,
            "msg":data['reason'],
            "data":None
        }
    else:
        return {"success":True,
            "msg":"获取信息成功",
            "data":data['reason']}







# @app.post("/ai-station-api/items/")
# async def create_item(item: post_model.Zongbiaomianji):
#     try:
#         data = {
#             "type": type(item).__name__,  # 返回类型名称
#             "received_data": item.model_dump()  # 使用 model_dump() 方法
#         }
#         print(pd.DataFrame([item.model_dump()]))
#         # 返回接收到的数据
#         return data
#     except Exception as e:
#         # 记录错误信息
#         logger.error(f"Error occurred: {e}")