apache-airflow-providers-amazon 8.16.0__py3-none-any.whl → 8.17.0__py3-none-any.whl

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

@@ -17,19 +17,19 @@
 # under the License.
 from __future__ import annotations
 
+import warnings
 from functools import cached_property
 from typing import TYPE_CHECKING, Sequence
 
-from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
 from airflow.providers.amazon.aws.hooks.quicksight import QuickSightHook
-from airflow.providers.amazon.aws.hooks.sts import StsHook
-from airflow.sensors.base import BaseSensorOperator
+from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
 
-class QuickSightSensor(BaseSensorOperator):
+class QuickSightSensor(AwsBaseSensor[QuickSightHook]):
     """
     Watches for the status of an Amazon QuickSight Ingestion.
 
@@ -39,27 +39,25 @@ class QuickSightSensor(BaseSensorOperator):
 
     :param data_set_id:  ID of the dataset used in the ingestion.
     :param ingestion_id: ID for the ingestion.
-    :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
+    :param botocore_config: Configuration dictionary (key-values) for botocore client. See:
+        https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html
     """
 
+    aws_hook_class = QuickSightHook
     template_fields: Sequence[str] = ("data_set_id", "ingestion_id", "aws_conn_id")
 
-    def __init__(
-        self,
-        *,
-        data_set_id: str,
-        ingestion_id: str,
-        aws_conn_id: str = "aws_default",
-        **kwargs,
-    ) -> None:
+    def __init__(self, *, data_set_id: str, ingestion_id: str, **kwargs):
         super().__init__(**kwargs)
         self.data_set_id = data_set_id
         self.ingestion_id = ingestion_id
-        self.aws_conn_id = aws_conn_id
         self.success_status = "COMPLETED"
         self.errored_statuses = ("FAILED", "CANCELLED")
 
@@ -71,13 +69,10 @@ class QuickSightSensor(BaseSensorOperator):
         :return: True if it COMPLETED and False if not.
         """
         self.log.info("Poking for Amazon QuickSight Ingestion ID: %s", self.ingestion_id)
-        aws_account_id = self.sts_hook.get_account_number()
-        quicksight_ingestion_state = self.quicksight_hook.get_status(
-            aws_account_id, self.data_set_id, self.ingestion_id
-        )
+        quicksight_ingestion_state = self.hook.get_status(None, self.data_set_id, self.ingestion_id)
         self.log.info("QuickSight Status: %s", quicksight_ingestion_state)
         if quicksight_ingestion_state in self.errored_statuses:
-            error = self.quicksight_hook.get_error_info(aws_account_id, self.data_set_id, self.ingestion_id)
+            error = self.hook.get_error_info(None, self.data_set_id, self.ingestion_id)
             message = f"The QuickSight Ingestion failed. Error info: {error}"
             if self.soft_fail:
                 raise AirflowSkipException(message)
@@ -86,8 +81,23 @@ class QuickSightSensor(BaseSensorOperator):
 
     @cached_property
     def quicksight_hook(self):
-        return QuickSightHook(aws_conn_id=self.aws_conn_id)
+        warnings.warn(
+            f"`{type(self).__name__}.quicksight_hook` property is deprecated, "
+            f"please use `{type(self).__name__}.hook` property instead.",
+            AirflowProviderDeprecationWarning,
+            stacklevel=2,
+        )
+        return self.hook
 
     @cached_property
     def sts_hook(self):
+        warnings.warn(
+            f"`{type(self).__name__}.sts_hook` property is deprecated and will be removed in the future. "
+            "This property used for obtain AWS Account ID, "
+            f"please consider to use `{type(self).__name__}.hook.account_id` instead",
+            AirflowProviderDeprecationWarning,
+            stacklevel=2,
+        )
+        from airflow.providers.amazon.aws.hooks.sts import StsHook
+
         return StsHook(aws_conn_id=self.aws_conn_id)

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

@@ -16,13 +16,16 @@
 # under the License.
 from __future__ import annotations
 
+from datetime import timedelta
 from functools import cached_property
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING, Any, Sequence
 
 from deprecated import deprecated
 
-from airflow.exceptions import AirflowProviderDeprecationWarning
+from airflow.configuration import conf
+from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
 from airflow.providers.amazon.aws.hooks.redshift_cluster import RedshiftHook
+from airflow.providers.amazon.aws.triggers.redshift_cluster import RedshiftClusterTrigger
 from airflow.sensors.base import BaseSensorOperator
 
 if TYPE_CHECKING:
@@ -39,6 +42,7 @@ 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.
     """
 
     template_fields: Sequence[str] = ("cluster_identifier", "target_status")
@@ -49,14 +53,16 @@ class RedshiftClusterSensor(BaseSensorOperator):
         cluster_identifier: str,
         target_status: str = "available",
         aws_conn_id: str = "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):
+    def poke(self, context: Context) -> bool:
         current_status = self.hook.cluster_status(self.cluster_identifier)
         self.log.info(
             "Poked cluster %s for status '%s', found status '%s'",
@@ -66,6 +72,38 @@ class RedshiftClusterSensor(BaseSensorOperator):
         )
         return current_status == self.target_status
 
+    def execute(self, context: Context) -> None:
+        if not self.deferrable:
+            super().execute(context=context)
+        elif not self.poke(context):
+            self.defer(
+                timeout=timedelta(seconds=self.timeout),
+                trigger=RedshiftClusterTrigger(
+                    aws_conn_id=self.aws_conn_id,
+                    cluster_identifier=self.cluster_identifier,
+                    target_status=self.target_status,
+                    poke_interval=self.poke_interval,
+                ),
+                method_name="execute_complete",
+            )
+
+    def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
+        if event is None:
+            err_msg = "Trigger error: event is None"
+            self.log.error(err_msg)
+            raise AirflowException(err_msg)
+
+        status = event["status"]
+        if status == "error":
+            # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
+            message = f"{event['status']}: {event['message']}"
+            if self.soft_fail:
+                raise AirflowSkipException(message)
+            raise AirflowException(message)
+        elif 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)
+
     @deprecated(reason="use `hook` property instead.", category=AirflowProviderDeprecationWarning)
     def get_hook(self) -> RedshiftHook:
         """Create and return a RedshiftHook."""

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

@@ -65,7 +65,6 @@ class S3KeySensor(BaseSensorOperator):
             def check_fn(files: List) -> bool:
                 return any(f.get('Size', 0) > 1048576 for f in files)
     :param aws_conn_id: a reference to the s3 connection
-    :param deferrable: Run operator in the deferrable mode
     :param verify: Whether to verify SSL certificates for S3 connection.
         By default, SSL certificates are verified.
         You can provide the following values:
@@ -76,6 +75,8 @@ class S3KeySensor(BaseSensorOperator):
         - ``path/to/cert/bundle.pem``: A filename of the CA cert bundle to uses.
                  You can specify this argument if you want to use a different
                  CA cert bundle than the one used by botocore.
+    :param deferrable: Run operator in the deferrable mode
+    :param use_regex: whether to use regex to check bucket
     """
 
     template_fields: Sequence[str] = ("bucket_key", "bucket_name")
@@ -90,6 +91,7 @@ class S3KeySensor(BaseSensorOperator):
         aws_conn_id: str = "aws_default",
         verify: str | bool | None = None,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
+        use_regex: bool = False,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -100,6 +102,7 @@ class S3KeySensor(BaseSensorOperator):
         self.aws_conn_id = aws_conn_id
         self.verify = verify
         self.deferrable = deferrable
+        self.use_regex = use_regex
 
     def _check_key(self, key):
         bucket_name, key = S3Hook.get_s3_bucket_key(self.bucket_name, key, "bucket_name", "bucket_key")
@@ -121,6 +124,11 @@ class S3KeySensor(BaseSensorOperator):
 
             # Reduce the set of metadata to size only
             files = [{"Size": f["Size"]} for f in key_matches]
+        elif self.use_regex:
+            keys = self.hook.get_file_metadata("", bucket_name)
+            key_matches = [k for k in keys if re.match(pattern=key, string=k["Key"])]
+            if not key_matches:
+                return False
         else:
             obj = self.hook.head_object(key, bucket_name)
             if obj is None:
@@ -158,11 +166,12 @@ class S3KeySensor(BaseSensorOperator):
                 verify=self.verify,
                 poke_interval=self.poke_interval,
                 should_check_fn=bool(self.check_fn),
+                use_regex=self.use_regex,
             ),
             method_name="execute_complete",
         )
 
-    def execute_complete(self, context: Context, event: dict[str, Any]) -> bool | None:
+    def execute_complete(self, context: Context, event: dict[str, Any]) -> None:
         """
         Execute when the trigger fires - returns immediately.
 
@@ -170,17 +179,13 @@ class S3KeySensor(BaseSensorOperator):
         """
         if event["status"] == "running":
             found_keys = self.check_fn(event["files"])  # type: ignore[misc]
-            if found_keys:
-                return None
-            else:
+            if not found_keys:
                 self._defer()
-
-        if event["status"] == "error":
+        elif event["status"] == "error":
             # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
             if self.soft_fail:
                 raise AirflowSkipException(event["message"])
             raise AirflowException(event["message"])
-        return None
 
     @deprecated(reason="use `hook` property instead.", category=AirflowProviderDeprecationWarning)
     def get_hook(self) -> S3Hook:

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

@@ -16,12 +16,14 @@
 # under the License.
 from __future__ import annotations
 
+import asyncio
 import warnings
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, AsyncIterator
 
 from airflow.exceptions import AirflowProviderDeprecationWarning
-from airflow.providers.amazon.aws.hooks.redshift_cluster import RedshiftHook
+from airflow.providers.amazon.aws.hooks.redshift_cluster import RedshiftAsyncHook, RedshiftHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
+from airflow.triggers.base import BaseTrigger, TriggerEvent
 
 if TYPE_CHECKING:
     from airflow.providers.amazon.aws.hooks.base_aws import AwsGenericHook
@@ -262,3 +264,53 @@ class RedshiftDeleteClusterTrigger(AwsBaseWaiterTrigger):
 
     def hook(self) -> AwsGenericHook:
         return RedshiftHook(aws_conn_id=self.aws_conn_id)
+
+
+class RedshiftClusterTrigger(BaseTrigger):
+    """
+    RedshiftClusterTrigger is fired as deferred class with params to run the task in trigger worker.
+
+    :param aws_conn_id: Reference to AWS connection id for redshift
+    :param cluster_identifier: unique identifier of a cluster
+    :param target_status: Reference to the status which needs to be checked
+    :param poke_interval:  polling period in seconds to check for the status
+    """
+
+    def __init__(
+        self,
+        aws_conn_id: str,
+        cluster_identifier: str,
+        target_status: str,
+        poke_interval: float,
+    ):
+        super().__init__()
+        self.aws_conn_id = aws_conn_id
+        self.cluster_identifier = cluster_identifier
+        self.target_status = target_status
+        self.poke_interval = poke_interval
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serializes RedshiftClusterTrigger arguments and classpath."""
+        return (
+            "airflow.providers.amazon.aws.triggers.redshift_cluster.RedshiftClusterTrigger",
+            {
+                "aws_conn_id": self.aws_conn_id,
+                "cluster_identifier": self.cluster_identifier,
+                "target_status": self.target_status,
+                "poke_interval": self.poke_interval,
+            },
+        )
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:
+        """Simple async function run until the cluster status match the target status."""
+        try:
+            hook = RedshiftAsyncHook(aws_conn_id=self.aws_conn_id)
+            while True:
+                res = await hook.cluster_status(self.cluster_identifier)
+                if (res["status"] == "success" and res["cluster_state"] == self.target_status) or res[
+                    "status"
+                ] == "error":
+                    yield TriggerEvent(res)
+                await asyncio.sleep(self.poke_interval)
+        except Exception as e:
+            yield TriggerEvent({"status": "error", "message": str(e)})

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

@@ -0,0 +1,113 @@
+# 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 asyncio
+from functools import cached_property
+from typing import Any, AsyncIterator
+
+from airflow.providers.amazon.aws.hooks.redshift_data import (
+    ABORTED_STATE,
+    FAILED_STATE,
+    RedshiftDataHook,
+    RedshiftDataQueryAbortedError,
+    RedshiftDataQueryFailedError,
+)
+from airflow.triggers.base import BaseTrigger, TriggerEvent
+
+
+class RedshiftDataTrigger(BaseTrigger):
+    """
+    RedshiftDataTrigger is fired as deferred class with params to run the task in triggerer.
+
+    :param statement_id: the UUID of the statement
+    :param task_id: task ID of the Dag
+    :param poll_interval:  polling period in seconds to check for the status
+    :param aws_conn_id: AWS connection ID for redshift
+    :param region_name: aws region to use
+    """
+
+    def __init__(
+        self,
+        statement_id: str,
+        task_id: str,
+        poll_interval: int,
+        aws_conn_id: str | None = "aws_default",
+        region_name: str | None = None,
+        verify: bool | str | None = None,
+        botocore_config: dict | None = None,
+    ):
+        super().__init__()
+        self.statement_id = statement_id
+        self.task_id = task_id
+        self.poll_interval = poll_interval
+
+        self.aws_conn_id = aws_conn_id
+        self.region_name = region_name
+        self.verify = verify
+        self.botocore_config = botocore_config
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serializes RedshiftDataTrigger arguments and classpath."""
+        return (
+            "airflow.providers.amazon.aws.triggers.redshift_data.RedshiftDataTrigger",
+            {
+                "statement_id": self.statement_id,
+                "task_id": self.task_id,
+                "aws_conn_id": self.aws_conn_id,
+                "poll_interval": self.poll_interval,
+                "region_name": self.region_name,
+                "verify": self.verify,
+                "botocore_config": self.botocore_config,
+            },
+        )
+
+    @cached_property
+    def hook(self) -> RedshiftDataHook:
+        return RedshiftDataHook(
+            aws_conn_id=self.aws_conn_id,
+            region_name=self.region_name,
+            verify=self.verify,
+            config=self.botocore_config,
+        )
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:
+        try:
+            while await self.hook.is_still_running(self.statement_id):
+                await asyncio.sleep(self.poll_interval)
+
+            is_finished = await self.hook.check_query_is_finished_async(self.statement_id)
+            if is_finished:
+                response = {"status": "success", "statement_id": self.statement_id}
+            else:
+                response = {
+                    "status": "error",
+                    "statement_id": self.statement_id,
+                    "message": f"{self.task_id} failed",
+                }
+            yield TriggerEvent(response)
+        except (RedshiftDataQueryFailedError, RedshiftDataQueryAbortedError) as error:
+            response = {
+                "status": "error",
+                "statement_id": self.statement_id,
+                "message": str(error),
+                "type": FAILED_STATE if isinstance(error, RedshiftDataQueryFailedError) else ABORTED_STATE,
+            }
+            yield TriggerEvent(response)
+        except Exception as error:
+            yield TriggerEvent({"status": "error", "statement_id": self.statement_id, "message": str(error)})

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

@@ -39,6 +39,7 @@ class S3KeyTrigger(BaseTrigger):
     :param wildcard_match: whether the bucket_key should be interpreted as a
         Unix wildcard pattern
     :param aws_conn_id: reference to the s3 connection
+    :param use_regex: whether to use regex to check bucket
     :param hook_params: params for hook its optional
     """
 
@@ -50,6 +51,7 @@ class S3KeyTrigger(BaseTrigger):
         aws_conn_id: str = "aws_default",
         poke_interval: float = 5.0,
         should_check_fn: bool = False,
+        use_regex: bool = False,
         **hook_params: Any,
     ):
         super().__init__()
@@ -60,6 +62,7 @@ class S3KeyTrigger(BaseTrigger):
         self.hook_params = hook_params
         self.poke_interval = poke_interval
         self.should_check_fn = should_check_fn
+        self.use_regex = use_regex
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
         """Serialize S3KeyTrigger arguments and classpath."""
@@ -73,6 +76,7 @@ class S3KeyTrigger(BaseTrigger):
                 "hook_params": self.hook_params,
                 "poke_interval": self.poke_interval,
                 "should_check_fn": self.should_check_fn,
+                "use_regex": self.use_regex,
             },
         )
 
@@ -86,7 +90,7 @@ class S3KeyTrigger(BaseTrigger):
             async with self.hook.async_conn as client:
                 while True:
                     if await self.hook.check_key_async(
-                        client, self.bucket_name, self.bucket_key, self.wildcard_match
+                        client, self.bucket_name, self.bucket_key, self.wildcard_match, self.use_regex
                     ):
                         if self.should_check_fn:
                             s3_objects = await self.hook.get_files_async(
@@ -94,10 +98,11 @@ class S3KeyTrigger(BaseTrigger):
                             )
                             await asyncio.sleep(self.poke_interval)
                             yield TriggerEvent({"status": "running", "files": s3_objects})
-                        else:
-                            yield TriggerEvent({"status": "success"})
-                    await asyncio.sleep(self.poke_interval)
 
+                        yield TriggerEvent({"status": "success"})
+
+                    self.log.info("Sleeping for %s seconds", self.poke_interval)
+                    await asyncio.sleep(self.poke_interval)
         except Exception as e:
             yield TriggerEvent({"status": "error", "message": str(e)})
 

airflow/providers/amazon/get_provider_info.py

@@ -28,8 +28,9 @@ def get_provider_info():
         "name": "Amazon",
         "description": "Amazon integration (including `Amazon Web Services (AWS) <https://aws.amazon.com/>`__).\n",
         "state": "ready",
-        "source-date-epoch": 1704610260,
+        "source-date-epoch": 1705911803,
         "versions": [
+            "8.17.0",
             "8.16.0",
             "8.15.0",
             "8.14.0",
@@ -86,21 +87,42 @@ def get_provider_info():
             "apache-airflow>=2.6.0",
             "apache-airflow-providers-common-sql>=1.3.1",
             "apache-airflow-providers-http",
-            "boto3>=1.28.0",
-            "botocore>=1.31.0",
+            "boto3>=1.33.0",
+            "botocore>=1.33.0",
             "inflection>=0.5.1",
             "watchtower>=2.0.1,<4",
             "jsonpath_ng>=1.5.3",
-            "redshift_connector>=2.0.888",
+            "redshift_connector>=2.0.918",
             "sqlalchemy_redshift>=0.8.6",
             "asgiref",
+            "PyAthena>=3.0.10",
+        ],
+        "additional-extras": [
+            {"name": "pandas", "dependencies": ["pandas>=1.2.5"]},
+            {"name": "aiobotocore", "dependencies": ["aiobotocore[boto3]>=2.5.3"]},
+            {"name": "cncf.kubernetes", "dependencies": ["apache-airflow-providers-cncf-kubernetes>=7.2.0"]},
+            {"name": "s3fs", "dependencies": ["s3fs>=2023.10.0"]},
+            {"name": "python3-saml", "dependencies": ["python3-saml>=1.16.0"]},
+        ],
+        "devel-dependencies": [
+            "aiobotocore>=2.7.0",
+            "aws_xray_sdk>=2.12.0",
+            "moto[cloudformation,glue]>=4.2.12",
+            "mypy-boto3-appflow>=1.33.0",
+            "mypy-boto3-rds>=1.33.0",
+            "mypy-boto3-redshift-data>=1.33.0",
+            "mypy-boto3-s3>=1.33.0",
+            "s3fs>=2023.10.0",
         ],
         "integrations": [
             {
                 "integration-name": "Amazon Athena",
                 "external-doc-url": "https://aws.amazon.com/athena/",
                 "logo": "/integration-logos/aws/Amazon-Athena_light-bg@4x.png",
-                "how-to-guide": ["/docs/apache-airflow-providers-amazon/operators/athena.rst"],
+                "how-to-guide": [
+                    "/docs/apache-airflow-providers-amazon/operators/athena/athena_boto.rst",
+                    "/docs/apache-airflow-providers-amazon/operators/athena/athena_sql.rst",
+                ],
                 "tags": ["aws"],
             },
             {
@@ -564,7 +586,10 @@ def get_provider_info():
         "hooks": [
             {
                 "integration-name": "Amazon Athena",
-                "python-modules": ["airflow.providers.amazon.aws.hooks.athena"],
+                "python-modules": [
+                    "airflow.providers.amazon.aws.hooks.athena",
+                    "airflow.providers.amazon.aws.hooks.athena_sql",
+                ],
             },
             {
                 "integration-name": "Amazon Chime",
@@ -729,7 +754,10 @@ def get_provider_info():
             },
             {
                 "integration-name": "Amazon Redshift",
-                "python-modules": ["airflow.providers.amazon.aws.triggers.redshift_cluster"],
+                "python-modules": [
+                    "airflow.providers.amazon.aws.triggers.redshift_cluster",
+                    "airflow.providers.amazon.aws.triggers.redshift_data",
+                ],
             },
             {
                 "integration-name": "Amazon SageMaker",
@@ -927,6 +955,10 @@ def get_provider_info():
                 "hook-class-name": "airflow.providers.amazon.aws.hooks.redshift_sql.RedshiftSQLHook",
                 "connection-type": "redshift",
             },
+            {
+                "hook-class-name": "airflow.providers.amazon.aws.hooks.athena_sql.AthenaSQLHook",
+                "connection-type": "athena",
+            },
         ],
         "notifications": [
             "airflow.providers.amazon.aws.notifications.chime.ChimeNotifier",
@@ -941,13 +973,6 @@ def get_provider_info():
             "airflow.providers.amazon.aws.log.s3_task_handler.S3TaskHandler",
             "airflow.providers.amazon.aws.log.cloudwatch_task_handler.CloudwatchTaskHandler",
         ],
-        "additional-extras": [
-            {"name": "pandas", "dependencies": ["pandas>=0.17.1"]},
-            {"name": "aiobotocore", "dependencies": ["aiobotocore[boto3]>=2.5.3"]},
-            {"name": "cncf.kubernetes", "dependencies": ["apache-airflow-providers-cncf-kubernetes>=7.2.0"]},
-            {"name": "s3fs", "dependencies": ["s3fs>=2023.10.0"]},
-            {"name": "python3-saml", "dependencies": ["python3-saml>=1.16.0"]},
-        ],
         "config": {
             "aws": {
                 "description": "This section contains settings for Amazon Web Services (AWS) integration.",
@@ -999,6 +1024,13 @@ def get_provider_info():
                         "example": "ecs_executor_cluster",
                         "default": None,
                     },
+                    "capacity_provider_strategy": {
+                        "description": "The capacity provider strategy to use for the task.\n\nIf a Capacity Provider Strategy is specified, the Launch Type parameter must be omitted. If\nno Capacity Provider Strategy or Launch Type is specified, the Default CapacityProvider Strategy\nfor the cluster is used, if present.\n\nWhen you use cluster auto scaling, you must specify Capacity Provider Strategy and not Launch Type.\n",
+                        "version_added": "8.17",
+                        "type": "string",
+                        "example": "[{'capacityProvider': 'cp1', 'weight': 5}, {'capacityProvider': 'cp2', 'weight': 1}]",
+                        "default": None,
+                    },
                     "container_name": {
                         "description": "Name of the container that will be used to execute Airflow tasks via the ECS executor.\nThe container should be specified in the ECS Task Definition and will receive an airflow\nCLI command as an additional parameter to its entrypoint. For more info see url to Boto3\ndocs above. Required.\n",
                         "version_added": "8.10",
@@ -1007,11 +1039,11 @@ def get_provider_info():
                         "default": None,
                     },
                     "launch_type": {
-                        "description": "Launch type can either be 'FARGATE' OR 'EC2'. For more info see url to\nBoto3 docs above.\n\nIf the launch type is EC2, the executor will attempt to place tasks on\nempty EC2 instances. If there are no EC2 instances available, no task\nis placed and this function will be called again in the next heart-beat.\n\nIf the launch type is FARGATE, this will run the tasks on new AWS Fargate\ninstances.\n",
+                        "description": "Launch type can either be 'FARGATE' OR 'EC2'. For more info see url to\nBoto3 docs above.\n\nIf a Launch Type is specified, the Capacity Provider Strategy parameter must be omitted. If\nno Capacity Provider Strategy or Launch Type is specified, the Default Capacity Provider Strategy\nfor the cluster is used, if present.\n\nIf the launch type is EC2, the executor will attempt to place tasks on\nempty EC2 instances. If there are no EC2 instances available, no task\nis placed and this function will be called again in the next heart-beat.\n\nIf the launch type is FARGATE, this will run the tasks on new AWS Fargate\ninstances.\n",
                         "version_added": "8.10",
                         "type": "string",
                         "example": "FARGATE",
-                        "default": "FARGATE",
+                        "default": None,
                     },
                     "platform_version": {
                         "description": "The platform version the task uses. A platform version is only specified\nfor tasks hosted on Fargate. If one isn't specified, the LATEST platform\nversion is used.\n",
@@ -1081,6 +1113,13 @@ def get_provider_info():
                         "example": "aws_default",
                         "default": "aws_default",
                     },
+                    "region_name": {
+                        "description": "The name of the AWS Region where Amazon Verified Permissions is configured. Required.\n",
+                        "version_added": "8.10",
+                        "type": "string",
+                        "example": "us-east-1",
+                        "default": None,
+                    },
                     "saml_metadata_url": {
                         "description": "SAML metadata XML file provided by AWS Identity Center.\nThis URL can be found in the AWS Identity Center console. Required.\n",
                         "version_added": "8.12.0",