infrahub-server 1.2.1__tar.gz → 1.2.2__tar.gz

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.2.1
+Version: 1.2.2
 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.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/computed_attribute/tasks.py

@@ -311,35 +311,36 @@ async def trigger_update_jinja2_computed_attributes(
 async def computed_attribute_setup_jinja2(
     service: InfrahubServices, context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None
 ) -> None:
-    log = get_run_logger()
+    async with service.database.start_session() as db:
+        log = get_run_logger()
 
-    if branch_name:
-        await add_tags(branches=[branch_name])
-        await wait_for_schema_to_converge(branch_name=branch_name, service=service, log=log)
-
-    triggers = await gather_trigger_computed_attribute_jinja2()
-
-    for trigger in triggers:
-        if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
-            await service.workflow.submit_workflow(
-                workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
-                context=context,
-                parameters={
-                    "branch_name": trigger.branch,
-                    "computed_attribute_name": trigger.computed_attribute.attribute.name,
-                    "computed_attribute_kind": trigger.computed_attribute.kind,
-                },
-            )
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            await wait_for_schema_to_converge(branch_name=branch_name, component=service.component, db=db, log=log)
 
-    # Configure all ComputedAttrJinja2Trigger in Prefect
-    async with get_client(sync_client=False) as prefect_client:
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers,
-            trigger_type=TriggerType.COMPUTED_ATTR_JINJA2,
-        )  # type: ignore[misc]
+        triggers = await gather_trigger_computed_attribute_jinja2()
+
+        for trigger in triggers:
+            if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
+                await service.workflow.submit_workflow(
+                    workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+                    context=context,
+                    parameters={
+                        "branch_name": trigger.branch,
+                        "computed_attribute_name": trigger.computed_attribute.attribute.name,
+                        "computed_attribute_kind": trigger.computed_attribute.kind,
+                    },
+                )
 
-    log.info(f"{len(triggers)} Computed Attribute for Jinja2 automation configuration completed")
+        # Configure all ComputedAttrJinja2Trigger in Prefect
+        async with get_client(sync_client=False) as prefect_client:
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers,
+                trigger_type=TriggerType.COMPUTED_ATTR_JINJA2,
+            )  # type: ignore[misc]
+
+        log.info(f"{len(triggers)} Computed Attribute for Jinja2 automation configuration completed")
 
 
 @flow(
@@ -353,46 +354,49 @@ async def computed_attribute_setup_python(
     event_name: str | None = None,
     commit: str | None = None,  # noqa: ARG001
 ) -> None:
-    log = get_run_logger()
+    async with service.database.start_session() as db:
+        log = get_run_logger()
+
+        branch_name = branch_name or registry.default_branch
 
-    branch_name = branch_name or registry.default_branch
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            await wait_for_schema_to_converge(branch_name=branch_name, component=service.component, db=db, log=log)
 
-    if branch_name:
-        await add_tags(branches=[branch_name])
-        await wait_for_schema_to_converge(branch_name=branch_name, service=service, log=log)
+        triggers_python, triggers_python_query = await gather_trigger_computed_attribute_python(db=db)
 
-    triggers_python, triggers_python_query = await gather_trigger_computed_attribute_python(db=service.database)
+        for trigger in triggers_python:
+            if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
+                log.info(
+                    f"Triggering update for {trigger.computed_attribute.computed_attribute.attribute.name} on {branch_name}"
+                )
+                await service.workflow.submit_workflow(
+                    workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+                    context=context,
+                    parameters={
+                        "branch_name": branch_name,
+                        "computed_attribute_name": trigger.computed_attribute.computed_attribute.attribute.name,
+                        "computed_attribute_kind": trigger.computed_attribute.computed_attribute.kind,
+                    },
+                )
 
-    for trigger in triggers_python:
-        if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
+        async with get_client(sync_client=False) as prefect_client:
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers_python,
+                trigger_type=TriggerType.COMPUTED_ATTR_PYTHON,
+            )  # type: ignore[misc]
+            log.info(f"{len(triggers_python)} Computed Attribute for Python automation configuration completed")
+
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers_python_query,
+                trigger_type=TriggerType.COMPUTED_ATTR_PYTHON_QUERY,
+            )  # type: ignore[misc]
             log.info(
-                f"Triggering update for {trigger.computed_attribute.computed_attribute.attribute.name} on {branch_name}"
-            )
-            await service.workflow.submit_workflow(
-                workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
-                context=context,
-                parameters={
-                    "branch_name": branch_name,
-                    "computed_attribute_name": trigger.computed_attribute.computed_attribute.attribute.name,
-                    "computed_attribute_kind": trigger.computed_attribute.computed_attribute.kind,
-                },
+                f"{len(triggers_python_query)} Computed Attribute for Python Query automation configuration completed"
             )
 
-    async with get_client(sync_client=False) as prefect_client:
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers_python,
-            trigger_type=TriggerType.COMPUTED_ATTR_PYTHON,
-        )  # type: ignore[misc]
-        log.info(f"{len(triggers_python)} Computed Attribute for Python automation configuration completed")
-
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers_python_query,
-            trigger_type=TriggerType.COMPUTED_ATTR_PYTHON_QUERY,
-        )  # type: ignore[misc]
-        log.info(f"{len(triggers_python_query)} Computed Attribute for Python Query automation configuration completed")
-
 
 @flow(
     name="query-computed-attribute-transform-targets",

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/core/query/node.py

@@ -8,6 +8,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, AsyncIterator, Generator
 
 from infrahub import config
+from infrahub.core import registry
 from infrahub.core.constants import (
     AttributeDBNodeType,
     RelationshipDirection,
@@ -713,14 +714,24 @@ class NodeGetKindQuery(Query):
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params["ids"] = self.ids
         query = """
-        MATCH p = (root:Root)<-[r_root:IS_PART_OF]-(n:Node)
-        WHERE n.uuid IN $ids
+MATCH (n:Node)-[r:IS_PART_OF {status: "active"}]->(:Root)
+WHERE toString(n.uuid) IN $ids
+        """
+        # only add the branch filter logic if a branch is included in the query parameters
+        if branch := getattr(self, "branch", None):
+            branch = await registry.get_branch(db=db, branch=branch)
+            branch_filter, branch_params = branch.get_query_filter_path(at=self.at)
+            self.params.update(branch_params)
+            query += f"AND {branch_filter}"
+        query += """
+WITH n.uuid AS node_id, n.kind AS node_kind
+ORDER BY r.from DESC
+WITH node_id, head(collect(node_kind)) AS node_kind
         """
         self.add_to_query(query)
-        self.params["ids"] = self.ids
-
-        self.return_labels = ["n.uuid AS node_id", "n.kind AS node_kind"]
+        self.return_labels = ["node_id", "node_kind"]
 
     async def get_node_kind_map(self) -> dict[str, str]:
         node_kind_map: dict[str, str] = {}

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/exceptions.py

@@ -76,6 +76,32 @@ class RepositoryError(Error):
         super().__init__(self.message)
 
 
+class RepositoryConnectionError(RepositoryError):
+    def __init__(self, identifier: str, message: str | None = None) -> None:
+        super().__init__(
+            identifier=identifier,
+            message=message
+            or f"Unable to clone the repository {identifier}, please check the address and the credential",
+        )
+
+
+class RepositoryCredentialsError(RepositoryError):
+    def __init__(self, identifier: str, message: str | None = None) -> None:
+        super().__init__(
+            identifier=identifier,
+            message=message or f"Authentication failed for {identifier}, please validate the credentials.",
+        )
+
+
+class RepositoryInvalidBranchError(RepositoryError):
+    def __init__(self, identifier: str, branch_name: str, location: str, message: str | None = None) -> None:
+        super().__init__(
+            identifier=identifier,
+            message=message
+            or f"The branch {branch_name} isn't a valid branch for the repository {identifier} at {location}.",
+        )
+
+
 class RepositoryInvalidFileSystemError(RepositoryError):
     def __init__(
         self,
@@ -83,9 +109,11 @@ class RepositoryInvalidFileSystemError(RepositoryError):
         directory: Path,
         message: str | None = None,
     ) -> None:
-        super().__init__(identifier=identifier)
+        super().__init__(
+            identifier=identifier,
+            message=message or f"Invalid file system for {identifier}, Local directory {directory} missing.",
+        )
         self.directory = directory
-        self.message = message or f"Invalid file system for {identifier}, Local directory {directory} missing."
 
 
 class CommitNotFoundError(Error):

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/git/base.py

@@ -17,13 +17,16 @@ from pydantic import BaseModel, ConfigDict, Field
 from pydantic import ValidationError as PydanticValidationError
 
 from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, RepositoryOperationalStatus, RepositorySyncStatus
 from infrahub.core.registry import registry
 from infrahub.exceptions import (
     CommitNotFoundError,
     FileOutOfRepositoryError,
+    RepositoryConnectionError,
+    RepositoryCredentialsError,
     RepositoryError,
     RepositoryFileNotFoundError,
+    RepositoryInvalidBranchError,
     RepositoryInvalidFileSystemError,
 )
 from infrahub.git.constants import BRANCHES_DIRECTORY_NAME, COMMITS_DIRECTORY_NAME, TEMPORARY_DIRECTORY_NAME
@@ -200,6 +203,54 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         """Return the path to the directory where the temp worktrees of all the commits pending validation are stored."""
         return self.directory_root / TEMPORARY_DIRECTORY_NAME
 
+    async def _update_operational_status(self, status: RepositoryOperationalStatus) -> None:
+        update_status = """
+        mutation UpdateRepositoryStatus(
+            $repo_id: String!,
+            $status: String!,
+        ) {
+            CoreGenericRepositoryUpdate(
+                data: {
+                    id: $repo_id,
+                    operational_status: { value: $status },
+                }
+            ) {
+                ok
+            }
+        }
+        """
+
+        await self.sdk.execute_graphql(
+            branch_name=self.infrahub_branch_name or registry.default_branch,
+            query=update_status,
+            variables={"repo_id": str(self.id), "status": status.value},
+            tracker="mutation-repository-update-operational-status",
+        )
+
+    async def _update_sync_status(self, branch_name: str, status: RepositorySyncStatus) -> None:
+        update_status = """
+        mutation UpdateRepositoryStatus(
+            $repo_id: String!,
+            $status: String!,
+        ) {
+            CoreGenericRepositoryUpdate(
+                data: {
+                    id: $repo_id,
+                    sync_status: { value: $status },
+                }
+            ) {
+                ok
+            }
+        }
+        """
+
+        await self.sdk.execute_graphql(
+            branch_name=branch_name,
+            query=update_status,
+            variables={"repo_id": str(self.id), "status": status.value},
+            tracker="mutation-repository-update-admin-status",
+        )
+
     def get_git_repo_main(self) -> Repo:
         """Return Git Repo object of the main repository.
 
@@ -340,7 +391,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
             repo = Repo.clone_from(self.location, self.directory_default)
             repo.git.checkout(checkout_ref or self.default_branch)
         except GitCommandError as exc:
-            self._raise_enriched_error(error=exc)
+            await self._raise_enriched_error(error=exc)
 
         self.has_origin = True
 
@@ -572,7 +623,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
             try:
                 br_repo.remotes.origin.pull(branch_name)
             except GitCommandError as exc:
-                self._raise_enriched_error(error=exc, branch_name=branch_name)
+                await self._raise_enriched_error(error=exc, branch_name=branch_name)
             self.create_commit_worktree(str(br_repo.head.reference.commit))
             log.debug(
                 f"Branch {branch_name} created in Git, tracking remote branch {remote_branch[0]}.",
@@ -668,7 +719,9 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         try:
             repo.remotes.origin.fetch()
         except GitCommandError as exc:
-            self._raise_enriched_error(error=exc)
+            await self._raise_enriched_error(error=exc)
+
+        await self._update_operational_status(status=RepositoryOperationalStatus.ONLINE)
 
         return True
 
@@ -765,7 +818,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
                 commit_before = str(repo.head.commit)
                 repo.remotes.origin.pull(branch_name)
             except GitCommandError as exc:
-                self._raise_enriched_error(error=exc, branch_name=branch_name)
+                await self._raise_enriched_error(error=exc, branch_name=branch_name)
 
             commit_after = str(repo.head.commit)
 
@@ -862,37 +915,41 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         except GitCommandError as exc:
             cls._raise_enriched_error_static(name=name, location=url, error=exc)
 
-    def _raise_enriched_error(self, error: GitCommandError, branch_name: str | None = None) -> NoReturn:
-        self._raise_enriched_error_static(
-            error=error, name=self.name, location=self.location, branch_name=branch_name or self.default_branch
-        )
+    async def _raise_enriched_error(self, error: GitCommandError, branch_name: str | None = None) -> NoReturn:
+        try:
+            self._raise_enriched_error_static(
+                error=error, name=self.name, location=self.location, branch_name=branch_name or self.default_branch
+            )
+        except RepositoryError as exc:
+            await self._update_operational_status(
+                status={
+                    RepositoryConnectionError: RepositoryOperationalStatus.ERROR_CONNECTION,
+                    RepositoryCredentialsError: RepositoryOperationalStatus.ERROR_CRED,
+                }.get(type(exc), RepositoryOperationalStatus.ERROR)
+            )
+            raise
 
     @staticmethod
     def _raise_enriched_error_static(
         error: GitCommandError, name: str, location: str, branch_name: str | None = None
     ) -> NoReturn:
         if "Repository not found" in error.stderr or "does not appear to be a git" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"Unable to clone the repository {name}, please check the address and the credential",
-            ) from error
+            raise RepositoryConnectionError(identifier=name) from error
 
         if "error: pathspec" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"The branch {branch_name} isn't a valid branch for the repository {name} at {location}.",
-            ) from error
+            raise RepositoryInvalidBranchError(identifier=name, branch_name=branch_name, location=location) from error
 
         if "SSL certificate problem" in error.stderr or "server certificate verification failed" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"SSL verification failed for {name}, please validate the certificate chain.",
+            raise RepositoryConnectionError(
+                identifier=name, message=f"SSL verification failed for {name}, please validate the certificate chain."
             ) from error
 
         if "authentication failed for" in error.stderr.lower():
-            raise RepositoryError(
-                identifier=name,
-                message=f"Authentication failed for {name}, please validate the credentials.",
+            raise RepositoryCredentialsError(identifier=name) from error
+
+        if "fatal: could not read Username for" in error.stderr and "terminal prompts disable" in error.stderr:
+            raise RepositoryCredentialsError(
+                identifier=name, message=f"Unable to correctly lookup credentials for repository {name} ({location})."
             ) from error
 
         if any(err in error.stderr for err in ("Need to specify how to reconcile", "because you have unmerged files")):
@@ -901,12 +958,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
                 message=f"Unable to pull the branch {branch_name} for repository {name}, there are conflicts that must be resolved.",
             ) from error
 
-        if "fatal: could not read Username for" in error.stderr and "terminal prompts disable" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"Unable to correctly lookup credentials for repository {name} ({location}).",
-            ) from error
-
         raise RepositoryError(identifier=name, message=error.stderr) from error
 
     def _get_mapped_remote_branch(self, branch_name: str) -> str:

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/git/integrator.py

@@ -212,30 +212,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             )
         )
 
-    async def _update_sync_status(self, branch_name: str, status: RepositorySyncStatus) -> None:
-        update_status = """
-        mutation UpdateRepositoryStatus(
-            $repo_id: String!,
-            $status: String!,
-            ) {
-            CoreGenericRepositoryUpdate(
-                data: {
-                    id: $repo_id,
-                    sync_status: { value: $status },
-                }
-            ) {
-                ok
-            }
-        }
-        """
-
-        await self.sdk.execute_graphql(
-            branch_name=branch_name,
-            query=update_status,
-            variables={"repo_id": str(self.id), "status": status.value},
-            tracker="mutation-repository-update-admin-status",
-        )
-
     @task(name="import-jinja2-tansforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_jinja2_transforms(
         self,

infrahub_server-1.2.2/backend/infrahub/trigger/tasks.py

@@ -0,0 +1,37 @@
+from prefect import flow
+from prefect.client.orchestration import get_client
+
+from infrahub.computed_attribute.gather import (
+    gather_trigger_computed_attribute_jinja2,
+    gather_trigger_computed_attribute_python,
+)
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.catalogue import builtin_triggers
+from infrahub.webhook.gather import gather_trigger_webhook
+
+from .setup import setup_triggers
+
+
+@flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
+async def trigger_configure_all(service: InfrahubServices) -> None:
+    async with service.database.start_session() as db:
+        webhook_trigger = await gather_trigger_webhook(db=db)
+        computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
+        (
+            computed_attribute_python_triggers,
+            computed_attribute_python_query_triggers,
+        ) = await gather_trigger_computed_attribute_python(db=db)
+
+        triggers = (
+            computed_attribute_j2_triggers
+            + computed_attribute_python_triggers
+            + computed_attribute_python_query_triggers
+            + builtin_triggers
+            + webhook_trigger
+        )
+
+        async with get_client(sync_client=False) as prefect_client:
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers,
+            )

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/backend/infrahub/workflows/utils.py

@@ -15,7 +15,8 @@ from .constants import TAG_NAMESPACE, WorkflowTag
 if TYPE_CHECKING:
     import logging
 
-    from infrahub.services import InfrahubServices
+    from infrahub.database import InfrahubDatabase
+    from infrahub.services import InfrahubComponent
 
 
 async def add_tags(
@@ -56,7 +57,7 @@ async def add_related_node_tag(node_id: str) -> None:
 
 
 async def wait_for_schema_to_converge(
-    branch_name: str, service: InfrahubServices, log: logging.Logger | logging.LoggerAdapter
+    branch_name: str, component: InfrahubComponent, db: InfrahubDatabase, log: logging.Logger | logging.LoggerAdapter
 ) -> None:
     has_converged = False
     branch_id = branch_name
@@ -67,7 +68,7 @@ async def wait_for_schema_to_converge(
     max_iterations = delay * 5 * 30
     iteration = 0
     while not has_converged:
-        workers = await service.component.list_workers(branch=branch_id, schema_hash=True)
+        workers = await component.list_workers(branch=branch_id, schema_hash=True)
 
         hashes = {worker.schema_hash for worker in workers if worker.active}
         if len(hashes) == 1:
@@ -79,8 +80,7 @@ async def wait_for_schema_to_converge(
             log.warning(
                 f"Schema had not converged after {delay * iteration:.2f} seconds, refreshing schema on local worker manually"
             )
-            async with service.database.start_session() as db:
-                await refresh_branches(db=db)
+            await refresh_branches(db=db)
             return
 
         iteration += 1

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "infrahub-server"
-version = "1.2.1"
+version = "1.2.2"
 description = "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."
 authors = ["OpsMill <info@opsmill.com>"]
 readme = "README.md"

{infrahub_server-1.2.1 → infrahub_server-1.2.2}/python_sdk/infrahub_sdk/node.py

@@ -1418,8 +1418,10 @@ class InfrahubNode(InfrahubNodeBase):
     ) -> None:
         mutation_query = self._generate_mutation_query()
 
+        # Upserting means we may want to create, meaning payload contains all mandatory fields required for a creation,
+        # so hfid is just redondant information. Currently, upsert mutation has performance overhead if `hfid` is filled.
         if allow_upsert:
-            input_data = self._generate_input_data(exclude_hfid=False, request_context=request_context)
+            input_data = self._generate_input_data(exclude_hfid=True, request_context=request_context)
             mutation_name = f"{self._schema.kind}Upsert"
             tracker = f"mutation-{str(self._schema.kind).lower()}-upsert"
         else:

infrahub_server-1.2.1/backend/infrahub/trigger/tasks.py

@@ -1,36 +0,0 @@
-from prefect import flow
-from prefect.client.orchestration import get_client
-
-from infrahub.computed_attribute.gather import (
-    gather_trigger_computed_attribute_jinja2,
-    gather_trigger_computed_attribute_python,
-)
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
-from infrahub.trigger.catalogue import builtin_triggers
-from infrahub.webhook.gather import gather_trigger_webhook
-
-from .setup import setup_triggers
-
-
-@flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
-async def trigger_configure_all(service: InfrahubServices) -> None:
-    webhook_trigger = await gather_trigger_webhook(db=service.database)
-    computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
-    (
-        computed_attribute_python_triggers,
-        computed_attribute_python_query_triggers,
-    ) = await gather_trigger_computed_attribute_python(db=service.database)
-
-    triggers = (
-        computed_attribute_j2_triggers
-        + computed_attribute_python_triggers
-        + computed_attribute_python_query_triggers
-        + builtin_triggers
-        + webhook_trigger
-    )
-
-    async with get_client(sync_client=False) as prefect_client:
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers,
-        )