infrahub-server 1.5.1__py3-none-any.whl → 1.5.3__py3-none-any.whl

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