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

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

@@ -20,14 +20,12 @@ from __future__ import annotations
 import os
 import urllib.parse
 from collections.abc import Sequence
-from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from botocore.exceptions import ClientError
 
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException
-from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.glue import GlueDataQualityHook, GlueJobHook
 from airflow.providers.amazon.aws.hooks.s3 import S3Hook
 from airflow.providers.amazon.aws.links.glue import GlueJobRunDetailsLink
@@ -38,12 +36,13 @@ from airflow.providers.amazon.aws.triggers.glue import (
     GlueJobCompleteTrigger,
 )
 from airflow.providers.amazon.aws.utils import validate_execute_complete_event
+from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
 
-class GlueJobOperator(BaseOperator):
+class GlueJobOperator(AwsBaseOperator[GlueJobHook]):
     """
     Create an AWS Glue Job.
 
@@ -82,7 +81,8 @@ class GlueJobOperator(BaseOperator):
         For more information see: https://repost.aws/questions/QUaKgpLBMPSGWO0iq2Fob_bw/glue-run-concurrent-jobs#ANFpCL2fRnQRqgDFuIU_rpvA
     """
 
-    template_fields: Sequence[str] = (
+    aws_hook_class = GlueJobHook
+    template_fields: Sequence[str] = aws_template_fields(
         "job_name",
         "script_location",
         "script_args",
@@ -112,8 +112,6 @@ class GlueJobOperator(BaseOperator):
         script_args: dict | None = None,
         retry_limit: int = 0,
         num_of_dpus: int | float | None = None,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         s3_bucket: str | None = None,
         iam_role_name: str | None = None,
         iam_role_arn: str | None = None,
@@ -137,8 +135,6 @@ class GlueJobOperator(BaseOperator):
         self.script_args = script_args or {}
         self.retry_limit = retry_limit
         self.num_of_dpus = num_of_dpus
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.s3_bucket = s3_bucket
         self.iam_role_name = iam_role_name
         self.iam_role_arn = iam_role_arn
@@ -155,39 +151,49 @@ class GlueJobOperator(BaseOperator):
         self.stop_job_run_on_kill = stop_job_run_on_kill
         self._job_run_id: str | None = None
         self.sleep_before_return: int = sleep_before_return
+        self.s3_script_location: str | None = None
 
-    @cached_property
-    def glue_job_hook(self) -> GlueJobHook:
+    @property
+    def _hook_parameters(self):
+        # Upload script to S3 before creating the hook.
         if self.script_location is None:
-            s3_script_location = None
-        elif not self.script_location.startswith(self.s3_protocol):
-            s3_hook = S3Hook(aws_conn_id=self.aws_conn_id)
-            script_name = os.path.basename(self.script_location)
-            s3_hook.load_file(
-                self.script_location,
-                self.s3_artifacts_prefix + script_name,
-                bucket_name=self.s3_bucket,
-                replace=self.replace_script_file,
-            )
-            s3_script_location = f"s3://{self.s3_bucket}/{self.s3_artifacts_prefix}{script_name}"
-        else:
-            s3_script_location = self.script_location
-        return GlueJobHook(
-            job_name=self.job_name,
-            desc=self.job_desc,
-            concurrent_run_limit=self.concurrent_run_limit,
-            script_location=s3_script_location,
-            retry_limit=self.retry_limit,
-            num_of_dpus=self.num_of_dpus,
-            aws_conn_id=self.aws_conn_id,
-            region_name=self.region_name,
-            s3_bucket=self.s3_bucket,
-            iam_role_name=self.iam_role_name,
-            iam_role_arn=self.iam_role_arn,
-            create_job_kwargs=self.create_job_kwargs,
-            update_config=self.update_config,
-            job_poll_interval=self.job_poll_interval,
+            self.s3_script_location = None
+        # location provided, but it's not in S3 yet.
+        elif self.script_location and self.s3_script_location is None:
+            if not self.script_location.startswith(self.s3_protocol):
+                self.upload_etl_script_to_s3()
+            else:
+                self.s3_script_location = self.script_location
+
+        return {
+            **super()._hook_parameters,
+            "job_name": self.job_name,
+            "desc": self.job_desc,
+            "concurrent_run_limit": self.concurrent_run_limit,
+            "script_location": self.s3_script_location,
+            "retry_limit": self.retry_limit,
+            "num_of_dpus": self.num_of_dpus,
+            "aws_conn_id": self.aws_conn_id,
+            "region_name": self.region_name,
+            "s3_bucket": self.s3_bucket,
+            "iam_role_name": self.iam_role_name,
+            "iam_role_arn": self.iam_role_arn,
+            "create_job_kwargs": self.create_job_kwargs,
+            "update_config": self.update_config,
+            "job_poll_interval": self.job_poll_interval,
+        }
+
+    def upload_etl_script_to_s3(self):
+        """Upload the ETL script to S3."""
+        s3_hook = S3Hook(aws_conn_id=self.aws_conn_id)
+        script_name = os.path.basename(self.script_location)
+        s3_hook.load_file(
+            self.script_location,
+            self.s3_artifacts_prefix + script_name,
+            bucket_name=self.s3_bucket,
+            replace=self.replace_script_file,
         )
+        self.s3_script_location = f"s3://{self.s3_bucket}/{self.s3_artifacts_prefix}{script_name}"
 
     def execute(self, context: Context):
         """
@@ -200,19 +206,19 @@ class GlueJobOperator(BaseOperator):
             self.job_name,
             self.wait_for_completion,
         )
-        glue_job_run = self.glue_job_hook.initialize_job(self.script_args, self.run_job_kwargs)
+        glue_job_run = self.hook.initialize_job(self.script_args, self.run_job_kwargs)
         self._job_run_id = glue_job_run["JobRunId"]
         glue_job_run_url = GlueJobRunDetailsLink.format_str.format(
-            aws_domain=GlueJobRunDetailsLink.get_aws_domain(self.glue_job_hook.conn_partition),
-            region_name=self.glue_job_hook.conn_region_name,
+            aws_domain=GlueJobRunDetailsLink.get_aws_domain(self.hook.conn_partition),
+            region_name=self.hook.conn_region_name,
             job_name=urllib.parse.quote(self.job_name, safe=""),
             job_run_id=self._job_run_id,
         )
         GlueJobRunDetailsLink.persist(
             context=context,
             operator=self,
-            region_name=self.glue_job_hook.conn_region_name,
-            aws_partition=self.glue_job_hook.conn_partition,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
             job_name=urllib.parse.quote(self.job_name, safe=""),
             job_run_id=self._job_run_id,
         )
@@ -230,7 +236,7 @@ class GlueJobOperator(BaseOperator):
                 method_name="execute_complete",
             )
         elif self.wait_for_completion:
-            glue_job_run = self.glue_job_hook.job_completion(
+            glue_job_run = self.hook.job_completion(
                 self.job_name, self._job_run_id, self.verbose, self.sleep_before_return
             )
             self.log.info(
@@ -254,7 +260,7 @@ class GlueJobOperator(BaseOperator):
         """Cancel the running AWS Glue Job."""
         if self.stop_job_run_on_kill:
             self.log.info("Stopping AWS Glue Job: %s. Run Id: %s", self.job_name, self._job_run_id)
-            response = self.glue_job_hook.conn.batch_stop_job_run(
+            response = self.hook.conn.batch_stop_job_run(
                 JobName=self.job_name,
                 JobRunIds=[self._job_run_id],
             )
@@ -290,7 +296,9 @@ class GlueDataQualityOperator(AwsBaseOperator[GlueDataQualityHook]):
     """
 
     aws_hook_class = GlueDataQualityHook
-    template_fields: Sequence[str] = ("name", "ruleset", "description", "data_quality_ruleset_kwargs")
+    template_fields: Sequence[str] = aws_template_fields(
+        "name", "ruleset", "description", "data_quality_ruleset_kwargs"
+    )
 
     template_fields_renderers = {
         "data_quality_ruleset_kwargs": "json",
@@ -387,7 +395,7 @@ class GlueDataQualityRuleSetEvaluationRunOperator(AwsBaseOperator[GlueDataQualit
 
     aws_hook_class = GlueDataQualityHook
 
-    template_fields: Sequence[str] = (
+    template_fields: Sequence[str] = aws_template_fields(
         "datasource",
         "role",
         "rule_set_names",
@@ -553,7 +561,7 @@ class GlueDataQualityRuleRecommendationRunOperator(AwsBaseOperator[GlueDataQuali
     """
 
     aws_hook_class = GlueDataQualityHook
-    template_fields: Sequence[str] = (
+    template_fields: Sequence[str] = aws_template_fields(
         "datasource",
         "role",
         "recommendation_run_kwargs",

airflow/providers/amazon/aws/queues/__init__.py

@@ -0,0 +1,16 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.

airflow/providers/amazon/aws/queues/sqs.py

@@ -0,0 +1,52 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from airflow.exceptions import AirflowOptionalProviderFeatureException
+from airflow.providers.amazon.aws.triggers.sqs import SqsSensorTrigger
+
+try:
+    from airflow.providers.common.messaging.providers.base_provider import BaseMessageQueueProvider
+except ImportError:
+    raise AirflowOptionalProviderFeatureException(
+        "This feature requires the 'common.messaging' provider to be installed in version >= 1.0.1."
+    )
+
+if TYPE_CHECKING:
+    from airflow.triggers.base import BaseEventTrigger
+
+# [START queue_regexp]
+QUEUE_REGEXP = r"^https://sqs\.[^.]+\.amazonaws\.com/[0-9]+/.+"
+# [END queue_regexp]
+
+
+class SqsMessageQueueProvider(BaseMessageQueueProvider):
+    """Configuration for SQS integration with common-messaging."""
+
+    def queue_matches(self, queue: str) -> bool:
+        return bool(re.match(QUEUE_REGEXP, queue))
+
+    def trigger_class(self) -> type[BaseEventTrigger]:
+        return SqsSensorTrigger
+
+    def trigger_kwargs(self, queue: str, **kwargs) -> dict:
+        return {
+            "sqs_queue": queue,
+        }

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

@@ -19,7 +19,6 @@ from __future__ import annotations
 
 from collections.abc import Iterable, Sequence
 from datetime import timedelta
-from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from airflow.configuration import conf
@@ -28,19 +27,20 @@ from airflow.exceptions import (
 )
 from airflow.providers.amazon.aws.hooks.emr import EmrContainerHook, EmrHook, EmrServerlessHook
 from airflow.providers.amazon.aws.links.emr import EmrClusterLink, EmrLogsLink, get_log_uri
+from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.emr import (
     EmrContainerTrigger,
     EmrStepSensorTrigger,
     EmrTerminateJobFlowTrigger,
 )
 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 EmrBaseSensor(BaseSensorOperator):
+class EmrBaseSensor(AwsBaseSensor[EmrHook]):
     """
     Contains general sensor behavior for EMR.
 
@@ -52,24 +52,23 @@ class EmrBaseSensor(BaseSensorOperator):
     Subclasses should set ``target_states`` and ``failed_states`` fields.
 
     :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 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.h
     """
 
+    aws_hook_class = EmrHook
     ui_color = "#66c3ff"
 
-    def __init__(self, *, aws_conn_id: str | None = "aws_default", **kwargs):
+    def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.aws_conn_id = aws_conn_id
         self.target_states: Iterable[str] = []  # will be set in subclasses
         self.failed_states: Iterable[str] = []  # will be set in subclasses
 
-    @cached_property
-    def hook(self) -> EmrHook:
-        return EmrHook(aws_conn_id=self.aws_conn_id)
-
     def poke(self, context: Context):
         response = self.get_emr_response(context=context)
 
@@ -117,7 +116,7 @@ class EmrBaseSensor(BaseSensorOperator):
         raise NotImplementedError("Please implement failure_message_from_response() in subclass")
 
 
-class EmrServerlessJobSensor(BaseSensorOperator):
+class EmrServerlessJobSensor(AwsBaseSensor[EmrServerlessHook]):
     """
     Poll the state of the job run until it reaches a terminal state; fails if the job run fails.
 
@@ -128,14 +127,18 @@ class EmrServerlessJobSensor(BaseSensorOperator):
     :param application_id: application_id to check the state of
     :param job_run_id: job_run_id to check the state of
     :param target_states: a set of states to wait for, defaults to 'SUCCESS'
-    :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.h
     """
 
-    template_fields: Sequence[str] = (
+    aws_hook_class = EmrServerlessHook
+    template_fields: Sequence[str] = aws_template_fields(
         "application_id",
         "job_run_id",
     )
@@ -146,10 +149,8 @@ class EmrServerlessJobSensor(BaseSensorOperator):
         application_id: str,
         job_run_id: str,
         target_states: set | frozenset = frozenset(EmrServerlessHook.JOB_SUCCESS_STATES),
-        aws_conn_id: str | None = "aws_default",
         **kwargs: Any,
     ) -> None:
-        self.aws_conn_id = aws_conn_id
         self.target_states = target_states
         self.application_id = application_id
         self.job_run_id = job_run_id
@@ -167,11 +168,6 @@ class EmrServerlessJobSensor(BaseSensorOperator):
 
         return state in self.target_states
 
-    @cached_property
-    def hook(self) -> EmrServerlessHook:
-        """Create and return an EmrServerlessHook."""
-        return EmrServerlessHook(aws_conn_id=self.aws_conn_id)
-
     @staticmethod
     def failure_message_from_response(response: dict[str, Any]) -> str | None:
         """
@@ -183,7 +179,7 @@ class EmrServerlessJobSensor(BaseSensorOperator):
         return response["jobRun"]["stateDetails"]
 
 
-class EmrServerlessApplicationSensor(BaseSensorOperator):
+class EmrServerlessApplicationSensor(AwsBaseSensor[EmrServerlessHook]):
     """
     Poll the state of the application until it reaches a terminal state; fails if the application fails.
 
@@ -193,24 +189,28 @@ class EmrServerlessApplicationSensor(BaseSensorOperator):
 
     :param application_id: application_id to check the state of
     :param target_states: a set of states to wait for, defaults to {'CREATED', 'STARTED'}
-    :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.h
     """
 
-    template_fields: Sequence[str] = ("application_id",)
+    aws_hook_class = EmrServerlessHook
+    template_fields: Sequence[str] = aws_template_fields(
+        "application_id",
+    )
 
     def __init__(
         self,
         *,
         application_id: str,
         target_states: set | frozenset = frozenset(EmrServerlessHook.APPLICATION_SUCCESS_STATES),
-        aws_conn_id: str | None = "aws_default",
         **kwargs: Any,
     ) -> None:
-        self.aws_conn_id = aws_conn_id
         self.target_states = target_states
         self.application_id = application_id
         super().__init__(**kwargs)
@@ -227,11 +227,6 @@ class EmrServerlessApplicationSensor(BaseSensorOperator):
 
         return state in self.target_states
 
-    @cached_property
-    def hook(self) -> EmrServerlessHook:
-        """Create and return an EmrServerlessHook."""
-        return EmrServerlessHook(aws_conn_id=self.aws_conn_id)
-
     @staticmethod
     def failure_message_from_response(response: dict[str, Any]) -> str | None:
         """
@@ -243,7 +238,7 @@ class EmrServerlessApplicationSensor(BaseSensorOperator):
         return response["application"]["stateDetails"]
 
 
-class EmrContainerSensor(BaseSensorOperator):
+class EmrContainerSensor(AwsBaseSensor[EmrContainerHook]):
     """
     Poll the state of the job run until it reaches a terminal state; fail if the job run fails.
 
@@ -254,11 +249,14 @@ class EmrContainerSensor(BaseSensorOperator):
     :param job_id: job_id to check the state of
     :param max_retries: Number of times to poll for query state before
         returning the current state, defaults to None
-    :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.h
     :param poll_interval: Time in seconds to wait between two consecutive call to
         check query status on athena, defaults to 10
     :param deferrable: Run sensor in the deferrable mode.
@@ -276,7 +274,8 @@ class EmrContainerSensor(BaseSensorOperator):
     )
     SUCCESS_STATES = ("COMPLETED",)
 
-    template_fields: Sequence[str] = ("virtual_cluster_id", "job_id")
+    aws_hook_class = EmrContainerHook
+    template_fields: Sequence[str] = aws_template_fields("virtual_cluster_id", "job_id")
     template_ext: Sequence[str] = ()
     ui_color = "#66c3ff"
 
@@ -286,22 +285,20 @@ class EmrContainerSensor(BaseSensorOperator):
         virtual_cluster_id: str,
         job_id: str,
         max_retries: int | None = None,
-        aws_conn_id: str | None = "aws_default",
         poll_interval: int = 10,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
-        self.aws_conn_id = aws_conn_id
         self.virtual_cluster_id = virtual_cluster_id
         self.job_id = job_id
         self.poll_interval = poll_interval
         self.max_retries = max_retries
         self.deferrable = deferrable
 
-    @cached_property
-    def hook(self) -> EmrContainerHook:
-        return EmrContainerHook(self.aws_conn_id, virtual_cluster_id=self.virtual_cluster_id)
+    @property
+    def _hook_parameters(self):
+        return {**super()._hook_parameters, "virtual_cluster_id": self.virtual_cluster_id}
 
     def poke(self, context: Context) -> bool:
         state = self.hook.poll_query_status(
@@ -369,7 +366,9 @@ class EmrNotebookExecutionSensor(EmrBaseSensor):
         Default failed_states is ``FAILED``.
     """
 
-    template_fields: Sequence[str] = ("notebook_execution_id",)
+    template_fields: Sequence[str] = aws_template_fields(
+        "notebook_execution_id",
+    )
 
     FAILURE_STATES = {"FAILED"}
     COMPLETED_STATES = {"FINISHED"}
@@ -387,10 +386,9 @@ class EmrNotebookExecutionSensor(EmrBaseSensor):
         self.failed_states = failed_states or self.FAILURE_STATES
 
     def get_emr_response(self, context: Context) -> dict[str, Any]:
-        emr_client = self.hook.conn
         self.log.info("Poking notebook %s", self.notebook_execution_id)
 
-        return emr_client.describe_notebook_execution(NotebookExecutionId=self.notebook_execution_id)
+        return self.hook.conn.describe_notebook_execution(NotebookExecutionId=self.notebook_execution_id)
 
     @staticmethod
     def state_from_response(response: dict[str, Any]) -> str:
@@ -438,7 +436,7 @@ class EmrJobFlowSensor(EmrBaseSensor):
     :param deferrable: Run sensor in the deferrable mode.
     """
 
-    template_fields: Sequence[str] = ("job_flow_id", "target_states", "failed_states")
+    template_fields: Sequence[str] = aws_template_fields("job_flow_id", "target_states", "failed_states")
     template_ext: Sequence[str] = ()
     operator_extra_links = (
         EmrClusterLink(),
@@ -471,9 +469,8 @@ class EmrJobFlowSensor(EmrBaseSensor):
 
         :return: response
         """
-        emr_client = self.hook.conn
         self.log.info("Poking cluster %s", self.job_flow_id)
-        response = emr_client.describe_cluster(ClusterId=self.job_flow_id)
+        response = self.hook.conn.describe_cluster(ClusterId=self.job_flow_id)
 
         EmrClusterLink.persist(
             context=context,
@@ -563,7 +560,9 @@ class EmrStepSensor(EmrBaseSensor):
     :param deferrable: Run sensor in the deferrable mode.
     """
 
-    template_fields: Sequence[str] = ("job_flow_id", "step_id", "target_states", "failed_states")
+    template_fields: Sequence[str] = aws_template_fields(
+        "job_flow_id", "step_id", "target_states", "failed_states"
+    )
     template_ext: Sequence[str] = ()
     operator_extra_links = (
         EmrClusterLink(),
@@ -598,10 +597,8 @@ class EmrStepSensor(EmrBaseSensor):
 
         :return: response
         """
-        emr_client = self.hook.conn
-
         self.log.info("Poking step %s on cluster %s", self.step_id, self.job_flow_id)
-        response = emr_client.describe_step(ClusterId=self.job_flow_id, StepId=self.step_id)
+        response = self.hook.conn.describe_step(ClusterId=self.job_flow_id, StepId=self.step_id)
 
         EmrClusterLink.persist(
             context=context,
@@ -616,7 +613,7 @@ class EmrStepSensor(EmrBaseSensor):
             region_name=self.hook.conn_region_name,
             aws_partition=self.hook.conn_partition,
             job_flow_id=self.job_flow_id,
-            log_uri=get_log_uri(emr_client=emr_client, job_flow_id=self.job_flow_id),
+            log_uri=get_log_uri(emr_client=self.hook.conn, job_flow_id=self.job_flow_id),
         )
 
         return response

airflow/providers/amazon/get_provider_info.py

@@ -1258,13 +1258,6 @@ def get_provider_info():
             "aws_auth_manager": {
                 "description": "This section only applies if you are using the AwsAuthManager. In other words, if you set\n``[core] auth_manager = airflow.providers.amazon.aws.auth_manager.aws_auth_manager.AwsAuthManager`` in\nAirflow's configuration.\n",
                 "options": {
-                    "enable": {
-                        "description": "AWS auth manager is not ready to be used. Turn on this flag to use it anyway.\nDo that at your own risk since the AWS auth manager is not in an usable state.\n",
-                        "version_added": "8.12.0",
-                        "type": "boolean",
-                        "example": "True",
-                        "default": "False",
-                    },
                     "conn_id": {
                         "description": "The Airflow connection (i.e. credentials) used by the AWS auth manager to make API calls to AWS\nIdentity Center and Amazon Verified Permissions.\n",
                         "version_added": "8.12.0",
@@ -1297,4 +1290,6 @@ def get_provider_info():
             },
         },
         "executors": ["airflow.providers.amazon.aws.executors.ecs.ecs_executor.AwsEcsExecutor"],
+        "auth-managers": ["airflow.providers.amazon.aws.auth_manager.aws_auth_manager.AwsAuthManager"],
+        "queues": ["airflow.providers.amazon.aws.queues.sqs.SqsMessageQueueProvider"],
     }

airflow/providers/amazon/version_compat.py

@@ -32,5 +32,4 @@ def get_base_airflow_version_tuple() -> tuple[int, int, int]:
     return airflow_version.major, airflow_version.minor, airflow_version.micro
 
 
-AIRFLOW_V_2_10_PLUS = get_base_airflow_version_tuple() >= (2, 10, 0)
 AIRFLOW_V_3_0_PLUS = get_base_airflow_version_tuple() >= (3, 0, 0)