apache-airflow-providers-amazon 9.8.0rc1__py3-none-any.whl → 9.9.0rc1__py3-none-any.whl

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

@@ -23,8 +23,8 @@ from typing import TYPE_CHECKING, Any
 
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException
-from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.redshift_cluster import RedshiftHook
+from airflow.providers.amazon.aws.operators.base_aws import AwsBaseOperator
 from airflow.providers.amazon.aws.triggers.redshift_cluster import (
     RedshiftCreateClusterSnapshotTrigger,
     RedshiftCreateClusterTrigger,
@@ -33,13 +33,14 @@ from airflow.providers.amazon.aws.triggers.redshift_cluster import (
     RedshiftResumeClusterTrigger,
 )
 from airflow.providers.amazon.aws.utils import validate_execute_complete_event
+from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 from airflow.utils.helpers import prune_dict
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
 
-class RedshiftCreateClusterOperator(BaseOperator):
+class RedshiftCreateClusterOperator(AwsBaseOperator[RedshiftHook]):
     """
     Creates a new cluster with the specified parameters.
 
@@ -95,15 +96,21 @@ class RedshiftCreateClusterOperator(BaseOperator):
         between Availability Zones after the cluster is created.
     :param aqua_configuration_status: The cluster is configured to use AQUA .
     :param default_iam_role_arn: ARN for the IAM role.
-    :param aws_conn_id: str | None = The Airflow connection used for AWS credentials.
-        The default connection id is ``aws_default``.
+    :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 wait_for_completion: Whether wait for the cluster to be in ``available`` state
     :param max_attempt: The maximum number of attempts to be made. Default: 5
     :param poll_interval: The amount of time in seconds to wait between attempts. Default: 60
     :param deferrable: If True, the operator will run in deferrable mode
     """
 
-    template_fields: Sequence[str] = (
+    template_fields: Sequence[str] = aws_template_fields(
         "cluster_identifier",
         "cluster_type",
         "node_type",
@@ -141,6 +148,7 @@ class RedshiftCreateClusterOperator(BaseOperator):
     )
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
+    aws_hook_class = RedshiftHook
 
     def __init__(
         self,
@@ -178,7 +186,6 @@ class RedshiftCreateClusterOperator(BaseOperator):
         availability_zone_relocation: bool | None = None,
         aqua_configuration_status: str | None = None,
         default_iam_role_arn: str | None = None,
-        aws_conn_id: str | None = "aws_default",
         wait_for_completion: bool = False,
         max_attempt: int = 5,
         poll_interval: int = 60,
@@ -219,7 +226,6 @@ class RedshiftCreateClusterOperator(BaseOperator):
         self.availability_zone_relocation = availability_zone_relocation
         self.aqua_configuration_status = aqua_configuration_status
         self.default_iam_role_arn = default_iam_role_arn
-        self.aws_conn_id = aws_conn_id
         self.wait_for_completion = wait_for_completion
         self.max_attempt = max_attempt
         self.poll_interval = poll_interval
@@ -227,7 +233,6 @@ class RedshiftCreateClusterOperator(BaseOperator):
         self.kwargs = kwargs
 
     def execute(self, context: Context):
-        redshift_hook = RedshiftHook(aws_conn_id=self.aws_conn_id)
         self.log.info("Creating Redshift cluster %s", self.cluster_identifier)
         params: dict[str, Any] = {}
         if self.db_name:
@@ -291,7 +296,7 @@ class RedshiftCreateClusterOperator(BaseOperator):
         # of its value
         params["PubliclyAccessible"] = self.publicly_accessible
 
-        cluster = redshift_hook.create_cluster(
+        cluster = self.hook.create_cluster(
             self.cluster_identifier,
             self.node_type,
             self.master_username,
@@ -309,7 +314,7 @@ class RedshiftCreateClusterOperator(BaseOperator):
                 method_name="execute_complete",
             )
         if self.wait_for_completion:
-            redshift_hook.get_conn().get_waiter("cluster_available").wait(
+            self.hook.get_conn().get_waiter("cluster_available").wait(
                 ClusterIdentifier=self.cluster_identifier,
                 WaiterConfig={
                     "Delay": self.poll_interval,
@@ -327,7 +332,7 @@ class RedshiftCreateClusterOperator(BaseOperator):
             raise AirflowException(f"Error creating cluster: {validated_event}")
 
 
-class RedshiftCreateClusterSnapshotOperator(BaseOperator):
+class RedshiftCreateClusterSnapshotOperator(AwsBaseOperator[RedshiftHook]):
     """
     Creates a manual snapshot of the specified cluster. The cluster must be in the available state.
 
@@ -344,15 +349,23 @@ class RedshiftCreateClusterSnapshotOperator(BaseOperator):
     :param poll_interval: Time (in seconds) to wait between two consecutive calls to check state
     :param max_attempt: The maximum number of attempts to be made to check the state
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        The default connection id is ``aws_default``
+         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 deferrable: If True, the operator will run as a deferrable operator.
     """
 
-    template_fields: Sequence[str] = (
+    template_fields: Sequence[str] = aws_template_fields(
         "cluster_identifier",
         "snapshot_identifier",
     )
 
+    aws_hook_class = RedshiftHook
+
     def __init__(
         self,
         *,
@@ -363,7 +376,6 @@ class RedshiftCreateClusterSnapshotOperator(BaseOperator):
         wait_for_completion: bool = False,
         poll_interval: int = 15,
         max_attempt: int = 20,
-        aws_conn_id: str | None = "aws_default",
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         **kwargs,
     ):
@@ -376,18 +388,16 @@ class RedshiftCreateClusterSnapshotOperator(BaseOperator):
         self.poll_interval = poll_interval
         self.max_attempt = max_attempt
         self.deferrable = deferrable
-        self.aws_conn_id = aws_conn_id
-        self.redshift_hook = RedshiftHook(aws_conn_id=aws_conn_id)
 
     def execute(self, context: Context) -> Any:
-        cluster_state = self.redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+        cluster_state = self.hook.cluster_status(cluster_identifier=self.cluster_identifier)
         if cluster_state != "available":
             raise AirflowException(
                 "Redshift cluster must be in available state. "
                 f"Redshift cluster current state is {cluster_state}"
             )
 
-        self.redshift_hook.create_cluster_snapshot(
+        self.hook.create_cluster_snapshot(
             cluster_identifier=self.cluster_identifier,
             snapshot_identifier=self.snapshot_identifier,
             retention_period=self.retention_period,
@@ -408,7 +418,7 @@ class RedshiftCreateClusterSnapshotOperator(BaseOperator):
             )
 
         if self.wait_for_completion:
-            self.redshift_hook.get_conn().get_waiter("snapshot_available").wait(
+            self.hook.conn.get_waiter("snapshot_available").wait(
                 ClusterIdentifier=self.cluster_identifier,
                 WaiterConfig={
                     "Delay": self.poll_interval,
@@ -425,7 +435,7 @@ class RedshiftCreateClusterSnapshotOperator(BaseOperator):
         self.log.info("Cluster snapshot created.")
 
 
-class RedshiftDeleteClusterSnapshotOperator(BaseOperator):
+class RedshiftDeleteClusterSnapshotOperator(AwsBaseOperator[RedshiftHook]):
     """
     Deletes the specified manual snapshot.
 
@@ -438,11 +448,18 @@ class RedshiftDeleteClusterSnapshotOperator(BaseOperator):
     :param wait_for_completion: Whether wait for cluster deletion or not
         The default value is ``True``
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        The default connection id is ``aws_default``
+         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 poll_interval: Time (in seconds) to wait between two consecutive calls to check snapshot state
     """
 
-    template_fields: Sequence[str] = (
+    aws_hook_class = RedshiftHook
+    template_fields: Sequence[str] = aws_template_fields(
         "cluster_identifier",
         "snapshot_identifier",
     )
@@ -453,7 +470,6 @@ class RedshiftDeleteClusterSnapshotOperator(BaseOperator):
         snapshot_identifier: str,
         cluster_identifier: str,
         wait_for_completion: bool = True,
-        aws_conn_id: str | None = "aws_default",
         poll_interval: int = 10,
         **kwargs,
     ):
@@ -462,10 +478,9 @@ class RedshiftDeleteClusterSnapshotOperator(BaseOperator):
         self.cluster_identifier = cluster_identifier
         self.wait_for_completion = wait_for_completion
         self.poll_interval = poll_interval
-        self.redshift_hook = RedshiftHook(aws_conn_id=aws_conn_id)
 
     def execute(self, context: Context) -> Any:
-        self.redshift_hook.get_conn().delete_cluster_snapshot(
+        self.hook.conn.delete_cluster_snapshot(
             SnapshotClusterIdentifier=self.cluster_identifier,
             SnapshotIdentifier=self.snapshot_identifier,
         )
@@ -475,12 +490,12 @@ class RedshiftDeleteClusterSnapshotOperator(BaseOperator):
                 time.sleep(self.poll_interval)
 
     def get_status(self) -> str:
-        return self.redshift_hook.get_cluster_snapshot_status(
+        return self.hook.get_cluster_snapshot_status(
             snapshot_identifier=self.snapshot_identifier,
         )
 
 
-class RedshiftResumeClusterOperator(BaseOperator):
+class RedshiftResumeClusterOperator(AwsBaseOperator[RedshiftHook]):
     """
     Resume a paused AWS Redshift Cluster.
 
@@ -490,7 +505,13 @@ class RedshiftResumeClusterOperator(BaseOperator):
 
     :param cluster_identifier:  Unique identifier of the AWS Redshift cluster
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        The default connection id is ``aws_default``
+         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 poll_interval: Time (in seconds) to wait between two consecutive calls to check cluster state
     :param max_attempts: The maximum number of attempts to check the state of the cluster.
     :param wait_for_completion: If True, the operator will wait for the cluster to be in the
@@ -498,15 +519,17 @@ class RedshiftResumeClusterOperator(BaseOperator):
     :param deferrable: If True, the operator will run as a deferrable operator.
     """
 
-    template_fields: Sequence[str] = ("cluster_identifier",)
+    template_fields: Sequence[str] = aws_template_fields(
+        "cluster_identifier",
+    )
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
+    aws_hook_class = RedshiftHook
 
     def __init__(
         self,
         *,
         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 = 30,
@@ -515,7 +538,6 @@ class RedshiftResumeClusterOperator(BaseOperator):
     ):
         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
@@ -527,13 +549,12 @@ class RedshiftResumeClusterOperator(BaseOperator):
         self._attempt_interval = 15
 
     def execute(self, context: Context):
-        redshift_hook = RedshiftHook(aws_conn_id=self.aws_conn_id)
         self.log.info("Starting resume cluster")
         while self._remaining_attempts:
             try:
-                redshift_hook.get_conn().resume_cluster(ClusterIdentifier=self.cluster_identifier)
+                self.hook.conn.resume_cluster(ClusterIdentifier=self.cluster_identifier)
                 break
-            except redshift_hook.get_conn().exceptions.InvalidClusterStateFault as error:
+            except self.hook.conn.exceptions.InvalidClusterStateFault as error:
                 self._remaining_attempts -= 1
 
                 if self._remaining_attempts:
@@ -546,7 +567,7 @@ class RedshiftResumeClusterOperator(BaseOperator):
 
         if self.wait_for_completion:
             if self.deferrable:
-                cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+                cluster_state = self.hook.cluster_status(cluster_identifier=self.cluster_identifier)
                 if cluster_state == "available":
                     self.log.info("Resumed cluster successfully")
                 elif cluster_state == "deleting":
@@ -567,7 +588,7 @@ class RedshiftResumeClusterOperator(BaseOperator):
                         timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
                     )
             else:
-                waiter = redshift_hook.get_waiter("cluster_resumed")
+                waiter = self.hook.get_waiter("cluster_resumed")
                 waiter.wait(
                     ClusterIdentifier=self.cluster_identifier,
                     WaiterConfig={
@@ -584,7 +605,7 @@ class RedshiftResumeClusterOperator(BaseOperator):
         self.log.info("Resumed cluster successfully")
 
 
-class RedshiftPauseClusterOperator(BaseOperator):
+class RedshiftPauseClusterOperator(AwsBaseOperator[RedshiftHook]):
     """
     Pause an AWS Redshift Cluster if it has status `available`.
 
@@ -594,25 +615,30 @@ class RedshiftPauseClusterOperator(BaseOperator):
 
     :param cluster_identifier: id of the AWS Redshift Cluster
     :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).
+         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 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
     """
 
-    template_fields: Sequence[str] = ("cluster_identifier",)
+    template_fields: Sequence[str] = aws_template_fields(
+        "cluster_identifier",
+    )
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
+    aws_hook_class = RedshiftHook
 
     def __init__(
         self,
         *,
         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 = 30,
@@ -621,7 +647,6 @@ class RedshiftPauseClusterOperator(BaseOperator):
     ):
         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
@@ -633,12 +658,11 @@ class RedshiftPauseClusterOperator(BaseOperator):
         self._attempt_interval = 15
 
     def execute(self, context: Context):
-        redshift_hook = RedshiftHook(aws_conn_id=self.aws_conn_id)
         while self._remaining_attempts:
             try:
-                redshift_hook.get_conn().pause_cluster(ClusterIdentifier=self.cluster_identifier)
+                self.hook.conn.pause_cluster(ClusterIdentifier=self.cluster_identifier)
                 break
-            except redshift_hook.get_conn().exceptions.InvalidClusterStateFault as error:
+            except self.hook.conn.exceptions.InvalidClusterStateFault as error:
                 self._remaining_attempts -= 1
 
                 if self._remaining_attempts:
@@ -650,7 +674,7 @@ class RedshiftPauseClusterOperator(BaseOperator):
                     raise error
         if self.wait_for_completion:
             if self.deferrable:
-                cluster_state = redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+                cluster_state = self.hook.cluster_status(cluster_identifier=self.cluster_identifier)
                 if cluster_state == "paused":
                     self.log.info("Paused cluster successfully")
                 elif cluster_state == "deleting":
@@ -671,7 +695,7 @@ class RedshiftPauseClusterOperator(BaseOperator):
                         timeout=timedelta(seconds=self.max_attempts * self.poll_interval + 60),
                     )
             else:
-                waiter = redshift_hook.get_waiter("cluster_paused")
+                waiter = self.hook.get_waiter("cluster_paused")
                 waiter.wait(
                     ClusterIdentifier=self.cluster_identifier,
                     WaiterConfig=prune_dict(
@@ -690,7 +714,7 @@ class RedshiftPauseClusterOperator(BaseOperator):
         self.log.info("Paused cluster successfully")
 
 
-class RedshiftDeleteClusterOperator(BaseOperator):
+class RedshiftDeleteClusterOperator(AwsBaseOperator[RedshiftHook]):
     """
     Delete an AWS Redshift cluster.
 
@@ -704,18 +728,24 @@ class RedshiftDeleteClusterOperator(BaseOperator):
     :param wait_for_completion: Whether wait for cluster deletion or not
         The default value is ``True``
     :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).
+         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 poll_interval: Time (in seconds) to wait between two consecutive calls to check cluster state
     :param deferrable: Run operator in the deferrable mode.
     :param max_attempts: (Deferrable mode only) The maximum number of attempts to be made
     """
 
-    template_fields: Sequence[str] = ("cluster_identifier",)
+    template_fields: Sequence[str] = aws_template_fields(
+        "cluster_identifier",
+    )
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
+    aws_hook_class = RedshiftHook
 
     def __init__(
         self,
@@ -724,7 +754,6 @@ class RedshiftDeleteClusterOperator(BaseOperator):
         skip_final_cluster_snapshot: bool = True,
         final_cluster_snapshot_identifier: str | None = None,
         wait_for_completion: bool = True,
-        aws_conn_id: str | None = "aws_default",
         poll_interval: int = 30,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         max_attempts: int = 30,
@@ -741,25 +770,23 @@ class RedshiftDeleteClusterOperator(BaseOperator):
         # is thrown. In such case, retrying
         self._attempts = 10
         self._attempt_interval = 15
-        self.redshift_hook = RedshiftHook(aws_conn_id=aws_conn_id)
-        self.aws_conn_id = aws_conn_id
         self.deferrable = deferrable
         self.max_attempts = max_attempts
 
     def execute(self, context: Context):
         while self._attempts:
             try:
-                self.redshift_hook.delete_cluster(
+                self.hook.delete_cluster(
                     cluster_identifier=self.cluster_identifier,
                     skip_final_cluster_snapshot=self.skip_final_cluster_snapshot,
                     final_cluster_snapshot_identifier=self.final_cluster_snapshot_identifier,
                 )
                 break
-            except self.redshift_hook.conn.exceptions.InvalidClusterStateFault:
+            except self.hook.conn.exceptions.InvalidClusterStateFault:
                 self._attempts -= 1
 
                 if self._attempts:
-                    current_state = self.redshift_hook.conn.describe_clusters(
+                    current_state = self.hook.conn.describe_clusters(
                         ClusterIdentifier=self.cluster_identifier
                     )["Clusters"][0]["ClusterStatus"]
                     self.log.error(
@@ -772,7 +799,7 @@ class RedshiftDeleteClusterOperator(BaseOperator):
                     raise
 
         if self.deferrable:
-            cluster_state = self.redshift_hook.cluster_status(cluster_identifier=self.cluster_identifier)
+            cluster_state = self.hook.cluster_status(cluster_identifier=self.cluster_identifier)
             if cluster_state == "cluster_not_found":
                 self.log.info("Cluster deleted successfully")
             elif cluster_state in ("creating", "modifying"):
@@ -792,7 +819,7 @@ class RedshiftDeleteClusterOperator(BaseOperator):
                 )
 
         elif self.wait_for_completion:
-            waiter = self.redshift_hook.conn.get_waiter("cluster_deleted")
+            waiter = self.hook.conn.get_waiter("cluster_deleted")
             waiter.wait(
                 ClusterIdentifier=self.cluster_identifier,
                 WaiterConfig={"Delay": self.poll_interval, "MaxAttempts": self.max_attempts},

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

@@ -53,6 +53,10 @@ class SnsPublishOperator(AwsBaseOperator[SnsHook]):
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param botocore_config: Configuration dictionary (key-values) for botocore client. See:
         https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html
+    :param message_deduplication_id: Every message must have a unique message_deduplication_id.
+        This parameter applies only to FIFO (first-in-first-out) topics.
+    :param message_group_id: Tag that specifies that a message belongs to a specific message group.
+        This parameter applies only to FIFO (first-in-first-out) topics.
     """
 
     aws_hook_class = SnsHook
@@ -61,6 +65,8 @@ class SnsPublishOperator(AwsBaseOperator[SnsHook]):
         "message",
         "subject",
         "message_attributes",
+        "message_deduplication_id",
+        "message_group_id",
     )
     template_fields_renderers = {"message_attributes": "json"}
 
@@ -71,6 +77,8 @@ class SnsPublishOperator(AwsBaseOperator[SnsHook]):
         message: str,
         subject: str | None = None,
         message_attributes: dict | None = None,
+        message_deduplication_id: str | None = None,
+        message_group_id: str | None = None,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -78,15 +86,19 @@ class SnsPublishOperator(AwsBaseOperator[SnsHook]):
         self.message = message
         self.subject = subject
         self.message_attributes = message_attributes
+        self.message_deduplication_id = message_deduplication_id
+        self.message_group_id = message_group_id
 
     def execute(self, context: Context):
         self.log.info(
-            "Sending SNS notification to %s using %s:\nsubject=%s\nattributes=%s\nmessage=%s",
+            "Sending SNS notification to %s using %s:\nsubject=%s\nattributes=%s\nmessage=%s\nmessage_deduplication_id=%s\nmessage_group_id=%s",
             self.target_arn,
             self.aws_conn_id,
             self.subject,
             self.message_attributes,
             self.message,
+            self.message_deduplication_id,
+            self.message_group_id,
         )
 
         return self.hook.publish_to_target(
@@ -94,4 +106,6 @@ class SnsPublishOperator(AwsBaseOperator[SnsHook]):
             message=self.message,
             subject=self.subject,
             message_attributes=self.message_attributes,
+            message_deduplication_id=self.message_deduplication_id,
+            message_group_id=self.message_group_id,
         )

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

@@ -18,21 +18,21 @@ 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.redshift_cluster import RedshiftHook
+from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.redshift_cluster import RedshiftClusterTrigger
 from airflow.providers.amazon.aws.utils import validate_execute_complete_event
-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 RedshiftClusterSensor(BaseSensorOperator):
+class RedshiftClusterSensor(AwsBaseSensor[RedshiftHook]):
     """
     Waits for a Redshift cluster to reach a specific status.
 
@@ -43,23 +43,30 @@ class RedshiftClusterSensor(BaseSensorOperator):
     :param cluster_identifier: The identifier for the cluster being pinged.
     :param target_status: The cluster status desired.
     :param deferrable: Run operator in the deferrable mode.
+    :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_identifier", "target_status")
+    template_fields: Sequence[str] = aws_template_fields("cluster_identifier", "target_status")
+    aws_hook_class = RedshiftHook
 
     def __init__(
         self,
         *,
         cluster_identifier: str,
         target_status: str = "available",
-        aws_conn_id: str | None = "aws_default",
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.cluster_identifier = cluster_identifier
         self.target_status = target_status
-        self.aws_conn_id = aws_conn_id
         self.deferrable = deferrable
 
     def poke(self, context: Context) -> bool:
@@ -96,7 +103,3 @@ class RedshiftClusterSensor(BaseSensorOperator):
         if status == "success":
             self.log.info("%s completed successfully.", self.task_id)
             self.log.info("Cluster Identifier %s is in %s state", self.cluster_identifier, self.target_status)
-
-    @cached_property
-    def hook(self) -> RedshiftHook:
-        return RedshiftHook(aws_conn_id=self.aws_conn_id)