Catching general exceptions in Fast API and Custom Message for custom exceptions

I am trying to implement Exception Handling in FastAPI.

1. I have Try along with Exception block in which I am trying to implement Generic Exception if any other exception occurs than HTTPExceptions mentioned in Try Block.
   In generic exception, I would like to print details of actual exception in format { "details": "Actual Exception Details" }
   However, in below implementation, even though any exception in Try is raised it goes to Except block and prints that exception.

2. I Try block specific exceptions, I am trying to have a CustomException class that can print the details of custom exception provded name of exception.

@app.get("/school/studentclass")
async def get_student_class(id: int, stream: str, rank: int = 1):
    try:      
        student = Student(id=id,stream=stream,rank=1)
        if (student.id != 0):
            if (student.stream is not None or  student.stream != ''):
                if(student.rank!= 0):
                   // Student Class is used to represent API Output : Student_Class_Name and Student_Class_Room and Student_Class_Teacher
                    studentClass = StudentClass()
                    // Processing Logic to get Student Class 
                                        
                    return JSONResponse(content=studentClass)
                else:
                    raise HTTPException(status_code = 422, detail = "Student Rank is not right", headers={"X-Error": "Student Rank is not right"})
            else:
                raise HTTPException(status_code = 422, detail="Student Stream is not right", headers={"X-Error": "Student Stream is not right"})
        else:
            raise HTTPException(status_code = 422, detail="Student Id is not right", headers={"X-Error": "Student Id is not right"})
except Exception as e:
        raise HTTPException(status_code = 418, detail=str(e))

Custom Exception Class

class CustomException(Exception):
    def __init__(self, name: str):
        self.name = name

For the second question, I tried to implement as below but it isn't working this way

else:
    raise HTTPException(status_code = 422, detail = CustomException(name = "Invalid Student Rank"), headers={"Error": "Invalid Student Rank"})

The Error Handling is done as follows:

@app.exception_handler(StarletteHTTPException)
async def custom_http_exception_handler(request, exc):
    print(f"HTTP Error: {repr(exc)}")
    return await http_exception_handler(request, exc)
    
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    print(f"Invalid Data: {exc}")
    return await request_validation_exception_handler(request, exc)

You can use conint and constr from Pydantic to limit the ranges of allowed values for your parameters, which will also supply the necessary information if included in documentation. They will generate 422 errors automagically that includes descriptive information about values being too low.

I also strongly suggest following the "return early" rule (even if you're using exceptions here). However, in this case we can make pydantic do all the validation for us, and automagically have FastAPI return a 422 error if the submitted values doesn't conform:

from pydantic import constr, conint

@app.get("/school/studentclass")
async def get_student_class(id: conint(gt=0), stream: constr(min_length=1), rank: conint(gt=0) = 1):
    student = Student(id=id, stream=stream, rank=rank)

    # Student Class is used to represent API Output : Student_Class_Name and Student_Class_Room and Student_Class_Teacher
    
    student_class = StudentClass()
    # Processing Logic to get Student Class 
                                        
    return {"content": student_class)  # I'd also recommend avoiding "content" here as it conveys no meaning at all

I have no idea what your final except is meant to catch (i.e. what exception can be thrown inside Student), but you shouldn't have to handle that yourself (if a custom exception is thrown, use FastAPI's built-in exception handling to handle it).

If you want to take it a bit step further, where this is a common thing you do, move generating the Student object to a separate dependency instead:

from pydantic import constr, conint
from typing import Annotated


async def student_from_url_id(id: conint(gt=0), stream: constr(min_length=1), rank: conint(gt=0) = 1):
    return Student(id=id, stream=stream, rank=rank)


@app.get("/school/studentclass")
async def student_class_endpoint(student: Annotated[Student, Depends(student_from_url_id)])
    student_class = StudentClass()
    # Processing Logic to get Student Class 
                                        
    return {"content": student_class)

That way your dependency can be re-used everywhere you need to fetch a student from a URL-argument for example.

{
  detail: [
    {
      loc: [
        "query",
        "rank"
      ],
      msg: "ensure this value is greater than 0",
      type: "value_error.number.not_gt",
      ctx: {
        limit_value: 0
      }
    }
  ]
}