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__})"
             )