async def app(request: Request) -> Response:
body = None
if body_field:
if is_body_form:
raw_body = await request.form()
body = {}
for field, value in raw_body.items():
if isinstance(value, UploadFile):
body[field] = await value.read()
else:
body[field] = value
else:
body = await request.json()
values, errors = await solve_dependencies(request=request,
dependant=dependant,
body=body)
if errors:
errors_out = ValidationError(errors)
raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY,
detail=errors_out.errors())
else:
assert dependant.call is not None, "dependant.call must me a function"
if is_coroutine:
raw_response = await dependant.call(**values)
else:
raw_response = await run_in_threadpool(dependant.call,
**values)
if isinstance(raw_response, Response):
return raw_response
if isinstance(raw_response, BaseModel):
return content_type(content=jsonable_encoder(raw_response),
status_code=status_code)
errors = []
try:
return content_type(
content=serialize_response(field=response_field,
response=raw_response),
status_code=status_code,
)
except Exception as e:
errors.append(e)
try:
response = dict(raw_response)
return content_type(
content=serialize_response(field=response_field,
response=response),
status_code=status_code,
)
except Exception as e:
errors.append(e)
try:
response = vars(raw_response)
return content_type(
content=serialize_response(field=response_field,
response=response),
status_code=status_code,
)
except Exception as e:
errors.append(e)
raise ValueError(errors)
async def app(websocket: WebSocket) -> None:
values, errors, _ = await solve_dependencies(request=websocket,
dependant=dependant)
if errors:
await websocket.close(code=WS_1008_POLICY_VIOLATION)
errors_out = ValidationError(errors)
raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY,
detail=errors_out.errors())
assert dependant.call is not None, "dependant.call must me a function"
await dependant.call(**values)
def level2_validation_handler(request: Request, exc: ValidationError):
"""
Most validation errors are caught immediately, but we do some
secondary validation when populating our xxx_answers tables
this catches those and returns a 422
"""
rslogger.error(exc)
return JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content=jsonable_encoder({"detail": exc.errors()}),
)
async def app(request: Request) -> Response:
try:
body = None
if body_field:
if is_body_form:
body = await request.form()
else:
body_bytes = await request.body()
if body_bytes:
body = await request.json()
except Exception as e:
logging.error(f"Error getting request body: {e}")
raise HTTPException(
status_code=400,
detail="There was an error parsing the body") from e
values, errors, background_tasks = await solve_dependencies(
request=request, dependant=dependant, body=body)
if errors:
errors_out = ValidationError(errors)
raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY,
detail=errors_out.errors())
else:
assert dependant.call is not None, "dependant.call must be a function"
if is_coroutine:
raw_response = await dependant.call(**values)
else:
raw_response = await run_in_threadpool(dependant.call,
**values)
if isinstance(raw_response, Response):
if raw_response.background is None:
raw_response.background = background_tasks
return raw_response
response_data = serialize_response(
field=response_field,
response=raw_response,
include=response_model_include,
exclude=response_model_exclude,
by_alias=response_model_by_alias,
skip_defaults=response_model_skip_defaults,
)
return response_class(
content=response_data,
status_code=status_code,
background=background_tasks,
)
async def app(request: Request) -> Response:
try:
body = None
if body_field:
if is_body_form:
raw_body = await request.form()
form_fields = {}
for field, value in raw_body.items():
if isinstance(value, UploadFile):
form_fields[field] = await value.read()
else:
form_fields[field] = value
if form_fields:
body = form_fields
else:
body_bytes = await request.body()
if body_bytes:
body = await request.json()
except Exception as e:
logging.error("Error getting request body", e)
raise HTTPException(
status_code=400, detail="There was an error parsing the body"
)
values, errors = await solve_dependencies(
request=request, dependant=dependant, body=body
)
if errors:
errors_out = ValidationError(errors)
raise HTTPException(
status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail=errors_out.errors()
)
else:
assert dependant.call is not None, "dependant.call must me a function"
if is_coroutine:
raw_response = await dependant.call(**values)
else:
raw_response = await run_in_threadpool(dependant.call, **values)
if isinstance(raw_response, Response):
return raw_response
response_data = serialize_response(
field=response_field, response=raw_response
)
return content_type(content=response_data, status_code=status_code)
async def validation_exception_response(request: Request, exc: ValidationError):
# logger.debug(traceback.format_exc())
print(traceback.format_exc())
error = exc.errors()[0]
try:
field = error['loc'][1]
except IndexError:
field = ''
err_type = error['type']
if err_type == 'type_error.enum':
msg = error['msg'].replace('value', field, 1)
else:
msg = f"{error['msg']}: {field}"
return UJSONResponse(
status_code=400,
content={
'status': 'error',
'message': msg
},
)
async def validationHandler(request: Request, exc: PydanticValidationError):
return await exceptionHandler(
request,
exceptions.ValidationException(detail=str(exc),
validation=exc.errors()),
)
async def validation_exception_handler(request,
exc: ValidationError) -> JSONResponse:
return JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content=jsonable_encoder({"detail": exc.errors()}),
)
async def validation_error(cls, request: Request, exc: ValidationError):
return JSONResponse(exc.errors(), status_code=400)
async def validationHandler(request: Request, exc: ValidationError):
return await exceptionHandler(
request,
ClientSideException(detail=str(exc), code=422,
validation=exc.errors()))
