# Source code for graphql.execution.base

    # We keep the following imports to preserve compatibility
    from .utils import (
        ExecutionContext,
        SubscriberExecutionContext,
        get_operation_root_type,
        collect_fields,
        should_include_node,
        does_fragment_condition_match,
        get_field_entry_key,
        default_resolve_fn,
        get_field_def,
    )
    from ..pyutils.ordereddict import OrderedDict
    from ..error.format_error import format_error as default_format_error

    # Necessary for static type checking
    if False:  # flake8: noqa
        from typing import Any, Optional, Dict, List, Union, Callable, Type
        from ..language.ast import Field, OperationDefinition
        from ..type.definition import GraphQLList, GraphQLObjectType, GraphQLScalarType
        from ..type.schema import GraphQLSchema

    class ExecutionResult(object):
        """The result of execution. `data` is the result of executing the
        query, `errors` is null if no errors occurred, and is a
        non-empty array if an error occurred."""

        __slots__ = "data", "errors", "invalid", "extensions"

        def __init__(self, data=None, errors=None, invalid=False, extensions=None):
            # type: (Optional[Dict], Optional[List[Exception]], bool, Optional[Any]) -> None
            self.data = data
            self.errors = errors
            self.extensions = extensions or dict()

            if invalid:
                assert data is None

            self.invalid = invalid

        def __eq__(self, other):
            # type: (Any) -> bool
            return self is other or (
                isinstance(other, ExecutionResult)
                and self.data == other.data
                and self.errors == other.errors
                and self.invalid == other.invalid
            )

        def __str__(self):
            return str(self.to_dict())

        def to_dict(self, format_error=None, dict_class=OrderedDict):
            # type: (Optional[Callable[[Exception], Dict]], Type[Dict]) -> Dict[str, Any]
            if format_error is None:
                format_error = default_format_error

            response = dict_class()
            if self.errors:
                response["errors"] = [format_error(e) for e in self.errors]

            if not self.invalid:
                response["data"] = self.data

            return response

    class ResolveInfo(object):
        __slots__ = (
            "field_name",
            "field_asts",
            "return_type",
            "parent_type",
            "schema",
            "fragments",
            "root_value",
            "operation",
            "variable_values",
            "context",
            "path",
        )

        def __init__(
            self,
            field_name,  # type: str
            field_asts,  # type: List[Field]
            return_type,  # type: Union[GraphQLList, GraphQLObjectType, GraphQLScalarType]
            parent_type,  # type: GraphQLObjectType
            schema,  # type: GraphQLSchema
            fragments,  # type: Dict
            root_value,  # type: Optional[type]
            operation,  # type: OperationDefinition
            variable_values,  # type: Dict
            context,  # type: Optional[Any]
            path=None,  # type: Union[List[Union[int, str]], List[str]]
        ):
            # type: (...) -> None
            self.field_name = field_name
            self.field_asts = field_asts
            self.return_type = return_type
            self.parent_type = parent_type
            self.schema = schema
            self.fragments = fragments
            self.root_value = root_value
            self.operation = operation
            self.variable_values = variable_values
            self.context = context
            self.path = path

    __all__ = [
        "ExecutionResult",
        "ResolveInfo",
        "ExecutionContext",
        "SubscriberExecutionContext",
        "get_operation_root_type",
        "collect_fields",
        "should_include_node",
        "does_fragment_condition_match",
        "get_field_entry_key",
        "default_resolve_fn",
        "get_field_def",
    ]