ariadne-codegen 0.14.0.dev1__tar.gz → 0.14.0.dev2__tar.gz

{ariadne_codegen-0.14.0.dev1 → ariadne_codegen-0.14.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ariadne-codegen
-Version: 0.14.0.dev1
+Version: 0.14.0.dev2
 Summary: Generate fully typed GraphQL client from schema, queries and mutations!
 Project-URL: Homepage, https://ariadnegraphql.org/
 Project-URL: Repository, https://github.com/mirumee/ariadne-codegen

{ariadne_codegen-0.14.0.dev1 → ariadne_codegen-0.14.0.dev2}/ariadne_codegen/client_generators/client.py

@@ -16,6 +16,7 @@ from ..codegen import (
     generate_class_def,
     generate_comp,
     generate_constant,
+    generate_dict,
     generate_expr,
     generate_import_from,
     generate_keyword,
@@ -44,15 +45,20 @@ from .constants import (
     LIST,
     MODEL_VALIDATE_METHOD,
     NAME_NODE,
+    NAMED_TYPE_NODE,
     OPERATION_DEFINITION_NODE,
     OPERATION_TYPE,
     OPTIONAL,
     PRINT_AST,
+    SELECTION_NODE,
     SELECTION_SET_NODE,
+    TUPLE,
     TYPING_MODULE,
     UNION,
     UNSET_IMPORT,
     UPLOAD_IMPORT,
+    VARIABLE_DEFINITION_NODE,
+    VARIABLE_NODE,
 )
 from .scalars import ScalarData, generate_scalar_imports
 
@@ -207,133 +213,477 @@ class ClientGenerator:
             generate_import_from(names=[return_type], from_=return_type_module, level=1)
         )
 
-    def add_execute_custom_operation_method(self):
-        self._add_import(
-            generate_import_from(
-                [
-                    DOCUMENT_NODE,
-                    OPERATION_DEFINITION_NODE,
-                    NAME_NODE,
-                    SELECTION_SET_NODE,
-                    PRINT_AST,
+    def create_combine_variables_method(self):
+        method_body = [
+            generate_assign(
+                targets=["variables_types_combined"],
+                value=generate_dict(),
+            ),
+            generate_assign(
+                targets=["processed_variables_combined"],
+                value=generate_dict(),
+            ),
+            ast.For(
+                target=generate_name("field"),
+                iter=generate_name("fields"),
+                body=[
+                    generate_assign(
+                        targets=["formatted_variables"],
+                        value=generate_call(
+                            func=generate_name("field.get_formatted_variables")
+                        ),
+                    ),
+                    generate_expr(
+                        value=generate_call(
+                            func=generate_attribute(
+                                value=generate_name("variables_types_combined"),
+                                attr="update",
+                            ),
+                            args=[
+                                ast.DictComp(
+                                    key=generate_name("k"),
+                                    value=generate_name('v["type"]'),
+                                    generators=[
+                                        generate_comp(
+                                            target="k, v",
+                                            iter_="formatted_variables.items()",
+                                        )
+                                    ],
+                                )
+                            ],
+                        )
+                    ),
+                    generate_expr(
+                        value=generate_call(
+                            func=generate_attribute(
+                                value=generate_name("processed_variables_combined"),
+                                attr="update",
+                            ),
+                            args=[
+                                ast.DictComp(
+                                    key=generate_name("k"),
+                                    value=generate_name('v["value"]'),
+                                    generators=[
+                                        generate_comp(
+                                            target="k, v",
+                                            iter_="formatted_variables.items()",
+                                        )
+                                    ],
+                                )
+                            ],
+                        )
+                    ),
                 ],
-                GRAPHQL_MODULE,
-            )
+                orelse=[],
+                lineno=1,
+            ),
+            generate_return(
+                value=generate_dict(
+                    keys=[generate_constant("types"), generate_constant("values")],
+                    values=[
+                        generate_name("variables_types_combined"),
+                        generate_name("processed_variables_combined"),
+                    ],
+                )
+            ),
+        ]
+
+        args = generate_arguments(
+            args=[
+                generate_arg("self"),
+                generate_arg(
+                    name="fields",
+                    annotation=generate_subscript(
+                        generate_name(TUPLE),
+                        generate_tuple(
+                            [
+                                generate_name("GraphQLField"),
+                                generate_name("..."),
+                            ]
+                        ),
+                    ),
+                ),
+            ],
         )
-        self._add_import(
-            generate_import_from(
-                [BASE_GRAPHQL_FIELD_CLASS_NAME], BASE_OPERATION_FILE_PATH.stem, level=1
-            )
+
+        returns = generate_subscript(
+            generate_name(DICT),
+            generate_tuple(
+                [
+                    generate_name("str"),
+                    generate_subscript(
+                        generate_name(DICT),
+                        generate_tuple([generate_name("str"), generate_name("Any")]),
+                    ),
+                ]
+            ),
         )
-        execute_await = generate_await(
-            value=generate_call(
-                func=generate_attribute(value=generate_name("self"), attr="execute"),
-                args=[
-                    generate_call(
-                        func=generate_name("print_ast"),
-                        args=[generate_name("operation_ast")],
-                    )
-                ],
-                keywords=[
-                    generate_keyword(
-                        arg="operation_name", value=generate_name("operation_name")
-                    )
-                ],
-            )
+
+        method_def = generate_method_definition(
+            name="_combine_variables",
+            arguments=args,
+            body=method_body,
+            decorator_list=[],
+            return_type=returns,
         )
 
-        operation_definition_node = generate_call(
-            func=generate_name("OperationDefinitionNode"),
-            keywords=[
-                generate_keyword(
-                    arg="operation", value=generate_name("operation_type")
-                ),
-                generate_keyword(
-                    arg="name",
-                    value=generate_call(
-                        func=generate_name("NameNode"),
+        return method_def
+
+    def create_build_variable_definitions_method(self):
+        method_body = [
+            generate_return(
+                value=generate_list_comp(
+                    elt=generate_call(
+                        func=generate_name("VariableDefinitionNode"),
                         keywords=[
                             generate_keyword(
-                                arg="value", value=generate_name("operation_name")
-                            )
-                        ],
-                    ),
-                ),
-                generate_keyword(
-                    arg="selection_set",
-                    value=generate_call(
-                        func=generate_name("SelectionSetNode"),
-                        keywords=[
+                                arg="variable",
+                                value=generate_call(
+                                    func=generate_name("VariableNode"),
+                                    keywords=[
+                                        generate_keyword(
+                                            arg="name",
+                                            value=generate_call(
+                                                func=generate_name("NameNode"),
+                                                keywords=[
+                                                    generate_keyword(
+                                                        arg="value",
+                                                        value=generate_name("var_name"),
+                                                    )
+                                                ],
+                                            ),
+                                        )
+                                    ],
+                                ),
+                            ),
                             generate_keyword(
-                                arg="selections",
-                                value=generate_list_comp(
-                                    elt=generate_call(
-                                        func=generate_attribute(
-                                            value=generate_name("field"),
-                                            attr="to_ast",
-                                        ),
-                                    ),
-                                    generators=[
-                                        generate_comp(
-                                            target="field",
-                                            iter_="fields",
+                                arg="type",
+                                value=generate_call(
+                                    func=generate_name("NamedTypeNode"),
+                                    keywords=[
+                                        generate_keyword(
+                                            arg="name",
+                                            value=generate_call(
+                                                func=generate_name("NameNode"),
+                                                keywords=[
+                                                    generate_keyword(
+                                                        arg="value",
+                                                        value=generate_name(
+                                                            "var_value",
+                                                        ),
+                                                    )
+                                                ],
+                                            ),
                                         )
                                     ],
                                 ),
-                            )
+                            ),
                         ],
                     ),
-                ),
-            ],
-        )
-        operation_ast = generate_call(
-            func=generate_name("DocumentNode"),
-            keywords=[
-                generate_keyword(
-                    arg="definitions",
-                    value=generate_list(elements=[operation_definition_node]),
+                    generators=[
+                        generate_comp(
+                            target="var_name, var_value",
+                            iter_="variables_types_combined.items()",
+                        )
+                    ],
                 )
-            ],
-        )
-        body_return = generate_return(
-            value=generate_call(
-                func=generate_attribute(value=generate_name("self"), attr="get_data"),
-                args=[generate_name("response")],
             )
+        ]
+        return generate_method_definition(
+            name="_build_variable_definitions",
+            arguments=generate_arguments(
+                args=[
+                    generate_arg("self"),
+                    generate_arg(
+                        "variables_types_combined",
+                        annotation=generate_subscript(
+                            generate_name(DICT),
+                            generate_tuple(
+                                [
+                                    generate_name("str"),
+                                    generate_name("str"),
+                                ]
+                            ),
+                        ),
+                    ),
+                ]
+            ),
+            body=method_body,
+            return_type=generate_subscript(
+                generate_name("List"), generate_name("VariableDefinitionNode")
+            ),
         )
-        async_def_node = generate_async_method_definition(
-            name="execute_custom_operation",
+
+    def create_build_operation_ast_method(self):
+        keywords = [
+            generate_keyword(
+                arg="definitions",
+                value=generate_list(
+                    elements=[
+                        generate_call(
+                            func=generate_name("OperationDefinitionNode"),
+                            keywords=[
+                                generate_keyword(
+                                    arg="operation",
+                                    value=generate_name("operation_type"),
+                                ),
+                                generate_keyword(
+                                    arg="name",
+                                    value=generate_call(
+                                        func=generate_name("NameNode"),
+                                        keywords=[
+                                            generate_keyword(
+                                                arg="value",
+                                                value=generate_name(
+                                                    "operation_name",
+                                                ),
+                                            )
+                                        ],
+                                    ),
+                                ),
+                                generate_keyword(
+                                    arg="variable_definitions",
+                                    value=generate_name(
+                                        "variable_definitions",
+                                    ),
+                                ),
+                                generate_keyword(
+                                    arg="selection_set",
+                                    value=generate_call(
+                                        func=generate_name(
+                                            "SelectionSetNode",
+                                        ),
+                                        keywords=[
+                                            generate_keyword(
+                                                arg="selections",
+                                                value=generate_name("selections"),
+                                            )
+                                        ],
+                                    ),
+                                ),
+                            ],
+                        )
+                    ]
+                ),
+            )
+        ]
+        method_body = [
+            generate_return(
+                value=generate_call(
+                    func=generate_name("DocumentNode"),
+                    keywords=keywords,
+                )
+            )
+        ]
+        return generate_method_definition(
+            name="_build_operation_ast",
             arguments=generate_arguments(
                 args=[
                     generate_arg("self"),
                     generate_arg(
-                        "*fields",
-                        annotation=generate_name("GraphQLField"),
+                        "selections",
+                        annotation=generate_subscript(
+                            generate_name(LIST),
+                            generate_name(SELECTION_NODE),
+                        ),
                     ),
                     generate_arg(
                         "operation_type",
                         annotation=generate_name("OperationType"),
                     ),
                     generate_arg("operation_name", annotation=generate_name("str")),
-                ],
+                    generate_arg(
+                        "variable_definitions",
+                        annotation=generate_subscript(
+                            generate_name("List"),
+                            generate_name("VariableDefinitionNode"),
+                        ),
+                    ),
+                ]
             ),
-            body=[
-                generate_assign(
-                    targets=["operation_ast"],
-                    value=operation_ast,
+            body=method_body,
+            return_type=generate_name("DocumentNode"),
+        )
+
+    def create_execute_custom_operation_method(self):
+        method_body = [
+            generate_assign(
+                targets=["selections"],
+                value=generate_call(
+                    func=generate_attribute(
+                        value=generate_name("self"), attr="_build_selection_set"
+                    ),
+                    args=[generate_name("fields")],
                 ),
-                generate_assign(
-                    targets=["response"],
-                    value=execute_await,
+            ),
+            ast.Assign(
+                targets=[generate_name("combined_variables")],
+                value=generate_call(
+                    func=generate_attribute(
+                        value=generate_name("self"), attr="_combine_variables"
+                    ),
+                    args=[generate_name("fields")],
                 ),
-                body_return,
-            ],
+                lineno=1,
+            ),
+            generate_assign(
+                targets=["variable_definitions"],
+                value=generate_call(
+                    func=generate_attribute(
+                        value=generate_name("self"), attr="_build_variable_definitions"
+                    ),
+                    args=[generate_name('combined_variables["types"]')],
+                ),
+            ),
+            generate_assign(
+                targets=["operation_ast"],
+                value=generate_call(
+                    func=generate_attribute(
+                        value=generate_name("self"), attr="_build_operation_ast"
+                    ),
+                    args=[
+                        generate_name("selections"),
+                        generate_name("operation_type"),
+                        generate_name("operation_name"),
+                        generate_name("variable_definitions"),
+                    ],
+                ),
+            ),
+            generate_assign(
+                targets=["response"],
+                value=generate_await(
+                    value=generate_call(
+                        func=generate_attribute(
+                            value=generate_name("self"),
+                            attr="execute",
+                        ),
+                        args=[
+                            generate_call(
+                                func=generate_name("print_ast"),
+                                args=[generate_name("operation_ast")],
+                            )
+                        ],
+                        keywords=[
+                            generate_keyword(
+                                arg="variables",
+                                value=generate_name('combined_variables["values"]'),
+                            ),
+                            generate_keyword(
+                                arg="operation_name",
+                                value=generate_name("operation_name"),
+                            ),
+                        ],
+                    )
+                ),
+            ),
+            generate_return(
+                value=generate_call(
+                    func=generate_attribute(
+                        value=generate_name("self"),
+                        attr="get_data",
+                    ),
+                    args=[generate_name("response")],
+                )
+            ),
+        ]
+        return generate_async_method_definition(
+            name="execute_custom_operation",
+            arguments=generate_arguments(
+                args=[
+                    generate_arg("self"),
+                    generate_arg("*fields", annotation=generate_name("GraphQLField")),
+                    generate_arg(
+                        "operation_type",
+                        annotation=generate_name(
+                            "OperationType",
+                        ),
+                    ),
+                    generate_arg("operation_name", annotation=generate_name("str")),
+                ]
+            ),
+            body=method_body,
             return_type=generate_subscript(
                 generate_name(DICT),
                 generate_tuple([generate_name("str"), generate_name("Any")]),
             ),
         )
-        self._class_def.body.append(async_def_node)
+
+    def create_build_selection_set(self):
+        return generate_method_definition(
+            name="_build_selection_set",
+            arguments=generate_arguments(
+                args=[
+                    generate_arg("self"),
+                    generate_arg(
+                        "fields",
+                        annotation=generate_subscript(
+                            generate_name("Tuple"),
+                            generate_tuple(
+                                [
+                                    generate_name("GraphQLField"),
+                                    generate_name("..."),
+                                ]
+                            ),
+                        ),
+                    ),
+                ]
+            ),
+            body=[
+                generate_return(
+                    value=generate_list_comp(
+                        elt=generate_call(
+                            func=generate_attribute(
+                                value=generate_name(
+                                    "field",
+                                ),
+                                attr="to_ast",
+                            ),
+                            args=[generate_name("idx")],
+                        ),
+                        generators=[
+                            generate_comp(
+                                target="idx, field",
+                                iter_="enumerate(fields)",
+                            )
+                        ],
+                    ),
+                ),
+            ],
+            return_type=generate_subscript(
+                generate_name(LIST),
+                generate_name(SELECTION_NODE),
+            ),
+        )
+
+    def add_execute_custom_operation_method(self):
+        self._add_import(
+            generate_import_from(
+                [
+                    DOCUMENT_NODE,
+                    OPERATION_DEFINITION_NODE,
+                    NAME_NODE,
+                    SELECTION_SET_NODE,
+                    PRINT_AST,
+                    VARIABLE_DEFINITION_NODE,
+                    VARIABLE_NODE,
+                    NAMED_TYPE_NODE,
+                    SELECTION_NODE,
+                ],
+                GRAPHQL_MODULE,
+            )
+        )
+        self._add_import(
+            generate_import_from(
+                [BASE_GRAPHQL_FIELD_CLASS_NAME], BASE_OPERATION_FILE_PATH.stem, level=1
+            )
+        )
+        self._add_import(generate_import_from([DICT, TUPLE, LIST, ANY], "typing"))
+
+        self._class_def.body.append(self.create_execute_custom_operation_method())
+        self._class_def.body.append(self.create_combine_variables_method())
+        self._class_def.body.append(self.create_build_variable_definitions_method())
+        self._class_def.body.append(self.create_build_operation_ast_method())
+        self._class_def.body.append(self.create_build_selection_set())
 
     def create_custom_operation_method(self, name, operation_type):
         self._add_import(

{ariadne_codegen-0.14.0.dev1 → ariadne_codegen-0.14.0.dev2}/ariadne_codegen/client_generators/constants.py

@@ -19,6 +19,7 @@ ANY = "Any"
 TYPE = "Type"
 TYPE_CHECKING = "TYPE_CHECKING"
 DICT = "Dict"
+TUPLE = "Tuple"
 CALLABLE = "Callable"
 ANNOTATED = "Annotated"
 LITERAL = "Literal"
@@ -27,8 +28,12 @@ DOCUMENT_NODE = "DocumentNode"
 OPERATION_DEFINITION_NODE = "OperationDefinitionNode"
 NAME_NODE = "NameNode"
 SELECTION_SET_NODE = "SelectionSetNode"
+SELECTION_NODE = "SelectionNode"
 PRINT_AST = "print_ast"
 OPERATION_TYPE = "OperationType"
+VARIABLE_DEFINITION_NODE = "VariableDefinitionNode"
+VARIABLE_NODE = "VariableNode"
+NAMED_TYPE_NODE = "NamedTypeNode"
 
 HTTPX = "httpx"
 HTTPX_RESPONSE = "httpx.Response"