autographql 0.1.0__py3-none-any.whl

autographql/__init__.py

@@ -0,0 +1,15 @@
+"""AutoGraphQL: schema-driven generation of NL2GraphQL datasets.
+
+Turns a GraphQL SDL schema into validated (schema, natural-language query,
+GraphQL query) triples, covering aliases, directives, fragments, inline
+fragments, filters, pagination and mutations.
+"""
+try:
+    # Written at build time by hatch-vcs from the git tag.
+    from ._version import __version__
+except ImportError:                      # running from a source tree, not installed
+    __version__ = "0.0.0.dev0"
+
+from .query_generator_app import GraphQLQueryGeneratorApp
+
+__all__ = ["GraphQLQueryGeneratorApp", "__version__"]

autographql/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

autographql/cli.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+if root_dir not in sys.path:
+    sys.path.insert(0, root_dir)
+
+from .query_generator_app import GraphQLQueryGeneratorApp
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate GraphQL queries from multiple schemas')
+    parser.add_argument('--schema', type=str, help='Path to a specific GraphQL schema file')
+    parser.add_argument('--category', type=str, required=True, 
+                        choices=['external_fragments', 'inline_fragments', 'directives', 'filters', 'aliases', 'mutations', 'pagination', 'all'],
+                        help='Category of queries to generate')
+    parser.add_argument('--count', type=int, required=True, help='Number of unique queries to generate per category')
+    parser.add_argument('--max-hops', type=int, default=2, help='Maximum number of hops (query depth) allowed in generated queries')
+    
+    args = parser.parse_args()
+    
+    schema_dir = 'schemas'
+    output_dir = 'generated_queries'
+    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    if not os.path.exists(schema_dir):
+        os.makedirs(schema_dir)
+    
+    app = GraphQLQueryGeneratorApp()
+    
+    if args.schema:
+        schema_path = args.schema
+        
+        if os.path.isdir(schema_path):
+            index_file = os.path.join(schema_path, 'index.graphql')
+            if os.path.isfile(index_file):
+                schema_path = index_file
+        elif not os.path.exists(schema_path):
+            schema_dir_path = os.path.join(schema_dir, schema_path)
+            index_file = os.path.join(schema_dir_path, 'index.graphql')
+            
+            if os.path.isdir(schema_dir_path) and os.path.isfile(index_file):
+                schema_path = index_file
+            else:
+                schema_file = schema_path
+                if not schema_file.endswith('.graphql'):
+                    schema_file += '.graphql'
+                
+                schema_path = os.path.join(schema_dir, schema_file)        
+
+        if not os.path.exists(schema_path):
+            print(f"Error: Schema '{args.schema}' does not exist at any of the possible locations.")
+            return 1
+        
+        app.generate_queries_for_schema(schema_path, args.category, args.count, args.max_hops, output_dir)
+    else:
+        app.generate_queries_from_directory(schema_dir, args.category, args.count, args.max_hops, output_dir)
+    
+    print("\nQuery generation complete!")
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main()) 

autographql/generators/__init__.py

@@ -0,0 +1 @@
+"""Per-category query generators, selected through `generator_factory`."""

autographql/generators/alias_generator.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+import logging
+from typing import Dict, Any, Tuple, Set
+import random
+from .base_generator import BaseQueryGenerator
+
+logger = logging.getLogger(__name__)
+
+class AliasQueryGenerator(BaseQueryGenerator):
+    def __init__(self, schema, exclude_fields: Set[str] = None, max_hops: int = 2):
+        super().__init__(schema, exclude_fields, max_hops)
+
+    def generate_query(self) -> Tuple[str, Dict[str, Any]]:
+        if not self.root_query_fields:
+            return "", {}
+        
+        add_directive = self.should_add_feature(0.3)
+        add_filter = False if add_directive else self.should_add_feature(0.3)
+        query_sub_category = ''
+        query_variables = {}
+        
+        available_fields = []
+        for field_name in self.root_query_fields.keys():
+            if field_name in self.exclude_fields:
+                continue
+            
+            field = self.root_query_fields.get(field_name)
+            if field:
+                return_type = self._get_field_type_name(field)
+                if return_type:
+                    available_fields.append(field_name)
+        
+        if not available_fields:
+            return "", {}
+        
+        object_fields = []
+        for field_name in available_fields:
+            field = self.root_query_fields.get(field_name)
+            if not field:
+                continue
+                
+            return_type_name = self._get_field_type_name(field)
+            if self._is_object_or_interface(return_type_name):
+                sub_fields = self._get_type_fields(return_type_name)
+                if sub_fields and len(sub_fields) > 0:
+                    object_fields.append((field_name, field, return_type_name))
+        
+        if object_fields:
+            field_name, field, return_type_name = random.choice(object_fields)
+            
+            field_args, field_vars = self._get_field_args(field, use_variables=True)
+            query_variables.update(field_vars)
+            
+            if add_filter and not field_args:
+                field_name_with_filter, sub_category, filter_variables = self.add_filter_to_field(field, field_name)
+                if sub_category == 'filters':
+                    field_name, field_args = field_name_with_filter.split('(', 1)
+                    field_args = '(' + field_args
+                    query_variables.update(filter_variables)
+                    query_sub_category = 'filters'
+            
+            sub_fields = self._get_type_fields(return_type_name)
+            sub_field_names = list(sub_fields.keys())
+            
+            if sub_field_names:
+                num_subfields = min(random.randint(2, 5), len(sub_field_names))
+                selected_subfields = random.sample(sub_field_names, num_subfields)
+                
+                aliased_fields = []
+                for subfield in selected_subfields:
+                    alias = f"aliased{subfield.capitalize()}"
+                    subfield_type = self._get_field_type_name(sub_fields[subfield])
+                    subfield_name = subfield
+                    apply_directive = add_directive and self.should_add_feature(0.5) and query_sub_category != 'filters'
+                    
+                    if self._is_object_or_interface(subfield_type):
+                        nested_fields_str = self._build_fields_string(subfield_type, max_depth=2)
+                        
+                        if apply_directive:
+                            subfield_with_directive, sub_category, directive_variables = self.add_directive_to_field(
+                                subfield_name + " {"
+                            )
+                            if sub_category == 'directives':
+                                query_variables.update(directive_variables)
+                                query_sub_category = 'directives'
+                                subfield_opening = subfield_with_directive
+                            else:
+                                subfield_opening = f"{subfield_name} {{"
+                        else:
+                            subfield_opening = f"{subfield_name} {{"
+                        
+                        if nested_fields_str:
+                            indented_nested_str = nested_fields_str.replace('\n', '\n      ')
+                            aliased_fields.append(f"{alias}: {subfield_opening}\n      {indented_nested_str}\n    }}")
+                        else:
+                            default_field = self._get_default_field(subfield_type)
+                            aliased_fields.append(f"{alias}: {subfield_opening}\n      {default_field}\n    }}")
+                    else:
+                        if apply_directive:
+                            subfield_with_directive, sub_category, directive_variables = self.add_directive_to_field(subfield_name)
+                            if sub_category == 'directives':
+                                query_variables.update(directive_variables)
+                                query_sub_category = 'directives'
+                                aliased_fields.append(f"{alias}: {subfield_with_directive}")
+                            else:
+                                aliased_fields.append(f"{alias}: {subfield_name}")
+                        else:
+                            aliased_fields.append(f"{alias}: {subfield_name}")
+                
+                variable_section = self._format_variable_section(query_variables)
+                indented_aliased_fields = "\n    ".join(aliased_fields)
+                query = f"""query {field_name.capitalize()}AliasQuery{variable_section} {{
+  {field_name}{field_args} {{
+    {indented_aliased_fields}
+  }}
+}}"""
+              
+                final_variables = self._simplify_variables(query_variables)
+                return query, final_variables
+        
+        return "", {}
+
+    def _format_variable_section(self, query_variables: Dict[str, Any]) -> str:
+        """Format the variable section for the query."""
+        if not query_variables:
+            return ""
+        
+        var_defs = []
+        for var_name, var_info in query_variables.items():
+            var_type = var_info.get('type', 'String')
+            if not var_type.endswith('!'):
+                var_type += '!'
+            var_defs.append(f"${var_name}: {var_type}")
+        
+        return f"({', '.join(var_defs)})" if var_defs else ""
+
+    def _simplify_variables(self, query_variables: Dict[str, Any]) -> Dict[str, Any]:
+        """Simplify variable values for the query."""
+        final_variables = {}
+        for var_name, var_info in query_variables.items():
+            final_variables[var_name] = self._simplify_variable_value(var_info)
+        return final_variables