class_docstr: Resume a paused AWS Redshift Cluster.
  
  .. seealso::
      For more information on how to use this operator, take a look at the guide:
      :ref:`howto/operator:RedshiftResumeClusterOperator`
  
  :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``
  :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
      `resumed` state. Default is False.
  :param deferrable: If True, the operator will run as a deferrable operator.
code: 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
              )
              break
          except (
              redshift_hook.get_conn().exceptions.InvalidClusterStateFault
          ) as error:
              self._remaining_attempts -= 1
  
              if self._remaining_attempts:
                  self.log.error(
                      "Unable to resume cluster. %d attempts remaining.",
                      self._remaining_attempts,
                  )
                  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 == "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
                  ),
              )
  
      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,
              },
          )
  
imports: from __future__ import annotations
  import time
  from datetime import timedelta
  from typing import TYPE_CHECKING, Any, Sequence
  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.triggers.redshift_cluster import RedshiftCreateClusterSnapshotTrigger, RedshiftCreateClusterTrigger, RedshiftDeleteClusterTrigger, RedshiftPauseClusterTrigger, RedshiftResumeClusterTrigger
label_desc: Use image node_id 2 for calling the RedshiftResumeClusterOperator obj's underlying member method code with example usage: obj.execute(context) without return types