apache-airflow-providers-standard 1.9.2rc1__py3-none-any.whl → 1.11.0__py3-none-any.whl

airflow/providers/standard/sensors/external_task.py

@@ -23,10 +23,13 @@ import warnings
 from collections.abc import Callable, Collection, Iterable, Sequence
 from typing import TYPE_CHECKING, ClassVar
 
-from airflow.configuration import conf
-from airflow.exceptions import AirflowSkipException
 from airflow.models.dag import DagModel
-from airflow.providers.common.compat.sdk import BaseOperatorLink, BaseSensorOperator
+from airflow.providers.common.compat.sdk import (
+    AirflowSkipException,
+    BaseOperatorLink,
+    BaseSensorOperator,
+    conf,
+)
 from airflow.providers.standard.exceptions import (
     DuplicateStateError,
     ExternalDagDeletedError,
@@ -59,8 +62,7 @@ else:
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
-    from airflow.models.taskinstancekey import TaskInstanceKey
-    from airflow.providers.common.compat.sdk import Context
+    from airflow.providers.common.compat.sdk import Context, TaskInstanceKey
 
 
 class ExternalDagLink(BaseOperatorLink):
@@ -80,8 +82,17 @@ class ExternalDagLink(BaseOperatorLink):
 
         if not AIRFLOW_V_3_0_PLUS:
             from airflow.models.renderedtifields import RenderedTaskInstanceFields
+            from airflow.models.taskinstancekey import TaskInstanceKey as CoreTaskInstanceKey
+
+            core_ti_key = CoreTaskInstanceKey(
+                dag_id=ti_key.dag_id,
+                task_id=ti_key.task_id,
+                run_id=ti_key.run_id,
+                try_number=ti_key.try_number,
+                map_index=ti_key.map_index,
+            )
 
-            if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
+            if template_fields := RenderedTaskInstanceFields.get_templated_fields(core_ti_key):
                 external_dag_id: str = template_fields.get("external_dag_id", operator.external_dag_id)  # type: ignore[no-redef]
 
         if AIRFLOW_V_3_0_PLUS:
@@ -251,6 +262,7 @@ class ExternalTaskSensor(BaseSensorOperator):
         self._has_checked_existence = False
         self.deferrable = deferrable
         self.poll_interval = poll_interval
+        self.external_dates_filter: str | None = None
 
     def _get_dttm_filter(self, context: Context) -> Sequence[datetime.datetime]:
         logical_date = self._get_logical_date(context)
@@ -262,13 +274,19 @@ class ExternalTaskSensor(BaseSensorOperator):
             return result if isinstance(result, list) else [result]
         return [logical_date]
 
+    @staticmethod
+    def _serialize_dttm_filter(dttm_filter: Sequence[datetime.datetime]) -> str:
+        return ",".join(dt.isoformat() for dt in dttm_filter)
+
     def poke(self, context: Context) -> bool:
         # delay check to poke rather than __init__ in case it was supplied as XComArgs
         if self.external_task_ids and len(self.external_task_ids) > len(set(self.external_task_ids)):
             raise ValueError("Duplicate task_ids passed in external_task_ids parameter")
 
         dttm_filter = self._get_dttm_filter(context)
-        serialized_dttm_filter = ",".join(dt.isoformat() for dt in dttm_filter)
+        serialized_dttm_filter = self._serialize_dttm_filter(dttm_filter)
+        # Save as attribute - to be used by listeners
+        self.external_dates_filter = serialized_dttm_filter
 
         if self.external_task_ids:
             self.log.info(
@@ -457,6 +475,9 @@ class ExternalTaskSensor(BaseSensorOperator):
         if event is None:
             raise ExternalTaskNotFoundError("No event received from trigger")
 
+        # Re-set as attribute after coming back from deferral - to be used by listeners
+        self.external_dates_filter = self._serialize_dttm_filter(self._get_dttm_filter(context))
+
         if event["status"] == "success":
             self.log.info("External tasks %s has executed successfully.", self.external_task_ids)
         elif event["status"] == "skipped":

airflow/providers/standard/sensors/filesystem.py

@@ -20,31 +20,14 @@ from __future__ import annotations
 import datetime
 import os
 from collections.abc import Sequence
-from dataclasses import dataclass
 from functools import cached_property
 from glob import glob
 from typing import TYPE_CHECKING, Any
 
-from airflow.configuration import conf
-from airflow.exceptions import AirflowException
-from airflow.providers.common.compat.sdk import BaseSensorOperator
+from airflow.providers.common.compat.sdk import AirflowException, BaseSensorOperator, conf
 from airflow.providers.standard.hooks.filesystem import FSHook
 from airflow.providers.standard.triggers.file import FileTrigger
-
-try:
-    from airflow.triggers.base import StartTriggerArgs  # type: ignore[no-redef]
-except ImportError:  # TODO: Remove this when min airflow version is 2.10.0 for standard provider
-
-    @dataclass
-    class StartTriggerArgs:  # type: ignore[no-redef]
-        """Arguments required for start task execution from triggerer."""
-
-        trigger_cls: str
-        next_method: str
-        trigger_kwargs: dict[str, Any] | None = None
-        next_kwargs: dict[str, Any] | None = None
-        timeout: datetime.timedelta | None = None
-
+from airflow.triggers.base import StartTriggerArgs
 
 if TYPE_CHECKING:
     from airflow.sdk import Context

airflow/providers/standard/sensors/time.py

@@ -19,28 +19,12 @@ from __future__ import annotations
 
 import datetime
 import warnings
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from airflow.configuration import conf
 from airflow.exceptions import AirflowProviderDeprecationWarning
-from airflow.providers.common.compat.sdk import BaseSensorOperator, timezone
+from airflow.providers.common.compat.sdk import BaseSensorOperator, conf, timezone
 from airflow.providers.standard.triggers.temporal import DateTimeTrigger
-
-try:
-    from airflow.triggers.base import StartTriggerArgs  # type: ignore[no-redef]
-except ImportError:  # TODO: Remove this when min airflow version is 2.10.0 for standard provider
-
-    @dataclass
-    class StartTriggerArgs:  # type: ignore[no-redef]
-        """Arguments required for start task execution from triggerer."""
-
-        trigger_cls: str
-        next_method: str
-        trigger_kwargs: dict[str, Any] | None = None
-        next_kwargs: dict[str, Any] | None = None
-        timeout: datetime.timedelta | None = None
-
+from airflow.triggers.base import StartTriggerArgs
 
 if TYPE_CHECKING:
     from airflow.sdk import Context

airflow/providers/standard/sensors/time_delta.py

@@ -25,9 +25,8 @@ from typing import TYPE_CHECKING, Any
 from deprecated.classic import deprecated
 from packaging.version import Version
 
-from airflow.configuration import conf
-from airflow.exceptions import AirflowProviderDeprecationWarning, AirflowSkipException
-from airflow.providers.common.compat.sdk import BaseSensorOperator, timezone
+from airflow.exceptions import AirflowProviderDeprecationWarning
+from airflow.providers.common.compat.sdk import AirflowSkipException, BaseSensorOperator, conf, timezone
 from airflow.providers.standard.triggers.temporal import DateTimeTrigger, TimeDeltaTrigger
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
 
@@ -194,9 +193,11 @@ class WaitSensor(BaseSensorOperator):
     def execute(self, context: Context) -> None:
         if self.deferrable:
             self.defer(
-                trigger=TimeDeltaTrigger(self.time_to_wait, end_from_trigger=True)
-                if AIRFLOW_V_3_0_PLUS
-                else TimeDeltaTrigger(self.time_to_wait),
+                trigger=(
+                    TimeDeltaTrigger(self.time_to_wait, end_from_trigger=True)
+                    if AIRFLOW_V_3_0_PLUS
+                    else TimeDeltaTrigger(self.time_to_wait)
+                ),
                 method_name="execute_complete",
             )
         else:

airflow/providers/standard/triggers/external_task.py

@@ -226,23 +226,26 @@ class DagStateTrigger(BaseTrigger):
         elif self.execution_dates:
             runs_ids_or_dates = len(self.execution_dates)
 
+        cls_path, data = self.serialize()
+
         if AIRFLOW_V_3_0_PLUS:
-            data = await self.validate_count_dags_af_3(runs_ids_or_dates_len=runs_ids_or_dates)
-            yield TriggerEvent(data)
+            data.update(  # update with {run_id: run_state} dict
+                await self.validate_count_dags_af_3(runs_ids_or_dates_len=runs_ids_or_dates)
+            )
+            yield TriggerEvent((cls_path, data))
             return
         else:
             while True:
                 num_dags = await self.count_dags()
                 if num_dags == runs_ids_or_dates:
-                    yield TriggerEvent(self.serialize())
+                    yield TriggerEvent((cls_path, data))
                     return
                 await asyncio.sleep(self.poll_interval)
 
-    async def validate_count_dags_af_3(self, runs_ids_or_dates_len: int = 0) -> dict[str, typing.Any]:
+    async def validate_count_dags_af_3(self, runs_ids_or_dates_len: int = 0) -> dict[str, str]:
         from airflow.sdk.execution_time.task_runner import RuntimeTaskInstance
 
-        cls_path, data = self.serialize()
-
+        run_states: dict[str, str] = {}  # {run_id: run_state}
         while True:
             num_dags = await sync_to_async(RuntimeTaskInstance.get_dr_count)(
                 dag_id=self.dag_id,
@@ -257,8 +260,8 @@ class DagStateTrigger(BaseTrigger):
                             dag_id=self.dag_id,
                             run_id=run_id,
                         )
-                        data[run_id] = state
-                        return data
+                        run_states[run_id] = state
+                        return run_states
             await asyncio.sleep(self.poll_interval)
 
     if not AIRFLOW_V_3_0_PLUS:

airflow/providers/standard/triggers/hitl.py

@@ -16,7 +16,7 @@
 # under the License.
 from __future__ import annotations
 
-from airflow.exceptions import AirflowOptionalProviderFeatureException
+from airflow.providers.common.compat.sdk import AirflowOptionalProviderFeatureException
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_1_PLUS
 
 if not AIRFLOW_V_3_1_PLUS:
@@ -30,7 +30,7 @@ from uuid import UUID
 
 from asgiref.sync import sync_to_async
 
-from airflow.exceptions import ParamValidationError
+from airflow.providers.common.compat.sdk import ParamValidationError
 from airflow.sdk import Param
 from airflow.sdk.definitions.param import ParamsDict
 from airflow.sdk.execution_time.hitl import (

airflow/providers/standard/utils/openlineage.py

@@ -0,0 +1,185 @@
+# 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 logging
+from typing import TYPE_CHECKING
+
+from airflow.providers.common.compat.openlineage.check import require_openlineage_version
+from airflow.providers.common.compat.sdk import AirflowOptionalProviderFeatureException
+
+if TYPE_CHECKING:
+    from airflow.models import TaskInstance
+    from airflow.sdk.types import RuntimeTaskInstanceProtocol as RuntimeTI
+
+log = logging.getLogger(__name__)
+
+OPENLINEAGE_PROVIDER_MIN_VERSION = "2.8.0"
+
+
+def _is_openlineage_provider_accessible() -> bool:
+    """
+    Check if the OpenLineage provider is accessible.
+
+    This function attempts to import the necessary OpenLineage modules and checks if the provider
+    is enabled and the listener is available.
+
+    Returns:
+        bool: True if the OpenLineage provider is accessible, False otherwise.
+    """
+    try:
+        from airflow.providers.openlineage.conf import is_disabled
+        from airflow.providers.openlineage.plugins.listener import get_openlineage_listener
+    except (ImportError, AttributeError):
+        log.debug("OpenLineage provider could not be imported.")
+        return False
+
+    if is_disabled():
+        log.debug("OpenLineage provider is disabled.")
+        return False
+
+    if not get_openlineage_listener():
+        log.debug("OpenLineage listener could not be found.")
+        return False
+
+    return True
+
+
+@require_openlineage_version(provider_min_version=OPENLINEAGE_PROVIDER_MIN_VERSION)
+def _get_openlineage_parent_info(ti: TaskInstance | RuntimeTI) -> dict[str, str]:
+    """Get OpenLineage metadata about the parent task."""
+    from airflow.providers.openlineage.plugins.macros import (
+        lineage_job_name,
+        lineage_job_namespace,
+        lineage_root_job_name,
+        lineage_root_job_namespace,
+        lineage_root_run_id,
+        lineage_run_id,
+    )
+
+    return {
+        "parentRunId": lineage_run_id(ti),
+        "parentJobName": lineage_job_name(ti),
+        "parentJobNamespace": lineage_job_namespace(),
+        "rootParentRunId": lineage_root_run_id(ti),
+        "rootParentJobName": lineage_root_job_name(ti),
+        "rootParentJobNamespace": lineage_root_job_namespace(ti),
+    }
+
+
+def _inject_openlineage_parent_info_to_dagrun_conf(
+    dr_conf: dict | None, ol_parent_info: dict[str, str]
+) -> dict:
+    """
+    Safely inject OpenLineage parent and root run metadata into a DAG run configuration.
+
+    This function adds parent and root job/run identifiers derived from the given TaskInstance into the
+    `openlineage` section of the DAG run configuration. If an `openlineage` key already exists, it is
+    preserved and extended, but no existing parent or root identifiers are overwritten.
+
+    The function performs several safety checks:
+    - If conf is not a dictionary or contains a non-dict `openlineage` section, conf is returned unmodified.
+    - If `openlineage` section contains any parent/root lineage identifiers, conf is returned unmodified.
+
+    Args:
+        dr_conf: The original DAG run configuration dictionary or None.
+        ol_parent_info: OpenLineage metadata about the parent task
+
+    Returns:
+        A modified DAG run conf with injected OpenLineage parent and root metadata,
+        or the original conf if injection is not possible.
+    """
+    current_ol_dr_conf = {}
+    if isinstance(dr_conf, dict) and dr_conf.get("openlineage"):
+        current_ol_dr_conf = dr_conf["openlineage"]
+        if not isinstance(current_ol_dr_conf, dict):
+            log.warning(
+                "Existing 'openlineage' section of DagRun conf is not a dictionary; "
+                "skipping injection of parent metadata."
+            )
+            return dr_conf
+        forbidden_keys = (
+            "parentRunId",
+            "parentJobName",
+            "parentJobNamespace",
+            "rootParentRunId",
+            "rootJobName",
+            "rootJobNamespace",
+        )
+
+        if existing := [k for k in forbidden_keys if k in current_ol_dr_conf]:
+            log.warning(
+                "'openlineage' section of DagRun conf already contains parent or root "
+                "identifiers: `%s`; skipping injection to avoid overwriting existing values.",
+                ", ".join(existing),
+            )
+            return dr_conf
+
+    return {**(dr_conf or {}), **{"openlineage": {**ol_parent_info, **current_ol_dr_conf}}}
+
+
+def safe_inject_openlineage_properties_into_dagrun_conf(
+    dr_conf: dict | None, ti: TaskInstance | RuntimeTI | None
+) -> dict | None:
+    """
+    Safely inject OpenLineage parent task metadata into a DAG run conf.
+
+    This function checks whether the OpenLineage provider is accessible and supports parent information
+    injection. If so, it enriches the DAG run conf with OpenLineage metadata about the parent task
+    to improve lineage tracking. The function does not modify other conf fields, will not overwrite
+    any existing content, and safely returns the original configuration if OpenLineage is unavailable,
+    unsupported, or an error occurs during injection.
+
+    :param dr_conf: The original DAG run configuration dictionary.
+    :param ti: The TaskInstance whose metadata may be injected.
+
+    :return: A potentially enriched DAG run conf with OpenLineage parent information,
+        or the original conf if injection was skipped or failed.
+    """
+    try:
+        if ti is None:
+            log.debug("Task instance not provided - dagrun conf not modified.")
+            return dr_conf
+
+        if not _is_openlineage_provider_accessible():
+            log.debug("OpenLineage provider not accessible - dagrun conf not modified.")
+            return dr_conf
+
+        ol_parent_info = _get_openlineage_parent_info(ti=ti)
+
+        log.info("Injecting openlineage parent task information into dagrun conf.")
+        new_conf = _inject_openlineage_parent_info_to_dagrun_conf(
+            dr_conf=dr_conf.copy() if isinstance(dr_conf, dict) else dr_conf,
+            ol_parent_info=ol_parent_info,
+        )
+        return new_conf
+    except AirflowOptionalProviderFeatureException:
+        log.info(
+            "Current OpenLineage provider version doesn't support parent information in "
+            "the DagRun conf. Upgrade `apache-airflow-providers-openlineage>=%s` to use this feature. "
+            "DagRun conf has not been modified by OpenLineage.",
+            OPENLINEAGE_PROVIDER_MIN_VERSION,
+        )
+        return dr_conf
+    except Exception as e:
+        log.warning(
+            "An error occurred while trying to inject OpenLineage information into dagrun conf. "
+            "DagRun conf has not been modified by OpenLineage. Error: %s",
+            str(e),
+        )
+        log.debug("Error details: ", exc_info=e)
+        return dr_conf

airflow/providers/standard/utils/python_virtualenv.py

@@ -30,7 +30,7 @@ from pathlib import Path
 import jinja2
 from jinja2 import select_autoescape
 
-from airflow.configuration import conf
+from airflow.providers.common.compat.sdk import conf
 
 
 def _is_uv_installed() -> bool:
@@ -150,7 +150,7 @@ def _execute_in_subprocess(cmd: list[str], cwd: str | None = None, env: dict[str
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         bufsize=0,
-        close_fds=True,
+        close_fds=False,
         cwd=cwd,
         env=env,
     ) as proc:
@@ -200,9 +200,10 @@ def prepare_virtualenv(
 
     if _use_uv():
         venv_cmd = _generate_uv_cmd(venv_directory, python_bin, system_site_packages)
+        _execute_in_subprocess(venv_cmd, env={**os.environ, **_index_urls_to_uv_env_vars(index_urls)})
     else:
         venv_cmd = _generate_venv_cmd(venv_directory, python_bin, system_site_packages)
-    _execute_in_subprocess(venv_cmd)
+        _execute_in_subprocess(venv_cmd)
 
     pip_cmd = None
     if requirements is not None and len(requirements) != 0:

airflow/providers/standard/utils/python_virtualenv_script.jinja2

@@ -40,6 +40,23 @@ if sys.version_info >= (3,6):
         pass
 {% endif %}
 
+try:
+    from airflow.sdk.execution_time import task_runner
+except ModuleNotFoundError:
+    pass
+else:
+  {#-
+    We are in an Airflow 3.x environment, try and set up supervisor comms so
+    virtualenv can access Vars/Conn/XCom/etc that normal tasks can
+
+    We don't use the walrus operator (`:=`) below as it is possible people can
+    be using this on pre-3.8 versions of python, and while Airflow doesn't
+    support them, it's easy to not break it not using that operator here.
+  #}
+  reinit_supervisor_comms = getattr(task_runner, "reinit_supervisor_comms", None)
+  if reinit_supervisor_comms:
+      reinit_supervisor_comms()
+
 # Script
 {{ python_callable_source }}
 
@@ -49,12 +66,10 @@ if sys.version_info >= (3,6):
 import types
 
 {{ modified_dag_module_name }}  = types.ModuleType("{{ modified_dag_module_name }}")
-
 {{ modified_dag_module_name }}.{{ python_callable }} = {{ python_callable }}
-
 sys.modules["{{modified_dag_module_name}}"] = {{modified_dag_module_name}}
 
-{% endif%}
+{%- endif -%}
 
 {% if op_args or op_kwargs %}
 with open(sys.argv[1], "rb") as file:

airflow/providers/standard/utils/skipmixin.py

@@ -21,7 +21,7 @@ from collections.abc import Iterable, Sequence
 from types import GeneratorType
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowException
+from airflow.providers.common.compat.sdk import AirflowException
 from airflow.utils.log.logging_mixin import LoggingMixin
 
 if TYPE_CHECKING:
@@ -63,7 +63,7 @@ class SkipMixin(LoggingMixin):
         """
         # Import is internal for backward compatibility when importing PythonOperator
         # from airflow.providers.common.compat.standard.operators
-        from airflow.exceptions import DownstreamTasksSkipped
+        from airflow.providers.common.compat.sdk import DownstreamTasksSkipped
 
         #  The following could be applied only for non-mapped tasks,
         #  as future mapped tasks have not been expanded yet. Such tasks

{apache_airflow_providers_standard-1.9.2rc1.dist-info → apache_airflow_providers_standard-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-standard
-Version: 1.9.2rc1
+Version: 1.11.0
 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>
@@ -22,15 +22,17 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Monitoring
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: apache-airflow>=2.10.0rc1
-Requires-Dist: apache-airflow-providers-common-compat>=1.8.0rc1
+Requires-Dist: apache-airflow>=2.11.0
+Requires-Dist: apache-airflow-providers-common-compat>=1.13.0
+Requires-Dist: apache-airflow-providers-openlineage ; extra == "openlineage"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.staged.apache.org/docs/apache-airflow-providers-standard/1.9.2/changelog.html
-Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-standard/1.9.2
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/1.11.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/1.11.0
 Project-URL: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
 Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
+Provides-Extra: openlineage
 
 
 .. Licensed to the Apache Software Foundation (ASF) under one
@@ -57,7 +59,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-standard``
 
-Release: ``1.9.2``
+Release: ``1.11.0``
 
 
 Airflow Standard Provider
@@ -70,7 +72,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/1.9.2/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.11.0/>`_.
 
 Installation
 ------------
@@ -87,8 +89,8 @@ Requirements
 ==========================================  ==================
 PIP package                                 Version required
 ==========================================  ==================
-``apache-airflow``                          ``>=2.10.0``
-``apache-airflow-providers-common-compat``  ``>=1.8.0``
+``apache-airflow``                          ``>=2.11.0``
+``apache-airflow-providers-common-compat``  ``>=1.13.0``
 ==========================================  ==================
 
 Cross provider package dependencies
@@ -108,8 +110,18 @@ You can install such cross-provider dependencies when installing from PyPI. For
 Dependent package                                                                                                   Extra
 ==================================================================================================================  =================
 `apache-airflow-providers-common-compat <https://airflow.apache.org/docs/apache-airflow-providers-common-compat>`_  ``common.compat``
+`apache-airflow-providers-openlineage <https://airflow.apache.org/docs/apache-airflow-providers-openlineage>`_      ``openlineage``
 ==================================================================================================================  =================
 
+Optional dependencies
+----------------------
+
+===============  ========================================
+Extra            Dependencies
+===============  ========================================
+``openlineage``  ``apache-airflow-providers-openlineage``
+===============  ========================================
+
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.9.2/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.11.0/changelog.html>`_.