infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/graphql/schema.py

@@ -19,7 +19,9 @@ from .mutations.computed_attribute import RecomputeComputedAttribute, UpdateComp
 from .mutations.convert_object_type import ConvertObjectType
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
+from .mutations.display_label import UpdateDisplayLabel
 from .mutations.generator import GeneratorDefinitionRequestRun
+from .mutations.hfid import UpdateHFID
 from .mutations.profile import InfrahubProfilesRefresh
 from .mutations.proposed_change import (
     ProposedChangeCheckForApprovalRevoke,
@@ -114,6 +116,8 @@ class InfrahubBaseMutation(ObjectType):
     InfrahubRepositoryProcess = ProcessRepository.Field()
     InfrahubRepositoryConnectivity = ValidateRepositoryConnectivity.Field()
     InfrahubUpdateComputedAttribute = UpdateComputedAttribute.Field()
+    InfrahubUpdateDisplayLabel = UpdateDisplayLabel.Field()
+    InfrahubUpdateHFID = UpdateHFID.Field()
     InfrahubRecomputeComputedAttribute = RecomputeComputedAttribute.Field()
 
     RelationshipAdd = RelationshipAdd.Field()

infrahub/groups/tasks.py

@@ -20,7 +20,7 @@ async def update_graphql_query_group(model: RequestGraphQLQueryGroupUpdate) -> N
     if len(model.subscribers) == 1:
         related_nodes.append(model.subscribers[0])
 
-    await add_tags(branches=[model.branch], nodes=related_nodes)
+    await add_tags(branches=[model.branch], nodes=related_nodes, namespace=False)
 
     params_hash = dict_hash(model.params)
     group_name = f"{model.query_name}__{params_hash}"

infrahub/hfid/gather.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from prefect import task
+from prefect.cache_policies import NONE
+from prefect.logging import get_run_logger
+
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+
+from .models import HFIDTriggerDefinition
+
+
+@dataclass
+class BranchScope:
+    name: str
+    out_of_scope: list[str] = field(default_factory=list)
+
+
+@task(
+    name="gather-trigger-hfid",
+    cache_policy=NONE,
+)
+async def gather_trigger_hfid(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[HFIDTriggerDefinition]:
+    log = get_run_logger()
+
+    # Build a list of all branches to process based on which branch is different from main
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+    branches_to_process: list[BranchScope] = [BranchScope(name=branch) for branch in branches_with_diff_from_main]
+    branches_to_process.append(BranchScope(name=registry.default_branch, out_of_scope=branches_with_diff_from_main))
+
+    triggers: list[HFIDTriggerDefinition] = []
+
+    for branch in branches_to_process:
+        schema_branch = registry.schema.get_schema_branch(name=branch.name)
+        branch_triggers = HFIDTriggerDefinition.from_schema_hfids(
+            branch=branch.name,
+            hfids=schema_branch.hfids,
+            branches_out_of_scope=branch.out_of_scope,
+        )
+        log.info(f"Generating {len(branch_triggers)} HFID trigger for {branch.name} (except {branch.out_of_scope})")
+
+        triggers.extend(branch_triggers)
+
+    return triggers

infrahub/hfid/models.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+from infrahub_sdk.graphql import Query
+from pydantic import BaseModel, Field
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.registry import registry
+from infrahub.core.schema import NodeSchema  # noqa: TC001
+from infrahub.events import NodeUpdatedEvent
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import (
+    EventTrigger,
+    ExecuteWorkflow,
+    TriggerBranchDefinition,
+    TriggerType,
+)
+from infrahub.workflows.catalogue import HFID_PROCESS
+
+if TYPE_CHECKING:
+    from infrahub.core.schema.schema_branch_hfid import HFIDs, RelationshipTriggers
+
+
+@dataclass
+class AttributeTarget:
+    hash: str
+    fields: set[str]
+
+
+class HFIDTriggerDefinition(TriggerBranchDefinition):
+    type: TriggerType = TriggerType.HUMAN_FRIENDLY_ID
+    hfid_hash: str
+    target_kind: str | None = Field(default=None)
+
+    def get_description(self) -> str:
+        return f"{super().get_description()} | hash:{self.hfid_hash}"
+
+    @classmethod
+    def from_schema_hfids(
+        cls,
+        branch: str,
+        hfids: HFIDs,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[HFIDTriggerDefinition]:
+        """
+        This function is used to create a trigger definition for a display labels of type Jinja2.
+        """
+
+        definitions: list[HFIDTriggerDefinition] = []
+
+        for node_kind, hfid_definition in hfids.get_template_nodes().items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=node_kind,
+                    target_kind=node_kind,
+                    fields=[
+                        "_trigger_placeholder"
+                    ],  # Triggers for the nodes themselves are only used to determine if all nodes should be regenerated
+                    hfid_hash=hfid_definition.get_hash(),
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        for related_kind, relationship_trigger in hfids.get_related_trigger_nodes().items():
+            definitions.extend(
+                cls.from_related_node(
+                    branch=branch,
+                    related_kind=related_kind,
+                    relationship_trigger=relationship_trigger,
+                    hfids=hfids,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def from_related_node(
+        cls,
+        branch: str,
+        related_kind: str,
+        relationship_trigger: RelationshipTriggers,
+        hfids: HFIDs,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[HFIDTriggerDefinition]:
+        targets_by_attribute: dict[str, AttributeTarget] = {}
+        definitions: list[HFIDTriggerDefinition] = []
+        for attribute, relationship_identifiers in relationship_trigger.attributes.items():
+            for relationship_identifier in relationship_identifiers:
+                actual_node = hfids.get_node_definition(kind=relationship_identifier.kind)
+                if relationship_identifier.kind not in targets_by_attribute:
+                    targets_by_attribute[relationship_identifier.kind] = AttributeTarget(
+                        actual_node.get_hash(), fields=set()
+                    )
+                targets_by_attribute[relationship_identifier.kind].fields.add(attribute)
+
+        for target_kind, attribute_target in targets_by_attribute.items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=related_kind,
+                    target_kind=target_kind,
+                    fields=sorted(attribute_target.fields),
+                    hfid_hash=attribute_target.hash,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def new(
+        cls,
+        branch: str,
+        node_kind: str,
+        target_kind: str,
+        hfid_hash: str,
+        fields: list[str],
+        branches_out_of_scope: list[str] | None = None,
+    ) -> Self:
+        event_trigger = EventTrigger()
+        event_trigger.events.add(NodeUpdatedEvent.event_name)
+        event_trigger.match = {"infrahub.node.kind": node_kind}
+        if branches_out_of_scope:
+            event_trigger.match["infrahub.branch.name"] = [f"!{branch}" for branch in branches_out_of_scope]
+        elif not branches_out_of_scope and branch != registry.default_branch:
+            event_trigger.match["infrahub.branch.name"] = branch
+
+        event_trigger.match_related = {
+            "prefect.resource.role": ["infrahub.node.attribute_update", "infrahub.node.relationship_update"],
+            "infrahub.field.name": fields,
+        }
+
+        workflow = ExecuteWorkflow(
+            workflow=HFID_PROCESS,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "node_kind": node_kind,
+                "object_id": "{{ event.resource['infrahub.node.id'] }}",
+                "target_kind": target_kind,
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {
+                        "__prefect_kind": "jinja",
+                        "template": "{{ event.payload['context'] | tojson }}",
+                    },
+                },
+            },
+        )
+
+        trigger_definition_target_kind = target_kind if target_kind == node_kind else None
+
+        return cls(
+            name=f"{target_kind}{NAME_SEPARATOR}by{NAME_SEPARATOR}{node_kind}",
+            hfid_hash=hfid_hash,
+            branch=branch,
+            trigger=event_trigger,
+            actions=[workflow],
+            target_kind=trigger_definition_target_kind,
+        )
+
+
+class HFIDGraphQLResponse(BaseModel):
+    node_id: str
+    hfid_value: list[str] | None = Field(default=None)
+    variables: dict[str, str] = Field(default_factory=dict)
+
+
+class HFIDGraphQL(BaseModel):
+    filter_key: str
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields["hfid"] = None
+        query = Query(
+            name="HFIDFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {self.filter_key: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[HFIDGraphQLResponse]:
+        rendered_response: list[HFIDGraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> HFIDGraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        hfid = node.get("hfid")
+        response = HFIDGraphQLResponse(node_id=node_id, hfid_value=hfid)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            # response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = str(field_content.get(remainder, ""))
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = str(related_attribute_content.get(related_value, ""))
+
+        return response

infrahub/hfid/tasks.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from typing import cast
+
+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 HFID_PROCESS, TRIGGER_UPDATE_HFID
+from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
+
+from .gather import gather_trigger_hfid
+from .models import HFIDGraphQL, HFIDGraphQLResponse, HFIDTriggerDefinition
+
+UPDATE_HFID = """
+mutation UpdateHFID(
+    $id: String!,
+    $kind: String!,
+    $value: [String!]!
+  ) {
+  InfrahubUpdateHFID(
+    data: {id: $id, value: $value, kind: $kind}
+  ) {
+    ok
+  }
+}
+"""
+
+
+@flow(
+    name="hfid-update-value",
+    flow_run_name="Update value for hfid on {node_kind}",
+)
+async def hfid_update_value(
+    branch_name: str,
+    obj: HFIDGraphQLResponse,
+    node_kind: str,
+    hfid_definition: list[str],
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    rendered_hfid: list[str] = []
+    for hfid_component in hfid_definition:
+        if hfid_component in obj.variables:
+            rendered_hfid.append(obj.variables[hfid_component])
+    # value = await template.render(variables=obj.variables)
+    if rendered_hfid == obj.hfid_value:
+        log.debug(f"Ignoring to update {obj} with existing value on human_friendly_id={obj.hfid_value}")
+        return
+
+    await client.execute_graphql(
+        query=UPDATE_HFID,
+        variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
+        branch_name=branch_name,
+    )
+    log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
+
+
+@flow(
+    name="hfid-process",
+    flow_run_name="Process human friendly ids for {target_kind}",
+)
+async def process_hfid(
+    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:
+        hfid_definition = schema_branch.hfids.get_node_definition(kind=node_kind)
+    else:
+        hfid_definition = schema_branch.hfids.get_related_definition(related_kind=node_kind, target_kind=target_kind)
+
+    # jinja_template = Jinja2Template(template=display_label_template.template)
+    # variables = jinja_template.get_variables()
+    hfid_graphql = HFIDGraphQL(
+        node_schema=node_schema, variables=hfid_definition.hfid, filter_key=hfid_definition.filter_key
+    )
+
+    query = hfid_graphql.render_graphql_query(filter_id=object_id)
+    response = await client.execute_graphql(query=query, branch_name=branch_name)
+    update_candidates = hfid_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=hfid_update_value,
+            branch_name=branch_name,
+            obj=node,
+            node_kind=node_schema.kind,
+            hfid_definition=hfid_definition.hfid,
+        )
+
+    _ = [response async for _, response in batch.execute()]
+
+
+@flow(name="hfid-setup", flow_run_name="Setup human friendly ids in task-manager")
+async def hfid_setup(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_hfid, trigger_type=TriggerType.HUMAN_FRIENDLY_ID
+        )  # type: ignore[misc]
+
+        # Configure all DisplayLabelTriggerDefinitions in Prefect
+        hfid_reports = [cast(HFIDTriggerDefinition, entry) for entry in report.updated + report.created]
+        direct_target_triggers = [hfid_report for hfid_report in hfid_reports if hfid_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_HFID,
+                    context=context,
+                    parameters={
+                        "branch_name": display_report.branch,
+                        "kind": display_report.target_kind,
+                    },
+                )
+
+        log.info(f"{report.in_use_count} HFID automation configurations completed")
+
+
+@flow(
+    name="trigger-update-hfid",
+    flow_run_name="Trigger updates for display labels for kind",
+)
+async def trigger_update_hfid(
+    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=HFID_PROCESS,
+            context=context,
+            parameters={
+                "branch_name": branch_name,
+                "node_kind": kind,
+                "target_kind": kind,
+                "object_id": node.id,
+                "context": context,
+            },
+        )

infrahub/hfid/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 HFID_SETUP
+
+TRIGGER_HFID_ALL_SCHEMA = BuiltinTriggerDefinition(
+    name="hfid-setup-all",
+    trigger=EventTrigger(events={SchemaUpdatedEvent.event_name, BranchDeletedEvent.event_name}),
+    actions=[
+        ExecuteWorkflow(
+            workflow=HFID_SETUP,
+            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/lock.py

@@ -98,10 +98,10 @@ class NATSLock:
         while True:
             if await self.do_acquire(token):
                 self.token = token
-                return True
+                return
             await sleep(0.1)  # default Redis GlobalLock value
 
-    async def do_acquire(self, token: str) -> bool:
+    async def do_acquire(self, token: str) -> bool | None:
         return await self.service.cache.set(key=self.name, value=token, not_exists=True)
 
     async def release(self) -> None:
@@ -124,14 +124,14 @@ class InfrahubLock:
         local: bool | None = None,
         in_multi: bool = False,
     ) -> None:
-        self.use_local: bool = local
+        self.use_local: bool | None = local
         self.local: LocalLock = None
         self.remote: GlobalLock = None
         self.name: str = name
         self.connection: redis.Redis | None = connection
         self.in_multi: bool = in_multi
         self.lock_type: str = "multi" if self.in_multi else "individual"
-        self.acquire_time: int | None = None
+        self._acquire_time: int | None = None
         self.event = asyncio.Event()
 
         if not self.connection or (self.use_local is None and name.startswith("local.")):
@@ -144,6 +144,17 @@ class InfrahubLock:
         else:
             self.remote = NATSLock(service=self.connection, name=f"{LOCK_PREFIX}.{self.name}")
 
+    @property
+    def acquire_time(self) -> int:
+        if self._acquire_time is not None:
+            return self._acquire_time
+
+        raise ValueError("The lock has not been initialized")
+
+    @acquire_time.setter
+    def acquire_time(self, value: int) -> None:
+        self._acquire_time = value
+
     async def __aenter__(self):
         await self.acquire()
 

infrahub/middleware.py

@@ -1,7 +1,8 @@
 from typing import Any
 
+from fastapi.middleware.gzip import GZipMiddleware
 from starlette.middleware.cors import CORSMiddleware
-from starlette.types import ASGIApp
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from infrahub import config
 
@@ -15,3 +16,27 @@ class InfrahubCORSMiddleware(CORSMiddleware):
         kwargs["allow_headers"] = config.SETTINGS.api.cors_allow_headers
 
         super().__init__(app, *args, **kwargs)
+
+
+class ConditionalGZipMiddleware(GZipMiddleware):
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        minimum_size: int = 500,
+        compresslevel: int = 9,
+        include_paths: tuple[str, ...] = (),
+    ) -> None:
+        super().__init__(app, minimum_size=minimum_size, compresslevel=compresslevel)
+        self.include_paths = include_paths
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:  # type: ignore[override]
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+        if any(path.startswith(include) for include in self.include_paths):
+            await super().__call__(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)

infrahub/proposed_change/tasks.py

@@ -307,6 +307,7 @@ async def run_generators(model: RequestProposedChangeRunGenerators, context: Inf
         populate_store=True,
         branch=model.source_branch,
     )
+
     generator_definitions = [
         ProposedChangeGeneratorDefinition(
             definition_id=generator.id,
@@ -319,8 +320,11 @@ async def run_generators(model: RequestProposedChangeRunGenerators, context: Inf
             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
+        if generator.execute_in_proposed_change.value
     ]
 
     diff_summary = await get_diff_summary_cache(pipeline_id=model.branch_diff.pipeline_id)
@@ -760,6 +764,8 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
         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)
@@ -786,6 +792,8 @@ async def run_generator_as_check(model: RunGeneratorAsCheckModel, context: Infra
             params=model.variables,
             generator_instance=generator_instance.id,
             convert_query_response=generator_definition.convert_query_response,
+            execute_after_merge=generator_definition.execute_after_merge,
+            execute_in_proposed_change=generator_definition.execute_in_proposed_change,
             infrahub_node=InfrahubNode,
         )
         generator._init_client.request_context = context.to_request_context()
@@ -934,7 +942,7 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
     requested_instances = 0
     impacted_instances = model.branch_diff.get_subscribers_ids(kind=InfrahubKind.GENERATORINSTANCE)
 
-    check_generator_run_models = []
+    check_generator_run_models: list[RunGeneratorAsCheckModel] = []
     for relationship in group.members.peers:
         member = relationship.peer
         generator_instance = instance_by_member.get(member.id)
@@ -970,6 +978,7 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
             context=context,
         )
         for check_generator_run_model in check_generator_run_models
+        if check_generator_run_model.generator_definition.execute_in_proposed_change
     ]
 
     await run_checks_and_update_validator(