FastAPI后台开发基础（13）： 异常处理 Exception

items = {"foo": "The Foo Wrestlers"}


@app.get("/items/{item_id}")
async def read_item(item_id: str):
    """
    the in operator for dictionaries checks if the given key exists in the dictionary
    in items is slightly more efficient because it directly uses the dictionary's hash table for lookup
    the items.keys() method is more useful when you need to perform operations on the keys themselves,
    such as set operations or when you need to pass the keys to another function
        common_keys = set(items.keys()) & set(other_dict.keys())
    """
    if item_id not in items:
        """
        The situation with HTTP headers and character encoding is a bit nuanced:
        Header Names: These should always be ASCII characters. 
                      This is a strict requirement in the HTTP specification.
        Header Values: The HTTP/1.1 specification (RFC 7230) states that header field values may contain 
                       any character from the ASCII character set, except for a few specific control characters. 
                       However, non-ASCII characters (like Chinese characters) are not directly supported in header values.
        Practical Implementation: Many modern web servers and clients can handle non-ASCII characters in header values, 
                                  but this is not guaranteed to work universally. 
                                  It may cause issues with some servers, proxies, or other intermediaries.
        Best Practices: To ensure maximum compatibility and adherence to standards, 
                        it's recommended to restrict header values to ASCII characters. 
                        When you need to include non-ASCII content, 
                        you should encode it (using methods like URL encoding, Base64, etc.) as we discussed earlier.
        """
        raise HTTPException(status_code = 404,
                            detail = "Item not found",
                            headers = {
                                "my-header": quote("this is my header error info 中文信息"),
                                "Content-Type": "application/json; charset=utf-8"
                            })
    return {"item": items[item_id]}

class MyException(Exception):
    def __init__(self):
        self.occurred_time = datetime.datetime.now().isoformat()
        self.uuid = uuid.uuid4().hex


@app.exception_handler(MyException)
def my_exception_handler(request: Request, exc: MyException):
    return JSONResponse(
        status_code = http.HTTPStatus.BAD_REQUEST,
        content = {
            'exception_occurred_time': exc.occurred_time,
            'exception_uuid': exc.uuid,
            'method': request.method,
            'url': f'{request.url.scheme}://{request.url.hostname}:{request.url.port}{request.url.path}',
            'headers': dict(request.headers.items()),
        })


@app.post('/raise_my_exception/{test_id}')
def raise_my_exception(test_id: str, req: Request):
    if test_id == 'raise':
        raise MyException()
    else:
        return JSONResponse(
            status_code = http.HTTPStatus.OK,
            content = {
                'url': f'{req.url.scheme}://{req.url.hostname}:{req.url.port}{req.url.path}',
                'method': req.method,
                'headers': dict(req.headers.items()),
            }
        )

class MyException(Exception):
    def __init__(self):
        self.occurred_time = datetime.datetime.now().isoformat()
        self.uuid = uuid.uuid4().hex

@app.exception_handler(MyException)
def my_exception_handler(request: Request, exc: MyException):
    return JSONResponse(
        status_code = http.HTTPStatus.BAD_REQUEST,
        content = {
            'exception_occurred_time': exc.occurred_time,
            'exception_uuid': exc.uuid,
            'method': request.method,
            'url': f'{request.url.scheme}://{request.url.hostname}:{request.url.port}{request.url.path}',
            'headers': dict(request.headers.items()),
        }
    )

@app.post('/raise_my_exception/{test_id}')
def raise_my_exception(test_id: str, req: Request):
    if test_id == 'raise':
        raise MyException()
    else:
        return JSONResponse(
            status_code = http.HTTPStatus.OK,
            content = {
                'url': f'{req.url.scheme}://{req.url.hostname}:{req.url.port}{req.url.path}',
                'method': req.method,
                'headers': dict(req.headers.items()),
            }
        )

@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
    """
        HTTPException is a subclass of StarletteHTTPException
        so when you raise an HTTPException
        it's caught by the StarletteHTTPException handler
    """
    return PlainTextResponse(str(f'http_exception_handler, '
                                 f'this is my http exception info:{exc.detail}, '
                                 f'req headers: {request.headers}'
                                 f'req url: {request.url.path}'),
                             status_code = exc.status_code)


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    """
        RequestValidationError is a specific exception raised by Pydantic when request validation fails
        It's caught by the RequestValidationError handler
        the custom ValidationException doesn't work with the RequestValidationError handler (they're unrelated)

        when you raise an exception
        FastAPI looks for the most specific matching exception handler
        If it doesn't find one
        it moves up the exception hierarchy
        until it finds a suitable handler
        or reaches the default exception handling behavior.

        FastAPI doesn't have a built-in exception class specifically named "ValidationException".
        Instead, it primarily uses the following exception classes for validation-related issues:
            RequestValidationError: This is raised when the incoming request data fails validation against the defined model or parameters.
                                    It's part of FastAPI and is raised automatically when request data doesn't match the expected schema.

            ValidationError: This is a Pydantic exception, which FastAPI uses internally.
                             It's raised when data fails validation against a Pydantic model.
    """
    return PlainTextResponse(str(f'validation_exception_handler, '
                                 f'this is my validation exception info: {exc.errors()},'
                                 f'req headers: {request.headers},'
                                 f'req url: {request.url.path},'
                                 f'body: {exc.body}'),
                             status_code = 400)


@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 0:
        raise HTTPException(status_code = 418, detail = f'item_id is {item_id}')
    if item_id == 1:
        """
        curl -X 'GET' 'http://127.0.0.1:18081/items/abc' -H 'accept: application/json'
        """
        raise RequestValidationError(errors = ['ABC', 'DEF'])
    return {"item_id": item_id}


class Item(BaseModel):
    title: str
    size: int


@app.post("/items/")
async def create_item(item: Item):
    return item

@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
    return PlainTextResponse(
        str(f'http_exception_handler, this is my http exception info:{exc.detail}, req headers: {request.headers} req url: {request.url.path}'),
        status_code=exc.status_code
    )

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    return PlainTextResponse(
        str(f'validation_exception_handler, this is my validation exception info: {exc.errors()}, req headers: {request.headers}, req url: {request.url.path}, body: {exc.body}'),
        status_code=400
    )

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 0:
        raise HTTPException(status_code=418, detail=f'item_id is {item_id}')
    if item_id == 1:
        raise RequestValidationError(errors=['ABC', 'DEF'])
    return {"item_id": item_id}