Python rest_framework.serializers 模块，IntegerField() 实例源码

def test_validation_attrs(self):
        data = (
            (CharField(), {}),
            (IntegerField, {}),
            (CharField(min_length=3), {'min': 3}),
            (CharField(max_length=10), {'max': 10}),
            (CharField(min_length=3, max_length=10), {'min': 3, 'max': 10}),
            (IntegerField(min_value=0), {'min': 0}),
            (IntegerField(max_value=100), {'max': 100}),
            (IntegerField(min_value=0, max_value=100), {'min': 0, 'max': 100}),
        )

        for input_field, expected in data:
            result = utils.get_validation_attrs(input_field)
            self.assertEqual(result, expected,
                             'got {} while expecting {} when comparing validation attrs for {}'.format(
                                 result,
                                 expected,
                                 input_field
                             ))

def get_fields(self):
        field_mapping = OrderedDict()

        # Normal properties
        for field, property_class in self.instance.defined_properties(aliases=False, rels=False).items():
            # TODO: Support AliasField - check for __call__ in _field_mapping.
            field_mapping['id'] = serializers.IntegerField(default=self.instance.id)
            field_mapping['label'] = serializers.CharField(default=self.instance.__label__)
            field_mapping.update({
                field: self.get_serializer_field(property_class, **self._get_default_field_kwargs(property_class))
            })

        # Relationships
        for field, property_class in self.instance.defined_properties(aliases=False, properties=False).items():
            field_mapping.update({
                field: RelationshipSerializer(property_class.definition, many=not isinstance(property_class, One))
            })

        return field_mapping

def typemap(self, p):
        mapping = {
            ParameterType.String : serializers.CharField,
            ParameterType.Number : serializers.FloatField,
            ParameterType.Integer : serializers.IntegerField,
            ParameterType.Boolean : serializers.BooleanField,
            ParameterType.Array : serializers.ListField,
            ParameterType.Enum : serializers.ChoiceField,
            ParameterType.File : serializers.FileField
        }

        return mapping.get(p, None)

    # TODO: properly handle array and enums

def get_value(self, dictionary):
        """Get value."""
        value = super(IntegerField, self).get_value(dictionary)
        return to_representation(value)

def test_should_integer_convert_int():
    assert_conversion(serializers.IntegerField, graphene.Int)

def test_should_list_convert_to_list():
    class StringListField(serializers.ListField):
        child = serializers.CharField()

    field_a = assert_conversion(
        serializers.ListField,
        graphene.List,
        child=serializers.IntegerField(min_value=0, max_value=100)
    )

    assert field_a.of_type == graphene.Int

    field_b = assert_conversion(StringListField, graphene.List)

    assert field_b.of_type == graphene.String

def get_fields(self):
        field_mapping = OrderedDict()
        for key, value in self.instance.items():
            if key == 'node_class':
                field_mapping['to'] = serializers.CharField(default=value.__label__)
            elif isinstance(value, RelationshipMeta):
                field_mapping['meta'] = serializers.DictField(
                    child=serializers.CharField(),
                    default={k: v.default for k, v in value.__dict__.items() if isinstance(v, properties.Property)})
            elif key == 'direction':
                field_mapping[key] = serializers.IntegerField(default=value)
            elif key == 'relation_type':
                field_mapping[key] = serializers.CharField(default=value)
        return field_mapping

def extend_issue_serializer(self, serializer):
        from issues_geometry.models import DEFAULT_SRID
        serializer.fields['geometry'] = GeoJSONField(write_only=True, required=False)
        serializer.fields['srid'] = serializers.IntegerField(write_only=True, required=False, default=DEFAULT_SRID)

def to_representation(self, obj):
        if isinstance(obj,UserProfile):
            return super(UserProfileSerializer,self).to_representation(obj)
        serializer = TokenSerializer(obj)
        return serializer.data

# class ScoreSerializer(serializers.ModelSerializer):
#     UserId = serializers.IntegerField(source='GiverPersonId_id',read_only=True) #Read olurken hangi user in verdigini anlamak icin kullanilir
#     Score = serializers.IntegerField(source='Point')
#     Name = serializers.CharField(source='GiverPersonId.user.first_name',read_only=True)
#     Image = serializers.ImageField(source='GiverPersonId.Photo', max_length=None, use_url=True, read_only=True)
#     class Meta(object):
#         model = Score
#         fields = ('Score','UserId','Name','Image')
#     def create(self, validated_data):
#         taker = self.context['view'].kwargs['pk']
#         score = Score.objects.create(TakerPersonId_id=taker ,GiverPersonId_id=self.context['request'].user.id, **validated_data)
#         scores = Score.objects.filter(TakerPersonId_id=taker)
#         total = 0.0
#         for score in scores:
#             total += score.Point
#         avarage_score =  total / len(scores)
#         user = UserProfile.objects.get(pk=taker)
#         user.Score = avarage_score
#         user.save()
#         return {'IsSuccess':True,'context':''}
#     def to_representation(self, obj):
#         if isinstance(obj,Score):
#             return super(ScoreSerializer,self).to_representation(obj)
#         serializer = ResultSerializer(obj)
#         return serializer.data

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 field_to_schema(field):
    title = force_text(field.label) if field.label else ''
    description = force_text(field.help_text) if field.help_text else ''

    if isinstance(field, serializers.ListSerializer):
        child_schema = field_to_schema(field.child)
        return coreschema.Array(
            items=child_schema,
            title=title,
            description=description
        )
    elif isinstance(field, serializers.Serializer):
        return coreschema.Object(
            properties=OrderedDict([
                (key, field_to_schema(value))
                for key, value
                in field.fields.items()
            ]),
            title=title,
            description=description
        )
    elif isinstance(field, serializers.ManyRelatedField):
        return coreschema.Array(
            items=coreschema.String(),
            title=title,
            description=description
        )
    elif isinstance(field, serializers.RelatedField):
        return coreschema.String(title=title, description=description)
    elif isinstance(field, serializers.MultipleChoiceField):
        return coreschema.Array(
            items=coreschema.Enum(enum=list(field.choices.keys())),
            title=title,
            description=description
        )
    elif isinstance(field, serializers.ChoiceField):
        return coreschema.Enum(
            enum=list(field.choices.keys()),
            title=title,
            description=description
        )
    elif isinstance(field, serializers.BooleanField):
        return coreschema.Boolean(title=title, description=description)
    elif isinstance(field, (serializers.DecimalField, serializers.FloatField)):
        return coreschema.Number(title=title, description=description)
    elif isinstance(field, serializers.IntegerField):
        return coreschema.Integer(title=title, description=description)

    if field.style.get('base_template') == 'textarea.html':
        return coreschema.String(
            title=title,
            description=description,
            format='textarea'
        )
    return coreschema.String(title=title, description=description)