infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub_sdk/convert_object_type.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, model_validator
+
+CONVERT_OBJECT_MUTATION = """
+    mutation($node_id: String!, $target_kind: String!, $fields_mapping: GenericScalar!) {
+        ConvertObjectType(data: {
+                node_id: $node_id,
+                target_kind: $target_kind,
+                fields_mapping: $fields_mapping
+            }) {
+                ok
+                node
+        }
+    }
+"""
+
+
+class ConversionFieldValue(BaseModel):  # Only one of these fields can be not None
+    """
+    Holds the new value of the destination field during an object conversion.
+    Use `attribute_value` to specify the new raw value of an attribute.
+    Use `peer_id` to specify new peer of a cardinality one relationship.
+    Use `peers_ids` to specify new peers of a cardinality many relationship.
+    Only one of `attribute_value`, `peer_id` and `peers_ids` can be specified.
+    """
+
+    attribute_value: Any | None = None
+    peer_id: str | None = None
+    peers_ids: list[str] | None = None
+
+    @model_validator(mode="after")
+    def check_only_one_field(self) -> ConversionFieldValue:
+        fields = [self.attribute_value, self.peer_id, self.peers_ids]
+        set_fields = [f for f in fields if f is not None]
+        if len(set_fields) != 1:
+            raise ValueError("Exactly one of `attribute_value`, `peer_id`, or `peers_ids` must be set")
+        return self
+
+
+class ConversionFieldInput(BaseModel):
+    """
+    Indicates how to fill in the value of the destination field during an object conversion.
+    Use `source_field` to reuse the value of the corresponding field of the object being converted.
+    Use `data` to specify the new value for the field.
+    Use `use_default_value` to set the destination field to its schema default.
+    Only one of `source_field`, `data`, or `use_default_value` can be specified.
+    """
+
+    source_field: str | None = None
+    data: ConversionFieldValue | None = None
+    use_default_value: bool = False
+
+    @model_validator(mode="after")
+    def check_only_one_field(self) -> ConversionFieldInput:
+        fields_set = [self.source_field is not None, self.data is not None, self.use_default_value is True]
+        if sum(fields_set) != 1:
+            raise ValueError("Exactly one of `source_field`, `data` or `use_default_value` must be set")
+        return self

infrahub_sdk/ctl/check.py

@@ -11,10 +11,9 @@ import typer
 from rich.console import Console
 from rich.logging import RichHandler
 
-from ..ctl import config
 from ..ctl.client import initialize_client
 from ..ctl.exceptions import QueryNotFoundError
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.utils import catch_exception, execute_graphql_query
 from ..exceptions import ModuleImportError
 
@@ -59,7 +58,7 @@ def run(
     FORMAT = "%(message)s"
     logging.basicConfig(level=log_level, format=FORMAT, datefmt="[%X]", handlers=[RichHandler()])
 
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available:
         list_checks(repository_config=repository_config)

infrahub_sdk/ctl/cli_commands.py

@@ -20,17 +20,17 @@ from rich.table import Table
 
 from .. import __version__ as sdk_version
 from ..async_typer import AsyncTyper
-from ..ctl import config
 from ..ctl.branch import app as branch_app
 from ..ctl.check import run as run_check
 from ..ctl.client import initialize_client, initialize_client_sync
 from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.generator import run as run_generator
+from ..ctl.graphql import app as graphql_app
 from ..ctl.menu import app as menu_app
 from ..ctl.object import app as object_app
 from ..ctl.render import list_jinja2_transforms, print_template_errors
 from ..ctl.repository import app as repository_app
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.schema import app as schema_app
 from ..ctl.transform import list_transforms
 from ..ctl.utils import (
@@ -46,7 +46,7 @@ from ..protocols_generator.generator import CodeGenerator
 from ..schema import MainSchemaTypesAll, SchemaRoot
 from ..template import Jinja2Template
 from ..template.exceptions import JinjaTemplateError
-from ..utils import get_branch, write_to_file
+from ..utils import write_to_file
 from ..yaml import SchemaFile
 from .exporter import dump
 from .importer import load
@@ -63,6 +63,7 @@ app.add_typer(validate_app, name="validate")
 app.add_typer(repository_app, name="repository")
 app.add_typer(menu_app, name="menu")
 app.add_typer(object_app, name="object")
+app.add_typer(graphql_app, name="graphql")
 
 app.command(name="dump")(dump)
 app.command(name="load")(load)
@@ -208,7 +209,6 @@ async def _run_transform(
         debug: Prints debug info to the command line
         repository_config: Repository config object. This is used to load the graphql query from the repository.
     """
-    branch = get_branch(branch)
 
     try:
         response = execute_graphql_query(
@@ -260,7 +260,7 @@ async def render(
     """Render a local Jinja2 Transform for debugging purpose."""
 
     variables_dict = parse_cli_vars(variables)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not transform_name:
         list_jinja2_transforms(config=repository_config)
@@ -270,7 +270,7 @@ async def render(
     try:
         transform_config = repository_config.get_jinja2_transform(name=transform_name)
     except KeyError as exc:
-        console.print(f'[red]Unable to find "{transform_name}" in {config.INFRAHUB_REPO_CONFIG_FILE}')
+        console.print(f'[red]Unable to find "{transform_name}" in repository config file')
         list_jinja2_transforms(config=repository_config)
         raise typer.Exit(1) from exc
 
@@ -310,7 +310,7 @@ def transform(
     """Render a local transform (TransformPython) for debugging purpose."""
 
     variables_dict = parse_cli_vars(variables)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not transform_name:
         list_transforms(config=repository_config)
@@ -409,7 +409,6 @@ def info(  # noqa: PLR0915
     _: str = CONFIG_PARAM,
 ) -> None:
     """Display the status of the Python SDK."""
-
     info: dict[str, Any] = {
         "error": None,
         "status": ":x:",
@@ -417,12 +416,17 @@ def info(  # noqa: PLR0915
         "user_info": {},
         "groups": {},
     }
+    client = initialize_client_sync()
+    fetch_user_details = bool(client.config.username) or bool(client.config.api_token)
+
     try:
-        client = initialize_client_sync()
         info["infrahub_version"] = client.get_version()
-        info["user_info"] = client.get_user()
+
+        if fetch_user_details:
+            info["user_info"] = client.get_user()
+            info["groups"] = client.get_user_permissions()
+
         info["status"] = ":white_heavy_check_mark:"
-        info["groups"] = client.get_user_permissions()
     except Exception as e:
         info["error"] = f"{e!s} ({e.__class__.__name__})"
 
@@ -469,7 +473,7 @@ def info(  # noqa: PLR0915
         pretty_model = Pretty(client.config.model_dump(), expand_all=True)
         layout["client_info"].update(Panel(pretty_model, title="Client Info"))
 
-        # Infrahub information planel
+        # Infrahub information panel
         infrahub_info = Table(show_header=False, box=None)
         if info["user_info"]:
             infrahub_info.add_row("User:", info["user_info"]["AccountProfile"]["display_label"])
@@ -487,6 +491,8 @@ def info(  # noqa: PLR0915
                 infrahub_info.add_row("Groups:", "")
                 for group, roles in groups.items():
                     infrahub_info.add_row("", group, ", ".join(roles))
+        else:
+            infrahub_info.add_row("User:", "anonymous")
 
         layout["infrahub_info"].update(Panel(infrahub_info, title="Infrahub Info"))
 

infrahub_sdk/ctl/config.py

@@ -2,16 +2,22 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
-import toml
 import typer
 from pydantic import Field, ValidationError, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
 DEFAULT_CONFIG_FILE = "infrahubctl.toml"
 ENVVAR_CONFIG_FILE = "INFRAHUBCTL_CONFIG"
 INFRAHUB_REPO_CONFIG_FILE = ".infrahub.yml"
+INFRAHUB_REPO_CONFIG_FILE_ALT = ".infrahub.yaml"
 
 
 class Settings(BaseSettings):
@@ -59,7 +65,7 @@ class ConfiguredSettings:
 
         if config_file.is_file():
             config_string = config_file.read_text(encoding="utf-8")
-            config_tmp = toml.loads(config_string)
+            config_tmp = tomllib.loads(config_string)
 
             self._settings = Settings(**config_tmp)
             return

infrahub_sdk/ctl/generator.py

@@ -6,9 +6,8 @@ from typing import TYPE_CHECKING, Optional
 import typer
 from rich.console import Console
 
-from ..ctl import config
 from ..ctl.client import initialize_client
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.utils import execute_graphql_query, init_logging, parse_cli_vars
 from ..exceptions import ModuleImportError
 from ..node import InfrahubNode
@@ -26,7 +25,7 @@ async def run(
     variables: Optional[list[str]] = None,
 ) -> None:
     init_logging(debug=debug)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not generator_name:
         list_generators(repository_config=repository_config)
@@ -65,6 +64,8 @@ async def run(
             branch=branch or "",
             params=variables_dict,
             convert_query_response=generator_config.convert_query_response,
+            execute_in_proposed_change=generator_config.execute_in_proposed_change,
+            execute_after_merge=generator_config.execute_after_merge,
             infrahub_node=InfrahubNode,
         )
         await generator._init_client.schema.all(branch=generator.branch_name)
@@ -94,6 +95,8 @@ async def run(
                 branch=branch or "",
                 params=params,
                 convert_query_response=generator_config.convert_query_response,
+                execute_in_proposed_change=generator_config.execute_in_proposed_change,
+                execute_after_merge=generator_config.execute_after_merge,
                 infrahub_node=InfrahubNode,
             )
             data = execute_graphql_query(

infrahub_sdk/ctl/graphql.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional
+
+import typer
+from ariadne_codegen.client_generators.package import PackageGenerator, get_package_generator
+from ariadne_codegen.exceptions import ParsingError
+from ariadne_codegen.plugins.explorer import get_plugins_types
+from ariadne_codegen.plugins.manager import PluginManager
+from ariadne_codegen.schema import (
+    filter_fragments_definitions,
+    filter_operations_definitions,
+    get_graphql_schema_from_path,
+)
+from ariadne_codegen.settings import ClientSettings, CommentsStrategy
+from ariadne_codegen.utils import ast_to_str
+from graphql import DefinitionNode, GraphQLSchema, NoUnusedFragmentsRule, parse, specified_rules, validate
+from rich.console import Console
+
+from ..async_typer import AsyncTyper
+from ..ctl.client import initialize_client
+from ..ctl.utils import catch_exception
+from ..graphql.utils import insert_fragments_inline, remove_fragment_import
+from .parameters import CONFIG_PARAM
+
+app = AsyncTyper()
+console = Console()
+
+ARIADNE_PLUGINS = [
+    "infrahub_sdk.graphql.plugin.PydanticBaseModelPlugin",
+    "infrahub_sdk.graphql.plugin.FutureAnnotationPlugin",
+    "infrahub_sdk.graphql.plugin.StandardTypeHintPlugin",
+]
+
+
+def find_gql_files(query_path: Path) -> list[Path]:
+    """
+    Find all files with .gql extension in the specified directory.
+
+    Args:
+        query_path: Path to the directory to search for .gql files
+
+    Returns:
+        List of Path objects for all .gql files found
+    """
+    if not query_path.exists():
+        raise FileNotFoundError(f"File or directory not found: {query_path}")
+
+    if not query_path.is_dir() and query_path.is_file():
+        return [query_path]
+
+    return list(query_path.glob("**/*.gql"))
+
+
+def get_graphql_query(queries_path: Path, schema: GraphQLSchema) -> tuple[DefinitionNode, ...]:
+    """Get GraphQL queries definitions from a single GraphQL file."""
+
+    if not queries_path.exists():
+        raise FileNotFoundError(f"File not found: {queries_path}")
+    if not queries_path.is_file():
+        raise ValueError(f"{queries_path} is not a file")
+
+    queries_str = queries_path.read_text(encoding="utf-8")
+    queries_ast = parse(queries_str)
+    validation_errors = validate(
+        schema=schema,
+        document_ast=queries_ast,
+        rules=[r for r in specified_rules if r is not NoUnusedFragmentsRule],
+    )
+    if validation_errors:
+        raise ValueError("\n\n".join(error.message for error in validation_errors))
+    return queries_ast.definitions
+
+
+def generate_result_types(directory: Path, package: PackageGenerator, fragment: ast.Module) -> None:
+    for file_name, module in package._result_types_files.items():
+        file_path = directory / file_name
+
+        insert_fragments_inline(module, fragment)
+        remove_fragment_import(module)
+
+        code = package._add_comments_to_code(ast_to_str(module), package.queries_source)
+        if package.plugin_manager:
+            code = package.plugin_manager.generate_result_types_code(code)
+        file_path.write_text(code)
+        package._generated_files.append(file_path.name)
+
+
+@app.callback()
+def callback() -> None:
+    """
+    Various GraphQL related commands.
+    """
+
+
+@app.command()
+@catch_exception(console=console)
+async def export_schema(
+    destination: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Export the GraphQL schema to a file."""
+
+    client = initialize_client()
+    schema_text = await client.schema.get_graphql_schema()
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(schema_text)
+    console.print(f"[green]Schema exported to {destination}")
+
+
+@app.command()
+@catch_exception(console=console)
+async def generate_return_types(
+    query: Optional[Path] = typer.Argument(
+        None, help="Location of the GraphQL query file(s). Defaults to current directory if not specified."
+    ),
+    schema: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Create Pydantic Models for GraphQL query return types"""
+
+    query = Path.cwd() if query is None else query
+
+    # Load the GraphQL schema
+    if not schema.exists():
+        raise FileNotFoundError(f"GraphQL Schema file not found: {schema}")
+    graphql_schema = get_graphql_schema_from_path(schema_path=str(schema))
+
+    # Initialize the plugin manager
+    plugin_manager = PluginManager(
+        schema=graphql_schema,
+        plugins_types=get_plugins_types(plugins_strs=ARIADNE_PLUGINS),
+    )
+
+    # Find the GraphQL files and organize them by directory
+    gql_files = find_gql_files(query)
+    gql_per_directory: dict[Path, list[Path]] = defaultdict(list)
+    for gql_file in gql_files:
+        gql_per_directory[gql_file.parent].append(gql_file)
+
+    # Generate the Pydantic Models for the GraphQL queries
+    for directory, gql_files in gql_per_directory.items():
+        for gql_file in gql_files:
+            try:
+                definitions = get_graphql_query(queries_path=gql_file, schema=graphql_schema)
+            except ValueError as exc:
+                console.print(f"[red]Error generating result types for {gql_file}: {exc}")
+                continue
+            queries = filter_operations_definitions(definitions)
+            fragments = filter_fragments_definitions(definitions)
+
+            package_generator = get_package_generator(
+                schema=graphql_schema,
+                fragments=fragments,
+                settings=ClientSettings(
+                    schema_path=str(schema),
+                    target_package_name=directory.name,
+                    queries_path=str(directory),
+                    include_comments=CommentsStrategy.NONE,
+                ),
+                plugin_manager=plugin_manager,
+            )
+
+            parsing_failed = False
+            try:
+                for query_operation in queries:
+                    package_generator.add_operation(query_operation)
+            except ParsingError as exc:
+                console.print(f"[red]Unable to process {gql_file.name}: {exc}")
+                parsing_failed = True
+
+            if parsing_failed:
+                continue
+
+            module_fragment = package_generator.fragments_generator.generate()
+
+            generate_result_types(directory=directory, package=package_generator, fragment=module_fragment)
+
+            for file_name in package_generator._result_types_files.keys():
+                console.print(f"[green]Generated {file_name} in {directory}")

infrahub_sdk/ctl/repository.py

@@ -24,11 +24,49 @@ app = AsyncTyper()
 console = Console()
 
 
+def find_repository_config_file(base_path: Path | None = None) -> Path:
+    """Find the repository config file, checking for both .yml and .yaml extensions.
+
+    Args:
+        base_path: Base directory to search in. If None, uses current directory.
+
+    Returns:
+        Path to the config file.
+
+    Raises:
+        FileNotFoundError: If neither .infrahub.yml nor .infrahub.yaml exists.
+    """
+    if base_path is None:
+        base_path = Path()
+
+    yml_path = base_path / ".infrahub.yml"
+    yaml_path = base_path / ".infrahub.yaml"
+
+    # Prefer .yml if both exist
+    if yml_path.exists():
+        return yml_path
+    if yaml_path.exists():
+        return yaml_path
+    # For backward compatibility, return .yml path for error messages
+    return yml_path
+
+
 def get_repository_config(repo_config_file: Path) -> InfrahubRepositoryConfig:
+    # If the file doesn't exist, try to find it with alternate extension
+    if not repo_config_file.exists():
+        if repo_config_file.name == ".infrahub.yml":
+            alt_path = repo_config_file.parent / ".infrahub.yaml"
+            if alt_path.exists():
+                repo_config_file = alt_path
+        elif repo_config_file.name == ".infrahub.yaml":
+            alt_path = repo_config_file.parent / ".infrahub.yml"
+            if alt_path.exists():
+                repo_config_file = alt_path
+
     try:
         config_file_data = load_repository_config_file(repo_config_file)
     except FileNotFoundError as exc:
-        console.print(f"[red]File not found {exc}")
+        console.print(f"[red]File not found {exc} (also checked for .infrahub.yml and .infrahub.yaml)")
         raise typer.Exit(1) from exc
     except FileNotValidError as exc:
         console.print(f"[red]{exc.message}")

infrahub_sdk/ctl/schema.py

@@ -73,14 +73,29 @@ def display_schema_load_errors(response: dict[str, Any], schemas_data: list[Sche
             loc_type = loc_path[-1]
             input_str = error.get("input", None)
             error_message = f"{loc_type} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
         elif len(loc_path) > 6:
             loc_type = loc_path[5]
-            input_label = node[loc_type][loc_path[6]].get("name", None)
+            error_data = node[loc_type]
+            attribute = loc_path[6]
+
+            if isinstance(attribute, str):
+                input_label = None
+                for data in error_data:
+                    if data.get(attribute) is not None:
+                        input_label = data.get("name", None)
+                        break
+            else:
+                input_label = error_data[attribute].get("name", None)
+
             input_str = error.get("input", None)
             error_message = f"{loc_type[:-1].title()}: {input_label} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
 
 def handle_non_detail_errors(response: dict[str, Any]) -> None:

infrahub_sdk/ctl/utils.py

@@ -118,6 +118,10 @@ def execute_graphql_query(
     query_str = query_object.load_query()
 
     client = initialize_client_sync()
+
+    if not branch:
+        branch = client.config.default_infrahub_branch
+
     response = client.execute_graphql(
         query=query_str,
         branch_name=branch,

infrahub_sdk/ctl/validate.py

@@ -14,7 +14,7 @@ from ..ctl.client import initialize_client, initialize_client_sync
 from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.utils import catch_exception, find_graphql_query, parse_cli_vars
 from ..exceptions import GraphQLError
-from ..utils import get_branch, write_to_file
+from ..utils import write_to_file
 from ..yaml import SchemaFile
 from .parameters import CONFIG_PARAM
 from .utils import load_yamlfile_from_disk_and_exit
@@ -68,8 +68,6 @@ def validate_graphql(
 ) -> None:
     """Validate the format of a GraphQL Query stored locally by executing it on a remote GraphQL endpoint"""
 
-    branch = get_branch(branch)
-
     try:
         query_str = find_graphql_query(query)
     except QueryNotFoundError:
@@ -81,6 +79,10 @@ def validate_graphql(
     variables_dict = parse_cli_vars(variables)
 
     client = initialize_client_sync()
+
+    if not branch:
+        branch = client.config.default_infrahub_branch
+
     try:
         response = client.execute_graphql(
             query=query_str,

infrahub_sdk/diff.py

@@ -37,8 +37,8 @@ class NodeDiffPeer(TypedDict):
 
 def get_diff_summary_query() -> str:
     return """
-        query GetDiffTree($branch_name: String!) {
-            DiffTree(branch: $branch_name) {
+        query GetDiffTree($branch_name: String!, $name: String, $from_time: DateTime, $to_time: DateTime) {
+            DiffTree(branch: $branch_name, name: $name, from_time: $from_time, to_time: $to_time) {
                 nodes {
                     uuid
                     kind
@@ -117,12 +117,11 @@ def diff_tree_node_to_node_diff(node_dict: dict[str, Any], branch_name: str) ->
                     )
                 relationship_diff["peers"] = peer_diffs
             element_diffs.append(relationship_diff)
-    node_diff = NodeDiff(
+    return NodeDiff(
         branch=branch_name,
         kind=str(node_dict.get("kind")),
         id=str(node_dict.get("uuid")),
-        action=str(node_dict.get("action")),
+        action=str(node_dict.get("status")),
         display_label=str(node_dict.get("label")),
         elements=element_diffs,
     )
-    return node_diff

infrahub_sdk/exceptions.py

@@ -17,6 +17,8 @@ class JsonDecodeError(Error):
         self.url = url
         if not self.message and self.url:
             self.message = f"Unable to decode response as JSON data from {self.url}"
+            if self.content:
+                self.message += f". Server response: {self.content}"
         super().__init__(self.message)
 
 

infrahub_sdk/generator.py

@@ -26,6 +26,8 @@ class InfrahubGenerator(InfrahubOperation):
         generator_instance: str = "",
         params: dict | None = None,
         convert_query_response: bool = False,
+        execute_in_proposed_change: bool = True,
+        execute_after_merge: bool = True,
         logger: logging.Logger | None = None,
         request_context: RequestContext | None = None,
     ) -> None:
@@ -44,6 +46,8 @@ class InfrahubGenerator(InfrahubOperation):
         self._client: InfrahubClient | None = None
         self.logger = logger if logger else logging.getLogger("infrahub.tasks")
         self.request_context = request_context
+        self.execute_in_proposed_change = execute_in_proposed_change
+        self.execute_after_merge = execute_after_merge
 
     @property
     def subscribers(self) -> list[str] | None:
@@ -81,8 +85,10 @@ class InfrahubGenerator(InfrahubOperation):
         unpacked = data.get("data") or data
         await self.process_nodes(data=unpacked)
 
+        group_type = "CoreGeneratorGroup" if self.execute_after_merge else "CoreGeneratorAwareGroup"
+
         async with self._init_client.start_tracking(
-            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type="CoreGeneratorGroup"
+            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type=group_type
         ) as self.client:
             await self.generate(data=unpacked)
 

infrahub_sdk/graphql/__init__.py

@@ -0,0 +1,12 @@
+from .constants import VARIABLE_TYPE_MAPPING
+from .query import Mutation, Query
+from .renderers import render_input_block, render_query_block, render_variables_to_string
+
+__all__ = [
+    "VARIABLE_TYPE_MAPPING",
+    "Mutation",
+    "Query",
+    "render_input_block",
+    "render_query_block",
+    "render_variables_to_string",
+]

infrahub_sdk/graphql/constants.py

@@ -0,0 +1 @@
+VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))