def get_value(self, dictionary): # We override the default field access in order to support # nested HTML forms. if html.is_html_input(dictionary): return html.parse_html_dict(dictionary, prefix=self.field_name) or empty return dictionary.get(self.field_name, empty)
def to_internal_value(self, data): """Dicts of native values <- Dicts of primitive datatypes.""" if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail("not_a_dict", input_type=type(data).__name__) return self.run_child_validation(data)
def to_internal_value(self, data): """ Range instances <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) validated_dict = {} for key in ('lower', 'upper'): try: value = data.pop(key) except KeyError: continue validated_dict[six.text_type(key)] = self.child.run_validation( value) for key in ('bounds', 'empty'): try: value = data.pop(key) except KeyError: continue validated_dict[six.text_type(key)] = value if data: self.fail('too_much_content', extra=', '.join(map(str, data.keys()))) return self.range_type(**validated_dict)
def to_internal_value(self, data): """ Range instances <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) extra_content = list( set(data) - set(["lower", "upper", "bounds", "empty"])) if extra_content: self.fail('too_much_content', extra=', '.join(map(str, extra_content))) validated_dict = {} for key in ('lower', 'upper'): try: value = data[key] except KeyError: continue validated_dict[str(key)] = self.child.run_validation(value) for key in ('bounds', 'empty'): try: value = data[key] except KeyError: continue validated_dict[str(key)] = value return self.range_type(**validated_dict)
def get_value(self, dictionary): """ Override the default field access in order to support dictionaries in HTML forms. """ if html.is_html_input(dictionary): return html.parse_html_dict(dictionary, prefix=self.field_name) return dictionary.get(self.field_name, serializers.empty)
def get_value(self, dictionary): # We override the default field access in order to support # nested HTML forms. if html.is_html_input(dictionary): return html.parse_html_dict( dictionary, prefix=self.field_name ) or empty return dictionary.get(self.field_name, empty)
def to_internal_value(self, data): """ Dicts of native values <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) return dict([(six.text_type(key), self.child.run_validation(value)) for key, value in data.items()])
def to_internal_value(self, data): """ Ensure incoming data is a dictionary and run validation on entries. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail("not_a_dict", input_type=type(data).__name__) if not self.allow_empty and len(data) == 0: self.fail("empty") return self.run_child_validation(data)
def to_internal_value(self, data): """ Dicts of native values <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) return dict([ (six.text_type(key), self.child.run_validation(value)) for key, value in data.items() ])
def to_internal_value(self, data): """ Dicts of native values <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) if not self.allow_empty and len(data.keys()) == 0: message = self.error_messages['empty'] raise ValidationError( {api_settings.NON_FIELD_ERRORS_KEY: [message]}) return { str(key): self.child.run_validation(value) for key, value in data.items() }
def get_value(self, dictionary): # get just field name value = dictionary.get(self.field_name, dict()) if value is None: return empty if not isinstance(value, dict): raise ValidationError("Must be an object or null") # then merge in fields with keys like `content_defaults.author` multi_value = MultiValueDict() multi_value.update(dictionary) html_value = unnest_dict( html.parse_html_dict(multi_value, prefix=self.field_name).dict()) value.update(html_value) return value if len(value.keys()) else empty
def to_internal_value(self, data): """ Range instances <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) # allow_empty is added to DictField in DRF Version 3.9.3 if hasattr(self, "allow_empty") and not self.allow_empty and len(data) == 0: self.fail('empty') extra_content = list( set(data) - set(["lower", "upper", "bounds", "empty"])) if extra_content: self.fail('too_much_content', extra=', '.join(map(str, extra_content))) validated_dict = {} for key in ('lower', 'upper'): try: value = data[key] except KeyError: continue validated_dict[str(key)] = self.child.run_validation(value) lower, upper = validated_dict.get('lower'), validated_dict.get('upper') if lower is not None and upper is not None and lower > upper: self.fail('bound_ordering') for key in ('bounds', 'empty'): try: value = data[key] except KeyError: continue validated_dict[str(key)] = value return self.range_type(**validated_dict)
def to_internal_value(self, data): """ Data transformation to python JSON object. :param str data: Data for transformation. :return: Transformed data. :rtype: dict :raise ValidationError: If not valid data. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) return { six.text_type(key): self.child.run_validation(value) for key, value in six.iteritems(data) }
def to_internal_value(self, data): """ Range instances <- Lists of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, (list, tuple,)): self.fail('not_a_list', input_type=type(data).__name__) validated_dict = {} for field in ('lower', 'upper',): try: validated_dict[field] = self.child.run_validation(data.pop(0)) except: validated_dict[field] = None try: validated_dict['bounds'] = data.pop(0) except IndexError: pass if data: self.fail('too_much_content', extra=', '.join(map(str, data))) return self.range_type(**validated_dict)
def to_internal_value(self, data): """ Range instances <- Dicts of primitive datatypes. """ if html.is_html_input(data): data = html.parse_html_dict(data) if not isinstance(data, dict): self.fail('not_a_dict', input_type=type(data).__name__) validated_dict = {} for key in ('lower', 'upper'): try: value = data.pop(key) except KeyError: continue validated_dict[six.text_type(key)] = self.child.run_validation(value) for key in ('bounds', 'empty'): try: value = data.pop(key) except KeyError: continue validated_dict[six.text_type(key)] = value if data: self.fail('too_much_content', extra=', '.join(map(str, data.keys()))) return self.range_type(**validated_dict)
def getFromRequestData(dictionary, key): if html.is_html_input(dictionary): return html.parse_html_dict(dictionary, prefix=key) or None return dictionary.get(key, None)
def get_value(self, dictionary): if html.is_html_input(dictionary): data = html.parse_html_dict(dictionary, prefix=self.field_name) data = dictionary.get(self.field_name, empty) print('my dict field %s' % data) return data