示例#1
0
    def _validate(self):
        """
        Compare fields to the schema and raise AttributeError if mismatched.
        Named _validate instead of validate because the data may have a field named "validate".
        """
        fields, schema = self.__dict__, self._schema

        # Check for extra fields not defined in the schema
        extra_fields = fields.viewkeys() - schema.viewkeys() - BUILT_IN_ATTRS
        if len(extra_fields) > 0:
            raise AttributeError(
                'Fields found that are not in the schema: %r' %
                (list(extra_fields)))

        required_decorator = 'Required'
        content_type_decorator = 'ContentType'
        content_count_decorator = 'ContentCount'
        value_range_decorator = 'ValueRange'
        value_pattern_decorator = 'ValuePattern'

        # Check required field criteria met
        for key in schema:
            if 'decorators' in schema[key] and required_decorator in schema[
                    key]['decorators']:
                if not key in fields or fields[key] is None:
                    raise AttributeError('Required value "%s" not set' % key)

        # Check each attribute
        for key in fields.iterkeys():
            if key in BUILT_IN_ATTRS:
                continue

            schema_val = schema[key]

            # Correct any float or long types that got downgraded to int
            if isinstance(fields[key], int):
                if schema_val['type'] == 'float':
                    fields[key] = float(fields[key])
                elif schema_val['type'] == 'long':
                    fields[key] = long(fields[key])

            # argh, annoying work around for OrderedDict vs dict issue
            if type(fields[key]
                    ) == dict and schema_val['type'] == 'OrderedDict':
                fields[key] = OrderedDict(fields[key])

            # Basic type checking
            field_val = fields[key]

            if type(field_val).__name__ != schema_val['type']:

                # if the schema doesn't define a type, we can't very well validate it
                if schema_val['type'] == 'NoneType':
                    continue

                # Allow unicode instead of str. This may be too lenient.
                if schema_val['type'] == 'str' and type(
                        field_val).__name__ == 'unicode':
                    continue

                # Already checked for required above.  Assume optional and continue
                if field_val is None:
                    continue

                # Allow unicode instead of str. This may be too lenient.
                if schema_val['type'] == 'str' and type(
                        field_val).__name__ == 'unicode':
                    continue

                # IonObjects are ok for dict fields too!
                if isinstance(
                        field_val,
                        IonObjectBase) and schema_val['type'] == 'OrderedDict':
                    continue

                if not key in fields or fields[key] is None:
                    raise AttributeError('Required value "%s" not set' % key)

                # Check for inheritance
                if self.check_inheritance_chain(type(field_val),
                                                schema_val['type']):
                    continue

                # Check enum types
                from pyon.core.registry import enum_classes
                if isinstance(field_val,
                              int) and schema_val['type'] in enum_classes:
                    if field_val not in enum_classes(
                            schema_val['type'])._str_map:
                        raise AttributeError(
                            'Invalid enum value "%d" for field "%s.%s", should be between 1 and %d'
                            % (fields[key], type(self).__name__, key,
                               len(enum_classes(schema_val['type'])._str_map)))
                    else:
                        continue

                if type(field_val) == tuple and schema_val['type'] == 'list':
                    continue

                if isinstance(field_val,
                              IonObjectBase) and schema_val['type'] == 'dict':
                    log.warn(
                        'TODO: Please convert generic dict attribute type to abstract type for field "%s.%s"'
                        % (type(self).__name__, key))
                    continue

                # Special case check for ION object being passed where default type is dict or str
                if 'decorators' in schema_val:
                    if content_type_decorator in schema_val['decorators']:
                        if isinstance(
                                field_val, IonObjectBase
                        ) and schema_val['type'] == 'dict' or schema_val[
                                'type'] == 'str':
                            self.check_content(
                                key, field_val, schema_val['decorators']
                                [content_type_decorator])
                            continue

                raise AttributeError(
                    'Invalid type "%s" for field "%s.%s", should be "%s"' %
                    (type(fields[key]), type(self).__name__, key,
                     schema_val['type']))

            if type(field_val).__name__ == 'str':
                if value_pattern_decorator in schema_val['decorators']:
                    self.check_string_pattern_match(
                        key, field_val,
                        schema_val['decorators'][value_pattern_decorator])

            if type(field_val).__name__ in ['int', 'float', 'long']:
                if value_range_decorator in schema_val['decorators']:
                    self.check_numeric_value_range(
                        key, field_val,
                        schema_val['decorators'][value_range_decorator])

            if 'decorators' in schema_val:
                if content_type_decorator in schema_val['decorators']:
                    if schema_val['type'] == 'list':
                        self.check_collection_content(
                            key, field_val,
                            schema_val['decorators'][content_type_decorator])
                    elif schema_val['type'] == 'dict' or schema_val[
                            'type'] == 'OrderedDict':
                        self.check_collection_content(
                            key, field_val.values(),
                            schema_val['decorators'][content_type_decorator])
                    else:
                        self.check_content(
                            key, field_val,
                            schema_val['decorators'][content_type_decorator])
                if content_count_decorator in schema_val['decorators']:
                    if schema_val['type'] == 'list':
                        self.check_collection_length(
                            key, field_val,
                            schema_val['decorators'][content_count_decorator])
                    if schema_val['type'] == 'dict' or schema_val[
                            'type'] == 'OrderedDict':
                        self.check_collection_length(
                            key, field_val.values(),
                            schema_val['decorators'][content_count_decorator])

            if isinstance(field_val, IonObjectBase):
                field_val._validate()

            # Next validate only IonObjects found in child collections.
            # Note that this is non-recursive; only for first-level collections.
            elif isinstance(field_val, Mapping):
                for subkey in field_val:
                    subval = field_val[subkey]
                    if isinstance(subval, IonObjectBase):
                        subval._validate()
            elif isinstance(field_val, Iterable):
                for subval in field_val:
                    if isinstance(subval, IonObjectBase):
                        subval._validate()
示例#2
0
文件: object.py 项目: ateranishi/pyon
    def _validate(self):
        """
        Compare fields to the schema and raise AttributeError if mismatched.
        Named _validate instead of validate because the data may have a field named "validate".
        """
        fields, schema = self.__dict__, self._schema

        # Check for extra fields not defined in the schema
        extra_fields = fields.viewkeys() - schema.viewkeys() - built_in_attrs
        if len(extra_fields) > 0:
            raise AttributeError('Fields found that are not in the schema: %r' % (list(extra_fields)))

        required_decorator = 'Required'
        content_type_decorator = 'ContentType'
        content_count_decorator = 'ContentCount'
        value_range_decorator = 'ValueRange'
        value_pattern_decorator = 'ValuePattern'

        # Check required field criteria met
        for key in schema:
            if 'decorators' in schema[key] and required_decorator in schema[key]['decorators']:
                if not key in fields or fields[key] is None:
                    raise AttributeError('Required value "%s" not set' % key)

        # Check each attribute
        for key in fields.iterkeys():
            if key in built_in_attrs:
                continue

            schema_val = schema[key]

            # Correct any float or long types that got downgraded to int
            if isinstance(fields[key], int):
                if schema_val['type'] == 'float':
                    fields[key] = float(fields[key])
                elif schema_val['type'] == 'long':
                    fields[key] = long(fields[key])

            # argh, annoying work around for OrderedDict vs dict issue
            if type(fields[key]) == dict and schema_val['type'] == 'OrderedDict':
                fields[key] = OrderedDict(fields[key])

            # Basic type checking
            field_val = fields[key]
            if 'decorators' in schema_val:
                log.debug("Validating %s: %s: %s: %s" % (key, schema_val["type"], schema_val["decorators"], str(field_val)))
            else:
                log.debug("Validating %s: %s: %s" % (key, schema_val["type"], str(field_val)))
            if type(field_val).__name__ != schema_val['type']:

                # if the schema doesn't define a type, we can't very well validate it
                if schema_val['type'] == 'NoneType':
                    continue

                # Already checked for required above.  Assume optional and continue
                if field_val is None:
                    continue

                # IonObjects are ok for dict fields too!
                if isinstance(field_val, IonObjectBase) and schema_val['type'] == 'OrderedDict':
                    continue

                if not key in fields or fields[key] is None:
                    raise AttributeError('Required value "%s" not set' % key)

                # Check for inheritance
                if self.check_inheritance_chain(type(field_val), schema_val['type']):
                    continue

                # Check enum types
                from pyon.core.registry import enum_classes
                if isinstance(field_val, int) and schema_val['type'] in enum_classes:
                    if field_val not in enum_classes(schema_val['type'])._str_map:
                        raise AttributeError('Invalid enum value "%d" for field "%s.%s", should be between 1 and %d' %
                                     (fields[key], type(self).__name__, key, len(enum_classes(schema_val['type'])._str_map)))
                    else:
                        continue

                # TODO work around for msgpack issue
                if type(field_val) == tuple and schema_val['type'] == 'list':
                    continue

                # TODO remove this at some point
                if isinstance(field_val, IonObjectBase) and schema_val['type'] == 'dict':
                    log.warn('TODO: Please convert generic dict attribute type to abstract type for field "%s.%s"' % (type(self).__name__, key))
                    continue

                # Special case check for ION object being passed where default type is dict or str
                if 'decorators' in schema_val:
                    if content_type_decorator in schema_val['decorators']:
                        if isinstance(field_val, IonObjectBase) and schema_val['type'] == 'dict' or schema_val['type'] == 'str':
                            self.check_content(key, field_val, schema_val['decorators'][content_type_decorator])
                            continue

                raise AttributeError('Invalid type "%s" for field "%s.%s", should be "%s"' %
                                     (type(fields[key]), type(self).__name__, key, schema_val['type']))

            if type(field_val).__name__ == 'str':
                if value_pattern_decorator in schema_val['decorators']:
                    self.check_string_pattern_match(key, field_val, schema_val['decorators'][value_pattern_decorator])

            if type(field_val).__name__ in ['int', 'float', 'long']:
                if value_range_decorator in schema_val['decorators']:
                    self.check_numeric_value_range(key, field_val, schema_val['decorators'][value_range_decorator])

            if 'decorators' in schema_val:
                if content_type_decorator in schema_val['decorators']:
                    if schema_val['type'] == 'list':
                        self.check_collection_content(key, field_val, schema_val['decorators'][content_type_decorator])
                    elif schema_val['type'] == 'dict' or schema_val['type'] == 'OrderedDict':
                        self.check_collection_content(key, field_val.values(), schema_val['decorators'][content_type_decorator])
                    else:
                        self.check_content(key, field_val, schema_val['decorators'][content_type_decorator])
                if content_count_decorator in schema_val['decorators']:
                    if schema_val['type'] == 'list':
                        self.check_collection_length(key, field_val, schema_val['decorators'][content_count_decorator])
                    if schema_val['type'] == 'dict' or schema_val['type'] == 'OrderedDict':
                        self.check_collection_length(key, field_val.values(), schema_val['decorators'][content_count_decorator])

            if isinstance(field_val, IonObjectBase):
                field_val._validate()

            # Next validate only IonObjects found in child collections.
            # Note that this is non-recursive; only for first-level collections.
            elif isinstance(field_val, Mapping):
                for subkey in field_val:
                    subval = field_val[subkey]
                    if isinstance(subval, IonObjectBase):
                        subval._validate()
            elif isinstance(field_val, Iterable):
                for subval in field_val:
                    if isinstance(subval, IonObjectBase):
                        subval._validate()
示例#3
0
    def _validate(self, validate_objects=True):
        """
        Compare fields to the schema and raise AttributeError if mismatched.
        Named _validate instead of validate because the data may have a field named "validate".
        """
        fields, schema = self.__dict__, self._schema

        # Check for extra fields not defined in the schema
        extra_fields = fields.viewkeys() - schema.viewkeys() - BUILT_IN_ATTRS
        if len(extra_fields) > 0:
            raise AttributeError("Invalid field(s): %r" % (list(extra_fields)))

        # Check required field criteria met
        for key in schema:
            if DECO_VALIDATE_REQUIRED in schema[key].get('decorators', {}):
                if key not in fields or fields[key] is None:
                    raise AttributeError("Value required for '%s'" % key)

        # Check each attribute
        for key in fields.iterkeys():
            if key in BUILT_IN_ATTRS:
                continue

            schema_val = schema[key]
            schema_val_type = schema_val['type']
            schema_val_decos = schema_val.get('decorators', {})

            # Side effect - Correct any float or long types that got downgraded to int
            if isinstance(fields[key], int):
                if schema_val_type == 'float':
                    fields[key] = float(fields[key])
                elif schema_val_type == 'long':
                    fields[key] = long(fields[key])

            # Side effect - Work around for OrderedDict vs dict issue
            if type(fields[key]) == dict and schema_val_type == 'OrderedDict':
                fields[key] = OrderedDict(fields[key])

            # Basic type checking
            field_val = fields[key]
            field_val_type = type(field_val).__name__
            #log.debug("Validating %s: %s: %s: %s" % (key, schema_val_type, schema_val_decos, field_val))

            if field_val_type == "long" and schema_val_type == "int":
                # Accept a long for an int
                pass

            elif field_val_type != schema_val_type:

                # If the schema type is None, all types are allowed
                if schema_val_type == 'NoneType':
                    continue

                # Allow unicode instead of str. This may be too lenient.
                if schema_val_type == 'str' and field_val_type == 'unicode':
                    continue

                # Already checked for required above.  Assume optional and continue
                if field_val is None:
                    continue

                # Allow unicode instead of str. This may be too lenient.
                if schema_val_type == 'str' and field_val_type == 'unicode':
                    continue

                # IonObjects are ok for dict fields too!
                if isinstance(field_val, IonObjectBase) and schema_val_type == 'OrderedDict':
                    continue

                # Check for inheritance
                if self._check_inheritance_chain(type(field_val), schema_val_type):
                    continue

                # Check enum types
                from pyon.core.registry import enum_classes
                if isinstance(field_val, int) and schema_val_type in enum_classes:
                    if field_val in enum_classes[schema_val_type]._str_map:
                        continue
                    raise AttributeError("Invalid enum value '%d' for field '%s.%s', should be between 1 and %d" %
                            (fields[key], type(self).__name__, key, len(enum_classes(schema_val_type)._str_map)))

                # Tuple allowed for list type (Msgpack decodes list to tuples)
                if type(field_val) == tuple and schema_val_type == 'list':
                    continue

                # IonObject allowed for dict type
                if isinstance(field_val, IonObjectBase) and schema_val_type == 'dict':
                    #log.warn('Please convert generic dict attribute type to abstract type for field "%s.%s"' % (type(self).__name__, key))
                    continue

                # Special case check for ION object being passed where default type is dict or str
                if DECO_VALIDATE_CONTENT_TYPE in schema_val_decos:
                    if isinstance(field_val, IonObjectBase) and schema_val_type in ('dict', 'str'):
                        self._check_content(key, field_val, schema_val_decos[DECO_VALIDATE_CONTENT_TYPE])
                        continue

                raise AttributeError("Invalid type '%s' for field '%s.%s', should be '%s'" %
                        (field_val_type, type(self).__name__, key, schema_val_type))

            if field_val_type == 'str' and DECO_VALIDATE_VALUE_PATTERN in schema_val_decos:
                self._check_string_pattern_match(key, field_val, schema_val_decos[DECO_VALIDATE_VALUE_PATTERN])

            if field_val_type in ('int', 'float', 'long') and DECO_VALIDATE_VALUE_RANGE in schema_val_decos:
                self._check_numeric_value_range(key, field_val, schema_val_decos[DECO_VALIDATE_VALUE_RANGE])

            if DECO_VALIDATE_CONTENT_TYPE in schema_val_decos:
                if schema_val_type == 'list':
                    self._check_collection_content(key, field_val, schema_val_decos[DECO_VALIDATE_CONTENT_TYPE])
                elif schema_val_type in ('dict', 'OrderedDict'):
                    self._check_collection_content(key, field_val.values(), schema_val_decos[DECO_VALIDATE_CONTENT_TYPE])
                else:
                    self._check_content(key, field_val, schema_val_decos[DECO_VALIDATE_CONTENT_TYPE])

            if DECO_VALIDATE_CONTENT_COUNT in schema_val_decos and schema_val_type in ('list', 'dict', 'OrderedDict'):
                self._check_collection_length(key, len(field_val), schema_val_decos[DECO_VALIDATE_CONTENT_COUNT])

            if validate_objects:
                # Only if desired - if entire object is walked anyways, these checks are redundant
                if isinstance(field_val, IonObjectBase):
                    field_val._validate()

                # Next validate only IonObjects found in child collections.
                # Note that this is non-recursive; only for first-level collections.
                elif isinstance(field_val, Mapping):
                    for subkey in field_val:
                        subval = field_val[subkey]
                        if isinstance(subval, IonObjectBase):
                            subval._validate()
                elif isinstance(field_val, Iterable):
                    for subval in field_val:
                        if isinstance(subval, IonObjectBase):
                            subval._validate()