Python serializers.Field方法代码示例

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def test_embedding_custom_bottom(self):
        class CustomEmbedding(Field):
            bla = drf_fields.CharField()

        class TestSerializer(DocumentSerializer):
            serializer_embedded_bottom = CustomEmbedding

            class Meta:
                model = NestedEmbeddingDoc
                fields = '__all__'
                depth_embedding = 0

        expected = dedent("""
            TestSerializer():
                id = ObjectIdField(read_only=True)
                embedded = CustomEmbedding(default=None, required=False)
        """)
        assert repr(TestSerializer()) == expected 

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def test_should_base_field_convert_string():
    assert_conversion(serializers.Field, graphene.String) 

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def test_should_model_convert_field():
    class MyModelSerializer(serializers.ModelSerializer):
        class Meta:
            model = None
            fields = "__all__"

    assert_conversion(MyModelSerializer, graphene.Field, is_input=False) 

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def test_describe_field_with_custom_type(self):
        class DummyField(serializers.Field):
            doc_format = '{"foo": "bar"}'
            writable_doc_format = '{"baz": "quux"}'

        class DummySerializer(serializers.Serializer):
            field = DummyField()

        instance = DummySerializer()

        result = describe_serializer(instance, include_read_only=True)
        self.assertEqual(_flatten_field_data(result), {'field': {'value': {'foo': 'bar'}}})

        result = describe_serializer(instance, include_read_only=False)
        self.assertEqual(_flatten_field_data(result), {'field': {'value': {'baz': 'quux'}}}) 

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def get_attribute(self, instance):
        return serializers.Field.get_attribute(self, instance) 

# 需要导入模块: from rest_framework import serializers [as 别名]
# 或者: from rest_framework.serializers import Field [as 别名]
def modelserializer_factory(model, serializer=serializers.ModelSerializer, fields=None, exclude=None, **kwargs):
    """
    Generate serializer basing on django's modelform_factory
    :param model: model we create serializer for
    :param serializer: base serializer class
    :param fields: list of fields to include in serializer
    :param exclude: list of fields to exclude from serializer
    :param kwargs: fields mapping
    :return:
    """

    # TODO: decide if we need cache and what to do with parameters tha can be different
    serializer_class = serializer_cache.get(model, None)

    if serializer_class:
        return serializer_class

    def _get_declared_fields(attrs):
        fields = [(field_name, attrs.pop(field_name))
                  for field_name, obj in list(attrs.items())
                  if isinstance(obj, serializers.Field)]
        fields.sort(key=lambda x: x[1]._creation_counter)
        return OrderedDict(fields)

    meta_attrs = {'model': model}
    if fields is not None:
        meta_attrs['fields'] = fields
    if exclude is not None:
        meta_attrs['exclude'] = exclude
    if fields is None and exclude is None:
        meta_attrs['fields'] = '__all__'

    parent = (object, )
    Meta = type(str('Meta'), parent, meta_attrs)
    class_name = model.__name__ + str('Serializer')

    serializer_class_attrs = {
        'Meta': Meta,
        '_get_declared_fields': _get_declared_fields(kwargs),
    }
    serializer_class = type(serializer)(class_name, (serializer,), serializer_class_attrs)
    serializer_cache[model] = serializer_class
    return serializer_class