chore: DROP 3.8, leverage hatch to run tests and static analisys

- provide explicit configs for mypy, ruff, coverage
- Python 3.8 support is dropped
- Python 3.13 support introduced

Author: pkucmus

ariadne/asgi/graphql.py

@@ -1,5 +1,6 @@
+from collections.abc import Awaitable
 from logging import Logger, LoggerAdapter
-from typing import Any, Awaitable, Optional, Type, Union
+from typing import Any, Optional, Union
 
 from graphql import ExecutionContext, GraphQLSchema
 from starlette.requests import Request
@@ -45,7 +46,7 @@ def __init__(
         explorer: Optional[Explorer] = None,
         logger: Union[None, str, Logger, LoggerAdapter] = None,
         error_formatter: ErrorFormatter = format_error,
-        execution_context_class: Optional[Type[ExecutionContext]] = None,
+        execution_context_class: Optional[type[ExecutionContext]] = None,
         http_handler: Optional[GraphQLHTTPHandler] = None,
         websocket_handler: Optional[GraphQLWebsocketHandler] = None,
     ) -> None:
@@ -182,7 +183,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send):
         elif scope["type"] == "websocket":
             await self.websocket_handler.handle(scope=scope, receive=receive, send=send)
         else:
-            raise ValueError("Unknown scope type: %r" % (scope["type"],))
+            raise ValueError("Unknown scope type: {!r}".format(scope["type"]))
 
     async def handle_request(self, request: Request) -> Response:
         """Shortcut for `graphql_app.http_handler.handle_request(...)`."""

ariadne/asgi/handlers/__init__.py

@@ -1,8 +1,7 @@
 from .base import GraphQLHandler, GraphQLHttpHandlerBase, GraphQLWebsocketHandler
-from .http import GraphQLHTTPHandler
 from .graphql_transport_ws import GraphQLTransportWSHandler
 from .graphql_ws import GraphQLWSHandler
-
+from .http import GraphQLHTTPHandler
 
 __all__ = [
     "GraphQLHandler",

ariadne/asgi/handlers/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from inspect import isawaitable
 from logging import Logger, LoggerAdapter
-from typing import Any, Optional, Type, Union
+from typing import Any, Optional, Union
 
 from graphql import DocumentNode, ExecutionContext, GraphQLSchema, MiddlewareManager
 from starlette.types import Receive, Scope, Send
@@ -41,8 +41,8 @@ def __init__(self) -> None:
         self.query_validator: Optional[QueryValidator] = None
         self.validation_rules: Optional[ValidationRules] = None
         self.execute_get_queries: bool = False
-        self.execution_context_class: Optional[Type[ExecutionContext]] = None
-        self.middleware_manager_class: Optional[Type[MiddlewareManager]] = None
+        self.execution_context_class: Optional[type[ExecutionContext]] = None
+        self.middleware_manager_class: Optional[type[MiddlewareManager]] = None
 
     @abstractmethod
     async def handle(self, scope: Scope, receive: Receive, send: Send):
@@ -86,7 +86,7 @@ def configure(
         explorer: Optional[Explorer] = None,
         logger: Union[None, str, Logger, LoggerAdapter] = None,
         error_formatter: ErrorFormatter = format_error,
-        execution_context_class: Optional[Type[ExecutionContext]] = None,
+        execution_context_class: Optional[type[ExecutionContext]] = None,
     ):
         """Configures the handler with options from the ASGI application.
 

ariadne/asgi/handlers/graphql_transport_ws.py

@@ -1,15 +1,16 @@
 import asyncio
+from collections.abc import AsyncGenerator
 from contextlib import suppress
 from datetime import timedelta
 from inspect import isawaitable
-from typing import Any, AsyncGenerator, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
 from graphql import GraphQLError
 from graphql.language import OperationType
 from starlette.types import Receive, Scope, Send
 from starlette.websockets import WebSocket, WebSocketDisconnect, WebSocketState
 
-from ...graphql import subscribe, parse_query, validate_data
+from ...graphql import parse_query, subscribe, validate_data
 from ...logger import log_error
 from ...types import (
     ExecutionResult,
@@ -24,8 +25,8 @@ def __init__(self) -> None:
         self.connection_acknowledged: bool = False
         self.connection_init_timeout_task: Optional[asyncio.Task] = None
         self.connection_init_received: bool = False
-        self.operations: Dict[str, Operation] = {}
-        self.operation_tasks: Dict[str, asyncio.Task] = {}
+        self.operations: dict[str, Operation] = {}
+        self.operation_tasks: dict[str, asyncio.Task] = {}
         self.websocket: WebSocket
 
 
@@ -374,7 +375,7 @@ async def get_results():
 
         if not success:
             if not isinstance(results_producer, list):
-                error_payload = cast(List[dict], [results_producer])
+                error_payload = cast(list[dict], [results_producer])
             else:
                 error_payload = results_producer
 
@@ -524,7 +525,8 @@ async def observe_async_results(
                     }
                 )
         except asyncio.CancelledError:  # pylint: disable=W0706
-            # if asyncio Task is cancelled then CancelledError is thrown in the coroutine
+            # if asyncio Task is cancelled then CancelledError 
+            # is thrown in the coroutine
             raise
         except Exception as error:
             if not isinstance(error, GraphQLError):

ariadne/asgi/handlers/graphql_ws.py

@@ -1,6 +1,7 @@
 import asyncio
+from collections.abc import AsyncGenerator
 from inspect import isawaitable
-from typing import Any, AsyncGenerator, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
 from graphql import DocumentNode, GraphQLError
 from graphql.language import OperationType
@@ -104,7 +105,7 @@ async def handle_websocket(self, websocket: WebSocket):
 
         `websocket`: the `WebSocket` instance from Starlette or FastAPI.
         """
-        operations: Dict[str, Operation] = {}
+        operations: dict[str, Operation] = {}
         await websocket.accept("graphql-ws")
         try:
             while WebSocketState.DISCONNECTED not in (
@@ -134,7 +135,7 @@ async def handle_websocket_message(
         self,
         websocket: WebSocket,
         message: dict,
-        operations: Dict[str, Operation],
+        operations: dict[str, Operation],
     ):
         """Handles new message from websocket connection.
 
@@ -167,7 +168,7 @@ async def process_single_message(
         websocket: WebSocket,
         data: Any,
         operation_id: str,
-        operations: Dict[str, Operation],
+        operations: dict[str, Operation],
     ) -> None:
         """Processes websocket message containing new GraphQL operation.
 
@@ -290,7 +291,7 @@ async def start_websocket_operation(
         context_value: Any,
         query_document: DocumentNode,
         operation_id: str,
-        operations: Dict[str, Operation],
+        operations: dict[str, Operation],
     ):
         if self.schema is None:
             raise TypeError("schema is not set, call configure method to initialize it")
@@ -310,7 +311,7 @@ async def start_websocket_operation(
         )
 
         if not success:
-            results = cast(List[dict], results)
+            results = cast(list[dict], results)
             await websocket.send_json(
                 {
                     "type": GraphQLWSHandler.GQL_ERROR,

ariadne/asgi/handlers/http.py

@@ -1,7 +1,7 @@
 import json
 from http import HTTPStatus
 from inspect import isawaitable
-from typing import Any, Optional, Type, Union, cast
+from typing import Any, Optional, Union, cast
 
 from graphql import DocumentNode, MiddlewareManager
 from starlette.datastructures import UploadFile
@@ -38,7 +38,7 @@ def __init__(
         self,
         extensions: Optional[Extensions] = None,
         middleware: Optional[Middlewares] = None,
-        middleware_manager_class: Optional[Type[MiddlewareManager]] = None,
+        middleware_manager_class: Optional[type[MiddlewareManager]] = None,
     ) -> None:
         """Initializes the HTTP handler.
 

ariadne/contrib/federation/__init__.py

@@ -7,3 +7,5 @@
 from .interfaces import FederatedInterfaceType
 from .objects import FederatedObjectType
 from .schema import make_federated_schema
+
+__all__ = ["FederatedInterfaceType", "FederatedObjectType", "make_federated_schema"]

ariadne/contrib/federation/schema.py

@@ -1,6 +1,6 @@
-import re
 import os
-from typing import Dict, List, Optional, Type, Union, cast
+import re
+from typing import Optional, Union, cast
 
 from graphql import extend_schema, parse
 from graphql.language import DocumentNode
@@ -13,12 +13,12 @@
 
 from ...executable_schema import (
     SchemaBindables,
-    make_executable_schema,
     join_type_defs,
+    make_executable_schema,
 )
+from ...load_schema import load_schema_from_path
 from ...schema_names import SchemaNameConverter
 from ...schema_visitor import SchemaDirectiveVisitor
-from ...load_schema import load_schema_from_path
 from .utils import get_entity_types, purge_schema_directives, resolve_entities
 
 base_federation_service_type_defs = """
@@ -54,9 +54,9 @@ def has_query_type(type_defs: str) -> bool:
 
 
 def make_federated_schema(
-    type_defs: Union[str, List[str]],
+    type_defs: Union[str, list[str]],
     *bindables: SchemaBindables,
-    directives: Optional[Dict[str, Type[SchemaDirectiveVisitor]]] = None,
+    directives: Optional[dict[str, type[SchemaDirectiveVisitor]]] = None,
     convert_names_case: Union[bool, SchemaNameConverter] = False,
 ) -> GraphQLSchema:
     if isinstance(type_defs, list):

ariadne/contrib/federation/utils.py

@@ -1,7 +1,7 @@
 # pylint: disable=cell-var-from-loop
 
 from inspect import isawaitable
-from typing import Any, List, Tuple, cast
+from typing import Any, cast
 
 from graphql import (
     DirectiveDefinitionNode,
@@ -11,14 +11,13 @@
 )
 from graphql.language import DirectiveNode
 from graphql.type import (
-    GraphQLNamedType,
     GraphQLInputObjectType,
+    GraphQLNamedType,
     GraphQLObjectType,
     GraphQLResolveInfo,
     GraphQLSchema,
 )
 
-
 _allowed_directives = [
     "skip",  # Default directive as per specs.
     "include",  # Default directive as per specs.
@@ -41,7 +40,7 @@
 ]
 
 
-def _purge_directive_nodes(nodes: Tuple[Node, ...]) -> Tuple[Node, ...]:
+def _purge_directive_nodes(nodes: tuple[Node, ...]) -> tuple[Node, ...]:
     return tuple(
         node
         for node in nodes
@@ -58,11 +57,11 @@ def _purge_type_directives(definition: Node):
         if isinstance(value, tuple):
             # Remove directive nodes from the tuple
             # e.g. doc -> definitions [DirectiveDefinitionNode]
-            next_value = _purge_directive_nodes(cast(Tuple[Node, ...], value))
+            next_value = _purge_directive_nodes(cast(tuple[Node, ...], value))
             for item in next_value:
                 if isinstance(item, Node):
-                    # Look for directive nodes on sub-nodes
-                    # e.g. doc -> definitions [ObjectTypeDefinitionNode] -> fields -> directives
+                    # Look for directive nodes on sub-nodes, e.g.: doc ->
+                    # definitions [ObjectTypeDefinitionNode] -> fields -> directives
                     _purge_type_directives(item)
             setattr(definition, key, next_value)
         elif isinstance(value, Node):
@@ -111,7 +110,7 @@ async def add_typename_to_async_return(obj: Any, typename: str) -> Any:
     return add_typename_to_possible_return(await obj, typename)
 
 
-def get_entity_types(schema: GraphQLSchema) -> List[GraphQLNamedType]:
+def get_entity_types(schema: GraphQLSchema) -> list[GraphQLNamedType]:
     """Get all types that include the @key directive."""
     schema_types = schema.type_map.values()
 
@@ -135,9 +134,9 @@ def includes_directive(
 
 def gather_directives(
     type_object: GraphQLNamedType,
-) -> List[DirectiveNode]:
+) -> list[DirectiveNode]:
     """Get all directive attached to a type."""
-    directives: List[DirectiveNode] = []
+    directives: list[DirectiveNode] = []
 
     if hasattr(type_object, "extension_ast_nodes") and type_object.extension_ast_nodes:
         for ast_node in type_object.extension_ast_nodes: