apache-airflow-providers-amazon 8.29.0rc1__py3-none-any.whl → 9.0.0__py3-none-any.whl

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

@@ -19,18 +19,12 @@
 
 from __future__ import annotations
 
-import warnings
 from typing import Sequence
 
-from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.base_aws import AwsBaseHook
 from airflow.utils.types import NOTSET, ArgNotSet
 
-_DEPRECATION_MSG = (
-    "The aws_conn_id parameter has been deprecated. Use the source_aws_conn_id parameter instead."
-)
-
 
 class AwsToAwsBaseOperator(BaseOperator):
     """
@@ -43,8 +37,6 @@ class AwsToAwsBaseOperator(BaseOperator):
         would be used (and must be maintained on each worker node).
     :param dest_aws_conn_id: The Airflow connection used for AWS credentials
         to access S3. If this is not set then the source_aws_conn_id connection is used.
-    :param aws_conn_id: The Airflow connection used for AWS credentials (deprecated; use source_aws_conn_id).
-
     """
 
     template_fields: Sequence[str] = (
@@ -57,17 +49,12 @@ class AwsToAwsBaseOperator(BaseOperator):
         *,
         source_aws_conn_id: str | None = AwsBaseHook.default_conn_name,
         dest_aws_conn_id: str | None | ArgNotSet = NOTSET,
-        aws_conn_id: str | None | ArgNotSet = NOTSET,
         **kwargs,
     ) -> None:
         super().__init__(**kwargs)
         self.source_aws_conn_id = source_aws_conn_id
         self.dest_aws_conn_id = dest_aws_conn_id
-        if not isinstance(aws_conn_id, ArgNotSet):
-            warnings.warn(_DEPRECATION_MSG, AirflowProviderDeprecationWarning, stacklevel=3)
-            self.source_aws_conn_id = aws_conn_id
-        else:
-            self.source_aws_conn_id = source_aws_conn_id
+        self.source_aws_conn_id = source_aws_conn_id
         if isinstance(dest_aws_conn_id, ArgNotSet):
             self.dest_aws_conn_id = self.source_aws_conn_id
         else:

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

@@ -20,12 +20,11 @@
 from __future__ import annotations
 
 import os
-import warnings
 from typing import TYPE_CHECKING, Sequence
 
 from packaging.version import Version
 
-from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
+from airflow.exceptions import AirflowException
 from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.s3 import S3Hook
 from airflow.providers.google.cloud.hooks.gcs import GCSHook
@@ -43,12 +42,8 @@ class GCSToS3Operator(BaseOperator):
         :ref:`howto/operator:GCSToS3Operator`
 
     :param gcs_bucket: The Google Cloud Storage bucket to find the objects. (templated)
-    :param bucket: (Deprecated) Use ``gcs_bucket`` instead.
     :param prefix: Prefix string which filters objects whose name begin with
         this prefix. (templated)
-    :param delimiter: (Deprecated) The delimiter by which you want to filter the objects. (templated)
-        For e.g to lists the CSV files from in a directory in GCS you would use
-        delimiter='.csv'.
     :param gcp_conn_id: (Optional) The connection ID used to connect to Google Cloud.
     :param dest_aws_conn_id: The destination S3 connection
     :param dest_s3_key: The base S3 key to be used to store the files. (templated)
@@ -91,7 +86,6 @@ class GCSToS3Operator(BaseOperator):
     template_fields: Sequence[str] = (
         "gcs_bucket",
         "prefix",
-        "delimiter",
         "dest_s3_key",
         "google_impersonation_chain",
         "gcp_user_project",
@@ -101,10 +95,8 @@ class GCSToS3Operator(BaseOperator):
     def __init__(
         self,
         *,
-        gcs_bucket: str | None = None,
-        bucket: str | None = None,
+        gcs_bucket: str,
         prefix: str | None = None,
-        delimiter: str | None = None,
         gcp_conn_id: str = "google_cloud_default",
         dest_aws_conn_id: str | None = "aws_default",
         dest_s3_key: str,
@@ -119,17 +111,7 @@ class GCSToS3Operator(BaseOperator):
         **kwargs,
     ) -> None:
         super().__init__(**kwargs)
-        if bucket:
-            warnings.warn(
-                "The ``bucket`` parameter is deprecated and will be removed in a future version. "
-                "Please use ``gcs_bucket`` instead.",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-        self.gcs_bucket = gcs_bucket or bucket
-        if not (bucket or gcs_bucket):
-            raise ValueError("You must pass either ``bucket`` or ``gcs_bucket``.")
-
+        self.gcs_bucket = gcs_bucket
         self.prefix = prefix
         self.gcp_conn_id = gcp_conn_id
         self.dest_aws_conn_id = dest_aws_conn_id
@@ -149,18 +131,10 @@ class GCSToS3Operator(BaseOperator):
                 self.__is_match_glob_supported = False
         except ImportError:  # __version__ was added in 10.1.0, so this means it's < 10.3.0
             self.__is_match_glob_supported = False
-        if self.__is_match_glob_supported:
-            if delimiter:
-                warnings.warn(
-                    "Usage of 'delimiter' is deprecated, please use 'match_glob' instead",
-                    AirflowProviderDeprecationWarning,
-                    stacklevel=2,
-                )
-        elif match_glob:
+        if not self.__is_match_glob_supported and match_glob:
             raise AirflowException(
                 "The 'match_glob' parameter requires 'apache-airflow-providers-google>=10.3.0'."
             )
-        self.delimiter = delimiter
         self.match_glob = match_glob
         self.gcp_user_project = gcp_user_project
 
@@ -172,16 +146,14 @@ class GCSToS3Operator(BaseOperator):
         )
 
         self.log.info(
-            "Getting list of the files. Bucket: %s; Delimiter: %s; Prefix: %s",
+            "Getting list of the files. Bucket: %s; Prefix: %s",
             self.gcs_bucket,
-            self.delimiter,
             self.prefix,
         )
 
         list_kwargs = {
             "bucket_name": self.gcs_bucket,
             "prefix": self.prefix,
-            "delimiter": self.delimiter,
             "user_project": self.gcp_user_project,
         }
         if self.__is_match_glob_supported:

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

@@ -45,7 +45,8 @@ class RedshiftToS3Operator(BaseOperator):
     :param s3_key: reference to a specific S3 key. If ``table_as_file_name`` is set
         to False, this param must include the desired file name
     :param schema: reference to a specific schema in redshift database,
-        used when ``table`` param provided and ``select_query`` param not provided
+        used when ``table`` param provided and ``select_query`` param not provided.
+        Do not provide when unloading a temporary table
     :param table: reference to a specific table in redshift database,
         used when ``schema`` param provided and ``select_query`` param not provided
     :param select_query: custom select query to fetch data from redshift database,
@@ -55,8 +56,8 @@ class RedshiftToS3Operator(BaseOperator):
         If the AWS connection contains 'aws_iam_role' in ``extras``
         the operator will use AWS STS credentials with a token
         https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-authorization.html#copy-credentials
-    :param verify: Whether or not to verify SSL certificates for S3 connection.
-        By default SSL certificates are verified.
+    :param verify: Whether to verify SSL certificates for S3 connection.
+        By default, SSL certificates are verified.
         You can provide the following values:
 
         - ``False``: do not validate SSL certificates. SSL will still be used
@@ -67,7 +68,7 @@ class RedshiftToS3Operator(BaseOperator):
                  CA cert bundle than the one used by botocore.
     :param unload_options: reference to a list of UNLOAD options
     :param autocommit: If set to True it will automatically commit the UNLOAD statement.
-        Otherwise it will be committed right before the redshift connection gets closed.
+        Otherwise, it will be committed right before the redshift connection gets closed.
     :param include_header: If set to True the s3 file contains the header columns.
     :param parameters: (optional) the parameters to render the SQL query with.
     :param table_as_file_name: If set to True, the s3 file will be named as the table.
@@ -141,9 +142,15 @@ class RedshiftToS3Operator(BaseOperator):
 
     @property
     def default_select_query(self) -> str | None:
-        if self.schema and self.table:
-            return f"SELECT * FROM {self.schema}.{self.table}"
-        return None
+        if not self.table:
+            return None
+
+        if self.schema:
+            table = f"{self.schema}.{self.table}"
+        else:
+            # Relevant when unloading a temporary table
+            table = self.table
+        return f"SELECT * FROM {table}"
 
     def execute(self, context: Context) -> None:
         if self.table and self.table_as_file_name:
@@ -152,9 +159,7 @@ class RedshiftToS3Operator(BaseOperator):
         self.select_query = self.select_query or self.default_select_query
 
         if self.select_query is None:
-            raise ValueError(
-                "Please provide both `schema` and `table` params or `select_query` to fetch the data."
-            )
+            raise ValueError("Please specify either a table or `select_query` to fetch the data.")
 
         if self.include_header and "HEADER" not in [uo.upper().strip() for uo in self.unload_options]:
             self.unload_options = [*self.unload_options, "HEADER"]

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

@@ -28,7 +28,6 @@ from airflow.providers.amazon.aws.utils.redshift import build_credentials_block
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
-
 AVAILABLE_METHODS = ["APPEND", "REPLACE", "UPSERT"]
 
 
@@ -40,17 +39,18 @@ class S3ToRedshiftOperator(BaseOperator):
         For more information on how to use this operator, take a look at the guide:
         :ref:`howto/operator:S3ToRedshiftOperator`
 
-    :param schema: reference to a specific schema in redshift database
     :param table: reference to a specific table in redshift database
     :param s3_bucket: reference to a specific S3 bucket
     :param s3_key: key prefix that selects single or multiple objects from S3
+    :param schema: reference to a specific schema in redshift database.
+        Do not provide when copying into a temporary table
     :param redshift_conn_id: reference to a specific redshift database OR a redshift data-api connection
     :param aws_conn_id: reference to a specific S3 connection
         If the AWS connection contains 'aws_iam_role' in ``extras``
         the operator will use AWS STS credentials with a token
         https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-authorization.html#copy-credentials
-    :param verify: Whether or not to verify SSL certificates for S3 connection.
-        By default SSL certificates are verified.
+    :param verify: Whether to verify SSL certificates for S3 connection.
+        By default, SSL certificates are verified.
         You can provide the following values:
 
         - ``False``: do not validate SSL certificates. SSL will still be used
@@ -87,10 +87,10 @@ class S3ToRedshiftOperator(BaseOperator):
     def __init__(
         self,
         *,
-        schema: str,
         table: str,
         s3_bucket: str,
         s3_key: str,
+        schema: str | None = None,
         redshift_conn_id: str = "redshift_default",
         aws_conn_id: str | None = "aws_default",
         verify: bool | str | None = None,
@@ -160,7 +160,7 @@ class S3ToRedshiftOperator(BaseOperator):
             credentials_block = build_credentials_block(credentials)
 
         copy_options = "\n\t\t\t".join(self.copy_options)
-        destination = f"{self.schema}.{self.table}"
+        destination = f"{self.schema}.{self.table}" if self.schema else self.table
         copy_destination = f"#{self.table}" if self.method == "UPSERT" else destination
 
         copy_statement = self._build_copy_query(

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

@@ -223,12 +223,9 @@ class SqlToS3Operator(BaseOperator):
         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)
-                    .drop(random_column_name, axis=1, errors="ignore")
-                    .reset_index(drop=True),
-                ),
+                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/batch.py

@@ -16,182 +16,15 @@
 # under the License.
 from __future__ import annotations
 
-import asyncio
-import itertools
-from functools import cached_property
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
-from botocore.exceptions import WaiterError
-from deprecated import deprecated
-
-from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.batch_client import BatchClientHook
 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
 
 
-@deprecated(reason="use BatchJobTrigger instead", category=AirflowProviderDeprecationWarning)
-class BatchOperatorTrigger(BaseTrigger):
-    """
-    Asynchronously poll the boto3 API and wait for the Batch job to be in the `SUCCEEDED` state.
-
-    :param job_id:  A unique identifier for the cluster.
-    :param max_retries: The maximum number of attempts to be made.
-    :param aws_conn_id: The Airflow connection used for AWS credentials.
-    :param region_name: region name to use in AWS Hook
-    :param poll_interval: The amount of time in seconds to wait between attempts.
-    """
-
-    def __init__(
-        self,
-        job_id: str | None = None,
-        max_retries: int = 10,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
-        poll_interval: int = 30,
-    ):
-        super().__init__()
-        self.job_id = job_id
-        self.max_retries = max_retries
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
-        self.poll_interval = poll_interval
-
-    def serialize(self) -> tuple[str, dict[str, Any]]:
-        """Serialize BatchOperatorTrigger arguments and classpath."""
-        return (
-            "airflow.providers.amazon.aws.triggers.batch.BatchOperatorTrigger",
-            {
-                "job_id": self.job_id,
-                "max_retries": self.max_retries,
-                "aws_conn_id": self.aws_conn_id,
-                "region_name": self.region_name,
-                "poll_interval": self.poll_interval,
-            },
-        )
-
-    @cached_property
-    def hook(self) -> BatchClientHook:
-        return BatchClientHook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)
-
-    async def run(self):
-        async with self.hook.async_conn as client:
-            waiter = self.hook.get_waiter("batch_job_complete", deferrable=True, client=client)
-            for attempt in range(1, 1 + self.max_retries):
-                try:
-                    await waiter.wait(
-                        jobs=[self.job_id],
-                        WaiterConfig={
-                            "Delay": self.poll_interval,
-                            "MaxAttempts": 1,
-                        },
-                    )
-                except WaiterError as error:
-                    if "terminal failure" in str(error):
-                        yield TriggerEvent(
-                            {"status": "failure", "message": f"Delete Cluster Failed: {error}"}
-                        )
-                        break
-                    self.log.info(
-                        "Job status is %s. Retrying attempt %s/%s",
-                        error.last_response["jobs"][0]["status"],
-                        attempt,
-                        self.max_retries,
-                    )
-                    await asyncio.sleep(int(self.poll_interval))
-                else:
-                    yield TriggerEvent({"status": "success", "job_id": self.job_id})
-                    break
-            else:
-                yield TriggerEvent({"status": "failure", "message": "Job Failed - max attempts reached."})
-
-
-@deprecated(reason="use BatchJobTrigger instead", category=AirflowProviderDeprecationWarning)
-class BatchSensorTrigger(BaseTrigger):
-    """
-    Checks for the status of a submitted job_id to AWS Batch until it reaches a failure or a success state.
-
-    BatchSensorTrigger is fired as deferred class with params to poll the job state in Triggerer.
-
-    :param job_id: the job ID, to poll for job completion or not
-    :param region_name: AWS region name to use
-        Override the region_name in connection (if provided)
-    :param aws_conn_id: connection id of AWS credentials / region name. If None,
-        credential boto3 strategy will be used
-    :param poke_interval: polling period in seconds to check for the status of the job
-    """
-
-    def __init__(
-        self,
-        job_id: str,
-        region_name: str | None,
-        aws_conn_id: str | None = "aws_default",
-        poke_interval: float = 5,
-    ):
-        super().__init__()
-        self.job_id = job_id
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
-        self.poke_interval = poke_interval
-
-    def serialize(self) -> tuple[str, dict[str, Any]]:
-        """Serialize BatchSensorTrigger arguments and classpath."""
-        return (
-            "airflow.providers.amazon.aws.triggers.batch.BatchSensorTrigger",
-            {
-                "job_id": self.job_id,
-                "aws_conn_id": self.aws_conn_id,
-                "region_name": self.region_name,
-                "poke_interval": self.poke_interval,
-            },
-        )
-
-    @cached_property
-    def hook(self) -> BatchClientHook:
-        return BatchClientHook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)
-
-    async def run(self):
-        """
-        Make async connection using aiobotocore library to AWS Batch, periodically poll for the job status.
-
-        The status that indicates job completion are: 'SUCCEEDED'|'FAILED'.
-        """
-        async with self.hook.async_conn as client:
-            waiter = self.hook.get_waiter("batch_job_complete", deferrable=True, client=client)
-            for attempt in itertools.count(1):
-                try:
-                    await waiter.wait(
-                        jobs=[self.job_id],
-                        WaiterConfig={
-                            "Delay": int(self.poke_interval),
-                            "MaxAttempts": 1,
-                        },
-                    )
-                except WaiterError as error:
-                    if "error" in str(error):
-                        yield TriggerEvent({"status": "failure", "message": f"Job Failed: {error}"})
-                        break
-                    self.log.info(
-                        "Job response is %s. Retrying attempt %s",
-                        error.last_response["Error"]["Message"],
-                        attempt,
-                    )
-                    await asyncio.sleep(int(self.poke_interval))
-                else:
-                    break
-
-            yield TriggerEvent(
-                {
-                    "status": "success",
-                    "job_id": self.job_id,
-                    "message": f"Job {self.job_id} Succeeded",
-                }
-            )
-
-
 class BatchJobTrigger(AwsBaseWaiterTrigger):
     """
     Checks for the status of a submitted job_id to AWS Batch until it reaches a failure or a success state.

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

@@ -16,12 +16,11 @@
 # under the License.
 from __future__ import annotations
 
-import warnings
 from typing import TYPE_CHECKING, Any
 
 from botocore.exceptions import ClientError
 
-from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.eks import EksHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
 from airflow.providers.amazon.aws.utils.waiter_with_logging import async_wait
@@ -235,17 +234,8 @@ class EksCreateFargateProfileTrigger(AwsBaseWaiterTrigger):
         waiter_delay: int,
         waiter_max_attempts: int,
         aws_conn_id: str | None,
-        region: str | None = None,
         region_name: str | None = None,
     ):
-        if region is not None:
-            warnings.warn(
-                "please use region_name param instead of region",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            region_name = region
-
         super().__init__(
             serialized_fields={"cluster_name": cluster_name, "fargate_profile_name": fargate_profile_name},
             waiter_name="fargate_profile_active",
@@ -282,17 +272,8 @@ class EksDeleteFargateProfileTrigger(AwsBaseWaiterTrigger):
         waiter_delay: int,
         waiter_max_attempts: int,
         aws_conn_id: str | None,
-        region: str | None = None,
         region_name: str | None = None,
     ):
-        if region is not None:
-            warnings.warn(
-                "please use region_name param instead of region",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            region_name = region
-
         super().__init__(
             serialized_fields={"cluster_name": cluster_name, "fargate_profile_name": fargate_profile_name},
             waiter_name="fargate_profile_deleted",

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

@@ -17,10 +17,8 @@
 from __future__ import annotations
 
 import sys
-import warnings
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.emr import EmrContainerHook, EmrHook, EmrServerlessHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
 
@@ -81,21 +79,10 @@ class EmrCreateJobFlowTrigger(AwsBaseWaiterTrigger):
     def __init__(
         self,
         job_flow_id: str,
-        poll_interval: int | None = None,  # deprecated
-        max_attempts: int | None = None,  # deprecated
         aws_conn_id: str | None = None,
         waiter_delay: int = 30,
         waiter_max_attempts: int = 60,
     ):
-        if poll_interval is not None or max_attempts is not None:
-            warnings.warn(
-                "please use waiter_delay instead of poll_interval "
-                "and waiter_max_attempts instead of max_attempts",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_delay = poll_interval or waiter_delay
-            waiter_max_attempts = max_attempts or waiter_max_attempts
         super().__init__(
             serialized_fields={"job_flow_id": job_flow_id},
             waiter_name="job_flow_waiting",
@@ -131,21 +118,10 @@ class EmrTerminateJobFlowTrigger(AwsBaseWaiterTrigger):
     def __init__(
         self,
         job_flow_id: str,
-        poll_interval: int | None = None,  # deprecated
-        max_attempts: int | None = None,  # deprecated
         aws_conn_id: str | None = None,
         waiter_delay: int = 30,
         waiter_max_attempts: int = 60,
     ):
-        if poll_interval is not None or max_attempts is not None:
-            warnings.warn(
-                "please use waiter_delay instead of poll_interval "
-                "and waiter_max_attempts instead of max_attempts",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_delay = poll_interval or waiter_delay
-            waiter_max_attempts = max_attempts or waiter_max_attempts
         super().__init__(
             serialized_fields={"job_flow_id": job_flow_id},
             waiter_name="job_flow_terminated",
@@ -183,17 +159,9 @@ class EmrContainerTrigger(AwsBaseWaiterTrigger):
         virtual_cluster_id: str,
         job_id: str,
         aws_conn_id: str | None = "aws_default",
-        poll_interval: int | None = None,  # deprecated
         waiter_delay: int = 30,
         waiter_max_attempts: int = sys.maxsize,
     ):
-        if poll_interval is not None:
-            warnings.warn(
-                "please use waiter_delay instead of poll_interval.",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_delay = poll_interval or waiter_delay
         super().__init__(
             serialized_fields={"virtual_cluster_id": virtual_cluster_id, "job_id": job_id},
             waiter_name="container_job_complete",

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

@@ -16,10 +16,8 @@
 # under the License.
 from __future__ import annotations
 
-import warnings
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.glue_crawler import GlueCrawlerHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
 
@@ -32,26 +30,17 @@ class GlueCrawlerCompleteTrigger(AwsBaseWaiterTrigger):
     Watches for a glue crawl, triggers when it finishes.
 
     :param crawler_name: name of the crawler to watch
-    :param poll_interval: The amount of time in seconds to wait between attempts.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
     """
 
     def __init__(
         self,
         crawler_name: str,
-        poll_interval: int | None = None,
         aws_conn_id: str | None = "aws_default",
         waiter_delay: int = 5,
         waiter_max_attempts: int = 1500,
         **kwargs,
     ):
-        if poll_interval is not None:
-            warnings.warn(
-                "please use waiter_delay instead of poll_interval.",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_delay = poll_interval or waiter_delay
         super().__init__(
             serialized_fields={"crawler_name": crawler_name},
             waiter_name="crawler_ready",

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

@@ -17,9 +17,6 @@
 
 from __future__ import annotations
 
-import warnings
-
-from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.amazon.aws.hooks.glue_databrew import GlueDataBrewHook
 from airflow.providers.amazon.aws.triggers.base import AwsBaseWaiterTrigger
 
@@ -30,9 +27,7 @@ class GlueDataBrewJobCompleteTrigger(AwsBaseWaiterTrigger):
 
     :param job_name: Glue DataBrew job name
     :param run_id: the ID of the specific run to watch for that job
-    :param delay: Number of seconds to wait between two checks.(Deprecated).
     :param waiter_delay: Number of seconds to wait between two checks. Default is 30 seconds.
-    :param max_attempts: Maximum number of attempts to wait for the job to complete.(Deprecated).
     :param waiter_max_attempts: Maximum number of attempts to wait for the job to complete. Default is 60 attempts.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
     """
@@ -41,27 +36,11 @@ class GlueDataBrewJobCompleteTrigger(AwsBaseWaiterTrigger):
         self,
         job_name: str,
         run_id: str,
-        delay: int | None = None,
-        max_attempts: int | None = None,
         waiter_delay: int = 30,
         waiter_max_attempts: int = 60,
         aws_conn_id: str | None = "aws_default",
         **kwargs,
     ):
-        if delay is not None:
-            warnings.warn(
-                "please use `waiter_delay` instead of delay.",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_delay = delay or waiter_delay
-        if max_attempts is not None:
-            warnings.warn(
-                "please use `waiter_max_attempts` instead of max_attempts.",
-                AirflowProviderDeprecationWarning,
-                stacklevel=2,
-            )
-            waiter_max_attempts = max_attempts or waiter_max_attempts
         super().__init__(
             serialized_fields={"job_name": job_name, "run_id": run_id},
             waiter_name="job_complete",