apache-airflow-providers-amazon 9.2.0rc2__py3-none-any.whl → 9.3.0__py3-none-any.whl

airflow/providers/amazon/aws/operators/comprehend.py

@@ -23,6 +23,10 @@ from typing import TYPE_CHECKING, Any, ClassVar
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.comprehend import ComprehendHook
+from airflow.providers.amazon.aws.links.comprehend import (
+    ComprehendDocumentClassifierLink,
+    ComprehendPiiEntitiesDetectionLink,
+)
 from airflow.providers.amazon.aws.operators.base_aws import AwsBaseOperator
 from airflow.providers.amazon.aws.triggers.comprehend import (
     ComprehendCreateDocumentClassifierCompletedTrigger,
@@ -120,6 +124,8 @@ class ComprehendStartPiiEntitiesDetectionJobOperator(ComprehendBaseOperator):
         https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html
     """
 
+    operator_extra_links = (ComprehendPiiEntitiesDetectionLink(),)
+
     def __init__(
         self,
         input_data_config: dict,
@@ -166,6 +172,19 @@ class ComprehendStartPiiEntitiesDetectionJobOperator(ComprehendBaseOperator):
             **self.start_pii_entities_kwargs,
         )["JobId"]
 
+        job_url = ComprehendPiiEntitiesDetectionLink.format_str.format(
+            aws_domain=ComprehendPiiEntitiesDetectionLink.get_aws_domain(self.hook.conn_partition),
+            region_name=self.hook.conn_region_name,
+            job_id=job_id,
+        )
+        ComprehendPiiEntitiesDetectionLink.persist(
+            context=context,
+            operator=self,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
+            job_id=job_id,
+        )
+        self.log.info("You can view the PII entities detection job at %s", job_url)
         message_description = f"start pii entities detection job {job_id} to complete."
         if self.deferrable:
             self.log.info("Deferring %s", message_description)
@@ -188,12 +207,12 @@ class ComprehendStartPiiEntitiesDetectionJobOperator(ComprehendBaseOperator):
         return job_id
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str:
-        event = validate_execute_complete_event(event)
-        if event["status"] != "success":
-            raise AirflowException("Error while running job: %s", event)
+        validated_event = validate_execute_complete_event(event)
+        if validated_event["status"] != "success":
+            raise AirflowException("Error while running job: %s", validated_event)
 
-        self.log.info("Comprehend pii entities detection job `%s` complete.", event["job_id"])
-        return event["job_id"]
+        self.log.info("Comprehend pii entities detection job `%s` complete.", validated_event["job_id"])
+        return validated_event["job_id"]
 
 
 class ComprehendCreateDocumentClassifierOperator(AwsBaseOperator[ComprehendHook]):
@@ -238,6 +257,7 @@ class ComprehendCreateDocumentClassifierOperator(AwsBaseOperator[ComprehendHook]
     """
 
     aws_hook_class = ComprehendHook
+    operator_extra_links = (ComprehendDocumentClassifierLink(),)
 
     template_fields: Sequence[str] = aws_template_fields(
         "document_classifier_name",
@@ -300,6 +320,22 @@ class ComprehendCreateDocumentClassifierOperator(AwsBaseOperator[ComprehendHook]
             **self.document_classifier_kwargs,
         )["DocumentClassifierArn"]
 
+        # create the link to console
+        job_url = ComprehendDocumentClassifierLink.format_str.format(
+            aws_domain=ComprehendDocumentClassifierLink.get_aws_domain(self.hook.conn_partition),
+            region_name=self.hook.conn_region_name,
+            arn=document_classifier_arn,
+        )
+
+        ComprehendDocumentClassifierLink.persist(
+            context=context,
+            operator=self,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
+            arn=document_classifier_arn,
+        )
+        self.log.info("You can monitor the classifier at %s", job_url)
+
         message_description = f"document classifier {document_classifier_arn} to complete."
         if self.deferrable:
             self.log.info("Deferring %s", message_description)
@@ -327,14 +363,19 @@ class ComprehendCreateDocumentClassifierOperator(AwsBaseOperator[ComprehendHook]
         return document_classifier_arn
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str:
-        event = validate_execute_complete_event(event)
-        if event["status"] != "success":
-            raise AirflowException("Error while running comprehend create document classifier: %s", event)
+        validated_event = validate_execute_complete_event(event)
+        if validated_event["status"] != "success":
+            raise AirflowException(
+                "Error while running comprehend create document classifier: %s", validated_event
+            )
 
         self.hook.validate_document_classifier_training_status(
-            document_classifier_arn=event["document_classifier_arn"], fail_on_warnings=self.fail_on_warnings
+            document_classifier_arn=validated_event["document_classifier_arn"],
+            fail_on_warnings=self.fail_on_warnings,
         )
 
-        self.log.info("Comprehend document classifier `%s` complete.", event["document_classifier_arn"])
+        self.log.info(
+            "Comprehend document classifier `%s` complete.", validated_event["document_classifier_arn"]
+        )
 
-        return event["document_classifier_arn"]
+        return validated_event["document_classifier_arn"]

airflow/providers/amazon/aws/operators/datasync.py

@@ -25,6 +25,7 @@ from typing import TYPE_CHECKING, Any
 
 from airflow.exceptions import AirflowException, AirflowTaskTimeout
 from airflow.providers.amazon.aws.hooks.datasync import DataSyncHook
+from airflow.providers.amazon.aws.links.datasync import DataSyncTaskExecutionLink, DataSyncTaskLink
 from airflow.providers.amazon.aws.operators.base_aws import AwsBaseOperator
 from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
@@ -130,6 +131,8 @@ class DataSyncOperator(AwsBaseOperator[DataSyncHook]):
     }
     ui_color = "#44b5e2"
 
+    operator_extra_links = (DataSyncTaskLink(), DataSyncTaskExecutionLink())
+
     def __init__(
         self,
         *,
@@ -215,6 +218,23 @@ class DataSyncOperator(AwsBaseOperator[DataSyncHook]):
         if not self.task_arn:
             raise AirflowException("DataSync TaskArn could not be identified or created.")
 
+        task_id = self.task_arn.split("/")[-1]
+
+        task_url = DataSyncTaskLink.format_str.format(
+            aws_domain=DataSyncTaskLink.get_aws_domain(self.hook.conn_partition),
+            region_name=self.hook.conn_region_name,
+            task_id=task_id,
+        )
+
+        DataSyncTaskLink.persist(
+            context=context,
+            operator=self,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
+            task_id=task_id,
+        )
+        self.log.info("You can view this DataSync task at %s", task_url)
+
         self.log.info("Using DataSync TaskArn %s", self.task_arn)
 
         # Update the DataSync Task
@@ -222,7 +242,7 @@ class DataSyncOperator(AwsBaseOperator[DataSyncHook]):
             self._update_datasync_task()
 
         # Execute the DataSync Task
-        self._execute_datasync_task()
+        self._execute_datasync_task(context=context)
 
         if not self.task_execution_arn:
             raise AirflowException("Nothing was executed")
@@ -327,7 +347,7 @@ class DataSyncOperator(AwsBaseOperator[DataSyncHook]):
         self.hook.update_task(self.task_arn, **self.update_task_kwargs)
         self.log.info("Updated TaskArn %s", self.task_arn)
 
-    def _execute_datasync_task(self) -> None:
+    def _execute_datasync_task(self, context: Context) -> None:
         """Create and monitor an AWS DataSync TaskExecution for a Task."""
         if not self.task_arn:
             raise AirflowException("Missing TaskArn")
@@ -337,6 +357,24 @@ class DataSyncOperator(AwsBaseOperator[DataSyncHook]):
         self.task_execution_arn = self.hook.start_task_execution(self.task_arn, **self.task_execution_kwargs)
         self.log.info("Started TaskExecutionArn %s", self.task_execution_arn)
 
+        # Create the execution extra link
+        execution_url = DataSyncTaskExecutionLink.format_str.format(
+            aws_domain=DataSyncTaskExecutionLink.get_aws_domain(self.hook.conn_partition),
+            region_name=self.hook.conn_region_name,
+            task_id=self.task_arn.split("/")[-1],
+            task_execution_id=self.task_execution_arn.split("/")[-1],  # type: ignore[union-attr]
+        )
+        DataSyncTaskExecutionLink.persist(
+            context=context,
+            operator=self,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
+            task_id=self.task_arn.split("/")[-1],
+            task_execution_id=self.task_execution_arn.split("/")[-1],  # type: ignore[union-attr]
+        )
+
+        self.log.info("You can view this DataSync task execution at %s", execution_url)
+
         if not self.wait_for_completion:
             return
 

airflow/providers/amazon/aws/operators/dms.py

@@ -493,10 +493,6 @@ class DmsDeleteReplicationConfigOperator(AwsBaseOperator[DmsHook]):
             Filters=[{"Name": "replication-config-arn", "Values": [self.replication_config_arn]}],
             WaiterConfig={"Delay": self.waiter_delay, "MaxAttempts": self.waiter_max_attempts},
         )
-        self.hook.get_waiter("replication_deprovisioned").wait(
-            Filters=[{"Name": "replication-config-arn", "Values": [self.replication_config_arn]}],
-            WaiterConfig={"Delay": self.waiter_delay, "MaxAttempts": self.waiter_max_attempts},
-        )
         self.hook.delete_replication_config(self.replication_config_arn)
         self.handle_delete_wait()
 

airflow/providers/amazon/aws/operators/ec2.py

@@ -23,6 +23,10 @@ from typing import TYPE_CHECKING
 from airflow.exceptions import AirflowException
 from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.ec2 import EC2Hook
+from airflow.providers.amazon.aws.links.ec2 import (
+    EC2InstanceDashboardLink,
+    EC2InstanceLink,
+)
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -47,6 +51,7 @@ class EC2StartInstanceOperator(BaseOperator):
         between each instance state checks until operation is completed
     """
 
+    operator_extra_links = (EC2InstanceLink(),)
     template_fields: Sequence[str] = ("instance_id", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
@@ -71,6 +76,13 @@ class EC2StartInstanceOperator(BaseOperator):
         self.log.info("Starting EC2 instance %s", self.instance_id)
         instance = ec2_hook.get_instance(instance_id=self.instance_id)
         instance.start()
+        EC2InstanceLink.persist(
+            context=context,
+            operator=self,
+            aws_partition=ec2_hook.conn_partition,
+            instance_id=self.instance_id,
+            region_name=ec2_hook.conn_region_name,
+        )
         ec2_hook.wait_for_state(
             instance_id=self.instance_id,
             target_state="running",
@@ -97,6 +109,7 @@ class EC2StopInstanceOperator(BaseOperator):
         between each instance state checks until operation is completed
     """
 
+    operator_extra_links = (EC2InstanceLink(),)
     template_fields: Sequence[str] = ("instance_id", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
@@ -120,7 +133,15 @@ class EC2StopInstanceOperator(BaseOperator):
         ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)
         self.log.info("Stopping EC2 instance %s", self.instance_id)
         instance = ec2_hook.get_instance(instance_id=self.instance_id)
+        EC2InstanceLink.persist(
+            context=context,
+            operator=self,
+            aws_partition=ec2_hook.conn_partition,
+            instance_id=self.instance_id,
+            region_name=ec2_hook.conn_region_name,
+        )
         instance.stop()
+
         ec2_hook.wait_for_state(
             instance_id=self.instance_id,
             target_state="stopped",
@@ -154,6 +175,7 @@ class EC2CreateInstanceOperator(BaseOperator):
         in the `running` state before returning.
     """
 
+    operator_extra_links = (EC2InstanceDashboardLink(),)
     template_fields: Sequence[str] = (
         "image_id",
         "max_count",
@@ -198,6 +220,15 @@ class EC2CreateInstanceOperator(BaseOperator):
         )["Instances"]
 
         instance_ids = self._on_kill_instance_ids = [instance["InstanceId"] for instance in instances]
+        # Console link is for EC2 dashboard list, not individual instances when more than 1 instance
+
+        EC2InstanceDashboardLink.persist(
+            context=context,
+            operator=self,
+            region_name=ec2_hook.conn_region_name,
+            aws_partition=ec2_hook.conn_partition,
+            instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(instance_ids),
+        )
         for instance_id in instance_ids:
             self.log.info("Created EC2 instance %s", instance_id)
 
@@ -311,6 +342,7 @@ class EC2RebootInstanceOperator(BaseOperator):
         in the `running` state before returning.
     """
 
+    operator_extra_links = (EC2InstanceDashboardLink(),)
     template_fields: Sequence[str] = ("instance_ids", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
@@ -341,6 +373,14 @@ class EC2RebootInstanceOperator(BaseOperator):
         self.log.info("Rebooting EC2 instances %s", ", ".join(self.instance_ids))
         ec2_hook.conn.reboot_instances(InstanceIds=self.instance_ids)
 
+        # Console link is for EC2 dashboard list, not individual instances
+        EC2InstanceDashboardLink.persist(
+            context=context,
+            operator=self,
+            region_name=ec2_hook.conn_region_name,
+            aws_partition=ec2_hook.conn_partition,
+            instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(self.instance_ids),
+        )
         if self.wait_for_completion:
             ec2_hook.get_waiter("instance_running").wait(
                 InstanceIds=self.instance_ids,
@@ -374,6 +414,7 @@ class EC2HibernateInstanceOperator(BaseOperator):
         in the `stopped` state before returning.
     """
 
+    operator_extra_links = (EC2InstanceDashboardLink(),)
     template_fields: Sequence[str] = ("instance_ids", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
@@ -404,6 +445,15 @@ class EC2HibernateInstanceOperator(BaseOperator):
         self.log.info("Hibernating EC2 instances %s", ", ".join(self.instance_ids))
         instances = ec2_hook.get_instances(instance_ids=self.instance_ids)
 
+        # Console link is for EC2 dashboard list, not individual instances
+        EC2InstanceDashboardLink.persist(
+            context=context,
+            operator=self,
+            region_name=ec2_hook.conn_region_name,
+            aws_partition=ec2_hook.conn_partition,
+            instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(self.instance_ids),
+        )
+
         for instance in instances:
             hibernation_options = instance.get("HibernationOptions")
             if not hibernation_options or not hibernation_options["Configured"]:

airflow/providers/amazon/aws/operators/ecs.py

@@ -375,6 +375,7 @@ class EcsRunTaskOperator(EcsBaseOperator):
     :param awslogs_fetch_interval: the interval that the ECS task log fetcher should wait
         in between each Cloudwatch logs fetches.
         If deferrable is set to True, that parameter is ignored and waiter_delay is used instead.
+    :param container_name: The name of the container to fetch logs from. If not set, the first container is used.
     :param quota_retry: Config if and how to retry the launch of a new ECS task, to handle
         transient errors.
     :param reattach: If set to True, will check if the task previously launched by the task_instance
@@ -414,6 +415,7 @@ class EcsRunTaskOperator(EcsBaseOperator):
         "awslogs_region",
         "awslogs_stream_prefix",
         "awslogs_fetch_interval",
+        "container_name",
         "propagate_tags",
         "reattach",
         "number_logs_exception",
@@ -445,6 +447,7 @@ class EcsRunTaskOperator(EcsBaseOperator):
         awslogs_region: str | None = None,
         awslogs_stream_prefix: str | None = None,
         awslogs_fetch_interval: timedelta = timedelta(seconds=30),
+        container_name: str | None = None,
         propagate_tags: str | None = None,
         quota_retry: dict | None = None,
         reattach: bool = False,
@@ -484,7 +487,7 @@ class EcsRunTaskOperator(EcsBaseOperator):
             self.awslogs_region = self.region_name
 
         self.arn: str | None = None
-        self.container_name: str | None = None
+        self.container_name: str | None = container_name
         self._started_by: str | None = None
 
         self.retry_args = quota_retry
@@ -568,12 +571,12 @@ class EcsRunTaskOperator(EcsBaseOperator):
             return None
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str | None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error in task execution: {event}")
-        self.arn = event["task_arn"]  # restore arn to its updated value, needed for next steps
-        self.cluster = event["cluster"]
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error in task execution: {validated_event}")
+        self.arn = validated_event["task_arn"]  # restore arn to its updated value, needed for next steps
+        self.cluster = validated_event["cluster"]
         self._after_execution()
         if self._aws_logs_enabled():
             # same behavior as non-deferrable mode, return last line of logs of the task.
@@ -628,7 +631,8 @@ class EcsRunTaskOperator(EcsBaseOperator):
         self.log.info("ECS Task started: %s", response)
 
         self.arn = response["tasks"][0]["taskArn"]
-        self.container_name = response["tasks"][0]["containers"][0]["name"]
+        if not self.container_name:
+            self.container_name = response["tasks"][0]["containers"][0]["name"]
         self.log.info("ECS task ID is: %s", self._get_ecs_task_id(self.arn))
 
     def _try_reattach_task(self, started_by: str):

airflow/providers/amazon/aws/operators/eks.py

@@ -415,11 +415,11 @@ class EksCreateClusterOperator(BaseOperator):
         raise AirflowException("Error creating cluster")
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
         resource = "fargate profile" if self.compute == "fargate" else self.compute
-        if event["status"] != "success":
-            raise AirflowException(f"Error creating {resource}: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error creating {resource}: {validated_event}")
 
         self.log.info("%s created successfully", resource)
 
@@ -543,10 +543,10 @@ class EksCreateNodegroupOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error creating nodegroup: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error creating nodegroup: {validated_event}")
 
 
 class EksCreateFargateProfileOperator(BaseOperator):
@@ -655,10 +655,10 @@ class EksCreateFargateProfileOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error creating Fargate profile: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error creating Fargate profile: {validated_event}")
 
         self.log.info("Fargate profile created successfully")
 
@@ -789,9 +789,9 @@ class EksDeleteClusterOperator(BaseOperator):
         self.log.info(SUCCESS_MSG.format(compute=FARGATE_FULL_NAME))
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] == "success":
+        if validated_event["status"] == "success":
             self.log.info("Cluster deleted successfully.")
 
 
@@ -880,10 +880,10 @@ class EksDeleteNodegroupOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error deleting nodegroup: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error deleting nodegroup: {validated_event}")
 
 
 class EksDeleteFargateProfileOperator(BaseOperator):
@@ -974,10 +974,10 @@ class EksDeleteFargateProfileOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error deleting Fargate profile: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error deleting Fargate profile: {validated_event}")
 
         self.log.info("Fargate profile deleted successfully")
 

airflow/providers/amazon/aws/operators/emr.py

@@ -199,13 +199,13 @@ class EmrAddStepsOperator(BaseOperator):
         return step_ids
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error while running steps: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error while running steps: {validated_event}")
 
         self.log.info("Steps completed successfully")
-        return event["value"]
+        return validated_event["value"]
 
 
 class EmrStartNotebookExecutionOperator(BaseOperator):
@@ -591,12 +591,12 @@ class EmrContainerOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error while running job: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error while running job: {validated_event}")
 
-        return event["job_id"]
+        return validated_event["job_id"]
 
     def on_kill(self) -> None:
         """Cancel the submitted job run."""
@@ -769,13 +769,13 @@ class EmrCreateJobFlowOperator(BaseOperator):
         return self._job_flow_id
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> str:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error creating jobFlow: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error creating jobFlow: {validated_event}")
 
         self.log.info("JobFlow created successfully")
-        return event["job_flow_id"]
+        return validated_event["job_flow_id"]
 
     def on_kill(self) -> None:
         """Terminate the EMR cluster (job flow) unless TerminationProtected is enabled on the cluster."""
@@ -944,10 +944,10 @@ class EmrTerminateJobFlowOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Error terminating JobFlow: {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Error terminating JobFlow: {validated_event}")
 
         self.log.info("Jobflow terminated successfully.")
 
@@ -1086,13 +1086,13 @@ class EmrServerlessCreateApplicationOperator(BaseOperator):
         )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] != "success":
-            raise AirflowException(f"Trigger error: Application failed to start, event is {event}")
+        if validated_event["status"] != "success":
+            raise AirflowException(f"Trigger error: Application failed to start, event is {validated_event}")
 
-        self.log.info("Application %s started", event["application_id"])
-        return event["application_id"]
+        self.log.info("Application %s started", validated_event["application_id"])
+        return validated_event["application_id"]
 
 
 class EmrServerlessStartJobOperator(BaseOperator):
@@ -1273,11 +1273,11 @@ class EmrServerlessStartJobOperator(BaseOperator):
         return self.job_id
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] == "success":
+        if validated_event["status"] == "success":
             self.log.info("Serverless job completed")
-            return event["job_id"]
+            return validated_event["job_id"]
 
     def on_kill(self) -> None:
         """
@@ -1547,9 +1547,9 @@ class EmrServerlessStopApplicationOperator(BaseOperator):
             )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] == "success":
+        if validated_event["status"] == "success":
             self.log.info("EMR serverless application %s stopped successfully", self.application_id)
 
 
@@ -1651,7 +1651,7 @@ class EmrServerlessDeleteApplicationOperator(EmrServerlessStopApplicationOperato
         self.log.info("EMR serverless application deleted")
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
-        event = validate_execute_complete_event(event)
+        validated_event = validate_execute_complete_event(event)
 
-        if event["status"] == "success":
+        if validated_event["status"] == "success":
             self.log.info("EMR serverless application %s deleted successfully", self.application_id)