infrahub-server 1.5.2__py3-none-any.whl → 1.5.4__py3-none-any.whl

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/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/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/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/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/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 45
+GRAPH_VERSION = 46

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/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/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/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/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/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/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/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/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,

infrahub/task_manager/task.py

@@ -1,5 +1,6 @@
 import asyncio
-import uuid
+import hashlib
+import json
 from datetime import datetime, timedelta, timezone
 from typing import Any
 from uuid import UUID
@@ -27,11 +28,14 @@ from prefect.client.schemas.sorting import (
     FlowRunSort,
 )
 
+from infrahub import config
 from infrahub.core.constants import TaskConclusion
 from infrahub.core.query.node import NodeGetKindQuery
 from infrahub.database import InfrahubDatabase
 from infrahub.log import get_logger
+from infrahub.message_bus.types import KVTTL
 from infrahub.utils import get_nested_dict
+from infrahub.workers.dependencies import get_cache
 from infrahub.workflows.constants import TAG_NAMESPACE, WorkflowTag
 
 from .constants import CONCLUSION_STATE_MAPPING
@@ -44,6 +48,12 @@ PREFECT_MAX_LOGS_PER_CALL = 200
 
 
 class PrefectTask:
+    @staticmethod
+    def _build_flow_run_count_cache_key(body: dict[str, Any]) -> str:
+        serialized = json.dumps(body, sort_keys=True, separators=(",", ":"))
+        hashed = hashlib.sha256(serialized.encode()).hexdigest()
+        return f"task_manager:flow_run_count:{hashed}"
+
     @classmethod
     async def count_flow_runs(
         cls,
@@ -59,10 +69,24 @@ class PrefectTask:
             "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (flow_run_filter.model_dump(mode="json", exclude_unset=True) if flow_run_filter else None),
         }
+        cache_key = cls._build_flow_run_count_cache_key(body)
+
+        cache = await get_cache()
+        cached_value_raw = await cache.get(key=cache_key)
+        if cached_value_raw is not None:
+            try:
+                return int(cached_value_raw)
+            except (TypeError, ValueError):
+                await cache.delete(key=cache_key)
 
         response = await client._client.post("/flow_runs/count", json=body)
         response.raise_for_status()
-        return response.json()
+        count_value = int(response.json())
+
+        if count_value >= config.SETTINGS.workflow.flow_run_count_cache_threshold:
+            await cache.set(key=cache_key, value=str(count_value), expires=KVTTL.ONE_MINUTE)
+
+        return count_value
 
     @classmethod
     async def _get_related_nodes(cls, db: InfrahubDatabase, flows: list[FlowRun]) -> RelatedNodesInfo:
@@ -204,7 +228,7 @@ class PrefectTask:
             tags=FlowRunFilterTags(all_=filter_tags),
         )
         if ids:
-            flow_run_filter.id = FlowRunFilterId(any_=[uuid.UUID(id) for id in ids])
+            flow_run_filter.id = FlowRunFilterId(any_=[UUID(id) for id in ids])
 
         if statuses:
             flow_run_filter.state = FlowRunFilterState(type=FlowRunFilterStateType(any_=statuses))

infrahub/telemetry/task_manager.py

@@ -8,6 +8,7 @@ from prefect.client.schemas.objects import WorkerStatus
 from infrahub.events.utils import get_all_events
 from infrahub.trigger.constants import NAME_SEPARATOR
 from infrahub.trigger.models import TriggerType
+from infrahub.trigger.setup import gather_all_automations
 
 from .models import TelemetryPrefectData, TelemetryWorkPoolData
 
@@ -53,7 +54,7 @@ async def gather_prefect_events(client: PrefectClient) -> dict[str, Any]:
 
 @task(name="telemetry-gather-automations", task_run_name="Gather Automations", cache_policy=NONE)
 async def gather_prefect_automations(client: PrefectClient) -> dict[str, Any]:
-    automations = await client.read_automations()
+    automations = await gather_all_automations(client=client)
 
     data: dict[str, Any] = {}
 

infrahub/trigger/models.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from enum import Enum
-from typing import TYPE_CHECKING, Any
+from enum import Enum, StrEnum
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from prefect.events.actions import RunDeployment
 from prefect.events.schemas.automations import Automation, Posture
@@ -18,16 +18,78 @@ from .constants import NAME_SEPARATOR
 if TYPE_CHECKING:
     from uuid import UUID
 
+T = TypeVar("T", bound="TriggerDefinition")
+
+
+class TriggerComparison(StrEnum):
+    MATCH = "match"  # Expected trigger and actual trigger is identical
+    REFRESH = "refresh"  # The branch parameters doesn't match, the hash does, refresh in Prefect but don't run triggers
+    UPDATE = "update"  # Neither branch or other data points match, update in Prefect and run triggers
+
+    @property
+    def update_prefect(self) -> bool:
+        return self in {TriggerComparison.REFRESH, TriggerComparison.UPDATE}
+
 
 class TriggerSetupReport(BaseModel):
     created: list[TriggerDefinition] = Field(default_factory=list)
+    refreshed: list[TriggerDefinition] = Field(default_factory=list)
     updated: list[TriggerDefinition] = Field(default_factory=list)
     deleted: list[Automation] = Field(default_factory=list)
     unchanged: list[TriggerDefinition] = Field(default_factory=list)
 
     @property
     def in_use_count(self) -> int:
-        return len(self.created + self.updated + self.unchanged)
+        return len(self.created + self.updated + self.unchanged + self.refreshed)
+
+    def add_with_comparison(self, trigger: TriggerDefinition, comparison: TriggerComparison) -> None:
+        match comparison:
+            case TriggerComparison.UPDATE:
+                self.updated.append(trigger)
+            case TriggerComparison.REFRESH:
+                self.refreshed.append(trigger)
+            case TriggerComparison.MATCH:
+                self.unchanged.append(trigger)
+
+    def _created_triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        return [trigger for trigger in self.created if isinstance(trigger, trigger_type)]
+
+    def _refreshed_triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        return [trigger for trigger in self.refreshed if isinstance(trigger, trigger_type)]
+
+    def _unchanged_triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        return [trigger for trigger in self.unchanged if isinstance(trigger, trigger_type)]
+
+    def _updated_triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        return [trigger for trigger in self.updated if isinstance(trigger, trigger_type)]
+
+    def triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        """Return all triggers that match the specified type.
+
+        Args:
+            trigger_type: A TriggerDefinition class or subclass to filter by
+
+        Returns:
+            List of triggers of the specified type from all categories
+        """
+        created = self._created_triggers_with_type(trigger_type=trigger_type)
+        updated = self._updated_triggers_with_type(trigger_type=trigger_type)
+        refreshed = self._refreshed_triggers_with_type(trigger_type=trigger_type)
+        unchanged = self._unchanged_triggers_with_type(trigger_type=trigger_type)
+        return created + updated + refreshed + unchanged
+
+    def modified_triggers_with_type(self, trigger_type: type[T]) -> list[T]:
+        """Return all created and updated triggers that match the specified type.
+
+        Args:
+            trigger_type: A TriggerDefinition class or subclass to filter by
+
+        Returns:
+            List of triggers of the specified type from both created and updated lists
+        """
+        created = self._created_triggers_with_type(trigger_type=trigger_type)
+        updated = self._updated_triggers_with_type(trigger_type=trigger_type)
+        return created + updated
 
 
 class TriggerType(str, Enum):
@@ -41,6 +103,16 @@ class TriggerType(str, Enum):
     HUMAN_FRIENDLY_ID = "human_friendly_id"
     # OBJECT = "object"
 
+    @property
+    def is_branch_specific(self) -> bool:
+        return self in {
+            TriggerType.COMPUTED_ATTR_JINJA2,
+            TriggerType.COMPUTED_ATTR_PYTHON,
+            TriggerType.COMPUTED_ATTR_PYTHON_QUERY,
+            TriggerType.DISPLAY_LABEL_JINJA2,
+            TriggerType.HUMAN_FRIENDLY_ID,
+        }
+
 
 def _match_related_dict() -> dict:
     # Make Mypy happy as match related is a dict[str, Any] | list[dict[str, Any]]

infrahub/trigger/setup.py

@@ -12,22 +12,36 @@ from infrahub import lock
 from infrahub.database import InfrahubDatabase
 from infrahub.trigger.models import TriggerDefinition
 
-from .models import TriggerSetupReport, TriggerType
+from .models import TriggerComparison, TriggerSetupReport, TriggerType
 
 if TYPE_CHECKING:
     from uuid import UUID
 
 
-def compare_automations(target: AutomationCore, existing: Automation) -> bool:
-    """Compare an AutomationCore with an existing Automation object to identify if they are identical or not
-
-    Return True if the target is identical to the existing automation
+def compare_automations(
+    target: AutomationCore, existing: Automation, trigger_type: TriggerType | None, force_update: bool = False
+) -> TriggerComparison:
+    """Compare an AutomationCore with an existing Automation object to identify if they are identical,
+    if it's a branch specific automation and the branch filter may be different, or if they are different.
     """
 
+    if force_update:
+        return TriggerComparison.UPDATE
+
     target_dump = target.model_dump(exclude_defaults=True, exclude_none=True)
     existing_dump = existing.model_dump(exclude_defaults=True, exclude_none=True, exclude={"id"})
 
-    return target_dump == existing_dump
+    if target_dump == existing_dump:
+        return TriggerComparison.MATCH
+
+    if not trigger_type or not trigger_type.is_branch_specific:
+        return TriggerComparison.UPDATE
+
+    if target.description == existing.description:
+        # If only the branch related info is different, we consider it a refresh
+        return TriggerComparison.REFRESH
+
+    return TriggerComparison.UPDATE
 
 
 @task(name="trigger-setup-specific", task_run_name="Setup triggers of a specific kind", cache_policy=NONE)  # type: ignore[arg-type]
@@ -63,10 +77,8 @@ async def setup_triggers(
 
     report = TriggerSetupReport()
 
-    if trigger_type:
-        log.debug(f"Setting up triggers of type {trigger_type.value}")
-    else:
-        log.debug("Setting up all triggers")
+    trigger_log_message = f"triggers of type {trigger_type.value}" if trigger_type else "all triggers"
+    log.debug(f"Setting up {trigger_log_message}")
 
     # -------------------------------------------------------------
     # Retrieve existing Deployments and Automation from the server
@@ -80,16 +92,14 @@ async def setup_triggers(
     }
     deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
 
-    # If a trigger type is provided, narrow down the list of existing triggers to know which one to delete
-    existing_automations: dict[str, Automation] = {}
+    existing_automations = {item.name: item for item in await gather_all_automations(client=client)}
     if trigger_type:
+        # If a trigger type is provided, narrow down the list of existing triggers to know which one to delete
         existing_automations = {
-            item.name: item
-            for item in await client.read_automations()
-            if item.name.startswith(f"{trigger_type.value}::")
+            automation_name: automation
+            for automation_name, automation in existing_automations.items()
+            if automation_name.startswith(f"{trigger_type.value}::")
         }
-    else:
-        existing_automations = {item.name: item for item in await client.read_automations()}
 
     trigger_names = [trigger.generate_name() for trigger in triggers]
     automation_names = list(existing_automations.keys())
@@ -115,12 +125,13 @@ async def setup_triggers(
         existing_automation = existing_automations.get(trigger.generate_name(), None)
 
         if existing_automation:
-            if force_update or not compare_automations(target=automation, existing=existing_automation):
+            trigger_comparison = compare_automations(
+                target=automation, existing=existing_automation, trigger_type=trigger_type, force_update=force_update
+            )
+            if trigger_comparison.update_prefect:
                 await client.update_automation(automation_id=existing_automation.id, automation=automation)
                 log.info(f"{trigger.generate_name()} Updated")
-                report.updated.append(trigger)
-            else:
-                report.unchanged.append(trigger)
+            report.add_with_comparison(trigger, trigger_comparison)
         else:
             await client.create_automation(automation=automation)
             log.info(f"{trigger.generate_name()} Created")
@@ -145,15 +156,34 @@ async def setup_triggers(
             else:
                 raise
 
-    if trigger_type:
-        log.info(
-            f"Processed triggers of type {trigger_type.value}: "
-            f"{len(report.created)} created, {len(report.updated)} updated, {len(report.unchanged)} unchanged, {len(report.deleted)} deleted"
-        )
-    else:
-        log.info(
-            f"Processed all triggers: "
-            f"{len(report.created)} created, {len(report.updated)} updated, {len(report.unchanged)} unchanged, {len(report.deleted)} deleted"
-        )
+    log.info(
+        f"Processed {trigger_log_message}: {len(report.created)} created, {len(report.updated)} updated, "
+        f"{len(report.refreshed)} refreshed, {len(report.unchanged)} unchanged, {len(report.deleted)} deleted"
+    )
 
     return report
+
+
+async def gather_all_automations(client: PrefectClient) -> list[Automation]:
+    """Gather all automations from the Prefect server
+
+    By default the Prefect client only retrieves a limited number of automations, this function
+    retrieves them all by paginating through the results. The default within Prefect is 200 items,
+    and client.read_automations() doesn't support pagination parameters.
+    """
+    automation_count_response = await client.request("POST", "/automations/count")
+    automation_count_response.raise_for_status()
+    automation_count: int = automation_count_response.json()
+    offset = 0
+    limit = 200
+    missing_automations = True
+    automations: list[Automation] = []
+    while missing_automations:
+        response = await client.request("POST", "/automations/filter", json={"limit": limit, "offset": offset})
+        response.raise_for_status()
+        automations.extend(Automation.model_validate_list(response.json()))
+        if len(automations) >= automation_count:
+            missing_automations = False
+        offset += limit
+
+    return automations

{infrahub_server-1.5.2.dist-info → infrahub_server-1.5.4.dist-info}/METADATA

@@ -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.dist-info → infrahub_server-1.5.4.dist-info}/RECORD

@@ -54,20 +54,20 @@ infrahub/components.py,sha256=lSLDCDwIZoakZ2iBrfHi9c3BxzugMiuiZO6V7Egt6tk,107
 infrahub/computed_attribute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/computed_attribute/constants.py,sha256=oTMPEfRuf2mcfCkBpRLWRALO6nsLHpFm9jJGu0lowS4,446
 infrahub/computed_attribute/gather.py,sha256=xhH4dsgCjRFyFshns4Iu3sloe5m1bVMRdeQAJjFdyYU,8220
-infrahub/computed_attribute/models.py,sha256=P_MijLwCVd7394oyTTfYQ3HmX5wIF966jdchuZaLRbs,17361
-infrahub/computed_attribute/tasks.py,sha256=3HGVb6mat9kD5VFYBtdUhJx6KW_cRlh2hbgHDOVAwFo,17944
+infrahub/computed_attribute/models.py,sha256=U2zM2cGpGWAmRpVEp28hFauCNQYaDdI332thj_65zvE,17658
+infrahub/computed_attribute/tasks.py,sha256=zld2oDQ5Z4HZzHTDrCYNLOxzCW8SqcLTvvxtSk6TADM,19388
 infrahub/computed_attribute/triggers.py,sha256=ve1cUj0CZ7dU1VtZkxET9LD8StszKIL9mCkTZpCeUaI,2304
-infrahub/config.py,sha256=jWGDVIwZiRdn7TRw0LwcFD61zr5T0mUacQ9C2MYLoLg,39188
+infrahub/config.py,sha256=PX6RlgWJhShbl0vnRrw8MVitjWcjCYn764VtHfHvfmk,39389
 infrahub/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/constants/database.py,sha256=WmV1iuOk4xulxZHOVvO3sS_VF1eTf7fKh0TPe_RnfV4,507
 infrahub/constants/environment.py,sha256=ry-6qsBzSumOjjiq1D3XNoquf1LWqFKiQSJj8t6nET4,32
 infrahub/context.py,sha256=8SZRKSECkkcsNNzDaKEUJ7Nyr0EzUfToAy969LXjQVk,1554
 infrahub/core/__init__.py,sha256=z6EJBZyCYCBqinoBtX9li6BTBbbGV8WCkE_4CrEsmDA,104
 infrahub/core/account.py,sha256=6f1cIDWvL-HsbzL0UwWoCbDTzx55wzd_SkpQXiKDjcE,27477
-infrahub/core/attribute.py,sha256=4_FvQI5EgCmOGKb8_N0c7k2kV1EbXwLqRgFsvOtQbVw,44907
+infrahub/core/attribute.py,sha256=quW5lG-e4c3VjIhiSta12TUTB8Uv_Gmi8mwTenwBSIo,44921
 infrahub/core/branch/__init__.py,sha256=h0oIj0gHp1xI-N1cYW8_N6VZ81CBOmLuiUt5cS5nKuk,49
 infrahub/core/branch/enums.py,sha256=wE_TvKxd-r3zeHgLOMuZhsyKRwDWWC8BMxAEC_aX7A8,212
-infrahub/core/branch/models.py,sha256=wgTeFJCcrgW7soZrfJWhGaJg2jDmTnsAjabpjf0-KWI,20617
+infrahub/core/branch/models.py,sha256=BgEHOXr0bpOfhIV0-v7OJR0UVtHUFQXjn3giAEHD6Vw,20674
 infrahub/core/branch/needs_rebase_status.py,sha256=purrg93k9zWcV9NONjIdMF8cWLXEKHq6YjO0ayC3C04,407
 infrahub/core/branch/tasks.py,sha256=RnQlWdFmAj3VIALb4WNaMiL7ZuvtGcW1zgdbnemjE-Q,23558
 infrahub/core/changelog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -143,7 +143,7 @@ infrahub/core/diff/repository/deserializer.py,sha256=bhN9ao8HxqKyRz273QGLNV9z9_S
 infrahub/core/diff/repository/repository.py,sha256=u0QTMY1e2dknG_DuRAwzFt-Lp1_mdj5lqF2ymt77k9E,25581
 infrahub/core/diff/tasks.py,sha256=lQMTcqvVC1p5hc3KmwR2ONA1M6qffDUl62vKOktTs5c,3514
 infrahub/core/enums.py,sha256=qGbhRVoH43Xi0iDkUfWdQiKapJbLT9UKsCobFk_paIk,491
-infrahub/core/graph/__init__.py,sha256=KNVHBhDx3HVtzNMVi-7A8m-Cp_rbi61MeY-Ag62bZ78,19
+infrahub/core/graph/__init__.py,sha256=zt3OOi7yTehM66ClW2czqpghOQrlZ2Tzgw7hRet4-LM,19
 infrahub/core/graph/constraints.py,sha256=lmuzrKDFoeSKRiLtycB9PXi6zhMYghczKrPYvfWyy90,10396
 infrahub/core/graph/index.py,sha256=A9jzEE_wldBJsEsflODeMt4GM8sPmmbHAJRNdFioR1k,1736
 infrahub/core/graph/schema.py,sha256=o50Jcy6GBRk55RkDJSMIDDwHhLD7y_RWOirI9rCex4A,10776
@@ -163,7 +163,7 @@ infrahub/core/manager.py,sha256=IU5VfkHLCN4WhvqzI6DOEyCXo9fBT_st5BmN__A4vas,4418
 infrahub/core/merge.py,sha256=TNZpxjNYcl3dnvE8eYXaWSXFDYeEa8DDsS9XbR2XKlA,11217
 infrahub/core/migrations/__init__.py,sha256=ttA1YkKhiG9Zc0fwIIcMLIDCrIhN5xVOIh6ojFoy58o,1541
 infrahub/core/migrations/exceptions.py,sha256=gEAkWzjvN-IXr0YPqUrEqnu_GsR-uqucsu1QUaWhEmM,147
-infrahub/core/migrations/graph/__init__.py,sha256=epa6L0I-ZMzHS2NkpTusTl_1LEDjGNRq7q_S_HukqqQ,4475
+infrahub/core/migrations/graph/__init__.py,sha256=ShWFHlPSkyrkOORcFNn907I9-I4UM2n4GBktPPsHZx8,4558
 infrahub/core/migrations/graph/load_schema_branch.py,sha256=OvjowaeDnx4djD1aGPjE7Rqyh1p843LSodOf_Frdt9U,1008
 infrahub/core/migrations/graph/m001_add_version_to_graph.py,sha256=YcLN6cFjE6IGheXR4Ujb6CcyY8bJ7WE289hcKJaENOc,1515
 infrahub/core/migrations/graph/m002_attribute_is_default.py,sha256=wB6f2N_ChTvGajqHD-OWCG5ahRMDhhXZuwo79ieq_II,1036
@@ -207,9 +207,10 @@ infrahub/core/migrations/graph/m039_ipam_reconcile.py,sha256=yRWTE73Rq1Qh6tPLu98
 infrahub/core/migrations/graph/m040_duplicated_attributes.py,sha256=2LxsG-CfcZnBirwGhwYL4kU-g3oxl6lNSM12vZTZ7Gw,2930
 infrahub/core/migrations/graph/m041_deleted_dup_edges.py,sha256=eP2BqUfvwkjACJrKI5fVyBBmXxEDwxtAD9O_CcbwBMw,5409
 infrahub/core/migrations/graph/m042_profile_attrs_in_db.py,sha256=KdEaNPHovJxxiNL3CFRjWBnNzaMdidj1nmW5Jbhrt-4,6431
-infrahub/core/migrations/graph/m043_create_hfid_display_label_in_db.py,sha256=x7OgI5ZoX8yslg329VNFHXbZ2eDFwcdFhBeC-UWqVdk,7072
-infrahub/core/migrations/graph/m044_backfill_hfid_display_label_in_db.py,sha256=mzw_sitDDDNQRMurvMo3mprUqhXNLJVh6Dgabh67cTw,39096
+infrahub/core/migrations/graph/m043_create_hfid_display_label_in_db.py,sha256=giICX6Dwd_z1GaWTWyX3KD5Va34LGth0Vv2uyaof044,7290
+infrahub/core/migrations/graph/m044_backfill_hfid_display_label_in_db.py,sha256=FuV3EBWS4lY4dtOn7-1Qgo6J7j4XDq4s5yIQjfCCVDM,39575
 infrahub/core/migrations/graph/m045_backfill_hfid_display_label_in_db_profile_template.py,sha256=mnND7TIdPSVcN9uJeYMmRpVjlAU6QBqfu7e1CS31D9Q,7934
+infrahub/core/migrations/graph/m046_fill_agnostic_hfid_display_labels.py,sha256=labPu3UwH2L6X3VCVmNQHGSbRS-De0ihVzsaUiTf2so,10210
 infrahub/core/migrations/query/__init__.py,sha256=nUbKk8bX6Ei4RkLe0VNNAm7c-d2zDoAMgdFGkYW0Czw,850
 infrahub/core/migrations/query/attribute_add.py,sha256=wKChMnqcd8hb8YCTIU3rUrtVqwHFSI5bdvXAPUcnRIA,4969
 infrahub/core/migrations/query/attribute_remove.py,sha256=IhAPlv9jyZTWMf8f8HZJ8G0ImWebt-ER78NrP3vIWhU,5307
@@ -232,7 +233,7 @@ infrahub/core/migrations/schema/placeholder_dummy.py,sha256=YBGFUVPi57ARbWgAmbtK
 infrahub/core/migrations/schema/tasks.py,sha256=2J8gHGSP-WhxSi4GYhOc9xAJOg_S1ONm3YE4_ukLKxw,4164
 infrahub/core/migrations/shared.py,sha256=sQMdbx1gnht2G_-nb1MDbStwUso5YJkyyumjlKAJq3g,9592
 infrahub/core/models.py,sha256=xoodMSKLaHD5nOtBT35soRQnyHO_OrDlVRNdXuL51Ho,26679
-infrahub/core/node/__init__.py,sha256=yr6WFmh7pvL6XeFx6Hou0UoSc0DniZy09YPn84NGipg,50084
+infrahub/core/node/__init__.py,sha256=OihBPaPhEbgvSLKPdBOBBuh0EFWf2wt897LZ_jdWb_g,50114
 infrahub/core/node/base.py,sha256=BAowVRCK_WC50yXym1kCyUppJDJnrODGU5uoj1s0Yd4,2564
 infrahub/core/node/constraints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/core/node/constraints/attribute_uniqueness.py,sha256=lcHBk4d3bc12sywxRTnQs18VEm_S6pDcUhNnsXnb-uI,2162
@@ -255,7 +256,7 @@ infrahub/core/property.py,sha256=mUf8JGUHSUVBaegN7TPmmJ2CnQRGo2d1rQEQQmdNmbU,538
 infrahub/core/protocols.py,sha256=QoDvLhsvLiJ7Jqouri31ja4apApVN4zmwm_59KTKhs8,12741
 infrahub/core/protocols_base.py,sha256=cEi6giHtEUmaD0JWfDfWHJhEv_6wjaBA3oJRJCbvc6Q,3411
 infrahub/core/query/__init__.py,sha256=2qIMaODLwJ6pK6BUd5vODTlA15Aecf5I8_-J44UlCso,23089
-infrahub/core/query/attribute.py,sha256=rz0IJPD1wUhjzt20z8R-_gMYGJuNyShM_PDzKPLiF1M,14901
+infrahub/core/query/attribute.py,sha256=ud9dySDbH8OYnCMB6KJKZONekE3Ar0IrUbVEQ9DeWYQ,14873
 infrahub/core/query/branch.py,sha256=aIYyDxpnw_Zw2lqTnMEVlhPUaYckZtJJJU1SFUht1o0,4343
 infrahub/core/query/delete.py,sha256=7tPP1qtNV6QGYtmgE1RKsuQ9oxENnMTVkttLvJ2PiKg,1927
 infrahub/core/query/diff.py,sha256=uvojpzJSZFdcuutPAbA74M6R85hN1fteBDS4ZufE8IA,38579
@@ -277,7 +278,7 @@ infrahub/core/relationship/constraints/peer_kind.py,sha256=Bropiav4y6r0iU2KfWJ_k
 infrahub/core/relationship/constraints/peer_parent.py,sha256=z7elpC8xS_ovAF28Haq-RNpFtTEiUehzowiDgYGT68U,2343
 infrahub/core/relationship/constraints/peer_relatives.py,sha256=Ye79l7njaWxZkU2chTOaptIjvKBIawsNCl0IQxCTDtM,2737
 infrahub/core/relationship/constraints/profiles_kind.py,sha256=nEZPGtGcmelZ1Nb8EPcQ-7_zCLCNIYwwWbU6C9fLj5E,2464
-infrahub/core/relationship/model.py,sha256=ZaR6Rrp1CiS8vjbAcMTILpeI755ORj2_aj-3MYD-Q1E,48978
+infrahub/core/relationship/model.py,sha256=ocow8RLJWaR-DNHh7JqYhA0g0fe_elwNeOmuG9ywzII,49093
 infrahub/core/root.py,sha256=8ZLSOtnmjQcrjqX2vxNO-AGopEUArmBPo_X5NeZBdP0,416
 infrahub/core/schema/__init__.py,sha256=U1DWsadfu7Y3FUc51h9DNwXEq4Qa_yZ5w5Bip8pVpmw,6674
 infrahub/core/schema/attribute_parameters.py,sha256=ABL1GEsOl4_CcDvK9_NucGMaF6LUeOjAxbDQVm_G7eg,6516
@@ -442,7 +443,7 @@ infrahub/dependencies/registry.py,sha256=YNv73l66EIYDBLaxeeWfGStl8MY6Xz_HpQY1osX
 infrahub/display_labels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/display_labels/gather.py,sha256=FVMB6dGh3rwUKvxlqHOYrmxAEOuRkw7AC4SHjtL3w5Y,1786
 infrahub/display_labels/models.py,sha256=eOnbMy70qtw8je2ltYxW9BMSt2UO0T6H8ouHJATW_wE,9779
-infrahub/display_labels/tasks.py,sha256=LADymXZWPtCnrzz93uliNyBEeXSNhvdmZ0jBhXUIo2I,7009
+infrahub/display_labels/tasks.py,sha256=BlXADozQcAdh3Qzhbr6ARjGM3X9rCpEnfjvzCHCe0qA,7934
 infrahub/display_labels/triggers.py,sha256=dWMKAC5w525bz6MnDF8kQFbDsSL-qI8A7zcZRP2Xq6U,966
 infrahub/events/__init__.py,sha256=6BtpkdstvgnMYvUWc-q2dqiA08ZRaU-Xs4vmhWpOJXs,1702
 infrahub/events/artifact_action.py,sha256=-j_Sh-_NdJIGJhUDYm5DoZS--eIYsaMsejj36OUE6yk,2823
@@ -587,7 +588,7 @@ infrahub/helpers.py,sha256=KchbQqgipU4VjfwnDbzCGjnEv-4espw_g63Zw4KAhbo,251
 infrahub/hfid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/hfid/gather.py,sha256=ruv1NtzAuDO0Q6XsAjNsj0ujeXwqHxYOB1tVobPFf4U,1691
 infrahub/hfid/models.py,sha256=DZ6bX0sIcYB6nEbdDWzEVs6seqa2FU3dTT3sTP1PCXw,9481
-infrahub/hfid/tasks.py,sha256=gJKnQWywOXRcmGcrYb1-KovgA5SahQw9UiTtYfVjvMs,6764
+infrahub/hfid/tasks.py,sha256=MEOZQ9mI23187Ae1Rmzuf9l3qxuAB2d_BV4dOWRWKtM,7670
 infrahub/hfid/triggers.py,sha256=A0-oB1GvvfLJFQ9HsL44vFz-ZVgpsSKOhIkDUiL-5fw,912
 infrahub/lock.py,sha256=tebDPS_LZmTCA7M49LNtKwK_e_evqEcguuYoXnbbel8,10954
 infrahub/locks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -703,7 +704,7 @@ infrahub/task_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 infrahub/task_manager/constants.py,sha256=1t1BZRa8_y89gIDPNHzIbRKo63nHOP37-r5OvtHa56c,559
 infrahub/task_manager/event.py,sha256=AVzfTt_jcsL9XgtMDEnhrb7w0xeZ84wB4ZNK2P3g4JA,14127
 infrahub/task_manager/models.py,sha256=WJxyCJPznSck8sUiGhCmfqN5SpKabLPBuTjiHC7vhNE,8940
-infrahub/task_manager/task.py,sha256=CAc7ZMZtQ1uniSnvtmVWSBb4kMOLJEzDob0xiKUDvTQ,15308
+infrahub/task_manager/task.py,sha256=DV3zlj7bRgH0au3tbD6FC8tyx8OtXyryomFCHXR-o6g,16298
 infrahub/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/tasks/artifact.py,sha256=q1MyQAbT77pD-pm8StHsF_JlTpEQreNc51JHJfnsTD4,1958
 infrahub/tasks/check.py,sha256=37n1U1Knb3AV6kz2sw_IabL9pnlqceLVICWf9GdSxZE,687
@@ -715,7 +716,7 @@ infrahub/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 infrahub/telemetry/constants.py,sha256=_5mJAZaT_wTCaF7Yzsd---Zn1N6GZkoP_954GK8K4-c,184
 infrahub/telemetry/database.py,sha256=9UVPOxRionVF65jjo8slRIaNBOv-KMRzq7I-7fe3wZE,3111
 infrahub/telemetry/models.py,sha256=q3h_wSX0A2OZgDHo05TXTgcHrzDSxx8hSyqRKPGLvwc,1405
-infrahub/telemetry/task_manager.py,sha256=x7bUCQ2jXi93VWmrjKZHZTzR3JhD7r0OhhqK7ymCnAM,2864
+infrahub/telemetry/task_manager.py,sha256=ZTmrN_MTiPIMyFQuD7xBy0PQkMCchNfI9KHnn5oLkkE,2934
 infrahub/telemetry/tasks.py,sha256=O1oK1AJIuf5x2kMxxN2fEDiurH1PmBcYUFCQO_HBvoc,4380
 infrahub/telemetry/utils.py,sha256=K-gmj4QilO3HXAqJRzUwVcpqdA9KcM4RYJPU_zUYpHA,308
 infrahub/trace.py,sha256=Hir9hMWx_6IKF_dhDnMxYjusJdy0ycjB5CHWge2wXNE,3759
@@ -726,8 +727,8 @@ infrahub/transformations/tasks.py,sha256=fxq1t5k0Uj9guEEQN4JSagF4ITVDP7_eyp9TxfQ
 infrahub/trigger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/trigger/catalogue.py,sha256=62WmN3waxVGBLgcGIygcxLwA7HWk4ffbm2WQPgdimiE,976
 infrahub/trigger/constants.py,sha256=u9_5A6gIUIrprzfEdwseYk2yTkwU0VPCjZTwL8b3T6s,22
-infrahub/trigger/models.py,sha256=niFKtFpgUovIllKKImAkyqeBMUUxcqSHBNf6jBGbGzQ,4968
-infrahub/trigger/setup.py,sha256=EZxsneu-da-nXtHtsl5jSicKr8B9uWd-2YCq1J-4fko,6537
+infrahub/trigger/models.py,sha256=X82Kz1K1s2knb8iezx87ctu4ML6d8f0wWYWM6EglUQo,8240
+infrahub/trigger/setup.py,sha256=YCp8smOzXE4jlQ0n7OlK_FMDHPPusHfoRVKREv9bKiI,8018
 infrahub/trigger/tasks.py,sha256=b_tdEKYpWYkDnv3m7cfwH5JanZdMBhro4Lzf0LV8_RI,1871
 infrahub/types.py,sha256=aea-_EXtaqhYq8-P5LGqkU9VitfMs_WU4WXOSsItrsg,11591
 infrahub/utils.py,sha256=3p_bXmRGOTnXIMG9fZ9mFsKdBw2fU3VBFJT3YHrbvyw,2704
@@ -888,8 +889,8 @@ infrahub_testcontainers/models.py,sha256=hT7WEX2o7gxTFPE9uhtP5yigKgP5YSsy2c3tFB-
 infrahub_testcontainers/performance_test.py,sha256=_nf7Uk15mHwqpN4y7XUfI4JI54-UaXW-Yu4uwMIx21w,6185
 infrahub_testcontainers/plugin.py,sha256=I3RuZQ0dARyKHuqCf0y1Yj731P2Mwf3BJUehRJKeWrs,5645
 infrahub_testcontainers/prometheus.yml,sha256=610xQEyj3xuVJMzPkC4m1fRnCrjGpiRBrXA2ytCLa54,599
-infrahub_server-1.5.2.dist-info/LICENSE.txt,sha256=7GQO7kxVoQYnZtFrjZBKLRXbrGwwwimHPPOJtqXsozQ,11340
-infrahub_server-1.5.2.dist-info/METADATA,sha256=FI3l6-MziBYaFBQiDqElU0MK6XgH67S3iQsq6jiJ4_8,6127
-infrahub_server-1.5.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-infrahub_server-1.5.2.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
-infrahub_server-1.5.2.dist-info/RECORD,,
+infrahub_server-1.5.4.dist-info/LICENSE.txt,sha256=7GQO7kxVoQYnZtFrjZBKLRXbrGwwwimHPPOJtqXsozQ,11340
+infrahub_server-1.5.4.dist-info/METADATA,sha256=nX55O3QHheHyTq0Ntl453Hw2Bizx-R_r657PW5T2O8k,6127
+infrahub_server-1.5.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+infrahub_server-1.5.4.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
+infrahub_server-1.5.4.dist-info/RECORD,,