apache-airflow-providers-amazon 8.17.0rc2__py3-none-any.whl → 8.18.0rc2__py3-none-any.whl

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

@@ -32,6 +32,7 @@ from airflow.providers.amazon.aws.triggers.emr import (
     EmrStepSensorTrigger,
     EmrTerminateJobFlowTrigger,
 )
+from airflow.providers.amazon.aws.utils import validate_execute_complete_event
 from airflow.sensors.base import BaseSensorOperator
 
 if TYPE_CHECKING:
@@ -335,15 +336,17 @@ class EmrContainerSensor(BaseSensorOperator):
                 method_name="execute_complete",
             )
 
-    def execute_complete(self, context, event=None):
+    def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
+        event = validate_execute_complete_event(event)
+
         if event["status"] != "success":
             # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
             message = f"Error while running job: {event}"
             if self.soft_fail:
                 raise AirflowSkipException(message)
             raise AirflowException(message)
-        else:
-            self.log.info("Job completed.")
+
+        self.log.info("Job completed.")
 
 
 class EmrNotebookExecutionSensor(EmrBaseSensor):
@@ -526,7 +529,9 @@ class EmrJobFlowSensor(EmrBaseSensor):
                 method_name="execute_complete",
             )
 
-    def execute_complete(self, context: Context, event=None) -> None:
+    def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
+        event = validate_execute_complete_event(event)
+
         if event["status"] != "success":
             # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
             message = f"Error while running job: {event}"
@@ -657,7 +662,9 @@ class EmrStepSensor(EmrBaseSensor):
                 method_name="execute_complete",
             )
 
-    def execute_complete(self, context, event=None):
+    def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> None:
+        event = validate_execute_complete_event(event)
+
         if event["status"] != "success":
             # TODO: remove this if check when min_airflow_version is set to higher than 2.7.1
             message = f"Error while running job: {event}"
@@ -665,4 +672,4 @@ class EmrStepSensor(EmrBaseSensor):
                 raise AirflowSkipException(message)
             raise AirflowException(message)
 
-        self.log.info("Job completed.")
+        self.log.info("Job %s completed.", self.job_flow_id)

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

@@ -27,6 +27,7 @@ from airflow.configuration import conf
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
 from airflow.providers.amazon.aws.hooks.glue_catalog import GlueCatalogHook
 from airflow.providers.amazon.aws.triggers.glue import GlueCatalogPartitionTrigger
+from airflow.providers.amazon.aws.utils import validate_execute_complete_event
 from airflow.sensors.base import BaseSensorOperator
 
 if TYPE_CHECKING:
@@ -111,7 +112,9 @@ class GlueCatalogPartitionSensor(BaseSensorOperator):
         return self.hook.check_for_partition(self.database_name, self.table_name, self.expression)
 
     def execute_complete(self, context: Context, event: dict | None = None) -> None:
-        if event is None or event["status"] != "success":
+        event = validate_execute_complete_event(event)
+
+        if event["status"] != "success":
             # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
             message = f"Trigger error: event is {event}"
             if self.soft_fail:

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

@@ -17,10 +17,11 @@
 # under the License.
 from __future__ import annotations
 
-import warnings
 from functools import cached_property
 from typing import TYPE_CHECKING, Sequence
 
+from deprecated import deprecated
+
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
 from airflow.providers.amazon.aws.hooks.quicksight import QuickSightHook
 from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
@@ -80,24 +81,26 @@ class QuickSightSensor(AwsBaseSensor[QuickSightHook]):
         return quicksight_ingestion_state == self.success_status
 
     @cached_property
+    @deprecated(
+        reason=(
+            "`QuickSightSensor.quicksight_hook` property is deprecated, "
+            "please use `QuickSightSensor.hook` property instead."
+        ),
+        category=AirflowProviderDeprecationWarning,
+    )
     def quicksight_hook(self):
-        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. "
+    @deprecated(
+        reason=(
+            "`QuickSightSensor.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,
-        )
+            "please consider to use `QuickSightSensor.hook.account_id` instead"
+        ),
+        category=AirflowProviderDeprecationWarning,
+    )
+    def sts_hook(self):
         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

@@ -26,6 +26,7 @@ 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.providers.amazon.aws.utils import validate_execute_complete_event
 from airflow.sensors.base import BaseSensorOperator
 
 if TYPE_CHECKING:
@@ -88,10 +89,7 @@ class RedshiftClusterSensor(BaseSensorOperator):
             )
 
     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)
+        event = validate_execute_complete_event(event)
 
         status = event["status"]
         if status == "error":

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

@@ -27,6 +27,7 @@ from typing import TYPE_CHECKING, Any, Callable, Sequence, cast
 from deprecated import deprecated
 
 from airflow.configuration import conf
+from airflow.providers.amazon.aws.utils import validate_execute_complete_event
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -371,6 +372,8 @@ class S3KeysUnchangedSensor(BaseSensorOperator):
 
         Relies on trigger to throw an exception, otherwise it assumes execution was successful.
         """
+        event = validate_execute_complete_event(event)
+
         if event and event["status"] == "error":
             # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
             if self.soft_fail:

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

@@ -28,6 +28,7 @@ from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarni
 from airflow.providers.amazon.aws.hooks.sqs import SqsHook
 from airflow.providers.amazon.aws.sensors.base_aws import AwsBaseSensor
 from airflow.providers.amazon.aws.triggers.sqs import SqsSensorTrigger
+from airflow.providers.amazon.aws.utils import validate_execute_complete_event
 from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 from airflow.providers.amazon.aws.utils.sqs import MessageFilteringType, process_response
 
@@ -155,7 +156,9 @@ class SqsSensor(AwsBaseSensor[SqsHook]):
             super().execute(context=context)
 
     def execute_complete(self, context: Context, event: dict | None = None) -> None:
-        if event is None or event["status"] != "success":
+        event = validate_execute_complete_event(event)
+
+        if event["status"] != "success":
             # TODO: remove this if block when min_airflow_version is set to higher than 2.7.1
             message = f"Trigger error: event is {event}"
             if self.soft_fail:

airflow/providers/amazon/aws/transfers/s3_to_redshift.py

@@ -77,6 +77,7 @@ class S3ToRedshiftOperator(BaseOperator):
         "copy_options",
         "redshift_conn_id",
         "method",
+        "aws_conn_id",
     )
     template_ext: Sequence[str] = ()
     ui_color = "#99e699"

airflow/providers/amazon/aws/transfers/sql_to_s3.py

@@ -81,6 +81,9 @@ class SqlToS3Operator(BaseOperator):
                 You can specify this argument if you want to use a different
                 CA cert bundle than the one used by botocore.
     :param file_format: the destination file format, only string 'csv', 'json' or 'parquet' is accepted.
+    :param max_rows_per_file: (optional) argument to set destination file number of rows limit, if source data
+        is larger than that, it will be dispatched into multiple files.
+        Will be ignored if ``groupby_kwargs`` argument is specified.
     :param pd_kwargs: arguments to include in DataFrame ``.to_parquet()``, ``.to_json()`` or ``.to_csv()``.
     :param groupby_kwargs: argument to include in DataFrame ``groupby()``.
     """
@@ -110,6 +113,7 @@ class SqlToS3Operator(BaseOperator):
         aws_conn_id: str = "aws_default",
         verify: bool | str | None = None,
         file_format: Literal["csv", "json", "parquet"] = "csv",
+        max_rows_per_file: int = 0,
         pd_kwargs: dict | None = None,
         groupby_kwargs: dict | None = None,
         **kwargs,
@@ -124,12 +128,19 @@ class SqlToS3Operator(BaseOperator):
         self.replace = replace
         self.pd_kwargs = pd_kwargs or {}
         self.parameters = parameters
+        self.max_rows_per_file = max_rows_per_file
         self.groupby_kwargs = groupby_kwargs or {}
         self.sql_hook_params = sql_hook_params
 
         if "path_or_buf" in self.pd_kwargs:
             raise AirflowException("The argument path_or_buf is not allowed, please remove it")
 
+        if self.max_rows_per_file and self.groupby_kwargs:
+            raise AirflowException(
+                "SqlToS3Operator arguments max_rows_per_file and groupby_kwargs "
+                "can not be both specified. Please choose one."
+            )
+
         try:
             self.file_format = FILE_FORMAT[file_format.upper()]
         except KeyError:
@@ -177,10 +188,8 @@ class SqlToS3Operator(BaseOperator):
         s3_conn = S3Hook(aws_conn_id=self.aws_conn_id, verify=self.verify)
         data_df = sql_hook.get_pandas_df(sql=self.query, parameters=self.parameters)
         self.log.info("Data from SQL obtained")
-
         self._fix_dtypes(data_df, self.file_format)
         file_options = FILE_OPTIONS_MAP[self.file_format]
-
         for group_name, df in self._partition_dataframe(df=data_df):
             with NamedTemporaryFile(mode=file_options.mode, suffix=file_options.suffix) as tmp_file:
                 self.log.info("Writing data to temp file")
@@ -194,13 +203,32 @@ class SqlToS3Operator(BaseOperator):
 
     def _partition_dataframe(self, df: pd.DataFrame) -> Iterable[tuple[str, pd.DataFrame]]:
         """Partition dataframe using pandas groupby() method."""
+        try:
+            import secrets
+            import string
+
+            import numpy as np
+        except ImportError:
+            pass
+        # if max_rows_per_file argument is specified, a temporary column with a random unusual name will be
+        # added to the dataframe. This column is used to dispatch the dataframe into smaller ones using groupby()
+        random_column_name = ""
+        if self.max_rows_per_file and not self.groupby_kwargs:
+            random_column_name = "".join(secrets.choice(string.ascii_letters) for _ in range(20))
+            df[random_column_name] = np.arange(len(df)) // self.max_rows_per_file
+            self.groupby_kwargs = {"by": random_column_name}
         if not self.groupby_kwargs:
             yield "", df
             return
         for group_label in (grouped_df := df.groupby(**self.groupby_kwargs)).groups:
             yield (
                 cast(str, group_label),
-                cast("pd.DataFrame", grouped_df.get_group(group_label).reset_index(drop=True)),
+                cast(
+                    "pd.DataFrame",
+                    grouped_df.get_group(group_label)
+                    .drop(random_column_name, axis=1, errors="ignore")
+                    .reset_index(drop=True),
+                ),
             )
 
     def _get_hook(self) -> DbApiHook:

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

@@ -0,0 +1,115 @@
+# 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
+
+from typing import TYPE_CHECKING
+
+from airflow.providers.amazon.aws.hooks.neptune import NeptuneHook
+from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
+
+if TYPE_CHECKING:
+    from airflow.providers.amazon.aws.hooks.base_aws import AwsGenericHook
+
+
+class NeptuneClusterAvailableTrigger(AwsBaseWaiterTrigger):
+    """
+    Triggers when a Neptune Cluster is available.
+
+    :param db_cluster_id: Cluster ID to poll.
+    :param waiter_delay: The amount of time in seconds to wait between attempts.
+    :param waiter_max_attempts: The maximum number of attempts to be made.
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+    :param region_name: AWS region name (example: us-east-1)
+    """
+
+    def __init__(
+        self,
+        *,
+        db_cluster_id: str,
+        waiter_delay: int = 30,
+        waiter_max_attempts: int = 60,
+        aws_conn_id: str | None = None,
+        region_name: str | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            serialized_fields={"db_cluster_id": db_cluster_id},
+            waiter_name="cluster_available",
+            waiter_args={"DBClusterIdentifier": db_cluster_id},
+            failure_message="Failed to start Neptune cluster",
+            status_message="Status of Neptune cluster is",
+            status_queries=["DBClusters[0].Status"],
+            return_key="db_cluster_id",
+            return_value=db_cluster_id,
+            waiter_delay=waiter_delay,
+            waiter_max_attempts=waiter_max_attempts,
+            aws_conn_id=aws_conn_id,
+            **kwargs,
+        )
+
+    def hook(self) -> AwsGenericHook:
+        return NeptuneHook(
+            aws_conn_id=self.aws_conn_id,
+            region_name=self.region_name,
+            verify=self.verify,
+            config=self.botocore_config,
+        )
+
+
+class NeptuneClusterStoppedTrigger(AwsBaseWaiterTrigger):
+    """
+    Triggers when a Neptune Cluster is stopped.
+
+    :param db_cluster_id: Cluster ID to poll.
+    :param waiter_delay: The amount of time in seconds to wait between attempts.
+    :param waiter_max_attempts: The maximum number of attempts to be made.
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+    :param region_name: AWS region name (example: us-east-1)
+    """
+
+    def __init__(
+        self,
+        *,
+        db_cluster_id: str,
+        waiter_delay: int = 30,
+        waiter_max_attempts: int = 60,
+        aws_conn_id: str | None = None,
+        region_name: str | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            serialized_fields={"db_cluster_id": db_cluster_id},
+            waiter_name="cluster_stopped",
+            waiter_args={"DBClusterIdentifier": db_cluster_id},
+            failure_message="Failed to stop Neptune cluster",
+            status_message="Status of Neptune cluster is",
+            status_queries=["DBClusters[0].Status"],
+            return_key="db_cluster_id",
+            return_value=db_cluster_id,
+            waiter_delay=waiter_delay,
+            waiter_max_attempts=waiter_max_attempts,
+            aws_conn_id=aws_conn_id,
+            **kwargs,
+        )
+
+    def hook(self) -> AwsGenericHook:
+        return NeptuneHook(
+            aws_conn_id=self.aws_conn_id,
+            region_name=self.region_name,
+            verify=self.verify,
+            config=self.botocore_config,
+        )

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

@@ -16,10 +16,11 @@
 # under the License.
 from __future__ import annotations
 
-import warnings
 from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
+from deprecated import deprecated
+
 from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.rds import RdsHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
@@ -31,6 +32,13 @@ if TYPE_CHECKING:
     from airflow.providers.amazon.aws.hooks.base_aws import AwsGenericHook
 
 
+@deprecated(
+    reason=(
+        "This trigger is deprecated, please use the other RDS triggers "
+        "such as RdsDbDeletedTrigger, RdsDbStoppedTrigger or RdsDbAvailableTrigger"
+    ),
+    category=AirflowProviderDeprecationWarning,
+)
 class RdsDbInstanceTrigger(BaseTrigger):
     """
     Deprecated Trigger for RDS operations. Do not use.
@@ -55,12 +63,6 @@ class RdsDbInstanceTrigger(BaseTrigger):
         region_name: str | None,
         response: dict[str, Any],
     ):
-        warnings.warn(
-            "This trigger is deprecated, please use the other RDS triggers "
-            "such as RdsDbDeletedTrigger, RdsDbStoppedTrigger or RdsDbAvailableTrigger",
-            AirflowProviderDeprecationWarning,
-            stacklevel=2,
-        )
         self.db_instance_identifier = db_instance_identifier
         self.waiter_delay = waiter_delay
         self.waiter_max_attempts = waiter_max_attempts

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

@@ -290,7 +290,7 @@ class RedshiftClusterTrigger(BaseTrigger):
         self.poke_interval = poke_interval
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
-        """Serializes RedshiftClusterTrigger arguments and classpath."""
+        """Serialize RedshiftClusterTrigger arguments and classpath."""
         return (
             "airflow.providers.amazon.aws.triggers.redshift_cluster.RedshiftClusterTrigger",
             {
@@ -302,7 +302,7 @@ class RedshiftClusterTrigger(BaseTrigger):
         )
 
     async def run(self) -> AsyncIterator[TriggerEvent]:
-        """Simple async function run until the cluster status match the target status."""
+        """Run async until the cluster status matches the target status."""
         try:
             hook = RedshiftAsyncHook(aws_conn_id=self.aws_conn_id)
             while True:

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

@@ -63,7 +63,7 @@ class RedshiftDataTrigger(BaseTrigger):
         self.botocore_config = botocore_config
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
-        """Serializes RedshiftDataTrigger arguments and classpath."""
+        """Serialize RedshiftDataTrigger arguments and classpath."""
         return (
             "airflow.providers.amazon.aws.triggers.redshift_data.RedshiftDataTrigger",
             {

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

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from collections import Counter
 from enum import IntEnum
 from functools import cached_property
@@ -26,7 +27,7 @@ from typing import Any, AsyncIterator
 from botocore.exceptions import WaiterError
 
 from airflow.exceptions import AirflowException
-from airflow.providers.amazon.aws.hooks.sagemaker import SageMakerHook
+from airflow.providers.amazon.aws.hooks.sagemaker import LogState, SageMakerHook
 from airflow.providers.amazon.aws.utils.waiter_with_logging import async_wait
 from airflow.triggers.base import BaseTrigger, TriggerEvent
 
@@ -196,3 +197,83 @@ class SageMakerPipelineTrigger(BaseTrigger):
                     await asyncio.sleep(int(self.waiter_delay))
 
             raise AirflowException("Waiter error: max attempts reached")
+
+
+class SageMakerTrainingPrintLogTrigger(BaseTrigger):
+    """
+    SageMakerTrainingPrintLogTrigger is fired as deferred class with params to run the task in triggerer.
+
+    :param job_name: name of the job to check status
+    :param poke_interval:  polling period in seconds to check for the status
+    :param aws_conn_id: AWS connection ID for sagemaker
+    """
+
+    def __init__(
+        self,
+        job_name: str,
+        poke_interval: float,
+        aws_conn_id: str = "aws_default",
+    ):
+        super().__init__()
+        self.job_name = job_name
+        self.poke_interval = poke_interval
+        self.aws_conn_id = aws_conn_id
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serialize SageMakerTrainingPrintLogTrigger arguments and classpath."""
+        return (
+            "airflow.providers.amazon.aws.triggers.sagemaker.SageMakerTrainingPrintLogTrigger",
+            {
+                "poke_interval": self.poke_interval,
+                "aws_conn_id": self.aws_conn_id,
+                "job_name": self.job_name,
+            },
+        )
+
+    @cached_property
+    def hook(self) -> SageMakerHook:
+        return SageMakerHook(aws_conn_id=self.aws_conn_id)
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:
+        """Make async connection to sagemaker async hook and gets job status for a job submitted by the operator."""
+        stream_names: list[str] = []  # The list of log streams
+        positions: dict[str, Any] = {}  # The current position in each stream, map of stream name -> position
+
+        last_description = await self.hook.describe_training_job_async(self.job_name)
+        instance_count = last_description["ResourceConfig"]["InstanceCount"]
+        status = last_description["TrainingJobStatus"]
+        job_already_completed = status not in self.hook.non_terminal_states
+        state = LogState.COMPLETE if job_already_completed else LogState.TAILING
+        last_describe_job_call = time.time()
+        while True:
+            try:
+                (
+                    state,
+                    last_description,
+                    last_describe_job_call,
+                ) = await self.hook.describe_training_job_with_log_async(
+                    self.job_name,
+                    positions,
+                    stream_names,
+                    instance_count,
+                    state,
+                    last_description,
+                    last_describe_job_call,
+                )
+                status = last_description["TrainingJobStatus"]
+                if status in self.hook.non_terminal_states:
+                    await asyncio.sleep(self.poke_interval)
+                elif status in self.hook.failed_states:
+                    reason = last_description.get("FailureReason", "(No reason provided)")
+                    error_message = f"SageMaker job failed because {reason}"
+                    yield TriggerEvent({"status": "error", "message": error_message})
+                else:
+                    billable_seconds = SageMakerHook.count_billable_seconds(
+                        training_start_time=last_description["TrainingStartTime"],
+                        training_end_time=last_description["TrainingEndTime"],
+                        instance_count=instance_count,
+                    )
+                    self.log.info("Billable seconds: %d", billable_seconds)
+                    yield TriggerEvent({"status": "success", "message": last_description})
+            except Exception as e:
+                yield TriggerEvent({"status": "error", "message": str(e)})

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

@@ -20,7 +20,9 @@ import logging
 import re
 from datetime import datetime, timezone
 from enum import Enum
+from typing import Any
 
+from airflow.exceptions import AirflowException
 from airflow.utils.helpers import prune_dict
 from airflow.version import version
 
@@ -72,6 +74,14 @@ def get_airflow_version() -> tuple[int, ...]:
     return tuple(int(x) for x in match.groups())
 
 
+def validate_execute_complete_event(event: dict[str, Any] | None = None) -> dict[str, Any]:
+    if event is None:
+        err_msg = "Trigger error: event is None"
+        log.error(err_msg)
+        raise AirflowException(err_msg)
+    return event
+
+
 class _StringCompareEnum(Enum):
     """
     An Enum class which can be compared with regular `str` and subclasses.

airflow/providers/amazon/aws/utils/connection_wrapper.py

@@ -25,6 +25,7 @@ from typing import TYPE_CHECKING, Any
 
 from botocore import UNSIGNED
 from botocore.config import Config
+from deprecated import deprecated
 
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.utils import trim_none_values
@@ -165,7 +166,7 @@ class AwsConnectionWrapper(LoggingMixin):
 
         return service_config.get("endpoint_url", global_endpoint_url)
 
-    def __post_init__(self, conn: Connection):
+    def __post_init__(self, conn: Connection | AwsConnectionWrapper | _ConnectionMetadata | None) -> None:
         if isinstance(conn, type(self)):
             # For every field with init=False we copy reference value from original wrapper
             # For every field with init=True we use init values if it not equal default
@@ -192,6 +193,9 @@ class AwsConnectionWrapper(LoggingMixin):
         elif not conn:
             return
 
+        if TYPE_CHECKING:
+            assert isinstance(conn, (Connection, _ConnectionMetadata))
+
         # Assign attributes from AWS Connection
         self.conn_id = conn.conn_id
         self.conn_type = conn.conn_type or "aws"
@@ -462,6 +466,13 @@ class AwsConnectionWrapper(LoggingMixin):
         return role_arn, assume_role_method, assume_role_kwargs
 
 
+@deprecated(
+    reason=(
+        "Use local credentials file is never documented and well tested. "
+        "Obtain credentials by this way deprecated and will be removed in a future releases."
+    ),
+    category=AirflowProviderDeprecationWarning,
+)
 def _parse_s3_config(
     config_file_name: str, config_format: str | None = "boto", profile: str | None = None
 ) -> tuple[str | None, str | None]:
@@ -474,13 +485,6 @@ def _parse_s3_config(
         Defaults to "boto"
     :param profile: profile name in AWS type config file
     """
-    warnings.warn(
-        "Use local credentials file is never documented and well tested. "
-        "Obtain credentials by this way deprecated and will be removed in a future releases.",
-        AirflowProviderDeprecationWarning,
-        stacklevel=4,
-    )
-
     import configparser
 
     config = configparser.ConfigParser()

airflow/providers/amazon/aws/utils/mixins.py

@@ -31,6 +31,7 @@ import warnings
 from functools import cached_property
 from typing import Any, Generic, NamedTuple, TypeVar
 
+from deprecated import deprecated
 from typing_extensions import final
 
 from airflow.compat.functools import cache
@@ -160,9 +161,12 @@ class AwsBaseHookMixin(Generic[AwsHookType]):
 
     @property
     @final
+    @deprecated(
+        reason="`region` is deprecated and will be removed in the future. Please use `region_name` instead.",
+        category=AirflowProviderDeprecationWarning,
+    )
     def region(self) -> str | None:
         """Alias for ``region_name``, used for compatibility (deprecated)."""
-        warnings.warn(REGION_MSG, AirflowProviderDeprecationWarning, stacklevel=3)
         return self.region_name