apache-airflow-providers-amazon 8.27.0rc1__py3-none-any.whl → 8.28.0__py3-none-any.whl

airflow/providers/amazon/__init__.py

@@ -29,11 +29,11 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "8.27.0"
+__version__ = "8.28.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
-    "2.7.0"
+    "2.8.0"
 ):
     raise RuntimeError(
-        f"The package `apache-airflow-providers-amazon:{__version__}` needs Apache Airflow 2.7.0+"
+        f"The package `apache-airflow-providers-amazon:{__version__}` needs Apache Airflow 2.8.0+"
     )

airflow/providers/amazon/aws/hooks/batch_client.py

@@ -103,6 +103,7 @@ class BatchProtocol(Protocol):
         parameters: dict,
         containerOverrides: dict,
         ecsPropertiesOverride: dict,
+        eksPropertiesOverride: dict,
         tags: dict,
     ) -> dict:
         """
@@ -122,6 +123,8 @@ class BatchProtocol(Protocol):
 
         :param ecsPropertiesOverride: the same parameter that boto3 will receive
 
+        :param eksPropertiesOverride: the same parameter that boto3 will receive
+
         :param tags: the same parameter that boto3 will receive
 
         :return: an API response

airflow/providers/amazon/aws/hooks/rds.py

@@ -155,7 +155,7 @@ class RdsHook(AwsGenericHook["RDSClient"]):
         try:
             response = self.conn.describe_export_tasks(ExportTaskIdentifier=export_task_id)
         except self.conn.exceptions.ClientError as e:
-            if e.response["Error"]["Code"] == "ExportTaskNotFoundFault":
+            if e.response["Error"]["Code"] in ("ExportTaskNotFound", "ExportTaskNotFoundFault"):
                 raise AirflowNotFoundException(e)
             raise e
         return response["ExportTasks"][0]["Status"].lower()
@@ -196,7 +196,7 @@ class RdsHook(AwsGenericHook["RDSClient"]):
         try:
             response = self.conn.describe_event_subscriptions(SubscriptionName=subscription_name)
         except self.conn.exceptions.ClientError as e:
-            if e.response["Error"]["Code"] == "SubscriptionNotFoundFault":
+            if e.response["Error"]["Code"] in ("SubscriptionNotFoundFault", "SubscriptionNotFound"):
                 raise AirflowNotFoundException(e)
             raise e
         return response["EventSubscriptionsList"][0]["Status"].lower()

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

@@ -68,6 +68,7 @@ class BatchOperator(BaseOperator):
     :param overrides: DEPRECATED, use container_overrides instead with the same value.
     :param container_overrides: the `containerOverrides` parameter for boto3 (templated)
     :param ecs_properties_override: the `ecsPropertiesOverride` parameter for boto3 (templated)
+    :param eks_properties_override: the `eksPropertiesOverride` parameter for boto3 (templated)
     :param node_overrides: the `nodeOverrides` parameter for boto3 (templated)
     :param share_identifier: The share identifier for the job. Don't specify this parameter if the job queue
         doesn't have a scheduling policy.
@@ -116,6 +117,7 @@ class BatchOperator(BaseOperator):
         "container_overrides",
         "array_properties",
         "ecs_properties_override",
+        "eks_properties_override",
         "node_overrides",
         "parameters",
         "retry_strategy",
@@ -129,6 +131,7 @@ class BatchOperator(BaseOperator):
         "container_overrides": "json",
         "parameters": "json",
         "ecs_properties_override": "json",
+        "eks_properties_override": "json",
         "node_overrides": "json",
         "retry_strategy": "json",
     }
@@ -166,6 +169,7 @@ class BatchOperator(BaseOperator):
         container_overrides: dict | None = None,
         array_properties: dict | None = None,
         ecs_properties_override: dict | None = None,
+        eks_properties_override: dict | None = None,
         node_overrides: dict | None = None,
         share_identifier: str | None = None,
         scheduling_priority_override: int | None = None,
@@ -208,6 +212,7 @@ class BatchOperator(BaseOperator):
             )
 
         self.ecs_properties_override = ecs_properties_override
+        self.eks_properties_override = eks_properties_override
         self.node_overrides = node_overrides
         self.share_identifier = share_identifier
         self.scheduling_priority_override = scheduling_priority_override
@@ -307,6 +312,8 @@ class BatchOperator(BaseOperator):
             self.log.info("AWS Batch job - array properties: %s", self.array_properties)
         if self.ecs_properties_override:
             self.log.info("AWS Batch job - ECS properties: %s", self.ecs_properties_override)
+        if self.eks_properties_override:
+            self.log.info("AWS Batch job - EKS properties: %s", self.eks_properties_override)
         if self.node_overrides:
             self.log.info("AWS Batch job - node properties: %s", self.node_overrides)
 
@@ -319,6 +326,7 @@ class BatchOperator(BaseOperator):
             "tags": self.tags,
             "containerOverrides": self.container_overrides,
             "ecsPropertiesOverride": self.ecs_properties_override,
+            "eksPropertiesOverride": self.eks_properties_override,
             "nodeOverrides": self.node_overrides,
             "retryStrategy": self.retry_strategy,
             "shareIdentifier": self.share_identifier,

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

@@ -1382,30 +1382,30 @@ class EmrServerlessStartJobOperator(BaseOperator):
 
         self.persist_links(context)
 
-        if self.deferrable:
-            self.defer(
-                trigger=EmrServerlessStartJobTrigger(
-                    application_id=self.application_id,
-                    job_id=self.job_id,
-                    waiter_delay=self.waiter_delay,
-                    waiter_max_attempts=self.waiter_max_attempts,
-                    aws_conn_id=self.aws_conn_id,
-                ),
-                method_name="execute_complete",
-                timeout=timedelta(seconds=self.waiter_max_attempts * self.waiter_delay),
-            )
-
         if self.wait_for_completion:
-            waiter = self.hook.get_waiter("serverless_job_completed")
-            wait(
-                waiter=waiter,
-                waiter_max_attempts=self.waiter_max_attempts,
-                waiter_delay=self.waiter_delay,
-                args={"applicationId": self.application_id, "jobRunId": self.job_id},
-                failure_message="Serverless Job failed",
-                status_message="Serverless Job status is",
-                status_args=["jobRun.state", "jobRun.stateDetails"],
-            )
+            if self.deferrable:
+                self.defer(
+                    trigger=EmrServerlessStartJobTrigger(
+                        application_id=self.application_id,
+                        job_id=self.job_id,
+                        waiter_delay=self.waiter_delay,
+                        waiter_max_attempts=self.waiter_max_attempts,
+                        aws_conn_id=self.aws_conn_id,
+                    ),
+                    method_name="execute_complete",
+                    timeout=timedelta(seconds=self.waiter_max_attempts * self.waiter_delay),
+                )
+            else:
+                waiter = self.hook.get_waiter("serverless_job_completed")
+                wait(
+                    waiter=waiter,
+                    waiter_max_attempts=self.waiter_max_attempts,
+                    waiter_delay=self.waiter_delay,
+                    args={"applicationId": self.application_id, "jobRunId": self.job_id},
+                    failure_message="Serverless Job failed",
+                    status_message="Serverless Job status is",
+                    status_args=["jobRun.state", "jobRun.stateDetails"],
+                )
 
         return self.job_id
 

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

@@ -32,6 +32,7 @@ from airflow.providers.amazon.aws.triggers.redshift_cluster import (
     RedshiftResumeClusterTrigger,
 )
 from airflow.providers.amazon.aws.utils import validate_execute_complete_event
+from airflow.utils.helpers import prune_dict
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -507,8 +508,8 @@ class RedshiftResumeClusterOperator(BaseOperator):
         aws_conn_id: str | None = "aws_default",
         wait_for_completion: bool = False,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
-        poll_interval: int = 10,
-        max_attempts: int = 10,
+        poll_interval: int = 30,
+        max_attempts: int = 30,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -542,38 +543,38 @@ class RedshiftResumeClusterOperator(BaseOperator):
                 else:
                     raise error
 
-        if self.deferrable:
-            cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
-            if cluster_state == "available":
-                self.log.info("Resumed cluster successfully")
-            elif cluster_state == "deleting":
-                raise AirflowException(
-                    "Unable to resume cluster since cluster is currently in status: %s", cluster_state
-                )
+        if self.wait_for_completion:
+            if self.deferrable:
+                cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+                if cluster_state == "available":
+                    self.log.info("Resumed cluster successfully")
+                elif cluster_state == "deleting":
+                    raise AirflowException(
+                        "Unable to resume cluster since cluster is currently in status: %s", cluster_state
+                    )
+                else:
+                    self.defer(
+                        trigger=RedshiftResumeClusterTrigger(
+                            cluster_identifier=self.cluster_identifier,
+                            waiter_delay=self.poll_interval,
+                            waiter_max_attempts=self.max_attempts,
+                            aws_conn_id=self.aws_conn_id,
+                        ),
+                        method_name="execute_complete",
+                        # timeout is set to ensure that if a trigger dies, the timeout does not restart
+                        # 60 seconds is added to allow the trigger to exit gracefully (i.e. yield TriggerEvent)
+                        timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
+                    )
             else:
-                self.defer(
-                    trigger=RedshiftResumeClusterTrigger(
-                        cluster_identifier=self.cluster_identifier,
-                        waiter_delay=self.poll_interval,
-                        waiter_max_attempts=self.max_attempts,
-                        aws_conn_id=self.aws_conn_id,
-                    ),
-                    method_name="execute_complete",
-                    # timeout is set to ensure that if a trigger dies, the timeout does not restart
-                    # 60 seconds is added to allow the trigger to exit gracefully (i.e. yield TriggerEvent)
-                    timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
+                waiter = redshift_hook.get_waiter("cluster_resumed")
+                waiter.wait(
+                    ClusterIdentifier=self.cluster_identifier,
+                    WaiterConfig={
+                        "Delay": self.poll_interval,
+                        "MaxAttempts": self.max_attempts,
+                    },
                 )
 
-        if self.wait_for_completion:
-            waiter = redshift_hook.get_waiter("cluster_resumed")
-            waiter.wait(
-                ClusterIdentifier=self.cluster_identifier,
-                WaiterConfig={
-                    "Delay": self.poll_interval,
-                    "MaxAttempts": self.max_attempts,
-                },
-            )
-
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
         event = validate_execute_complete_event(event)
 
@@ -596,6 +597,7 @@ class RedshiftPauseClusterOperator(BaseOperator):
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
+    :param wait_for_completion: If True, waits for the cluster to be paused. (default: False)
     :param deferrable: Run operator in the deferrable mode
     :param poll_interval: Time (in seconds) to wait between two consecutive calls to check cluster state
     :param max_attempts: Maximum number of attempts to poll the cluster
@@ -610,14 +612,16 @@ class RedshiftPauseClusterOperator(BaseOperator):
         *,
         cluster_identifier: str,
         aws_conn_id: str | None = "aws_default",
+        wait_for_completion: bool = False,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
-        poll_interval: int = 10,
-        max_attempts: int = 15,
+        poll_interval: int = 30,
+        max_attempts: int = 30,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.cluster_identifier = cluster_identifier
         self.aws_conn_id = aws_conn_id
+        self.wait_for_completion = wait_for_completion
         self.deferrable = deferrable
         self.max_attempts = max_attempts
         self.poll_interval = poll_interval
@@ -643,26 +647,38 @@ class RedshiftPauseClusterOperator(BaseOperator):
                     time.sleep(self._attempt_interval)
                 else:
                     raise error
-        if self.deferrable:
-            cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
-            if cluster_state == "paused":
-                self.log.info("Paused cluster successfully")
-            elif cluster_state == "deleting":
-                raise AirflowException(
-                    f"Unable to pause cluster since cluster is currently in status: {cluster_state}"
-                )
+        if self.wait_for_completion:
+            if self.deferrable:
+                cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+                if cluster_state == "paused":
+                    self.log.info("Paused cluster successfully")
+                elif cluster_state == "deleting":
+                    raise AirflowException(
+                        f"Unable to pause cluster since cluster is currently in status: {cluster_state}"
+                    )
+                else:
+                    self.defer(
+                        trigger=RedshiftPauseClusterTrigger(
+                            cluster_identifier=self.cluster_identifier,
+                            waiter_delay=self.poll_interval,
+                            waiter_max_attempts=self.max_attempts,
+                            aws_conn_id=self.aws_conn_id,
+                        ),
+                        method_name="execute_complete",
+                        # timeout is set to ensure that if a trigger dies, the timeout does not restart
+                        # 60 seconds is added to allow the trigger to exit gracefully (i.e. yield TriggerEvent)
+                        timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
+                    )
             else:
-                self.defer(
-                    trigger=RedshiftPauseClusterTrigger(
-                        cluster_identifier=self.cluster_identifier,
-                        waiter_delay=self.poll_interval,
-                        waiter_max_attempts=self.max_attempts,
-                        aws_conn_id=self.aws_conn_id,
+                waiter = redshift_hook.get_waiter("cluster_paused")
+                waiter.wait(
+                    ClusterIdentifier=self.cluster_identifier,
+                    WaiterConfig=prune_dict(
+                        {
+                            "Delay": self.poll_interval,
+                            "MaxAttempts": self.max_attempts,
+                        }
                     ),
-                    method_name="execute_complete",
-                    # timeout is set to ensure that if a trigger dies, the timeout does not restart
-                    # 60 seconds is added to allow the trigger to exit gracefully (i.e. yield TriggerEvent)
-                    timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
                 )
 
     def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:

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

@@ -127,8 +127,8 @@ class RedshiftDataOperator(AwsBaseOperator[RedshiftDataHook]):
 
         # Set wait_for_completion to False so that it waits for the status in the deferred task.
         wait_for_completion = self.wait_for_completion
-        if self.deferrable and self.wait_for_completion:
-            self.wait_for_completion = False
+        if self.deferrable:
+            wait_for_completion = False
 
         self.statement_id = self.hook.execute_query(
             database=self.database,
@@ -144,7 +144,7 @@ class RedshiftDataOperator(AwsBaseOperator[RedshiftDataHook]):
             poll_interval=self.poll_interval,
         )
 
-        if self.deferrable:
+        if self.deferrable and self.wait_for_completion:
             is_finished = self.hook.check_query_is_finished(self.statement_id)
             if not is_finished:
                 self.defer(

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

@@ -36,7 +36,6 @@ from airflow.providers.amazon.aws.hooks.sagemaker import (
 )
 from airflow.providers.amazon.aws.triggers.sagemaker import (
     SageMakerPipelineTrigger,
-    SageMakerTrainingPrintLogTrigger,
     SageMakerTrigger,
 )
 from airflow.providers.amazon.aws.utils import trim_none_values, validate_execute_complete_event
@@ -1195,25 +1194,15 @@ class SageMakerTrainingOperator(SageMakerBaseOperator):
             if self.max_ingestion_time:
                 timeout = datetime.timedelta(seconds=self.max_ingestion_time)
 
-            trigger: SageMakerTrainingPrintLogTrigger | SageMakerTrigger
-            if self.print_log:
-                trigger = SageMakerTrainingPrintLogTrigger(
-                    job_name=self.config["TrainingJobName"],
-                    poke_interval=self.check_interval,
-                    aws_conn_id=self.aws_conn_id,
-                )
-            else:
-                trigger = SageMakerTrigger(
+            self.defer(
+                timeout=timeout,
+                trigger=SageMakerTrigger(
                     job_name=self.config["TrainingJobName"],
                     job_type="Training",
                     poke_interval=self.check_interval,
                     max_attempts=self.max_attempts,
                     aws_conn_id=self.aws_conn_id,
-                )
-
-            self.defer(
-                timeout=timeout,
-                trigger=trigger,
+                ),
                 method_name="execute_complete",
             )
 

airflow/providers/amazon/aws/sensors/athena.py

@@ -25,7 +25,7 @@ from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.athena import AthenaHook
 
 
@@ -88,11 +88,7 @@ class AthenaSensor(AwsBaseSensor[AthenaHook]):
         state = self.hook.poll_query_status(self.query_execution_id, self.max_retries, self.sleep_time)
 
         if state in self.FAILURE_STATES:
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            message = "Athena sensor failed"
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException("Athena sensor failed")
 
         if state in self.INTERMEDIATE_STATES:
             return False

airflow/providers/amazon/aws/sensors/batch.py

@@ -86,18 +86,7 @@ class BatchSensor(BaseSensorOperator):
         if state in BatchClientHook.INTERMEDIATE_STATES:
             return False
 
-        if state == BatchClientHook.FAILURE_STATE:
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            message = f"Batch sensor failed. AWS Batch job status: {state}"
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
-
-        # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-        message = f"Batch sensor failed. Unknown AWS Batch job status: {state}"
-        if self.soft_fail:
-            raise AirflowSkipException(message)
-        raise AirflowException(message)
+        raise AirflowException(f"Batch sensor failed. AWS Batch job status: {state}")
 
     def execute(self, context: Context) -> None:
         if not self.deferrable:
@@ -127,12 +116,7 @@ class BatchSensor(BaseSensorOperator):
         Relies on trigger to throw an exception, otherwise it assumes execution was successful.
         """
         if event["status"] != "success":
-            message = f"Error while running job: {event}"
-            # TODO: remove this if-else block when min_airflow_version is set to higher than the version that
-            # changed in https://github.com/apache/airflow/pull/33424 is released (2.7.1)
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException(f"Error while running job: {event}")
         job_id = event["job_id"]
         self.log.info("Batch Job %s complete", job_id)
 
@@ -198,11 +182,7 @@ class BatchComputeEnvironmentSensor(BaseSensorOperator):
         )
 
         if not response["computeEnvironments"]:
-            message = f"AWS Batch compute environment {self.compute_environment} not found"
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException(f"AWS Batch compute environment {self.compute_environment} not found")
 
         status = response["computeEnvironments"][0]["status"]
 
@@ -212,11 +192,9 @@ class BatchComputeEnvironmentSensor(BaseSensorOperator):
         if status in BatchClientHook.COMPUTE_ENVIRONMENT_INTERMEDIATE_STATUS:
             return False
 
-        # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-        message = f"AWS Batch compute environment failed. AWS Batch compute environment status: {status}"
-        if self.soft_fail:
-            raise AirflowSkipException(message)
-        raise AirflowException(message)
+        raise AirflowException(
+            f"AWS Batch compute environment failed. AWS Batch compute environment status: {status}"
+        )
 
 
 class BatchJobQueueSensor(BaseSensorOperator):
@@ -276,11 +254,7 @@ class BatchJobQueueSensor(BaseSensorOperator):
             if self.treat_non_existing_as_deleted:
                 return True
             else:
-                # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-                message = f"AWS Batch job queue {self.job_queue} not found"
-                if self.soft_fail:
-                    raise AirflowSkipException(message)
-                raise AirflowException(message)
+                raise AirflowException(f"AWS Batch job queue {self.job_queue} not found")
 
         status = response["jobQueues"][0]["status"]
 

airflow/providers/amazon/aws/sensors/bedrock.py

@@ -21,7 +21,7 @@ import abc
 from typing import TYPE_CHECKING, Any, Sequence, TypeVar
 
 from airflow.configuration import conf
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.bedrock import BedrockAgentHook, BedrockHook
 from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.bedrock import (
@@ -76,9 +76,6 @@ class BedrockBaseSensor(AwsBaseSensor[_GenericBedrockHook]):
     def poke(self, context: Context, **kwargs) -> bool:
         state = self.get_state()
         if state in self.FAILURE_STATES:
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            if self.soft_fail:
-                raise AirflowSkipException(self.FAILURE_MESSAGE)
             raise AirflowException(self.FAILURE_MESSAGE)
 
         return state not in self.INTERMEDIATE_STATES

airflow/providers/amazon/aws/sensors/cloud_formation.py

@@ -27,7 +27,6 @@ from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
-from airflow.exceptions import AirflowSkipException
 from airflow.providers.amazon.aws.hooks.cloud_formation import CloudFormationHook
 
 
@@ -67,11 +66,7 @@ class CloudFormationCreateStackSensor(AwsBaseSensor[CloudFormationHook]):
         if stack_status in ("CREATE_IN_PROGRESS", None):
             return False
 
-        # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
-        message = f"Stack {self.stack_name} in bad state: {stack_status}"
-        if self.soft_fail:
-            raise AirflowSkipException(message)
-        raise ValueError(message)
+        raise ValueError(f"Stack {self.stack_name} in bad state: {stack_status}")
 
 
 class CloudFormationDeleteStackSensor(AwsBaseSensor[CloudFormationHook]):
@@ -119,8 +114,4 @@ class CloudFormationDeleteStackSensor(AwsBaseSensor[CloudFormationHook]):
         if stack_status == "DELETE_IN_PROGRESS":
             return False
 
-        # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
-        message = f"Stack {self.stack_name} in bad state: {stack_status}"
-        if self.soft_fail:
-            raise AirflowSkipException(message)
-        raise ValueError(message)
+        raise ValueError(f"Stack {self.stack_name} in bad state: {stack_status}")

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

@@ -20,7 +20,7 @@ import abc
 from typing import TYPE_CHECKING, Any, Sequence
 
 from airflow.configuration import conf
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.comprehend import ComprehendHook
 from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.comprehend import (
@@ -71,9 +71,6 @@ class ComprehendBaseSensor(AwsBaseSensor[ComprehendHook]):
     def poke(self, context: Context, **kwargs) -> bool:
         state = self.get_state()
         if state in self.FAILURE_STATES:
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            if self.soft_fail:
-                raise AirflowSkipException(self.FAILURE_MESSAGE)
             raise AirflowException(self.FAILURE_MESSAGE)
 
         return state not in self.INTERMEDIATE_STATES
@@ -241,9 +238,6 @@ class ComprehendCreateDocumentClassifierCompletedSensor(AwsBaseSensor[Comprehend
         )
 
         if status in self.FAILURE_STATES:
-            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-            if self.soft_fail:
-                raise AirflowSkipException(self.FAILURE_MESSAGE)
             raise AirflowException(self.FAILURE_MESSAGE)
 
         if status in self.SUCCESS_STATES:

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

@@ -21,7 +21,7 @@ from typing import TYPE_CHECKING, Iterable, Sequence
 
 from deprecated import deprecated
 
-from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
+from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.dms import DmsHook
 from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
@@ -75,11 +75,9 @@ class DmsTaskBaseSensor(AwsBaseSensor[DmsHook]):
 
     def poke(self, context: Context):
         if not (status := self.hook.get_task_status(self.replication_task_arn)):
-            # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
-            message = f"Failed to read task status, task with ARN {self.replication_task_arn} not found"
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException(
+                f"Failed to read task status, task with ARN {self.replication_task_arn} not found"
+            )
 
         self.log.info("DMS Replication task (%s) has status: %s", self.replication_task_arn, status)
 
@@ -87,11 +85,7 @@ class DmsTaskBaseSensor(AwsBaseSensor[DmsHook]):
             return True
 
         if status in self.termination_statuses:
-            # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
-            message = f"Unexpected status: {status}"
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException(f"Unexpected status: {status}")
 
         return False
 

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

@@ -21,7 +21,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any, Sequence
 
 from airflow.configuration import conf
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.ec2 import EC2Hook
 from airflow.providers.amazon.aws.triggers.ec2 import EC2StateSensorTrigger
 from airflow.providers.amazon.aws.utils import validate_execute_complete_event
@@ -97,8 +97,4 @@ class EC2InstanceStateSensor(BaseSensorOperator):
         event = validate_execute_complete_event(event)
 
         if event["status"] != "success":
-            # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
-            message = f"Error: {event}"
-            if self.soft_fail:
-                raise AirflowSkipException(message)
-            raise AirflowException(message)
+            raise AirflowException(f"Error: {event}")

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

@@ -19,7 +19,7 @@ from __future__ import annotations
 from functools import cached_property
 from typing import TYPE_CHECKING, Sequence
 
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.ecs import (
     EcsClusterStates,
     EcsHook,
@@ -37,11 +37,9 @@ if TYPE_CHECKING:
 
 def _check_failed(current_state, target_state, failure_states, soft_fail: bool) -> None:
     if (current_state != target_state) and (current_state in failure_states):
-        # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
-        message = f"Terminal state reached. Current state: {current_state}, Expected state: {target_state}"
-        if soft_fail:
-            raise AirflowSkipException(message)
-        raise AirflowException(message)
+        raise AirflowException(
+            f"Terminal state reached. Current state: {current_state}, Expected state: {target_state}"
+        )
 
 
 class EcsBaseSensor(AwsBaseSensor[EcsHook]):