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

infrahub/tasks/telemetry.py

@@ -13,14 +13,14 @@ from infrahub.core import registry, utils
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.graph.schema import GRAPH_SCHEMA
-from infrahub.services import InfrahubServices, services
+from infrahub.services import InfrahubServices
 
 TELEMETRY_KIND: str = "community"
 TELEMETRY_VERSION: str = "20240524"
 
 
-@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)
-async def gather_database_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_database_information(service: InfrahubServices) -> dict:
     async with service.database.start_session() as db:
         data: dict[str, Any] = {
             "database_type": db.db_type.value,
@@ -37,8 +37,8 @@ async def gather_database_information(service: InfrahubServices, branch: Branch)
         return data
 
 
-@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)
-async def gather_schema_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_schema_information(branch: Branch) -> dict:
     data: dict[str, Any] = {}
     main_schema = registry.schema.get_schema_branch(name=branch.name)
     data["node_count"] = len(main_schema.node_names)
@@ -48,8 +48,8 @@ async def gather_schema_information(service: InfrahubServices, branch: Branch) -
     return data
 
 
-@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)
-async def gather_feature_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
+@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)  # type: ignore[arg-type]
+async def gather_feature_information(service: InfrahubServices) -> dict:
     async with service.database.start_session() as db:
         data = {}
         features_to_count = [
@@ -67,7 +67,7 @@ async def gather_feature_information(service: InfrahubServices, branch: Branch)
         return data
 
 
-@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)
+@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)  # type: ignore[arg-type]
 async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
     start_time = time.time()
 
@@ -87,9 +87,9 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
         "branches": {
             "total": len(registry.branch),
         },
-        "features": await gather_feature_information(service=service, branch=default_branch),
-        "schema": await gather_schema_information(service=service, branch=default_branch),
-        "database": await gather_database_information(service=service, branch=default_branch),
+        "features": await gather_feature_information(service=service),
+        "schema": await gather_schema_information(branch=default_branch),
+        "database": await gather_database_information(service=service),
     }
 
     data["execution_time"] = time.time() - start_time
@@ -97,7 +97,7 @@ async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
     return data
 
 
-@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)
+@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)  # type: ignore[arg-type]
 async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict[str, Any]) -> None:
     """Send the telemetry data to the specified URL, using HTTP POST."""
     response = await service.http.post(url=url, json=payload)
@@ -105,8 +105,7 @@ async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict
 
 
 @flow(name="anonymous_telemetry_send", flow_run_name="Send anonymous telemetry")
-async def send_telemetry_push() -> None:
-    service = services.service
+async def send_telemetry_push(service: InfrahubServices) -> None:
     log = get_run_logger()
     if config.SETTINGS.main.telemetry_optout:
         log.info("Skipping, User opted out of this service.")

infrahub/transformations/tasks.py

@@ -4,7 +4,7 @@ from prefect import flow
 
 from infrahub.git.repository import get_initialized_repo
 from infrahub.log import get_logger
-from infrahub.services import services
+from infrahub.services import InfrahubServices
 from infrahub.workflows.utils import add_branch_tag
 
 from .models import TransformJinjaTemplateData, TransformPythonData
@@ -13,8 +13,7 @@ log = get_logger()
 
 
 @flow(name="transform_render_python", flow_run_name="Render transform python", persist_result=True)
-async def transform_python(message: TransformPythonData) -> Any:
-    service = services.service
+async def transform_python(message: TransformPythonData, service: InfrahubServices) -> Any:
     await add_branch_tag(branch_name=message.branch)
 
     repo = await get_initialized_repo(
@@ -37,8 +36,7 @@ async def transform_python(message: TransformPythonData) -> Any:
 
 
 @flow(name="transform_render_jinja2_template", flow_run_name="Render transform Jinja2", persist_result=True)
-async def transform_render_jinja2_template(message: TransformJinjaTemplateData) -> str:
-    service = services.service
+async def transform_render_jinja2_template(message: TransformJinjaTemplateData, service: InfrahubServices) -> str:
     await add_branch_tag(branch_name=message.branch)
 
     repo = await get_initialized_repo(

infrahub/trigger/catalogue.py

@@ -0,0 +1,16 @@
+from infrahub.computed_attribute.triggers import (
+    TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+)
+from infrahub.trigger.models import TriggerDefinition
+from infrahub.webhook.triggers import TRIGGER_WEBHOOK_SETUP_UPDATE
+
+builtin_triggers: list[TriggerDefinition] = [
+    TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
+    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_WEBHOOK_SETUP_UPDATE,
+]

infrahub/trigger/constants.py

@@ -0,0 +1,9 @@
+DEPRECATED_STATIC_TRIGGER_NAMES = [
+    "Trigger-branch-create-events",  # used in 1.1.x
+    "Trigger-branch-remove-events",  # used in 1.1.x
+    "Trigger-webhook-update-configuration",  # used in 1.1.x
+    "Trigger-repository-commit-update-event",  # used in 1.1.x
+    "Trigger-schema-update-event",  # used in 1.1.x
+]
+
+NAME_SEPARATOR = "::"

infrahub/trigger/models.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+from prefect.events.actions import RunDeployment
+from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
+from prefect.events.schemas.automations import Posture
+from prefect.events.schemas.events import ResourceSpecification
+from pydantic import BaseModel, Field
+
+from infrahub.workflows.models import WorkflowDefinition  # noqa: TC001
+
+from .constants import NAME_SEPARATOR
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+class TriggerType(str, Enum):
+    BUILTIN = "builtin"
+    WEBHOOK = "webhook"
+    # OBJECT = "object"
+    # COMPUTED_ATTR = "computed_attr"
+
+
+class EventTrigger(BaseModel):
+    events: set = Field(default_factory=set)
+    match: dict[str, Any] = Field(default_factory=dict)
+    match_related: dict[str, Any] = Field(default_factory=dict)
+
+    def get_prefect(self) -> PrefectEventTrigger:
+        return PrefectEventTrigger(
+            posture=Posture.Reactive,
+            expect=self.events,
+            within=timedelta(0),
+            match=ResourceSpecification(self.match),
+            match_related=ResourceSpecification(self.match_related),
+            threshold=1,
+        )
+
+
+class ExecuteWorkflow(BaseModel):
+    workflow: WorkflowDefinition
+    parameters: dict[str, Any] = Field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return self.workflow.name
+
+    def get_prefect(self, mapping: dict[str, UUID]) -> RunDeployment:
+        deployment_id = mapping[self.name]
+        return self.get(deployment_id)
+
+    def get(self, id: UUID) -> RunDeployment:
+        return RunDeployment(
+            source="selected",
+            deployment_id=id,
+            parameters=self.parameters,
+            job_variables={},
+        )
+
+    def validate_parameters(self) -> None:
+        if not self.parameters:
+            return
+
+        workflow_params = self.workflow.get_parameters()
+        workflow_required_params = [p.name for p in workflow_params.values() if p.required]
+        trigger_params = list(self.parameters.keys())
+
+        missing_required_params = set(workflow_required_params) - set(trigger_params)
+        wrong_params = set(trigger_params) - set(workflow_params)
+
+        if missing_required_params:
+            raise ValueError(
+                f"Missing required parameters: {missing_required_params} for workflow {self.workflow.name}"
+            )
+
+        if wrong_params:
+            raise ValueError(f"Workflow {self.workflow.name} doesn't support parameters: {wrong_params}")
+
+
+class TriggerDefinition(BaseModel):
+    name: str
+    type: TriggerType
+    previous_names: set = Field(default_factory=set)
+    description: str = ""
+    trigger: EventTrigger
+    actions: list[ExecuteWorkflow]
+
+    def get_deployment_names(self) -> list[str]:
+        """Return the name of all deployments used by this trigger"""
+        return [action.name for action in self.actions]
+
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.name}"
+
+    def validate_actions(self) -> None:
+        for action in self.actions:
+            action.validate_parameters()
+
+
+class BuiltinTriggerDefinition(TriggerDefinition):
+    type: TriggerType = TriggerType.BUILTIN

infrahub/trigger/tasks.py

@@ -0,0 +1,91 @@
+from typing import TYPE_CHECKING
+
+from prefect import get_run_logger, task
+from prefect.automations import AutomationCore
+from prefect.cache_policies import NONE
+from prefect.client.orchestration import PrefectClient
+from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
+
+from infrahub.trigger.models import TriggerDefinition
+
+# from .catalogue import triggers
+from .models import TriggerType
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+@task(name="trigger-setup", task_run_name="Setup triggers of type {trigger_type.value}", cache_policy=NONE)  # type: ignore[arg-type]
+async def setup_triggers(
+    client: PrefectClient,
+    triggers: list[TriggerDefinition],
+    trigger_type: TriggerType = TriggerType.BUILTIN,
+    deprecated_triggers: list[str] | None = None,
+) -> None:
+    log = get_run_logger()
+
+    # -------------------------------------------------------------
+    # Retrieve existing Deployments and Automation from the server
+    # -------------------------------------------------------------
+    deployment_names = list({name for trigger in triggers for name in trigger.get_deployment_names()})
+    deployments = {
+        item.name: item
+        for item in await client.read_deployments(
+            deployment_filter=DeploymentFilter(name=DeploymentFilterName(any_=deployment_names))
+        )
+    }
+    deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
+    existing_automations = {item.name: item for item in await client.read_automations()}
+
+    trigger_automations = [
+        item.name for item in await client.read_automations() if item.name.startswith(trigger_type.value)
+    ]
+    trigger_names = [trigger.generate_name() for trigger in triggers]
+
+    to_delete = set(trigger_automations) - set(trigger_names)
+
+    # -------------------------------------------------------------
+    # Create or Update all triggers
+    # -------------------------------------------------------------
+    for trigger in triggers:
+        automation = AutomationCore(
+            name=trigger.generate_name(),
+            description=trigger.description,
+            enabled=True,
+            trigger=trigger.trigger.get_prefect(),
+            actions=[action.get_prefect(mapping=deployments_mapping) for action in trigger.actions],
+        )
+
+        existing_automation = existing_automations.get(trigger.name, None)
+
+        if existing_automation:
+            await client.update_automation(automation_id=existing_automation.id, automation=automation)
+            log.info(f"{trigger.name} Updated")
+        else:
+            await client.create_automation(automation=automation)
+            log.info(f"{trigger.name} Created")
+
+    # -------------------------------------------------------------
+    # Delete Triggers that shouldn't be there
+    # -------------------------------------------------------------
+    for item_to_delete in to_delete:
+        existing_automation = existing_automations.get(item_to_delete)
+
+        if not existing_automation:
+            continue
+
+        await client.delete_automation(automation_id=existing_automation.id)
+        log.info(f"{item_to_delete} Deleted")
+
+    # -------------------------------------------------------------
+    # Delete Deprecated triggers
+    # -------------------------------------------------------------
+    if deprecated_triggers:
+        for trigger_name in deprecated_triggers:
+            existing_automation = existing_automations.get(trigger_name)
+
+            if not existing_automation:
+                continue
+
+            await client.delete_automation(automation_id=existing_automation.id)
+            log.info(f"{trigger_name} Deleted")

infrahub/types.py

@@ -354,7 +354,7 @@ ATTRIBUTE_PYTHON_TYPES: dict[str, type] = {
     "Color": str,  # Colors often represented as hex strings
     "Number": float,  # Numbers can be floats for general use
     "Bandwidth": float,  # Bandwidth in some units, represented as a float
-    "IPHost": IPvAnyAddress,
+    "IPHost": IPvAnyAddress,  # type: ignore[dict-item]
     "IPNetwork": str,
     "Boolean": bool,
     "Checkbox": bool,  # Checkboxes represent boolean values

infrahub/utils.py

@@ -36,7 +36,7 @@ def format_label(slug: str) -> str:
 class MetaEnum(EnumMeta):
     def __contains__(cls, item: Any) -> bool:
         try:
-            cls(item)  # pylint: disable=no-value-for-parameter
+            cls(item)
         except ValueError:
             return False
         return True

infrahub/webhook/constants.py

@@ -1,3 +1 @@
-AUTOMATION_NAME = "Trigger-webhook-update-configuration"
-
 AUTOMATION_NAME_RUN = "Trigger-webhook-execution"

infrahub/webhook/models.py

@@ -1,64 +1,158 @@
+from __future__ import annotations
+
 import base64
 import hashlib
 import hmac
-from datetime import datetime, timezone
-from math import floor
-from typing import Any, Optional, Union
-from uuid import uuid4
+from typing import TYPE_CHECKING, Any, Optional, Union
+from uuid import UUID, uuid4
 
-from infrahub_sdk.protocols import CoreTransformPython
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, computed_field
+from typing_extensions import Self
 
+from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind
+from infrahub.core.timestamp import Timestamp
 from infrahub.git.repository import InfrahubReadOnlyRepository, InfrahubRepository
-from infrahub.services import InfrahubServices
-from infrahub.transformations.constants import DEFAULT_TRANSFORM_TIMEOUT
+from infrahub.trigger.models import EventTrigger, ExecuteWorkflow, TriggerDefinition, TriggerType
+from infrahub.workflows.catalogue import WEBHOOK_PROCESS
+
+if TYPE_CHECKING:
+    from httpx import Response
+    from infrahub_sdk.protocols import CoreCustomWebhook, CoreStandardWebhook, CoreTransformPython, CoreWebhook
+
+    from infrahub.services import InfrahubServices
+
+
+class WebhookTriggerDefinition(TriggerDefinition):
+    type: TriggerType = TriggerType.WEBHOOK
+
+    @classmethod
+    def from_object(cls, obj: CoreWebhook) -> Self:
+        event_trigger = EventTrigger()
+        if obj.event_type.value == "all":
+            event_trigger.events.add("infrahub.*")
+        else:
+            event_trigger.events.add(obj.event_type.value)
+
+        if obj.branch_scope.value == "default_branch":
+            event_trigger.match_related = {
+                "prefect.resource.role": "infrahub.branch",
+                "infrahub.resource.label": registry.default_branch,
+            }
+        elif obj.branch_scope.value == "other_branches":
+            event_trigger.match_related = {
+                "prefect.resource.role": "infrahub.branch",
+                "infrahub.resource.label": f"!{registry.default_branch}",
+            }
+
+        definition = cls(
+            name=obj.name.value,
+            trigger=event_trigger,
+            actions=[
+                ExecuteWorkflow(
+                    workflow=WEBHOOK_PROCESS,
+                    parameters={
+                        "webhook_id": obj.id,
+                        "webhook_kind": obj.get_kind(),
+                        "event_id": "{{ event.id }}",
+                        "event_type": "{{ event.event }}",
+                        "event_occured_at": "{{ event.occurred }}",
+                        "event_payload": {
+                            "__prefect_kind": "json",
+                            "value": {"__prefect_kind": "jinja", "template": "{{ event.payload | tojson }}"},
+                        },
+                    },
+                ),
+            ],
+        )
+
+        return definition
 
 
-class SendWebhookData(BaseModel):
-    """Sent a webhook to an external source."""
+class EventContext(BaseModel):
+    id: str = Field(..., description="The internal id of the event")
+    branch: str | None = Field(None, description="The branch associated with the event")
+    account_id: str | None = Field(None, description="The id of the account associated with the event")
+    occured_at: str = Field(..., description="The time when the event occurred")
+    event: str = Field(..., description="The event type")
 
-    webhook_id: str = Field(..., description="The unique ID of the webhook")
-    event_type: str = Field(..., description="The event type")
-    event_data: dict = Field(..., description="The data tied to the event")
+    @classmethod
+    def from_event(cls, event_id: str, event_type: str, event_occured_at: str, event_payload: dict[str, Any]) -> Self:
+        """Extract the context from the raw event we are getting from Prefect."""
+
+        infrahub_context: dict[str, Any] = event_payload.get("context", {})
+        account_info: dict[str, Any] = infrahub_context.get("account", {})
+        branch_info: dict[str, Any] = infrahub_context.get("branch", {})
+
+        return cls(
+            id=event_id,
+            branch=branch_info.get("name")
+            if branch_info and branch_info.get("name") != registry.get_global_branch().name
+            else None,
+            account_id=account_info.get("account_id"),
+            occured_at=event_occured_at,
+            event=event_type,
+        )
 
 
 class Webhook(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
-    service: InfrahubServices = Field(...)
+    name: str = Field(...)
     url: str = Field(...)
     event_type: str = Field(...)
-    data: dict[str, Any] = Field(...)
     validate_certificates: bool = Field(...)
     _payload: Any = None
     _headers: Optional[dict[str, Any]] = None
 
-    async def _prepare_payload(self) -> None:
-        self._payload = {"event_type": self.event_type, "data": self.data}
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:  # noqa: ARG002
+        self._payload = {"data": data, **context.model_dump()}
 
     def _assign_headers(self) -> None:
         self._headers = {}
 
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def webhook_type(self) -> str:
         return self.__class__.__name__
 
-    async def send(self) -> None:
-        await self._prepare_payload()
+    async def prepare(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
+        await self._prepare_payload(data=data, context=context, service=service)
         self._assign_headers()
-        await self.service.http.post(url=self.url, json=self._payload, headers=self._headers)
+
+    async def send(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> Response:
+        await self.prepare(data=data, context=context, service=service)
+        return await service.http.post(url=self.url, json=self.get_payload(), headers=self._headers)
+
+    def get_payload(self) -> dict[str, Any]:
+        return self._payload
+
+    def to_cache(self) -> dict[str, Any]:
+        return self.model_dump()
+
+    @classmethod
+    def from_cache(cls, data: dict[str, Any]) -> Self:
+        return cls(**data)
 
 
 class CustomWebhook(Webhook):
     """Custom webhook"""
 
+    @classmethod
+    def from_object(cls, obj: CoreCustomWebhook) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+        )
+
 
 class StandardWebhook(Webhook):
-    shared_key: bytes = Field(...)
+    shared_key: str = Field(...)
 
-    def _assign_headers(self) -> None:
-        message_id = f"msg_{uuid4().hex}"
-        timestamp = str(floor(datetime.now(tz=timezone.utc).timestamp()))
+    def _assign_headers(self, uuid: UUID | None = None, at: Timestamp | None = None) -> None:
+        message_id = f"msg_{uuid.hex}" if uuid else f"msg_{uuid4().hex}"
+        timestamp = str(at.to_timestamp()) if at else str(Timestamp().to_timestamp())
         payload = self._payload or {}
         unsigned_data = f"{message_id}.{timestamp}.{payload}".encode()
         signature = self._sign(data=unsigned_data)
@@ -72,7 +166,17 @@ class StandardWebhook(Webhook):
         }
 
     def _sign(self, data: bytes) -> bytes:
-        return hmac.new(key=self.shared_key, msg=data, digestmod=hashlib.sha256).digest()
+        return hmac.new(key=self.shared_key.encode(), msg=data, digestmod=hashlib.sha256).digest()
+
+    @classmethod
+    def from_object(cls, obj: CoreStandardWebhook) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+            shared_key=obj.shared_key.value,
+        )
 
 
 class TransformWebhook(Webhook):
@@ -82,31 +186,48 @@ class TransformWebhook(Webhook):
     transform_name: str = Field(...)
     transform_class: str = Field(...)
     transform_file: str = Field(...)
+    transform_timeout: int = Field(...)
 
-    async def _prepare_payload(self) -> None:
+    async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
         repo: Union[InfrahubReadOnlyRepository, InfrahubRepository]
         if self.repository_kind == InfrahubKind.READONLYREPOSITORY:
             repo = await InfrahubReadOnlyRepository.init(
-                id=self.repository_id, name=self.repository_name, client=self.service.client
+                id=self.repository_id,
+                name=self.repository_name,
+                client=service.client,
+                service=service,
             )
         else:
             repo = await InfrahubRepository.init(
-                id=self.repository_id, name=self.repository_name, client=self.service.client
+                id=self.repository_id,
+                name=self.repository_name,
+                client=service.client,
+                service=service,
             )
 
-        default_branch = repo.default_branch
-        commit = repo.get_commit_value(branch_name=default_branch)
-
-        timeout = DEFAULT_TRANSFORM_TIMEOUT
-        if transform := await self.service.client.get(
-            kind=CoreTransformPython, name__value=self.transform_name, raise_when_missing=False
-        ):
-            timeout = transform.timeout.value
+        branch = context.branch or repo.default_branch
+        commit = repo.get_commit_value(branch_name=branch)
 
-        self._payload = await repo.execute_python_transform.with_options(timeout_seconds=timeout)(
-            branch_name=default_branch,
+        self._payload = await repo.execute_python_transform.with_options(timeout_seconds=self.transform_timeout)(
+            branch_name=branch,
             commit=commit,
             location=f"{self.transform_file}::{self.transform_class}",
-            data={"event_type": self.event_type, "data": self.data},
-            client=self.service.client,
+            data={"data": data, **context.model_dump()},
+            client=service.client,
+        )
+
+    @classmethod
+    def from_object(cls, obj: CoreCustomWebhook, transform: CoreTransformPython) -> Self:
+        return cls(
+            name=obj.name.value,
+            url=obj.url.value,
+            event_type=obj.event_type.value,
+            validate_certificates=obj.validate_certificates.value or False,
+            repository_id=transform.repository.id,
+            repository_name=transform.repository.peer.name.value,
+            repository_kind=transform.repository.peer.get_kind(),
+            transform_name=transform.name.value,
+            transform_class=transform.class_name.value,
+            transform_file=transform.file_path.value,
+            transform_timeout=transform.timeout.value,
         )