fix too long lines in docstrings

Signed-off-by: oleg.hoefling <oleg.hoefling@gmail.com>

Author: hoefling

src/graphql/execution/execute.py

@@ -678,7 +678,8 @@ def complete_value(
         inner type on each item in the list.
 
         If the field type is a Scalar or Enum, ensures the completed value is a legal
-        value of the type by calling the ``serialize`` method of GraphQL type definition.
+        value of the type by calling the ``serialize`` method of GraphQL type
+        definition.
 
         If the field is an abstract type, determine the runtime type of the value and
         then complete based on that type.
@@ -1120,8 +1121,9 @@ def default_type_resolver(
     First, See if the provided value has a ``__typename`` field defined, if so, use that
     value as name of the resolved type.
 
-    Otherwise, test each possible type for the abstract type by calling :meth:`~graphql.type.GraphQLObjectType.is_type_of`
-    for the object being coerced, returning the first type that matches.
+    Otherwise, test each possible type for the abstract type by calling
+    :meth:`~graphql.type.GraphQLObjectType.is_type_of` for the object
+    being coerced, returning the first type that matches.
     """
     # First, look for `__typename`.
     type_name = get_typename(value)

src/graphql/graphql.py

@@ -65,7 +65,8 @@ async def graphql(
     :arg type_resolver:
       A type resolver function to use when none is provided by the schema.
       If not provided, the default type resolver is used (which looks for a
-      ``__typename`` field or alternatively calls the :meth:`~graphql.type.GraphQLObjectType.is_type_of` method).
+      ``__typename`` field or alternatively calls the
+      :meth:`~graphql.type.GraphQLObjectType.is_type_of` method).
     :arg middleware:
       The middleware to wrap the resolvers with
     :arg execution_context_class:

src/graphql/language/parser.py

@@ -77,14 +77,16 @@ def parse(
     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. The ``no_location`` option disables that behavior for performance
-    or testing.
+    they correspond to. The ``no_location`` option disables that behavior for
+    performance or testing.
 
     Experimental features:
 
-    If ``experimental_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 :attr:`~graphql.language.FragmentDefinitionNode.variable_definitions` field of the :class:`~graphql.language.FragmentDefinitionNode`.
+    If ``experimental_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
+    :attr:`~graphql.language.FragmentDefinitionNode.variable_definitions` field
+    of the :class:`~graphql.language.FragmentDefinitionNode`.
 
     The syntax is identical to normal, query-defined variables. For example::
 
@@ -110,7 +112,8 @@ def parse_value(
     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: :func:`~graphql.value_from_ast`.
+    Consider providing the results to the utility function:
+    :func:`~graphql.value_from_ast`.
     """
     parser = Parser(
         source,
@@ -133,7 +136,8 @@ def parse_type(
     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: :func:`~graphql.value_from_ast`.
+    Consider providing the results to the utility function:
+    :func:`~graphql.value_from_ast`.
     """
     parser = Parser(
         source,
@@ -1044,7 +1048,8 @@ def any(
 
         Returns a possibly empty list of parse nodes, determined by the ``parse_fn``.
         This list begins with a lex token of ``open_kind`` and ends with a lex token of
-        ``close_kind``. Advances the parser to the next lex token after the closing token.
+        ``close_kind``. Advances the parser to the next lex token after the closing
+        token.
         """
         self.expect_token(open_kind)
         nodes: List[T] = []
@@ -1061,7 +1066,8 @@ def optional_many(
         Returns a list of parse nodes, determined by the ``parse_fn``. It can be empty
         only if the open token is missing, otherwise it will always return a non-empty
         list that begins with a lex token of ``open_kind`` and ends with a lex token of
-        ``close_kind``. Advances the parser to the next lex token after the closing token.
+        ``close_kind``. Advances the parser to the next lex token after the closing
+        token.
         """
         if self.expect_optional_token(open_kind):
             nodes = [parse_fn()]
@@ -1078,7 +1084,8 @@ def many(
 
         Returns a non-empty list of parse nodes, determined by the ``parse_fn``.
         This list begins with a lex token of ``open_kind`` and ends with a lex token of
-        ``close_kind``. Advances the parser to the next lex token after the closing token.
+        ``close_kind``. Advances the parser to the next lex token after the closing
+        token.
         """
         self.expect_token(open_kind)
         nodes = [parse_fn()]

src/graphql/language/visitor.py

@@ -147,9 +147,9 @@ def enter(self, node, key, parent, path, ancestors):
 
     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.
+    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.
     """
 
     # Provide special return values as attributes
@@ -209,9 +209,9 @@ def visit(root: Node, visitor: Visitor, visitor_keys=None) -> Any:
     False), editing the AST by returning a value or None to remove the value, or to stop
     the whole traversal by returning :data:`~.BREAK`.
 
-    When using :func:`~.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.
+    When using :func:`~.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.

src/graphql/subscription/subscribe.py

@@ -75,11 +75,11 @@ async def map_source_to_response(payload) -> ExecutionResult:
         """Map source to response.
 
         For each payload yielded from a subscription, map it over the normal GraphQL
-        :func:`~graphql.execute` function, with ``payload`` as the ``root_value``. This implements the
-        "MapSourceToResponseEvent" algorithm described in the GraphQL specification.
-        The :func:`~graphql.execute` function provides the "ExecuteSubscriptionEvent" algorithm,
-        as it is nearly identical to the "ExecuteQuery" algorithm, for which :func:`~graphql.execute`
-        is also used.
+        :func:`~graphql.execute` function, with ``payload`` as the ``root_value``.
+        This implements the "MapSourceToResponseEvent" algorithm described in the
+        GraphQL specification. The :func:`~graphql.execute` function provides the
+        "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
+        "ExecuteQuery" algorithm, for which :func:`~graphql.execute` is also used.
         """
         result = execute(
             schema,

src/graphql/utilities/build_ast_schema.py

@@ -36,9 +36,9 @@ def build_ast_schema(
     resolve methods, so execution will use default resolvers.
 
     When building a schema from a GraphQL service's introspection result, it might
-    be safe to assume the schema is valid. Set ``assume_valid`` to ``True`` to assume the
-    produced schema is valid. Set ``assume_valid_sdl`` to ``True`` to assume it is already
-    a valid SDL document.
+    be safe to assume the schema is valid. Set ``assume_valid`` to ``True`` to assume
+    the produced schema is valid. Set ``assume_valid_sdl`` to ``True`` to assume it is
+    already a valid SDL document.
     """
     if not isinstance(document_ast, DocumentNode):
         raise TypeError("Must provide valid Document AST.")

src/graphql/utilities/extend_schema.py

@@ -108,8 +108,9 @@ def extend_schema(
     copy. The original schema remains unaltered.
 
     When extending a schema with a known valid extension, it might be safe to assume the
-    schema is valid. Set ``assume_valid`` to ``True`` to assume the produced schema is valid.
-    Set ``assume_valid_sdl`` to ``True`` to assume it is already a valid SDL document.
+    schema is valid. Set ``assume_valid`` to ``True`` to assume the produced schema is
+    valid. Set ``assume_valid_sdl`` to ``True`` to assume it is already a valid SDL
+    document.
     """
     assert_schema(schema)
 

src/graphql/utilities/type_info.py

@@ -56,7 +56,8 @@ class TypeInfo:
 
     TypeInfo is a utility class which, given a GraphQL schema, can keep track of the
     current field and type definitions at any point in a GraphQL document AST during
-    a recursive descent by calling :meth:`enter(node) <.TypeInfo.enter>` and :meth:`leave(node) <.TypeInfo.leave>`.
+    a recursive descent by calling :meth:`enter(node) <.TypeInfo.enter>` and
+    :meth:`leave(node) <.TypeInfo.leave>`.
     """
 
     def __init__(
@@ -262,9 +263,9 @@ def get_field_def(
 ) -> Optional[GraphQLField]:
     """Get field definition.
 
-    Not exactly the same as the executor's definition of :func:`graphql.execution.get_field_def`, in this
-    statically evaluated environment we do not always have an Object type, and need
-    to handle Interface and Union types.
+    Not exactly the same as the executor's definition of
+    :func:`graphql.execution.get_field_def`, in this statically evaluated environment
+    we do not always have an Object type, and need to handle Interface and Union types.
     """
     name = field_node.name.value
     if name == "__schema" and schema.query_type is parent_type:

src/graphql/utilities/value_from_ast_untyped.py

@@ -12,8 +12,8 @@ def value_from_ast_untyped(
 ) -> Any:
     """Produce a Python value given a GraphQL Value AST.
 
-    Unlike :func:`~graphql.value_from_ast`, no type is provided. The resulting Python value will
-    reflect the provided GraphQL value AST.
+    Unlike :func:`~graphql.value_from_ast`, no type is provided.
+    The resulting Python value will reflect the provided GraphQL value AST.
 
     =================== ============== ================
        GraphQL Value      JSON Value     Python Value

src/graphql/validation/rules/overlapping_fields_can_be_merged.py

@@ -197,7 +197,7 @@ def find_conflicts_within_selection_set(
             # selection set to collect conflicts within fragments spread together.
             # This compares each item in the list of fragment names to every other
             # item in that same list (except for itself).
-            for other_fragment_name in fragment_names[i + 1:]:
+            for other_fragment_name in fragment_names[i + 1 :]:
                 collect_conflicts_between_fragments(
                     context,
                     conflicts,
@@ -440,7 +440,7 @@ def collect_conflicts_within(
         # compared.
         if len(fields) > 1:
             for i, field in enumerate(fields):
-                for other_field in fields[i + 1:]:
+                for other_field in fields[i + 1 :]:
                     conflict = find_conflict(
                         context,
                         cached_fields_and_fragment_names,
@@ -466,10 +466,10 @@ def collect_conflicts_between(
 ) -> None:
     """Collect all Conflicts between two collections of fields.
 
-    This is similar to, but different from the :func:`~.collect_conflicts_within` function above.
-    This check assumes that :func:`~.collect_conflicts_within` has already been called on each
-    provided collection of fields. This is true because this validator traverses each
-    individual selection set.
+    This is similar to, but different from the :func:`~.collect_conflicts_within`
+    function above. This check assumes that :func:`~.collect_conflicts_within` has
+    already been called on each provided collection of fields. This is true because
+    this validator traverses each individual selection set.
     """
     # A field map is a keyed collection, where each key represents a response name and
     # the value at that key is a list of all fields which provide that response name.