style: adjust styles to pass hatch run check

Author: KarolJagodzinski

.git-blame-ignore-revs

@@ -14,7 +14,7 @@
 )
 from .graphql import graphql, graphql_sync, subscribe
 from .inputs import InputType
-from .interfaces import InterfaceType, type_implements_interface
+from .interfaces import InterfaceType
 from .load_schema import load_schema_from_path
 from .objects import MutationType, ObjectType, QueryType
 from .resolvers import (
@@ -35,6 +35,7 @@
     convert_camel_case_to_snake,
     convert_kwargs_to_snake_case,
     gql,
+    type_implements_interface,
     unwrap_graphql_error,
 )
 

ariadne/__init__.py

@@ -525,7 +525,7 @@ async def observe_async_results(
                     }
                 )
         except asyncio.CancelledError:  # pylint: disable=W0706
-            # if asyncio Task is cancelled then CancelledError 
+            # if asyncio Task is cancelled then CancelledError
             # is thrown in the coroutine
             raise
         except Exception as error:

ariadne/asgi/handlers/graphql_transport_ws.py

@@ -30,7 +30,7 @@
 from .. import format_error
 from ..asgi.handlers import GraphQLHTTPHandler
 from ..exceptions import HttpError
-from ..graphql import (
+from ..graphql import (  # type: ignore[attr-defined]
     ExecutionResult,
     GraphQLError,
     parse_query,

ariadne/contrib/sse.py

@@ -90,19 +90,15 @@ def inverse_files_map(files_map: dict, files: FilesDict) -> dict:
     for field_name, paths in files_map.items():
         if not isinstance(paths, list):
             raise HttpBadRequestError(
-                
-                    "Invalid type for the 'map' multipart field entry "
-                    f"key '{field_name}' array ({SPEC_URL})."
-                
+                "Invalid type for the 'map' multipart field entry "
+                f"key '{field_name}' array ({SPEC_URL})."
             )
 
         for i, path in enumerate(paths):
             if not isinstance(path, str):
                 raise HttpBadRequestError(
-                    
-                        "Invalid type for the 'map' multipart field entry key "
-                        f"'{field_name}' array index '{i}' value ({SPEC_URL})."
-                    
+                    "Invalid type for the 'map' multipart field entry key "
+                    f"'{field_name}' array index '{i}' value ({SPEC_URL})."
                 )
 
             try:

ariadne/file_uploads.py

@@ -107,7 +107,8 @@ async def graphql(
     with two arguments: `context_value`, and `data` dict.
 
     `query_validator`: a `QueryValidator` to use instead of default one. Is called
-    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors' and 'type_info'.
+    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors'
+    and 'type_info'.
 
     `query_document`: an already parsed GraphQL query. Setting this option will
     prevent `graphql` from parsing `query` string from `data` second time.
@@ -298,7 +299,8 @@ def graphql_sync(
     with two arguments: `context_value`, and `data` dict.
 
     `query_validator`: a `QueryValidator` to use instead of default one. Is called
-    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors' and 'type_info'.
+    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors'
+    and 'type_info'.
 
     `query_document`: an already parsed GraphQL query. Setting this option will
     prevent `graphql_sync` from parsing `query` string from `data` second time.
@@ -466,7 +468,7 @@ async def subscribe(
 
     Returns a tuple with two items:
 
-    `bool`: `True` when no errors occurred, `False` otherwise.
+    `bool`: `True` when no errors occurred, `False` otherwise.f
 
     `AsyncGenerator`: an async generator that server implementation should
     consume to retrieve messages to send to client.
@@ -490,7 +492,8 @@ async def subscribe(
     with two arguments: `context_value`, and `data` dict.
 
     `query_validator`: a `QueryValidator` to use instead of default one. Is called
-    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors' and 'type_info'.
+    with five arguments: `schema`, 'document_ast', 'rules', 'max_errors'
+    and 'type_info'.
 
     `query_document`: an already parsed GraphQL query. Setting this option will
     prevent `subscribe` from parsing `query` string from `data` second time.

ariadne/graphql.py

@@ -195,5 +195,7 @@ def validate_graphql_type(self, graphql_type: Optional[GraphQLNamedType]) -> Non
             raise ValueError(f"Type {self.name} is not defined in the schema")
         if not isinstance(graphql_type, GraphQLInputObjectType):
             raise ValueError(
-                f"{self.name} is defined in the schema, but it is instance of {type(graphql_type).__name__} (expected {GraphQLInputObjectType.__name__})"
+                f"{self.name} is defined in the schema, "
+                f"but it is instance of {type(graphql_type).__name__} "
+                f"(expected {GraphQLInputObjectType.__name__})"
             )

ariadne/inputs.py

@@ -167,9 +167,9 @@ def set_type_resolver(self, type_resolver: Resolver) -> Resolver:
         ```python
         interface_type = InterfaceType("MyInterface")
 
+
         @interface_type.type_resolver
-        def type_resolver(obj: Any, *_) -> str:
-            ...
+        def type_resolver(obj: Any, *_) -> str: ...
         ```
         """
         self._resolve_type = type_resolver

ariadne/interfaces.py

@@ -165,7 +165,8 @@ def __init__(self, name: str) -> None:
         self._resolvers = {}
 
     def field(self, name: str) -> Callable[[Resolver], Resolver]:
-        """Return a decorator that sets decorated function as a resolver for named field.
+        """Return a decorator that sets decorated
+        function as a resolver for named field.
 
         Wrapper for `create_register_resolver` that on runtime validates `name` to be a
         string.
@@ -182,7 +183,8 @@ def field(self, name: str) -> Callable[[Resolver], Resolver]:
         return self.create_register_resolver(name)
 
     def create_register_resolver(self, name: str) -> Callable[[Resolver], Resolver]:
-        """Return a decorator that sets decorated function as a resolver for named field.
+        """Return a decorator that sets decorated function
+        as a resolver for named field.
 
         # Required arguments
 
@@ -240,16 +242,16 @@ def validate_graphql_type(self, graphql_type: Optional[GraphQLNamedType]) -> Non
             raise ValueError(f"Type {self.name} is not defined in the schema")
         if not isinstance(graphql_type, GraphQLObjectType):
             raise ValueError(
-                f"{self.name} is defined in the schema, but it is instance of {type(graphql_type).__name__} (expected {GraphQLObjectType.__name__})"
+                f"{self.name} is defined in the schema, "
+                f"but it is instance of {type(graphql_type).__name__} "
+                f"(expected {GraphQLObjectType.__name__})"
             )
 
     def bind_resolvers_to_graphql_type(self, graphql_type, replace_existing=True):
         """Binds this `ObjectType` instance to the instance of GraphQL schema."""
         for field, resolver in self._resolvers.items():
             if field not in graphql_type.fields:
-                raise ValueError(
-                    f"Field {field} is not defined on type {self.name}"
-                )
+                raise ValueError(f"Field {field} is not defined on type {self.name}")
             if graphql_type.fields[field].resolve is None or replace_existing:
                 graphql_type.fields[field].resolve = resolver
 

ariadne/objects.py

@@ -49,9 +49,7 @@ def parse_date_str(value: str) -> date:
             # Parse "YYYY-MM-DD" string into date
             return datetime.strptime(value, "%Y-%m-%d").date()
         except (ValueError, TypeError):
-            raise ValueError(
-                f'"{value}" is not a date string in YYYY-MM-DD format.'
-            )
+            raise ValueError(f'"{value}" is not a date string in YYYY-MM-DD format.')
     ```
 
     # Literal parsing
@@ -63,19 +61,15 @@ def parse_date_str(value: str) -> date:
     query's variables and returns Python value:
 
     ```python
-    def parse_date_literal(
-        value: str, variable_values: dict[str, Any] = None
-    ) -> date:
+    def parse_date_literal(value: str, variable_values: dict[str, Any] = None) -> date:
         if not isinstance(ast, StringValueNode):
             raise ValueError()
 
         try:
             # Parse "YYYY-MM-DD" string into date
             return datetime.strptime(ast.value, "%Y-%m-%d").date()
         except (ValueError, TypeError):
-            raise ValueError(
-                f'"{value}" is not a date string in YYYY-MM-DD format.'
-            )
+            raise ValueError(f'"{value}" is not a date string in YYYY-MM-DD format.')
     ```
 
     When scalar has custom value parser set, but not the literal parser, the
@@ -225,6 +219,7 @@ def set_serializer(self, f: GraphQLScalarSerializer) -> GraphQLScalarSerializer:
         ```python
         date_scalar = ScalarType("Date")
 
+
         @date_scalar.serializer
         def serialize_date(value: date) -> str:
             # Serialize dates as "YYYY-MM-DD" string
@@ -242,15 +237,14 @@ def set_value_parser(self, f: GraphQLScalarValueParser) -> GraphQLScalarValuePar
         ```python
         date_scalar = ScalarType("Date")
 
+
         @date_scalar.value_parser
         def parse_date_str(value: str) -> date:
             try:
                 # Parse "YYYY-MM-DD" string into date
                 return datetime.strptime(value, "%Y-%m-%d").date()
             except (ValueError, TypeError):
-                raise ValueError(
-                    f'"{value}" is not a date string in YYYY-MM-DD format.'
-                )
+                raise ValueError(f'"{value}" is not a date string in YYYY-MM-DD format.')
         ```
         """
         self._parse_value = f
@@ -266,20 +260,17 @@ def set_literal_parser(
         ```python
         date_scalar = ScalarType("Date")
 
+
         @date_scalar.literal_parser
-        def parse_date_literal(
-            value: str, variable_values: Optional[dict[str, Any]] = None
-        ) -> date:
+        def parse_date_literal(value: str, variable_values: Optional[dict[str, Any]] = None) -> date:
             if not isinstance(ast, StringValueNode):
                 raise ValueError()
 
             try:
                 # Parse "YYYY-MM-DD" string into date
                 return datetime.strptime(ast.value, "%Y-%m-%d").date()
             except (ValueError, TypeError):
-                raise ValueError(
-                    f'"{value}" is not a date string in YYYY-MM-DD format.'
-                )
+                raise ValueError(f'"{value}" is not a date string in YYYY-MM-DD format.')
         ```
         """
         self._parse_literal = f
@@ -316,5 +307,7 @@ def validate_graphql_type(self, graphql_type: Optional[GraphQLNamedType]) -> Non
             raise ValueError(f"Scalar {self.name} is not defined in the schema")
         if not isinstance(graphql_type, GraphQLScalarType):
             raise ValueError(
-                f"{self.name} is defined in the schema, but it is instance of {type(graphql_type).__name__} (expected {GraphQLScalarType.__name__})"
+                f"{self.name} is defined in the schema, "
+                f"but it is instance of {type(graphql_type).__name__} "
+                f"(expected {GraphQLScalarType.__name__})"
             )

ariadne/scalars.py

@@ -155,7 +155,7 @@ def visit_input_field_definition(
         pass
 
 
-def visit_schema(
+def visit_schema(  # noqa: C901
     schema: GraphQLSchema,
     visitor_selector: Callable[
         [VisitableSchemaType, str], list["SchemaDirectiveVisitor"]
@@ -347,6 +347,7 @@ class SchemaDirectiveVisitor(SchemaVisitor):
         GraphQLUnionType,
     )
 
+
     class MyDirective(SchemaDirectiveVisitor):
         def visit_schema(self, schema: GraphQLSchema) -> None:
             pass
@@ -386,9 +387,7 @@ def visit_enum_value(
         ) -> GraphQLEnumValue:
             pass
 
-        def visit_input_object(
-            self, object_: GraphQLInputObjectType
-        ) -> GraphQLInputObjectType:
+        def visit_input_object(self, object_: GraphQLInputObjectType) -> GraphQLInputObjectType:
             pass
 
         def visit_input_field_definition(
@@ -612,8 +611,8 @@ def _visitor_selector(
 NamedTypeMap = dict[str, GraphQLNamedType]
 
 
-def heal_schema(schema: GraphQLSchema) -> GraphQLSchema:
-    def heal(type_: VisitableSchemaType):
+def heal_schema(schema: GraphQLSchema) -> GraphQLSchema:  # noqa: C901
+    def heal(type_: VisitableSchemaType):  # noqa: C901
         if isinstance(type_, GraphQLSchema):
             original_type_map: NamedTypeMap = type_.type_map
             actual_named_type_map: NamedTypeMap = {}
@@ -716,7 +715,7 @@ def _heal_field(field, _):
         each(type_.fields, _heal_field)
 
     def heal_type(
-        type_: Union[GraphQLList, GraphQLNamedType, GraphQLNonNull]
+        type_: Union[GraphQLList, GraphQLNamedType, GraphQLNonNull],
     ) -> Union[GraphQLList, GraphQLNamedType, GraphQLNonNull]:
         # Unwrap the two known wrapper types
         if isinstance(type_, GraphQLList):

ariadne/schema_visitor.py

@@ -21,9 +21,7 @@ class SubscriptionType(ObjectType):
     Its signature is same as resolver:
 
     ```python
-    async def source_fn(
-        root_value: Any, info: GraphQLResolveInfo, **field_args
-    ) -> Any:
+    async def source_fn(root_value: Any, info: GraphQLResolveInfo, **field_args) -> Any:
         yield ...
     ```
 
@@ -35,9 +33,7 @@ async def source_fn(
     source function as first argument.
 
     ```python
-    def resolver_fn(
-        message: Any, info: GraphQLResolveInfo, **field_args
-    ) -> Any:
+    def resolver_fn(message: Any, info: GraphQLResolveInfo, **field_args) -> Any:
         # Subscription resolver can be sync and async.
         return ...
     ```
@@ -117,8 +113,8 @@ def __init__(self) -> None:
     def source(self, name: str) -> Callable[[Subscriber], Subscriber]:
         """Return a decorator that sets decorated function as a source for named field.
 
-        Wrapper for `create_register_subscriber` that on runtime validates `name` to be a
-        string.
+        Wrapper for `create_register_subscriber` that on runtime
+        validates `name` to be a string.
 
         # Required arguments
 
@@ -179,8 +175,6 @@ def bind_subscribers_to_graphql_type(self, graphql_type):
         """
         for field, subscriber in self._subscribers.items():
             if field not in graphql_type.fields:
-                raise ValueError(
-                    f"Field {field} is not defined on type {self.name}"
-                )
+                raise ValueError(f"Field {field} is not defined on type {self.name}")
 
             graphql_type.fields[field].subscribe = subscriber