python类CharField()的实例源码

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_fields(self):
        """
        Adds invitation_hash field in create action only if registration is
        disabled
        """
        request = self.context.get('request')
        ret = super(UserSerializer, self).get_fields()

        if not request:
            return ret

        if request.method == 'POST' and \
                bool(User.objects.all().count() is not 0) and \
                not settings.VAULTIER.get('registration_allow'):
            ret['invitation_hash'] = serializers.CharField(write_only=True,
                                                           required=True)
        return ret

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 setUp(self):
        from .models import User, Skill

        class AnotherSkillSerializer(serializers.ModelSerializer):
            fullname = serializers.CharField(source="name")

            class Meta:
                model = Skill
                fields = ("id", "fullname")

        class AnotherUserSerializer(serializers.ModelSerializer):
            fullname = serializers.CharField(source="username")
            my_skills = AnotherSkillSerializer(many=True, source="skills")

            class Meta:
                model = User
                fields = ("id", "fullname", "my_skills")
        self.Serializer = AnotherUserSerializer

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(CharField, self).get_value(dictionary)
        return to_representation(value)

def __init__(self, *args, **kwargs):
    """
    Dynamically add the USERNAME_FIELD to self.fields.
    """
    super(ChannelJSONWebTokenSerializer, self).__init__(*args, **kwargs)
    #self.fields['channel'] = serializers.CharField(write_only=True)

def get_field_serializer(cls, field_type):
        try:
            # Try to retrieve right field type
            serializer = getattr(serializers, '%sField' % field_type)
        except AttributeError:
            # Fallback on CharField
            serializer = serializers.CharField
        return serializer

def __init__(self, *args, **kwargs):
        """ Dynamically add the USERNAME_FIELD to self.fields. """
        super().__init__(*args, **kwargs)

        self.fields[self.username_field] = serializers.CharField(
            required=False)
        self.fields['password'] = PasswordField(
            write_only=True, required=False)

def test_should_char_convert_string():
    assert_conversion(serializers.CharField, graphene.String)

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 _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 extend_issue_serializer(self, serializer):
        serializer.fields['service_object_id'] = serializers.CharField(write_only=True, required=False)
        serializer.fields['service_object_type'] = serializers.CharField(write_only=True, required=False)
        serializer.fields['title'] = serializers.CharField(write_only=True, required=False)

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 __init__(self, *args, **kwargs):
        """
        Dynamically add the USERNAME_FIELD to self.fields.
        """
        super(JSONWebTokenSerializer, self).__init__(*args, **kwargs)

        self.fields[self.username_field] = serializers.CharField()
        self.fields['password'] = PasswordField(write_only=True)