apache-airflow-providers-standard 1.9.1rc1__py3-none-any.whl → 1.10.3__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.1"
+__version__ = "1.10.3"
 
 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/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/hooks/subprocess.py

@@ -77,14 +77,6 @@ class SubprocessHook(BaseHook):
         """
         self.log.info("Tmp dir root location: %s", gettempdir())
         with working_directory(cwd=cwd) as cwd:
-
-            def pre_exec():
-                # Restore default signal disposition and invoke setsid
-                for sig in ("SIGPIPE", "SIGXFZ", "SIGXFSZ"):
-                    if hasattr(signal, sig):
-                        signal.signal(getattr(signal, sig), signal.SIG_DFL)
-                os.setsid()
-
             self.log.info("Running command: %s", command)
 
             self.sub_process = Popen(
@@ -93,7 +85,8 @@ class SubprocessHook(BaseHook):
                 stderr=STDOUT,
                 cwd=cwd,
                 env=env if env or env == {} else os.environ,
-                preexec_fn=pre_exec,
+                start_new_session=True,
+                restore_signals=True,
             )
 
             self.log.info("Output:")

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,8 +18,8 @@ from __future__ import annotations
 
 import logging
 
-from airflow.exceptions import AirflowOptionalProviderFeatureException
-from airflow.providers.standard.version_compat import AIRFLOW_V_3_1_PLUS
+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:
     raise AirflowOptionalProviderFeatureException("Human in the loop functionality needs Airflow 3.1+.")
@@ -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,14 @@ 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 []
         )
@@ -110,6 +118,7 @@ class HITLOperator(BaseOperator):
         Raises:
             ValueError: If `"_options"` key is present in `params`, which is not allowed.
         """
+        self.params.validate()
         if "_options" in self.params:
             raise ValueError('"_options" is not allowed in params')
 
@@ -165,8 +174,10 @@ class HITLOperator(BaseOperator):
         )
 
     @property
-    def serialized_params(self) -> dict[str, Any]:
-        return self.params.dump() if isinstance(self.params, ParamsDict) else self.params
+    def serialized_params(self) -> dict[str, dict[str, Any]]:
+        if not AIRFLOW_V_3_1_3_PLUS:
+            return self.params.dump() if isinstance(self.params, ParamsDict) else self.params
+        return {k: self.params.get_param(k).serialize() for k in self.params}
 
     def execute_complete(self, context: Context, event: dict[str, Any]) -> Any:
         if "error" in event:
@@ -196,13 +207,12 @@ class HITLOperator(BaseOperator):
 
     def validate_params_input(self, params_input: Mapping) -> None:
         """Check whether user provide valid params input."""
-        if (
-            self.serialized_params is not None
-            and params_input is not None
-            and set(self.serialized_params.keys()) ^ set(params_input)
-        ):
+        if self.params and params_input and set(self.serialized_params.keys()) ^ set(params_input):
             raise ValueError(f"params_input {params_input} does not match params {self.params}")
 
+        for key, value in params_input.items():
+            self.params[key] = value
+
     def generate_link_to_ui(
         self,
         *,

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):
     """
@@ -88,9 +99,9 @@ class LatestOnlyOperator(BaseBranchOperator):
     def _get_compare_dates(self, dag_run: DagRun) -> tuple[DateTime, DateTime] | None:
         dagrun_date: DateTime
         if AIRFLOW_V_3_0_PLUS:
-            dagrun_date = dag_run.logical_date or dag_run.run_after
+            dagrun_date = dag_run.logical_date or dag_run.run_after  # type: ignore[assignment]
         else:
-            dagrun_date = dag_run.logical_date
+            dagrun_date = dag_run.logical_date  # type: ignore[assignment]
 
         from airflow.timetables.base import DataInterval, TimeRestriction
 
@@ -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,21 @@ 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.standard.hooks.package_index import PackageIndexHook
-from airflow.providers.standard.utils.python_virtualenv import prepare_virtualenv, write_python_script
+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.utils import hashlib_wrapper
 from airflow.utils.file import get_unique_dag_module_name
 from airflow.utils.operator_helpers import KeywordParameters
-from airflow.utils.process_utils import execute_in_subprocess
 
 if AIRFLOW_V_3_0_PLUS:
     from airflow.providers.standard.operators.branch import BaseBranchOperator
@@ -485,8 +486,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))
@@ -559,9 +580,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),
@@ -572,7 +605,7 @@ class _BasePythonVirtualenvOperator(PythonOperator, metaclass=ABCMeta):
                     os.fspath(termination_log_path),
                     os.fspath(airflow_context_path),
                 ]
-                execute_in_subprocess(
+                _execute_in_subprocess(
                     cmd=cmd,
                     env=env_vars,
                 )

airflow/providers/standard/operators/trigger_dagrun.py

@@ -21,27 +21,35 @@ import datetime
 import json
 import time
 from collections.abc import Sequence
+from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any
 
 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"
@@ -128,8 +136,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] = (
@@ -159,6 +172,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)
@@ -178,7 +192,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
@@ -202,9 +217,17 @@ class TriggerDagRunOperator(BaseOperator):
             parsed_logical_date = timezone.parse(self.logical_date)
 
         try:
+            if self.conf and isinstance(self.conf, str):
+                self.conf = json.loads(self.conf)
             json.dumps(self.conf)
-        except TypeError:
-            raise ValueError("conf parameter should be JSON Serializable")
+        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)
@@ -218,8 +241,13 @@ 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:
+                raise ValueError(f"Dag {self.trigger_dag_id} is not found")
             if dag_model.is_paused:
                 # TODO: enable this when dag state endpoint available from task sdk
                 # if AIRFLOW_V_3_0_PLUS:
@@ -227,12 +255,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,
@@ -245,7 +277,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):
@@ -286,7 +318,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,
@@ -317,17 +349,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)
@@ -351,10 +406,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

@@ -17,14 +17,12 @@
 # under the License.
 from __future__ import annotations
 
-import os
 from collections.abc import Sequence
 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
@@ -89,7 +87,7 @@ class BashSensor(BaseSensorOperator):
                 close_fds=True,
                 cwd=tmp_dir,
                 env=self.env,
-                preexec_fn=os.setsid,
+                start_new_session=True,
             ) as resp:
                 if resp.stdout:
                     self.log.info("Output:")

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