hxf/backend/main.py

# uvicorn main:app --host 0.0.0.0 --port 8000 --reload
from fastapi import FastAPI
from os.path import dirname, realpath

from dotenv import load_dotenv
load_dotenv()

from utils.util_log import init_logger
from loguru import logger
base_dir: str = dirname(realpath(__file__))
init_logger(base_dir)

from th_agenter.api.routes import router
from contextlib import asynccontextmanager
from starlette.exceptions import HTTPException as StarletteHTTPException
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.staticfiles import StaticFiles
@asynccontextmanager
async def lifespan(app: FastAPI):
    """Application lifespan manager."""
    logger.info("[生命周期] - Starting up TH Agenter application...")
    yield
    # Shutdown
    logger.info("[生命周期] - Shutting down TH Agenter application...")

def setup_exception_handlers(app: FastAPI) -> None:
    """Setup global exception handlers."""
    
    # Import custom exceptions and handlers
    from utils.util_exceptions import ChatAgentException, chat_agent_exception_handler
    
    @app.exception_handler(ChatAgentException)
    async def custom_chat_agent_exception_handler(request, exc):
        return await chat_agent_exception_handler(request, exc)
    
    @app.exception_handler(StarletteHTTPException)
    async def http_exception_handler(request, exc):
        from utils.util_exceptions import HxfErrorResponse
        logger.exception(f"HTTP Exception: {exc.status_code} - {exc.detail} - {request.method} {request.url}")
        return HxfErrorResponse(exc.status_code, exc.detail)
    
    def make_json_serializable(obj):
        """递归地将对象转换为JSON可序列化的格式"""
        if obj is None or isinstance(obj, (str, int, float, bool)):
            return obj
        elif isinstance(obj, bytes):
            return obj.decode('utf-8')
        elif isinstance(obj, (ValueError, Exception)):
            return str(obj)
        elif isinstance(obj, dict):
            return {k: make_json_serializable(v) for k, v in obj.items()}
        elif isinstance(obj, (list, tuple)):
            return [make_json_serializable(item) for item in obj]
        else:
            # For any other object, convert to string
            return str(obj)

    @app.exception_handler(RequestValidationError)
    async def validation_exception_handler(request, exc):
        # Convert any non-serializable objects to strings in error details
        try:
            errors = make_json_serializable(exc.errors())
        except Exception as e:
            # Fallback: if even our conversion fails, use a simple error message
            errors = [{"type": "serialization_error", "msg": f"Error processing validation details: {str(e)}"}]
            logger.exception(f"Request Validation Error: {errors}")
        
        logger.exception(f"validation_error: {errors}")
        return JSONResponse(
            status_code=422,
            content={
                "error": {
                    "type": "validation_error",
                    "message": "Request validation failed",
                    "details": errors
                }
            }
        )
    
    @app.exception_handler(Exception)
    async def general_exception_handler(request, exc):
        logger.error(f"Unhandled exception: {exc}", exc_info=True)
        return JSONResponse(
            status_code=500,
            content={
                "error": {
                    "type": "internal_error",
                    "message": "Internal server error"
                }
            }
        )

def create_app() -> FastAPI:
    """Create and configure FastAPI application."""
    from th_agenter.core.config import get_settings
    settings = get_settings()
    
    # Create FastAPI app
    app = FastAPI(
        title=settings.app_name,
        version=settings.app_version,
        description="基于Vue的第一个聊天智能体应用，使用FastAPI后端，由TH Agenter修改",
        debug=settings.debug,
        lifespan=lifespan,
    )
    app.mount("/static", StaticFiles(directory="static"), name="th_agenter_static")
    
    # Add middleware
    from th_agenter.core.app import setup_middleware
    setup_middleware(app, settings)  
    
    # # Add exception handlers
    setup_exception_handlers(app)
    add_router(app)

    return app

def add_router(app: FastAPI) -> None:
    """Add default routers to the FastAPI application."""

    @app.get("/")
    def read_root():
        logger.info("Hello World")
        return {"Hello": "World"}

    # Include routers
    app.include_router(router, prefix="/api")



    # app.include_router(table_metadata.router)
    # # 在现有导入中添加
    # from ..api.endpoints import database_config

    # # 在路由注册部分添加
    # app.include_router(database_config.router)
    # # Health check endpoint
    # @app.get("/health")
    # async def health_check():
    #     return {"status": "healthy", "version": settings.app_version}
    
    # # Root endpoint
    # @app.get("/")
    # async def root():
    #     return {"message": "Chat Agent API is running"}
    
    # # Test endpoint
    # @app.get("/test")
    # async def test_endpoint():
    #     return {"message": "API is working"}
    

app = create_app()

# from utils.util_test import test_db
# test_db()