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

airflow/providers/standard/__init__.py

@@ -29,11 +29,11 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "1.9.2"
+__version__ = "1.11.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
-    "2.10.0"
+    "2.11.0"
 ):
     raise RuntimeError(
-        f"The package `apache-airflow-providers-standard:{__version__}` needs Apache Airflow 2.10.0+"
+        f"The package `apache-airflow-providers-standard:{__version__}` needs Apache Airflow 2.11.0+"
     )

airflow/providers/standard/decorators/bash.py

@@ -89,8 +89,7 @@ class _BashDecoratedOperator(DecoratedOperator, BashOperator):
             raise TypeError("The returned value from the TaskFlow callable must be a non-empty string.")
 
         self._is_inline_cmd = self._is_inline_command(bash_command=self.bash_command)
-        context["ti"].render_templates()  # type: ignore[attr-defined]
-
+        self.render_template_fields(context)
         return super().execute(context)
 
 

airflow/providers/standard/example_dags/example_bash_decorator.py

@@ -19,11 +19,11 @@ from __future__ import annotations
 
 import pendulum
 
-from airflow.exceptions import AirflowSkipException
 from airflow.providers.common.compat.sdk import TriggerRule
 from airflow.providers.standard.operators.empty import EmptyOperator
 from airflow.providers.standard.utils.weekday import WeekDay
 from airflow.sdk import chain, dag, task
+from airflow.sdk.exceptions import AirflowSkipException
 
 
 @dag(schedule=None, start_date=pendulum.datetime(2023, 1, 1, tz="UTC"), catchup=False)

airflow/providers/standard/example_dags/example_python_decorator.py

@@ -22,6 +22,7 @@ virtual environment.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import sys
 import time
@@ -75,6 +76,22 @@ def example_python_decorator():
         run_this >> log_the_sql >> sleeping_task
     # [END howto_operator_python_kwargs]
 
+    # [START howto_async_operator_python_kwargs]
+    # Generate 5 sleeping tasks, sleeping from 0.0 to 0.4 seconds respectively
+    # Asynchronous callables are natively supported since Airflow 3.2+
+    @task
+    async def my_async_sleeping_function(random_base):
+        """This is a function that will run within the DAG execution"""
+        await asyncio.sleep(random_base)
+
+    for i in range(5):
+        async_sleeping_task = my_async_sleeping_function.override(task_id=f"async_sleep_for_{i}")(
+            random_base=i / 10
+        )
+
+        run_this >> log_the_sql >> async_sleeping_task
+    # [END howto_async_operator_python_kwargs]
+
     # [START howto_operator_python_venv]
     @task.virtualenv(
         task_id="virtualenv_python", requirements=["colorama==0.4.0"], system_site_packages=False

airflow/providers/standard/example_dags/example_python_operator.py

@@ -22,6 +22,7 @@ within a virtual environment.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import sys
 import time
@@ -88,6 +89,23 @@ with DAG(
         run_this >> log_the_sql >> sleeping_task
     # [END howto_operator_python_kwargs]
 
+    # [START howto_async_operator_python_kwargs]
+    # Generate 5 sleeping tasks, sleeping from 0.0 to 0.4 seconds respectively
+    # Asynchronous callables are natively supported since Airflow 3.2+
+    async def my_async_sleeping_function(random_base):
+        """This is a function that will run within the DAG execution"""
+        await asyncio.sleep(random_base)
+
+    for i in range(5):
+        async_sleeping_task = PythonOperator(
+            task_id=f"async_sleep_for_{i}",
+            python_callable=my_async_sleeping_function,
+            op_kwargs={"random_base": i / 10},
+        )
+
+        run_this >> log_the_sql >> async_sleeping_task
+    # [END howto_async_operator_python_kwargs]
+
     # [START howto_operator_python_venv]
     def callable_virtualenv():
         """

airflow/providers/standard/exceptions.py

@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-from airflow.exceptions import AirflowException
+from airflow.providers.common.compat.sdk import AirflowException
 
 
 class AirflowExternalTaskSensorException(AirflowException):

airflow/providers/standard/get_provider_info.py

@@ -34,6 +34,7 @@ def get_provider_info():
                 "how-to-guide": [
                     "/docs/apache-airflow-providers-standard/operators/bash.rst",
                     "/docs/apache-airflow-providers-standard/operators/python.rst",
+                    "/docs/apache-airflow-providers-standard/operators/hitl.rst",
                     "/docs/apache-airflow-providers-standard/operators/datetime.rst",
                     "/docs/apache-airflow-providers-standard/operators/trigger_dag_run.rst",
                     "/docs/apache-airflow-providers-standard/operators/latest_only.rst",

airflow/providers/standard/operators/bash.py

@@ -24,14 +24,18 @@ from collections.abc import Callable, Container, Sequence
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, cast
 
-from airflow.exceptions import AirflowException, AirflowSkipException
-from airflow.providers.common.compat.sdk import context_to_airflow_vars
+from airflow.providers.common.compat.sdk import (
+    AirflowException,
+    AirflowSkipException,
+    context_to_airflow_vars,
+)
 from airflow.providers.standard.hooks.subprocess import SubprocessHook, SubprocessResult, working_directory
 from airflow.providers.standard.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     from airflow.providers.common.compat.sdk import Context
-    from airflow.utils.types import ArgNotSet
+
+    from tests_common.test_utils.version_compat import ArgNotSet
 
 
 class BashOperator(BaseOperator):

airflow/providers/standard/operators/datetime.py

@@ -20,8 +20,7 @@ import datetime
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowException
-from airflow.providers.common.compat.sdk import timezone
+from airflow.providers.common.compat.sdk import AirflowException, timezone
 from airflow.providers.standard.operators.branch import BaseBranchOperator
 
 if TYPE_CHECKING:

airflow/providers/standard/operators/hitl.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import logging
 
-from airflow.exceptions import AirflowOptionalProviderFeatureException
+from airflow.providers.common.compat.sdk import AirflowOptionalProviderFeatureException
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_1_3_PLUS, AIRFLOW_V_3_1_PLUS
 
 if not AIRFLOW_V_3_1_PLUS:
@@ -28,7 +28,7 @@ from collections.abc import Collection, Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 from urllib.parse import ParseResult, urlencode, urlparse, urlunparse
 
-from airflow.configuration import conf
+from airflow.providers.common.compat.sdk import conf
 from airflow.providers.standard.exceptions import HITLRejectException, HITLTimeoutError, HITLTriggerEventError
 from airflow.providers.standard.operators.branch import BranchMixIn
 from airflow.providers.standard.triggers.hitl import HITLTrigger, HITLTriggerEventSuccessPayload
@@ -84,6 +84,13 @@ class HITLOperator(BaseOperator):
         self.multiple = multiple
 
         self.params: ParamsDict = params if isinstance(params, ParamsDict) else ParamsDict(params or {})
+        if hasattr(ParamsDict, "filter_params_by_source"):
+            # Params that exist only in Dag level does not make sense to appear in HITLOperator
+            self.params = ParamsDict.filter_params_by_source(self.params, source="task")
+        elif self.params:
+            self.log.debug(
+                "ParamsDict.filter_params_by_source not available; HITLOperator will also include Dag level params."
+            )
 
         self.notifiers: Sequence[BaseNotifier] = (
             [notifiers] if isinstance(notifiers, BaseNotifier) else notifiers or []

airflow/providers/standard/operators/latest_only.py

@@ -26,7 +26,7 @@ from typing import TYPE_CHECKING
 import pendulum
 
 from airflow.providers.standard.operators.branch import BaseBranchOperator
-from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS, AIRFLOW_V_3_2_PLUS
 from airflow.utils.types import DagRunType
 
 if TYPE_CHECKING:
@@ -35,6 +35,17 @@ if TYPE_CHECKING:
     from airflow.models import DagRun
     from airflow.providers.common.compat.sdk import Context
 
+if AIRFLOW_V_3_2_PLUS:
+
+    def _get_dag_timetable(dag):
+        from airflow.serialization.encoders import coerce_to_core_timetable
+
+        return coerce_to_core_timetable(dag.timetable)
+else:
+
+    def _get_dag_timetable(dag):
+        return dag.timetable
+
 
 class LatestOnlyOperator(BaseBranchOperator):
     """
@@ -104,15 +115,13 @@ class LatestOnlyOperator(BaseBranchOperator):
         else:
             end = dagrun_date
 
-        current_interval = DataInterval(
-            start=start,
-            end=end,
-        )
-
+        timetable = _get_dag_timetable(self.dag)
+        current_interval = DataInterval(start=start, end=end)
         time_restriction = TimeRestriction(
             earliest=None, latest=current_interval.end - timedelta(microseconds=1), catchup=True
         )
-        if prev_info := self.dag.timetable.next_dagrun_info(
+
+        if prev_info := timetable.next_dagrun_info(
             last_automated_data_interval=current_interval,
             restriction=time_restriction,
         ):
@@ -121,7 +130,7 @@ class LatestOnlyOperator(BaseBranchOperator):
             left = current_interval.start
 
         time_restriction = TimeRestriction(earliest=current_interval.end, latest=None, catchup=True)
-        next_info = self.dag.timetable.next_dagrun_info(
+        next_info = timetable.next_dagrun_info(
             last_automated_data_interval=current_interval,
             restriction=time_restriction,
         )

airflow/providers/standard/operators/python.py

@@ -43,20 +43,22 @@ from packaging.version import InvalidVersion
 
 from airflow.exceptions import (
     AirflowConfigException,
-    AirflowException,
     AirflowProviderDeprecationWarning,
-    AirflowSkipException,
     DeserializingResultError,
 )
 from airflow.models.variable import Variable
-from airflow.providers.common.compat.sdk import context_merge
+from airflow.providers.common.compat.sdk import AirflowException, AirflowSkipException, context_merge
+from airflow.providers.common.compat.standard.operators import (
+    BaseAsyncOperator,
+    is_async_callable,
+)
 from airflow.providers.standard.hooks.package_index import PackageIndexHook
 from airflow.providers.standard.utils.python_virtualenv import (
     _execute_in_subprocess,
     prepare_virtualenv,
     write_python_script,
 )
-from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS, BaseOperator
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS, AIRFLOW_V_3_2_PLUS
 from airflow.utils import hashlib_wrapper
 from airflow.utils.file import get_unique_dag_module_name
 from airflow.utils.operator_helpers import KeywordParameters
@@ -77,7 +79,10 @@ if TYPE_CHECKING:
     from pendulum.datetime import DateTime
 
     from airflow.providers.common.compat.sdk import Context
-    from airflow.sdk.execution_time.callback_runner import ExecutionCallableRunner
+    from airflow.sdk.execution_time.callback_runner import (
+        AsyncExecutionCallableRunner,
+        ExecutionCallableRunner,
+    )
     from airflow.sdk.execution_time.context import OutletEventAccessorsProtocol
 
     _SerializerTypeDef = Literal["pickle", "cloudpickle", "dill"]
@@ -117,9 +122,9 @@ class _PythonVersionInfo(NamedTuple):
         return cls(*_parse_version_info(result.strip()))
 
 
-class PythonOperator(BaseOperator):
+class PythonOperator(BaseAsyncOperator):
     """
-    Executes a Python callable.
+    Base class for all Python operators.
 
     .. seealso::
         For more information on how to use this operator, take a look at the guide:
@@ -194,7 +199,14 @@ class PythonOperator(BaseOperator):
             self.template_ext = templates_exts
         self.show_return_value_in_logs = show_return_value_in_logs
 
-    def execute(self, context: Context) -> Any:
+    @property
+    def is_async(self) -> bool:
+        return is_async_callable(self.python_callable)
+
+    def execute(self, context) -> Any:
+        if self.is_async:
+            return BaseAsyncOperator.execute(self, context)
+
         context_merge(context, self.op_kwargs, templates_dict=self.templates_dict)
         self.op_kwargs = self.determine_kwargs(context)
 
@@ -238,6 +250,47 @@ class PythonOperator(BaseOperator):
         runner = create_execution_runner(self.python_callable, asset_events, logger=self.log)
         return runner.run(*self.op_args, **self.op_kwargs)
 
+    if AIRFLOW_V_3_2_PLUS:
+
+        async def aexecute(self, context):
+            context_merge(context, self.op_kwargs, templates_dict=self.templates_dict)
+            self.op_kwargs = self.determine_kwargs(context)
+
+            # This needs to be lazy because subclasses may implement execute_callable
+            # by running a separate process that can't use the eager result.
+            def __prepare_execution() -> (
+                tuple[AsyncExecutionCallableRunner, OutletEventAccessorsProtocol] | None
+            ):
+                from airflow.sdk.execution_time.callback_runner import create_async_executable_runner
+                from airflow.sdk.execution_time.context import context_get_outlet_events
+
+                return (
+                    cast("AsyncExecutionCallableRunner", create_async_executable_runner),
+                    context_get_outlet_events(context),
+                )
+
+            self.__prepare_execution = __prepare_execution
+
+            return_value = await self.aexecute_callable()
+            if self.show_return_value_in_logs:
+                self.log.info("Done. Returned value was: %s", return_value)
+            else:
+                self.log.info("Done. Returned value not shown")
+
+            return return_value
+
+        async def aexecute_callable(self) -> Any:
+            """
+            Call the python callable with the given arguments.
+
+            :return: the return value of the call.
+            """
+            if (execution_preparation := self.__prepare_execution()) is None:
+                return await self.python_callable(*self.op_args, **self.op_kwargs)
+            create_execution_runner, asset_events = execution_preparation
+            runner = create_execution_runner(self.python_callable, asset_events, logger=self.log)
+            return await runner.run(*self.op_args, **self.op_kwargs)
+
 
 class BranchPythonOperator(BaseBranchOperator, PythonOperator):
     """
@@ -488,8 +541,28 @@ class _BasePythonVirtualenvOperator(PythonOperator, metaclass=ABCMeta):
         serializable_keys = set(self._iter_serializable_context_keys())
         new = {k: v for k, v in context.items() if k in serializable_keys}
         serializable_context = cast("Context", new)
+        # Store bundle_path for subprocess execution
+        self._bundle_path = self._get_bundle_path_from_context(context)
         return super().execute(context=serializable_context)
 
+    def _get_bundle_path_from_context(self, context: Context) -> str | None:
+        """
+        Extract bundle_path from the task instance's bundle_instance.
+
+        :param context: The task execution context
+        :return: Path to the bundle root directory, or None if not in a bundle
+        """
+        if not AIRFLOW_V_3_0_PLUS:
+            return None
+
+        # In Airflow 3.x, the RuntimeTaskInstance has a bundle_instance attribute
+        # that contains the bundle information including its path
+        ti = context["ti"]
+        if bundle_instance := getattr(ti, "bundle_instance", None):
+            return bundle_instance.path
+
+        return None
+
     def get_python_source(self):
         """Return the source of self.python_callable."""
         return textwrap.dedent(inspect.getsource(self.python_callable))
@@ -562,9 +635,21 @@ class _BasePythonVirtualenvOperator(PythonOperator, metaclass=ABCMeta):
             )
 
             env_vars = dict(os.environ) if self.inherit_env else {}
+            if fd := os.getenv("__AIRFLOW_SUPERVISOR_FD"):
+                env_vars["__AIRFLOW_SUPERVISOR_FD"] = fd
             if self.env_vars:
                 env_vars.update(self.env_vars)
 
+            # Add bundle_path to PYTHONPATH for subprocess to import Dag bundle modules
+            if self._bundle_path:
+                bundle_path = self._bundle_path
+                existing_pythonpath = env_vars.get("PYTHONPATH", "")
+                if existing_pythonpath:
+                    # Append bundle_path after existing PYTHONPATH
+                    env_vars["PYTHONPATH"] = f"{existing_pythonpath}{os.pathsep}{bundle_path}"
+                else:
+                    env_vars["PYTHONPATH"] = bundle_path
+
             try:
                 cmd: list[str] = [
                     os.fspath(python_path),

airflow/providers/standard/operators/trigger_dagrun.py

@@ -28,21 +28,28 @@ from sqlalchemy import select
 from sqlalchemy.orm.exc import NoResultFound
 
 from airflow.api.common.trigger_dag import trigger_dag
-from airflow.configuration import conf
-from airflow.exceptions import (
-    AirflowException,
-    AirflowSkipException,
-    DagNotFound,
-    DagRunAlreadyExists,
-)
+from airflow.exceptions import DagNotFound, DagRunAlreadyExists
 from airflow.models.dag import DagModel
 from airflow.models.dagrun import DagRun
 from airflow.models.serialized_dag import SerializedDagModel
-from airflow.providers.common.compat.sdk import BaseOperatorLink, XCom, timezone
+from airflow.providers.common.compat.sdk import (
+    AirflowException,
+    AirflowSkipException,
+    BaseOperatorLink,
+    XCom,
+    conf,
+    timezone,
+)
 from airflow.providers.standard.triggers.external_task import DagStateTrigger
+from airflow.providers.standard.utils.openlineage import safe_inject_openlineage_properties_into_dagrun_conf
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS, BaseOperator
 from airflow.utils.state import DagRunState
-from airflow.utils.types import NOTSET, ArgNotSet, DagRunType
+from airflow.utils.types import DagRunType
+
+try:
+    from airflow.sdk.definitions._internal.types import NOTSET, ArgNotSet
+except ImportError:
+    from airflow.utils.types import NOTSET, ArgNotSet  # type: ignore[attr-defined,no-redef]
 
 XCOM_LOGICAL_DATE_ISO = "trigger_logical_date_iso"
 XCOM_RUN_ID = "trigger_run_id"
@@ -51,8 +58,7 @@ XCOM_RUN_ID = "trigger_run_id"
 if TYPE_CHECKING:
     from sqlalchemy.orm.session 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 DagIsPaused(AirflowException):
@@ -82,8 +88,17 @@ class TriggerDagRunLink(BaseOperatorLink):
         trigger_dag_id = operator.trigger_dag_id
         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):
                 trigger_dag_id: str = template_fields.get("trigger_dag_id", operator.trigger_dag_id)  # type: ignore[no-redef]
 
         # Fetch the correct dag_run_id for the triggerED dag which is
@@ -129,8 +144,13 @@ class TriggerDagRunOperator(BaseOperator):
     :param skip_when_already_exists: Set to true to mark the task as SKIPPED if a DAG run of the triggered
         DAG for the same logical date already exists.
     :param fail_when_dag_is_paused: If the dag to trigger is paused, DagIsPaused will be raised.
-    :param deferrable: If waiting for completion, whether or not to defer the task until done,
-        default is ``False``.
+    :param deferrable: If waiting for completion, whether to defer the task until done, default is ``False``.
+    :param openlineage_inject_parent_info: whether to include OpenLineage metadata about the parent task
+        in the triggered DAG run's conf, enabling improved lineage tracking. The metadata is only injected
+        if OpenLineage is enabled and running. This option does not modify any other part of the conf,
+        and existing OpenLineage-related settings in the conf will not be overwritten. The injection process
+        is safeguarded against exceptions - if any error occurs during metadata injection, it is gracefully
+        handled and the conf remains unchanged - so it's safe to use. Default is ``True``
     """
 
     template_fields: Sequence[str] = (
@@ -160,6 +180,7 @@ class TriggerDagRunOperator(BaseOperator):
         skip_when_already_exists: bool = False,
         fail_when_dag_is_paused: bool = False,
         deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
+        openlineage_inject_parent_info: bool = True,
         **kwargs,
     ) -> None:
         super().__init__(**kwargs)
@@ -179,7 +200,8 @@ class TriggerDagRunOperator(BaseOperator):
             self.failed_states = [DagRunState.FAILED]
         self.skip_when_already_exists = skip_when_already_exists
         self.fail_when_dag_is_paused = fail_when_dag_is_paused
-        self._defer = deferrable
+        self.openlineage_inject_parent_info = openlineage_inject_parent_info
+        self.deferrable = deferrable
         self.logical_date = logical_date
         if logical_date is NOTSET:
             self.logical_date = NOTSET
@@ -209,6 +231,12 @@ class TriggerDagRunOperator(BaseOperator):
         except (TypeError, JSONDecodeError):
             raise ValueError("conf parameter should be JSON Serializable %s", self.conf)
 
+        if self.openlineage_inject_parent_info:
+            self.log.debug("Checking if OpenLineage information can be safely injected into dagrun conf.")
+            self.conf = safe_inject_openlineage_properties_into_dagrun_conf(
+                dr_conf=self.conf, ti=context.get("ti")
+            )
+
         if self.trigger_run_id:
             run_id = str(self.trigger_run_id)
         else:
@@ -221,6 +249,9 @@ class TriggerDagRunOperator(BaseOperator):
             else:
                 run_id = DagRun.generate_run_id(DagRunType.MANUAL, parsed_logical_date or timezone.utcnow())  # type: ignore[misc,call-arg]
 
+        # Save run_id as task attribute - to be used by listeners
+        self.trigger_run_id = run_id
+
         if self.fail_when_dag_is_paused:
             dag_model = DagModel.get_current(self.trigger_dag_id)
             if not dag_model:
@@ -232,12 +263,16 @@ class TriggerDagRunOperator(BaseOperator):
                 raise AirflowException(f"Dag {self.trigger_dag_id} is paused")
 
         if AIRFLOW_V_3_0_PLUS:
-            self._trigger_dag_af_3(context=context, run_id=run_id, parsed_logical_date=parsed_logical_date)
+            self._trigger_dag_af_3(
+                context=context, run_id=self.trigger_run_id, parsed_logical_date=parsed_logical_date
+            )
         else:
-            self._trigger_dag_af_2(context=context, run_id=run_id, parsed_logical_date=parsed_logical_date)
+            self._trigger_dag_af_2(
+                context=context, run_id=self.trigger_run_id, parsed_logical_date=parsed_logical_date
+            )
 
     def _trigger_dag_af_3(self, context, run_id, parsed_logical_date):
-        from airflow.exceptions import DagRunTriggerException
+        from airflow.providers.common.compat.sdk import DagRunTriggerException
 
         raise DagRunTriggerException(
             trigger_dag_id=self.trigger_dag_id,
@@ -250,7 +285,7 @@ class TriggerDagRunOperator(BaseOperator):
             allowed_states=self.allowed_states,
             failed_states=self.failed_states,
             poke_interval=self.poke_interval,
-            deferrable=self._defer,
+            deferrable=self.deferrable,
         )
 
     def _trigger_dag_af_2(self, context, run_id, parsed_logical_date):
@@ -291,7 +326,7 @@ class TriggerDagRunOperator(BaseOperator):
 
         if self.wait_for_completion:
             # Kick off the deferral process
-            if self._defer:
+            if self.deferrable:
                 self.defer(
                     trigger=DagStateTrigger(
                         dag_id=self.trigger_dag_id,
@@ -322,17 +357,40 @@ class TriggerDagRunOperator(BaseOperator):
                     return
 
     def execute_complete(self, context: Context, event: tuple[str, dict[str, Any]]):
+        """
+        Handle task completion after returning from a deferral.
+
+        Args:
+            context: The Airflow context dictionary.
+            event: A tuple containing the class path of the trigger and the trigger event data.
+        """
+        # Example event tuple content:
+        # (
+        #  "airflow.providers.standard.triggers.external_task.DagStateTrigger",
+        #  {
+        #   'dag_id': 'some_dag',
+        #   'states': ['success', 'failed'],
+        #   'poll_interval': 15,
+        #   'run_ids': ['manual__2025-11-19T17:49:20.907083+00:00'],
+        #   'execution_dates': [
+        #    DateTime(2025, 11, 19, 17, 49, 20, 907083, tzinfo=Timezone('UTC'))
+        #   ]
+        #  }
+        # )
+        _, event_data = event
+        run_ids = event_data["run_ids"]
+        # Re-set as attribute after coming back from deferral - to be used by listeners.
+        # Just a safety check on length, we should always have single run_id here.
+        self.trigger_run_id = run_ids[0] if len(run_ids) == 1 else None
         if AIRFLOW_V_3_0_PLUS:
-            self._trigger_dag_run_af_3_execute_complete(event=event)
+            self._trigger_dag_run_af_3_execute_complete(event_data=event_data)
         else:
-            self._trigger_dag_run_af_2_execute_complete(event=event)
+            self._trigger_dag_run_af_2_execute_complete(event_data=event_data)
 
-    def _trigger_dag_run_af_3_execute_complete(self, event: tuple[str, dict[str, Any]]):
-        run_ids = event[1]["run_ids"]
-        event_data = event[1]
+    def _trigger_dag_run_af_3_execute_complete(self, event_data: dict[str, Any]):
         failed_run_id_conditions = []
 
-        for run_id in run_ids:
+        for run_id in event_data["run_ids"]:
             state = event_data.get(run_id)
             if state in self.failed_states:
                 failed_run_id_conditions.append(run_id)
@@ -356,10 +414,10 @@ class TriggerDagRunOperator(BaseOperator):
 
         @provide_session
         def _trigger_dag_run_af_2_execute_complete(
-            self, event: tuple[str, dict[str, Any]], session: Session = NEW_SESSION
+            self, event_data: dict[str, Any], session: Session = NEW_SESSION
         ):
             # This logical_date is parsed from the return trigger event
-            provided_logical_date = event[1]["execution_dates"][0]
+            provided_logical_date = event_data["execution_dates"][0]
             try:
                 # Note: here execution fails on database isolation mode. Needs structural changes for AIP-72
                 dag_run = session.execute(

airflow/providers/standard/sensors/bash.py

@@ -22,8 +22,7 @@ from subprocess import PIPE, STDOUT, Popen
 from tempfile import NamedTemporaryFile, TemporaryDirectory, gettempdir
 from typing import TYPE_CHECKING
 
-from airflow.exceptions import AirflowFailException
-from airflow.providers.common.compat.sdk import BaseSensorOperator
+from airflow.providers.common.compat.sdk import AirflowFailException, BaseSensorOperator
 
 if TYPE_CHECKING:
     from airflow.providers.common.compat.sdk import Context

airflow/providers/standard/sensors/date_time.py

@@ -19,27 +19,12 @@ from __future__ import annotations
 
 import datetime
 from collections.abc import Sequence
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, NoReturn
 
 from airflow.providers.common.compat.sdk import BaseSensorOperator, timezone
 from airflow.providers.standard.triggers.temporal import DateTimeTrigger
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
-
-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