update ast usage in code for python 3.12 changes (#306)

update-typing-to-satisfy-mypy

Author: DamianCzajkowski

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.14.1 (UNRELEASED)
+
+- Changed code typing to satisfy MyPy 1.11.0 version
+
+
 ## 0.14.0 (2024-07-17)
 
 - Added `ClientForwardRefsPlugin` to standard plugins.

ariadne_codegen/client_generators/client.py

@@ -850,7 +850,7 @@ def _generate_variables_assign(
         self, variable_names: Dict[str, str], arguments_dict: ast.Dict, lineno: int = 1
     ) -> ast.AnnAssign:
         return generate_ann_assign(
-            target=variable_names[self._variables_dict_variable],
+            target=generate_name(variable_names[self._variables_dict_variable]),
             annotation=generate_subscript(
                 generate_name(DICT),
                 generate_tuple([generate_name("str"), generate_name("object")]),

ariadne_codegen/client_generators/custom_arguments.py

@@ -221,7 +221,7 @@ def generate_clear_arguments_section(
     ) -> Tuple[List[ast.stmt], List[ast.keyword]]:
         arguments_body = [
             generate_ann_assign(
-                "arguments",
+                generate_name("arguments"),
                 generate_subscript(
                     generate_name(DICT),
                     generate_tuple(
@@ -240,8 +240,8 @@ def generate_clear_arguments_section(
                     ),
                 ),
                 generate_dict(
-                    return_arguments_keys,
-                    return_arguments_values,  # type: ignore
+                    return_arguments_keys,  # type: ignore
+                    return_arguments_values,
                 ),
             ),
             generate_assign(

ariadne_codegen/client_generators/custom_fields.py

@@ -219,7 +219,7 @@ def _generate_class_field(
                 name, field_name, getattr(field, "args")
             )
         return generate_ann_assign(
-            target=name,
+            target=generate_name(name),
             annotation=generate_name(f'"{field_name}"'),
             value=generate_call(
                 func=generate_name(field_name), args=[generate_constant(org_name)]

ariadne_codegen/client_generators/input_fields.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Dict, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, cast
 
 from graphql import (
     BooleanValueNode,
@@ -142,15 +142,18 @@ def parse_input_const_value_node(
 
     if isinstance(node, ListValueNode):
         list_ = generate_list(
-            [
-                parse_input_const_value_node(
-                    node=v,
-                    field_type=field_type,
-                    nested_object=nested_object,
-                    nested_list=True,
-                )
-                for v in node.values
-            ]
+            cast(
+                List[ast.expr],
+                [
+                    parse_input_const_value_node(
+                        node=v,
+                        field_type=field_type,
+                        nested_object=nested_object,
+                        nested_list=True,
+                    )
+                    for v in node.values
+                ],
+            )
         )
         if not nested_list:
             return generate_call(
@@ -166,15 +169,18 @@ def parse_input_const_value_node(
     if isinstance(node, ObjectValueNode):
         dict_ = generate_dict(
             keys=[generate_constant(f.name.value) for f in node.fields],
-            values=[
-                parse_input_const_value_node(
-                    node=f.value,
-                    field_type=field_type,
-                    nested_object=True,
-                    nested_list=True,
-                )
-                for f in node.fields
-            ],
+            values=cast(
+                List[ast.expr],
+                [
+                    parse_input_const_value_node(
+                        node=f.value,
+                        field_type=field_type,
+                        nested_object=True,
+                        nested_list=True,
+                    )
+                    for f in node.fields
+                ],
+            ),
         )
         if not nested_object:
             return generate_call(

ariadne_codegen/client_generators/input_types.py

@@ -18,6 +18,7 @@
     generate_keyword,
     generate_method_call,
     generate_module,
+    generate_name,
     generate_pydantic_field,
     model_has_forward_refs,
 )
@@ -172,7 +173,7 @@ def _parse_input_definition(
                 field.type, custom_scalars=self.custom_scalars
             )
             field_implementation = generate_ann_assign(
-                target=name,
+                target=generate_name(name),
                 annotation=annotation,
                 value=parse_input_field_default_value(
                     node=field.ast_node, annotation=annotation, field_type=field_type

ariadne_codegen/client_generators/result_fields.py

@@ -216,7 +216,9 @@ def parse_interface_type(
     )
     context.abstract_type = True
     if inline_fragments or fragments_on_subtypes:
-        types = [generate_annotation_name('"' + class_name + type_.name + '"', False)]
+        types: List[ast.expr] = [
+            generate_annotation_name('"' + class_name + type_.name + '"', False)
+        ]
         context.related_classes.append(
             RelatedClassData(class_name=class_name + type_.name, type_name=type_.name)
         )
@@ -275,7 +277,7 @@ def parse_union_type(
     class_name: str,
 ) -> Annotation:
     context.abstract_type = True
-    sub_annotations = [
+    sub_annotations: List[ast.expr] = [
         parse_operation_field_type(
             type_=subtype,
             context=context,

ariadne_codegen/client_generators/result_types.py

@@ -38,6 +38,7 @@
     generate_import_from,
     generate_method_call,
     generate_module,
+    generate_name,
     generate_pass,
     generate_pydantic_field,
     model_has_forward_refs,
@@ -264,7 +265,7 @@ def _parse_type_definition(
             )
 
             field_implementation = generate_ann_assign(
-                target=name,
+                target=generate_name(name),
                 annotation=annotation,
                 lineno=lineno,
                 value=default_value,

ariadne_codegen/codegen.py

@@ -1,5 +1,6 @@
 import ast
-from typing import Any, Dict, List, Optional, Union
+import sys
+from typing import Any, Dict, List, Optional, Union, cast
 
 from graphql import (
     GraphQLEnumType,
@@ -24,11 +25,6 @@
 from .exceptions import ParsingError
 
 
-def generate_import(names: List[str], level: int = 0) -> ast.Import:
-    """Generate import statement."""
-    return ast.Import(names=[ast.alias(n) for n in names], level=level)
-
-
 def generate_import_from(
     names: List[str], from_: Optional[str] = None, level: int = 0
 ) -> ast.ImportFrom:
@@ -94,17 +90,21 @@ def generate_async_method_definition(
     return_type: Union[ast.Name, ast.Subscript],
     body: Optional[List[ast.stmt]] = None,
     lineno: int = 1,
-    decorator_list: Optional[List[ast.Name]] = None,
+    decorator_list: Optional[List[ast.expr]] = None,
 ) -> ast.AsyncFunctionDef:
     """Generate async function."""
-    return ast.AsyncFunctionDef(
-        name=name,
-        args=arguments,
-        body=body if body else [ast.Pass()],
-        decorator_list=decorator_list if decorator_list else [],
-        returns=return_type,
-        lineno=lineno,
-    )
+    params: Dict[str, Any] = {
+        "name": name,
+        "args": arguments,
+        "body": body if body else [ast.Pass()],
+        "decorator_list": decorator_list if decorator_list else [],
+        "returns": return_type,
+        "lineno": lineno,
+    }
+    if sys.version_info >= (3, 12):
+        params["type_params"] = []
+
+    return ast.AsyncFunctionDef(**params)
 
 
 def generate_class_def(
@@ -113,14 +113,20 @@ def generate_class_def(
     body: Optional[List[ast.stmt]] = None,
 ) -> ast.ClassDef:
     """Generate class definition."""
-    bases = [ast.Name(id=name) for name in base_names] if base_names else []
-    return ast.ClassDef(
-        name=name,
-        bases=bases,
-        keywords=[],
-        body=body if body else [],
-        decorator_list=[],
+    bases = cast(
+        List[ast.expr], [ast.Name(id=name) for name in base_names] if base_names else []
     )
+    params: Dict[str, Any] = {
+        "name": name,
+        "bases": bases,
+        "keywords": [],
+        "body": body if body else [],
+        "decorator_list": [],
+    }
+    if sys.version_info >= (3, 12):
+        params["type_params"] = []
+
+    return ast.ClassDef(**params)
 
 
 def generate_name(name: str) -> ast.Name:
@@ -153,37 +159,39 @@ def generate_assign(
 ) -> ast.Assign:
     """Generate assign object."""
     return ast.Assign(
-        targets=[ast.Name(t) for t in targets], value=value, lineno=lineno
+        targets=[ast.Name(t) for t in targets],
+        value=value,  # type:ignore
+        lineno=lineno,
     )
 
 
 def generate_ann_assign(
-    target: Union[str, ast.expr],
+    target: Union[ast.Name, ast.Attribute, ast.Subscript],
     annotation: Annotation,
     value: Optional[ast.expr] = None,
     lineno: int = 1,
 ) -> ast.AnnAssign:
     """Generate ann assign object."""
     return ast.AnnAssign(
-        target=target if isinstance(target, ast.expr) else ast.Name(id=target),
+        target=target,
         annotation=annotation,
-        simple=1,
         value=value,
+        simple=1,
         lineno=lineno,
     )
 
 
 def generate_union_annotation(
-    types: List[Union[ast.Name, ast.Subscript]], nullable: bool = True
+    types: List[ast.expr], nullable: bool = True
 ) -> ast.Subscript:
     """Generate union annotation."""
     result = ast.Subscript(value=ast.Name(id=UNION), slice=ast.Tuple(elts=types))
     return result if not nullable else generate_nullable_annotation(result)
 
 
 def generate_dict(
-    keys: Optional[List[ast.expr]] = None,
-    values: Optional[List[Optional[ast.expr]]] = None,
+    keys: Optional[List[Optional[ast.expr]]] = None,
+    values: Optional[List[ast.expr]] = None,
 ) -> ast.Dict:
     """Generate dict object."""
     return ast.Dict(keys=keys if keys else [], values=values if values else [])
@@ -201,7 +209,9 @@ def generate_call(
 ) -> ast.Call:
     """Generate call object."""
     return ast.Call(
-        func=func, args=args if args else [], keywords=keywords if keywords else []
+        func=func,
+        args=args if args else [],  # type:ignore
+        keywords=keywords if keywords else [],
     )
 
 
@@ -240,7 +250,10 @@ def parse_field_type(
         return generate_annotation_name('"' + type_.name + '"', nullable)
 
     if isinstance(type_, GraphQLUnionType):
-        subtypes = [parse_field_type(subtype, False) for subtype in type_.types]
+        subtypes = cast(
+            List[ast.expr],
+            [parse_field_type(subtype, False) for subtype in type_.types],
+        )
         return generate_union_annotation(subtypes, nullable)
 
     if isinstance(type_, GraphQLList):
@@ -255,7 +268,7 @@ def parse_field_type(
 
 
 def generate_method_call(
-    object_name: str, method_name: str, args: Optional[List[Optional[ast.expr]]] = None
+    object_name: str, method_name: str, args: Optional[List[ast.expr]] = None
 ) -> ast.Call:
     """Generate object`s method call."""
     return ast.Call(
@@ -287,7 +300,7 @@ def generate_trivial_lambda(name: str, argument_name: str) -> ast.Assign:
     )
 
 
-def generate_list(elements: List[Optional[ast.expr]]) -> ast.List:
+def generate_list(elements: List[ast.expr]) -> ast.List:
     """Generate list object."""
     return ast.List(elts=elements)
 
@@ -343,16 +356,20 @@ def generate_method_definition(
     return_type: Union[ast.Name, ast.Subscript],
     body: Optional[List[ast.stmt]] = None,
     lineno: int = 1,
-    decorator_list: Optional[List[ast.Name]] = None,
+    decorator_list: Optional[List[ast.expr]] = None,
 ) -> ast.FunctionDef:
-    return ast.FunctionDef(
-        name=name,
-        args=arguments,
-        body=body if body else [ast.Pass()],
-        decorator_list=decorator_list if decorator_list else [],
-        returns=return_type,
-        lineno=lineno,
-    )
+    params: Dict[str, Any] = {
+        "name": name,
+        "args": arguments,
+        "body": body if body else [ast.Pass()],
+        "decorator_list": decorator_list if decorator_list else [],
+        "returns": return_type,
+        "lineno": lineno,
+    }
+    if sys.version_info >= (3, 12):
+        params["type_params"] = []
+
+    return ast.FunctionDef(**params)
 
 
 def generate_async_for(