async def search(
search_context: SearchContext = Depends(get_es_search_context)):
"""
:param search_context:
:return: BundleType
"""
try:
bundle = await fhir_search(
search_context,
params=search_context.engine.request.query_params.multi_items()
or None,
response_as_dict=True,
)
return fhir_rest_response(search_context.engine.request,
bundle,
status_code=200)
except SearchValidationError as exc:
new_exc = RequestValidationError(
[ErrorWrapper(exc, ("request", ))],
body="Search Validation Error",
)
# some hack
new_exc.code = "value"
new_exc.system_code = "MSG_BAD_FORMAT"
raise new_exc
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
print(jsonable_encoder({"detail": exc.errors(), "body": exc.body}))
return JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content=jsonable_encoder({
"detail": exc.errors(),
"body": exc.body
}),
)
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content=jsonable_encoder({
"message": "An error occurred",
"loc": exc.errors()[0]["loc"],
"detail": exc.errors()[0]["msg"]
}),
)
async def handle_validation_error(
request: Request,
exc: RequestValidationError,
) -> Response:
print(f"Validation error on {request.url}", "\n", exc.errors())
return Response(
content=orjson.dumps(exc.errors()),
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
)
async def validation_exception_handler(request, exc: RequestValidationError):
"""
Validation exception handler with localization
"""
for error in exc.errors():
error['msg'] = lazy_gettext(error['msg'])
response = TranslateJsonResponse(
{"detail": exc.errors()},
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
return response.translate_content(request.state.gettext)
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 json.JSONDecodeError as e:
raise RequestValidationError(
[ErrorWrapper(e, ("body", e.pos))], body=e.doc)
except Exception as e:
raise HTTPException(
status_code=400, detail="There was an error parsing the body"
) from e
solved_result = await solve_dependencies(
request=request,
dependant=dependant,
body=body,
dependency_overrides_provider=dependency_overrides_provider,
)
values, errors, background_tasks, sub_response, _ = solved_result
if errors:
raise RequestValidationError(errors, body=body)
else:
raw_response = await run_endpoint_function(
dependant=dependant, values=values, is_coroutine=is_coroutine
)
if isinstance(raw_response, Response):
if raw_response.background is None:
raw_response.background = background_tasks
return raw_response
response_data = await serialize_response(
field=response_field,
response_content=raw_response,
include=response_model_include,
exclude=response_model_exclude,
by_alias=response_model_by_alias,
exclude_unset=response_model_exclude_unset,
exclude_defaults=response_model_exclude_defaults,
exclude_none=response_model_exclude_none,
is_coroutine=is_coroutine,
)
response = actual_response_class(
content=response_data,
status_code=status_code,
background=background_tasks, # type: ignore # in Starlette
)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
return response
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
return JSONResponse(
# by default FastAPI responds with 422 on request validation errors, we want good ol' 400
status_code=status.HTTP_400_BAD_REQUEST,
content=jsonable_encoder({
"detail":
exc.errors(),
# DEMO: transform errors
"demo_errors": [{
".".join(error["loc"]): {error["msg"]}
} for error in exc.errors()],
}),
)
async def handle_request_validation_error(request: Request,
exc: RequestValidationError):
logger.error(exc)
# 自定义异常提示
msg = set()
for err in exc.errors():
if err['type'] == "value_error.paramsvalue":
msg.add(err['msg'])
resp = {}
if not isFormalSystem:
resp = exc.errors()
return comm_ret(code=resp_code.PARAMETER_ERROR,
msg="\n".join(msg) or "请求参数异常",
resp=resp)
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
"""
捕获请求参数 验证错误
:param request:
:param exc:
:return:
"""
data = exc.errors()[0]["msg"]
print(traceback.format_exc())
logger.error(
f"参数错误\nURL:{request.url}\nHeaders:{request.headers}\n{exc.errors()[0]['loc']}\n{data}"
)
return ValidationErrorResponse(content=exc.errors()[0]['loc'])
def validate_object(obj: BaseModel, is_request: bool = True):
*_, validation_error = validate_model(obj.__class__, obj.__dict__)
if validation_error:
if is_request:
raise RequestValidationError(validation_error.raw_errors)
raise validation_error
def _build_errors(cls, ex: RequestValidationError) -> list:
errors = []
for error in ex.errors():
_, _, field = error.get('loc')
message = error.get('msg')
errors.append(Error.of(field, message))
return errors
def request_validation_exception_handler(
request: Request, exc: RequestValidationError
) -> JSONResponse:
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content={"detail": exc.errors()},
)
def aggregate():
query = objects.filter(q_filters)
fields = []
annotations = {
'value':
getattr(aggregates,
aggregation_function.value.title())(field.value),
}
try:
if group_by:
fields += [g.value for g in group_by]
query = query.values(*fields).annotate(**annotations)
return list(pagination.query(query).values(*fields, 'value'))
else:
query = query.aggregate(**annotations)
return [query]
except ProgrammingError as error:
if error.__cause__.pgcode in (
psycopg2_error_codes.UNDEFINED_FUNCTION):
raise RequestValidationError([
ErrorWrapper(ProgrammingError(),
("query", "aggregation_function"))
]) from error
raise
async def validation_exception_handler(request: Request, exc: RequestValidationError):
json_error = JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content=jsonable_encoder({"detail": exc.errors(), "body": exc.body})
)
print("WARN - Estructura invalida - {}".format(json_error))
return json_error
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
error_id = str(uuid4())
headers = getattr(exc, 'headers', None)
response_data = {'detail': exc.errors(), 'error_id': error_id}
await _generate_log(error_id, request, 422, exc)
return await _generate_response(headers, response_data, 422)
async def validation_exception_handler(
request: Request, exc: RequestValidationError
):
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content=jsonable_encoder({"errors": exc.errors()}),
)
def create_endpoint(self, *, request: Request, data: Dict[str, Any]):
try:
validated_data = self.create_validator.validate(data).dict()
model = self.create(data=validated_data)
except ValidationError as e:
raise RequestValidationError(errors=e.raw_errors, body=data)
return self.read_validator.from_orm(model)
def test_from_request_validation_error():
problem = middleware.from_request_validation_error(
RequestValidationError(errors=[
ErrorWrapper(ValueError('foo'), 'here'),
ErrorWrapper(ValueError('bar'), 'there'),
], ))
assert problem == middleware.Problem(
type='',
title='Validation Error',
status=400,
detail='One or more user-provided parameters are invalid',
errors=[
{
'loc': ('here', ),
'msg': 'foo',
'type': 'value_error',
},
{
'loc': ('there', ),
'msg': 'bar',
'type': 'value_error',
},
],
)
async def database_validation_exception_handler(
request: Request, exc: DatabaseValidationError) -> JSONResponse:
return await request_validation_exception_handler(
request,
RequestValidationError(
[ErrorWrapper(ValueError(exc.message), exc.field or "__root__")]),
)
def make_outcome(request: Request, exc: RequestValidationError):
"""
https://terminology.hl7.org/2.0.0/CodeSystem-operation-outcome.html
:param exc:
:param status_code:
:return:
"""
klass = lookup_fhir_class(
"OperationOutcome", fhir_release=request.scope["FHIR_VERSION"]
)
issues = list()
for error in exc.errors():
issue = {
"severity": "error",
"code": exc.code,
"details": {
"coding": [
{
"system": "http://terminology.hl7.org/CodeSystem/operation-outcome",
"code": exc.system_code,
"display": exc.body,
}
]
},
"diagnostics": f"loc: {error['loc']}, message: {error['msg']}",
}
issues.append(issue)
outcome = klass(**{"id": str(request.scope["FHIR_REQUEST_ID"]), "issue": issues})
return outcome
async def query_entrypoint(query: EncodedRequest):
"""Validate and process input request.
Arguments:
query {dict} -- Encoded JWT
Returns:
{obj} -- JSON response
"""
try:
log.debug(f"Raw Query JSON: {query.json()}")
decrypted_query = await jwt_decode(query.encoded)
decrypted_query = json.loads(decrypted_query)
log.debug(f"Decrypted Query: {decrypted_query}")
validated_query = Request(**decrypted_query)
query_output = await run_query(validated_query)
log.debug(f"Query Output:\n{query_output}")
encoded = await jwt_encode(query_output)
return {"encoded": encoded}
except ValidationError as err_validation:
raise RequestValidationError(str(err_validation))
except HyperglassAgentError as err_agent:
raise HTTPException(status_code=err_agent.code, detail=str(err_agent))
async def handle_req(self,
http_request: Request,
background_tasks: BackgroundTasks,
req: Any,
dependency_cache: dict = None,
shared_dependencies_error: BaseError = None):
try:
JsonRpcRequest.validate(req)
except DictError:
raise InvalidRequest(
data={
'errors': [{
'loc': (),
'type': 'type_error.dict',
'msg': "value is not a valid dict",
}]
})
except ValidationError as exc:
raise invalid_request_from_validation_error(exc)
if req['method'] != self.name:
raise MethodNotFound
if shared_dependencies_error:
raise shared_dependencies_error
# dependency_cache - there are shared dependencies, we pass them to each method, since
# they are common to all methods in the batch.
# But if the methods have their own dependencies, they are resolved separately.
dependency_cache = dependency_cache.copy()
values, errors, background_tasks, sub_response, _ = await solve_dependencies(
request=http_request,
dependant=self.func_dependant,
body=req['params'],
background_tasks=background_tasks,
dependency_overrides_provider=self.dependency_overrides_provider,
dependency_cache=dependency_cache,
)
if errors:
raise invalid_params_from_validation_error(
RequestValidationError(errors))
result = await call_sync_async(self.func, **values)
response = {'jsonrpc': '2.0', 'result': result, 'id': req.get('id')}
# noinspection PyTypeChecker
resp = await serialize_response(
field=self.secure_cloned_response_field,
response=response,
include=self.response_model_include,
exclude=self.response_model_exclude,
by_alias=self.response_model_by_alias,
exclude_unset=self.response_model_exclude_unset,
)
return resp
async def validation_exception_handler_error(
request: Request, exc: RequestValidationError
):
error_out = utils.convert_error_pydantic(exc.errors())
return JSONResponse(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
content={"error": error_out, "status": "failed"},
)
def override_fastapi_default_422_response_with_400_on_invalid_payloads(
request: Request,
exception: RequestValidationError,
) -> None:
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content={'detail': exception.errors()},
)
def predict(self, input):
logging.debug('Begin prediction')
if self.status == ServableStatus.IDLE or self.status == ServableStatus.PREDICTING:
self.status = ServableStatus.PREDICTING
response = self.model.predict(input)
self.status = ServableStatus.IDLE
return response
raise RequestValidationError('No model available') # TODO this error is totally wrong
async def rve_error_handler(request: Request,
exc: RequestValidationError) -> ORJSONResponse:
"""Use JSEND protocol for validation errors."""
return ORJSONResponse(status_code=422,
content={
"status": "failed",
"message": json.loads(exc.json())
})
def validation_exception_handler(request, exc: RequestValidationError):
error_code = 1000
print(generate_error_message(error_code), exc)
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content=generate_error_content(error_code=error_code,
error_detail=exc.errors()),
)
async def handle_validation_error(request, exc: RequestValidationError):
return JSONResponse(
{
'error': ErrorType.VALIDATION_ERROR,
'detail': exc.errors(),
},
status_code=422,
)
async def validation_execption_handler(request: Request, exc: RequestValidationError):
"""Adjust validation error output to conform to schema"""
detail = []
for err in exc.errors():
if "loc" in err:
err["loc"] = (str(v) for v in err["loc"]) # sometimes not string
detail.append(err)
return JSONResponse(status_code=422, content=jsonable_encoder({"detail": detail}))
async def validation_exception_handler(request: Request,
exc: RequestValidationError):
res = []
for error_obj in exc.errors():
res.append({error_obj['loc'][-1]: error_obj['msg']})
return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST,
content=BaseResponse.error_response(
error=res, status=status.HTTP_400_BAD_REQUEST))
