apache-airflow-providers-standard 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

airflow/providers/standard/triggers/external_task.py

@@ -0,0 +1,216 @@
+# 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
+import typing
+from typing import Any
+
+from asgiref.sync import sync_to_async
+from sqlalchemy import func
+
+from airflow.models import DagRun
+from airflow.providers.standard.utils.sensor_helper import _get_count
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+from airflow.triggers.base import BaseTrigger, TriggerEvent
+from airflow.utils.session import NEW_SESSION, provide_session
+
+if typing.TYPE_CHECKING:
+    from datetime import datetime
+
+    from sqlalchemy.orm import Session
+
+    from airflow.utils.state import DagRunState
+
+
+class WorkflowTrigger(BaseTrigger):
+    """
+    A trigger to monitor tasks, task group and dag execution in Apache Airflow.
+
+    :param external_dag_id: The ID of the external DAG.
+    :param logical_dates: A list of logical dates for the external DAG.
+    :param external_task_ids: A collection of external task IDs to wait for.
+    :param external_task_group_id: The ID of the external task group to wait for.
+    :param failed_states: States considered as failed for external tasks.
+    :param skipped_states: States considered as skipped for external tasks.
+    :param allowed_states: States considered as successful for external tasks.
+    :param poke_interval: The interval (in seconds) for poking the external tasks.
+    :param soft_fail: If True, the trigger will not fail the entire DAG on external task failure.
+    """
+
+    def __init__(
+        self,
+        external_dag_id: str,
+        logical_dates: list[datetime] | None = None,
+        execution_dates: list[datetime] | None = None,
+        external_task_ids: typing.Collection[str] | None = None,
+        external_task_group_id: str | None = None,
+        failed_states: typing.Iterable[str] | None = None,
+        skipped_states: typing.Iterable[str] | None = None,
+        allowed_states: typing.Iterable[str] | None = None,
+        poke_interval: float = 2.0,
+        soft_fail: bool = False,
+        **kwargs,
+    ):
+        self.external_dag_id = external_dag_id
+        self.external_task_ids = external_task_ids
+        self.external_task_group_id = external_task_group_id
+        self.failed_states = failed_states
+        self.skipped_states = skipped_states
+        self.allowed_states = allowed_states
+        self.logical_dates = logical_dates
+        self.poke_interval = poke_interval
+        self.soft_fail = soft_fail
+        self.execution_dates = execution_dates
+        super().__init__(**kwargs)
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serialize the trigger param and module path."""
+        _dates = (
+            {"logical_dates": self.logical_dates}
+            if AIRFLOW_V_3_0_PLUS
+            else {"execution_dates": self.execution_dates}
+        )
+        return (
+            "airflow.providers.standard.triggers.external_task.WorkflowTrigger",
+            {
+                "external_dag_id": self.external_dag_id,
+                "external_task_ids": self.external_task_ids,
+                "external_task_group_id": self.external_task_group_id,
+                "failed_states": self.failed_states,
+                "skipped_states": self.skipped_states,
+                "allowed_states": self.allowed_states,
+                **_dates,
+                "poke_interval": self.poke_interval,
+                "soft_fail": self.soft_fail,
+            },
+        )
+
+    async def run(self) -> typing.AsyncIterator[TriggerEvent]:
+        """Check periodically tasks, task group or dag status."""
+        while True:
+            if self.failed_states:
+                failed_count = await self._get_count(self.failed_states)
+                if failed_count > 0:
+                    yield TriggerEvent({"status": "failed"})
+                    return
+                else:
+                    yield TriggerEvent({"status": "success"})
+                    return
+            if self.skipped_states:
+                skipped_count = await self._get_count(self.skipped_states)
+                if skipped_count > 0:
+                    yield TriggerEvent({"status": "skipped"})
+                    return
+            allowed_count = await self._get_count(self.allowed_states)
+            _dates = self.logical_dates if AIRFLOW_V_3_0_PLUS else self.execution_dates
+            if allowed_count == len(_dates):  # type: ignore[arg-type]
+                yield TriggerEvent({"status": "success"})
+                return
+            self.log.info("Sleeping for %s seconds", self.poke_interval)
+            await asyncio.sleep(self.poke_interval)
+
+    @sync_to_async
+    def _get_count(self, states: typing.Iterable[str] | None) -> int:
+        """
+        Get the count of records against dttm filter and states. Async wrapper for _get_count.
+
+        :param states: task or dag states
+        :return The count of records.
+        """
+        return _get_count(
+            dttm_filter=self.logical_dates if AIRFLOW_V_3_0_PLUS else self.execution_dates,
+            external_task_ids=self.external_task_ids,
+            external_task_group_id=self.external_task_group_id,
+            external_dag_id=self.external_dag_id,
+            states=states,
+        )
+
+
+class DagStateTrigger(BaseTrigger):
+    """
+    Waits asynchronously for a DAG to complete for a specific logical date.
+
+    :param dag_id: The dag_id that contains the task you want to wait for
+    :param states: allowed states, default is ``['success']``
+    :param logical_dates: The logical date at which DAG run.
+    :param poll_interval: The time interval in seconds to check the state.
+        The default value is 5.0 sec.
+    """
+
+    def __init__(
+        self,
+        dag_id: str,
+        states: list[DagRunState],
+        logical_dates: list[datetime] | None = None,
+        execution_dates: list[datetime] | None = None,
+        poll_interval: float = 5.0,
+    ):
+        super().__init__()
+        self.dag_id = dag_id
+        self.states = states
+        self.logical_dates = logical_dates
+        self.execution_dates = execution_dates
+        self.poll_interval = poll_interval
+
+    def serialize(self) -> tuple[str, dict[str, typing.Any]]:
+        """Serialize DagStateTrigger arguments and classpath."""
+        _dates = (
+            {"logical_dates": self.logical_dates}
+            if AIRFLOW_V_3_0_PLUS
+            else {"execution_dates": self.execution_dates}
+        )
+        return (
+            "airflow.providers.standard.triggers.external_task.DagStateTrigger",
+            {
+                "dag_id": self.dag_id,
+                "states": self.states,
+                **_dates,
+                "poll_interval": self.poll_interval,
+            },
+        )
+
+    async def run(self) -> typing.AsyncIterator[TriggerEvent]:
+        """Check periodically if the dag run exists, and has hit one of the states yet, or not."""
+        while True:
+            # mypy confuses typing here
+            num_dags = await self.count_dags()  # type: ignore[call-arg]
+            _dates = self.logical_dates if AIRFLOW_V_3_0_PLUS else self.execution_dates
+            if num_dags == len(_dates):  # type: ignore[arg-type]
+                yield TriggerEvent(self.serialize())
+                return
+            await asyncio.sleep(self.poll_interval)
+
+    @sync_to_async
+    @provide_session
+    def count_dags(self, *, session: Session = NEW_SESSION) -> int | None:
+        """Count how many dag runs in the database match our criteria."""
+        _dag_run_date_condition = (
+            DagRun.logical_date.in_(self.logical_dates)
+            if AIRFLOW_V_3_0_PLUS
+            else DagRun.execution_date.in_(self.execution_dates)
+        )
+        count = (
+            session.query(func.count("*"))  # .count() is inefficient
+            .filter(
+                DagRun.dag_id == self.dag_id,
+                DagRun.state.in_(self.states),
+                _dag_run_date_condition,
+            )
+            .scalar()
+        )
+        return typing.cast(int, count)

airflow/providers/standard/triggers/file.py

@@ -0,0 +1,77 @@
+# 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
+import datetime
+import os
+import typing
+from glob import glob
+from typing import Any
+
+from airflow.triggers.base import BaseTrigger, TriggerEvent
+
+
+class FileTrigger(BaseTrigger):
+    """
+    A trigger that fires exactly once after it finds the requested file or folder.
+
+    :param filepath: File or folder name (relative to the base path set within the connection), can
+        be a glob.
+    :param recursive: when set to ``True``, enables recursive directory matching behavior of
+        ``**`` in glob filepath parameter. Defaults to ``False``.
+    :param poke_interval: Time that the job should wait in between each try
+    """
+
+    def __init__(
+        self,
+        filepath: str,
+        recursive: bool = False,
+        poke_interval: float = 5.0,
+        **kwargs,
+    ):
+        super().__init__()
+        self.filepath = filepath
+        self.recursive = recursive
+        self.poke_interval = poke_interval
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serialize FileTrigger arguments and classpath."""
+        return (
+            "airflow.providers.standard.triggers.file.FileTrigger",
+            {
+                "filepath": self.filepath,
+                "recursive": self.recursive,
+                "poke_interval": self.poke_interval,
+            },
+        )
+
+    async def run(self) -> typing.AsyncIterator[TriggerEvent]:
+        """Loop until the relevant files are found."""
+        while True:
+            for path in glob(self.filepath, recursive=self.recursive):
+                if os.path.isfile(path):
+                    mod_time_f = os.path.getmtime(path)
+                    mod_time = datetime.datetime.fromtimestamp(mod_time_f).strftime("%Y%m%d%H%M%S")
+                    self.log.info("Found File %s last modified: %s", path, mod_time)
+                    yield TriggerEvent(True)
+                    return
+                for _, _, files in os.walk(self.filepath):
+                    if files:
+                        yield TriggerEvent(True)
+                        return
+            await asyncio.sleep(self.poke_interval)

airflow/providers/standard/triggers/temporal.py

@@ -0,0 +1,114 @@
+# 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
+import datetime
+from collections.abc import AsyncIterator
+from typing import Any
+
+import pendulum
+
+from airflow.exceptions import AirflowException
+from airflow.providers.standard.version_compat import AIRFLOW_V_2_10_PLUS
+from airflow.triggers.base import BaseTrigger, TriggerEvent
+from airflow.utils import timezone
+
+if AIRFLOW_V_2_10_PLUS:
+    from airflow.triggers.base import TaskSuccessEvent
+
+
+class DateTimeTrigger(BaseTrigger):
+    """
+    Trigger based on a datetime.
+
+    A trigger that fires exactly once, at the given datetime, give or take
+    a few seconds.
+
+    The provided datetime MUST be in UTC.
+
+    :param moment: when to yield event
+    :param end_from_trigger: whether the trigger should mark the task successful after time condition
+        reached or resume the task after time condition reached.
+    """
+
+    def __init__(self, moment: datetime.datetime, *, end_from_trigger: bool = False) -> None:
+        super().__init__()
+        if not isinstance(moment, datetime.datetime):
+            raise TypeError(f"Expected datetime.datetime type for moment. Got {type(moment)}")
+        # Make sure it's in UTC
+        elif moment.tzinfo is None:
+            raise ValueError("You cannot pass naive datetimes")
+        else:
+            self.moment: pendulum.DateTime = timezone.convert_to_utc(moment)
+        if not AIRFLOW_V_2_10_PLUS and end_from_trigger:
+            raise AirflowException("end_from_trigger is only supported in Airflow 2.10 and later. ")
+
+        self.end_from_trigger = end_from_trigger
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        return (
+            "airflow.providers.standard.triggers.temporal.DateTimeTrigger",
+            {"moment": self.moment, "end_from_trigger": self.end_from_trigger},
+        )
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:
+        """
+        Loop until the relevant time is met.
+
+        We do have a two-phase delay to save some cycles, but sleeping is so
+        cheap anyway that it's pretty loose. We also don't just sleep for
+        "the number of seconds until the time" in case the system clock changes
+        unexpectedly, or handles a DST change poorly.
+        """
+        # Sleep in successively smaller increments starting from 1 hour down to 10 seconds at a time
+        self.log.info("trigger starting")
+        for step in 3600, 60, 10:
+            seconds_remaining = (self.moment - pendulum.instance(timezone.utcnow())).total_seconds()
+            while seconds_remaining > 2 * step:
+                self.log.info("%d seconds remaining; sleeping %s seconds", seconds_remaining, step)
+                await asyncio.sleep(step)
+                seconds_remaining = (self.moment - pendulum.instance(timezone.utcnow())).total_seconds()
+        # Sleep a second at a time otherwise
+        while self.moment > pendulum.instance(timezone.utcnow()):
+            self.log.info("sleeping 1 second...")
+            await asyncio.sleep(1)
+        if self.end_from_trigger:
+            self.log.info("Sensor time condition reached; marking task successful and exiting")
+            yield TaskSuccessEvent()
+        else:
+            self.log.info("yielding event with payload %r", self.moment)
+            yield TriggerEvent(self.moment)
+
+
+class TimeDeltaTrigger(DateTimeTrigger):
+    """
+    Create DateTimeTriggers based on delays.
+
+    Subclass to create DateTimeTriggers based on time delays rather
+    than exact moments.
+
+    While this is its own distinct class here, it will serialise to a
+    DateTimeTrigger class, since they're operationally the same.
+
+    :param delta: how long to wait
+    :param end_from_trigger: whether the trigger should mark the task successful after time condition
+        reached or resume the task after time condition reached.
+    """
+
+    def __init__(self, delta: datetime.timedelta, *, end_from_trigger: bool = False) -> None:
+        super().__init__(moment=timezone.utcnow() + delta, end_from_trigger=end_from_trigger)

airflow/providers/standard/utils/python_virtualenv_script.jinja2

@@ -70,7 +70,6 @@ if len(sys.argv) > 5:
     from types import ModuleType
 
     from airflow.providers.standard.operators import python as airflow_python
-    from airflow.serialization.serialized_objects import BaseSerialization
 
 
     class _MockPython(ModuleType):
@@ -78,7 +77,8 @@ if len(sys.argv) > 5:
         def get_current_context():
             with open(sys.argv[5]) as file:
                 context = json.load(file)
-                return BaseSerialization.deserialize(context, use_pydantic_models=True)
+                raise Exception("Not yet implemented")
+                # TODO: return deserialized context
 
         def __getattr__(self, name: str):
             return getattr(airflow_python, name)

airflow/providers/standard/utils/sensor_helper.py

@@ -0,0 +1,123 @@
+# 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, cast
+
+from sqlalchemy import func, select
+
+from airflow.models import DagBag, DagRun, TaskInstance
+from airflow.utils.session import NEW_SESSION, provide_session
+from airflow.utils.sqlalchemy import tuple_in_condition
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Query, Session
+
+
+@provide_session
+def _get_count(
+    dttm_filter,
+    external_task_ids,
+    external_task_group_id,
+    external_dag_id,
+    states,
+    session: Session = NEW_SESSION,
+) -> int:
+    """
+    Get the count of records against dttm filter and states.
+
+    :param dttm_filter: date time filter for logical date
+    :param external_task_ids: The list of task_ids
+    :param external_task_group_id: The ID of the external task group
+    :param external_dag_id: The ID of the external DAG.
+    :param states: task or dag states
+    :param session: airflow session object
+    """
+    TI = TaskInstance
+    DR = DagRun
+    if not dttm_filter:
+        return 0
+
+    if external_task_ids:
+        count = (
+            session.scalar(
+                _count_query(TI, states, dttm_filter, external_dag_id, session).filter(
+                    TI.task_id.in_(external_task_ids)
+                )
+            )
+        ) / len(external_task_ids)
+    elif external_task_group_id:
+        external_task_group_task_ids = _get_external_task_group_task_ids(
+            dttm_filter, external_task_group_id, external_dag_id, session
+        )
+        if not external_task_group_task_ids:
+            count = 0
+        else:
+            count = (
+                session.scalar(
+                    _count_query(TI, states, dttm_filter, external_dag_id, session).filter(
+                        tuple_in_condition((TI.task_id, TI.map_index), external_task_group_task_ids)
+                    )
+                )
+            ) / len(external_task_group_task_ids)
+    else:
+        count = session.scalar(_count_query(DR, states, dttm_filter, external_dag_id, session))
+    return cast(int, count)
+
+
+def _count_query(model, states, dttm_filter, external_dag_id, session: Session) -> Query:
+    """
+    Get the count of records against dttm filter and states.
+
+    :param model: The SQLAlchemy model representing the relevant table.
+    :param states: task or dag states
+    :param dttm_filter: date time filter for logical date
+    :param external_dag_id: The ID of the external DAG.
+    :param session: airflow session object
+    """
+    query = select(func.count()).filter(
+        model.dag_id == external_dag_id, model.state.in_(states), model.logical_date.in_(dttm_filter)
+    )
+    return query
+
+
+def _get_external_task_group_task_ids(dttm_filter, external_task_group_id, external_dag_id, session):
+    """
+    Get the count of records against dttm filter and states.
+
+    :param dttm_filter: date time filter for logical date
+    :param external_task_group_id: The ID of the external task group
+    :param external_dag_id: The ID of the external DAG.
+    :param session: airflow session object
+    """
+    refreshed_dag_info = DagBag(read_dags_from_db=True).get_dag(external_dag_id, session)
+    task_group = refreshed_dag_info.task_group_dict.get(external_task_group_id)
+
+    if task_group:
+        group_tasks = session.scalars(
+            select(TaskInstance).filter(
+                TaskInstance.dag_id == external_dag_id,
+                TaskInstance.task_id.in_(task.task_id for task in task_group),
+                TaskInstance.logical_date.in_(dttm_filter),
+            )
+        )
+
+        return [(t.task_id, t.map_index) for t in group_tasks]
+
+    # returning default task_id as group_id itself, this will avoid any failure in case of
+    # 'check_existence=False' and will fail on timeout
+    return [(external_task_group_id, -1)]

airflow/providers/standard/version_compat.py

@@ -0,0 +1,36 @@
+# 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.
+#
+# NOTE! THIS FILE IS COPIED MANUALLY IN OTHER PROVIDERS DELIBERATELY TO AVOID ADDING UNNECESSARY
+# DEPENDENCIES BETWEEN PROVIDERS. IF YOU WANT TO ADD CONDITIONAL CODE IN YOUR PROVIDER THAT DEPENDS
+# ON AIRFLOW VERSION, PLEASE COPY THIS FILE TO THE ROOT PACKAGE OF YOUR PROVIDER AND IMPORT
+# THOSE CONSTANTS FROM IT RATHER THAN IMPORTING THEM FROM ANOTHER PROVIDER OR TEST CODE
+#
+from __future__ import annotations
+
+
+def get_base_airflow_version_tuple() -> tuple[int, int, int]:
+    from packaging.version import Version
+
+    from airflow import __version__
+
+    airflow_version = Version(__version__)
+    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)

{apache_airflow_providers_standard-0.0.2.dist-info → apache_airflow_providers_standard-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: apache-airflow-providers-standard
-Version: 0.0.2
+Version: 0.0.3
 Summary: Provider package apache-airflow-providers-standard for Apache Airflow
 Keywords: airflow-provider,standard,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -21,13 +21,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
 Requires-Dist: apache-airflow-providers-common-sql>=1.20.0
-Requires-Dist: apache-airflow>=2.8.0
+Requires-Dist: apache-airflow>=2.9.0
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.2/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.2
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.3/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.3
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
-Project-URL: Twitter, https://twitter.com/ApacheAirflow
+Project-URL: Twitter, https://x.com/ApacheAirflow
 Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 
@@ -74,7 +74,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-standard``
 
-Release: ``0.0.2``
+Release: ``0.0.3``
 
 
 Airflow Standard Provider
@@ -87,7 +87,7 @@ This is a provider package for ``standard`` provider. All classes for this provi
 are in ``airflow.providers.standard`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.2/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.3/>`_.
 
 Installation
 ------------
@@ -104,9 +104,9 @@ Requirements
 =======================================  ==================
 PIP package                              Version required
 =======================================  ==================
-``apache-airflow``                       ``>=2.8.0``
+``apache-airflow``                       ``>=2.9.0``
 ``apache-airflow-providers-common-sql``  ``>=1.20.0``
 =======================================  ==================
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.2/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.0.3/changelog.html>`_.