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
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 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))
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
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
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
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)
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__")]),
)
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
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 JSONForm_warpper(formdata: str = Form(*args, **kwargs)) -> Any:
try:
return json.loads(formdata)
except:
# 这种情况只能判断为客户端传了个非json字符串过来...
raise RequestValidationError([
ErrorWrapper(PydanticErrors.JsonError(),
["body", "<JSONFormField>"])
])
async def app(request: Request) -> Response:
try:
body: Any = None
if body_field:
if is_body_form:
body = await request.form()
else:
body_bytes = await request.body()
if body_bytes:
if (request.headers.get("Content-Type",
"application/octet-stream") ==
"application/json"):
body = await request.json()
else:
body = body_bytes
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 = response_class(
content=response_data,
status_code=status_code,
background=background_tasks,
)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
return response
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:
logger.error(f"Error getting request body: {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:
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 = await serialize_response(
field=response_field,
response=raw_response,
include=response_model_include,
exclude=response_model_exclude,
by_alias=response_model_by_alias,
exclude_unset=response_model_exclude_unset,
is_coroutine=is_coroutine,
)
response = response_class(
content=response_data,
status_code=status_code,
background=background_tasks,
)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
return response
def update_endpoint(self, *, request: Request, data: Dict[str, Any]):
try:
validated_data = self.update_validator.validate(data).dict()
model = self.update(data=validated_data)
except ValidationError as e:
raise RequestValidationError(errors=e.raw_errors, body=data)
except DaoNotFoundException as e:
raise HTTPException(
status_code=404,
detail=get_message(CrudMessageKeys.NOT_FOUND, self.vocabulary),
)
return self.read_validator.from_orm(model)
def test_fastapi_error(self):
request = mock.Mock()
exc = RequestValidationError([])
response = fastapi.exception_handler(request, exc)
assert response.status_code == 422
assert json.loads(response.body) == {
"message": "Request validation error.",
"debug_message": [],
"code": None,
}
def query(
self, objects: Union[BaseManager,
QuerySet], q_filters: Q = Q()) -> QuerySet:
"""
Filter a given model's BaseManager or pre-filtered Queryset with the given q_filters and apply order_by and offset/limit from the pagination.
"""
try:
return objects.filter(q_filters).order_by(
*self.order_by)[self.offset:self.limit]
except (FieldDoesNotExist, FieldError) as error:
raise RequestValidationError(
[ErrorWrapper(error, ("query", "order_by"))]) from error
async def _as_form(**data):
"""
Create the model as a form data.
"""
# parse literal back to dictionary
for field_alias in literal_fields:
value = data.pop(field_alias, None)
data[field_alias] = ast.literal_eval(str(value))
try:
cls.parse_obj(data)
return cls(**data)
except ValidationError as exc:
raise RequestValidationError(exc.raw_errors)
async def handle_req(
self,
http_request: Request,
background_tasks: BackgroundTasks,
sub_response: Response,
ctx: JsonRpcContext,
dependency_cache: dict = None,
shared_dependencies_error: BaseError = None
):
await ctx.enter_middlewares(self.middlewares)
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, _, _ = await solve_dependencies(
request=http_request,
dependant=self.func_dependant,
body=ctx.request.params,
background_tasks=background_tasks,
response=sub_response,
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,
}
# noinspection PyTypeChecker
resp = await serialize_response(
field=self.secure_cloned_response_field,
response_content=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 solve_shared_dependencies(self, http_request: Request, background_tasks: BackgroundTasks) -> dict:
# Must not be empty, otherwise FastAPI re-creates it
dependency_cache = {(lambda: None, ('', )): 1}
if self.dependencies:
_, errors, _, _, _ = await solve_dependencies(
request=http_request,
dependant=self.shared_dependant,
body=None,
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))
return dependency_cache
def update_my_password(
updates: schema.UserSelfPasswordIn,
current_user: "******" = Depends(login_required),
session: db.Session = Depends(get_session),
):
"""Update logged-in user's password"""
if not verify_password(updates.current_password, current_user.password):
# We need to fake a normal validation error, because we can't really do this in the schema
# (need access to the database session for the password verification)
raise RequestValidationError(errors=(ErrorWrapper(
exc=ValueError("Current password is invalid."),
loc="current_password",
), ))
current_user.password = generate_password_hash(updates.password)
session.commit()
return {"detail": "Your password has been updated!"}
def start_date_dependency(start_date: datetime.date = None):
"""Dependency для контроллеров fastapi, для определения стартовой даты.
:param start_date: datetime.date
:return: Optional[datetime.date]
:raises RequestValidationError: if start_date invalid
"""
if not start_date:
return None
if start_date < FIRST_USER_ACTION_LOG_DATE:
raise RequestValidationError(errors=[
ErrorWrapper(
DateTimeError(limit_value=FIRST_USER_ACTION_LOG_DATE),
loc=('query', 'start_date'),
),
])
return start_date
async def set_flag_value(response: Response,
project: str,
environment: str,
flag: str,
value: FLAG_VALUE_TYPE,
revision: Optional[UUID] = None) -> UUID:
"""Update the value for the given flag in the given environment and project."""
try:
is_new, new_revision = await set_value(project, environment, flag, value, revision)
if is_new:
response.status_code = 201 # Value did not previously exist, created
elif new_revision == revision:
response.status_code = 204 # Value not changed
return new_revision
except DoesNotExist as e:
raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail=str(e))
except ValidationError as e:
raise RequestValidationError(e.raw_errors)
except RevisionMismatch as e:
raise HTTPException(status_code=HTTP_409_CONFLICT, detail=str(e))
def test_render_request_validation_error(self):
resp = middleware.ProblemResponse(
RequestValidationError(
errors=[ErrorWrapper(ValueError('foo'), 'bar')], ), )
assert resp.media_type == 'application/problem+json'
assert resp.debug is False
assert resp.status_code == 400
assert json.loads(resp.body) == {
'type': 'about:blank',
'status': 400,
'title': 'Validation Error',
'detail': 'One or more user-provided parameters are invalid',
'errors': [
{
'loc': ['bar'],
'msg': 'foo',
'type': 'value_error',
},
],
}
def predict(self, model_name: str = None, version: str = None, input=None):
"""Predict. Check if matching model is available.
"""
# TODO logging
servable = self.get_servable(model_name, version)
if servable is False:
response = {
'error_message': 'Model or version is not found',
'available_models': self.all_models_meta_data_response()
}
return JSONResponse(status_code=404, content=response)
# for the standard /predict route, no data model is known, thus we have to transform
request_format = servable.model.request_format()
if isinstance(input, request_format) is False:
try:
input = servable.model.request_format()(**input)
except Exception as e:
raise RequestValidationError([e])
return servable.predict(input)
async def update_orm(model: Type[BaseModel],
orm_obj: models.Model,
input: BaseModel,
*,
access: Optional[Access] = None) -> BaseModel:
"""
Apply (partial) changes given in `input` to an orm_obj and return an instance of `model` with the full data of the orm including the updated fields.
"""
warnings.warn(
"Use transfer_to_orm with exclude_unset=True instead of this function",
category=DeprecationWarning)
if access:
check_field_access(input, access)
data = await model.from_orm(orm_obj)
input_dict: dict = input.dict(exclude_unset=True)
def update(model: BaseModel, input: dict):
for key, value in input.items():
if isinstance(value, dict):
attr = getattr(model, key)
if attr is None:
setattr(model, key,
model.__fields__[key].type_.parse_obj(value))
else:
update(attr, value)
else:
setattr(model, key, value)
update(data, input_dict)
values, fields_set, validation_error = validate_model(model, data.dict())
if validation_error:
raise RequestValidationError(validation_error.raw_errors)
transfer_to_orm(data, orm_obj)
return data
async def unpack(content_type: ContentType,
value: UploadFile,
dont_close_after_read=typing.Any) -> StrBytes:
await value.seek(0)
_value = await value.read()
if dont_close_after_read:
await value.close()
else:
await value.seek(0)
try:
if 'base64' in content_type.params:
_value = multipart.multipart.base64.standard_b64decode(_value)
if 'lz4' in content_type.params:
_value = lz4.block.decompress(source=_value)
except BaseException as exc:
raise RequestValidationError(errors=[
pydantic.error_wrappers.ErrorWrapper(exc=ValueError(
'Не могу распаковать содержиме файла.', StrictStr(exc)),
loc=("body", "params"))
],
body=ContentType)
return _value
async def publish_model(
model: BaseMLModel = Depends(BaseMLModel.as_form),
files:
List[UploadFile] = File(
[],
description=
'This field can be set with empty value. In such settings, the publish is a dry run to'
'validate the `ml_model_in_form` field. You are recommend to try a dry run to find input'
'errors before you send the wight file(s) to the server.'),
convert: bool = True,
profile: bool = False):
"""Publish model to the model hub. The model weight file(s) as well as its meta information (e.g.
architecture, framework, and serving engine) will be stored into the model hub.
The publish API will also automatically convert the published model into other deployable format such as
TorchScript and ONNX. After successfully converted, original model and its generated models will be profiled
on the underlying devices in the clusters, and collects, aggregates, and processes running model performance.
Args:
model (MLModel): Model meta information.
files (List[UploadFile]): A list of model weight files. The files are organized accordingly. Their file name
contains relative path to their common parent directory.
If the files is empty value, a dry-run to this API is conducted for parameter checks. No information
will be saved into model hub in this case.
convert (bool): Flag for auto configuration.
profile (bool): Flag for auto profiling.
Returns:
A message response, with IDs of all published model. The format of the return is:
```
{
"data": {"id": ["603e6a1f5a62b08bc0a2a7f2", "603e6a383b00cbe9bfee7277"]},
"status": true
}
```
Specially, if the dry-run test passed, it will return a status True:
```
{
"status": true
}
```
"""
# save the posted files as local cache
loop = asyncio.get_event_loop()
saved_path = model.saved_path
if len(files) == 0:
# conduct dry run for parameter check only.
return {'status': True}
if len(files) == 1:
file = files[0]
suffix = Path(file.filename).suffix
try:
# create directory
if len(suffix) == 0:
error = ErrorWrapper(ValueError(
f'Expect a suffix for file {file.filename}, got None.'),
loc='files[0]')
raise RequestValidationError([error])
saved_path = saved_path.with_suffix(suffix)
saved_path.parent.mkdir(exist_ok=True, parents=True)
# save file
await file.seek(0)
with open(saved_path, 'wb') as buffer:
await loop.run_in_executor(None, shutil.copyfileobj, file.file,
buffer)
finally:
await file.close()
else:
raise NotImplementedError(
'`publish_model` not implemented for multiple files upload.')
# zip the files
model = MLModel(**model.dict(), weight=saved_path)
models = register_model(model=model, convert=convert, profile=profile)
return {
'data': {
'id': [str(model.id) for model in models],
},
'status': True
}
async def app(request: Request) -> Response:
try:
body: Any = None
if body_field:
if is_body_form:
body = await request.form()
else:
body_bytes = await request.body()
if body_bytes:
json_body: Any = Undefined
content_type_value = request.headers.get(
"content-type")
if not content_type_value:
json_body = await request.json()
else:
message = email.message.Message()
message["content-type"] = content_type_value
if message.get_content_maintype() == "application":
subtype = message.get_content_subtype()
if subtype == "json" or subtype.endswith(
"+json"):
json_body = await request.json()
if json_body != Undefined:
body = json_body
else:
body = body_bytes
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_args: Dict[str, Any] = {"background": background_tasks}
# If status_code was set, use it, otherwise use the default from the
# response class, in the case of redirect it's 307
if status_code is not None:
response_args["status_code"] = status_code
response = actual_response_class(response_data, **response_args)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
return response
async def app(scope, receive, send):
raise RequestValidationError(
errors=[ErrorWrapper(ValueError('foo'), 'bar')], )
async def parse_format(
url: AnyUrl = Query(default=None,
title="URI источника данных",
description=_descr_source),
file: UploadFile = File(default=...,
title="Файл DBF",
description="Файл формата dBase(3/4)"),
request: Request = None):
content_type = await ContentType.from_str(StrictStr(file.content_type))
if content_type.type == "application/octet-stream":
dbf_bytes = await unpack(value=file,
content_type=content_type,
dont_close_after_read=request)
ext = PurePosixPath(file.filename).suffix.lower()
if ext in ['.dbf']:
dbf = None
try:
dbf = await bssapi.core.dbf.get_dbf(dbf_bytes) if len(
dbf_bytes) else None
except BaseException as exc:
raise RequestValidationError(errors=[
pydantic.error_wrappers.ErrorWrapper(exc=ValueError(
'Не могу открыть файл.', StrictStr(exc)),
loc=("body", "file"))
],
body={"file": file.filename})
else:
if isinstance(dbf, DBF):
format_packet = await bssapi.schemas.exch.build_format(
url=url, fields=dbf.fields)
dbf.unload()
return format_packet
else:
raise RequestValidationError(errors=[
pydantic.error_wrappers.ErrorWrapper(
exc=ValueError('Не могу открыть файл.'),
loc=("body", "file"))
],
body={"file": file.filename})
else:
raise RequestValidationError(errors=[
pydantic.error_wrappers.ErrorWrapper(
exc=ValueError('Не верное расширение файла'),
loc=("body", "filename", "extension"))
],
body={
"filename": {
"extension": ext,
"filename": file.filename
}
})
else:
raise RequestValidationError(errors=[
pydantic.error_wrappers.ErrorWrapper(exc=ValueError(
"Не верный тип содержимого тела запроса. Ожидалось 'application/octet-stream'"
),
loc=("body", "Сontent-type"))
],
body={"Сontent-type": file.content_type})