infrahub-server 1.5.2__tar.gz → 1.5.4__tar.gz

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.5.2
+Version: 1.5.4
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: Apache-2.0
 Author: OpsMill

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/computed_attribute/models.py

@@ -119,6 +119,12 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
     type: TriggerType = TriggerType.COMPUTED_ATTR_JINJA2
     computed_attribute: ComputedAttributeTarget
     template_hash: str
+    trigger_kind: str
+
+    @property
+    def targets_self(self) -> bool:
+        """Determine if the specific trigger definition targets the actual node kind of the computed attribute."""
+        return self.trigger_kind == self.computed_attribute.kind
 
     def get_description(self) -> str:
         return f"{super().get_description()} | hash:{self.template_hash}"
@@ -190,6 +196,7 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
         definition = cls(
             name=f"{computed_attribute.key_name}{NAME_SEPARATOR}kind{NAME_SEPARATOR}{trigger_node.kind}",
             template_hash=template_hash,
+            trigger_kind=trigger_node.kind,
             branch=branch,
             computed_attribute=computed_attribute,
             trigger=event_trigger,

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/computed_attribute/tasks.py

@@ -29,6 +29,7 @@ from .gather import gather_trigger_computed_attribute_jinja2, gather_trigger_com
 from .models import (
     ComputedAttrJinja2GraphQL,
     ComputedAttrJinja2GraphQLResponse,
+    ComputedAttrJinja2TriggerDefinition,
     PythonTransformTarget,
 )
 
@@ -312,21 +313,46 @@ async def computed_attribute_setup_jinja2(
         )  # type: ignore[misc]
         # Configure all ComputedAttrJinja2Trigger in Prefect
 
+        all_triggers = report.triggers_with_type(trigger_type=ComputedAttrJinja2TriggerDefinition)
+
         # Since we can have multiple trigger per NodeKind
-        # we need to extract the list of unique node that should be processed
-        unique_nodes: set[tuple[str, str, str]] = {
-            (trigger.branch, trigger.computed_attribute.kind, trigger.computed_attribute.attribute.name)  # type: ignore[attr-defined]
-            for trigger in report.updated + report.created
-        }
-        for branch, kind, attribute_name in unique_nodes:
-            if event_name != BranchDeletedEvent.event_name and branch == branch_name:
+        # we need to extract the list of unique node that should be processed, this is done by filtering the triggers that targets_self
+        modified_triggers = [
+            trigger
+            for trigger in report.modified_triggers_with_type(trigger_type=ComputedAttrJinja2TriggerDefinition)
+            if trigger.targets_self
+        ]
+
+        for modified_trigger in modified_triggers:
+            if event_name != BranchDeletedEvent.event_name and modified_trigger.branch == branch_name:
+                if branch_name != registry.default_branch:
+                    default_branch_triggers = [
+                        trigger
+                        for trigger in all_triggers
+                        if trigger.branch == registry.default_branch
+                        and trigger.targets_self
+                        and trigger.computed_attribute.kind == modified_trigger.computed_attribute.kind
+                        and trigger.computed_attribute.attribute.name
+                        == modified_trigger.computed_attribute.attribute.name
+                    ]
+                    if (
+                        default_branch_triggers
+                        and len(default_branch_triggers) == 1
+                        and default_branch_triggers[0].template_hash == modified_trigger.template_hash
+                    ):
+                        log.debug(
+                            f"Skipping computed attribute updates for {modified_trigger.computed_attribute.kind}."
+                            f"{modified_trigger.computed_attribute.attribute.name} [{branch_name}], schema is identical to default branch"
+                        )
+                        continue
+
                 await get_workflow().submit_workflow(
                     workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
                     context=context,
                     parameters={
-                        "branch_name": branch,
-                        "computed_attribute_name": attribute_name,
-                        "computed_attribute_kind": kind,
+                        "branch_name": modified_trigger.branch,
+                        "computed_attribute_name": modified_trigger.computed_attribute.attribute.name,
+                        "computed_attribute_kind": modified_trigger.computed_attribute.kind,
                     },
                 )
 

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/config.py

@@ -402,6 +402,11 @@ class WorkflowSettings(BaseSettings):
     worker_polling_interval: int = Field(
         default=2, ge=1, le=30, description="Specify how often the worker should poll the server for tasks (sec)"
     )
+    flow_run_count_cache_threshold: int = Field(
+        default=100_000,
+        ge=0,
+        description="Threshold for caching flow run counts (0 to always cache, higher values to disable)",
+    )
 
     @property
     def api_endpoint(self) -> str:

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/attribute.py

@@ -336,7 +336,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         delete_at = Timestamp(at)
 
-        query = await AttributeGetQuery.init(db=db, attr=self)
+        query = await AttributeGetQuery.init(db=db, attr=self, at=delete_at)
         await query.execute(db=db)
         results = query.get_results()
 

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/branch/models.py

@@ -339,7 +339,7 @@ class Branch(StandardNode):
         at = Timestamp(at)
         at_str = at.to_string()
         if branch_agnostic:
-            filter_str = f"{variable_name}.from <= ${pp}time1 AND ({variable_name}.to IS NULL or {variable_name}.to >= ${pp}time1)"
+            filter_str = f"{variable_name}.from < ${pp}time1 AND ({variable_name}.to IS NULL or {variable_name}.to >= ${pp}time1)"
             params[f"{pp}time1"] = at_str
             return filter_str, params
 
@@ -352,10 +352,13 @@ class Branch(StandardNode):
         filters = []
         for idx in range(len(branches_times)):
             filters.append(
-                f"({variable_name}.branch IN ${pp}branch{idx} AND {variable_name}.from <= ${pp}time{idx} AND {variable_name}.to IS NULL)"
+                f"({variable_name}.branch IN ${pp}branch{idx} "
+                f"AND {variable_name}.from < ${pp}time{idx} AND {variable_name}.to IS NULL)"
             )
             filters.append(
-                f"({variable_name}.branch IN ${pp}branch{idx} AND {variable_name}.from <= ${pp}time{idx} AND {variable_name}.to >= ${pp}time{idx})"
+                f"({variable_name}.branch IN ${pp}branch{idx} "
+                f"AND {variable_name}.from < ${pp}time{idx} "
+                f"AND {variable_name}.to >= ${pp}time{idx})"
             )
 
         filter_str = "(" + "\n OR ".join(filters) + ")"

infrahub_server-1.5.4/backend/infrahub/core/graph/__init__.py

@@ -0,0 +1 @@
+GRAPH_VERSION = 46

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/migrations/graph/__init__.py

@@ -47,6 +47,7 @@ from .m042_profile_attrs_in_db import Migration042
 from .m043_create_hfid_display_label_in_db import Migration043
 from .m044_backfill_hfid_display_label_in_db import Migration044
 from .m045_backfill_hfid_display_label_in_db_profile_template import Migration045
+from .m046_fill_agnostic_hfid_display_labels import Migration046
 
 if TYPE_CHECKING:
     from ..shared import MigrationTypes
@@ -98,6 +99,7 @@ MIGRATIONS: list[type[MigrationTypes]] = [
     Migration043,
     Migration044,
     Migration045,
+    Migration046,
 ]
 
 

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/migrations/graph/m043_create_hfid_display_label_in_db.py

@@ -6,7 +6,7 @@ from rich.progress import Progress
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.constants import SchemaPathType
+from infrahub.core.constants import BranchSupportType, SchemaPathType
 from infrahub.core.initialization import get_root_node
 from infrahub.core.migrations.schema.node_attribute_add import NodeAttributeAddMigration
 from infrahub.core.migrations.shared import MigrationRequiringRebase, MigrationResult, get_migration_console
@@ -78,6 +78,8 @@ class Migration043(MigrationRequiringRebase):
 
         for node_schema_kind in main_schema_branch.node_names:
             schema = main_schema_branch.get(name=node_schema_kind, duplicate=False)
+            if schema.branch is not BranchSupportType.AWARE:
+                continue
             migrations.extend(
                 [
                     NodeAttributeAddMigration(
@@ -123,6 +125,8 @@ class Migration043(MigrationRequiringRebase):
 
         for node_kind, node_ids in node_ids_by_kind.items():
             schema = schema_branch.get(name=node_kind, duplicate=False)
+            if schema.branch not in (BranchSupportType.AWARE, BranchSupportType.LOCAL):
+                continue
             migrations.extend(
                 [
                     NodeAttributeAddMigration(

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/migrations/graph/m044_backfill_hfid_display_label_in_db.py

@@ -40,18 +40,23 @@ class DefaultBranchNodeCount(Query):
     name = "get_branch_node_count"
     type = QueryType.READ
 
-    def __init__(self, kinds_to_skip: list[str], **kwargs: Any) -> None:
+    def __init__(
+        self, kinds_to_skip: list[str] | None = None, kinds_to_include: list[str] | None = None, **kwargs: Any
+    ) -> None:
         super().__init__(**kwargs)
-        self.kinds_to_skip = kinds_to_skip
+        self.kinds_to_skip = kinds_to_skip or []
+        self.kinds_to_include = kinds_to_include
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         self.params = {
             "branch_names": [registry.default_branch, GLOBAL_BRANCH_NAME],
             "kinds_to_skip": self.kinds_to_skip,
+            "kinds_to_include": self.kinds_to_include,
         }
         query = """
 MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
 WHERE NOT n.kind IN $kinds_to_skip
+AND ($kinds_to_include IS NULL OR n.kind IN $kinds_to_include)
 AND e.branch IN $branch_names
 AND e.status = "active"
 AND e.to IS NULL
@@ -731,6 +736,10 @@ class Migration044(MigrationRequiringRebase):
                         continue
 
                     node_schema = main_schema_branch.get_node(name=node_schema_name, duplicate=False)
+
+                    if node_schema.branch is not BranchSupportType.AWARE:
+                        continue
+
                     attribute_schema_map = {}
                     if node_schema.display_labels:
                         attribute_schema_map[display_labels_attribute_schema] = display_label_attribute_schema
@@ -826,6 +835,8 @@ class Migration044(MigrationRequiringRebase):
                     continue
 
                 node_schema = schema_branch.get_node(name=node_schema_name, duplicate=False)
+                if node_schema.branch not in (BranchSupportType.AWARE, BranchSupportType.LOCAL):
+                    continue
                 try:
                     default_node_schema = main_schema_branch.get_node(name=node_schema_name, duplicate=False)
                 except SchemaNotFoundError:

infrahub_server-1.5.4/backend/infrahub/core/migrations/graph/m046_fill_agnostic_hfid_display_labels.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from itertools import chain
+from typing import TYPE_CHECKING, Any
+
+import ujson
+from rich.progress import Progress, TaskID
+
+from infrahub.core.branch import Branch
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType, SchemaPathType
+from infrahub.core.initialization import get_root_node
+from infrahub.core.migrations.graph.m044_backfill_hfid_display_label_in_db import (
+    DefaultBranchNodeCount,
+    GetPathDetailsDefaultBranch,
+    GetResultMapQuery,
+    UpdateAttributeValuesQuery,
+)
+from infrahub.core.migrations.schema.node_attribute_add import NodeAttributeAddMigration
+from infrahub.core.migrations.shared import ArbitraryMigration, MigrationResult, get_migration_console
+from infrahub.core.path import SchemaPath
+from infrahub.core.query import Query, QueryType
+
+from .load_schema_branch import get_or_load_schema_branch
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import AttributeSchema, MainSchemaTypes, NodeSchema, SchemaAttributePath
+    from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.database import InfrahubDatabase
+
+
+class DeleteBranchAwareAttrsForBranchAgnosticNodesQuery(Query):
+    name = "delete_branch_aware_attrs_for_branch_agnostic_nodes_query"
+    type = QueryType.WRITE
+    insert_return = False
+    raise_error_if_empty = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (n:Node {branch_support: "agnostic"})
+MATCH (n)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+WHERE attr.name IN ["human_friendly_id", "display_label"]
+WITH DISTINCT attr
+CALL (attr) {
+    DETACH DELETE attr
+} IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class Migration046(ArbitraryMigration):
+    """
+    Delete any branch-aware human_friendly_id and display_label attributes added to branch-agnostic nodes
+    Add human_friendly_id and display_label attributes to branch-agnostic nodes
+    Set human_friendly_id and display_label attributes for branch-agnostic nodes on global branch
+
+    Uses and duplicates code from Migration044
+    """
+
+    name: str = "046_fill_agnostic_hfid_display_labels"
+    minimum_version: int = 45
+    update_batch_size: int = 1000
+
+    async def _do_one_schema_all(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        schema: MainSchemaTypes,
+        schema_branch: SchemaBranch,
+        attribute_schema_map: dict[AttributeSchema, AttributeSchema],
+        progress: Progress | None = None,
+        update_task: TaskID | None = None,
+    ) -> None:
+        print(f"Processing {schema.kind}...", end="")
+
+        schema_paths_by_name: dict[str, list[SchemaAttributePath]] = {}
+        for source_attribute_schema in attribute_schema_map.keys():
+            node_schema_property = getattr(schema, source_attribute_schema.name)
+            if not node_schema_property:
+                continue
+            if isinstance(node_schema_property, list):
+                schema_paths_by_name[source_attribute_schema.name] = [
+                    schema.parse_schema_path(path=str(path), schema=schema_branch) for path in node_schema_property
+                ]
+            else:
+                schema_paths_by_name[source_attribute_schema.name] = [
+                    schema.parse_schema_path(path=str(node_schema_property), schema=schema_branch)
+                ]
+        all_schema_paths = list(chain(*schema_paths_by_name.values()))
+        offset = 0
+
+        # loop until we get no results from the get_details_query
+        while True:
+            get_details_query: GetResultMapQuery = await GetPathDetailsDefaultBranch.init(
+                db=db,
+                schema_kind=schema.kind,
+                schema_paths=all_schema_paths,
+                offset=offset,
+                limit=self.update_batch_size,
+            )
+            await get_details_query.execute(db=db)
+
+            num_updates = 0
+            for source_attribute_schema, destination_attribute_schema in attribute_schema_map.items():
+                schema_paths = schema_paths_by_name[source_attribute_schema.name]
+                schema_path_values_map = get_details_query.get_result_map(schema_paths)
+                num_updates = max(num_updates, len(schema_path_values_map))
+                formatted_schema_path_values_map = {}
+                for k, v in schema_path_values_map.items():
+                    if not v:
+                        continue
+                    if destination_attribute_schema.kind == "List":
+                        formatted_schema_path_values_map[k] = ujson.dumps(v)
+                    else:
+                        formatted_schema_path_values_map[k] = " ".join(item for item in v if item is not None)
+
+                if not formatted_schema_path_values_map:
+                    continue
+
+                update_display_label_query = await UpdateAttributeValuesQuery.init(
+                    db=db,
+                    branch=branch,
+                    attribute_schema=destination_attribute_schema,
+                    values_by_id_map=formatted_schema_path_values_map,
+                )
+                await update_display_label_query.execute(db=db)
+
+            if progress is not None and update_task is not None:
+                progress.update(update_task, advance=num_updates)
+
+            if num_updates == 0:
+                break
+
+            offset += self.update_batch_size
+
+        print("done")
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        try:
+            return await self._do_execute(db=db)
+        except Exception as exc:
+            return MigrationResult(errors=[str(exc)])
+
+    async def _do_execute(self, db: InfrahubDatabase) -> MigrationResult:
+        console = get_migration_console()
+        result = MigrationResult()
+
+        root_node = await get_root_node(db=db, initialize=False)
+        default_branch_name = root_node.default_branch
+        default_branch = await Branch.get_by_name(db=db, name=default_branch_name)
+        main_schema_branch = await get_or_load_schema_branch(db=db, branch=default_branch)
+
+        console.print("Deleting branch-aware attributes for branch-agnostic nodes...", end="")
+        delete_query = await DeleteBranchAwareAttrsForBranchAgnosticNodesQuery.init(db=db)
+        await delete_query.execute(db=db)
+        console.print("done")
+
+        branch_agnostic_schemas: list[NodeSchema] = []
+        migrations = []
+        for node_schema_kind in main_schema_branch.node_names:
+            schema = main_schema_branch.get_node(name=node_schema_kind, duplicate=False)
+            if schema.branch is not BranchSupportType.AGNOSTIC:
+                continue
+            branch_agnostic_schemas.append(schema)
+            migrations.extend(
+                [
+                    NodeAttributeAddMigration(
+                        new_node_schema=schema,
+                        previous_node_schema=schema,
+                        schema_path=SchemaPath(
+                            schema_kind=schema.kind, path_type=SchemaPathType.ATTRIBUTE, field_name="human_friendly_id"
+                        ),
+                    ),
+                    NodeAttributeAddMigration(
+                        new_node_schema=schema,
+                        previous_node_schema=schema,
+                        schema_path=SchemaPath(
+                            schema_kind=schema.kind, path_type=SchemaPathType.ATTRIBUTE, field_name="display_label"
+                        ),
+                    ),
+                ]
+            )
+
+        global_branch = await Branch.get_by_name(db=db, name=GLOBAL_BRANCH_NAME)
+        with Progress(console=console) as progress:
+            update_task = progress.add_task(
+                "Adding HFID and display label attributes to branch-agnostic nodes", total=len(migrations)
+            )
+
+            for migration in migrations:
+                try:
+                    execution_result = await migration.execute(db=db, branch=global_branch)
+                    result.errors.extend(execution_result.errors)
+                    progress.update(update_task, advance=1)
+                except Exception as exc:
+                    result.errors.append(str(exc))
+                    return result
+
+        total_nodes_query = await DefaultBranchNodeCount.init(
+            db=db, kinds_to_include=[sch.kind for sch in branch_agnostic_schemas]
+        )
+        await total_nodes_query.execute(db=db)
+        total_nodes_count = total_nodes_query.get_num_nodes()
+
+        base_node_schema = main_schema_branch.get("SchemaNode", duplicate=False)
+        display_label_attribute_schema = base_node_schema.get_attribute("display_label")
+        display_labels_attribute_schema = base_node_schema.get_attribute("display_labels")
+        hfid_attribute_schema = base_node_schema.get_attribute("human_friendly_id")
+
+        with Progress(console=console) as progress:
+            update_task = progress.add_task(
+                f"Set display_label and human_friendly_id for {total_nodes_count} branch-agnostic nodes on global branch",
+                total=total_nodes_count,
+            )
+            for branch_agnostic_schema in branch_agnostic_schemas:
+                attribute_schema_map = {}
+                if branch_agnostic_schema.display_labels:
+                    attribute_schema_map[display_labels_attribute_schema] = display_label_attribute_schema
+                if branch_agnostic_schema.human_friendly_id:
+                    attribute_schema_map[hfid_attribute_schema] = hfid_attribute_schema
+                if not attribute_schema_map:
+                    continue
+
+                await self._do_one_schema_all(
+                    db=db,
+                    branch=global_branch,
+                    schema=branch_agnostic_schema,
+                    schema_branch=main_schema_branch,
+                    attribute_schema_map=attribute_schema_map,
+                    progress=progress,
+                    update_task=update_task,
+                )
+
+        return result
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/node/__init__.py

@@ -1088,7 +1088,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
             if key in self._relationships:
                 rel: RelationshipManager = getattr(self, key)
-                changed |= await rel.update(db=db, data=value)
+                changed |= await rel.update(db=db, data=value, process_delete=process_pools)
 
         return changed
 

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/query/attribute.py

@@ -38,7 +38,7 @@ class AttributeQuery(Query):
         if at:
             self.at = Timestamp(at)
         else:
-            self.at = self.attr.at
+            self.at = Timestamp()
 
         self.branch = branch or self.attr.get_branch_based_on_support_type()
 
@@ -247,10 +247,9 @@ class AttributeGetQuery(AttributeQuery):
         self.params["attr_uuid"] = self.attr.id
         self.params["node_uuid"] = self.attr.node.id
 
-        at = self.at or self.attr.at
-        self.params["at"] = at.to_string()
+        self.params["at"] = self.at.to_string()
 
-        rels_filter, rels_params = self.branch.get_query_filter_path(at=at.to_string())
+        rels_filter, rels_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(rels_params)
 
         query = (

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/core/relationship/model.py

@@ -1061,7 +1061,12 @@ class RelationshipManager:
 
         return self._relationships.as_list()
 
-    async def update(self, data: list[str | Node] | dict[str, Any] | str | Node | None, db: InfrahubDatabase) -> bool:
+    async def update(
+        self,
+        data: list[str | Node] | dict[str, Any] | str | Node | None,
+        db: InfrahubDatabase,
+        process_delete: bool = True,
+    ) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
             list_data: Sequence[str | Node | dict[str, Any] | None] = [data]
@@ -1087,8 +1092,9 @@ class RelationshipManager:
 
             if item is None:
                 if previous_relationships:
-                    for rel in previous_relationships.values():
-                        await rel.delete(db=db)
+                    if process_delete:
+                        for rel in previous_relationships.values():
+                            await rel.delete(db=db)
                     changed = True
                 continue
 

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/display_labels/tasks.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import cast
-
 from infrahub_sdk.exceptions import URLNotFoundError
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
@@ -139,11 +137,32 @@ async def display_labels_setup_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]
+        all_triggers = report.triggers_with_type(trigger_type=DisplayLabelTriggerDefinition)
+        direct_target_triggers = [
+            display_report
+            for display_report in report.modified_triggers_with_type(trigger_type=DisplayLabelTriggerDefinition)
+            if display_report.target_kind
+        ]
 
         for display_report in direct_target_triggers:
             if event_name != BranchDeletedEvent.event_name and display_report.branch == branch_name:
+                if branch_name != registry.default_branch:
+                    default_branch_triggers = [
+                        trigger
+                        for trigger in all_triggers
+                        if trigger.branch == registry.default_branch
+                        and trigger.target_kind == display_report.target_kind
+                    ]
+                    if (
+                        default_branch_triggers
+                        and len(default_branch_triggers) == 1
+                        and default_branch_triggers[0].template_hash == display_report.template_hash
+                    ):
+                        log.debug(
+                            f"Skipping display label updates for {display_report.target_kind} [{branch_name}], schema is identical to default branch"
+                        )
+                        continue
+
                 await get_workflow().submit_workflow(
                     workflow=TRIGGER_UPDATE_DISPLAY_LABELS,
                     context=context,

{infrahub_server-1.5.2 → infrahub_server-1.5.4}/backend/infrahub/hfid/tasks.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import cast
-
 from infrahub_sdk.exceptions import URLNotFoundError
 from prefect import flow
 from prefect.logging import get_run_logger
@@ -138,11 +136,32 @@ async def hfid_setup(context: InfrahubContext, branch_name: str | None = None, e
         )  # 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]
+        all_triggers = report.triggers_with_type(trigger_type=HFIDTriggerDefinition)
+        direct_target_triggers = [
+            hfid_report
+            for hfid_report in report.modified_triggers_with_type(trigger_type=HFIDTriggerDefinition)
+            if hfid_report.target_kind
+        ]
 
         for display_report in direct_target_triggers:
             if event_name != BranchDeletedEvent.event_name and display_report.branch == branch_name:
+                if branch_name != registry.default_branch:
+                    default_branch_triggers = [
+                        trigger
+                        for trigger in all_triggers
+                        if trigger.branch == registry.default_branch
+                        and trigger.target_kind == display_report.target_kind
+                    ]
+                    if (
+                        default_branch_triggers
+                        and len(default_branch_triggers) == 1
+                        and default_branch_triggers[0].hfid_hash == display_report.hfid_hash
+                    ):
+                        log.debug(
+                            f"Skipping HFID updates for {display_report.target_kind} [{branch_name}], schema is identical to default branch"
+                        )
+                        continue
+
                 await get_workflow().submit_workflow(
                     workflow=TRIGGER_UPDATE_HFID,
                     context=context,