python_ai/main.py

# from flask import Flask, request, jsonify, Response
import os
from checkPlaceName import checkPlaceName
from checkRepeatText import checkRepeatText
from checkCompanyName import checkCompanyName
from checkDocumentError import checkDocumentError
from checkTitleName import checkTitleName
# from flask_cors import CORS
import qwen_agenttext
from myLogger import outLog
import time
# app = Flask(__name__)
# cros = CORS(app)
import uvicorn
from fastapi import FastAPI, Request, File, UploadFile, HTTPException
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from sse_starlette.sse import EventSourceResponse
import asyncio

app = FastAPI()
# 允许所有来源的跨域请求
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"]
)

UPLOAD_FOLDER = 'uploads'
if not os.path.exists(UPLOAD_FOLDER):
    os.makedirs(UPLOAD_FOLDER)


# @app.route('/upload', methods=['POST'])
# def upload_file():
#     if 'file' not in request.files:
#         return jsonify({"error": "No file part"}), 400
#     file = request.files['file']
#     if file.filename == '':
#         return jsonify({"error": "No selected file"}), 400
#     if file:
#         filename = file.filename
#         file.save(os.path.join(UPLOAD_FOLDER, filename))
#         return jsonify({"message": "File uploaded successfully"}), 200
@app.post("/sse/upload")
async def upload_file(file: UploadFile = File(...)):
    if not file.filename:
        raise HTTPException(status_code=400, detail="No selected file")

    # 保存文件
    try:
        file_location = os.path.join(UPLOAD_FOLDER, file.filename)
        with open(file_location, "wb") as f:
            content = await file.read()
            f.write(content)
        return JSONResponse(content={"message": "文件上传成功"}, status_code=200)
    except Exception as e:
        raise HTTPException(status_code=500, detail="文件上传失败，错误信息：" + str(e))


@app.get("/sse")
async def root(request: Request):
    async def event_generator(request: Request):
        res_str = "七夕情人节即将来临，我们为您准备了精美的鲜花和美味的蛋糕"
        for i in res_str:
            if await request.is_disconnected():
                print("连接已中断")
                break
            yield {
                "event": "message",
                "id": "7",
                "data": f"{i}"
            }

            await asyncio.sleep(0.1)

    g = event_generator(request)
    return EventSourceResponse(g)


# def stream_numbers():
#     context = request.args.get('context')
#     # def generate_numbers():
#     #     event_id=0
#     #     for number in range(1, 10):
#     #         json_data = json.dumps({"number": number})
#     #         print(json_data)
#     #         event_id += 1
#     #         yield f"id: {event_id}\n"
#     #         yield f"event: time-update\n"
#     #         yield f"data: {json_data}\n\n"  # 每次生成一个数字就发送
#     #         time.sleep(0.5)  # 为了演示，加入短暂延迟
#     #     json_data = json.dumps({"number": "done"})
#     #     yield f"id: {1}\n"
#     #     yield f"event: time-update\n"
#     #     yield f"data: {json_data}\n\n"  # 发送完成信号

#     headers = {
#         "Content-Type": "text/event-stream",
#         "Cache-Control": "no-cache",
#         "X-Accel-Buffering": "no",
#         "Access-Control-Allow-Origin": "*",
#         "Access-Control-Allow-Methods": "GET,POST",
#         "Access-Control-Allow-Headers": "x-requested-with,content-type",
#     }
#     return Response(qwen_agenttext.getxinx(context), headers=headers)

@app.get("/sse/checkRepeatText")
async def checkRepeatTextWeb(filename, userId, request: Request):
    async def generate_checkRepeatText(filename, userId, request: Request):
        global outLog
        id = 0
        for i in checkRepeatText(filename, userId, outLog):
            id += 1
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkRepeatText",
                    "data": "checkRepeatText连接已中断"
                }
                break
            yield {
                "id": f"{id}",
                "event": "checkRepeatText",
                "data": i
            }

    g = generate_checkRepeatText(filename, userId, request)
    return EventSourceResponse(g)


@app.get('/sse/checkPlaceName')
def checkPlaceNameWebSse(filename, userId, request: Request):
    async def generate_checkPlaceName(filename, userId, request: Request):
        id = 0
        global outLog
        for i in checkPlaceName(filename, userId, outLog):
            id += 1
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkPlaceName",
                    "data": "checkPlaceName连接已中断"
                }
                break
            yield {
                "id": f"{id}",
                "event": "checkPlaceName",
                "data": i
            }

    g = generate_checkPlaceName(filename, userId, request)
    return EventSourceResponse(g)


@app.get('/sse/checkCompanyName')
def checkCompanyNameWebSse(filename, userId, request: Request):
    async def generate_checkCompanyName(filename, userId, request: Request):
        id = 0
        global outLog
        for i in checkCompanyName(filename, userId, outLog):
            id += 1
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkCompanyName",
                    "data": "checkCompanyName连接已中断"
                }
                break
            yield {
                "id": f"{id}",
                "event": "checkCompanyName",
                "data": i
            }

    g = generate_checkCompanyName(filename, userId, request)
    return EventSourceResponse(g)


@app.get('/sse/checkDocumentErrorWeb')
def checkDocumentErrorWebSse(filename, userId, request: Request):
    async def generate_checkDocumentError(filename, userId, request: Request):
        id = 0
        global outLog
        for i in checkDocumentError(filename, userId, outLog):
            id += 1
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkDocumentError",
                    "data": "checkDocumentError连接已中断"
                }
                break
            yield {
                "id": f"{id}",
                "event": "checkDocumentError",
                "data": i
            }

    g = generate_checkDocumentError(filename, userId, request)
    return EventSourceResponse(g)


@app.get('/sse/checkTitleName')
def checkTitleNameWebSse(filename, userId, request: Request):
    async def generate_checkTitleName(filename, userId, request: Request):
        id = 0
        global outLog
        for i in checkTitleName(filename, userId, outLog):
            id += 1
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkTitleName",
                    "data": "checkTitleName连接已中断"
                }
                break
            yield {
                "id": f"{id}",
                "event": "checkTitleName",
                "data": i
            }

    g = generate_checkTitleName(filename, userId, request)
    return EventSourceResponse(g)


@app.get("/sse/getLog")
# @app.route('/sse/getLog', methods=['GET'])
async def getlog(userId, request: Request):
    # userId = request.args.get("userId")
    async def generate_getLog(userId):
        id = 0
        global outLog
        await asyncio.sleep(5)
        while True:
            isbreak = outLog.is_done(userId)
            if isbreak:
                break  # 完成了
            text = outLog.get_queueData(userId)
            if await request.is_disconnected():
                yield {
                    "id": f"{id}",
                    "event": "checkTitleName",
                    "data": "checkTitleName连接已中断"
                }
                break
            if text:
                id += 1
                yield {
                    "id": id,
                    "event": "getlog",
                    "data": text
                }
                # yield f"id: {id}\n"
                # yield f"event: getlog\n"
                # yield f"data: {text}\n\n"  # 发送完成信号
        # yield f"id: {id}\n"
        # yield f"event: getlog\n"
        # yield f"data: 任务结束！！！！！\n\n"  # 发送完成信号
        yield {
            "id": id,
            "event": "getlog",
            "data": "任务结束！！！！"
        }
        outLog.del_queue(userId)

    # headers = {
    #     "Content-Type": "text/event-stream",
    #     "Cache-Control": "no-cache",
    #     "X-Accel-Buffering": "no",
    #     "Access-Control-Allow-Origin": "*",
    #     "Access-Control-Allow-Methods": "GET,POST",
    #     "Access-Control-Allow-Headers": "x-requested-with,content-type",
    # }
    g = generate_getLog(userId)
    return EventSourceResponse(g)
    # return Response(generate_getLog(userId), headers=headers)


if __name__ == '__main__':
    # app.run(host="0.0.0.0", port=80,threaded=True)
    # uvicorn.run(app='main:app', host="0.0.0.0", port=80,workers=1)
    app.run()