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))