apache-airflow-providers-amazon 9.6.0rc1__py3-none-any.whl → 9.6.1__py3-none-any.whl

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

@@ -850,9 +850,8 @@ class EmrModifyClusterOperator(BaseOperator):
 
         if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
             raise AirflowException(f"Modify cluster failed: {response}")
-        else:
-            self.log.info("Steps concurrency level %d", response["StepConcurrencyLevel"])
-            return response["StepConcurrencyLevel"]
+        self.log.info("Steps concurrency level %d", response["StepConcurrencyLevel"])
+        return response["StepConcurrencyLevel"]
 
 
 class EmrTerminateJobFlowOperator(BaseOperator):
@@ -1070,7 +1069,7 @@ class EmrServerlessCreateApplicationOperator(BaseOperator):
         if event is None:
             self.log.error("Trigger error: event is None")
             raise AirflowException("Trigger error: event is None")
-        elif event["status"] != "success":
+        if event["status"] != "success":
             raise AirflowException(f"Application {event['application_id']} failed to create")
         self.log.info("Starting application %s", event["application_id"])
         self.hook.conn.start_application(applicationId=event["application_id"])
@@ -1533,7 +1532,7 @@ class EmrServerlessStopApplicationOperator(BaseOperator):
         if event is None:
             self.log.error("Trigger error: event is None")
             raise AirflowException("Trigger error: event is None")
-        elif event["status"] == "success":
+        if event["status"] == "success":
             self.hook.conn.stop_application(applicationId=self.application_id)
             self.defer(
                 trigger=EmrServerlessStopApplicationTrigger(

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

@@ -97,7 +97,7 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
         note: str | None = None,
         wait_for_completion: bool = False,
         waiter_delay: int = 60,
-        waiter_max_attempts: int = 720,
+        waiter_max_attempts: int = 20,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         **kwargs,
     ):

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

@@ -139,7 +139,7 @@ class NeptuneStartDbClusterOperator(AwsBaseOperator[NeptuneHook]):
         if status.lower() in NeptuneHook.AVAILABLE_STATES:
             self.log.info("Neptune cluster %s is already available.", self.cluster_id)
             return {"db_cluster_id": self.cluster_id}
-        elif status.lower() in NeptuneHook.ERROR_STATES:
+        if status.lower() in NeptuneHook.ERROR_STATES:
             # some states will not allow you to start the cluster
             self.log.error(
                 "Neptune cluster %s is in error state %s and cannot be started", self.cluster_id, status
@@ -259,7 +259,7 @@ class NeptuneStopDbClusterOperator(AwsBaseOperator[NeptuneHook]):
         if status.lower() in NeptuneHook.STOPPED_STATES:
             self.log.info("Neptune cluster %s is already stopped.", self.cluster_id)
             return {"db_cluster_id": self.cluster_id}
-        elif status.lower() in NeptuneHook.ERROR_STATES:
+        if status.lower() in NeptuneHook.ERROR_STATES:
             # some states will not allow you to stop the cluster
             self.log.error(
                 "Neptune cluster %s is in error state %s and cannot be stopped", self.cluster_id, status

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

@@ -224,8 +224,7 @@ class RedshiftDataOperator(AwsBaseOperator[RedshiftDataHook]):
             results: list = [self.hook.conn.get_statement_result(Id=sid) for sid in statement_ids]
             self.log.debug("Statement result(s): %s", results)
             return results
-        else:
-            return statement_ids
+        return statement_ids
 
     def on_kill(self) -> None:
         """Cancel the submitted redshift query."""

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

@@ -158,9 +158,8 @@ class S3GetBucketTaggingOperator(AwsBaseOperator[S3Hook]):
         if self.hook.check_for_bucket(self.bucket_name):
             self.log.info("Getting tags for bucket %s", self.bucket_name)
             return self.hook.get_bucket_tagging(self.bucket_name)
-        else:
-            self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
-            return None
+        self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
+        return None
 
 
 class S3PutBucketTaggingOperator(AwsBaseOperator[S3Hook]):
@@ -213,9 +212,8 @@ class S3PutBucketTaggingOperator(AwsBaseOperator[S3Hook]):
             return self.hook.put_bucket_tagging(
                 key=self.key, value=self.value, tag_set=self.tag_set, bucket_name=self.bucket_name
             )
-        else:
-            self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
-            return None
+        self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
+        return None
 
 
 class S3DeleteBucketTaggingOperator(AwsBaseOperator[S3Hook]):
@@ -254,9 +252,8 @@ class S3DeleteBucketTaggingOperator(AwsBaseOperator[S3Hook]):
         if self.hook.check_for_bucket(self.bucket_name):
             self.log.info("Deleting tags for bucket %s", self.bucket_name)
             return self.hook.delete_bucket_tagging(self.bucket_name)
-        else:
-            self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
-            return None
+        self.log.warning(BUCKET_DOES_NOT_EXIST_MSG, self.bucket_name)
+        return None
 
 
 class S3CopyObjectOperator(AwsBaseOperator[S3Hook]):
@@ -725,10 +722,9 @@ class S3FileTransformOperator(AwsBaseOperator[S3Hook]):
 
                     if process.returncode:
                         raise AirflowException(f"Transform script failed: {process.returncode}")
-                    else:
-                        self.log.info(
-                            "Transform script successful. Output temporarily located at %s", f_dest.name
-                        )
+                    self.log.info(
+                        "Transform script successful. Output temporarily located at %s", f_dest.name
+                    )
 
             self.log.info("Uploading transformed file to S3")
             f_dest.flush()

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

@@ -165,13 +165,10 @@ class SageMakerBaseOperator(BaseOperator):
             # in case there is collision.
             if fail_if_exists:
                 raise AirflowException(f"A SageMaker {resource_type} with name {name} already exists.")
-            else:
-                max_name_len = 63
-                timestamp = str(
-                    time.time_ns() // 1000000000
-                )  # only keep the relevant datetime (first 10 digits)
-                name = f"{proposed_name[: max_name_len - len(timestamp) - 1]}-{timestamp}"  # we subtract one to make provision for the dash between the truncated name and timestamp
-                self.log.info("Changed %s name to '%s' to avoid collision.", resource_type, name)
+            max_name_len = 63
+            timestamp = str(time.time_ns() // 1000000000)  # only keep the relevant datetime (first 10 digits)
+            name = f"{proposed_name[: max_name_len - len(timestamp) - 1]}-{timestamp}"  # we subtract one to make provision for the dash between the truncated name and timestamp
+            self.log.info("Changed %s name to '%s' to avoid collision.", resource_type, name)
         return name
 
     def _check_resource_type(self, resource_type: str):
@@ -197,8 +194,7 @@ class SageMakerBaseOperator(BaseOperator):
         except ClientError as e:
             if e.response["Error"]["Code"] == "ValidationException":
                 return False  # ValidationException is thrown when the resource could not be found
-            else:
-                raise e
+            raise e
 
     def execute(self, context: Context):
         raise NotImplementedError("Please implement execute() in sub class!")
@@ -326,7 +322,7 @@ class SageMakerProcessingOperator(SageMakerBaseOperator):
             status = response["ProcessingJobStatus"]
             if status in self.hook.failed_states:
                 raise AirflowException(f"SageMaker job failed because {response['FailureReason']}")
-            elif status == "Completed":
+            if status == "Completed":
                 self.log.info("%s completed successfully.", self.task_id)
                 return {"Processing": serialize(response)}
 
@@ -430,12 +426,9 @@ class SageMakerEndpointConfigOperator(SageMakerBaseOperator):
         response = self.hook.create_endpoint_config(self.config)
         if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
             raise AirflowException(f"Sagemaker endpoint config creation failed: {response}")
-        else:
-            return {
-                "EndpointConfig": serialize(
-                    self.hook.describe_endpoint_config(self.config["EndpointConfigName"])
-                )
-            }
+        return {
+            "EndpointConfig": serialize(self.hook.describe_endpoint_config(self.config["EndpointConfigName"]))
+        }
 
 
 class SageMakerEndpointOperator(SageMakerBaseOperator):
@@ -1038,8 +1031,7 @@ class SageMakerModelOperator(SageMakerBaseOperator):
         response = self.hook.create_model(self.config)
         if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
             raise AirflowException(f"Sagemaker model creation failed: {response}")
-        else:
-            return {"Model": serialize(self.hook.describe_model(self.config["ModelName"]))}
+        return {"Model": serialize(self.hook.describe_model(self.config["ModelName"]))}
 
 
 class SageMakerTrainingOperator(SageMakerBaseOperator):
@@ -1177,7 +1169,7 @@ class SageMakerTrainingOperator(SageMakerBaseOperator):
             if status in self.hook.failed_states:
                 reason = description.get("FailureReason", "(No reason provided)")
                 raise AirflowException(f"SageMaker job failed because {reason}")
-            elif status == "Completed":
+            if status == "Completed":
                 log_message = f"{self.task_id} completed successfully."
                 if self.print_log:
                     billable_seconds = SageMakerHook.count_billable_seconds(

airflow/providers/amazon/aws/secrets/secrets_manager.py

@@ -224,8 +224,7 @@ class SecretsManagerBackend(BaseSecretsBackend, LoggingMixin):
             standardized_secret_dict = self._standardize_secret_keys(secret_dict)
             standardized_secret = json.dumps(standardized_secret_dict)
             return standardized_secret
-        else:
-            return secret
+        return secret
 
     def get_variable(self, key: str) -> str | None:
         """

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

@@ -18,20 +18,20 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from datetime import timedelta
-from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.batch_client import BatchClientHook
+from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.batch import BatchJobTrigger
-from airflow.sensors.base import BaseSensorOperator
+from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
 
-class BatchSensor(BaseSensorOperator):
+class BatchSensor(AwsBaseSensor[BatchClientHook]):
     """
     Poll the state of the Batch Job until it reaches a terminal state; fails if the job fails.
 
@@ -40,19 +40,24 @@ class BatchSensor(BaseSensorOperator):
         :ref:`howto/sensor:BatchSensor`
 
     :param job_id: Batch job_id to check the state for
-    :param aws_conn_id: aws connection to use, defaults to 'aws_default'
-        If this is None or empty then the default boto3 behaviour is used. If
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         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 region_name: aws region name associated with the client
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param deferrable: Run sensor in the deferrable mode.
     :param poke_interval: polling period in seconds to check for the status of the job.
     :param max_retries: Number of times to poll for job state before
         returning the current state.
     """
 
-    template_fields: Sequence[str] = ("job_id",)
+    aws_hook_class = BatchClientHook
+    template_fields: Sequence[str] = aws_template_fields(
+        "job_id",
+    )
     template_ext: Sequence[str] = ()
     ui_color = "#66c3ff"
 
@@ -60,8 +65,6 @@ class BatchSensor(BaseSensorOperator):
         self,
         *,
         job_id: str,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         poke_interval: float = 30,
         max_retries: int = 4200,
@@ -69,8 +72,6 @@ class BatchSensor(BaseSensorOperator):
     ):
         super().__init__(**kwargs)
         self.job_id = job_id
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.deferrable = deferrable
         self.poke_interval = poke_interval
         self.max_retries = max_retries
@@ -119,15 +120,8 @@ class BatchSensor(BaseSensorOperator):
         job_id = event["job_id"]
         self.log.info("Batch Job %s complete", job_id)
 
-    @cached_property
-    def hook(self) -> BatchClientHook:
-        return BatchClientHook(
-            aws_conn_id=self.aws_conn_id,
-            region_name=self.region_name,
-        )
-
 
-class BatchComputeEnvironmentSensor(BaseSensorOperator):
+class BatchComputeEnvironmentSensor(AwsBaseSensor[BatchClientHook]):
     """
     Poll the state of the Batch environment until it reaches a terminal state; fails if the environment fails.
 
@@ -137,38 +131,31 @@ class BatchComputeEnvironmentSensor(BaseSensorOperator):
 
     :param compute_environment: Batch compute environment name
 
-    :param aws_conn_id: aws connection to use, defaults to 'aws_default'
-        If this is None or empty then the default boto3 behaviour is used. If
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         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 region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
 
-    :param region_name: aws region name associated with the client
     """
 
-    template_fields: Sequence[str] = ("compute_environment",)
+    aws_hook_class = BatchClientHook
+    template_fields: Sequence[str] = aws_template_fields(
+        "compute_environment",
+    )
     template_ext: Sequence[str] = ()
     ui_color = "#66c3ff"
 
     def __init__(
         self,
         compute_environment: str,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.compute_environment = compute_environment
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
-
-    @cached_property
-    def hook(self) -> BatchClientHook:
-        """Create and return a BatchClientHook."""
-        return BatchClientHook(
-            aws_conn_id=self.aws_conn_id,
-            region_name=self.region_name,
-        )
 
     def poke(self, context: Context) -> bool:
         response = self.hook.client.describe_compute_environments(  # type: ignore[union-attr]
@@ -191,7 +178,7 @@ class BatchComputeEnvironmentSensor(BaseSensorOperator):
         )
 
 
-class BatchJobQueueSensor(BaseSensorOperator):
+class BatchJobQueueSensor(AwsBaseSensor[BatchClientHook]):
     """
     Poll the state of the Batch job queue until it reaches a terminal state; fails if the queue fails.
 
@@ -204,16 +191,20 @@ class BatchJobQueueSensor(BaseSensorOperator):
     :param treat_non_existing_as_deleted: If True, a non-existing Batch job queue is considered as a deleted
         queue and as such a valid case.
 
-    :param aws_conn_id: aws connection to use, defaults to 'aws_default'
-        If this is None or empty then the default boto3 behaviour is used. If
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         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 region_name: aws region name associated with the client
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     """
 
-    template_fields: Sequence[str] = ("job_queue",)
+    aws_hook_class = BatchClientHook
+    template_fields: Sequence[str] = aws_template_fields(
+        "job_queue",
+    )
     template_ext: Sequence[str] = ()
     ui_color = "#66c3ff"
 
@@ -221,23 +212,11 @@ class BatchJobQueueSensor(BaseSensorOperator):
         self,
         job_queue: str,
         treat_non_existing_as_deleted: bool = False,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.job_queue = job_queue
         self.treat_non_existing_as_deleted = treat_non_existing_as_deleted
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
-
-    @cached_property
-    def hook(self) -> BatchClientHook:
-        """Create and return a BatchClientHook."""
-        return BatchClientHook(
-            aws_conn_id=self.aws_conn_id,
-            region_name=self.region_name,
-        )
 
     def poke(self, context: Context) -> bool:
         response = self.hook.client.describe_job_queues(  # type: ignore[union-attr]
@@ -247,8 +226,7 @@ class BatchJobQueueSensor(BaseSensorOperator):
         if not response["jobQueues"]:
             if self.treat_non_existing_as_deleted:
                 return True
-            else:
-                raise AirflowException(f"AWS Batch job queue {self.job_queue} not found")
+            raise AirflowException(f"AWS Batch job queue {self.job_queue} not found")
 
         status = response["jobQueues"][0]["status"]
 

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

@@ -18,19 +18,20 @@
 
 from __future__ import annotations
 
+import warnings
 from abc import abstractmethod
 from collections.abc import Sequence
-from functools import cached_property
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowException
+from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.eks import (
     ClusterStates,
     EksHook,
     FargateProfileStates,
     NodegroupStates,
 )
-from airflow.sensors.base import BaseSensorOperator
+from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
+from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -57,7 +58,7 @@ NODEGROUP_TERMINAL_STATES = frozenset(
 )
 
 
-class EksBaseSensor(BaseSensorOperator):
+class EksBaseSensor(AwsBaseSensor):
     """
     Base class to check various EKS states.
 
@@ -68,41 +69,33 @@ class EksBaseSensor(BaseSensorOperator):
     :param target_state_type: The enum containing the states,
         will be used to convert the target state if it has to be converted from a string
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
-        empty, then the default boto3 configuration would be used (and must be
+        empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region: Which AWS region the connection should use.
-        If this is None or empty then the default boto3 behaviour is used.
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     """
 
+    aws_hook_class = EksHook
+
     def __init__(
         self,
         *,
         cluster_name: str,
         target_state: ClusterStates | NodegroupStates | FargateProfileStates,
         target_state_type: type,
-        aws_conn_id: str | None = DEFAULT_CONN_ID,
-        region: str | None = None,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.cluster_name = cluster_name
-        self.aws_conn_id = aws_conn_id
-        self.region = region
         self.target_state = (
             target_state
             if isinstance(target_state, target_state_type)
             else target_state_type(str(target_state).upper())
         )
 
-    @cached_property
-    def hook(self) -> EksHook:
-        return EksHook(
-            aws_conn_id=self.aws_conn_id,
-            region_name=self.region,
-        )
-
     def poke(self, context: Context) -> bool:
         state = self.get_state()
         self.log.info("Current state: %s", state)
@@ -130,16 +123,17 @@ class EksClusterStateSensor(EksBaseSensor):
 
     :param cluster_name: The name of the Cluster to watch. (templated)
     :param target_state: Target state of the Cluster. (templated)
-    :param region: Which AWS region the connection should use. (templated)
-        If this is None or empty then the default boto3 behaviour is used.
-    :param aws_conn_id: The Airflow connection used for AWS credentials. (templated)
-         If this is None or empty then the default boto3 behaviour is used. If
-         running Airflow in a distributed manner and aws_conn_id is None or
-         empty, then the default boto3 configuration would be used (and must be
-         maintained on each worker node).
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
+        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 region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     """
 
-    template_fields: Sequence[str] = ("cluster_name", "target_state", "aws_conn_id", "region")
+    template_fields: Sequence[str] = aws_template_fields("cluster_name", "target_state")
     ui_color = "#ff9900"
     ui_fgcolor = "#232F3E"
 
@@ -147,8 +141,16 @@ class EksClusterStateSensor(EksBaseSensor):
         self,
         *,
         target_state: ClusterStates = ClusterStates.ACTIVE,
+        region: str | None = None,
         **kwargs,
     ):
+        if region is not None:
+            warnings.warn(
+                message="Parameter `region` is deprecated. Use the parameter `region_name` instead",
+                category=AirflowProviderDeprecationWarning,
+                stacklevel=2,
+            )
+            kwargs["region_name"] = region
         super().__init__(target_state=target_state, target_state_type=ClusterStates, **kwargs)
 
     def get_state(self) -> ClusterStates:
@@ -169,21 +171,18 @@ class EksFargateProfileStateSensor(EksBaseSensor):
     :param cluster_name: The name of the Cluster which the AWS Fargate profile is attached to. (templated)
     :param fargate_profile_name: The name of the Fargate profile to watch. (templated)
     :param target_state: Target state of the Fargate profile. (templated)
-    :param region: Which AWS region the connection should use. (templated)
-        If this is None or empty then the default boto3 behaviour is used.
-    :param aws_conn_id: The Airflow connection used for AWS credentials. (templated)
-         If this is None or empty then the default boto3 behaviour is used. If
-         running Airflow in a distributed manner and aws_conn_id is None or
-         empty, then the default boto3 configuration would be used (and must be
-         maintained on each worker node).
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
+        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 region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     """
 
-    template_fields: Sequence[str] = (
-        "cluster_name",
-        "fargate_profile_name",
-        "target_state",
-        "aws_conn_id",
-        "region",
+    template_fields: Sequence[str] = aws_template_fields(
+        "cluster_name", "fargate_profile_name", "target_state"
     )
     ui_color = "#ff9900"
     ui_fgcolor = "#232F3E"
@@ -192,9 +191,17 @@ class EksFargateProfileStateSensor(EksBaseSensor):
         self,
         *,
         fargate_profile_name: str,
+        region: str | None = None,
         target_state: FargateProfileStates = FargateProfileStates.ACTIVE,
         **kwargs,
     ):
+        if region is not None:
+            warnings.warn(
+                message="Parameter `region` is deprecated. Use the parameter `region_name` instead",
+                category=AirflowProviderDeprecationWarning,
+                stacklevel=2,
+            )
+            kwargs["region_name"] = region
         super().__init__(target_state=target_state, target_state_type=FargateProfileStates, **kwargs)
         self.fargate_profile_name = fargate_profile_name
 
@@ -218,22 +225,17 @@ class EksNodegroupStateSensor(EksBaseSensor):
     :param cluster_name: The name of the Cluster which the Nodegroup is attached to. (templated)
     :param nodegroup_name: The name of the Nodegroup to watch. (templated)
     :param target_state: Target state of the Nodegroup. (templated)
-    :param region: Which AWS region the connection should use. (templated)
-        If this is None or empty then the default boto3 behaviour is used.
-    :param aws_conn_id: The Airflow connection used for AWS credentials. (templated)
-         If this is None or empty then the default boto3 behaviour is used. If
-         running Airflow in a distributed manner and aws_conn_id is None or
-         empty, then the default boto3 configuration would be used (and must be
-         maintained on each worker node).
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
+        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 region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     """
 
-    template_fields: Sequence[str] = (
-        "cluster_name",
-        "nodegroup_name",
-        "target_state",
-        "aws_conn_id",
-        "region",
-    )
+    template_fields: Sequence[str] = aws_template_fields("cluster_name", "nodegroup_name", "target_state")
     ui_color = "#ff9900"
     ui_fgcolor = "#232F3E"
 
@@ -242,8 +244,16 @@ class EksNodegroupStateSensor(EksBaseSensor):
         *,
         nodegroup_name: str,
         target_state: NodegroupStates = NodegroupStates.ACTIVE,
+        region: str | None = None,
         **kwargs,
     ):
+        if region is not None:
+            warnings.warn(
+                message="Parameter `region` is deprecated. Use the parameter `region_name` instead",
+                category=AirflowProviderDeprecationWarning,
+                stacklevel=2,
+            )
+            kwargs["region_name"] = region
         super().__init__(target_state=target_state, target_state_type=NodegroupStates, **kwargs)
         self.nodegroup_name = nodegroup_name
 

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

@@ -89,11 +89,10 @@ class GlacierJobOperationSensor(AwsBaseSensor[GlacierHook]):
             self.log.info("Job status: %s, code status: %s", response["Action"], response["StatusCode"])
             self.log.info("Job finished successfully")
             return True
-        elif response["StatusCode"] == JobStatus.IN_PROGRESS.value:
+        if response["StatusCode"] == JobStatus.IN_PROGRESS.value:
             self.log.info("Processing...")
             self.log.warning("Code status: %s", response["StatusCode"])
             return False
-        else:
-            raise AirflowException(
-                f"Sensor failed. Job status: {response['Action']}, code status: {response['StatusCode']}"
-            )
+        raise AirflowException(
+            f"Sensor failed. Job status: {response['Action']}, code status: {response['StatusCode']}"
+        )