Beispiel #1
0
def from_unicode_converter(field, value, context=None):
    if value is not None:
        if field._type is not None:
            if not isinstance(value, field._type):
                if isinstance(value, _type_conversions):
                    # only auto convert primitive types
                    try:
                        value = field._type(value)  # convert other types over
                    except ValueError:
                        raise WrongType(value, field._type, field.__name__)
                else:
                    raise WrongType(value, field._type, field.__name__)
        else:
            value = field.from_unicode(value)
    return value
Beispiel #2
0
    def patch(self, patch_data):

        if not isinstance(patch_data, (list, tuple)):
            raise WrongType(
                "patch value must be list or tuple type! but got `{0}` type.".format(
                    type(patch_data)
                ),
                type(patch_data),
                None,
            )

        if not bool(self):
            raise Invalid(
                "None object cannot be patched! "
                "Make sure fhir resource value is not empty!"
            )
        try:
            patcher = jsonpatch.JsonPatch(patch_data)
            value = patcher.apply(self._resource_obj.as_json())

            new_value = self._resource_obj.__class__(value)

            object.__setattr__(self, "_resource_obj", new_value)

        except jsonpatch.JsonPatchException as exc:
            return reraise(Invalid, str(exc))
    def _validate_object(self, obj: FhirResourceType = None):  # noqa: E999
        """ """
        if obj is None:
            return

        try:
            verifyObject(IFhirResource, obj, False)

        except (BrokenImplementation, BrokenMethodImplementation):

            t, v, tb = sys.exc_info()
            try:
                reraise(Invalid(str(v)), None, tb)
            finally:
                del t, v, tb

        except DoesNotImplement:
            msg = "Object must be derived from valid FHIR resource class!"
            msg += "But it is found that object is derived from `{0}`".format(
                obj.__class__.__module__ + "." + obj.__class__.__name__)

            t, v, tb = sys.exc_info()

            msg += "\nOriginal Exception: {0!s}".format(str(v))

            try:
                reraise(WrongType(msg), None, tb)
            finally:
                del t, v, tb
Beispiel #4
0
    def _validate(self, value):
        if self._type is not None and not isinstance(value, self._type):
            raise WrongType(value, self._type, self.__name__)

        if not self.constraint(value):
            raise ConstraintNotSatisfied(value, self.__name__)
        for validator in self._validators or []:
            validator(self, value)
Beispiel #5
0
def _optimized_lookup(value, field, context):
    if getattr(field, "_type", None) in _type_conversions:
        # for primitive types, all we really do is return the value back.
        # this is costly for all the lookups
        if not isinstance(value, field._type):
            if isinstance(value, _type_conversions):
                try:
                    value = field._type(value)  # convert other types over
                except ValueError:
                    raise WrongType(value, field._type, field.__name__)
            else:
                raise WrongType(value, field._type, field.__name__)
        return value
    else:
        try:
            return schema_compatible(value, field, context)
        except ValidationError as error:
            raise ValueDeserializationError(field,
                                            value,
                                            "Wrong contained type",
                                            errors=[error])
Beispiel #6
0
    def _validate(self, value):
        if self.allowed_mime_types\
                and value.mimeType not in self.allowed_mime_types:
            raise WrongType(value, self.allowed_mime_types)

        if self.max_length is not None and len(value.raw) > self.max_length:
            raise Invalid(
                _('msg_text_too_long',
                  default=u'Text is too long. (Maximum ${max} characters.)',
                  mapping={'max': self.max_length}))

        if not self.constraint(value):
            raise ConstraintNotSatisfied(value)
    def _pre_value_validate(self, fhir_json):
        """ """
        if isinstance(fhir_json, str):
            fhir_dict = parse_json_str(fhir_json).copy()

        elif isinstance(fhir_json, dict):
            fhir_dict = fhir_json.copy()

        else:
            raise WrongType(
                "Only dict type data is allowed but got `{0}` type data!".
                format(type(fhir_json)))

        if "resourceType" not in fhir_dict.keys(
        ) or "id" not in fhir_dict.keys():
            raise Invalid(
                "Invalid FHIR resource json is provided!\n{0}".format(
                    fhir_json))
Beispiel #8
0
 def _validate(self, value):
     super(InterfaceField, self)._validate(value)
     if not IInterface.providedBy(value):
         raise WrongType("An interface is required", value, self.__name__)
Beispiel #9
0
 def _validate(self, value):
     super(Date, self)._validate(value)
     if isinstance(value, datetime):
         raise WrongType(value, self._type, self.__name__)
Beispiel #10
0
    def _init(
        self, resource_class, resource_interface, resource_type, fhir_release, **kw
    ):
        """ """
        if "default" in kw:

            if (
                isinstance(kw["default"], (str, dict)) or kw["default"] is None
            ) is False:
                msg = (
                    "Only dict or string or None is accepted as "
                    "default value but got {0}".format(type(kw["default"]))
                )

                raise Invalid(msg)

        field_attributes = get_fields(IFhirField)

        attribute = field_attributes["resource_class"].bind(self)
        if resource_class is None:
            attribute.validate(resource_class)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_class)
        attribute.set(self, attribute_val)

        attribute = field_attributes["resource_interface"].bind(self)
        if resource_interface is None:
            attribute.validate(resource_interface)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_interface)
        attribute.set(self, attribute_val)

        attribute = field_attributes["resource_type"].bind(self)
        if resource_type is None:
            attribute.validate(resource_type)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_type)
        attribute.set(self, attribute_val)

        attribute = field_attributes["fhir_release"].bind(self)
        if fhir_release is None:
            attribute.validate(fhir_release)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(fhir_release)
            # just for ensure correct value
            FHIR_VERSION[attribute_val]
        attribute.set(self, attribute_val)

        if self.resource_type and self.resource_class is not None:
            raise Invalid(
                "Either `resource_class` or `resource_type` value is acceptable! "
                "you cannot provide both!"
            )

        if self.resource_class:
            try:
                klass = import_string(self.resource_class)
                self.ensure_fhir_abstract(klass)

            except ImportError:
                msg = (
                    "Invalid FHIR Resource class `{0}`! "
                    "Please check the module or class name."
                ).format(self.resource_class)

                return reraise(Invalid, msg)

            if not IFhirResource.implementedBy(klass):

                raise Invalid(
                    "{0!r} must be valid resource class from fhir.resources".format(
                        klass
                    )
                )
            self._resource_class = klass

        if self.resource_type:

            try:
                self._resource_class = implementer(IFhirResource)(
                    lookup_fhir_class(self.resource_type)
                )
            except ImportError:
                msg = "{0} is not valid fhir resource type!".format(self.resource_type)
                return reraise(Invalid, msg)

        if self.resource_interface:
            try:
                klass = implementer(IFhirResource)(
                    import_string(self.resource_interface)
                )
            except ImportError:
                msg = (
                    "Invalid FHIR Resource Interface`{0}`! "
                    "Please check the module or class name."
                ).format(self.resource_interface)
                return reraise(Invalid, msg)

            if not IInterface.providedBy(klass):
                raise WrongType("An interface is required", klass, self.__name__)

            if klass is not IFhirResource and not issubclass(klass, IFhirResource):
                msg = "`{0!r}` must be derived from {1}".format(
                    klass,
                    IFhirResource.__module__ + "." + IFhirResource.__class__.__name__,
                )

                raise Invalid(msg)

            self._resource_interface_class = klass
    def _init(self, resource_class, resource_interface, resource_type, **kw):
        """ """

        if "default" in kw:

            if (isinstance(kw["default"],
                           (str, dict)) or kw["default"] is None) is False:
                msg = ("Only dict or string or None is accepted as "
                       "default value but got {0}".format(type(kw["default"])))

                raise Invalid(msg)

        field_attributes = get_fields(IFhirField)

        attribute = field_attributes['resource_class'].bind(self)
        if resource_class is None:
            attribute.validate(resource_class)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_class)
        attribute.set(self, attribute_val)

        attribute = field_attributes['resource_interface'].bind(self)
        if resource_interface is None:
            attribute.validate(resource_interface)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_interface)
        attribute.set(self, attribute_val)

        attribute = field_attributes['resource_type'].bind(self)
        if resource_type is None:
            attribute.validate(resource_type)
            attribute_val = None
        else:
            attribute_val = attribute.from_unicode(resource_type)
        attribute.set(self, attribute_val)

        if self.resource_type and self.resource_class is not None:
            raise Invalid(
                "Either `resource_class` or `resource_type` value is acceptable! you cannot provide both!"
            )

        if self.resource_class:
            try:
                klass = import_string(self.resource_class)
            except ImportError:
                msg = "Invalid FHIR Resource class `{0}`! Please check the module or class name.".format(
                    self.resource_class)

                t, v, tb = sys.exc_info()
                try:
                    reraise(Invalid(msg), None, tb)
                finally:
                    del t, v, tb

            if not IFhirResource.implementedBy(klass):

                raise Invalid(
                    "{0!r} must be valid resource class from fhir.resources".
                    format(klass))
            self._resource_class = klass

        if self.resource_type:

            try:
                self._resource_class = resource_type_to_resource_cls(
                    self.resource_type)
            except ImportError:
                msg = "{0} is not valid fhir resource type!".format(
                    self.resource_type)
                t, v, tb = sys.exc_info()
                try:
                    reraise(Invalid(msg), None, tb)
                finally:
                    del t, v, tb
                raise Invalid(msg)

        if self.resource_interface:
            try:
                klass = import_string(self.resource_interface)
            except ImportError:
                msg = "Invalid FHIR Resource Interface`{0}`! Please check the module or class name.".format(
                    self.resource_interface)
                t, v, tb = sys.exc_info()
                try:
                    reraise(Invalid(msg), None, tb)
                finally:
                    del t, v, tb

            if not IInterface.providedBy(klass):
                raise WrongType("An interface is required", klass,
                                self.__name__)

            if klass is not IFhirResource and not issubclass(
                    klass, IFhirResource):
                msg = "`{0!r}` must be derived from {1}".format(
                    klass,
                    IFhirResource.__module__ + "." +
                    IFhirResource.__class__.__name__,
                )

                raise Invalid(msg)

            self._resource_interface_class = klass