python类Serializer()的实例源码

def test_char_field_error_content(self):
        # Too long string
        self.data_set['title'] = 'Too Long Title For Defined Serializer'
        s = run_is_valid(SnippetSerializer, data=self.data_set)
        code = settings.FRIENDLY_FIELD_ERRORS['CharField']['max_length']
        self.assertEqual(s.errors['errors'][0]['code'], code)
        self.assertEqual(s.errors['errors'][0]['field'], 'title')

        # Empty string
        self.data_set['title'] = ''
        s = run_is_valid(SnippetSerializer, data=self.data_set)
        code = settings.FRIENDLY_FIELD_ERRORS['CharField']['blank']
        self.assertEqual(s.errors['errors'][0]['code'], code)
        self.assertEqual(s.errors['errors'][0]['field'], 'title')

        # No data provided
        self.data_set.pop('title')
        s = run_is_valid(SnippetSerializer, data=self.data_set)
        code = settings.FRIENDLY_FIELD_ERRORS['CharField']['required']
        self.assertEqual(s.errors['errors'][0]['code'], code)
        self.assertEqual(s.errors['errors'][0]['field'], 'title')

def _get_default_field_kwargs(property_class):
        """
        Return default kwargs used to initialize
        the Serializer field with.
        :param property_class: Neomodel property class
        """
        defaults = property_class.__dict__.copy()
        delete_attrs = [
            'db_property',
            'choices',
            'has_default',
            'index',
            'unique_index'
        ]
        for attr in delete_attrs:
            if attr in defaults:
                del defaults[attr]

        return defaults

def get_paginator_serializer(self, view, child_serializer_class):
        class BaseFakeListSerializer(serializers.Serializer):
            results = child_serializer_class(many=True)

        class FakePrevNextListSerializer(BaseFakeListSerializer):
            next = URLField()
            previous = URLField()

        # Validate if the view has a pagination_class
        if not (hasattr(view, 'pagination_class')) or view.pagination_class is None:
            return BaseFakeListSerializer

        pager = view.pagination_class
        if hasattr(pager, 'default_pager'):
            # Must be a ProxyPagination
            pager = pager.default_pager

        if issubclass(pager, (PageNumberPagination, LimitOffsetPagination)):
            class FakeListSerializer(FakePrevNextListSerializer):
                count = IntegerField()
            return FakeListSerializer
        elif issubclass(pager, CursorPagination):
            return FakePrevNextListSerializer

        return BaseFakeListSerializer

def __init__(self, oftype = None, model = None, fields = ['__all__']):
        assert oftype is not None, ('You should specify a type for the serializer')
        assert type(fields) is list, ('Serializer fields should be listed')
        assert len(fields) > 0, ('Serializer fields should not be an empty list')

        self.fields = fields
        self.oftype = oftype
        self.model = model
        self.serializer = LazyClass('SwaggerDefaultSerializer', self.oftype)

        self.serializer.set_attr('Meta', self.make_meta())

def get_NAME_serializer(self, field: models.Field, qs: models.QuerySet, obj=None) -> Serializer:
        """
        Returns serializer <NAME> field. This method (`get_NAME_serializer`) is not supposed to use directly.
        :param obj: optional obj passed to method
        :param field: model field
        :param qs: queryset
        :return: Serializer
        """
        raise Exception()

    # noinspection PyPep8Naming,PyMethodMayBeStatic

def get_serializer_fields(self, path, method, view):
        """
        Return a list of `coreapi.Field` instances corresponding to any
        request body input, as determined by the serializer class.
        """
        if method not in ('PUT', 'PATCH', 'POST'):
            return []

        if not hasattr(view, 'get_serializer'):
            return []

        serializer = view.get_serializer()

        if isinstance(serializer, serializers.ListSerializer):
            return [
                coreapi.Field(
                    name='data',
                    location='body',
                    required=True,
                    schema=coreschema.Array()
                )
            ]

        if not isinstance(serializer, serializers.Serializer):
            return []

        fields = []
        for field in serializer.fields.values():
            if field.read_only or isinstance(field, serializers.HiddenField):
                continue

            required = field.required and method != 'PATCH'
            field = coreapi.Field(
                name=field.field_name,
                location='form',
                required=required,
                schema=field_to_schema(field)
            )
            fields.append(field)

        return fields

def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None):
        """
        Alters the init arguments slightly.
        For example, drop 'template_name', and instead use 'data'.

        Setting 'renderer' and 'media_type' will typically be deferred,
        For example being set automatically by the `APIView`.
        """
        super(Response, self).__init__(None, status=status)

        if isinstance(data, Serializer):
            msg = (
                'You passed a Serializer instance as data, but '
                'probably meant to pass serialized `.data` or '
                '`.error`. representation.'
            )
            raise AssertionError(msg)

        self.data = data
        self.template_name = template_name
        self.exception = exception
        self.content_type = content_type

        if headers:
            for name, value in six.iteritems(headers):
                self[name] = value

def add_disponibility_representation(func):
  @wraps(func)
  def _impl(self, instance):
    # We pop disponibility field to avoid AttributeError on default Serializer.to_representation
    for i, field in enumerate(self._readable_fields):
      if field.field_name == "disponibility":
        disponibility = self._readable_fields.pop(i)

    ret = func(self, instance)
    self._readable_fields.insert(i, disponibility) # Put disp back

    # Add disponibility representation
    obj = None
    ret["disponibility"] = None

    try:
      type = "job"
      obj = JobSerializer().to_representation(instance.job)
    except models.Job.DoesNotExist:
      try:
        type = "work"
        obj = WorkSerializer().to_representation(instance.work)
      except models.Work.DoesNotExist: # pragma: no cover
        pass

    if obj:
      ret["disponibility"] = {
        "type": type,
        type: obj
      }


    return ret
  return _impl

def __init__(self, field, parent, only_fields, include_fields):
        self.field = field
        self.parent = parent
        self.is_many = isinstance(field, serializers.ListSerializer) and isinstance(field.child, serializers.Serializer)
        self.has_context = isinstance(field, serializers.Serializer) or self.is_many
        if self.has_context:
            self.old_context = None
            self.only_fields = self.filter_fields(field.field_name, only_fields)
            self.include_fields = self.filter_fields(field.field_name, include_fields)
            self.on_exit_delete_fields = False
            self.on_exit_delete_include_fields = False
            self.old_fields = None
            self.old_include_fields = None

def data(self):
        return super(serializers.Serializer, self).data

def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None):
        """
        Alters the init arguments slightly.
        For example, drop 'template_name', and instead use 'data'.

        Setting 'renderer' and 'media_type' will typically be deferred,
        For example being set automatically by the `APIView`.
        """
        super(Response, self).__init__(None, status=status)

        if isinstance(data, Serializer):
            msg = (
                'You passed a Serializer instance as data, but '
                'probably meant to pass serialized `.data` or '
                '`.error`. representation.'
            )
            raise AssertionError(msg)

        self.data = data
        self.template_name = template_name
        self.exception = exception
        self.content_type = content_type

        if headers:
            for name, value in six.iteritems(headers):
                self[name] = value

def paginated_response(queryset, serializer_class, request):
    """
    Pagination helper for a @detail route.
    http://stackoverflow.com/a/29144786/1377500

    :type serializer_class: rest_framework.serializers.Serializer
    :rtype:                 rest_framework.response.Response
    """
    paginator = CountedPageNumberPagination()
    page = paginator.paginate_queryset(queryset, request)
    serializer = serializer_class(
        page, many=True, context={'request': request})
    return paginator.get_paginated_response(serializer.data)

def setUp(self):

        class TestSerializer(serializers.Serializer):
            ctype = ContentTypeIdentityField(queryset=ContentType.objects.all())

        self.Serializer = TestSerializer
        self.ctype = ContentType.objects.get(app_label='auth', model='user')

def test_serialize_valid_input(self):
        serializer = self.Serializer(data={'ctype': 'auth.user'})
        self.assertTrue(serializer.is_valid())
        self.assertEqual(serializer.validated_data['ctype'], self.ctype)

def test_serialize_invalid_data_type(self):
        serializer = self.Serializer(data={'ctype': 1})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('ctype' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise ValidationError when serializing invalid data type using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(
                str(e), "{'ctype': ['Incorrect type. Expected content type string identifier, received int.']}")

def test_serialize_invalid_length_content_type_string(self):
        serializer = self.Serializer(data={'ctype': 'auth'})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('ctype' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise ValidationError when serializing invalid content '
                      'type string using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(str(e), "{'ctype': ['Incorrect length. Expected content type string, "
                                     "separated by punctuation. Received \"auth\".']}")

def test_serializer_non_existent_content_type(self):
        serializer = self.Serializer(data={'ctype': 'non.existent'})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('ctype' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise exception when serializing non-existent content '
                      'type string using using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(str(e), "{'ctype': ['Invalid content type \"non.existent\" - object does not exist.']}")

def test_serialize_valid_permission_input(self):
        serializer = self.Serializer(data={'perm': self.perm_string})
        self.assertTrue(serializer.is_valid())
        self.assertEqual(serializer.validated_data['perm'], self.permission)

def test_serialize_invalid_permission_data_type(self):
        serializer = self.Serializer(data={'perm': 1})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('perm' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise ValidationError when serializing invalid data type using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(
                str(e), "{'perm': ['Incorrect type. Expected permission string identifier, received int.']}")

def test_serialize_invalid_length_permission_string(self):
        serializer = self.Serializer(data={'perm': 'add_user'})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('perm' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise ValidationError when serializing invalid permission '
                      'string using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(str(e), "{'perm': ['Incorrect length. Expected permission string identifier, "
                                     "separated by punctuation. Received \"add_user\".']}")

def test_serializer_non_existent_permission(self):
        serializer = self.Serializer(data={'perm': 'auth.can_levitate'})
        self.assertFalse(serializer.is_valid())
        self.assertTrue('perm' in serializer.errors)

        try:
            serializer.is_valid(raise_exception=True)
            self.fail('Did not raise exception when serializing non-existent permission '
                      'string using using `raise_exception=True`')
        except serializers.ValidationError as e:
            self.assertEqual(str(e), "{'perm': ['Invalid permission \"auth.can_levitate\" "
                                     "- object does not exist.']}")

def get_serializer_class(self):
        if self.action == 'review':
            return serializers.Serializer
        return super().get_serializer_class()

def build_nested_field(self, field_name, info, relationship, nested_depth):
        """
        Builds nested serializer to handle relationshipped model
        """
        target_model = relationship.mapper.class_
        nested_fields = self.get_nested_relationship_fields(target_model, info, relationship, nested_depth)

        field_kwargs = self.get_relationship_kwargs(relationship, nested_depth)
        field_kwargs = self.include_extra_kwargs(field_kwargs, self._extra_kwargs.get(field_name))
        nested_extra_kwargs = {}

        nested_info = model_info(target_model)
        if not field_kwargs.get('required', True):
            for nested_field in nested_info.primary_keys:
                nested_extra_kwargs.setdefault(nested_field, {}).setdefault('required', False)

        if not field_kwargs.get('allow_nested_updates', True):
            nested_depth = 0
            for nested_field in nested_info.properties:
                nested_extra_kwargs.setdefault(nested_field, {}).setdefault('read_only', True)
                nested_extra_kwargs.setdefault(nested_field, {}).pop('required', None)

        class NestedSerializer(ModelSerializer):

            class Meta:
                model = target_model
                session = self.session
                depth = max(0, nested_depth - 1)
                fields = nested_fields
                extra_kwargs = nested_extra_kwargs

        return type(target_model.__name__ + 'Serializer', (NestedSerializer, ), {})(**field_kwargs)

def _makeSerializer(self):
        class CommentSerializer(serializers.Serializer):
            name = serializers.CharField()
            content = serializers.CharField()

        class ArticleSerializer(serializers.Serializer):
            name = serializers.CharField()
            content = serializers.CharField()
            comments = CommentSerializer(many=True)
        return ArticleSerializer

def test_it(self):
        Serializer = self._makeOne(self._makeSerializer())
        article = self._makeArticle()
        result = Serializer(article).data

        expected = '{"name": "hello", "content": "hello world", "comments": [{"name": "title0", "content": "hmm"}, {"name": "title1", "content": "hmm"}, {"name": "title2", "content": "hmm"}]}'  # NOQA
        actual = json.dumps(result)
        self.assertEqual(actual, expected)

def test_it__filtering(self):
        Serializer = self._makeOne(self._makeSerializer())
        article = self._makeArticle()
        request = self._makeDummyRequest({"skip_fields": "content,comments__content"})
        result = Serializer(article, context={"request": request}).data

        expected = '{"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}'  # NOQA
        actual = json.dumps(result)
        self.assertEqual(actual, expected)

def test_it__filtering__from_list__cached(self):
        Serializer = self._makeOne(self._makeSerializer())

        articles = [self._makeArticle(), self._makeArticle(), self._makeArticle()]
        request = self._makeDummyRequest({"skip_fields": "content,comments__content"})
        result = Serializer(articles, context={"request": request}, many=True).data
        expected = '[{"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}, {"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}, {"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}]'  # NOQA

        actual = json.dumps(result)
        self.assertEqual(actual, expected)

def __init__(self, allow_extra):
        class Model(serializers.Serializer):
            id = serializers.IntegerField()
            client_name = serializers.CharField(max_length=255)
            sort_index = serializers.FloatField()
            # client_email = serializers.EmailField(required=False, allow_null=True)
            client_phone = serializers.CharField(max_length=255, required=False, allow_null=True)

            class Location(serializers.Serializer):
                latitude = serializers.FloatField(required=False, allow_null=True)
                longitude = serializers.FloatField(required=False, allow_null=True)
            location = Location(required=False, allow_null=True)

            contractor = serializers.IntegerField(required=False, allow_null=True, min_value=0)
            upstream_http_referrer = serializers.CharField(max_length=1023, required=False, allow_null=True)
            grecaptcha_response = serializers.CharField(min_length=20, max_length=1000)
            last_updated = serializers.DateTimeField(required=False, allow_null=True)

            class Skill(serializers.Serializer):
                subject = serializers.CharField()
                subject_id = serializers.IntegerField()
                category = serializers.CharField()
                qual_level = serializers.CharField()
                qual_level_id = serializers.IntegerField()
                qual_level_ranking = serializers.FloatField(default=0)
            skills = serializers.ListField(child=Skill())

        self.allow_extra = allow_extra  # unused
        self.serializer = Model

def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None,
                 err_code=0, err_msg=''):
        """
        Alters the init arguments slightly.
        For example, drop 'template_name', and instead use 'data'.

        Setting 'renderer' and 'media_type' will typically be deferred,
        For example being set automatically by the `APIView`.
        """
        super(Response, self).__init__(None, status=status)

        if isinstance(data, Serializer):
            msg = (
                'You passed a Serializer instance as data, but '
                'probably meant to pass serialized `.data` or '
                '`.error`. representation.'
            )
            raise AssertionError(msg)

        self.data = data
        self.template_name = template_name
        self.exception = exception
        self.content_type = content_type
        self.wrapper = {
            'code': err_code,
            'message': err_msg,
            'data': self.data
        }

        if headers:
            for name, value in six.iteritems(headers):
                self[name] = value

def get_serializers(self):
        """ Get `Serializer`classes for every collection. """
        return self.serializers