Reformat with latest black version (20.8b1)

Cito · Cito · commit b668e4785455 · 2021-02-06T17:34:07.000+01:00
diff --git a/pyproject.toml b/pyproject.toml
@@ -38,7 +38,7 @@ pytest-benchmark = "^3.2"
 pytest-cov = "^2.10"
 pytest-describe = "^1.0"
 pytest-timeout = "^1.4"
-black = "19.10b0"
+black = "20.8b1"
 flake8 = "^3.8"
 mypy = "0.782"
 codecov = "^2"
diff --git a/src/graphql/execution/execute.py b/src/graphql/execution/execute.py
@@ -392,7 +392,9 @@ async def await_and_set_result(
             elif is_awaitable(result):
                 # noinspection PyShadowingNames
                 async def set_result(
-                    results: Dict[str, Any], response_name: str, result: Awaitable,
+                    results: Dict[str, Any],
+                    response_name: str,
+                    result: Awaitable,
                 ) -> Dict[str, Any]:
                     results[response_name] = await result
                     return results
diff --git a/src/graphql/type/schema.py b/src/graphql/type/schema.py
@@ -317,7 +317,9 @@ def is_possible_type(
         return self.is_sub_type(abstract_type, possible_type)
 
     def is_sub_type(
-        self, abstract_type: GraphQLAbstractType, maybe_sub_type: GraphQLNamedType,
+        self,
+        abstract_type: GraphQLAbstractType,
+        maybe_sub_type: GraphQLNamedType,
     ) -> bool:
         """Check whether a type is a subtype of a given abstract type."""
         types = self._sub_type_map.get(abstract_type.name)
diff --git a/src/graphql/utilities/type_from_ast.py b/src/graphql/utilities/type_from_ast.py
@@ -40,7 +40,10 @@ def type_from_ast(schema: GraphQLSchema, type_node: TypeNode) -> Optional[GraphQ
     ...
 
 
-def type_from_ast(schema: GraphQLSchema, type_node: TypeNode,) -> Optional[GraphQLType]:
+def type_from_ast(
+    schema: GraphQLSchema,
+    type_node: TypeNode,
+) -> Optional[GraphQLType]:
     """Get the GraphQL type definition from an AST node.
 
     Given a Schema and an AST node describing a type, return a GraphQLType definition
diff --git a/src/graphql/validation/rules/executable_definitions.py b/src/graphql/validation/rules/executable_definitions.py
@@ -40,7 +40,8 @@ def enter_document(self, node: DocumentNode, *_args: Any) -> VisitorAction:
                 )
                 self.report_error(
                     GraphQLError(
-                        f"The {def_name} definition is not executable.", definition,
+                        f"The {def_name} definition is not executable.",
+                        definition,
                     )
                 )
         return SKIP
diff --git a/src/graphql/validation/rules/possible_type_extensions.py b/src/graphql/validation/rules/possible_type_extensions.py
@@ -21,7 +21,7 @@
 class PossibleTypeExtensionsRule(SDLValidationRule):
     """Possible type extension
 
-     A type extension is only valid if the type is defined and has the same kind.
+    A type extension is only valid if the type is defined and has the same kind.
     """
 
     def __init__(self, context: SDLValidationContext):
diff --git a/tests/execution/test_executor.py b/tests/execution/test_executor.py
@@ -668,7 +668,10 @@ def errors_if_empty_string_is_provided_as_operation_name():
         document = parse("{ a }")
 
         result = execute(schema, document, operation_name="")
-        assert result == (None, [{"message": "Unknown operation named ''."}],)
+        assert result == (
+            None,
+            [{"message": "Unknown operation named ''."}],
+        )
 
     def uses_the_query_schema_for_queries():
         schema = GraphQLSchema(
diff --git a/tests/execution/test_middleware.py b/tests/execution/test_middleware.py
@@ -157,14 +157,20 @@ def skip_middleware_without_resolve_method():
             class BadMiddleware:
                 pass  # no resolve method here
 
-            assert execute(
-                GraphQLSchema(
-                    GraphQLObjectType("TestType", {"foo": GraphQLField(GraphQLString)},)
-                ),
-                parse("{ foo }"),
-                {"foo": "bar"},
-                middleware=MiddlewareManager(BadMiddleware()),
-            ) == ({"foo": "bar"}, None)
+            assert (
+                execute(
+                    GraphQLSchema(
+                        GraphQLObjectType(
+                            "TestType",
+                            {"foo": GraphQLField(GraphQLString)},
+                        )
+                    ),
+                    parse("{ foo }"),
+                    {"foo": "bar"},
+                    middleware=MiddlewareManager(BadMiddleware()),
+                )
+                == ({"foo": "bar"}, None)
+            )
 
         def with_function_and_object():
             doc = parse("{ field }")
diff --git a/tests/execution/test_resolve.py b/tests/execution/test_resolve.py
@@ -29,26 +29,35 @@ class RootValue:
             schema=_test_schema(GraphQLField(GraphQLString)),
             source="{ test }",
             root_value=RootValue(),
-        ) == ({"test": "testValue"}, None,)
+        ) == (
+            {"test": "testValue"},
+            None,
+        )
 
     def default_function_accesses_keys_of_dict():
         root_value = {"test": "testValue"}
 
-        assert graphql_sync(
-            schema=_test_schema(GraphQLField(GraphQLString)),
-            source="{ test }",
-            root_value=root_value,
-        ) == ({"test": "testValue"}, None)
+        assert (
+            graphql_sync(
+                schema=_test_schema(GraphQLField(GraphQLString)),
+                source="{ test }",
+                root_value=root_value,
+            )
+            == ({"test": "testValue"}, None)
+        )
 
     def default_function_accesses_keys_of_chain_map():
         # use a mapping that is not a subclass of dict
         root_value = ChainMap({"test": "testValue"})
 
-        assert graphql_sync(
-            schema=_test_schema(GraphQLField(GraphQLString)),
-            source="{ test }",
-            root_value=root_value,
-        ) == ({"test": "testValue"}, None)
+        assert (
+            graphql_sync(
+                schema=_test_schema(GraphQLField(GraphQLString)),
+                source="{ test }",
+                root_value=root_value,
+            )
+            == ({"test": "testValue"}, None)
+        )
 
     def default_function_calls_methods():
         class RootValue:
@@ -61,7 +70,10 @@ def test(self, _info):
             schema=_test_schema(GraphQLField(GraphQLString)),
             source="{ test }",
             root_value=RootValue(),
-        ) == ({"test": "secretValue"}, None,)
+        ) == (
+            {"test": "secretValue"},
+            None,
+        )
 
     def default_function_passes_args_and_context():
         class Adder:
@@ -90,7 +102,10 @@ class ContextValue:
             source=source,
             root_value=root_value,
             context_value=context_value,
-        ) == ({"test": 789}, None,)
+        ) == (
+            {"test": 789},
+            None,
+        )
 
     def uses_provided_resolve_function():
         schema = _test_schema(
@@ -114,7 +129,10 @@ def execute(source, root_value=None, context_value=None):
 
         assert execute("{ test }") == ({"test": "[None, {}]"}, None)
 
-        assert execute("{ test }", "Source!") == ({"test": "['Source!', {}]"}, None,)
+        assert execute("{ test }", "Source!") == (
+            {"test": "['Source!', {}]"},
+            None,
+        )
 
         assert execute('{ test(aStr: "String!") }', "Source!") == (
             {"test": "['Source!', {'aStr': 'String!'}]"},
@@ -144,7 +162,10 @@ def execute(source: str, root_value: Optional[Any] = None) -> ExecutionResult:
 
         assert execute("{ test }") == ({"test": "[None, {}]"}, None)
 
-        assert execute("{ test }", "Source!") == ({"test": "['Source!', {}]"}, None,)
+        assert execute("{ test }", "Source!") == (
+            {"test": "['Source!', {}]"},
+            None,
+        )
 
         assert execute('{ test(aStr: "String!") }', "Source!") == (
             {"test": "['Source!', {'a_str': 'String!'}]"},
@@ -177,7 +198,11 @@ def transforms_arguments_with_inputs_using_out_names():
         )
 
         def execute(source, root_value=None):
-            return graphql_sync(schema=schema, source=source, root_value=root_value,)
+            return graphql_sync(
+                schema=schema,
+                source=source,
+                root_value=root_value,
+            )
 
         assert execute("{ test }") == ({"test": "[None, {}]"}, None)
 
diff --git a/tests/execution/test_union_interface.py b/tests/execution/test_union_interface.py
@@ -518,7 +518,10 @@ def resolve_type(_source, info, _type):
             document=document,
             root_value=root_value,
             context_value=context_value,
-        ) == ({"name": "John", "friends": [{"name": "Liz"}]}, None,)
+        ) == (
+            {"name": "John", "friends": [{"name": "Liz"}]},
+            None,
+        )
 
         assert encountered == {
             "schema": schema2,
diff --git a/tests/language/test_lexer.py b/tests/language/test_lexer.py
@@ -356,13 +356,17 @@ def lex_does_not_allow_name_start_after_a_number():
             "1_1234", "Invalid number, expected digit but got: '_'.", (1, 2)
         )
         assert_syntax_error(
-            "1ß", "Cannot parse the unexpected character 'ß'.", (1, 2),
+            "1ß",
+            "Cannot parse the unexpected character 'ß'.",
+            (1, 2),
         )
         assert_syntax_error(
             "1.23f", "Invalid number, expected digit but got: 'f'.", (1, 5)
         )
         assert_syntax_error(
-            "12ß", "Cannot parse the unexpected character 'ß'.", (1, 3),
+            "12ß",
+            "Cannot parse the unexpected character 'ß'.",
+            (1, 3),
         )
 
     # noinspection PyArgumentEqualDefault
diff --git a/tests/subscription/test_subscribe.py b/tests/subscription/test_subscribe.py
@@ -459,7 +459,9 @@ async def resolves_to_an_error_if_variables_were_wrong_type():
         )
 
         result = await subscribe(
-            schema=email_schema, document=ast, variable_values={"priority": "meow"},
+            schema=email_schema,
+            document=ast,
+            variable_values={"priority": "meow"},
         )
 
         assert result == (
diff --git a/tests/type/test_definition.py b/tests/type/test_definition.py
@@ -1552,17 +1552,14 @@ def resolve():
                     "SomeInputObject",
                     {
                         "f": GraphQLInputField(  # type: ignore
-                            ScalarType, resolve=resolve,
+                            ScalarType,
+                            resolve=resolve,
                         )
                     },
                 )
             input_obj_type = GraphQLInputObjectType(
                 "SomeInputObject",
-                {
-                    "f": GraphQLField(  # type: ignore
-                        ScalarType, resolve=resolve
-                    )
-                },
+                {"f": GraphQLField(ScalarType, resolve=resolve)},  # type: ignore
             )
             with raises(TypeError) as exc_info:
                 if input_obj_type.fields:
diff --git a/tests/type/test_schema.py b/tests/type/test_schema.py
@@ -95,7 +95,10 @@ def define_sample_schema():
         )
 
         schema = GraphQLSchema(
-            BlogQuery, BlogMutation, BlogSubscription, description="Sample schema",
+            BlogQuery,
+            BlogMutation,
+            BlogSubscription,
+            description="Sample schema",
         )
 
         kwargs = schema.to_kwargs()
@@ -199,7 +202,9 @@ def includes_interfaces_thunk_subtypes_in_the_type_map():
             SomeSubtype = GraphQLObjectType(
                 "SomeSubtype", {}, interfaces=lambda: [SomeInterface]
             )
-            schema = GraphQLSchema(types=[SomeSubtype],)
+            schema = GraphQLSchema(
+                types=[SomeSubtype],
+            )
             assert schema.type_map["SomeInterface"] is SomeInterface
             assert schema.type_map["AnotherInterface"] is AnotherInterface
             assert schema.type_map["SomeSubtype"] is SomeSubtype
diff --git a/tests/type/test_validation.py b/tests/type/test_validation.py
@@ -1338,7 +1338,9 @@ def _schema_with_interface_field_of_type(field_type: GraphQLOutputType):
             field.type = field_type
         bad_interface_type = GraphQLInterfaceType("BadInterface", {"badField": field})
         bad_implementing_type = GraphQLObjectType(
-            "BadImplementing", {"badField": field}, interfaces=[bad_interface_type],
+            "BadImplementing",
+            {"badField": field},
+            interfaces=[bad_interface_type],
         )
         return GraphQLSchema(
             GraphQLObjectType("Query", {"f": GraphQLField(bad_interface_type)}),
@@ -1493,7 +1495,9 @@ def _schema_with_arg_of_type(arg_type: GraphQLInputType):
             GraphQLObjectType("Query", {"f": GraphQLField(bad_object_type)}),
             directives=[
                 GraphQLDirective(
-                    "BadDirective", [DirectiveLocation.QUERY], {"badArg": argument},
+                    "BadDirective",
+                    [DirectiveLocation.QUERY],
+                    {"badArg": argument},
                 )
             ],
         )
diff --git a/tests/utilities/test_ast_from_value.py b/tests/utilities/test_ast_from_value.py
@@ -130,7 +130,8 @@ def converts_id_values_to_int_or_string_asts():
 
     def converts_using_serialize_from_a_custom_scalar_type():
         pass_through_scalar = GraphQLScalarType(
-            "PassThroughScalar", serialize=lambda value: value,
+            "PassThroughScalar",
+            serialize=lambda value: value,
         )
 
         assert ast_from_value("value", pass_through_scalar) == StringValueNode(
@@ -146,7 +147,8 @@ def converts_using_serialize_from_a_custom_scalar_type():
         assert str(exc_info.value) == "Cannot convert value to AST: inf."
 
         return_null_scalar = GraphQLScalarType(
-            "ReturnNullScalar", serialize=lambda value: None,
+            "ReturnNullScalar",
+            serialize=lambda value: None,
         )
 
         assert ast_from_value("value", return_null_scalar) is None
@@ -155,7 +157,8 @@ class SomeClass:
             pass
 
         return_custom_class_scalar = GraphQLScalarType(
-            "ReturnCustomClassScalar", serialize=lambda value: SomeClass(),
+            "ReturnCustomClassScalar",
+            serialize=lambda value: SomeClass(),
         )
 
         with raises(TypeError) as exc_info:
diff --git a/tests/utilities/test_coerce_input_value.py b/tests/utilities/test_coerce_input_value.py
@@ -168,14 +168,26 @@ def returns_an_error_for_a_non_dict_value():
         def returns_an_error_for_an_invalid_field():
             result = _coerce_value({"foo": nan}, TestInputObject)
             assert expect_errors(result) == [
-                ("Int cannot represent non-integer value: nan", ["foo"], nan,)
+                (
+                    "Int cannot represent non-integer value: nan",
+                    ["foo"],
+                    nan,
+                )
             ]
 
         def returns_multiple_errors_for_multiple_invalid_fields():
             result = _coerce_value({"foo": "abc", "bar": "def"}, TestInputObject)
             assert expect_errors(result) == [
-                ("Int cannot represent non-integer value: 'abc'", ["foo"], "abc",),
-                ("Int cannot represent non-integer value: 'def'", ["bar"], "def",),
+                (
+                    "Int cannot represent non-integer value: 'abc'",
+                    ["foo"],
+                    "abc",
+                ),
+                (
+                    "Int cannot represent non-integer value: 'def'",
+                    ["bar"],
+                    "def",
+                ),
             ]
 
         def returns_error_for_a_missing_required_field():
@@ -275,8 +287,16 @@ def returns_no_error_for_a_valid_input():
         def returns_an_error_for_an_invalid_input():
             result = _coerce_value([1, "b", True, 4], TestList)
             assert expect_errors(result) == [
-                ("Int cannot represent non-integer value: 'b'", [1], "b",),
-                ("Int cannot represent non-integer value: True", [2], True,),
+                (
+                    "Int cannot represent non-integer value: 'b'",
+                    [1],
+                    "b",
+                ),
+                (
+                    "Int cannot represent non-integer value: True",
+                    [2],
+                    True,
+                ),
             ]
 
         def returns_a_list_for_a_non_list_value():
diff --git a/tests/utilities/test_extend_schema.py b/tests/utilities/test_extend_schema.py
diff --git a/tests/utilities/test_type_comparators.py b/tests/utilities/test_type_comparators.py
diff --git a/tox.ini b/tox.ini

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,8 @@ def enter_document(self, node: DocumentNode, *_args: Any) -> VisitorAction:`
`40`	`40`	`)`
`41`	`41`	`self.report_error(`
`42`	`42`	`GraphQLError(`
`43`		`- f"The {def_name} definition is not executable.", definition,`
	`43`	`+ f"The {def_name} definition is not executable.",`
	`44`	`+ definition,`
`44`	`45`	`)`
`45`	`46`	`)`
`46`	`47`	`return SKIP`