How to disable the default 422 doc

[Jedore]

FastAPI has a default response doc for 422,

but my response format is :

{
  'code': 0,
  'msg': 'hello',
  'data': <object>
}

and code contains any error code and msg contains any error info. I don't need the default 422 response doc.

I found the code in fastapi/openapi/utils

http422 = str(HTTP_422_UNPROCESSABLE_ENTITY)
            if (all_route_params or route.body_field) and not any(
                [
                    status in operation["responses"]
                    for status in [http422, "4XX", "default"]
                ]
            ):
                operation["responses"][http422] = {
                    "description": "Validation Error",
                    "content": {
                        "application/json": {
                            "schema": {"$ref": REF_PREFIX + "HTTPValidationError"}
                        }
                    },
                }
                if "ValidationError" not in definitions:
                    definitions.update(
                        {
                            "ValidationError": validation_error_definition,
                            "HTTPValidationError": validation_error_response_definition,
                        }
                    )

I think many application will need this feature.
Can you set an optional switch or else that I can disable the default 422 doc? @tiangolo thanks.

[panla]

1, catch exception and rewrite response

def register_exception(app)
    @app.exception_handler(ValidationError)
    async def db_validation_exception_handle(request: Request, exc: ValidationError):

        exc_str = '|'.join(exc.args)
        content = {'code': 0, 'msg': exc_str, 'data': None}
        return JSONResponse(content=content, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)

2, router, api

class ValidatorError(BaseModel):
    code: int = 0
    msg: str = ''
    data: Any = None

error_response = {
    ...
    422: {
        'model': ValidatorError,
        'description': '参数验证错误的返回值 data=null',
    }
}

@router.get('', response_model=YourSchema, status_code=YourCode, responses=error_response)
def func():
    ...

[Jedore]

@panla
Thank you. I think your idea can disable default 422 doc and left custom 422 response. But I wanna remove 422 response. My interfaces only support 200 http code, no 422.

[Jedore]

My solution is inheriting FastAPI class and rewrite openapi method.

[DionVitor]

I want disable 200 http code, because my api never return this code, is a post request.

[kounelios13]

@DionVitor what do you mean ? Regardless of the method you need to send an http status code back

[DionVitor]

@DionVitor what do you mean ? Regardless of the method you need to send an http status code back

Yes, but a post endpoint don't need 200 in my swagger. The solution, customize the openapi dict.

[kounelios13]

@DionVitor what do you mean ? Regardless of the method you need to send an http status code back
Yes, but a post endpoint don't need 200 in my swagger. The solution, customize the openapi dict.

The purpose of the swagger api definition is to include all the possible responses for an endpoint

[DionVitor]

@DionVitor what do you mean ? Regardless of the method you need to send an http status code back

Yes, but a post endpoint don't need 200 in my swagger. The solution, customize the openapi dict.

The purpose of the swagger api definition is to include all the possible responses for an endpoint

Exactly!! 200 status it's not possible in my post endpoint.

[kounelios13]

@DionVitor what do you mean ? Regardless of the method you need to send an http status code back

Yes, but a post endpoint don't need 200 in my swagger. The solution, customize the openapi dict.

The purpose of the swagger api definition is to include all the possible responses for an endpoint

Exactly!! 200 status it's not possible in my post endpoint.

If your endpoint returns a diffferent code you can configure your response code with response_code=<YOUR_CODE>. But by default any operation should return a valid HTTP code to let the client know how to close the communication

https://restfulapi.net/http-status-codes/#:~:text=It%20indicates%20that%20the%20REST,should%20include%20a%20response%20body.

[vanntile]

@kounelios13 I think you misunderstood what @DionVitor meant. I have probably a similar problem. I need to return the validation error with a different status code, but 422 is still in the OpenAPI if I override the ValidationError in FastAPI exception_handlers. Any tips how to remove the entry for 422 in the OpenAPI?

[Jedore]

My newest solution:

app = FastAPI()

def custom_openapi():
    if not app.openapi_schema:
        app.openapi_schema = get_openapi(
            title=app.title,
            version=app.version,
            openapi_version=app.openapi_version,
            description=app.description,
            terms_of_service=app.terms_of_service,
            contact=app.contact,
            license_info=app.license_info,
            routes=app.routes,
            tags=app.openapi_tags,
            servers=app.servers,
        )
        for _, method_item in app.openapi_schema.get('paths').items():
            for _, param in method_item.items():
                responses = param.get('responses')
                # remove 422 response, also can remove other status code
                if '422' in responses:
                    del responses['422']
    return app.openapi_schema

app.openapi = custom_openapi

Hope this is useful. @vanntile @kounelios13

[Jedore]

Another solution:

_openapi = FastAPI.openapi
def openapi(self: FastAPI):
    _openapi(self)

    for _, method_item in self.openapi_schema.get('paths').items():
        for _, param in method_item.items():
            responses = param.get('responses')
            # remove 422 response, also can remove other status code
            if '422' in responses:
                del responses['422']

    return self.openapi_schema

FastAPI.openapi = openapi

app = FastAPI()

[JKearnsl]

My newest solution:

app = FastAPI()

def custom_openapi():
    if not app.openapi_schema:
        app.openapi_schema = get_openapi(
            title=app.title,
            version=app.version,
            openapi_version=app.openapi_version,
            description=app.description,
            terms_of_service=app.terms_of_service,
            contact=app.contact,
            license_info=app.license_info,
            routes=app.routes,
            tags=app.openapi_tags,
            servers=app.servers,
        )
        for _, method_item in app.openapi_schema.get('paths').items():
            for _, param in method_item.items():
                responses = param.get('responses')
                # remove 422 response, also can remove other status code
                if '422' in responses:
                    del responses['422']
    return app.openapi_schema

app.openapi = custom_openapi

Hope this is useful. @vanntile @kounelios13

thank you

[tiangolo]

Thanks for the help and discussion all! ☕

[stavvy-aamiri]

The solutions above feel like a lot of boiler plate. The 422 response code is a reasonable default behavior, but the framework assuming that everyone wants this default behavior doest not feel reasonable. @JKearnsl solution would work, but it would be nice to have a way to inject this behavior instead of forcing people to monkey patch it if they don't want it.

[marcinnformula]

The 422 response code is a reasonable default behavior

Not exactly. The reasonable default status code for validation error is 400 Bad Request, because most of do not use WebDAV protocol. I have no idea how this mistake became de facto standard in FastAPI.

Ad rem, there are three possible solutions to fix the bug of the openapi generator:

• use correct status code by default (400); this would be fine for most cases (let's face it - nobody uses WebDAV); that's easiest and quickest one
• make status code for validation configurable (i.e. allow setting 400 instead of 422)
• allow default responses to override in FastAPI class

[Pluckerpluck]

Agreed. I've just ran into this myself. I want to map the 422 error to a more common 400 error, but there's no simple way to remove the 422 from the docs!

422 isn't included in RFC7231, so it's odd for it to be the default in general.

[biradar73383]

this is my code

import json
from pathlib import Path
from typing import Union

from fastapi import (APIRouter, FastAPI, HTTPException, Request, Response,Query,
Security, status)
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBearer
from pydantic import ValidationError
from src.common.create_jsonfile import create_response_json
from src.common.json_read import properties
from src.schemas.interlude_schemas.common_schemas import
PerformanceProfile_Common
from src.schemas.interlude_schemas.error_schemas import (Error400, Error401,
Error403, Error422,
Error500,Error404)
from src.schemas.interlude_schemas.performance_profile_schema import
PerformanceProfile

from .authentication import Auth
from .response_headers import add_headers

from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from fastapi import FastAPI, HTTPException
from fastapi.responses import PlainTextResponse
from starlette.exceptions import HTTPException as StarletteHTTPException

from fastapi.openapi.utils import get_openapi
from fastapi.openapi.utils import get_openapi

security = HTTPBearer()
auth_handler = Auth()

app = FastAPI()

router = APIRouter(
prefix="/v1/MEF/lsoInterlude"
)
#API to get performanceProfile for particular id
@router.get('/performanceProfile/{id}',tags=["performanceProfile"],response_model=Union[PerformanceProfile,Error404,Error500,Error400,Error403,Error401],
responses={

    200: properties["response_200"],
    400: properties["response_400"],
    401: properties["response_401"],
    403: properties["response_403"],
    404: properties["response_404"],
    500: properties["response_500"]

})
async def Retrieves_a_Performance_Profile_by_ID(id: str):

"""The Administrator or Buyer/Client requests detailed information about a single Performance Profile based on the Profile Identifier."""

if not id:
    error_400 = {"message": "QueryParameter missing", "reason": "The URI is missing a required query-string parameter", "referenceError":"https://tools.ietf.org/html/rfc7231", "code":"missingQueryParameter"}
    json_compatible_item_data = jsonable_encoder(Error400(**error_400))
    return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST, content=json_compatible_item_data,media_type="application/json;charset=utf-8")
else:
    cwd = Path(__file__).parents[1]
    fileName = cwd/'responses'/'interlude_response.json'
    
    with open(fileName, "r") as json_file:
        data = json.load(json_file)  
          
    all_keys= data.keys()
    
    if id in all_keys:
        try:
            jsonresult = data[id]
            json_compatible_item_data = jsonable_encoder(PerformanceProfile(**jsonresult))
            return JSONResponse(status_code=status.HTTP_200_OK, content=json_compatible_item_data,media_type="application/json;charset=utf-8")     
        
        except Exception as err:
            error_500 = {"message": str(err), "reason": "the server encountered an unexpected condition that prevented it from fulfilling the request", "referenceError":"https://tools.ietf.org/html/rfc7231", "code":"internalError"}
            json_compatible_item_data = jsonable_encoder(Error500(**error_500))
            return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=json_compatible_item_data,media_type="application/json;charset=utf-8")   

    else:
        error_404 = {"message": "Invalid id", "reason": "Resource for the requested id not found", "referenceError":"https://tools.ietf.org/html/rfc7231", "code":"notFound"}
        json_compatible_item_data = jsonable_encoder(Error404(**error_404))
        return JSONResponse(status_code=status.HTTP_404_NOT_FOUND, content=json_compatible_item_data)

def custom_openapi():
if not app.openapi_schema:
app.openapi_schema = get_openapi(
title=app.title,
version=app.version,
openapi_version=app.openapi_version,
description=app.description,
terms_of_service=app.terms_of_service,
contact=app.contact,
license_info=app.license_info,
routes=app.routes,
tags=app.openapi_tags,
servers=app.servers,
)
for _, method_item in app.openapi_schema.get('paths').items():
for _, param in method_item.items():
responses = param.get('responses')
# remove 422 response, also can remove other status code
if '422' in responses:
del responses['422']
return app.openapi_schema

app.openapi = custom_openapi

after adding the code then also I'm not able to disable 422 validation error ,how can I remove 422 validation error its coming by default

help me with this @tiangolo @Jedore @vanntile @Pluckerpluck @JKearnsl

[BigSamu]

This works, but now I wonder how I can access the Fastapi default model of 422 Errors, so I can show it in my documentation when necessary

[Jedore]

This works, but now I wonder how I can access the Fastapi default model of 422 Errors, so I can show it in my documentation when necessary

I think you could try to check the pydantic validation logic and fastapi excption handler logic.

[BigSamu]

I have check @Validators decorators from Pydantic, but how I can trigger them if 422 Exception errors are removed from the default behaviour of FastAPI? Pydantic would raise an error in the route method?

[Jedore]

@BigSamu The above method only can remove 422 from the doc schema, can not modify pydantic&fastapi's logic of validation and raising error. Then you could add custom fastapi exception fastapi.exceptions.RequestValidationError handler↪️, in which you can add specified code instead of 422 and show 422 error by your format. As follow:

[BigSamu]

@Jedore, perfect thanks for the advice!

[martincpt]

I made a decorator and decorate the openapi method in runtime. Please note, I only remove the 422 response if the schema ends with HTTPValidationError so it won't remove my custom 422 errors.

from typing import Callable


def customize_openapi(func: Callable[..., dict]) -> Callable[..., dict]:
    """Customize OpenAPI schema."""

    def wrapper(*args, **kwargs) -> dict:
        """Wrapper."""
        res = func(*args, **kwargs)
        for _, method_item in res.get("paths", {}).items():
            for _, param in method_item.items():
                responses = param.get("responses")
                # remove default 422 - the default 422 schema is HTTPValidationError
                if "422" in responses and responses["422"]["content"][
                    "application/json"
                ]["schema"]["$ref"].endswith("HTTPValidationError"):
                    del responses["422"]
        return res

    return wrapper

Usage:

# Create the application
app = FastAPI()
app.openapi = customize_openapi(app.openapi)

[BigSamu]

Thinking that it should be an option to turn off the default 422 response. @tiangolo What do you think about this? There are cases in an API Request that there will be no scenario that returns a 422 response if your route controller is correctly setup.

What others say?

[urunimi]

I don't want to initialize the openapi_schema myself.

Just call the app.openapi() will set the default values. so, here is a better way.

app_ = FastAPI()

for _, method_item in app_.openapi().get("paths").items():
        for _, param in method_item.items():
            responses = param.get("responses")
            if "422" in responses:
                del responses["422"]

[tomako]

Unfortunately this one has some kind of bug when FastAPI is behind a proxy and configured with root_path. It was a weird issue I spent too much time to figure out what was the reason. The OpenAPI web client sent requests without the required root_path while the path for the openapi.json was correct. Sorry I can't tell you what caused it exactly. Anyway, applying any of the other 3 solutions above worked well.

[JonnyBootsNpants]

I do appreciate the assistance, thank you. Ill definitely give it a shot thanks for the tip.

…

________________________________ From: Ben Pyungwoo Yoo ***@***.***> Sent: Wednesday, February 7, 2024 7:17 PM To: tiangolo/fastapi ***@***.***> Cc: Subscribed ***@***.***> Subject: Re: [tiangolo/fastapi] How to disable the default 422 doc (Discussion #6695) I don't want to initialize the openapi_schema myself. Here is a better way. app_ = FastAPI() for _, method_item in app_.openapi().get("paths").items(): for _, param in method_item.items(): responses = param.get("responses") if "422" in responses: del responses["422"] — Reply to this email directly, view it on GitHub<#6695 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/BE7DINDNTFQLWXOFLVRHJADYSQRSVAVCNFSM6AAAAAA2HMZC5SVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4DIMBRG4YDG>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>