Python graphene.ID属性代码示例

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def perform_mutation(cls, root, info, **data):
        """Perform the mutation.

        Delete the instance from the database given its `id` attribute
        in the input data.
        """
        instance = cls.get_instance(info, data.get('id'))

        db_id = instance.id
        cls.delete(info, instance)

        # After the instance is deleted, set its ID to the original database's
        # ID so that the success response contains ID of the deleted object.
        instance.id = db_id
        return cls(**{cls._meta.return_field_name: instance})


# Compatibility with older versions 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def __init__(self, _type, *args, **kwargs):
        kwargs["id"] = ID(
            required=True, description="Django object unique identification field"
        )

        super(DjangoObjectField, self).__init__(_type, *args, **kwargs) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_column_to_string(type, attribute, registry=None):
    if attribute.is_hash_key:
        return ID(description=attribute.attr_name, required=not attribute.null)

    return String(description=getattr(attribute, 'attr_name'),
                  required=not (getattr(attribute, 'null', True))) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_column_to_float_or_id(type, attribute, registry=None):
    if attribute.is_hash_key:
        return ID(description=attribute.attr_name, required=not attribute.null)

    return Float(description=attribute.attr_name, required=not attribute.null) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def __init__(self):
        self._typeMap = {}
        self.Field = create_registry_field(self)
        self.Argument = create_registry_argument(self)
        self.List = create_registry_list(self)
        self.NonNull = create_registry_nonnull(self)
        registering_metaclass = create_registering_metaclass(self)
        self.Union = create_union(registering_metaclass, self)
        self.Enum = create_enum(registering_metaclass)
        self.Mutation = graphene.Mutation

        # Not looping over GRAPHENE_TYPES in order to not fool lint
        self.ObjectType = create_registering_class(graphene.ObjectType, registering_metaclass)
        self.InputObjectType = create_registering_class(
            graphene.InputObjectType, registering_metaclass
        )
        self.Interface = create_registering_class(graphene.Interface, registering_metaclass)
        self.Scalar = create_registering_class(graphene.Scalar, registering_metaclass)

        # Not looping over GRAPHENE_BUILTINS in order to not fool lint
        self.String = graphene.String
        self.addType(graphene.String)
        self.Int = graphene.Int
        self.addType(graphene.Int)
        self.Float = graphene.Float
        self.addType(graphene.Float)
        self.Boolean = graphene.Boolean
        self.addType(graphene.Boolean)
        self.ID = graphene.ID
        self.addType(graphene.ID)
        self.GenericScalar = GenericScalar
        self.addType(GenericScalar) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_column_to_int_or_id(type, column, registry=None):
    if column.primary_key or column.foreign_keys:
        return graphene.ID(
            description=get_column_doc(column),
            required=not (is_column_nullable(column)),
        )
    else:
        return graphene.Int(
            description=get_column_doc(column),
            required=not (is_column_nullable(column)),
        ) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_field_to_id(field, registry=None):
    return graphene.ID(
        description=get_field_description(field, registry), required=field.required
    ) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def test_should_update(fixtures):
    class UpdateEditor(graphene.Mutation):
        class Arguments:
            id = graphene.ID()
            first_name = graphene.String()

        editor = graphene.Field(EditorNode)

        def mutate(self, info, id, first_name):
            editor = Editor.objects.get(id=id)
            editor.first_name = first_name
            editor.save()
            return UpdateEditor(editor=editor)

    class Query(graphene.ObjectType):

        node = Node.Field()

    class Mutation(graphene.ObjectType):

        update_editor = UpdateEditor.Field()

    query = """
        mutation EditorUpdater {
            updateEditor(
                id: "1"
                firstName: "Tony"
            ) {
                editor {
                    firstName
                }
            }
        }
    """
    expected = {"updateEditor": {"editor": {"firstName": "Tony"}}}
    schema = graphene.Schema(query=Query, mutation=Mutation)
    result = schema.execute(query)
    # print(result.data)
    assert not result.errors
    assert result.data == expected 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def test_should_uuid_convert_id():
    assert_conversion(mongoengine.UUIDField, graphene.ID) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def test_should_object_id_convert_id():
    assert_conversion(mongoengine.ObjectIdField, graphene.ID) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_form_field_to_list(field):
    return List(ID, required=field.required) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def convert_form_field_to_id(field):
    return ID(required=field.required) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def test_should_auto_convert_id():
    assert_conversion(models.AutoField, graphene.ID, primary_key=True) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def _is_list_of_ids(field):
    return (
        isinstance(field.type, graphene.List) and
        field.type.of_type == graphene.ID
    ) 

# 需要导入模块: import graphene [as 别名]
# 或者: from graphene import ID [as 别名]
def _is_id_field(field):
    return (
        field.type == graphene.ID or
        isinstance(field.type, graphene.NonNull) and
        field.type.of_type == graphene.ID
    )