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

airflow/providers/standard/__init__.py

@@ -29,7 +29,7 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "1.9.1"
+__version__ = "1.9.2"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
     "2.10.0"

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/hitl.py

@@ -19,7 +19,7 @@ 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.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+.")
@@ -84,6 +84,7 @@ class HITLOperator(BaseOperator):
         self.multiple = multiple
 
         self.params: ParamsDict = params if isinstance(params, ParamsDict) else ParamsDict(params or {})
+
         self.notifiers: Sequence[BaseNotifier] = (
             [notifiers] if isinstance(notifiers, BaseNotifier) else notifiers or []
         )
@@ -110,6 +111,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 +167,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 +200,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

@@ -88,9 +88,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
 

airflow/providers/standard/operators/python.py

@@ -51,12 +51,15 @@ from airflow.exceptions import (
 from airflow.models.variable import Variable
 from airflow.providers.common.compat.sdk import 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
@@ -572,7 +575,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,6 +21,7 @@ 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
@@ -202,9 +203,11 @@ 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.trigger_run_id:
             run_id = str(self.trigger_run_id)
@@ -220,6 +223,8 @@ class TriggerDagRunOperator(BaseOperator):
 
         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:

airflow/providers/standard/sensors/bash.py

@@ -17,7 +17,6 @@
 # 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
@@ -89,7 +88,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/external_task.py

@@ -18,9 +18,10 @@ from __future__ import annotations
 
 import datetime
 import os
+import typing
 import warnings
-from collections.abc import Callable, Collection, Iterable
-from typing import TYPE_CHECKING, Any, ClassVar
+from collections.abc import Callable, Collection, Iterable, Sequence
+from typing import TYPE_CHECKING, ClassVar
 
 from airflow.configuration import conf
 from airflow.exceptions import AirflowSkipException
@@ -251,17 +252,15 @@ class ExternalTaskSensor(BaseSensorOperator):
         self.deferrable = deferrable
         self.poll_interval = poll_interval
 
-    def _get_dttm_filter(self, context):
+    def _get_dttm_filter(self, context: Context) -> Sequence[datetime.datetime]:
         logical_date = self._get_logical_date(context)
 
         if self.execution_delta:
-            dttm = logical_date - self.execution_delta
-        elif self.execution_date_fn:
-            dttm = self._handle_execution_date_fn(context=context)
-        else:
-            dttm = logical_date
-
-        return dttm if isinstance(dttm, list) else [dttm]
+            return [logical_date - self.execution_delta]
+        if self.execution_date_fn:
+            result = self._handle_execution_date_fn(context=context)
+            return result if isinstance(result, list) else [result]
+        return [logical_date]
 
     def poke(self, context: Context) -> bool:
         # delay check to poke rather than __init__ in case it was supplied as XComArgs
@@ -298,7 +297,7 @@ class ExternalTaskSensor(BaseSensorOperator):
             return self._poke_af3(context, dttm_filter)
         return self._poke_af2(dttm_filter)
 
-    def _poke_af3(self, context: Context, dttm_filter: list[datetime.datetime]) -> bool:
+    def _poke_af3(self, context: Context, dttm_filter: Sequence[datetime.datetime]) -> bool:
         from airflow.providers.standard.utils.sensor_helper import _get_count_by_matched_states
 
         self._has_checked_existence = True
@@ -308,20 +307,20 @@ class ExternalTaskSensor(BaseSensorOperator):
             if self.external_task_ids:
                 return ti.get_ti_count(
                     dag_id=self.external_dag_id,
-                    task_ids=self.external_task_ids,  # type: ignore[arg-type]
-                    logical_dates=dttm_filter,
+                    task_ids=list(self.external_task_ids),
+                    logical_dates=list(dttm_filter),
                     states=states,
                 )
             if self.external_task_group_id:
                 run_id_task_state_map = ti.get_task_states(
                     dag_id=self.external_dag_id,
                     task_group_id=self.external_task_group_id,
-                    logical_dates=dttm_filter,
+                    logical_dates=list(dttm_filter),
                 )
                 return _get_count_by_matched_states(run_id_task_state_map, states)
             return ti.get_dr_count(
                 dag_id=self.external_dag_id,
-                logical_dates=dttm_filter,
+                logical_dates=list(dttm_filter),
                 states=states,
             )
 
@@ -339,7 +338,7 @@ class ExternalTaskSensor(BaseSensorOperator):
         count_allowed = self._calculate_count(count, dttm_filter)
         return count_allowed == len(dttm_filter)
 
-    def _calculate_count(self, count: int, dttm_filter: list[datetime.datetime]) -> float | int:
+    def _calculate_count(self, count: int, dttm_filter: Sequence[datetime.datetime]) -> float | int:
         """Calculate the normalized count based on the type of check."""
         if self.external_task_ids:
             return count / len(self.external_task_ids)
@@ -395,7 +394,7 @@ class ExternalTaskSensor(BaseSensorOperator):
     if not AIRFLOW_V_3_0_PLUS:
 
         @provide_session
-        def _poke_af2(self, dttm_filter: list[datetime.datetime], session: Session = NEW_SESSION) -> bool:
+        def _poke_af2(self, dttm_filter: Sequence[datetime.datetime], session: Session = NEW_SESSION) -> bool:
             if self.check_existence and not self._has_checked_existence:
                 self._check_for_existence(session=session)
 
@@ -416,27 +415,48 @@ class ExternalTaskSensor(BaseSensorOperator):
             super().execute(context)
         else:
             dttm_filter = self._get_dttm_filter(context)
-            logical_or_execution_dates = (
-                {"logical_dates": dttm_filter} if AIRFLOW_V_3_0_PLUS else {"execution_dates": dttm_filter}
-            )
-            self.defer(
-                timeout=self.execution_timeout,
-                trigger=WorkflowTrigger(
-                    external_dag_id=self.external_dag_id,
-                    external_task_group_id=self.external_task_group_id,
-                    external_task_ids=self.external_task_ids,
-                    allowed_states=self.allowed_states,
-                    failed_states=self.failed_states,
-                    skipped_states=self.skipped_states,
-                    poke_interval=self.poll_interval,
-                    soft_fail=self.soft_fail,
-                    **logical_or_execution_dates,
-                ),
-                method_name="execute_complete",
-            )
+            if AIRFLOW_V_3_0_PLUS:
+                self.defer(
+                    timeout=self.execution_timeout,
+                    trigger=WorkflowTrigger(
+                        external_dag_id=self.external_dag_id,
+                        external_task_group_id=self.external_task_group_id,
+                        external_task_ids=self.external_task_ids,
+                        allowed_states=self.allowed_states,
+                        failed_states=self.failed_states,
+                        skipped_states=self.skipped_states,
+                        poke_interval=self.poll_interval,
+                        soft_fail=self.soft_fail,
+                        logical_dates=list(dttm_filter),
+                        run_ids=None,
+                        execution_dates=None,
+                    ),
+                    method_name="execute_complete",
+                )
+            else:
+                self.defer(
+                    timeout=self.execution_timeout,
+                    trigger=WorkflowTrigger(
+                        external_dag_id=self.external_dag_id,
+                        external_task_group_id=self.external_task_group_id,
+                        external_task_ids=self.external_task_ids,
+                        allowed_states=self.allowed_states,
+                        failed_states=self.failed_states,
+                        skipped_states=self.skipped_states,
+                        poke_interval=self.poll_interval,
+                        soft_fail=self.soft_fail,
+                        execution_dates=list(dttm_filter),
+                        logical_dates=None,
+                        run_ids=None,
+                    ),
+                    method_name="execute_complete",
+                )
 
-    def execute_complete(self, context, event=None):
+    def execute_complete(self, context: Context, event: dict[str, typing.Any] | None = None) -> None:
         """Execute when the trigger fires - return immediately."""
+        if event is None:
+            raise ExternalTaskNotFoundError("No event received from trigger")
+
         if event["status"] == "success":
             self.log.info("External tasks %s has executed successfully.", self.external_task_ids)
         elif event["status"] == "skipped":
@@ -453,13 +473,14 @@ class ExternalTaskSensor(BaseSensorOperator):
                 "name of executed task and Dag."
             )
 
-    def _check_for_existence(self, session) -> None:
+    def _check_for_existence(self, session: Session) -> None:
         dag_to_wait = DagModel.get_current(self.external_dag_id, session)
 
         if not dag_to_wait:
             raise ExternalDagNotFoundError(f"The external DAG {self.external_dag_id} does not exist.")
 
-        if not os.path.exists(correct_maybe_zipped(dag_to_wait.fileloc)):
+        path = correct_maybe_zipped(dag_to_wait.fileloc)
+        if not path or not os.path.exists(path):
             raise ExternalDagDeletedError(f"The external DAG {self.external_dag_id} was deleted.")
 
         if self.external_task_ids:
@@ -488,7 +509,7 @@ class ExternalTaskSensor(BaseSensorOperator):
 
         self._has_checked_existence = True
 
-    def get_count(self, dttm_filter, session, states) -> int:
+    def get_count(self, dttm_filter: Sequence[datetime.datetime], session: Session, states: list[str]) -> int:
         """
         Get the count of records against dttm filter and states.
 
@@ -509,15 +530,19 @@ class ExternalTaskSensor(BaseSensorOperator):
             session,
         )
 
-    def get_external_task_group_task_ids(self, session, dttm_filter):
+    def get_external_task_group_task_ids(
+        self, session: Session, dttm_filter: Sequence[datetime.datetime]
+    ) -> list[tuple[str, int]]:
         warnings.warn(
             "This method is deprecated and will be removed in future.", DeprecationWarning, stacklevel=2
         )
+        if self.external_task_group_id is None:
+            return []
         return _get_external_task_group_task_ids(
-            dttm_filter, self.external_task_group_id, self.external_dag_id, session
+            list(dttm_filter), self.external_task_group_id, self.external_dag_id, session
         )
 
-    def _get_logical_date(self, context) -> datetime.datetime:
+    def _get_logical_date(self, context: Context) -> datetime.datetime:
         """
         Handle backwards- and forwards-compatible retrieval of the date.
 
@@ -527,19 +552,21 @@ class ExternalTaskSensor(BaseSensorOperator):
         if AIRFLOW_V_3_0_PLUS:
             logical_date = context.get("logical_date")
             dag_run = context.get("dag_run")
-            if not (logical_date or (dag_run and dag_run.run_after)):
-                raise ValueError(
-                    "Either `logical_date` or `dag_run.run_after` must be provided in the context"
-                )
-            return logical_date or dag_run.run_after
+            if logical_date:
+                return logical_date
+            if dag_run and hasattr(dag_run, "run_after") and dag_run.run_after:
+                return dag_run.run_after
+            raise ValueError("Either `logical_date` or `dag_run.run_after` must be provided in the context")
 
         # Airflow 2.x and earlier: contexts used "execution_date"
         execution_date = context.get("execution_date")
         if not execution_date:
             raise ValueError("Either `execution_date` must be provided in the context`")
+        if not isinstance(execution_date, datetime.datetime):
+            raise ValueError("execution_date must be a datetime object")
         return execution_date
 
-    def _handle_execution_date_fn(self, context) -> Any:
+    def _handle_execution_date_fn(self, context: Context) -> datetime.datetime | list[datetime.datetime]:
         """
         Handle backward compatibility.
 

airflow/providers/standard/triggers/external_task.py

@@ -18,10 +18,11 @@ from __future__ import annotations
 
 import asyncio
 import typing
+from collections.abc import Collection
 from typing import Any
 
 from asgiref.sync import sync_to_async
-from sqlalchemy import func
+from sqlalchemy import func, select
 
 from airflow.models import DagRun
 from airflow.providers.standard.utils.sensor_helper import _get_count
@@ -60,9 +61,9 @@ class WorkflowTrigger(BaseTrigger):
         logical_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,
+        failed_states: Collection[str] | None = None,
+        skipped_states: Collection[str] | None = None,
+        allowed_states: Collection[str] | None = None,
         poke_interval: float = 2.0,
         soft_fail: bool = False,
         **kwargs,
@@ -129,43 +130,41 @@ class WorkflowTrigger(BaseTrigger):
             self.log.info("Sleeping for %s seconds", self.poke_interval)
             await asyncio.sleep(self.poke_interval)
 
-    async def _get_count_af_3(self, states):
+    async def _get_count_af_3(self, states: Collection[str] | None) -> int:
         from airflow.providers.standard.utils.sensor_helper import _get_count_by_matched_states
         from airflow.sdk.execution_time.task_runner import RuntimeTaskInstance
 
-        params = {
-            "dag_id": self.external_dag_id,
-            "logical_dates": self.logical_dates,
-            "run_ids": self.run_ids,
-        }
         if self.external_task_ids:
             count = await sync_to_async(RuntimeTaskInstance.get_ti_count)(
-                task_ids=self.external_task_ids,
-                states=states,
-                **params,
+                dag_id=self.external_dag_id,
+                task_ids=list(self.external_task_ids),
+                logical_dates=self.logical_dates,
+                run_ids=self.run_ids,
+                states=list(states) if states else None,
             )
-        elif self.external_task_group_id:
+            return int(count / len(self.external_task_ids))
+        if self.external_task_group_id:
             run_id_task_state_map = await sync_to_async(RuntimeTaskInstance.get_task_states)(
+                dag_id=self.external_dag_id,
                 task_group_id=self.external_task_group_id,
-                **params,
+                logical_dates=self.logical_dates,
+                run_ids=self.run_ids,
             )
             count = await sync_to_async(_get_count_by_matched_states)(
                 run_id_task_state_map=run_id_task_state_map,
-                states=states,
+                states=states or [],
             )
-        else:
-            count = await sync_to_async(RuntimeTaskInstance.get_dr_count)(
-                dag_id=self.external_dag_id,
-                logical_dates=self.logical_dates,
-                run_ids=self.run_ids,
-                states=states,
-            )
-        if self.external_task_ids:
-            return count / len(self.external_task_ids)
+            return count
+        count = await sync_to_async(RuntimeTaskInstance.get_dr_count)(
+            dag_id=self.external_dag_id,
+            logical_dates=self.logical_dates,
+            run_ids=self.run_ids,
+            states=list(states) if states else None,
+        )
         return count
 
     @sync_to_async
-    def _get_count(self, states: typing.Iterable[str] | None) -> int:
+    def _get_count(self, states: Collection[str] | None) -> int:
         """
         Get the count of records against dttm filter and states. Async wrapper for _get_count.
 
@@ -228,8 +227,8 @@ class DagStateTrigger(BaseTrigger):
             runs_ids_or_dates = len(self.execution_dates)
 
         if AIRFLOW_V_3_0_PLUS:
-            event = await self.validate_count_dags_af_3(runs_ids_or_dates_len=runs_ids_or_dates)
-            yield TriggerEvent(event)
+            data = await self.validate_count_dags_af_3(runs_ids_or_dates_len=runs_ids_or_dates)
+            yield TriggerEvent(data)
             return
         else:
             while True:
@@ -239,7 +238,7 @@ class DagStateTrigger(BaseTrigger):
                     return
                 await asyncio.sleep(self.poll_interval)
 
-    async def validate_count_dags_af_3(self, runs_ids_or_dates_len: int = 0) -> tuple[str, dict[str, Any]]:
+    async def validate_count_dags_af_3(self, runs_ids_or_dates_len: int = 0) -> dict[str, typing.Any]:
         from airflow.sdk.execution_time.task_runner import RuntimeTaskInstance
 
         cls_path, data = self.serialize()
@@ -259,7 +258,7 @@ class DagStateTrigger(BaseTrigger):
                             run_id=run_id,
                         )
                         data[run_id] = state
-                        return cls_path, data
+                        return data
             await asyncio.sleep(self.poll_interval)
 
     if not AIRFLOW_V_3_0_PLUS:
@@ -270,17 +269,18 @@ class DagStateTrigger(BaseTrigger):
         def count_dags(self, *, session: Session = NEW_SESSION) -> int:
             """Count how many dag runs in the database match our criteria."""
             _dag_run_date_condition = (
-                DagRun.run_id.in_(self.run_ids)
+                DagRun.run_id.in_(self.run_ids or [])
                 if AIRFLOW_V_3_0_PLUS
                 else DagRun.execution_date.in_(self.execution_dates)
             )
-            count = (
-                session.query(func.count("*"))  # .count() is inefficient
-                .filter(
+            stmt = (
+                select(func.count())
+                .select_from(DagRun)
+                .where(
                     DagRun.dag_id == self.dag_id,
                     DagRun.state.in_(self.states),
                     _dag_run_date_condition,
                 )
-                .scalar()
             )
-            return typing.cast("int", count)
+            result = session.execute(stmt).scalar()
+            return result or 0

airflow/providers/standard/triggers/file.py

@@ -79,7 +79,7 @@ class FileTrigger(BaseTrigger):
                     self.log.info("Found File %s last modified: %s", path, mod_time)
                     yield TriggerEvent(True)
                     return
-                for _, _, files in os.walk(self.filepath):
+                for _, _, files in os.walk(path):
                     if files:
                         yield TriggerEvent(True)
                         return

airflow/providers/standard/triggers/hitl.py

@@ -30,6 +30,9 @@ from uuid import UUID
 
 from asgiref.sync import sync_to_async
 
+from airflow.exceptions import ParamValidationError
+from airflow.sdk import Param
+from airflow.sdk.definitions.param import ParamsDict
 from airflow.sdk.execution_time.hitl import (
     HITLUser,
     get_hitl_detail_content_detail,
@@ -43,7 +46,7 @@ class HITLTriggerEventSuccessPayload(TypedDict, total=False):
     """Minimum required keys for a success Human-in-the-loop TriggerEvent."""
 
     chosen_options: list[str]
-    params_input: dict[str, Any]
+    params_input: dict[str, dict[str, Any]]
     responded_by_user: HITLUser | None
     responded_at: datetime
     timedout: bool
@@ -53,7 +56,7 @@ class HITLTriggerEventFailurePayload(TypedDict):
     """Minimum required keys for a failed Human-in-the-loop TriggerEvent."""
 
     error: str
-    error_type: Literal["timeout", "unknown"]
+    error_type: Literal["timeout", "unknown", "validation"]
 
 
 class HITLTrigger(BaseTrigger):
@@ -64,7 +67,7 @@ class HITLTrigger(BaseTrigger):
         *,
         ti_id: UUID,
         options: list[str],
-        params: dict[str, Any],
+        params: dict[str, dict[str, Any]],
         defaults: list[str] | None = None,
         multiple: bool = False,
         timeout_datetime: datetime | None,
@@ -80,7 +83,21 @@ class HITLTrigger(BaseTrigger):
         self.defaults = defaults
         self.timeout_datetime = timeout_datetime
 
-        self.params = params
+        self.params = ParamsDict(
+            {
+                k: Param(
+                    v.pop("value"),
+                    **v,
+                )
+                if HITLTrigger._is_param(v)
+                else Param(v)
+                for k, v in params.items()
+            },
+        )
+
+    @staticmethod
+    def _is_param(value: Any) -> bool:
+        return isinstance(value, dict) and all(key in value for key in ("description", "schema", "value"))
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
         """Serialize HITLTrigger arguments and classpath."""
@@ -90,99 +107,131 @@ class HITLTrigger(BaseTrigger):
                 "ti_id": self.ti_id,
                 "options": self.options,
                 "defaults": self.defaults,
-                "params": self.params,
+                "params": {k: self.params.get_param(k).serialize() for k in self.params},
                 "multiple": self.multiple,
                 "timeout_datetime": self.timeout_datetime,
                 "poke_interval": self.poke_interval,
             },
         )
 
-    async def run(self) -> AsyncIterator[TriggerEvent]:
-        """Loop until the Human-in-the-loop response received or timeout reached."""
-        while True:
-            if self.timeout_datetime and self.timeout_datetime < utcnow():
-                # Fetch latest HITL detail before fallback
-                resp = await sync_to_async(get_hitl_detail_content_detail)(ti_id=self.ti_id)
-                # Response already received, yield success and exit
-                if resp.response_received and resp.chosen_options:
-                    if TYPE_CHECKING:
-                        assert resp.responded_by_user is not None
-                        assert resp.responded_at is not None
-
-                    self.log.info(
-                        "[HITL] responded_by=%s (id=%s) options=%s at %s (timeout fallback skipped)",
-                        resp.responded_by_user.name,
-                        resp.responded_by_user.id,
-                        resp.chosen_options,
-                        resp.responded_at,
-                    )
-                    yield TriggerEvent(
-                        HITLTriggerEventSuccessPayload(
-                            chosen_options=resp.chosen_options,
-                            params_input=resp.params_input or {},
-                            responded_at=resp.responded_at,
-                            responded_by_user=HITLUser(
-                                id=resp.responded_by_user.id,
-                                name=resp.responded_by_user.name,
-                            ),
-                            timedout=False,
-                        )
-                    )
-                    return
-
-                if self.defaults is None:
-                    yield TriggerEvent(
-                        HITLTriggerEventFailurePayload(
-                            error="The timeout has passed, and the response has not yet been received.",
-                            error_type="timeout",
-                        )
-                    )
-                    return
-
-                resp = await sync_to_async(update_hitl_detail_response)(
-                    ti_id=self.ti_id,
-                    chosen_options=self.defaults,
-                    params_input=self.params,
+    async def _handle_timeout(self) -> TriggerEvent:
+        """Handle HITL timeout logic and yield appropriate event."""
+        resp = await sync_to_async(get_hitl_detail_content_detail)(ti_id=self.ti_id)
+
+        # Case 1: Response arrived just before timeout
+        if resp.response_received and resp.chosen_options:
+            if TYPE_CHECKING:
+                assert resp.responded_by_user is not None
+                assert resp.responded_at is not None
+
+            chosen_options_list = list(resp.chosen_options or [])
+            self.log.info(
+                "[HITL] responded_by=%s (id=%s) options=%s at %s (timeout fallback skipped)",
+                resp.responded_by_user.name,
+                resp.responded_by_user.id,
+                chosen_options_list,
+                resp.responded_at,
+            )
+            return TriggerEvent(
+                HITLTriggerEventSuccessPayload(
+                    chosen_options=chosen_options_list,
+                    params_input=resp.params_input or {},
+                    responded_at=resp.responded_at,
+                    responded_by_user=HITLUser(
+                        id=resp.responded_by_user.id,
+                        name=resp.responded_by_user.name,
+                    ),
+                    timedout=False,
                 )
-                if TYPE_CHECKING:
-                    assert resp.responded_at is not None
-                self.log.info(
-                    "[HITL] timeout reached before receiving response, fallback to default %s", self.defaults
+            )
+
+        # Case 2: No defaults defined → failure
+        if self.defaults is None:
+            return TriggerEvent(
+                HITLTriggerEventFailurePayload(
+                    error="The timeout has passed, and the response has not yet been received.",
+                    error_type="timeout",
                 )
-                yield TriggerEvent(
-                    HITLTriggerEventSuccessPayload(
-                        chosen_options=self.defaults,
-                        params_input=self.params,
-                        responded_by_user=None,
-                        responded_at=resp.responded_at,
-                        timedout=True,
+            )
+
+        # Case 3: Timeout fallback to default
+        resp = await sync_to_async(update_hitl_detail_response)(
+            ti_id=self.ti_id,
+            chosen_options=self.defaults,
+            params_input=self.params.dump(),
+        )
+        if TYPE_CHECKING:
+            assert resp.responded_at is not None
+
+        self.log.info(
+            "[HITL] timeout reached before receiving response, fallback to default %s",
+            self.defaults,
+        )
+        return TriggerEvent(
+            HITLTriggerEventSuccessPayload(
+                chosen_options=self.defaults,
+                params_input=self.params.dump(),
+                responded_by_user=None,
+                responded_at=resp.responded_at,
+                timedout=True,
+            )
+        )
+
+    async def _handle_response(self):
+        """Check if HITL response is ready and yield success if so."""
+        resp = await sync_to_async(get_hitl_detail_content_detail)(ti_id=self.ti_id)
+        if TYPE_CHECKING:
+            assert resp.responded_by_user is not None
+            assert resp.responded_at is not None
+
+        if not (resp.response_received and resp.chosen_options):
+            return None
+
+        # validate input
+        if params_input := resp.params_input:
+            try:
+                for key, value in params_input.items():
+                    self.params[key] = value
+            except ParamValidationError as err:
+                return TriggerEvent(
+                    HITLTriggerEventFailurePayload(
+                        error=str(err),
+                        error_type="validation",
                     )
                 )
+
+        chosen_options_list = list(resp.chosen_options or [])
+        self.log.info(
+            "[HITL] responded_by=%s (id=%s) options=%s at %s",
+            resp.responded_by_user.name,
+            resp.responded_by_user.id,
+            chosen_options_list,
+            resp.responded_at,
+        )
+        return TriggerEvent(
+            HITLTriggerEventSuccessPayload(
+                chosen_options=chosen_options_list,
+                params_input=params_input or {},
+                responded_at=resp.responded_at,
+                responded_by_user=HITLUser(
+                    id=resp.responded_by_user.id,
+                    name=resp.responded_by_user.name,
+                ),
+                timedout=False,
+            )
+        )
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:
+        """Loop until the Human-in-the-loop response received or timeout reached."""
+        while True:
+            if self.timeout_datetime and self.timeout_datetime < utcnow():
+                event = await self._handle_timeout()
+                yield event
                 return
 
-            resp = await sync_to_async(get_hitl_detail_content_detail)(ti_id=self.ti_id)
-            if resp.response_received and resp.chosen_options:
-                if TYPE_CHECKING:
-                    assert resp.responded_by_user is not None
-                    assert resp.responded_at is not None
-                self.log.info(
-                    "[HITL] responded_by=%s (id=%s) options=%s at %s",
-                    resp.responded_by_user.name,
-                    resp.responded_by_user.id,
-                    resp.chosen_options,
-                    resp.responded_at,
-                )
-                yield TriggerEvent(
-                    HITLTriggerEventSuccessPayload(
-                        chosen_options=resp.chosen_options,
-                        params_input=resp.params_input or {},
-                        responded_at=resp.responded_at,
-                        responded_by_user=HITLUser(
-                            id=resp.responded_by_user.id,
-                            name=resp.responded_by_user.name,
-                        ),
-                        timedout=False,
-                    )
-                )
+            event = await self._handle_response()
+            if event:
+                yield event
                 return
+
             await asyncio.sleep(self.poke_interval)

airflow/providers/standard/utils/python_virtualenv.py

@@ -19,8 +19,11 @@
 
 from __future__ import annotations
 
+import logging
 import os
+import shlex
 import shutil
+import subprocess
 import warnings
 from pathlib import Path
 
@@ -28,7 +31,6 @@ import jinja2
 from jinja2 import select_autoescape
 
 from airflow.configuration import conf
-from airflow.utils.process_utils import execute_in_subprocess
 
 
 def _is_uv_installed() -> bool:
@@ -132,6 +134,37 @@ def _index_urls_to_uv_env_vars(index_urls: list[str] | None = None) -> dict[str,
     return uv_index_env_vars
 
 
+def _execute_in_subprocess(cmd: list[str], cwd: str | None = None, env: dict[str, str] | None = None) -> None:
+    """
+    Execute a process and stream output to logger.
+
+    :param cmd: command and arguments to run
+    :param cwd: Current working directory passed to the Popen constructor
+    :param env: Additional environment variables to set for the subprocess.
+    """
+    log = logging.getLogger(__name__)
+
+    log.info("Executing cmd: %s", " ".join(shlex.quote(c) for c in cmd))
+    with subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=0,
+        close_fds=True,
+        cwd=cwd,
+        env=env,
+    ) as proc:
+        log.info("Output:")
+        if proc.stdout:
+            with proc.stdout:
+                for line in iter(proc.stdout.readline, b""):
+                    log.info("%s", line.decode().rstrip())
+
+        exit_code = proc.wait()
+    if exit_code != 0:
+        raise subprocess.CalledProcessError(exit_code, cmd)
+
+
 def prepare_virtualenv(
     venv_directory: str,
     python_bin: str,
@@ -169,7 +202,7 @@ def prepare_virtualenv(
         venv_cmd = _generate_uv_cmd(venv_directory, python_bin, system_site_packages)
     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:
@@ -188,7 +221,7 @@ def prepare_virtualenv(
             )
 
     if pip_cmd:
-        execute_in_subprocess(pip_cmd, env={**os.environ, **_index_urls_to_uv_env_vars(index_urls)})
+        _execute_in_subprocess(pip_cmd, env={**os.environ, **_index_urls_to_uv_env_vars(index_urls)})
 
     return f"{venv_directory}/bin/python"
 

airflow/providers/standard/utils/sensor_helper.py

@@ -16,6 +16,7 @@
 # under the License.
 from __future__ import annotations
 
+from collections.abc import Collection
 from typing import TYPE_CHECKING, Any, cast
 
 from sqlalchemy import func, select, tuple_
@@ -27,7 +28,7 @@ from airflow.utils.session import NEW_SESSION, provide_session
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
-    from sqlalchemy.sql import Executable
+    from sqlalchemy.sql import Select
 
 
 @provide_session
@@ -59,6 +60,7 @@ def _get_count(
             session.scalar(
                 _count_stmt(TI, states, dttm_filter, external_dag_id).where(TI.task_id.in_(external_task_ids))
             )
+            or 0
         ) / len(external_task_ids)
     elif external_task_group_id:
         external_task_group_task_ids = _get_external_task_group_task_ids(
@@ -68,20 +70,25 @@ def _get_count(
             count = 0
         else:
             count = (
-                session.scalar(
-                    _count_stmt(TI, states, dttm_filter, external_dag_id).where(
-                        tuple_(TI.task_id, TI.map_index).in_(external_task_group_task_ids)
+                (
+                    session.scalar(
+                        _count_stmt(TI, states, dttm_filter, external_dag_id).where(
+                            tuple_(TI.task_id, TI.map_index).in_(external_task_group_task_ids)
+                        )
                     )
+                    or 0
                 )
                 / len(external_task_group_task_ids)
                 * len(dttm_filter)
             )
     else:
-        count = session.scalar(_count_stmt(DR, states, dttm_filter, external_dag_id))
+        count = session.scalar(_count_stmt(DR, states, dttm_filter, external_dag_id)) or 0
     return cast("int", count)
 
 
-def _count_stmt(model, states, dttm_filter, external_dag_id) -> Executable:
+def _count_stmt(
+    model: type[DagRun] | type[TaskInstance], states: list[str], dttm_filter: list[Any], external_dag_id: str
+) -> Select[tuple[int]]:
     """
     Get the count of records against dttm filter and states.
 
@@ -97,7 +104,9 @@ def _count_stmt(model, states, dttm_filter, external_dag_id) -> Executable:
     )
 
 
-def _get_external_task_group_task_ids(dttm_filter, external_task_group_id, external_dag_id, session):
+def _get_external_task_group_task_ids(
+    dttm_filter: list[Any], external_task_group_id: str, external_dag_id: str, session: Session
+) -> list[tuple[str, int]]:
     """
     Get the count of records against dttm filter and states.
 
@@ -107,6 +116,8 @@ def _get_external_task_group_task_ids(dttm_filter, external_task_group_id, exter
     :param session: airflow session object
     """
     refreshed_dag_info = SerializedDagModel.get_dag(external_dag_id, session=session)
+    if not refreshed_dag_info:
+        return [(external_task_group_id, -1)]
     task_group = refreshed_dag_info.task_group_dict.get(external_task_group_id)
 
     if task_group:
@@ -129,7 +140,7 @@ def _get_external_task_group_task_ids(dttm_filter, external_task_group_id, exter
 
 def _get_count_by_matched_states(
     run_id_task_state_map: dict[str, dict[str, Any]],
-    states: list[str],
+    states: Collection[str],
 ):
     count = 0
     for _, task_states in run_id_task_state_map.items():

airflow/providers/standard/version_compat.py

@@ -34,6 +34,7 @@ def get_base_airflow_version_tuple() -> tuple[int, int, int]:
 
 AIRFLOW_V_3_0_PLUS: bool = get_base_airflow_version_tuple() >= (3, 0, 0)
 AIRFLOW_V_3_1_PLUS: bool = get_base_airflow_version_tuple() >= (3, 1, 0)
+AIRFLOW_V_3_1_3_PLUS: bool = get_base_airflow_version_tuple() >= (3, 1, 3)
 AIRFLOW_V_3_2_PLUS: bool = get_base_airflow_version_tuple() >= (3, 2, 0)
 
 # BaseOperator: Use 3.1+ due to xcom_push method missing in SDK BaseOperator 3.0.x

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-standard
-Version: 1.9.1rc1
+Version: 1.9.2rc1
 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>
 Maintainer-email: Apache Software Foundation <dev@airflow.apache.org>
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
+License-Expression: Apache-2.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Environment :: Web Environment
@@ -14,17 +15,18 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: Framework :: Apache Airflow
 Classifier: Framework :: Apache Airflow :: Provider
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 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
 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.1/changelog.html
-Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-standard/1.9.1
+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: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
@@ -55,7 +57,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-standard``
 
-Release: ``1.9.1``
+Release: ``1.9.2``
 
 
 Airflow Standard Provider
@@ -68,7 +70,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.1/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.9.2/>`_.
 
 Installation
 ------------
@@ -109,5 +111,5 @@ Dependent package
 ==================================================================================================================  =================
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.9.1/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/1.9.2/changelog.html>`_.
 

{apache_airflow_providers_standard-1.9.1rc1.dist-info → apache_airflow_providers_standard-1.9.2rc1.dist-info}/RECORD

@@ -1,8 +1,7 @@
-airflow/providers/standard/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/standard/__init__.py,sha256=U9kcSbyD5ZHnLiCe5_tLPs6cbPhaIKxFIfJ3mbvq8Vw,1497
+airflow/providers/standard/__init__.py,sha256=jfNXXadd0prAQ-FCHal8rq0weWZ0Rb2en5O2wHveHE0,1497
 airflow/providers/standard/exceptions.py,sha256=m2Ryv36yrzAk8xMIA4lhR11n1gA1CKPFwRok8ksl_tk,2416
 airflow/providers/standard/get_provider_info.py,sha256=NVstkG2ZeAiTZnvmbrMpxcYgJzcdITKdQvgDOZYX1Rk,7227
-airflow/providers/standard/version_compat.py,sha256=-7q64t0wML0dv9SIfoRV5lGphE_8bWmBHZ07o6u6_9Y,2091
+airflow/providers/standard/version_compat.py,sha256=wzS7qPjUGZp-zZeL2YnvAlxD-Sdtt7ff6KnlFk3xlUA,2166
 airflow/providers/standard/decorators/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/decorators/bash.py,sha256=7njtxxSfAwBdcOz8ZPTH1MLsXTgyL-oxEE7kXMZvv3Q,4132
 airflow/providers/standard/decorators/branch_external_python.py,sha256=sGtSrCK137HLm77fcxbYgpDeMMuYdMJp6oVbPrQHvPU,2403
@@ -38,40 +37,42 @@ airflow/providers/standard/example_dags/sql/sample.sql,sha256=OVk1qozBY58lp_tFtn
 airflow/providers/standard/hooks/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/hooks/filesystem.py,sha256=-WxoAHv6hOmyZr_KjHKGOzdi5FbdiRDdGuJUjts9jTw,2887
 airflow/providers/standard/hooks/package_index.py,sha256=BgPZB9z0UKV1jO-QERdxZTwY1KLMwYl9YFAU_q_ZX0w,3786
-airflow/providers/standard/hooks/subprocess.py,sha256=fmo71AfSxmDJpkBO7fFtLDdJLAkhlhdIPCzHj-GDBjI,4937
+airflow/providers/standard/hooks/subprocess.py,sha256=bO6xV9JBfQ_iZAdV1JiycHSqd_HWYgKUOSGCd32H2Js,4667
 airflow/providers/standard/models/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/operators/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/operators/bash.py,sha256=BJaW76cjLdio8ldTytA03lKlDw16xJYl_zF4mWF39Ts,11053
 airflow/providers/standard/operators/branch.py,sha256=NtQVkB63nvZCnFoYlfhM-fG1c9zakEDIid20KfuoLW4,4247
 airflow/providers/standard/operators/datetime.py,sha256=U9hSX5wP0e0NfgM2gYitqOIoqvJxrGxTU2TUV82pHPg,4879
 airflow/providers/standard/operators/empty.py,sha256=flxN2BhuHegEOiiAcJR9QOuMO8PcxQu353Q9p-Yk82s,1342
-airflow/providers/standard/operators/hitl.py,sha256=iV7zcSAcgyZV1HCvl6vHF9YV535sJnMc7JsKP-3uDxE,18022
-airflow/providers/standard/operators/latest_only.py,sha256=FDQP8PMw-bDXJUwfpGB0ESjxitgRMd7kqPO5hAsbf6c,4961
-airflow/providers/standard/operators/python.py,sha256=H3AaqcEmIM_KZKJV8RiUxksjBfELoD1l7iCEqA_Is-E,53670
+airflow/providers/standard/operators/hitl.py,sha256=rsCkEKBeK-f0nCd17yvjMzPXqUdmTfKwhnwTgd9Xqo0,18209
+airflow/providers/standard/operators/latest_only.py,sha256=95c4z3tjjTlJQ-I90AbfQRnYeUPxxSjJI-TaTWkrCWs,5017
+airflow/providers/standard/operators/python.py,sha256=vxwTKJJ22ZCrMVWtzmWgKgfh6tO7oKeMVXOdItowPbc,53650
 airflow/providers/standard/operators/smooth.py,sha256=WamRqmeSm6BcGCCBAqBEVYIRk4ZXbeI_Q7OjPgLfnUI,1400
-airflow/providers/standard/operators/trigger_dagrun.py,sha256=2cNz7QgJy0biV6PCjMrr7FInCN6z_ZWkdrXF_lq54ns,16537
+airflow/providers/standard/operators/trigger_dagrun.py,sha256=b4mkLIn0knBqeGZMJYr-SkBpqPLjhnrjAArtnMExkQo,16816
 airflow/providers/standard/operators/weekday.py,sha256=s8C6T-x9Hvkj4YQWCguTRyhiAqdJYCBr12rPm2qYC3M,4957
 airflow/providers/standard/sensors/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/standard/sensors/bash.py,sha256=TNcFnE881afOhQQI_PQj6Xnd4WmPO5uKUFsFJuiKN1o,4830
+airflow/providers/standard/sensors/bash.py,sha256=W_RUdczpEfta7WZVzNHuPbsnZq5YvchmlqEGp3tiLYI,4822
 airflow/providers/standard/sensors/date_time.py,sha256=_Pc4DBL807sJInvaTFxBvAirb3FtBbdpoBYGZj-u4dQ,6355
-airflow/providers/standard/sensors/external_task.py,sha256=qWxjP8raAofH6rIj5CorVj1d6YTAv3q3ve2La5sK9bk,28797
+airflow/providers/standard/sensors/external_task.py,sha256=oGB71ZkyzuDE4p2GaGyaRBSEiMy4twATD5OTnG9HRFk,30357
 airflow/providers/standard/sensors/filesystem.py,sha256=tuKzvQhv-FO9yQOZ1lhDLAOTHtKlaMXPBmq1asSzlfU,5896
 airflow/providers/standard/sensors/python.py,sha256=eBfy0QRgsQHw4H4pZ4u7DNzu7ZdMH7TtPQWOdP4wWqA,3221
 airflow/providers/standard/sensors/time.py,sha256=ymNNjJmtcUKumlbSfPq6krCF_4lsuFtdjqTNr-gPlOM,4986
 airflow/providers/standard/sensors/time_delta.py,sha256=aEz9VMxnILWafac6sdZRXDYAvV_XukVYFRFYB2buVAY,7453
 airflow/providers/standard/sensors/weekday.py,sha256=Jb_QPJNN7_Os1X0Y-MA0-J_tv-rtWjZcU0C_5edo8X0,4291
 airflow/providers/standard/triggers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/standard/triggers/external_task.py,sha256=R2Wsd21pw9_gGTs9XuHafylt65hMVPisz2g6vnpLJ4o,11521
-airflow/providers/standard/triggers/file.py,sha256=2i8-RwSjEgdOwQNcHCqLmSdpE3Ehqg4GQJ8nE3-fHxo,4886
-airflow/providers/standard/triggers/hitl.py,sha256=MXAwMPlMcil1EBRnck9hjakicK93QfLTBEyKKmGucV0,7403
+airflow/providers/standard/triggers/external_task.py,sha256=LKjoLC--pIBWBDqt9uOVHeGqlmr8svSprh8beFGUSF8,11652
+airflow/providers/standard/triggers/file.py,sha256=mkZuOBNMHON9DQSBRO1NIqcNNjxGM5dbYOQ1Cfsm-BQ,4877
+airflow/providers/standard/triggers/hitl.py,sha256=cJfFqiuEq5nZRisfktJ2DgviJqxV9tiBIbS8CYmPaOQ,8501
 airflow/providers/standard/triggers/temporal.py,sha256=-Zxu96xqt40bhsyzFSK2gv-Ddb2GNr2UogeIoyBX684,4468
 airflow/providers/standard/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/standard/utils/python_virtualenv.py,sha256=logUzODR5qnUZYyew-ZEbL7rudrkTEtmnU9qTQhg0-0,8532
+airflow/providers/standard/utils/python_virtualenv.py,sha256=CyAn1rix-BCvtf6CI6fAMfLZWZx2GRhjfugpyrbRnZc,9522
 airflow/providers/standard/utils/python_virtualenv_script.jinja2,sha256=3Z334hVq6hQ9EHkOoGnAHc2_XNkZQkOJGxZArDKLc-c,2770
-airflow/providers/standard/utils/sensor_helper.py,sha256=FwI36sJK-s3Wz0slypF1_tAikQpiXovtTiN__Md00Aw,5049
+airflow/providers/standard/utils/sensor_helper.py,sha256=ZcJeWAGymwUma7R6U7pQXhmQLC2UEeiyjQOrH4uFxt0,5407
 airflow/providers/standard/utils/skipmixin.py,sha256=YDgyVUv6XBmsMJzv5AhatZvymgcThBmBD0Yr2_lh40E,8012
 airflow/providers/standard/utils/weekday.py,sha256=ySDrIkWv-lqqxURo9E98IGInDqERec2O4y9o2hQTGiQ,2685
-apache_airflow_providers_standard-1.9.1rc1.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
-apache_airflow_providers_standard-1.9.1rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-apache_airflow_providers_standard-1.9.1rc1.dist-info/METADATA,sha256=myRsPZSw0qhDL4Jpf0tWaeSpFe8wztNKDoYx5Vk18IU,5120
-apache_airflow_providers_standard-1.9.1rc1.dist-info/RECORD,,
+apache_airflow_providers_standard-1.9.2rc1.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
+apache_airflow_providers_standard-1.9.2rc1.dist-info/licenses/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
+apache_airflow_providers_standard-1.9.2rc1.dist-info/licenses/NOTICE,sha256=E3-_E02gwwSEFzeeWPKmnIjOoos3hW28CLISV6sYrbQ,168
+apache_airflow_providers_standard-1.9.2rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+apache_airflow_providers_standard-1.9.2rc1.dist-info/METADATA,sha256=C7vbo6Vt_Zmx2cfqp0IM3DqMLA5fE9cA8cK6l_kY10I,5131
+apache_airflow_providers_standard-1.9.2rc1.dist-info/RECORD,,

apache_airflow_providers_standard-1.9.2rc1.dist-info/licenses/NOTICE

@@ -0,0 +1,5 @@
+Apache Airflow
+Copyright 2016-2025 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).