infrahub-server 1.1.6__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/generators/tasks.py

@@ -1,13 +1,18 @@
 from __future__ import annotations
 
+import asyncio
+from typing import TYPE_CHECKING, Any
+
 from infrahub_sdk.exceptions import ModuleImportError
 from infrahub_sdk.node import InfrahubNode
 from infrahub_sdk.protocols import CoreGeneratorInstance
 from infrahub_sdk.schema.repository import InfrahubGeneratorDefinitionConfig
-from prefect import flow, task
+from prefect import State, flow, task
 from prefect.cache_policies import NONE
+from prefect.states import Completed, Failed
 
 from infrahub import lock
+from infrahub.context import InfrahubContext  # noqa: TC001 needed for prefect flow
 from infrahub.core.constants import GeneratorInstanceStatus, InfrahubKind
 from infrahub.generators.models import (
     ProposedChangeGeneratorDefinition,
@@ -16,18 +21,19 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import InfrahubServices, services
+from infrahub.services import InfrahubServices  # noqa: TC001 needed for prefect flow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
 
+if TYPE_CHECKING:
+    from collections.abc import Coroutine
+
 
 @flow(
     name="generator-run",
     flow_run_name="Run generator {model.generator_definition.definition_name}",
 )
-async def run_generator(model: RequestGeneratorRun) -> None:
-    service = services.service
-
+async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -> None:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
 
     repository = await get_initialized_repo(
@@ -80,7 +86,7 @@ async def run_generator(model: RequestGeneratorRun) -> None:
     await generator_instance.update(do_full_update=True)
 
 
-@task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)
+@task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)  # type: ignore[arg-type]
 async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices) -> CoreGeneratorInstance:
     if model.generator_instance:
         instance = await service.client.get(
@@ -119,9 +125,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
 
 
 @flow(name="generator-definition-run", flow_run_name="Run all generators")
-async def run_generator_definition(branch: str) -> None:
-    service = services.service
-
+async def run_generator_definition(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
     await add_tags(branches=[branch])
 
     generators = await service.client.filters(
@@ -146,16 +150,18 @@ async def run_generator_definition(branch: str) -> None:
 
     for generator_definition in generator_definitions:
         model = RequestGeneratorDefinitionRun(branch=branch, generator_definition=generator_definition)
-        await service.workflow.submit_workflow(workflow=REQUEST_GENERATOR_DEFINITION_RUN, parameters={"model": model})
+        await service.workflow.submit_workflow(
+            workflow=REQUEST_GENERATOR_DEFINITION_RUN, context=context, parameters={"model": model}
+        )
 
 
 @flow(
     name="request-generator-definition-run",
     flow_run_name="Execute generator {model.generator_definition.definition_name}",
 )
-async def request_generator_definition_run(model: RequestGeneratorDefinitionRun) -> None:
-    service = services.service
-
+async def request_generator_definition_run(
+    model: RequestGeneratorDefinitionRun, context: InfrahubContext, service: InfrahubServices
+) -> State[Any]:
     await add_tags(branches=[model.branch], nodes=[model.generator_definition.definition_id])
 
     group = await service.client.get(
@@ -191,8 +197,13 @@ async def request_generator_definition_run(model: RequestGeneratorDefinitionRun)
             raise_when_missing=True,
         )
 
+    tasks: list[Coroutine[Any, Any, Any]] = []
     for relationship in group.members.peers:
         member = relationship.peer
+
+        if model.target_members and member.id not in model.target_members:
+            continue
+
         generator_instance = instance_by_member.get(member.id)
         request_generator_run_model = RequestGeneratorRun(
             generator_definition=model.generator_definition,
@@ -207,6 +218,14 @@ async def request_generator_definition_run(model: RequestGeneratorDefinitionRun)
             target_id=member.id,
             target_name=member.display_label,
         )
-        await service.workflow.submit_workflow(
-            workflow=REQUEST_GENERATOR_RUN, parameters={"model": request_generator_run_model}
+        tasks.append(
+            service.workflow.execute_workflow(
+                workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
+            )
         )
+
+    try:
+        await asyncio.gather(*tasks)
+        return Completed(message=f"Successfully run {len(tasks)} generators")
+    except Exception as exc:
+        return Failed(message="One or more generators failed", error=exc)

infrahub/git/base.py

@@ -122,7 +122,7 @@ class BranchInLocal(BaseModel):
     has_worktree: bool = False
 
 
-class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public-methods
+class InfrahubRepositoryBase(BaseModel, ABC):
     """
     Local version of a Git repository organized to work with Infrahub.
     The idea is that all commits that are being tracked in the graph will be checkout out
@@ -395,9 +395,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public
         return [Worktree.init(response) for response in responses]
 
     def get_client(self) -> InfrahubClient:
-        if self.client:
-            return self.client
-        return self.service.client
+        return self.sdk
 
     def get_location(self) -> str:
         if self.location:
@@ -702,7 +700,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):  # pylint: disable=too-many-public
                 log.info("New commit detected", repository=self.name, branch=branch_name)
                 updated_branches.append(branch_name)
 
-        return sorted(list(new_branches)), sorted(updated_branches)
+        return sorted(new_branches), sorted(updated_branches)
 
     def validate_remote_branch(self, branch_name: str) -> bool:
         """Process a remote branch to validate that we can use it safely.

infrahub/git/constants.py

@@ -1,4 +1,3 @@
-AUTOMATION_NAME = "Trigger-repository-commit-update-event"
 COMMITS_DIRECTORY_NAME = "commits"
 BRANCHES_DIRECTORY_NAME = "branches"
 TEMPORARY_DIRECTORY_NAME = "temp"

infrahub/git/integrator.py

@@ -38,10 +38,13 @@ from pydantic import ValidationError as PydanticValidationError
 from typing_extensions import Self
 
 from infrahub.core.constants import ArtifactStatus, ContentType, InfrahubKind, RepositorySyncStatus
+from infrahub.core.registry import registry
+from infrahub.events.artifact_action import ArtifactEvent
+from infrahub.events.models import EventMeta
 from infrahub.events.repository_action import CommitUpdatedEvent
 from infrahub.exceptions import CheckError, RepositoryInvalidFileSystemError, TransformError
 from infrahub.git.base import InfrahubRepositoryBase, extract_repo_file_information
-from infrahub.services import InfrahubServices
+from infrahub.log import get_logger
 from infrahub.workflows.utils import add_tags
 
 if TYPE_CHECKING:
@@ -52,10 +55,9 @@ if TYPE_CHECKING:
     from infrahub_sdk.schema.repository import InfrahubRepositoryArtifactDefinitionConfig
     from infrahub_sdk.transforms import InfrahubTransform
 
+    from infrahub.artifacts.models import CheckArtifactCreate
     from infrahub.git.models import RequestArtifactGenerate
-    from infrahub.message_bus import messages
-
-# pylint: disable=too-many-lines
+    from infrahub.services import InfrahubServices
 
 
 class ArtifactGenerateResult(BaseModel):
@@ -120,7 +122,7 @@ class TransformPythonInformation(BaseModel):
     """Timeout for the function."""
 
 
-class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=too-many-public-methods
+class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     """
     This class provides interfaces to read and process information from .infrahub.yml files and can perform
     actions for objects defined within those files.
@@ -130,20 +132,20 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
     """
 
     @classmethod
-    async def init(cls, commit: str | None = None, service: InfrahubServices | None = None, **kwargs: Any) -> Self:
-        service = service or InfrahubServices()
+    async def init(cls, service: InfrahubServices, commit: str | None = None, **kwargs: Any) -> Self:
         self = cls(service=service, **kwargs)
+        log = get_logger()
         try:
             self.validate_local_directories()
         except RepositoryInvalidFileSystemError:
             await self.ensure_location_is_defined()
             await self.create_locally(infrahub_branch_name=self.infrahub_branch_name, update_commit_value=False)
-            service.log.info(f"Initialized the local directory for {self.name} because it was missing.")
+            log.info(f"Initialized the local directory for {self.name} because it was missing.")
 
         if commit:
             self.get_commit_worktree(commit=commit)
 
-        service.log.debug(
+        log.debug(
             f"Initiated the object on an existing directory for {self.name}",
         )
         return self
@@ -181,7 +183,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )
 
-                await self.import_all_python_files(
+                await self.import_all_python_files(  # type: ignore[call-overload]
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )
                 await self.import_jinja2_transforms(
@@ -191,7 +193,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )
 
-        except Exception as exc:  # pylint: disable=broad-exception-caught
+        except Exception as exc:
             sync_status = RepositorySyncStatus.ERROR_IMPORT
             error = exc
 
@@ -200,9 +202,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         if error:
             raise error
 
+        infrahub_branch = registry.get_branch_from_registry(branch=infrahub_branch_name)
         await self.service.event.send(
             CommitUpdatedEvent(
-                branch=infrahub_branch_name, commit=commit, repository_name=self.name, repository_id=str(self.id)
+                commit=commit,
+                repository_name=self.name,
+                repository_id=str(self.id),
+                meta=EventMeta.with_dummy_context(branch=infrahub_branch),
             )
         )
 
@@ -230,11 +236,11 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             tracker="mutation-repository-update-admin-status",
         )
 
-    @task(name="import-jinja2-tansforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)
+    @task(name="import-jinja2-tansforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_jinja2_transforms(
         self,
         branch_name: str,
-        commit: str,  # pylint: disable=unused-argument
+        commit: str,  # noqa: ARG002
         config_file: InfrahubRepositoryConfig,
     ) -> None:
         log = get_run_logger()
@@ -312,7 +318,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
     async def compare_jinja2_transform(
         cls, existing_transform: CoreTransformJinja2, local_transform: InfrahubRepositoryJinja2
     ) -> bool:
-        # pylint: disable=no-member
         if (
             existing_transform.description.value != local_transform.description
             or existing_transform.template_path.value != local_transform.template_path
@@ -325,7 +330,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
     async def update_jinja2_transform(
         self, existing_transform: CoreTransformJinja2, local_transform: InfrahubRepositoryJinja2
     ) -> None:
-        # pylint: disable=no-member
         if existing_transform.description.value != local_transform.description:
             existing_transform.description.value = local_transform.description
 
@@ -337,11 +341,11 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
 
         await existing_transform.save()
 
-    @task(name="import-artifact-definitions", task_run_name="Import Artifact Definitions", cache_policy=NONE)
+    @task(name="import-artifact-definitions", task_run_name="Import Artifact Definitions", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_artifact_definitions(
         self,
         branch_name: str,
-        commit: str,  # pylint: disable=unused-argument
+        commit: str,  # noqa: ARG002
         config_file: InfrahubRepositoryConfig,
     ) -> None:
         log = get_run_logger()
@@ -438,7 +442,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
 
         await existing_artifact_definition.save()
 
-    @task(name="repository-get-config", task_run_name="get repository config", cache_policy=NONE)
+    @task(name="repository-get-config", task_run_name="get repository config", cache_policy=NONE)  # type: ignore[arg-type]
     async def get_repository_config(self, branch_name: str, commit: str) -> Optional[InfrahubRepositoryConfig]:
         branch_wt = self.get_worktree(identifier=commit or branch_name)
         log = get_run_logger()
@@ -467,9 +471,8 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             log.error(f"Unable to load the configuration file {config_file_name}, the format is not valid  : {exc}")
             return None
 
-    @task(name="import-schema-files", task_run_name="Import schema files", cache_policy=NONE)
+    @task(name="import-schema-files", task_run_name="Import schema files", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_schema_files(self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig) -> None:
-        # pylint: disable=too-many-branches
         log = get_run_logger()
         branch_wt = self.get_worktree(identifier=commit or branch_name)
 
@@ -540,7 +543,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         for schema_file in schemas_data:
             log.info(f"schema '{schema_file.identifier}' loaded successfully!")
 
-    @task(name="import-graphql-queries", task_run_name="Import GraphQL Queries", cache_policy=NONE)
+    @task(name="import-graphql-queries", task_run_name="Import GraphQL Queries", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_all_graphql_query(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -598,7 +601,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         await obj.save()
         return obj
 
-    @task(name="import-python-check-definitions", task_run_name="Import Python Check Definitions", cache_policy=NONE)
+    @task(name="import-python-check-definitions", task_run_name="Import Python Check Definitions", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_python_check_definitions(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -669,7 +672,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             log.info(f"CheckDefinition '{check_name!r}' not found locally, deleting")
             await check_definition_in_graph[check_name].delete()
 
-    @task(name="import-generator-definitions", task_run_name="Import Generator Definitions", cache_policy=NONE)
+    @task(name="import-generator-definitions", task_run_name="Import Generator Definitions", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_generator_definitions(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -748,7 +751,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         if targets:
             generator.targets = targets[0].id
 
-        if (  # pylint: disable=too-many-boolean-expressions
+        if (
             existing_generator.query.id != generator.query
             or existing_generator.file_path.value != str(generator.file_path)
             or existing_generator.class_name.value != generator.class_name
@@ -759,7 +762,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             return True
         return False
 
-    @task(name="import-python-transforms", task_run_name="Import Python Transforms", cache_policy=NONE)
+    @task(name="import-python-transforms", task_run_name="Import Python Transforms", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_python_transforms(
         self, branch_name: str, commit: str, config_file: InfrahubRepositoryConfig
     ) -> None:
@@ -830,7 +833,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             log.info(f"TransformPython {transform_name!r} not found locally, deleting")
             await transform_definition_in_graph[transform_name].delete()
 
-    @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)
+    @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)  # type: ignore[arg-type]
     async def get_check_definition(
         self,
         branch_name: str,
@@ -863,14 +866,14 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
                 )
             )
 
-        except Exception as exc:  # pylint: disable=broad-exception-caught
+        except Exception as exc:
             log.error(
                 f"An error occurred while processing the CheckDefinition {check_class.__name__} from {file_path} : {exc} "
             )
             raise
         return checks
 
-    @task(name="python-transform-get", task_run_name="Get Python Transform", cache_policy=NONE)
+    @task(name="python-transform-get", task_run_name="Get Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def get_python_transforms(
         self, branch_name: str, module: types.ModuleType, file_path: str, transform: InfrahubPythonTransformConfig
     ) -> list[TransformPythonInformation]:
@@ -896,7 +899,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
                 )
             )
 
-        except Exception as exc:  # pylint: disable=broad-exception-caught
+        except Exception as exc:
             log.error(
                 f"An error occurred while processing the PythonTransform {transform.name} from {file_path} : {exc} "
             )
@@ -1003,7 +1006,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
     ) -> bool:
         """Compare an existing Python Check Object with a Check Class
         and identify if we need to update the object in the database."""
-        # pylint: disable=too-many-boolean-expressions
         if (
             existing_check.query.id != check.query
             or existing_check.file_path.value != check.file_path
@@ -1072,7 +1074,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         await self.import_python_transforms(branch_name=branch_name, commit=commit, config_file=config_file)
         await self.import_generator_definitions(branch_name=branch_name, commit=commit, config_file=config_file)
 
-    @task(name="jinja2-template-render", task_run_name="Render Jinja2 template", cache_policy=NONE)
+    @task(name="jinja2-template-render", task_run_name="Render Jinja2 template", cache_policy=NONE)  # type: ignore[arg-type]
     async def render_jinja2_template(self, commit: str, location: str, data: dict) -> str:
         log = get_run_logger()
         commit_worktree = self.get_commit_worktree(commit=commit)
@@ -1088,7 +1090,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             log.error(str(exc), exc_info=True)
             raise TransformError(repository_name=self.name, commit=commit, location=location, message=str(exc)) from exc
 
-    @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)
+    @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_check(
         self,
         branch_name: str,
@@ -1147,9 +1149,9 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
                 repository_name=self.name, class_name=class_name, commit=commit, location=location, message=str(exc)
             ) from exc
 
-    @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)
+    @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_transform(
-        self, branch_name: str, commit: str, location: str, client: InfrahubClient, data: Optional[dict] = None
+        self, branch_name: str, commit: str, location: str, client: InfrahubClient, data: dict | None = None
     ) -> Any:
         """Execute A Python Transform stored in the repository."""
         log = get_run_logger()
@@ -1265,7 +1267,10 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         return ArtifactGenerateResult(changed=True, checksum=checksum, storage_id=storage_id, artifact_id=artifact.id)
 
     async def render_artifact(
-        self, artifact: CoreArtifact, message: Union[messages.CheckArtifactCreate, RequestArtifactGenerate]
+        self,
+        artifact: CoreArtifact,
+        artifact_created: bool,
+        message: Union[CheckArtifactCreate, RequestArtifactGenerate],
     ) -> ArtifactGenerateResult:
         response = await self.sdk.query_gql_query(
             name=message.query,
@@ -1276,6 +1281,10 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
             branch_name=message.branch_name,
             timeout=message.timeout,
         )
+        branch = registry.get_branch_from_registry(branch=message.branch_name)
+
+        previous_checksum = artifact.checksum.value
+        previous_storage_id = artifact.storage_id.value
 
         if message.transform_type == InfrahubKind.TRANSFORMJINJA2:
             artifact_content = await self.render_jinja2_template.with_options(timeout_seconds=message.timeout)(
@@ -1314,4 +1323,19 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):  # pylint: disable=t
         if artifact.name.value != message.artifact_name:
             artifact.name.value = message.artifact_name
         await artifact.save()
+
+        event = ArtifactEvent(
+            node_id=artifact.id,
+            target_id=message.target_id,
+            target_kind=message.target_kind,
+            artifact_definition_id=message.artifact_definition,
+            meta=EventMeta.from_context(context=message.context, branch=branch),
+            checksum=checksum,
+            checksum_previous=previous_checksum,
+            storage_id=storage_id,
+            storage_id_previous=previous_storage_id,
+            created=artifact_created,
+        )
+
+        await self.service.event.send(event=event)
         return ArtifactGenerateResult(changed=True, checksum=checksum, storage_id=storage_id, artifact_id=artifact.id)

infrahub/git/models.py

@@ -1,6 +1,9 @@
 from typing import Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
+
+from infrahub.context import InfrahubContext
+from infrahub.message_bus.types import ProposedChangeBranchDiff
 
 
 class RequestArtifactDefinitionGenerate(BaseModel):
@@ -29,11 +32,13 @@ class RequestArtifactGenerate(BaseModel):
     repository_kind: str = Field(..., description="The kind of the Repository")
     branch_name: str = Field(..., description="The branch where the check is run")
     target_id: str = Field(..., description="The ID of the target object for this artifact")
+    target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")
     artifact_id: Optional[str] = Field(default=None, description="The id of the artifact if it previously existed")
     query: str = Field(..., description="The name of the query to use when collecting data")
     timeout: int = Field(..., description="Timeout for requests used to generate this artifact")
     variables: dict = Field(..., description="Input variables when generating the artifact")
+    context: InfrahubContext = Field(..., description="The context of the task")
 
 
 class GitRepositoryAdd(BaseModel):
@@ -110,3 +115,77 @@ class GitDiffNamesOnlyResponse(BaseModel):
     files_added: list[str] = Field(..., description="Files added")
     files_changed: list[str] = Field(..., description="Files changed")
     files_removed: list[str] = Field(..., description="Files removed")
+
+
+class UserCheckDefinitionData(BaseModel):
+    """Triggers user defined checks to run based on a Check Definition."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    check_definition_id: str = Field(..., description="The unique ID of the check definition")
+    commit: str = Field(..., description="The commit to target")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the Repository")
+    branch_name: str = Field(..., description="The branch where the check is run")
+    file_path: str = Field(..., description="The path and filename of the check")
+    class_name: str = Field(..., description="The name of the class containing the check")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+
+
+class UserCheckData(BaseModel):
+    """Runs a check as defined within a CoreCheckDefinition within a repository."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    validator_id: str = Field(..., description="The id of the validator associated with this check")
+    validator_execution_id: str = Field(..., description="The id of current execution of the associated validator")
+    check_execution_id: str = Field(..., description="The unique ID for the current execution of this check")
+    check_definition_id: str = Field(..., description="The unique ID of the check definition")
+    commit: str = Field(..., description="The commit to target")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the Repository")
+    branch_name: str = Field(..., description="The branch where the check is run")
+    file_path: str = Field(..., description="The path and filename of the check")
+    class_name: str = Field(..., description="The name of the class containing the check")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    variables: dict = Field(default_factory=dict, description="Input variables when running the check")
+    name: str = Field(..., description="The name of the check")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+    timeout: int = Field(..., description="The timeout for the check")
+
+
+class TriggerRepositoryUserChecks(BaseModel):
+    """Sent to trigger the user defined checks on a repository."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the Repository")
+    source_branch: str = Field(..., description="The source branch")
+    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
+    target_branch: str = Field(..., description="The target branch")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+
+
+class TriggerRepositoryInternalChecks(BaseModel):
+    """Sent to trigger the checks for a repository to be executed."""
+
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    repository: str = Field(..., description="The unique ID of the Repository")
+    source_branch: str = Field(..., description="The source branch")
+    target_branch: str = Field(..., description="The target branch")
+
+
+class CheckRepositoryMergeConflicts(BaseModel):
+    """Runs a check to validate if there are merge conflicts for a proposed change between two branches."""
+
+    validator_id: str = Field(..., description="The id of the validator associated with this check")
+    validator_execution_id: str = Field(..., description="The id of current execution of the associated validator")
+    check_execution_id: str = Field(..., description="The unique ID for the current execution of this check")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the Repository")
+    source_branch: str = Field(..., description="The source branch")
+    target_branch: str = Field(..., description="The target branch")

infrahub/git/repository.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from git.exc import BadName, GitCommandError
 from infrahub_sdk.exceptions import GraphQLError
@@ -10,7 +10,9 @@ from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
 from infrahub.exceptions import RepositoryError
 from infrahub.git.integrator import InfrahubRepositoryIntegrator
 from infrahub.log import get_logger
-from infrahub.services import InfrahubServices
+
+if TYPE_CHECKING:
+    from infrahub.services import InfrahubServices
 
 log = get_logger()
 
@@ -24,9 +26,8 @@ class InfrahubRepository(InfrahubRepositoryIntegrator):
 
     @classmethod
     async def new(
-        cls, service: InfrahubServices | None = None, update_commit_value: bool = True, **kwargs: Any
+        cls, service: InfrahubServices, update_commit_value: bool = True, **kwargs: Any
     ) -> InfrahubRepository:
-        service = service or InfrahubServices()
         self = cls(service=service, **kwargs)
         await self.create_locally(
             infrahub_branch_name=self.infrahub_branch_name, update_commit_value=update_commit_value
@@ -208,9 +209,7 @@ class InfrahubReadOnlyRepository(InfrahubRepositoryIntegrator):
     ref: str | None = Field(None, description="Ref to track on the external repository")
 
     @classmethod
-    async def new(cls, service: InfrahubServices | None = None, **kwargs: Any) -> InfrahubReadOnlyRepository:
-        service = service or InfrahubServices()
-
+    async def new(cls, service: InfrahubServices, **kwargs: Any) -> InfrahubReadOnlyRepository:
         if "ref" not in kwargs or "infrahub_branch_name" not in kwargs:
             raise ValueError("ref and infrahub_branch_name are mandatory to initialize a new Read-Only repository")
 
@@ -219,7 +218,7 @@ class InfrahubReadOnlyRepository(InfrahubRepositoryIntegrator):
         log.info("Created new repository locally.", repository=self.name)
         return self
 
-    def get_commit_value(self, branch_name: str, remote: bool = False) -> str:
+    def get_commit_value(self, branch_name: str, remote: bool = False) -> str:  # noqa: ARG002
         """Always get the latest commit for this repository's ref on the remote"""
         git_repo = self.get_git_repo_main()
         git_repo.remotes.origin.fetch()