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

infrahub/display_labels/tasks.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from typing import cast
+
+from infrahub_sdk.template import Jinja2Template
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.registry import registry
+from infrahub.events import BranchDeletedEvent
+from infrahub.trigger.models import TriggerSetupReport, TriggerType
+from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_component, get_database, get_workflow
+from infrahub.workflows.catalogue import DISPLAY_LABELS_PROCESS_JINJA2, TRIGGER_UPDATE_DISPLAY_LABELS
+from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
+
+from .gather import gather_trigger_display_labels_jinja2
+from .models import DisplayLabelJinja2GraphQL, DisplayLabelJinja2GraphQLResponse, DisplayLabelTriggerDefinition
+
+UPDATE_DISPLAY_LABEL = """
+mutation UpdateDisplayLabel(
+    $id: String!,
+    $kind: String!,
+    $value: String!
+  ) {
+  InfrahubUpdateDisplayLabel(
+    data: {id: $id, value: $value, kind: $kind}
+  ) {
+    ok
+  }
+}
+"""
+
+
+@flow(
+    name="display-label-jinja2-update-value",
+    flow_run_name="Update value for display_label on {node_kind}",
+)
+async def display_label_jinja2_update_value(
+    branch_name: str,
+    obj: DisplayLabelJinja2GraphQLResponse,
+    node_kind: str,
+    template: Jinja2Template,
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    value = await template.render(variables=obj.variables)
+    if value == obj.display_label_value:
+        log.debug(f"Ignoring to update {obj} with existing value on display_label={value}")
+        return
+
+    await client.execute_graphql(
+        query=UPDATE_DISPLAY_LABEL,
+        variables={"id": obj.node_id, "kind": node_kind, "value": value},
+        branch_name=branch_name,
+    )
+    log.info(f"Updating {node_kind}.display_label='{value}' ({obj.node_id})")
+
+
+@flow(
+    name="display-label-process-jinja2",
+    flow_run_name="Process display_labels for {target_kind}",
+)
+async def process_display_label(
+    branch_name: str,
+    node_kind: str,
+    object_id: str,
+    target_kind: str,
+    context: InfrahubContext,  # noqa: ARG001
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name])
+
+    target_schema = branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
+    schema_branch = registry.schema.get_schema_branch(name=target_schema)
+    node_schema = schema_branch.get_node(name=target_kind, duplicate=False)
+
+    if node_kind == target_kind:
+        display_label_template = schema_branch.display_labels.get_template_node(kind=node_kind)
+    else:
+        display_label_template = schema_branch.display_labels.get_related_template(
+            related_kind=node_kind, target_kind=target_kind
+        )
+
+    jinja_template = Jinja2Template(template=display_label_template.template)
+    variables = jinja_template.get_variables()
+    display_label_graphql = DisplayLabelJinja2GraphQL(
+        node_schema=node_schema, variables=variables, filter_key=display_label_template.filter_key
+    )
+
+    query = display_label_graphql.render_graphql_query(filter_id=object_id)
+    response = await client.execute_graphql(query=query, branch_name=branch_name)
+    update_candidates = display_label_graphql.parse_response(response=response)
+
+    if not update_candidates:
+        log.debug("No nodes found that requires updates")
+        return
+
+    batch = await client.create_batch()
+    for node in update_candidates:
+        batch.add(
+            task=display_label_jinja2_update_value,
+            branch_name=branch_name,
+            obj=node,
+            node_kind=node_schema.kind,
+            template=jinja_template,
+        )
+
+    _ = [response async for _, response in batch.execute()]
+
+
+@flow(name="display-labels-setup-jinja2", flow_run_name="Setup display labels in task-manager")
+async def display_labels_setup_jinja2(
+    context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None
+) -> None:
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
+
+        report: TriggerSetupReport = await setup_triggers_specific(
+            gatherer=gather_trigger_display_labels_jinja2, trigger_type=TriggerType.DISPLAY_LABEL_JINJA2
+        )  # type: ignore[misc]
+
+        # Configure all DisplayLabelTriggerDefinitions in Prefect
+        display_reports = [cast(DisplayLabelTriggerDefinition, entry) for entry in report.updated + report.created]
+        direct_target_triggers = [display_report for display_report in display_reports if display_report.target_kind]
+
+        for display_report in direct_target_triggers:
+            if event_name != BranchDeletedEvent.event_name and display_report.branch == branch_name:
+                await get_workflow().submit_workflow(
+                    workflow=TRIGGER_UPDATE_DISPLAY_LABELS,
+                    context=context,
+                    parameters={
+                        "branch_name": display_report.branch,
+                        "kind": display_report.target_kind,
+                    },
+                )
+
+        log.info(f"{report.in_use_count} Display labels for Jinja2 automation configuration completed")
+
+
+@flow(
+    name="trigger-update-display-labels",
+    flow_run_name="Trigger updates for display labels for kind",
+)
+async def trigger_update_display_labels(
+    branch_name: str,
+    kind: str,
+    context: InfrahubContext,
+) -> None:
+    await add_tags(branches=[branch_name])
+
+    client = get_client()
+
+    # NOTE we only need the id of the nodes, this query will still query for the HFID
+    node_schema = registry.schema.get_node_schema(name=kind, branch=branch_name)
+    nodes = await client.all(
+        kind=kind,
+        branch=branch_name,
+        exclude=node_schema.attribute_names + node_schema.relationship_names,
+        populate_store=False,
+    )
+
+    for node in nodes:
+        await get_workflow().submit_workflow(
+            workflow=DISPLAY_LABELS_PROCESS_JINJA2,
+            context=context,
+            parameters={
+                "branch_name": branch_name,
+                "node_kind": kind,
+                "target_kind": kind,
+                "object_id": node.id,
+                "context": context,
+            },
+        )

infrahub/display_labels/triggers.py

@@ -0,0 +1,22 @@
+from infrahub.events.branch_action import BranchDeletedEvent
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import DISPLAY_LABELS_SETUP_JINJA2
+
+TRIGGER_DISPLAY_LABELS_ALL_SCHEMA = BuiltinTriggerDefinition(
+    name="display-labels-setup-all",
+    trigger=EventTrigger(events={SchemaUpdatedEvent.event_name, BranchDeletedEvent.event_name}),
+    actions=[
+        ExecuteWorkflow(
+            workflow=DISPLAY_LABELS_SETUP_JINJA2,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "event_name": "{{ event.event }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/events/group_action.py

@@ -22,7 +22,7 @@ class GroupMutatedEvent(InfrahubEvent):
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
 
-        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GENERATORAWAREGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
             # Temporary workaround to avoid too large payloads for the related field
             return related
 

infrahub/events/node_action.py

@@ -24,7 +24,7 @@ class NodeMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
-        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GENERATORAWAREGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
             # Temporary workaround to avoid too large payloads for the related field
             return related
 

infrahub/generators/constants.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class GeneratorDefinitionRunSource(Enum):
+    PROPOSED_CHANGE = "proposed_change"
+    MERGE = "merge"
+    UNKNOWN = "unknown"

infrahub/generators/models.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field
 class RequestGeneratorRun(BaseModel):
     """Runs a generator."""
 
-    generator_definition: ProposedChangeGeneratorDefinition = Field(..., description="The Generator definition")
+    generator_definition: GeneratorDefinitionModel = Field(..., description="The Generator definition")
     generator_instance: str | None = Field(
         default=None, description="The id of the generator instance if it previously existed"
     )
@@ -31,14 +31,40 @@ class RequestGeneratorDefinitionRun(BaseModel):
     target_members: list[str] = Field(default_factory=list, description="List of targets to run the generator for")
 
 
-class ProposedChangeGeneratorDefinition(BaseModel):
-    definition_id: str
-    definition_name: str
-    query_name: str
-    convert_query_response: bool
-    query_models: list[str]
-    repository_id: str
-    class_name: str
-    file_path: str
-    parameters: dict
-    group_id: str
+class GeneratorDefinitionModel(BaseModel):
+    definition_id: str = Field(..., description="The id of the generator definition.")
+    definition_name: str = Field(..., description="The name of the generator definition.")
+    query_name: str = Field(..., description="The name of the query to use when collecting data.")
+    convert_query_response: bool = Field(
+        ...,
+        description="Decide if the generator should convert the result of the GraphQL query to SDK InfrahubNode objects.",
+    )
+    class_name: str = Field(..., description="The name of the generator class to run.")
+    file_path: str = Field(..., description="The file path of the generator in the repository.")
+    group_id: str = Field(..., description="The group to target when running this generator")
+    parameters: dict = Field(..., description="The input parameters required to run this check")
+
+    execute_in_proposed_change: bool = Field(
+        ..., description="Indicates if the generator should execute in a proposed change."
+    )
+    execute_after_merge: bool = Field(..., description="Indicates if the generator should execute after a merge.")
+
+    @classmethod
+    def from_pc_generator_definition(cls, model: ProposedChangeGeneratorDefinition) -> GeneratorDefinitionModel:
+        return GeneratorDefinitionModel(
+            definition_id=model.definition_id,
+            definition_name=model.definition_name,
+            query_name=model.query_name,
+            convert_query_response=model.convert_query_response,
+            class_name=model.class_name,
+            file_path=model.file_path,
+            group_id=model.group_id,
+            parameters=model.parameters,
+            execute_in_proposed_change=model.execute_in_proposed_change,
+            execute_after_merge=model.execute_after_merge,
+        )
+
+
+class ProposedChangeGeneratorDefinition(GeneratorDefinitionModel):
+    query_models: list[str] = Field(..., description="The models to use when collecting data.")
+    repository_id: str = Field(..., description="The id of the repository.")

infrahub/generators/tasks.py

@@ -14,7 +14,9 @@ from prefect.states import Completed, Failed
 from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001 needed for prefect flow
 from infrahub.core.constants import GeneratorInstanceStatus, InfrahubKind
+from infrahub.generators.constants import GeneratorDefinitionRunSource
 from infrahub.generators.models import (
+    GeneratorDefinitionModel,
     ProposedChangeGeneratorDefinition,
     RequestGeneratorDefinitionRun,
     RequestGeneratorRun,
@@ -52,9 +54,12 @@ async def run_generator(model: RequestGeneratorRun) -> None:
         name=model.generator_definition.definition_name,
         class_name=model.generator_definition.class_name,
         file_path=model.generator_definition.file_path,
+        parameters=model.generator_definition.parameters,
         query=model.generator_definition.query_name,
         targets=model.generator_definition.group_id,
         convert_query_response=model.generator_definition.convert_query_response,
+        execute_in_proposed_change=model.generator_definition.execute_in_proposed_change,
+        execute_after_merge=model.generator_definition.execute_after_merge,
     )
 
     commit_worktree = repository.get_commit_worktree(commit=model.commit)
@@ -78,6 +83,8 @@ async def run_generator(model: RequestGeneratorRun) -> None:
             params=model.variables,
             generator_instance=generator_instance.id,
             convert_query_response=generator_definition.convert_query_response,
+            execute_in_proposed_change=generator_definition.execute_in_proposed_change,
+            execute_after_merge=generator_definition.execute_after_merge,
             infrahub_node=InfrahubNode,
         )
         await generator.run(identifier=generator_definition.name)
@@ -127,28 +134,39 @@ async def _define_instance(model: RequestGeneratorRun, client: InfrahubClient) -
 
 
 @flow(name="generator-definition-run", flow_run_name="Run all generators")
-async def run_generator_definition(branch: str, context: InfrahubContext) -> None:
+async def run_generator_definition(
+    branch: str, context: InfrahubContext, source: GeneratorDefinitionRunSource = GeneratorDefinitionRunSource.UNKNOWN
+) -> None:
     await add_tags(branches=[branch])
 
     generators = await get_client().filters(
         kind=InfrahubKind.GENERATORDEFINITION, prefetch_relationships=True, populate_store=True, branch=branch
     )
 
-    generator_definitions = [
-        ProposedChangeGeneratorDefinition(
-            definition_id=generator.id,
-            definition_name=generator.name.value,
-            class_name=generator.class_name.value,
-            file_path=generator.file_path.value,
-            query_name=generator.query.peer.name.value,
-            query_models=generator.query.peer.models.value,
-            repository_id=generator.repository.peer.id,
-            parameters=generator.parameters.value,
-            group_id=generator.targets.peer.id,
-            convert_query_response=generator.convert_query_response.value,
+    generator_definitions: list[ProposedChangeGeneratorDefinition] = []
+
+    for generator in generators:
+        if (
+            source == GeneratorDefinitionRunSource.PROPOSED_CHANGE and not generator.execute_in_proposed_change.value
+        ) or (source == GeneratorDefinitionRunSource.MERGE and not generator.execute_after_merge.value):
+            continue
+
+        generator_definitions.append(
+            ProposedChangeGeneratorDefinition(
+                definition_id=generator.id,
+                definition_name=generator.name.value,
+                class_name=generator.class_name.value,
+                file_path=generator.file_path.value,
+                query_name=generator.query.peer.name.value,
+                query_models=generator.query.peer.models.value,
+                repository_id=generator.repository.peer.id,
+                parameters=generator.parameters.value,
+                group_id=generator.targets.peer.id,
+                convert_query_response=generator.convert_query_response.value,
+                execute_in_proposed_change=generator.execute_in_proposed_change.value,
+                execute_after_merge=generator.execute_after_merge.value,
+            )
         )
-        for generator in generators
-    ]
 
     for generator_definition in generator_definitions:
         model = RequestGeneratorDefinitionRun(branch=branch, generator_definition=generator_definition)
@@ -213,7 +231,7 @@ async def request_generator_definition_run(
 
         generator_instance = instance_by_member.get(member.id)
         request_generator_run_model = RequestGeneratorRun(
-            generator_definition=model.generator_definition,
+            generator_definition=GeneratorDefinitionModel.from_pc_generator_definition(model.generator_definition),
             commit=repository.commit.value,
             generator_instance=generator_instance,
             repository_id=repository.id,

infrahub/git/base.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, NoReturn
 from uuid import UUID  # noqa: TC003
 
 import git
-from git import Blob, Repo
+from git import BadName, Blob, Repo
 from git.exc import GitCommandError, InvalidGitRepositoryError
 from git.refs.remote import RemoteReference
 from infrahub_sdk import InfrahubClient  # noqa: TC002
@@ -67,6 +67,15 @@ class RepoFileInformation(BaseModel):
     """Extension of the file Example: py """
 
 
+class RepoChangedFiles(BaseModel):
+    added: list[str] = Field(default_factory=list)
+    copied: list[tuple[str, str]] = Field(default_factory=list)
+    deleted: list[str] = Field(default_factory=list)
+    renamed: list[tuple[str, str]] = Field(default_factory=list)
+    modified: list[str] = Field(default_factory=list)
+    type_changed: list[tuple[str, str]] = Field(default_factory=list)
+
+
 def extract_repo_file_information(
     full_filename: Path, repo_directory: Path, worktree_directory: Path | None = None
 ) -> RepoFileInformation:
@@ -970,3 +979,31 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         if branch_name == self.default_branch and branch_name != registry.default_branch:
             return registry.default_branch
         return branch_name
+
+    def get_changed_files(self, first_commit: str, second_commit: str | None = None) -> RepoChangedFiles:
+        """Return the changes between two commits in this repo."""
+        changes = RepoChangedFiles()
+        repo = self.get_git_repo_main()
+
+        try:
+            commit_a = repo.commit(first_commit)
+            commit_b = repo.commit(second_commit) if second_commit else repo.head.commit
+        except BadName as exc:
+            raise CommitNotFoundError(identifier=str(self.id), commit=exc.args[0]) from exc
+
+        for diff in commit_a.diff(commit_b):
+            match diff.change_type:
+                case "A":
+                    changes.added.append(diff.b_path)
+                case "C":
+                    changes.copied.append((diff.a_path, diff.b_path))
+                case "D":
+                    changes.deleted.append(diff.a_path)
+                case "R":
+                    changes.renamed.append((diff.a_path, diff.b_path))
+                case "M":
+                    changes.modified.append(diff.b_path)
+                case "T":
+                    changes.type_changed.append((diff.a_path, diff.b_path))
+
+        return changes

infrahub/git/integrator.py

@@ -226,7 +226,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             )
         )
 
-    @task(name="import-jinja2-tansforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-jinja2-transforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)
     async def import_jinja2_transforms(
         self,
         branch_name: str,
@@ -331,7 +331,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         await existing_transform.save()
 
-    @task(name="import-artifact-definitions", task_run_name="Import Artifact Definitions", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-artifact-definitions", task_run_name="Import Artifact Definitions", cache_policy=NONE)
     async def import_artifact_definitions(
         self,
         branch_name: str,
@@ -432,7 +432,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         await existing_artifact_definition.save()
 
-    @task(name="repository-get-config", task_run_name="get repository config", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="repository-get-config", task_run_name="get repository config", cache_policy=NONE)
     async def get_repository_config(self, branch_name: str, commit: str) -> InfrahubRepositoryConfig | None:
         branch_wt = self.get_worktree(identifier=commit or branch_name)
         log = get_run_logger()
@@ -469,7 +469,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             log.error(f"Unable to load the configuration file {config_file_name}, the format is not valid  : {exc}")
             return None
 
-    @task(name="import-schema-files", task_run_name="Import schema files", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-schema-files", task_run_name="Import schema files", cache_policy=NONE)
     async def import_schema_files(self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig) -> None:
         log = get_run_logger()
         branch_wt = self.get_worktree(identifier=commit or branch_name)
@@ -541,7 +541,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         for schema_file in schemas_data:
             log.info(f"schema '{schema_file.identifier}' loaded successfully!")
 
-    @task(name="import-graphql-queries", task_run_name="Import GraphQL Queries", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-graphql-queries", task_run_name="Import GraphQL Queries", cache_policy=NONE)
     async def import_all_graphql_query(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -599,7 +599,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         await obj.save()
         return obj
 
-    @task(name="import-python-check-definitions", task_run_name="Import Python Check Definitions", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-python-check-definitions", task_run_name="Import Python Check Definitions", cache_policy=NONE)
     async def import_python_check_definitions(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -670,7 +670,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             log.info(f"CheckDefinition '{check_name!r}' not found locally, deleting")
             await check_definition_in_graph[check_name].delete()
 
-    @task(name="import-generator-definitions", task_run_name="Import Generator Definitions", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-generator-definitions", task_run_name="Import Generator Definitions", cache_policy=NONE)
     async def import_generator_definitions(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -756,11 +756,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             or existing_generator.parameters.value != generator.parameters
             or existing_generator.convert_query_response.value != generator.convert_query_response
             or existing_generator.targets.id != generator.targets
+            or existing_generator.execute_in_proposed_change.value != generator.execute_in_proposed_change
+            or existing_generator.execute_after_merge.value != generator.execute_after_merge
         ):
             return True
         return False
 
-    @task(name="import-python-transforms", task_run_name="Import Python Transforms", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-python-transforms", task_run_name="Import Python Transforms", cache_policy=NONE)
     async def import_python_transforms(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -885,7 +887,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 file_type=file_type,
             )
 
-    @task(name="import-objects", task_run_name="Import Objects", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="import-objects", task_run_name="Import Objects", cache_policy=NONE)
     async def import_objects(
         self,
         branch_name: str,
@@ -905,7 +907,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             object_type=RepositoryObjects.MENU,
         )
 
-    @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)
     async def get_check_definition(
         self,
         branch_name: str,
@@ -945,7 +947,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             raise
         return checks
 
-    @task(name="python-transform-get", task_run_name="Get Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="python-transform-get", task_run_name="Get Python Transform", cache_policy=NONE)
     async def get_python_transforms(
         self, branch_name: str, module: types.ModuleType, file_path: str, transform: InfrahubPythonTransformConfig
     ) -> list[TransformPythonInformation]:
@@ -1023,6 +1025,12 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         if existing_generator.targets.id != generator.targets:
             existing_generator.targets = {"id": generator.targets, "source": str(self.id), "is_protected": True}
 
+        if existing_generator.execute_in_proposed_change.value != generator.execute_in_proposed_change:
+            existing_generator.execute_in_proposed_change.value = generator.execute_in_proposed_change
+
+        if existing_generator.execute_after_merge.value != generator.execute_after_merge:
+            existing_generator.execute_after_merge.value = generator.execute_after_merge
+
         await existing_generator.save()
 
     async def create_python_check_definition(
@@ -1152,7 +1160,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         await self.import_python_transforms(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
         await self.import_generator_definitions(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
 
-    @task(name="jinja2-template-render", task_run_name="Render Jinja2 template", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="jinja2-template-render", task_run_name="Render Jinja2 template", cache_policy=NONE)
     async def render_jinja2_template(self, commit: str, location: str, data: dict) -> str:
         log = get_run_logger()
         commit_worktree = self.get_commit_worktree(commit=commit)
@@ -1168,7 +1176,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 repository_name=self.name, commit=commit, location=location, message=exc.message
             ) from exc
 
-    @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)
     async def execute_python_check(
         self,
         branch_name: str,
@@ -1227,7 +1235,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 repository_name=self.name, class_name=class_name, commit=commit, location=location, message=str(exc)
             ) from exc
 
-    @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
+    @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)
     async def execute_python_transform(
         self,
         branch_name: str,

infrahub/graphql/analyzer.py

@@ -639,7 +639,7 @@ class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
         self, node: InlineFragmentNode, query_node: GraphQLQueryNode
     ) -> GraphQLQueryNode:
         context_type = query_node.context_type
-        infrahub_model = self.schema_branch.get(name=node.type_condition.name.value)
+        infrahub_model = self.schema_branch.get(name=node.type_condition.name.value, duplicate=False)
         context_type = ContextType.DIRECT
         current_node = GraphQLQueryNode(
             parent=query_node,

infrahub/graphql/api/dependencies.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from infrahub import config
 
 from ..app import InfrahubGraphQLApp
@@ -36,5 +34,5 @@ def build_graphql_query_permission_checker() -> GraphQLQueryPermissionChecker:
     )
 
 
-def build_graphql_app(**kwargs: Any) -> InfrahubGraphQLApp:
-    return InfrahubGraphQLApp(build_graphql_query_permission_checker(), **kwargs)
+def build_graphql_app() -> InfrahubGraphQLApp:
+    return InfrahubGraphQLApp(build_graphql_query_permission_checker())

infrahub/graphql/api/endpoints.py

@@ -9,7 +9,7 @@ from starlette.routing import Route, WebSocketRoute
 
 from infrahub.api.dependencies import get_branch_dep, get_current_user
 from infrahub.core import registry
-from infrahub.graphql.manager import GraphQLSchemaManager
+from infrahub.graphql.registry import registry as graphql_registry
 
 from .dependencies import build_graphql_app
 
@@ -32,6 +32,6 @@ async def get_graphql_schema(
     branch: Branch = Depends(get_branch_dep), _: AccountSession = Depends(get_current_user)
 ) -> PlainTextResponse:
     schema_branch = registry.schema.get_schema_branch(name=branch.name)
-    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
+    gqlm = graphql_registry.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
     graphql_schema = gqlm.get_graphql_schema()
     return PlainTextResponse(content=print_schema(graphql_schema))