async def request_body_to_args( required_params: List[ModelField], received_body: Optional[Union[Dict[str, Any], FormData]], ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values = {} errors = [] if required_params: field = required_params[0] field_info = get_field_info(field) embed = getattr(field_info, "embed", None) if len(required_params) == 1 and not embed: received_body = {field.alias: received_body} for field in required_params: value: Any = None if received_body is not None: if field.shape in sequence_shapes and isinstance( received_body, FormData): value = received_body.getlist(field.alias) else: value = received_body.get(field.alias) if (value is None or (isinstance(field_info, params.Form) and value == "") or (isinstance(field_info, params.Form) and field.shape in sequence_shapes and len(value) == 0)): if field.required: if PYDANTIC_1: errors.append( ErrorWrapper(MissingError(), loc=("body", field.alias))) else: # pragma: nocover errors.append( ErrorWrapper( # type: ignore MissingError(), loc=("body", field.alias), config=BaseConfig, )) else: values[field.name] = deepcopy(field.default) continue if (isinstance(field_info, params.File) and lenient_issubclass(field.type_, bytes) and isinstance(value, UploadFile)): value = await value.read() elif (field.shape in sequence_shapes and isinstance(field_info, params.File) and lenient_issubclass(field.type_, bytes) and isinstance(value, sequence_types)): awaitables = [sub_value.read() for sub_value in value] contents = await asyncio.gather(*awaitables) value = sequence_shape_to_type[field.shape](contents) v_, errors_ = field.validate(value, values, loc=("body", field.alias)) if isinstance(errors_, ErrorWrapper): errors.append(errors_) elif isinstance(errors_, list): errors.extend(errors_) else: values[field.name] = v_ return values, errors
def get_missing_field_error(loc: Tuple[str, ...]) -> ErrorWrapper: if PYDANTIC_1: missing_field_error = ErrorWrapper(MissingError(), loc=loc) else: # pragma: no cover missing_field_error = ErrorWrapper( # type: ignore MissingError(), loc=loc, config=BaseConfig, ) return missing_field_error
def get_missing_field_error(field_alias: str) -> ErrorWrapper: if PYDANTIC_1: missing_field_error = ErrorWrapper(MissingError(), loc=("body", field_alias)) else: # pragma: no cover missing_field_error = ErrorWrapper( # type: ignore MissingError(), loc=("body", field_alias), config=BaseConfig, ) return missing_field_error
def request_params_to_args( required_params: Sequence[Field], received_params: Union[Mapping[str, Any], QueryParams, Headers], ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values = {} errors = [] for field in required_params: if field.shape in sequence_shapes and isinstance( received_params, (QueryParams, Headers) ): value = received_params.getlist(field.alias) else: value = received_params.get(field.alias) schema: params.Param = field.schema assert isinstance(schema, params.Param), "Params must be subclasses of Param" if value is None: if field.required: errors.append( ErrorWrapper( MissingError(), loc=(schema.in_.value, field.alias), config=BaseConfig, ) ) else: values[field.name] = deepcopy(field.default) continue v_, errors_ = field.validate(value, values, loc=(schema.in_.value, field.alias)) if isinstance(errors_, ErrorWrapper): errors.append(errors_) elif isinstance(errors_, list): errors.extend(errors_) else: values[field.name] = v_ return values, errors
def request_params_to_args( required_params: Sequence[ModelField], received_params: Union[Mapping[str, Any], QueryParams, Headers], ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values = {} errors = [] for field in required_params: if is_scalar_sequence_field(field) and isinstance( received_params, (QueryParams, Headers)): value = received_params.getlist(field.alias) or field.default else: value = received_params.get(field.alias) field_info = field.field_info assert isinstance(field_info, params.Param), "Params must be subclasses of Param" if value is None: if field.required: errors.append( ErrorWrapper(MissingError(), loc=(field_info.in_.value, field.alias))) else: values[field.name] = deepcopy(field.default) continue v_, errors_ = field.validate(value, values, loc=(field_info.in_.value, field.alias)) if isinstance(errors_, ErrorWrapper): errors.append(errors_) elif isinstance(errors_, list): errors.extend(errors_) else: values[field.name] = v_ return values, errors
def validate_required_primitive_elements_1864( cls, values: typing.Dict[str, typing.Any] ) -> typing.Dict[str, typing.Any]: """https://www.hl7.org/fhir/extensibility.html#Special-Case In some cases, implementers might find that they do not have appropriate data for an element with minimum cardinality = 1. In this case, the element must be present, but unless the resource or a profile on it has made the actual value of the primitive data type mandatory, it is possible to provide an extension that explains why the primitive value is not present. """ required_fields = [ ("latitude", "latitude__ext"), ("longitude", "longitude__ext"), ] _missing = object() def _fallback(): return "" errors: typing.List["ErrorWrapper"] = [] for name, ext in required_fields: field = cls.__fields__[name] ext_field = cls.__fields__[ext] value = values.get(field.alias, _missing) if value not in (_missing, None): continue ext_value = values.get(ext_field.alias, _missing) missing_ext = True if ext_value not in (_missing, None): if isinstance(ext_value, dict): missing_ext = len(ext_value.get("extension", [])) == 0 elif ( getattr(ext_value.__class__, "get_resource_type", _fallback)() == "FHIRPrimitiveExtension" ): if ext_value.extension and len(ext_value.extension) > 0: missing_ext = False else: validate_pass = True for validator in ext_field.type_.__get_validators__(): try: ext_value = validator(v=ext_value) except ValidationError as exc: errors.append(ErrorWrapper(exc, loc=ext_field.alias)) validate_pass = False if not validate_pass: continue if ext_value.extension and len(ext_value.extension) > 0: missing_ext = False if missing_ext: if value is _missing: errors.append(ErrorWrapper(MissingError(), loc=field.alias)) else: errors.append( ErrorWrapper(NoneIsNotAllowedError(), loc=field.alias) ) if len(errors) > 0: raise ValidationError(errors, cls) # type: ignore return values
async def request_body_to_args( required_params: List[Field], received_body: Dict[str, Any]) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values = {} errors = [] if required_params: field = required_params[0] embed = getattr(field.schema, "embed", None) if len(required_params) == 1 and not embed: received_body = {field.alias: received_body} for field in required_params: value = received_body.get(field.alias) if value is None: if field.required: errors.append( ErrorWrapper(MissingError(), loc=("body", field.alias), config=BaseConfig)) else: values[field.name] = deepcopy(field.default) continue v_, errors_ = field.validate(value, values, loc=("body", field.alias)) if isinstance(errors_, ErrorWrapper): errors.append(errors_) elif isinstance(errors_, list): errors.extend(errors_) else: values[field.name] = v_ return values, errors
def validate_extension_or_fhir_comment_required( cls, values: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]: """Conditional Required Validation""" errors = list() extension = values.get("extension", None) fhir_comments = values.get("fhir_comments", None) if extension is None and fhir_comments is None: errors.append(ErrorWrapper(MissingError(), loc="extension")) raise ValidationError(errors, cls) # type: ignore return values
def to_args( cls, param_fields: List[ModelField], param_values: Union[Dict[str, Any], QueryDict, MultiValueDict], ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values: Dict[str, Any] = {} errors = [] for field in param_fields: if DependantUtils.is_scalar_sequence_field(field=field) and isinstance( param_values, QueryDict ): value = param_values.getlist(key=field.alias) or field.default else: value = param_values.get(field.alias) field_info = field.field_info assert isinstance( field_info, params.Param ), "Param must be subclasses of Param" if value is None: if field.required: errors.append( ErrorWrapper( MissingError(), loc=(field_info.in_.value, field.alias) ) ) continue else: # values[field.name] = deepcopy(field.default) value = deepcopy(field.default) validate_value, validate_errors = field.validate( v=value, values=values, loc=(field_info.in_.value, field.alias) ) if isinstance(validate_errors, ErrorWrapper): errors.append(validate_errors) elif isinstance(validate_errors, list): errors.extend(validate_errors) else: values[field.name] = validate_value return values, errors
async def request_body_to_args( required_params: List[Field], received_body: Dict[str, Any]) -> Tuple[Dict[str, Any], List[ErrorWrapper]]: values = {} errors = [] if required_params: field = required_params[0] embed = getattr(field.schema, "embed", None) if len(required_params) == 1 and not embed: received_body = {field.alias: received_body} elif received_body is None: received_body = {} for field in required_params: value = received_body.get(field.alias) if value is None or (isinstance(field.schema, params.Form) and value == ""): if field.required: errors.append( ErrorWrapper( MissingError(), loc=("body", field.alias), config=UnconstrainedConfig, )) else: values[field.name] = deepcopy(field.default) continue if (isinstance(field.schema, params.File) and lenient_issubclass(field.type_, bytes) and isinstance(value, UploadFile)): value = await value.read() v_, errors_ = field.validate(value, values, loc=("body", field.alias)) if isinstance(errors_, ErrorWrapper): errors.append(errors_) elif isinstance(errors_, list): errors.extend(errors_) else: values[field.name] = v_ return values, errors
def get_missing_field_error(loc: Tuple[str, ...]) -> ErrorWrapper: missing_field_error = ErrorWrapper(MissingError(), loc=loc) return missing_field_error