infrahub-server 1.5.1__py3-none-any.whl → 1.5.3__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

@@ -141,8 +141,9 @@ class Branch(StandardNode):
         """
 
         params: dict[str, Any] = {"name": name}
+        params["ignore_statuses"] = []
         if ignore_deleting:
-            params["ignore_statuses"] = [BranchStatus.DELETING.value]
+            params["ignore_statuses"].append(BranchStatus.DELETING.value)
 
         results = await db.execute_query(query=query, params=params, name="branch_get_by_name", type=QueryType.READ)
 
@@ -338,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
 
@@ -351,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/branch/tasks.py

@@ -502,9 +502,13 @@ async def post_process_branch_merge(source_branch: str, target_branch: str, cont
             parameters={"branch": target_branch, "source": GeneratorDefinitionRunSource.MERGE},
         )
 
+        active_branches = await Branch.get_list(db=db)
+        active_branch_names = {branch.name for branch in active_branches}
+
         for diff_root in branch_diff_roots:
             if (
                 diff_root.base_branch_name != diff_root.diff_branch_name
+                and diff_root.diff_branch_name in active_branch_names
                 and diff_root.tracking_id
                 and isinstance(diff_root.tracking_id, BranchTrackingId)
             ):

infrahub/core/diff/tasks.py

@@ -8,6 +8,7 @@ from infrahub.core.diff.coordinator import DiffCoordinator
 from infrahub.core.diff.models import RequestDiffUpdate  # noqa: TC001  needed for prefect flow
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.exceptions import BranchNotFoundError
 from infrahub.log import get_logger
 from infrahub.workers.dependencies import get_database, get_workflow
 from infrahub.workflows.catalogue import DIFF_REFRESH
@@ -24,7 +25,11 @@ async def update_diff(model: RequestDiffUpdate) -> None:
     async with database.start_session(read_only=False) as db:
         component_registry = get_component_registry()
         base_branch = await registry.get_branch(db=db, branch=registry.default_branch)
-        diff_branch = await registry.get_branch(db=db, branch=model.branch_name)
+        try:
+            diff_branch = await registry.get_branch(db=db, branch=model.branch_name)
+        except BranchNotFoundError:
+            log.warn(f"Branch {model.branch_name} not found, skipping diff update")
+            return
 
         diff_coordinator = await component_registry.get_component(DiffCoordinator, db=db, branch=diff_branch)
 

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 44
+GRAPH_VERSION = 46

infrahub/core/migrations/graph/__init__.py

@@ -46,6 +46,8 @@ from .m041_deleted_dup_edges import Migration041
 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
@@ -96,6 +98,8 @@ MIGRATIONS: list[type[MigrationTypes]] = [
     Migration042,
     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

@@ -13,13 +13,15 @@ from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType, Relat
 from infrahub.core.initialization import get_root_node
 from infrahub.core.migrations.shared import MigrationResult, get_migration_console
 from infrahub.core.query import Query, QueryType
+from infrahub.core.schema import NodeSchema
+from infrahub.exceptions import SchemaNotFoundError
 from infrahub.types import is_large_attribute_type
 
 from ..shared import MigrationRequiringRebase
 from .load_schema_branch import get_or_load_schema_branch
 
 if TYPE_CHECKING:
-    from infrahub.core.schema import AttributeSchema, NodeSchema
+    from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, TemplateSchema
     from infrahub.core.schema.basenode_schema import SchemaAttributePath
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
@@ -38,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
@@ -621,7 +628,7 @@ class Migration044(MigrationRequiringRebase):
         self,
         db: InfrahubDatabase,
         branch: Branch,
-        schema: NodeSchema,
+        schema: NodeSchema | ProfileSchema | TemplateSchema,
         schema_branch: SchemaBranch,
         attribute_schema_map: dict[AttributeSchema, AttributeSchema],
         progress: Progress | None = None,
@@ -729,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
@@ -755,7 +766,7 @@ class Migration044(MigrationRequiringRebase):
         self,
         db: InfrahubDatabase,
         branch: Branch,
-        schema: NodeSchema,
+        schema: NodeSchema | ProfileSchema | TemplateSchema,
         schema_branch: SchemaBranch,
         source_attribute_schema: AttributeSchema,
         destination_attribute_schema: AttributeSchema,
@@ -824,18 +835,32 @@ class Migration044(MigrationRequiringRebase):
                     continue
 
                 node_schema = schema_branch.get_node(name=node_schema_name, duplicate=False)
-                default_node_schema = main_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:
+                    default_node_schema = None
                 schemas_for_universal_update_map = {}
                 schemas_for_targeted_update_map = {}
-                if default_node_schema.display_label != node_schema.display_label:
-                    schemas_for_universal_update_map[display_labels_attribute_schema] = display_label_attribute_schema
-                elif node_schema.display_labels:
-                    schemas_for_targeted_update_map[display_labels_attribute_schema] = display_label_attribute_schema
-
-                if default_node_schema.human_friendly_id != node_schema.human_friendly_id:
-                    schemas_for_universal_update_map[hfid_attribute_schema] = hfid_attribute_schema
-                elif node_schema.human_friendly_id:
-                    schemas_for_targeted_update_map[hfid_attribute_schema] = hfid_attribute_schema
+                if node_schema.display_label:
+                    if default_node_schema is None or default_node_schema.display_label != node_schema.display_label:
+                        schemas_for_universal_update_map[display_labels_attribute_schema] = (
+                            display_label_attribute_schema
+                        )
+                    else:
+                        schemas_for_targeted_update_map[display_labels_attribute_schema] = (
+                            display_label_attribute_schema
+                        )
+
+                if node_schema.human_friendly_id:
+                    if (
+                        default_node_schema is None
+                        or default_node_schema.human_friendly_id != node_schema.human_friendly_id
+                    ):
+                        schemas_for_universal_update_map[hfid_attribute_schema] = hfid_attribute_schema
+                    else:
+                        schemas_for_targeted_update_map[hfid_attribute_schema] = hfid_attribute_schema
 
                 if schemas_for_universal_update_map:
                     await self._do_one_schema_all(

infrahub/core/migrations/graph/m045_backfill_hfid_display_label_in_db_profile_template.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.progress import Progress
+
+from infrahub.core import registry
+from infrahub.core.branch import Branch
+from infrahub.core.initialization import get_root_node
+from infrahub.core.migrations.graph.m044_backfill_hfid_display_label_in_db import DefaultBranchNodeCount, Migration044
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
+from infrahub.exceptions import SchemaNotFoundError
+
+from .load_schema_branch import get_or_load_schema_branch
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import ProfileSchema, TemplateSchema
+    from infrahub.database import InfrahubDatabase
+
+
+console = get_migration_console()
+
+
+class Migration045(Migration044):
+    """
+    Backfill `human_friendly_id` and `display_label` attributes for profile and template nodes with schemas that define them.
+    """
+
+    name: str = "045_backfill_hfid_display_label_in_db_profile_template"
+    minimum_version: int = 44
+    update_batch_size: int = 1000
+
+    async def execute(self, db: InfrahubDatabase) -> 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)
+        kinds_to_skip = self.kinds_to_skip + main_schema_branch.node_names
+
+        total_nodes_query = await DefaultBranchNodeCount.init(db=db, kinds_to_skip=kinds_to_skip)
+        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")
+
+        try:
+            with Progress(console=console) as progress:
+                update_task = progress.add_task(
+                    f"Set display_label and human_friendly_id for {total_nodes_count} nodes on default branch",
+                    total=total_nodes_count,
+                )
+                for node_schema_name in main_schema_branch.profile_names + main_schema_branch.template_names:
+                    if node_schema_name in self.kinds_to_skip:
+                        continue
+
+                    node_schema: ProfileSchema | TemplateSchema
+                    if node_schema_name in main_schema_branch.profile_names:
+                        node_schema = main_schema_branch.get_profile(name=node_schema_name, duplicate=False)
+                    else:
+                        node_schema = main_schema_branch.get_template(name=node_schema_name, duplicate=False)
+
+                    attribute_schema_map = {}
+                    if node_schema.display_labels:
+                        attribute_schema_map[display_labels_attribute_schema] = display_label_attribute_schema
+                    if node_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=default_branch,
+                        schema=node_schema,
+                        schema_branch=main_schema_branch,
+                        attribute_schema_map=attribute_schema_map,
+                        progress=progress,
+                        update_task=update_task,
+                    )
+
+        except Exception as exc:
+            return MigrationResult(errors=[str(exc)])
+        return MigrationResult()
+
+    async def execute_against_branch(self, db: InfrahubDatabase, branch: Branch) -> MigrationResult:
+        default_branch = await Branch.get_by_name(db=db, name=registry.default_branch)
+        main_schema_branch = await get_or_load_schema_branch(db=db, branch=default_branch)
+        schema_branch = await get_or_load_schema_branch(db=db, branch=branch)
+
+        base_node_schema = 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")
+
+        try:
+            for node_schema_name in schema_branch.profile_names + schema_branch.template_names:
+                if node_schema_name in self.kinds_to_skip:
+                    continue
+
+                node_schema: ProfileSchema | TemplateSchema
+                default_node_schema: ProfileSchema | TemplateSchema | None
+                if node_schema_name in schema_branch.profile_names:
+                    node_schema = schema_branch.get_profile(name=node_schema_name, duplicate=False)
+                    try:
+                        default_node_schema = main_schema_branch.get_profile(name=node_schema_name, duplicate=False)
+                    except SchemaNotFoundError:
+                        default_node_schema = None
+                else:
+                    node_schema = schema_branch.get_template(name=node_schema_name, duplicate=False)
+                    try:
+                        default_node_schema = main_schema_branch.get_template(name=node_schema_name, duplicate=False)
+                    except SchemaNotFoundError:
+                        default_node_schema = None
+
+                schemas_for_universal_update_map = {}
+                schemas_for_targeted_update_map = {}
+                if node_schema.display_labels:
+                    if default_node_schema is None or default_node_schema.display_label != node_schema.display_label:
+                        schemas_for_universal_update_map[display_labels_attribute_schema] = (
+                            display_label_attribute_schema
+                        )
+                    else:
+                        schemas_for_targeted_update_map[display_labels_attribute_schema] = (
+                            display_label_attribute_schema
+                        )
+
+                if node_schema.human_friendly_id:
+                    if (
+                        default_node_schema is None
+                        or default_node_schema.human_friendly_id != node_schema.human_friendly_id
+                    ):
+                        schemas_for_universal_update_map[hfid_attribute_schema] = hfid_attribute_schema
+                    else:
+                        schemas_for_targeted_update_map[hfid_attribute_schema] = hfid_attribute_schema
+
+                if schemas_for_universal_update_map:
+                    await self._do_one_schema_all(
+                        db=db,
+                        branch=branch,
+                        schema=node_schema,
+                        schema_branch=schema_branch,
+                        attribute_schema_map=schemas_for_universal_update_map,
+                    )
+
+                if not schemas_for_targeted_update_map:
+                    continue
+
+                for source_attribute_schema, destination_attribute_schema in schemas_for_targeted_update_map.items():
+                    await self._do_one_schema_branch(
+                        db=db,
+                        branch=branch,
+                        schema=node_schema,
+                        schema_branch=schema_branch,
+                        source_attribute_schema=source_attribute_schema,
+                        destination_attribute_schema=destination_attribute_schema,
+                    )
+
+        except Exception as exc:
+            return MigrationResult(errors=[str(exc)])
+        return MigrationResult()