def to_internal_value(self, data):
        """
        List of dicts of native values <- List of dicts of primitive datatypes.
        """
        if html.is_html_input(data):
            data = html.parse_html_list(data)

        if not isinstance(data, list):
            message = self.error_messages['not_a_list'].format(
                input_type=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = []
        errors = []

        for item in data:
            try:
                validated = self.child.run_validation(item)
            except ValidationError as exc:
                errors.append(exc.detail)
            else:
                ret.append(validated)
                errors.append({})

        if any(errors):
            raise ValidationError(errors)

        return ret

 def to_internal_value(self, data):
     """
     List of dicts of native values <- List of dicts of primitive datatypes.
     """
     if html.is_html_input(data):
         data = html.parse_html_list(data)
     return [self.child.run_validation(item) for item in data]

 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 get_value(self, dictionary):
		if html.is_html_input(dictionary): # NOTE: with form/urlencoded we get [u'opt,opt'] for some reason, gotta work around
			try:
				return dictionary.getlist(self.field_name)[0]
			except IndexError:
				return super(MultiSelectField, self).get_value(dictionary)
		else:
			return super(MultiSelectField, self).get_value(dictionary)

 def to_internal_value(self, data):
     """
     List of dicts of native values <- List of dicts of primitive datatypes.
     """
     if html.is_html_input(data):
         data = html.parse_html_list(data)
     if isinstance(data, type('')) or not hasattr(data, '__iter__'):
         self.fail('not_a_list', input_type=type(data).__name__)
     return [self.child.run_validation(item) for item in data]

 def get_value(self, dictionary):
     # We override the default field access in order to support
     # lists in HTML forms.
     if html.is_html_input(dictionary):
         return html.parse_html_list(dictionary, prefix=self.field_name)
     value = dictionary.get(self.field_name, empty)
     #if isinstance(value, type('')):
     #    return json.loads(value)
     return value

 def get_value(self, dictionary):
     """
     Given the input dictionary, return the field value.
     """
     # We override the default field access in order to support
     # lists in HTML forms.
     if html.is_html_input(dictionary):
         return html.parse_html_list(dictionary, prefix=self.field_name)
     return dictionary.get(self.field_name, empty)

 def get_value(self, dictionary):
     """
     Given the *incoming* primitive data, return the value for this field
     that should be validated and transformed to a native value.
     """
     if html.is_html_input(dictionary):
         # HTML forms will represent empty fields as '', and cannot
         # represent None or False values directly.
         ret = dictionary.get(self.field_name, '')
         return self.default_empty_html if (ret == '') else ret
     return dictionary.get(self.field_name, empty)

    def get_value(self, dictionary):
        # We override the default field access in order to support
        # lists in HTML forms.
        if html.is_html_input(dictionary):
            # Don't return [] if the update is partial
            if self.field_name not in dictionary:
                if getattr(self.root, 'partial', False):
                    return empty
            return dictionary.getlist(self.field_name)

        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):
        """
        List of dicts of native values <- List of dicts of primitive datatypes.
        """
        if html.is_html_input(data):
            data = html.parse_html_list(data)

        if not isinstance(data, list):
            message = self.error_messages['not_a_list'].format(
                input_type=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            }, code='not_a_list')

        if not self.allow_empty and len(data) == 0:
            if self.parent and self.partial:
                raise SkipField()

            message = self.error_messages['empty']
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            }, code='empty')

        ret = []
        errors = []

        for item in data:
            try:
                # prepare child serializer to only handle one instance
                if 'id' in item.keys():
                    self.child.instance = self.instance.get(id=item['id']) if self.instance else None
                if 'pk' in item.keys():
                    self.child.instance = self.instance.get(id=item['pk']) if self.instance else None

                self.child.initial_data = item
                # raw
                validated = self.child.run_validation(item)
            except ValidationError as exc:
                errors.append(exc.detail)
            else:
                ret.append(validated)
                errors.append({})

        if any(errors):
            raise ValidationError(errors)

        return ret

    def to_internal_value(self, data):
        """
        List of dicts of native values <- List of dicts of primitive datatypes.
        """

        serializer_field = self.fields[self.model_field.name]

        if html.is_html_input(data):
            data = html.parse_html_list(data)
        if isinstance(data, type('')) or not hasattr(data, '__iter__'):
            self.fail('not_a_dict', input_type=type(data).__name__)

        native = OrderedDict()
        for key in data:
            native[key] = serializer_field.run_validation(data[key])
        return native

 def get_value(self, dictionary):
     """
     Given the *incoming* primitive data, return the value for this field
     that should be validated and transformed to a native value.
     """
     if html.is_html_input(dictionary):
         # HTML forms will represent empty fields as '', and cannot
         # represent None or False values directly.
         if self.field_name not in dictionary:
             if getattr(self.root, 'partial', False):
                 return empty
             return self.default_empty_html
         ret = dictionary[self.field_name]
         if ret == '' and self.allow_null:
             # If the field is blank, and null is a valid value then
             # determine if we should use null instead.
             return '' if getattr(self, 'allow_blank', False) else None
         return ret
     return dictionary.get(self.field_name, empty)

    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 get_value(self, dictionary):
     if html.is_html_input(dictionary):
         content = dictionary.get(self.field_name, [''])
         return [x.strip() for x in content.splitlines() if x.strip()]
     return dictionary.get(self.field_name, [])

 def get_value(self, dictionary):
     # We override the default field access in order to support
     # lists in HTML forms.
     if html.is_html_input(dictionary):
         return dictionary.getlist(self.field_name)
     return dictionary.get(self.field_name, empty)

 def to_internal_value(self, data):
     if html.is_html_input(data):
         data = parse_json_form(data)
     return super(JSONFormSerializer, self).to_internal_value(data)

def html_safe_get(obj, key, default=None):
    if html.is_html_input(obj):
        return obj.getlist(key, default)
    return obj.get(key, default)

 def get_value(self, dictionary):
     if html.is_html_input(dictionary):
         return dictionary.getlist(self.field_name)
     return dictionary.get(self.field_name, None)