# Language

GraphQL Language

The `graphql.language` package is responsible for parsing and operating on the GraphQL language.

## AST

class graphql.language.Location(start_token: Token, end_token: Token, source: Source)

  Bases: `object`

  AST Location

  Contains a range of UTF-8 character offsets and token references that identify the region of the source from which the AST derived.

  __init__(start_token: Token, end_token: Token, source: Source) → None
  end: int
  end_token: Token
  source: Source
  start: int
  start_token: Token

class graphql.language.Node(**kwargs: Any)

  Bases: `object`

  AST nodes

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'ast'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

Each kind of AST node has its own class:

class graphql.language.ArgumentNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name', 'value')
  kind: str = 'argument'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  value: ValueNode

class graphql.language.BooleanValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'value')
  kind: str = 'boolean_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: bool

class graphql.language.ConstArgumentNode(**kwargs: Any)

  Bases: `ArgumentNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name', 'value', 'name', 'value')
  kind: str = 'argument'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode

class graphql.language.ConstDirectiveNode(**kwargs: Any)

  Bases: `DirectiveNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  arguments: Tuple[ConstArgumentNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'arguments', 'name', 'arguments')
  kind: str = 'directive'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ConstListValueNode(**kwargs: Any)

  Bases: `ListValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'values', 'values')
  kind: str = 'list_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  values: Tuple[IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode, ...]

class graphql.language.ConstObjectFieldNode(**kwargs: Any)

  Bases: `ObjectFieldNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name', 'value', 'name', 'value')
  kind: str = 'object_field'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode

class graphql.language.ConstObjectValueNode(**kwargs: Any)

  Bases: `ObjectValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  fields: Tuple[ConstObjectFieldNode, ...]
  keys: Tuple[str, ...] = ('loc', 'fields', 'fields')
  kind: str = 'object_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

graphql.language.ConstValueNode

  alias of `IntValueNode` | `FloatValueNode` | `StringValueNode` | `BooleanValueNode` | `NullValueNode` | `EnumValueNode` | `ConstListValueNode` | `ConstObjectValueNode`

class graphql.language.DefinitionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'definition'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.DirectiveDefinitionNode(**kwargs: Any)

  Bases: `TypeSystemDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  arguments: Tuple[InputValueDefinitionNode, ...]
  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'arguments', 'directives', 'repeatable', 'locations')
  kind: str = 'directive_definition'
  loc: Location | None
  locations: Tuple[NameNode, ...]
  name: NameNode
  repeatable: bool
  to_dict(locations: bool = False) → Dict

class graphql.language.DirectiveExtensionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives')
  kind: str = 'directive_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.DirectiveNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  arguments: Tuple[ArgumentNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'arguments')
  kind: str = 'directive'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.DocumentNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  definitions: Tuple[DefinitionNode, ...]
  keys: Tuple[str, ...] = ('loc', 'definitions')
  kind: str = 'document'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  token_count: int = 0

class graphql.language.EnumTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'values')
  kind: str = 'enum_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  values: Tuple[EnumValueDefinitionNode, ...]

class graphql.language.EnumTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives', 'values')
  kind: str = 'enum_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  values: Tuple[EnumValueDefinitionNode, ...]

class graphql.language.EnumValueDefinitionNode(**kwargs: Any)

  Bases: `DefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives')
  kind: str = 'enum_value_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.EnumValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'value')
  kind: str = 'enum_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: str

class graphql.language.ExecutableDefinitionNode(**kwargs: Any)

  Bases: `DefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'variable_definitions', 'selection_set')
  kind: str = 'executable_definition'
  loc: Location | None
  name: NameNode | None
  selection_set: SelectionSetNode
  to_dict(locations: bool = False) → Dict
  variable_definitions: Tuple[VariableDefinitionNode, ...]

class graphql.language.FieldDefinitionNode(**kwargs: Any)

  Bases: `DefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  arguments: Tuple[InputValueDefinitionNode, ...]
  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'arguments', 'type')
  kind: str = 'field_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  type: TypeNode

class graphql.language.FieldNode(**kwargs: Any)

  Bases: `SelectionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  alias: NameNode | None
  arguments: Tuple[ArgumentNode, ...]
  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'directives', 'alias', 'name', 'arguments', 'selection_set')
  kind: str = 'field'
  loc: Location | None
  name: NameNode
  selection_set: SelectionSetNode | None
  to_dict(locations: bool = False) → Dict

class graphql.language.FloatValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'value')
  kind: str = 'float_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: str

class graphql.language.FragmentDefinitionNode(**kwargs: Any)

  Bases: `ExecutableDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'variable_definitions', 'selection_set', 'type_condition')
  kind: str = 'fragment_definition'
  loc: Location | None
  name: NameNode
  selection_set: SelectionSetNode
  to_dict(locations: bool = False) → Dict
  type_condition: NamedTypeNode
  variable_definitions: Tuple[VariableDefinitionNode, ...]

class graphql.language.FragmentSpreadNode(**kwargs: Any)

  Bases: `SelectionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'directives', 'name')
  kind: str = 'fragment_spread'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.InlineFragmentNode(**kwargs: Any)

  Bases: `SelectionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'directives', 'type_condition', 'selection_set')
  kind: str = 'inline_fragment'
  loc: Location | None
  selection_set: SelectionSetNode
  to_dict(locations: bool = False) → Dict
  type_condition: NamedTypeNode

class graphql.language.InputObjectTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[InputValueDefinitionNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'fields')
  kind: str = 'input_object_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.InputObjectTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[InputValueDefinitionNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives', 'fields')
  kind: str = 'input_object_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.InputValueDefinitionNode(**kwargs: Any)

  Bases: `DefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  default_value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode | None
  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'type', 'default_value')
  kind: str = 'input_value_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  type: TypeNode

class graphql.language.IntValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'value')
  kind: str = 'int_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: str

class graphql.language.InterfaceTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[FieldDefinitionNode, ...]
  interfaces: Tuple[NamedTypeNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'fields', 'interfaces')
  kind: str = 'interface_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.InterfaceTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[FieldDefinitionNode, ...]
  interfaces: Tuple[NamedTypeNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives', 'interfaces', 'fields')
  kind: str = 'interface_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ListTypeNode(**kwargs: Any)

  Bases: `TypeNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'type')
  kind: str = 'list_type'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  type: TypeNode

class graphql.language.ListValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'values')
  kind: str = 'list_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  values: Tuple[ValueNode, ...]

class graphql.language.NameNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'value')
  kind: str = 'name'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: str

class graphql.language.NamedTypeNode(**kwargs: Any)

  Bases: `TypeNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name')
  kind: str = 'named_type'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.NonNullTypeNode(**kwargs: Any)

  Bases: `TypeNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'type')
  kind: str = 'non_null_type'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  type: NamedTypeNode | ListTypeNode

class graphql.language.NullValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'null_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.ObjectFieldNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name', 'value')
  kind: str = 'object_field'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  value: ValueNode

class graphql.language.ObjectTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[FieldDefinitionNode, ...]
  interfaces: Tuple[NamedTypeNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'interfaces', 'fields')
  kind: str = 'object_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ObjectTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  fields: Tuple[FieldDefinitionNode, ...]
  interfaces: Tuple[NamedTypeNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives', 'interfaces', 'fields')
  kind: str = 'object_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ObjectValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  fields: Tuple[ObjectFieldNode, ...]
  keys: Tuple[str, ...] = ('loc', 'fields')
  kind: str = 'object_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.OperationDefinitionNode(**kwargs: Any)

  Bases: `ExecutableDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'variable_definitions', 'selection_set', 'operation')
  kind: str = 'operation_definition'
  loc: Location | None
  name: NameNode | None
  operation: OperationType
  selection_set: SelectionSetNode
  to_dict(locations: bool = False) → Dict
  variable_definitions: Tuple[VariableDefinitionNode, ...]

class graphql.language.OperationType(*values)

  Bases: `Enum`

  MUTATION = 'mutation'
  QUERY = 'query'
  SUBSCRIPTION = 'subscription'

class graphql.language.OperationTypeDefinitionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'operation', 'type')
  kind: str = 'operation_type_definition'
  loc: Location | None
  operation: OperationType
  to_dict(locations: bool = False) → Dict
  type: NamedTypeNode

class graphql.language.ScalarTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives')
  kind: str = 'scalar_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ScalarTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives')
  kind: str = 'scalar_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.SchemaDefinitionNode(**kwargs: Any)

  Bases: `TypeSystemDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'directives', 'operation_types')
  kind: str = 'schema_definition'
  loc: Location | None
  operation_types: Tuple[OperationTypeDefinitionNode, ...]
  to_dict(locations: bool = False) → Dict

class graphql.language.SchemaExtensionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'directives', 'operation_types')
  kind: str = 'schema_extension'
  loc: Location | None
  operation_types: Tuple[OperationTypeDefinitionNode, ...]
  to_dict(locations: bool = False) → Dict

class graphql.language.SelectionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'directives')
  kind: str = 'selection'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.SelectionSetNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'selections')
  kind: str = 'selection_set'
  loc: Location | None
  selections: Tuple[SelectionNode, ...]
  to_dict(locations: bool = False) → Dict

class graphql.language.StringValueNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  block: bool | None
  keys: Tuple[str, ...] = ('loc', 'value', 'block')
  kind: str = 'string_value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  value: str

class graphql.language.TypeDefinitionNode(**kwargs: Any)

  Bases: `TypeSystemDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[DirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives')
  kind: str = 'type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.TypeExtensionNode(**kwargs: Any)

  Bases: `TypeSystemDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives')
  kind: str = 'type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.TypeNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'type'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.TypeSystemDefinitionNode(**kwargs: Any)

  Bases: `DefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'type_system_definition'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

graphql.language.TypeSystemExtensionNode

  alias of `SchemaExtensionNode` | `TypeExtensionNode` | `DirectiveExtensionNode`

class graphql.language.UnionTypeDefinitionNode(**kwargs: Any)

  Bases: `TypeDefinitionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'name', 'directives', 'types')
  kind: str = 'union_type_definition'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  types: Tuple[NamedTypeNode, ...]

class graphql.language.UnionTypeExtensionNode(**kwargs: Any)

  Bases: `TypeExtensionNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'name', 'directives', 'types')
  kind: str = 'union_type_extension'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict
  types: Tuple[NamedTypeNode, ...]

class graphql.language.ValueNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc',)
  kind: str = 'value'
  loc: Location | None
  to_dict(locations: bool = False) → Dict

class graphql.language.VariableDefinitionNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  default_value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode | None
  description: StringValueNode | None
  directives: Tuple[ConstDirectiveNode, ...]
  keys: Tuple[str, ...] = ('loc', 'description', 'variable', 'type', 'default_value', 'directives')
  kind: str = 'variable_definition'
  loc: Location | None
  to_dict(locations: bool = False) → Dict
  type: TypeNode
  variable: VariableNode

class graphql.language.VariableNode(**kwargs: Any)

  Bases: `ValueNode`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name')
  kind: str = 'variable'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

Schema coordinates are represented using the following node classes:

graphql.language.SchemaCoordinateNode

  alias of `TypeCoordinateNode` | `MemberCoordinateNode` | `ArgumentCoordinateNode` | `DirectiveCoordinateNode` | `DirectiveArgumentCoordinateNode`

class graphql.language.TypeCoordinateNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name')
  kind: str = 'type_coordinate'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.MemberCoordinateNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name', 'member_name')
  kind: str = 'member_coordinate'
  loc: Location | None
  member_name: NameNode
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.ArgumentCoordinateNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  argument_name: NameNode
  field_name: NameNode
  keys: Tuple[str, ...] = ('loc', 'name', 'field_name', 'argument_name')
  kind: str = 'argument_coordinate'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.DirectiveCoordinateNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  keys: Tuple[str, ...] = ('loc', 'name')
  kind: str = 'directive_coordinate'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

class graphql.language.DirectiveArgumentCoordinateNode(**kwargs: Any)

  Bases: `Node`

  __init__(**kwargs: Any) → None

    Initialize the node with the given keyword arguments.

  argument_name: NameNode
  keys: Tuple[str, ...] = ('loc', 'name', 'argument_name')
  kind: str = 'directive_argument_coordinate'
  loc: Location | None
  name: NameNode
  to_dict(locations: bool = False) → Dict

Directive locations are specified using the following enumeration:

class graphql.language.DirectiveLocation(*values)

  Bases: `Enum`

  The enum type representing the directive location values.

  ARGUMENT_DEFINITION = 'argument definition'
  DIRECTIVE_DEFINITION = 'directive definition'
  ENUM = 'enum'
  ENUM_VALUE = 'enum value'
  FIELD = 'field'
  FIELD_DEFINITION = 'field definition'
  FRAGMENT_DEFINITION = 'fragment definition'
  FRAGMENT_SPREAD = 'fragment spread'
  INLINE_FRAGMENT = 'inline fragment'
  INPUT_FIELD_DEFINITION = 'input field definition'
  INPUT_OBJECT = 'input object'
  INTERFACE = 'interface'
  MUTATION = 'mutation'
  OBJECT = 'object'
  QUERY = 'query'
  SCALAR = 'scalar'
  SCHEMA = 'schema'
  SUBSCRIPTION = 'subscription'
  UNION = 'union'
  VARIABLE_DEFINITION = 'variable definition'

You can also check the type of nodes with the following predicates:

graphql.language.is_definition_node(node: Node) → bool

  Check whether the given node represents a definition.

graphql.language.is_executable_definition_node(node: Node) → bool

  Check whether the given node represents an executable definition.

graphql.language.is_selection_node(node: Node) → bool

  Check whether the given node represents a selection.

graphql.language.is_value_node(node: Node) → bool

  Check whether the given node represents a value.

graphql.language.is_const_value_node(node: Node) → bool

  Check whether the given node represents a constant value.

graphql.language.is_type_node(node: Node) → bool

  Check whether the given node represents a type.

graphql.language.is_type_system_definition_node(node: Node) → bool

  Check whether the given node represents a type system definition.

graphql.language.is_type_definition_node(node: Node) → bool

  Check whether the given node represents a type definition.

graphql.language.is_type_system_extension_node(node: Node) → bool

  Check whether the given node represents a type system extension.

graphql.language.is_type_extension_node(node: Node) → bool

  Check whether the given node represents a type extension.

graphql.language.is_schema_coordinate_node(node: Node) → bool

  Check whether the given node represents a schema coordinate.

## Lexer

class graphql.language.Lexer(source: Source)

  Bases: `object`

  GraphQL Lexer

  A Lexer is a stateful stream generator in that every time it is advanced, it returns the next token in the Source. Assuming the source lexes, the final Token emitted by the lexer will be of kind EOF, after which the lexer will repeatedly return the same EOF token whenever called.

  __init__(source: Source)

    Given a Source object, initialize a Lexer for that source.

  advance() → Token

    Advance the token stream to the next non-ignored token.

  create_token(kind: TokenKind, start: int, end: int, value: str | None = None) → Token

    Create a token with line and column location information.

  lookahead() → Token

    Look ahead and return the next non-ignored token, but do not change state.

  print_code_point_at(location: int) → str

    Print the code point at the given location.

    Prints the code point (or end of file reference) at a given location in a source for use in error messages.

    Printable ASCII is printed quoted, while other points are printed in Unicode code point form (ie. U+1234).

  read_block_string(start: int) → Token

    Read a block string token from the source file.

  read_comment(start: int) → Token

    Read a comment token from the source file.

  read_digits(start: int, first_char: str) → int

    Return the new position in the source after reading one or more digits.

  read_escaped_character(position: int) → EscapeSequence
  read_escaped_unicode_fixed_width(position: int) → EscapeSequence
  read_escaped_unicode_variable_width(position: int) → EscapeSequence
  read_name(start: int) → Token

    Read an alphanumeric + underscore name from the source.

  read_next_token(start: int) → Token

    Get the next token from the source starting at the given position.

    This skips over whitespace until it finds the next lexable token, then lexes punctuators immediately or calls the appropriate helper function for more complicated tokens.

  read_number(start: int, first_char: str) → Token

    Reads a number token from the source file.

    This can be either a FloatValue or an IntValue, depending on whether a FractionalPart or ExponentPart is encountered.

  read_string(start: int) → Token

    Read a single-quote string token from the source file.

class graphql.language.TokenKind(*values)

  Bases: `Enum`

  The different kinds of tokens that the lexer emits

  AMP = '&'
  AT = '@'
  BANG = '!'
  BLOCK_STRING = 'BlockString'
  BRACE_L = '{'
  BRACE_R = '}'
  BRACKET_L = '['
  BRACKET_R = ']'
  COLON = ':'
  COMMENT = 'Comment'
  DOLLAR = '$'
  DOT = '.'
  EOF = '<EOF>'
  EQUALS = '='
  FLOAT = 'Float'
  INT = 'Int'
  NAME = 'Name'
  PAREN_L = '('
  PAREN_R = ')'
  PIPE = '|'
  SOF = '<SOF>'
  SPREAD = '...'
  STRING = 'String'

class graphql.language.Token(kind: TokenKind, start: int, end: int, line: int, column: int, value: str | None = None)

  Bases: `object`

  AST Token

  Represents a range of characters represented by a lexical token within a Source.

  __init__(kind: TokenKind, start: int, end: int, line: int, column: int, value: str | None = None) → None
  column: int
  property desc: str

    A helper property to describe a token as a string for debugging

  end: int
  kind: TokenKind
  line: int
  next: Token | None
  prev: Token | None
  start: int
  value: str | None

## Location

graphql.language.get_location(source: Source, position: int) → SourceLocation

  Get the line and column for a character position in the source.

  Takes a Source and a UTF-8 character offset, and returns the corresponding line and column as a SourceLocation.

class graphql.language.SourceLocation(line: int, column: int)

  Bases: `NamedTuple`

  Represents a location in a Source.

  __init__()
  column: int

    Alias for field number 1

  count(value, /)

    Return number of occurrences of value.

  property formatted: FormattedSourceLocation
  index(value, start=0, stop=9223372036854775807, /)

    Return first index of value.

    Raises ValueError if the value is not present.

  line: int

    Alias for field number 0

graphql.language.print_location(location: Location) → str

  Render a helpful description of the location in the GraphQL Source document.

class graphql.language.FormattedSourceLocation

  Bases: `TypedDict`

  Formatted source location

  column: int
  line: int

## Parser

graphql.language.parse(source: Source | str, no_location: bool = False, max_tokens: int | None = None, allow_legacy_fragment_variables: bool = False, experimental_directives_on_directive_definitions: bool = False) → DocumentNode

  Given a GraphQL source, parse it into a Document.

  Throws GraphQLError if a syntax error is encountered.

  By default, the parser creates AST nodes that know the location in the source that they correspond to. Setting the `no_location` parameter to False disables that behavior for performance or testing.

  Parser CPU and memory usage is linear to the number of tokens in a document, however in extreme cases it becomes quadratic due to memory exhaustion. Parsing happens before validation, so even invalid queries can burn lots of CPU time and memory. To prevent this, you can set a maximum number of tokens allowed within a document using the `max_tokens` parameter.

  Legacy feature (will be removed in v3.3):

  If `allow_legacy_fragment_variables` is set to `True`, the parser will understand and parse variable definitions contained in a fragment definition. They’ll be represented in the `variable_definitions` field of the `FragmentDefinitionNode`.

  This legacy fragment variable syntax is deprecated. Move variable definitions to operations for spec-compliant documents; if you need variables or arguments scoped to fragments, the more complete experimental fragment-arguments feature in graphql-core 3.3 should be used instead.

  The syntax is identical to normal, query-defined variables. For example:

      fragment A($var: Boolean = false) on T  {
        ...
      }

  Experimental feature:

  If `experimental_directives_on_directive_definitions` is set to `True`, the parser will understand and parse directives on directive definitions. This syntax is not part of the GraphQL specification and may change. For example:

      directive @foo @bar on FIELD

graphql.language.parse_type(source: Source | str, no_location: bool = False, max_tokens: int | None = None, allow_legacy_fragment_variables: bool = False, experimental_directives_on_directive_definitions: bool = False) → TypeNode

  Parse the AST for a given string containing a GraphQL Type.

  Throws GraphQLError if a syntax error is encountered.

  This is useful within tools that operate upon GraphQL Types directly and in isolation of complete GraphQL documents.

  Consider providing the results to the utility function: `value_from_ast()`.

graphql.language.parse_value(source: Source | str, no_location: bool = False, max_tokens: int | None = None, allow_legacy_fragment_variables: bool = False, experimental_directives_on_directive_definitions: bool = False) → ValueNode

  Parse the AST for a given string containing a GraphQL value.

  Throws GraphQLError if a syntax error is encountered.

  This is useful within tools that operate upon GraphQL Values directly and in isolation of complete GraphQL documents.

  Consider providing the results to the utility function: `value_from_ast()`.

graphql.language.parse_const_value(source: Source | str, no_location: bool = False, max_tokens: int | None = None, allow_legacy_fragment_variables: bool = False, experimental_directives_on_directive_definitions: bool = False) → IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode

  Parse the AST for a given string containing a GraphQL constant value.

  Similar to parse_value, but raises a arse error if it encounters a variable. The return type will be a constant value.

graphql.language.parse_schema_coordinate(source: Source | str, no_location: bool = False, max_tokens: int | None = None) → TypeCoordinateNode | MemberCoordinateNode | ArgumentCoordinateNode | DirectiveCoordinateNode | DirectiveArgumentCoordinateNode

  Parse the AST for a given string containing a GraphQL schema coordinate.

  Throws GraphQLError if a syntax error is encountered.

  This is useful within tools that operate upon GraphQL schema coordinates (ex. `Type.field`) directly and in isolation of complete GraphQL documents.

  Consider providing the results to the utility function: `resolve_ast_schema_coordinate()`. Or calling `resolve_schema_coordinate()` directly with an unparsed source.

## Printer

graphql.language.print_ast(ast: Node) → str

  Convert an AST into a string.

  The conversion is done using a set of reasonable formatting rules.

## Source

class graphql.language.Source(body: str, name: str = 'GraphQL request', location_offset: SourceLocation = (1, 1))

  Bases: `object`

  A representation of source input to GraphQL.

  __init__(body: str, name: str = 'GraphQL request', location_offset: SourceLocation = (1, 1)) → None

    Initialize source input.

    The `name` and `location_offset` parameters are optional, but they are useful for clients who store GraphQL documents in source files. For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might be useful for `name` to be `"Foo.graphql"` and location to be `(40, 0)`.

    The `line` and `column` attributes in `location_offset` are 1-indexed.

  body
  get_location(position: int) → SourceLocation
  location_offset
  name

graphql.language.print_source_location(source: Source, source_location: SourceLocation) → str

  Render a helpful description of the location in the GraphQL Source document.

## Visitor

graphql.language.visit(root: Node, visitor: Visitor, visitor_keys: Dict[str, Tuple[str, ...]] | None = None) → Any

  Visit each node in an AST.

  `visit()` will walk through an AST using a depth-first traversal, calling the visitor’s enter methods at each node in the traversal, and calling the leave methods after visiting that node and all of its child nodes.

  By returning different values from the enter and leave methods, the behavior of the visitor can be altered, including skipping over a sub-tree of the AST (by returning False), editing the AST by returning a value or None to remove the value, or to stop the whole traversal by returning `BREAK`.

  When using `visit()` to edit an AST, the original AST will not be modified, and a new version of the AST with the changes applied will be returned from the visit function.

  To customize the node attributes to be used for traversal, you can provide a dictionary visitor_keys mapping node kinds to node attributes.

class graphql.language.Visitor

  Bases: `object`

  Visitor that walks through an AST.

  Visitors can define two generic methods “enter” and “leave”. The former will be called when a node is entered in the traversal, the latter is called after visiting the node and its child nodes. These methods have the following signature:

      def enter(self, node, key, parent, path, ancestors):
          # The return value has the following meaning:
          # IDLE (None): no action
          # SKIP: skip visiting this node
          # BREAK: stop visiting altogether
          # REMOVE: delete this node
          # any other value: replace this node with the returned value
          return

      def leave(self, node, key, parent, path, ancestors):
          # The return value has the following meaning:
          # IDLE (None) or SKIP: no action
          # BREAK: stop visiting altogether
          # REMOVE: delete this node
          # any other value: replace this node with the returned value
          return

  The parameters have the following meaning:

  Parameters:

    - node – The current node being visiting.

    - key – The index or key to this node from the parent node or Array.

    - parent – the parent immediately above this node, which may be an Array.

    - path – The key path to get to this node from the root node.

    - ancestors – All nodes and Arrays visited before reaching parent of this node. These correspond to array indices in `path`. Note: ancestors includes arrays which contain the parent of visited node.

  You can also define node kind specific methods by suffixing them with an underscore followed by the kind of the node to be visited. For instance, to visit `field` nodes, you would defined the methods `enter_field()` and/or `leave_field()`, with the same signature as above. If no kind specific method has been defined for a given node, the generic method is called.

  BREAK = True
  IDLE = None
  REMOVE = Ellipsis
  SKIP = False
  __init__() → None
  enter_leave_map: Dict[str, EnterLeaveVisitor]
  get_enter_leave_for_kind(kind: str) → EnterLeaveVisitor

    Given a node kind, return the EnterLeaveVisitor for that kind.

  get_visit_fn(kind: str, is_leaving: bool = False) → Callable[[...], VisitorActionEnum | None] | None

    Get the visit function for the given node kind and direction.

    This deprecated compatibility helper delegates to `get_enter_leave_for_kind`; call `get_enter_leave_for_kind` directly because `get_visit_fn` will be removed in v3.3.

    Deprecated since version 3.2: Please use `get_enter_leave_for_kind` instead. Will be removed in v3.3.

class graphql.language.ParallelVisitor(visitors: Collection[Visitor])

  Bases: `Visitor`

  A Visitor which delegates to many visitors to run in parallel.

  Each visitor will be visited for each node before moving on.

  If a prior visitor edits a node, no following visitors will see that node.

  BREAK = True
  IDLE = None
  REMOVE = Ellipsis
  SKIP = False
  __init__(visitors: Collection[Visitor])

    Create a new visitor from the given list of parallel visitors.

  enter_leave_map: Dict[str, EnterLeaveVisitor]
  get_enter_leave_for_kind(kind: str) → EnterLeaveVisitor

    Given a node kind, return the EnterLeaveVisitor for that kind.

  get_visit_fn(kind: str, is_leaving: bool = False) → Callable[[...], VisitorActionEnum | None] | None

    Get the visit function for the given node kind and direction.

    This deprecated compatibility helper delegates to `get_enter_leave_for_kind`; call `get_enter_leave_for_kind` directly because `get_visit_fn` will be removed in v3.3.

    Deprecated since version 3.2: Please use `get_enter_leave_for_kind` instead. Will be removed in v3.3.

  skipping: List[Any]

The module also exports the following enumeration that can be used as the return type for `Visitor` methods:

class graphql.language.visitor.VisitorActionEnum(*values)

  Bases: `Enum`

  Special return values for the visitor methods.

  You can also use the values of this enum directly.

  BREAK = True
  REMOVE = Ellipsis
  SKIP = False

The module also exports the values of this enumeration directly. These can be used as return values of `Visitor` methods to signal particular actions:

graphql.language.BREAK (same as ``True``)

  This return value signals that no further nodes shall be visited.

graphql.language.SKIP (same as ``False``)

  This return value signals that the current node shall be skipped.

graphql.language.REMOVE (same as``Ellipsis``)

  This return value signals that the current node shall be deleted.

graphql.language.IDLE = None

  This return value signals that no additional action shall take place.