apache-airflow-providers-standard 0.1.1rc1__py3-none-any.whl → 0.2.0__py3-none-any.whl

airflow/providers/standard/__init__.py

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

airflow/providers/standard/get_provider_info.py

@@ -27,8 +27,8 @@ def get_provider_info():
         "name": "Standard",
         "description": "Airflow Standard Provider\n",
         "state": "ready",
-        "source-date-epoch": 1741509906,
-        "versions": ["0.1.1", "0.1.0", "0.0.3", "0.0.2", "0.0.1"],
+        "source-date-epoch": 1742480519,
+        "versions": ["0.2.0", "0.1.1", "0.1.0", "0.0.3", "0.0.2", "0.0.1"],
         "integrations": [
             {
                 "integration-name": "Standard",
@@ -53,6 +53,7 @@ def get_provider_info():
                     "airflow.providers.standard.operators.trigger_dagrun",
                     "airflow.providers.standard.operators.latest_only",
                     "airflow.providers.standard.operators.smooth",
+                    "airflow.providers.standard.operators.branch",
                 ],
             }
         ],

airflow/providers/standard/operators/bash.py

@@ -27,12 +27,15 @@ from typing import TYPE_CHECKING, Any, Callable, cast
 from airflow.exceptions import AirflowException, AirflowSkipException
 from airflow.models.baseoperator import BaseOperator
 from airflow.providers.standard.hooks.subprocess import SubprocessHook, SubprocessResult, working_directory
-from airflow.utils.operator_helpers import context_to_airflow_vars
-from airflow.utils.session import NEW_SESSION, provide_session
-from airflow.utils.types import ArgNotSet
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.execution_time.context import context_to_airflow_vars
+else:
+    from airflow.utils.operator_helpers import context_to_airflow_vars  # type: ignore[no-redef, attr-defined]
 
 if TYPE_CHECKING:
-    from sqlalchemy.orm import Session as SASession
+    from airflow.utils.types import ArgNotSet
 
     try:
         from airflow.sdk.definitions.context import Context
@@ -182,43 +185,15 @@ class BashOperator(BaseOperator):
         self.cwd = cwd
         self.append_env = append_env
         self.output_processor = output_processor
-
-        # When using the @task.bash decorator, the Bash command is not known until the underlying Python
-        # callable is executed and therefore set to NOTSET initially. This flag is useful during execution to
-        # determine whether the bash_command value needs to re-rendered.
-        self._init_bash_command_not_set = isinstance(self.bash_command, ArgNotSet)
-
-        # Keep a copy of the original bash_command, without the Jinja template rendered.
-        # This is later used to determine if the bash_command is a script or an inline string command.
-        # We do this later, because the bash_command is not available in __init__ when using @task.bash.
-        self._unrendered_bash_command: str | ArgNotSet = bash_command
+        self._is_inline_cmd = None
+        if isinstance(bash_command, str):
+            self._is_inline_cmd = self._is_inline_command(bash_command=bash_command)
 
     @cached_property
     def subprocess_hook(self):
         """Returns hook for running the bash command."""
         return SubprocessHook()
 
-    # TODO: This should be replaced with Task SDK API call
-    @staticmethod
-    @provide_session
-    def refresh_bash_command(ti, session: SASession = NEW_SESSION) -> None:
-        """
-        Rewrite the underlying rendered bash_command value for a task instance in the metadatabase.
-
-        TaskInstance.get_rendered_template_fields() cannot be used because this will retrieve the
-        RenderedTaskInstanceFields from the metadatabase which doesn't have the runtime-evaluated bash_command
-        value.
-
-        :meta private:
-        """
-        from airflow.models.renderedtifields import RenderedTaskInstanceFields
-
-        """Update rendered task instance fields for cases where runtime evaluated, not templated."""
-
-        rtif = RenderedTaskInstanceFields(ti)
-        RenderedTaskInstanceFields.write(rtif, session=session)
-        RenderedTaskInstanceFields.delete_old_records(ti.task_id, ti.dag_id, session=session)
-
     def get_env(self, context) -> dict:
         """Build the set of environment variables to be exposed for the bash command."""
         system_env = os.environ.copy()
@@ -247,19 +222,7 @@ class BashOperator(BaseOperator):
                 raise AirflowException(f"The cwd {self.cwd} must be a directory")
         env = self.get_env(context)
 
-        # Because the bash_command value is evaluated at runtime using the @task.bash decorator, the
-        # RenderedTaskInstanceField data needs to be rewritten and the bash_command value re-rendered -- the
-        # latter because the returned command from the decorated callable could contain a Jinja expression.
-        # Both will ensure the correct Bash command is executed and that the Rendered Template view in the UI
-        # displays the executed command (otherwise it will display as an ArgNotSet type).
-        if self._init_bash_command_not_set:
-            is_inline_command = self._is_inline_command(bash_command=cast(str, self.bash_command))
-            ti = context["ti"]
-            self.refresh_bash_command(ti)
-        else:
-            is_inline_command = self._is_inline_command(bash_command=cast(str, self._unrendered_bash_command))
-
-        if is_inline_command:
+        if self._is_inline_cmd:
             result = self._run_inline_command(bash_path=bash_path, env=env)
         else:
             result = self._run_rendered_script_file(bash_path=bash_path, env=env)

airflow/providers/standard/operators/branch.py

@@ -0,0 +1,105 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Branching operators."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from airflow.models.baseoperator import BaseOperator
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.providers.standard.utils.skipmixin import SkipMixin
+else:
+    from airflow.models.skipmixin import SkipMixin
+
+if TYPE_CHECKING:
+    from airflow.sdk.definitions.context import Context
+    from airflow.sdk.types import RuntimeTaskInstanceProtocol
+
+
+class BranchMixIn(SkipMixin):
+    """Utility helper which handles the branching as one-liner."""
+
+    def do_branch(self, context: Context, branches_to_execute: str | Iterable[str]) -> str | Iterable[str]:
+        """Implement the handling of branching including logging."""
+        self.log.info("Branch into %s", branches_to_execute)
+        branch_task_ids = self._expand_task_group_roots(context["ti"], branches_to_execute)
+        self.skip_all_except(context["ti"], branch_task_ids)
+        return branches_to_execute
+
+    def _expand_task_group_roots(
+        self, ti: RuntimeTaskInstanceProtocol, branches_to_execute: str | Iterable[str]
+    ) -> Iterable[str]:
+        """Expand any task group into its root task ids."""
+        if TYPE_CHECKING:
+            assert ti.task
+
+        task = ti.task
+        dag = task.dag
+        if TYPE_CHECKING:
+            assert dag
+
+        if branches_to_execute is None:
+            return
+        elif isinstance(branches_to_execute, str) or not isinstance(branches_to_execute, Iterable):
+            branches_to_execute = [branches_to_execute]
+
+        for branch in branches_to_execute:
+            if branch in dag.task_group_dict:
+                tg = dag.task_group_dict[branch]
+                root_ids = [root.task_id for root in tg.roots]
+                self.log.info("Expanding task group %s into %s", tg.group_id, root_ids)
+                yield from root_ids
+            else:
+                yield branch
+
+
+class BaseBranchOperator(BaseOperator, BranchMixIn):
+    """
+    A base class for creating operators with branching functionality, like to BranchPythonOperator.
+
+    Users should create a subclass from this operator and implement the function
+    `choose_branch(self, context)`. This should run whatever business logic
+    is needed to determine the branch, and return one of the following:
+    - A single task_id (as a str)
+    - A single task_group_id (as a str)
+    - A list containing a combination of task_ids and task_group_ids
+
+    The operator will continue with the returned task_id(s) and/or task_group_id(s), and all other
+    tasks directly downstream of this operator will be skipped.
+    """
+
+    inherits_from_skipmixin = True
+
+    def choose_branch(self, context: Context) -> str | Iterable[str]:
+        """
+        Abstract method to choose which branch to run.
+
+        Subclasses should implement this, running whatever logic is
+        necessary to choose a branch and returning a task_id or list of
+        task_ids.
+
+        :param context: Context dictionary as passed to execute()
+        """
+        raise NotImplementedError
+
+    def execute(self, context: Context):
+        return self.do_branch(context, self.choose_branch(context))

airflow/providers/standard/operators/datetime.py

@@ -21,7 +21,7 @@ from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
 from airflow.exceptions import AirflowException
-from airflow.operators.branch import BaseBranchOperator
+from airflow.providers.standard.operators.branch import BaseBranchOperator
 from airflow.utils import timezone
 
 if TYPE_CHECKING:

airflow/providers/standard/operators/latest_only.py

@@ -24,7 +24,7 @@ from typing import TYPE_CHECKING
 
 import pendulum
 
-from airflow.operators.branch import BaseBranchOperator
+from airflow.providers.standard.operators.branch import BaseBranchOperator
 from airflow.utils.types import DagRunType
 
 if TYPE_CHECKING:

airflow/providers/standard/operators/python.py

@@ -42,9 +42,7 @@ from airflow.exceptions import (
     DeserializingResultError,
 )
 from airflow.models.baseoperator import BaseOperator
-from airflow.models.skipmixin import SkipMixin
 from airflow.models.variable import Variable
-from airflow.operators.branch import BranchMixIn
 from airflow.providers.standard.utils.python_virtualenv import prepare_virtualenv, write_python_script
 from airflow.providers.standard.version_compat import AIRFLOW_V_2_10_PLUS, AIRFLOW_V_3_0_PLUS
 from airflow.utils import hashlib_wrapper
@@ -53,6 +51,14 @@ 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, execute_in_subprocess_with_kwargs
 
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.providers.standard.operators.branch import BranchMixIn
+    from airflow.providers.standard.utils.skipmixin import SkipMixin
+else:
+    from airflow.models.skipmixin import SkipMixin
+    from airflow.operators.branch import BranchMixIn
+
+
 log = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
@@ -60,10 +66,12 @@ if TYPE_CHECKING:
 
     from pendulum.datetime import DateTime
 
+    from airflow.sdk.execution_time.callback_runner import ExecutionCallableRunner
+    from airflow.sdk.execution_time.context import OutletEventAccessorsProtocol
+
     try:
         from airflow.sdk.definitions.context import Context
-    except ImportError:
-        # TODO: Remove once provider drops support for Airflow 2
+    except ImportError:  # TODO: Remove once provider drops support for Airflow 2
         from airflow.utils.context import Context
 
     _SerializerTypeDef = Literal["pickle", "cloudpickle", "dill"]
@@ -184,14 +192,22 @@ class PythonOperator(BaseOperator):
         context_merge(context, self.op_kwargs, templates_dict=self.templates_dict)
         self.op_kwargs = self.determine_kwargs(context)
 
-        if AIRFLOW_V_3_0_PLUS:
-            from airflow.utils.context import context_get_outlet_events
+        # 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[ExecutionCallableRunner, OutletEventAccessorsProtocol] | None:
+            if AIRFLOW_V_3_0_PLUS:
+                from airflow.sdk.execution_time.callback_runner import create_executable_runner
+                from airflow.sdk.execution_time.context import context_get_outlet_events
 
-            self._asset_events = context_get_outlet_events(context)
-        elif AIRFLOW_V_2_10_PLUS:
-            from airflow.utils.context import context_get_outlet_events
+                return create_executable_runner, context_get_outlet_events(context)
+            if AIRFLOW_V_2_10_PLUS:
+                from airflow.utils.context import context_get_outlet_events  # type: ignore
+                from airflow.utils.operator_helpers import ExecutionCallableRunner  # type: ignore
 
-            self._dataset_events = context_get_outlet_events(context)
+                return ExecutionCallableRunner, context_get_outlet_events(context)
+            return None
+
+        self.__prepare_execution = __prepare_execution
 
         return_value = self.execute_callable()
         if self.show_return_value_in_logs:
@@ -204,21 +220,18 @@ class PythonOperator(BaseOperator):
     def determine_kwargs(self, context: Mapping[str, Any]) -> Mapping[str, Any]:
         return KeywordParameters.determine(self.python_callable, self.op_args, context).unpacking()
 
+    __prepare_execution: Callable[[], tuple[ExecutionCallableRunner, OutletEventAccessorsProtocol] | None]
+
     def execute_callable(self) -> Any:
         """
         Call the python callable with the given arguments.
 
         :return: the return value of the call.
         """
-        try:
-            from airflow.utils.operator_helpers import ExecutionCallableRunner
-
-            asset_events = self._asset_events if AIRFLOW_V_3_0_PLUS else self._dataset_events
-
-            runner = ExecutionCallableRunner(self.python_callable, asset_events, logger=self.log)
-        except ImportError:
-            # Handle Pre Airflow 3.10 case where ExecutionCallableRunner was not available
+        if (execution_preparation := self.__prepare_execution()) is None:
             return 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 runner.run(*self.op_args, **self.op_kwargs)
 
 
@@ -236,6 +249,8 @@ class BranchPythonOperator(PythonOperator, BranchMixIn):
     the DAG run's state to be inferred.
     """
 
+    inherits_from_skipmixin = True
+
     def execute(self, context: Context) -> Any:
         return self.do_branch(context, super().execute(context))
 
@@ -266,6 +281,8 @@ class ShortCircuitOperator(PythonOperator, SkipMixin):
         skipped but the ``trigger_rule`` defined for all other downstream tasks will be respected.
     """
 
+    inherits_from_skipmixin = True
+
     def __init__(self, *, ignore_downstream_trigger_rules: bool = True, **kwargs) -> None:
         super().__init__(**kwargs)
         self.ignore_downstream_trigger_rules = ignore_downstream_trigger_rules
@@ -295,25 +312,24 @@ class ShortCircuitOperator(PythonOperator, SkipMixin):
 
         to_skip = get_tasks_to_skip()
 
-        # this let's us avoid an intermediate list unless debug logging
+        # this lets us avoid an intermediate list unless debug logging
         if self.log.getEffectiveLevel() <= logging.DEBUG:
             self.log.debug("Downstream task IDs %s", to_skip := list(get_tasks_to_skip()))
 
         self.log.info("Skipping downstream tasks")
         if AIRFLOW_V_3_0_PLUS:
             self.skip(
-                dag_id=dag_run.dag_id,
-                run_id=dag_run.run_id,
+                ti=context["ti"],
                 tasks=to_skip,
-                map_index=context["ti"].map_index,
             )
         else:
-            self.skip(
-                dag_run=dag_run,
-                tasks=to_skip,
-                execution_date=cast("DateTime", dag_run.logical_date),  # type: ignore[call-arg, union-attr]
-                map_index=context["ti"].map_index,
-            )
+            if to_skip:
+                self.skip(
+                    dag_run=context["dag_run"],
+                    tasks=to_skip,
+                    execution_date=cast("DateTime", dag_run.logical_date),  # type: ignore[call-arg, union-attr]
+                    map_index=context["ti"].map_index,
+                )
 
         self.log.info("Done.")
         # returns the result of the super execute method as it is instead of returning None
@@ -868,6 +884,8 @@ class BranchPythonVirtualenvOperator(PythonVirtualenvOperator, BranchMixIn):
         :ref:`howto/operator:BranchPythonVirtualenvOperator`
     """
 
+    inherits_from_skipmixin = True
+
     def execute(self, context: Context) -> Any:
         return self.do_branch(context, super().execute(context))
 

airflow/providers/standard/operators/trigger_dagrun.py

@@ -38,13 +38,12 @@ from airflow.models import BaseOperator
 from airflow.models.dag import DagModel
 from airflow.models.dagbag import DagBag
 from airflow.models.dagrun import DagRun
-from airflow.models.xcom import XCom
 from airflow.providers.standard.triggers.external_task import DagStateTrigger
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
 from airflow.utils import timezone
 from airflow.utils.session import provide_session
 from airflow.utils.state import DagRunState
-from airflow.utils.types import DagRunTriggeredByType, DagRunType
+from airflow.utils.types import DagRunType
 
 XCOM_LOGICAL_DATE_ISO = "trigger_logical_date_iso"
 XCOM_RUN_ID = "trigger_run_id"
@@ -63,7 +62,9 @@ if TYPE_CHECKING:
 
 if AIRFLOW_V_3_0_PLUS:
     from airflow.sdk import BaseOperatorLink
+    from airflow.sdk.execution_time.xcom import XCom
 else:
+    from airflow.models import XCom  # type: ignore[no-redef]
     from airflow.models.baseoperatorlink import BaseOperatorLink  # type: ignore[no-redef]
 
 
@@ -77,15 +78,15 @@ class TriggerDagRunLink(BaseOperatorLink):
     name = "Triggered DAG"
 
     def get_link(self, operator: BaseOperator, *, ti_key: TaskInstanceKey) -> str:
-        from airflow.models.renderedtifields import RenderedTaskInstanceFields
-
         if TYPE_CHECKING:
             assert isinstance(operator, TriggerDagRunOperator)
 
-        if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
-            trigger_dag_id: str = template_fields.get("trigger_dag_id", operator.trigger_dag_id)
-        else:
-            trigger_dag_id = operator.trigger_dag_id
+        trigger_dag_id = operator.trigger_dag_id
+        if not AIRFLOW_V_3_0_PLUS:
+            from airflow.models.renderedtifields import RenderedTaskInstanceFields
+
+            if template_fields := RenderedTaskInstanceFields.get_templated_fields(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
         # stored in xcom during execution of the triggerING task.
@@ -173,7 +174,7 @@ class TriggerDagRunOperator(BaseOperator):
             self.allowed_states = [DagRunState(s) for s in allowed_states]
         else:
             self.allowed_states = [DagRunState.SUCCESS]
-        if failed_states or failed_states == []:
+        if failed_states is not None:
             self.failed_states = [DagRunState(s) for s in failed_states]
         else:
             self.failed_states = [DagRunState.FAILED]
@@ -197,25 +198,51 @@ class TriggerDagRunOperator(BaseOperator):
         try:
             json.dumps(self.conf)
         except TypeError:
-            raise AirflowException("conf parameter should be JSON Serializable")
+            raise ValueError("conf parameter should be JSON Serializable")
 
         if self.trigger_run_id:
             run_id = str(self.trigger_run_id)
         else:
-            run_id = DagRun.generate_run_id(
-                run_type=DagRunType.MANUAL,
-                logical_date=parsed_logical_date,
-                run_after=parsed_logical_date or timezone.utcnow(),
-            )
+            if AIRFLOW_V_3_0_PLUS:
+                run_id = DagRun.generate_run_id(
+                    run_type=DagRunType.MANUAL,
+                    logical_date=parsed_logical_date,
+                    run_after=parsed_logical_date or timezone.utcnow(),
+                )
+            else:
+                run_id = DagRun.generate_run_id(DagRunType.MANUAL, parsed_logical_date or timezone.utcnow())  # type: ignore[misc,call-arg]
 
+        if AIRFLOW_V_3_0_PLUS:
+            self._trigger_dag_af_3(context=context, run_id=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)
+
+    def _trigger_dag_af_3(self, context, run_id, parsed_logical_date):
+        from airflow.exceptions import DagRunTriggerException
+
+        raise DagRunTriggerException(
+            trigger_dag_id=self.trigger_dag_id,
+            dag_run_id=run_id,
+            conf=self.conf,
+            logical_date=parsed_logical_date,
+            reset_dag_run=self.reset_dag_run,
+            skip_when_already_exists=self.skip_when_already_exists,
+            wait_for_completion=self.wait_for_completion,
+            allowed_states=self.allowed_states,
+            failed_states=self.failed_states,
+            poke_interval=self.poke_interval,
+        )
+
+        # TODO: Support deferral
+
+    def _trigger_dag_af_2(self, context, run_id, parsed_logical_date):
         try:
             dag_run = trigger_dag(
                 dag_id=self.trigger_dag_id,
                 run_id=run_id,
                 conf=self.conf,
-                logical_date=parsed_logical_date,
+                execution_date=parsed_logical_date,
                 replace_microseconds=False,
-                triggered_by=DagRunTriggeredByType.OPERATOR,
             )
 
         except DagRunAlreadyExists as e:
@@ -231,7 +258,7 @@ class TriggerDagRunOperator(BaseOperator):
                 # Note: here execution fails on database isolation mode. Needs structural changes for AIP-72
                 dag_bag = DagBag(dag_folder=dag_model.fileloc, read_dags_from_db=True)
                 dag = dag_bag.get_dag(self.trigger_dag_id)
-                dag.clear(run_id=dag_run.run_id)
+                dag.clear(start_date=dag_run.logical_date, end_date=dag_run.logical_date)
             else:
                 if self.skip_when_already_exists:
                     raise AirflowSkipException(
@@ -252,6 +279,7 @@ class TriggerDagRunOperator(BaseOperator):
                     trigger=DagStateTrigger(
                         dag_id=self.trigger_dag_id,
                         states=self.allowed_states + self.failed_states,
+                        execution_dates=[dag_run.logical_date],
                         run_ids=[run_id],
                         poll_interval=self.poke_interval,
                     ),
@@ -278,16 +306,18 @@ class TriggerDagRunOperator(BaseOperator):
 
     @provide_session
     def execute_complete(self, context: Context, session: Session, event: tuple[str, dict[str, Any]]):
-        # This run_ids is parsed from the return trigger event
-        provided_run_id = event[1]["run_ids"][0]
+        # This logical_date is parsed from the return trigger event
+        provided_logical_date = event[1]["execution_dates"][0]
         try:
             # Note: here execution fails on database isolation mode. Needs structural changes for AIP-72
             dag_run = session.execute(
-                select(DagRun).where(DagRun.dag_id == self.trigger_dag_id, DagRun.run_id == provided_run_id)
+                select(DagRun).where(
+                    DagRun.dag_id == self.trigger_dag_id, DagRun.execution_date == provided_logical_date
+                )
             ).scalar_one()
         except NoResultFound:
             raise AirflowException(
-                f"No DAG run found for DAG {self.trigger_dag_id} and run ID {provided_run_id}"
+                f"No DAG run found for DAG {self.trigger_dag_id} and logical date {self.logical_date}"
             )
 
         state = dag_run.state

airflow/providers/standard/operators/weekday.py

@@ -20,9 +20,9 @@ from __future__ import annotations
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
-from airflow.operators.branch import BaseBranchOperator
+from airflow.providers.standard.operators.branch import BaseBranchOperator
+from airflow.providers.standard.utils.weekday import WeekDay
 from airflow.utils import timezone
-from airflow.utils.weekday import WeekDay
 
 if TYPE_CHECKING:
     try:
@@ -63,7 +63,7 @@ class BranchDayOfWeekOperator(BaseBranchOperator):
     .. code-block:: python
 
         # import WeekDay Enum
-        from airflow.utils.weekday import WeekDay
+        from airflow.providers.standard.utils.weekday import WeekDay
         from airflow.providers.standard.operators.empty import EmptyOperator
         from airflow.operators.weekday import BranchDayOfWeekOperator
 

airflow/providers/standard/sensors/time_delta.py

@@ -46,29 +46,48 @@ def _get_airflow_version():
 
 class TimeDeltaSensor(BaseSensorOperator):
     """
-    Waits for a timedelta after the run's data interval.
+    Waits for a timedelta.
 
-    :param delta: time length to wait after the data interval before succeeding.
+    The delta will be evaluated against data_interval_end if present for the dag run,
+    otherwise run_after will be used.
+
+    :param delta: time to wait before succeeding.
 
     .. seealso::
         For more information on how to use this sensor, take a look at the guide:
         :ref:`howto/operator:TimeDeltaSensor`
 
-
     """
 
     def __init__(self, *, delta, **kwargs):
         super().__init__(**kwargs)
         self.delta = delta
 
-    def poke(self, context: Context):
-        data_interval_end = context["data_interval_end"]
+    def _derive_base_time(self, context: Context) -> datetime:
+        """
+        Get the "base time" against which the delta should be calculated.
+
+        If data_interval_end is populated, use it; else use run_after.
+        """
+        data_interval_end = context.get("data_interval_end")
+        if data_interval_end:
+            if not isinstance(data_interval_end, datetime):
+                raise ValueError("`data_interval_end` returned non-datetime object")
 
-        if not isinstance(data_interval_end, datetime):
-            raise ValueError("`data_interval_end` returned non-datetime object")
+            return data_interval_end
 
-        target_dttm: datetime = data_interval_end + self.delta
-        self.log.info("Checking if the time (%s) has come", target_dttm)
+        if not data_interval_end and not AIRFLOW_V_3_0_PLUS:
+            raise ValueError("`data_interval_end` not found in task context.")
+
+        dag_run = context.get("dag_run")
+        if not dag_run:
+            raise ValueError("`dag_run` not found in task context")
+        return dag_run.run_after
+
+    def poke(self, context: Context) -> bool:
+        base_time = self._derive_base_time(context=context)
+        target_dttm = base_time + self.delta
+        self.log.info("Checking if the delta has elapsed base_time=%s, delta=%s", base_time, self.delta)
         return timezone.utcnow() > target_dttm
 
 
@@ -92,12 +111,8 @@ class TimeDeltaSensorAsync(TimeDeltaSensor):
         self.end_from_trigger = end_from_trigger
 
     def execute(self, context: Context) -> bool | NoReturn:
-        data_interval_end = context["data_interval_end"]
-
-        if not isinstance(data_interval_end, datetime):
-            raise ValueError("`data_interval_end` returned non-datetime object")
-
-        target_dttm: datetime = data_interval_end + self.delta
+        base_time = self._derive_base_time(context=context)
+        target_dttm: datetime = base_time + self.delta
 
         if timezone.utcnow() > target_dttm:
             # If the target datetime is in the past, return immediately

airflow/providers/standard/sensors/weekday.py

@@ -20,9 +20,9 @@ from __future__ import annotations
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
+from airflow.providers.standard.utils.weekday import WeekDay
 from airflow.sensors.base import BaseSensorOperator
 from airflow.utils import timezone
-from airflow.utils.weekday import WeekDay
 
 if TYPE_CHECKING:
     try:
@@ -54,7 +54,7 @@ class DayOfWeekSensor(BaseSensorOperator):
     **Example** (with :class:`~airflow.utils.weekday.WeekDay` enum): ::
 
         # import WeekDay Enum
-        from airflow.utils.weekday import WeekDay
+        from airflow.providers.standard.utils.weekday import WeekDay
 
         weekend_check = DayOfWeekSensor(
             task_id="weekend_check",
@@ -103,7 +103,21 @@ class DayOfWeekSensor(BaseSensorOperator):
             self.week_day,
             WeekDay(timezone.utcnow().isoweekday()).name,
         )
+
         if self.use_task_logical_date:
-            return context["logical_date"].isoweekday() in self._week_day_num
+            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 `run_after` should be provided in the task context when "
+                    "`use_task_logical_date` is True"
+                )
+
+            determined_weekday_num = (
+                logical_date.isoweekday() if logical_date else dag_run.run_after.isoweekday()  # type: ignore[union-attr]
+            )
+
+            return determined_weekday_num in self._week_day_num
         else:
             return timezone.utcnow().isoweekday() in self._week_day_num

airflow/providers/standard/utils/python_virtualenv_script.jinja2

@@ -20,7 +20,12 @@ from __future__ import annotations
 
 import {{ pickling_library }}
 import sys
+import os
+# Setting the PYTHON_OPERATORS_VIRTUAL_ENV_MODE environment variable to 1,
+# helps to avoid the issue of re creating the orm session in the settings file, otherwise
+# it fails with airflow-db-not-allowed
 
+os.environ["PYTHON_OPERATORS_VIRTUAL_ENV_MODE"] = "1"
 {% if expect_airflow %}
  {# Check whether Airflow is available in the environment.
  # If it is, we'll want to ensure that we integrate any macros that are being provided

airflow/providers/standard/utils/skipmixin.py

@@ -0,0 +1,192 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from types import GeneratorType
+from typing import TYPE_CHECKING
+
+from airflow.exceptions import AirflowException
+from airflow.utils.log.logging_mixin import LoggingMixin
+
+if TYPE_CHECKING:
+    from airflow.models.operator import Operator
+    from airflow.sdk.definitions._internal.node import DAGNode
+    from airflow.sdk.types import RuntimeTaskInstanceProtocol
+
+# The key used by SkipMixin to store XCom data.
+XCOM_SKIPMIXIN_KEY = "skipmixin_key"
+
+# The dictionary key used to denote task IDs that are skipped
+XCOM_SKIPMIXIN_SKIPPED = "skipped"
+
+# The dictionary key used to denote task IDs that are followed
+XCOM_SKIPMIXIN_FOLLOWED = "followed"
+
+
+def _ensure_tasks(nodes: Iterable[DAGNode]) -> Sequence[Operator]:
+    from airflow.models.baseoperator import BaseOperator
+    from airflow.models.mappedoperator import MappedOperator
+
+    return [n for n in nodes if isinstance(n, (BaseOperator, MappedOperator))]
+
+
+# This class should only be used in Airflow 3.0 and later.
+class SkipMixin(LoggingMixin):
+    """A Mixin to skip Tasks Instances."""
+
+    @staticmethod
+    def _set_state_to_skipped(
+        tasks: Sequence[str | tuple[str, int]],
+        map_index: int | None,
+    ) -> None:
+        """
+        Set state of task instances to skipped from the same dag run.
+
+        Raises
+        ------
+        SkipDownstreamTaskInstances
+            If the task instances are not in the same dag run.
+        """
+        # Import is internal for backward compatibility when importing PythonOperator
+        # from airflow.providers.common.compat.standard.operators
+        from airflow.exceptions import DownstreamTasksSkipped
+
+        #  The following could be applied only for non-mapped tasks,
+        #  as future mapped tasks have not been expanded yet. Such tasks
+        #  have to be handled by NotPreviouslySkippedDep.
+        if tasks and map_index == -1:
+            raise DownstreamTasksSkipped(tasks=tasks)
+
+    def skip(
+        self,
+        ti: RuntimeTaskInstanceProtocol,
+        tasks: Iterable[DAGNode],
+    ):
+        """
+        Set tasks instances to skipped from the same dag run.
+
+        If this instance has a `task_id` attribute, store the list of skipped task IDs to XCom
+        so that NotPreviouslySkippedDep knows these tasks should be skipped when they
+        are cleared.
+
+        :param ti: the task instance for which to set the tasks to skipped
+        :param tasks: tasks to skip (not task_ids)
+        """
+        # SkipMixin may not necessarily have a task_id attribute. Only store to XCom if one is available.
+        task_id: str | None = getattr(self, "task_id", None)
+        task_list = _ensure_tasks(tasks)
+        if not task_list:
+            return
+
+        task_ids_list = [d.task_id for d in task_list]
+
+        if task_id is not None:
+            ti.xcom_push(
+                key=XCOM_SKIPMIXIN_KEY,
+                value={XCOM_SKIPMIXIN_SKIPPED: task_ids_list},
+            )
+
+        self._set_state_to_skipped(task_ids_list, ti.map_index)
+
+    def skip_all_except(
+        self,
+        ti: RuntimeTaskInstanceProtocol,
+        branch_task_ids: None | str | Iterable[str],
+    ):
+        """
+        Implement the logic for a branching operator.
+
+        Given a single task ID or list of task IDs to follow, this skips all other tasks
+        immediately downstream of this operator.
+
+        branch_task_ids is stored to XCom so that NotPreviouslySkippedDep knows skipped tasks or
+        newly added tasks should be skipped when they are cleared.
+        """
+        # Ensure we don't serialize a generator object
+        if branch_task_ids and isinstance(branch_task_ids, GeneratorType):
+            branch_task_ids = list(branch_task_ids)
+        log = self.log  # Note: need to catch logger form instance, static logger breaks pytest
+        if isinstance(branch_task_ids, str):
+            branch_task_id_set = {branch_task_ids}
+        elif isinstance(branch_task_ids, Iterable):
+            branch_task_id_set = set(branch_task_ids)
+            invalid_task_ids_type = {
+                (bti, type(bti).__name__) for bti in branch_task_id_set if not isinstance(bti, str)
+            }
+            if invalid_task_ids_type:
+                raise AirflowException(
+                    f"'branch_task_ids' expected all task IDs are strings. "
+                    f"Invalid tasks found: {invalid_task_ids_type}."
+                )
+        elif branch_task_ids is None:
+            branch_task_id_set = set()
+        else:
+            raise AirflowException(
+                "'branch_task_ids' must be either None, a task ID, or an Iterable of IDs, "
+                f"but got {type(branch_task_ids).__name__!r}."
+            )
+
+        log.info("Following branch %s", branch_task_id_set)
+
+        if TYPE_CHECKING:
+            assert ti.task
+
+        task = ti.task
+        dag = ti.task.dag
+
+        valid_task_ids = set(dag.task_ids)
+        invalid_task_ids = branch_task_id_set - valid_task_ids
+        if invalid_task_ids:
+            raise AirflowException(
+                "'branch_task_ids' must contain only valid task_ids. "
+                f"Invalid tasks found: {invalid_task_ids}."
+            )
+
+        downstream_tasks = _ensure_tasks(task.downstream_list)
+
+        if downstream_tasks:
+            # For a branching workflow that looks like this, when "branch" does skip_all_except("task1"),
+            # we intuitively expect both "task1" and "join" to execute even though strictly speaking,
+            # "join" is also immediately downstream of "branch" and should have been skipped. Therefore,
+            # we need a special case here for such empty branches: Check downstream tasks of branch_task_ids.
+            # In case the task to skip is also downstream of branch_task_ids, we add it to branch_task_ids and
+            # exclude it from skipping.
+            #
+            # branch  ----->  join
+            #   \            ^
+            #     v        /
+            #       task1
+            #
+            for branch_task_id in list(branch_task_id_set):
+                branch_task_id_set.update(dag.get_task(branch_task_id).get_flat_relative_ids(upstream=False))
+
+            skip_tasks = [
+                (t.task_id, ti.map_index) for t in downstream_tasks if t.task_id not in branch_task_id_set
+            ]
+
+            follow_task_ids = [t.task_id for t in downstream_tasks if t.task_id in branch_task_id_set]
+            log.info("Skipping tasks %s", skip_tasks)
+            ti.xcom_push(
+                key=XCOM_SKIPMIXIN_KEY,
+                value={XCOM_SKIPMIXIN_FOLLOWED: follow_task_ids},
+            )
+            #  The following could be applied only for non-mapped tasks,
+            #  as future mapped tasks have not been expanded yet. Such tasks
+            #  have to be handled by NotPreviouslySkippedDep.
+            self._set_state_to_skipped(skip_tasks, ti.map_index)  # type: ignore[arg-type]

airflow/providers/standard/utils/weekday.py

@@ -0,0 +1,77 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Get the ISO standard day number of the week from a given day string."""
+
+from __future__ import annotations
+
+import enum
+from collections.abc import Iterable
+
+
+@enum.unique
+class WeekDay(enum.IntEnum):
+    """Python Enum containing Days of the Week."""
+
+    MONDAY = 1
+    TUESDAY = 2
+    WEDNESDAY = 3
+    THURSDAY = 4
+    FRIDAY = 5
+    SATURDAY = 6
+    SUNDAY = 7
+
+    @classmethod
+    def get_weekday_number(cls, week_day_str: str):
+        """
+        Return the ISO Week Day Number for a Week Day.
+
+        :param week_day_str: Full Name of the Week Day. Example: "Sunday"
+        :return: ISO Week Day Number corresponding to the provided Weekday
+        """
+        sanitized_week_day_str = week_day_str.upper()
+
+        if sanitized_week_day_str not in cls.__members__:
+            raise AttributeError(f'Invalid Week Day passed: "{week_day_str}"')
+
+        return cls[sanitized_week_day_str]
+
+    @classmethod
+    def convert(cls, day: str | WeekDay) -> int:
+        """Return the day number in the week."""
+        if isinstance(day, WeekDay):
+            return day
+        return cls.get_weekday_number(week_day_str=day)
+
+    @classmethod
+    def validate_week_day(
+        cls,
+        week_day: str | WeekDay | Iterable[str] | Iterable[WeekDay],
+    ) -> set[int]:
+        """Validate each item of iterable and create a set to ease compare of values."""
+        if not isinstance(week_day, Iterable):
+            if isinstance(week_day, WeekDay):
+                week_day = {week_day}
+            else:
+                raise TypeError(
+                    f"Unsupported Type for week_day parameter: {type(week_day)}."
+                    "Input should be iterable type:"
+                    "str, set, list, dict or Weekday enum type"
+                )
+        if isinstance(week_day, str):
+            week_day = {week_day}
+
+        return {cls.convert(item) for item in week_day}

{apache_airflow_providers_standard-0.1.1rc1.dist-info → apache_airflow_providers_standard-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-standard
-Version: 0.1.1rc1
+Version: 0.2.0
 Summary: Provider package apache-airflow-providers-standard for Apache Airflow
 Keywords: airflow-provider,standard,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -20,13 +20,13 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
-Requires-Dist: apache-airflow>=2.9.0rc0
+Requires-Dist: apache-airflow>=2.9.0
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.1.1/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.1.1
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.2.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.2.0
+Project-URL: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
-Project-URL: Twitter, https://x.com/ApacheAirflow
 Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 
@@ -54,7 +54,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-standard``
 
-Release: ``0.1.1``
+Release: ``0.2.0``
 
 
 Airflow Standard Provider
@@ -67,7 +67,7 @@ This is a provider package for ``standard`` provider. All classes for this provi
 are in ``airflow.providers.standard`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.1.1/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.2.0/>`_.
 
 Installation
 ------------
@@ -88,5 +88,5 @@ PIP package         Version required
 ==================  ==================
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.1.1/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.2.0/changelog.html>`_.
 

{apache_airflow_providers_standard-0.1.1rc1.dist-info → apache_airflow_providers_standard-0.2.0.dist-info}/RECORD

@@ -1,20 +1,21 @@
 airflow/providers/standard/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/standard/__init__.py,sha256=oKPXyaF0Nga5JSyyp76PexiS-ziduggLTXve8T5s6kQ,1495
-airflow/providers/standard/get_provider_info.py,sha256=sfKYpLnXfvTkEo96DyJbJdc0C5EW5QTIMzAiFXreZRU,4925
+airflow/providers/standard/__init__.py,sha256=1JnLSwdhaPlf4-fFYYRzmIXascrRrb-dPF5ATK7OSE4,1495
+airflow/providers/standard/get_provider_info.py,sha256=pgEtex_ULwmTYoAoSWRib8eZP0Kh49Kshbgskx2eY-I,5001
 airflow/providers/standard/version_compat.py,sha256=aHg90_DtgoSnQvILFICexMyNlHlALBdaeWqkX3dFDug,1605
 airflow/providers/standard/hooks/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/hooks/filesystem.py,sha256=fDZwW_EYD8z1QXnReqI7gIwSbDPZNTKtqQvgktiP02o,2870
 airflow/providers/standard/hooks/package_index.py,sha256=U7_s_02-wwz9kTkzKr3JAhVQj2spuntWd_GmjfpV-y4,3769
 airflow/providers/standard/hooks/subprocess.py,sha256=GAmdF69jwUcpc7DH5I42GnJRs6NMQvHwFhimWpIdTU4,4920
 airflow/providers/standard/operators/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/standard/operators/bash.py,sha256=AMSTPCgtArDE78XQ01b5jf1d3HEbZuP8_xz9dyXQgKc,13664
-airflow/providers/standard/operators/datetime.py,sha256=vsn2eaeVvUZBLXTzrEIC5Bd9svk81gM2VlxXCcmZhHY,4749
+airflow/providers/standard/operators/bash.py,sha256=dwi_TgXxeaQBVTuBZLq-omh5-Ul4ktCXzubuQWeS-0c,11405
+airflow/providers/standard/operators/branch.py,sha256=C_AUd7TSo_U52GiWsrR7rJIsRU5KKfrybBFw84brm_c,4070
+airflow/providers/standard/operators/datetime.py,sha256=eHcjqjLqrFi_YFtN8KBB40DJ7OyE8upH5zUUzO0I0cI,4768
 airflow/providers/standard/operators/empty.py,sha256=C7_uLWJK6kExzlNc7xdMo8VAQ_ONWITvEQ2FImrMepM,1324
-airflow/providers/standard/operators/latest_only.py,sha256=iENi2PkJoQH-S_xP6v-vW1UtIM5srfjJz4ho-vPeTeI,3358
-airflow/providers/standard/operators/python.py,sha256=3M_i160nXjRRNpCLJkno2k8GvaLyw6vEkiDBG--4W2o,49158
+airflow/providers/standard/operators/latest_only.py,sha256=OdUbeJA0_HuqxPFo8zFefkysUWtGpvdvoVEfIy0yJPo,3377
+airflow/providers/standard/operators/python.py,sha256=_ssens0qUAaUkSlAq9RsgLj9Y4Mo4Av6LEDqC5S4HWo,50115
 airflow/providers/standard/operators/smooth.py,sha256=d3OV38EzV_wlfMYN3JGWGwyzsFonx8VbqgGfXSw0_bM,1382
-airflow/providers/standard/operators/trigger_dagrun.py,sha256=MO4im8m1PbM8G_HYxx4rNeRzK54683CNslAYyl9BYxw,12785
-airflow/providers/standard/operators/weekday.py,sha256=XL1fMejCoCrifl52t9QmlrnavL3Nm3_VYbhUMWhI10I,4841
+airflow/providers/standard/operators/trigger_dagrun.py,sha256=xXGVZOaIB8Ru2tALmmS-IWjzKhA3dFhiOpa3GTuKxeQ,14231
+airflow/providers/standard/operators/weekday.py,sha256=5tDS3V4hhKdE_POgmhQkyGQ9UyG6VdxjqAknW9EYu84,4898
 airflow/providers/standard/sensors/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/sensors/bash.py,sha256=afyz1m-1qzAp1fE5ta71rXhpTrKcCH7bNfwUU2Hv7GQ,5025
 airflow/providers/standard/sensors/date_time.py,sha256=hRUuLaNgqDh4jqaIaD8zdyq2BUXkpWM2NzJN5YkwTJI,6077
@@ -22,17 +23,19 @@ airflow/providers/standard/sensors/external_task.py,sha256=LJhmPg0dSxcZQ7OfNf5Cm
 airflow/providers/standard/sensors/filesystem.py,sha256=rfupSeHtFGdAcL6cw3H6u6ttBxogSThYiPqsUKgABMU,6029
 airflow/providers/standard/sensors/python.py,sha256=kvgpHN8hiyxJPlw9HsVpna0X6NRt0iTDvFFjqt3KFtQ,3405
 airflow/providers/standard/sensors/time.py,sha256=Pc9BZqqTQy3Qqz7uME9yF4qmWsXYCzAoAlsmwgpAraY,5007
-airflow/providers/standard/sensors/time_delta.py,sha256=H1jSNT72e-83usqMPMIRSgnR41IAFwkrafmE006jAOc,6012
-airflow/providers/standard/sensors/weekday.py,sha256=GdYa-DdKdQ_cOpuAFppHSaDKrzGGvVha4BfkoiJLTpM,3884
+airflow/providers/standard/sensors/time_delta.py,sha256=1OlDMIwNYXhBeeE8TmfsAMIFIOur4BMlDWe0L_JScZc,6633
+airflow/providers/standard/sensors/weekday.py,sha256=HzV21T3XhrQgfsR6svl6uWlJNPSnTbAHbQKd0jifIUU,4467
 airflow/providers/standard/triggers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/triggers/external_task.py,sha256=iZn-WsjTlJRd780xVds6rrTOrfLkf-Bp3Q1PbGfbYuU,8476
 airflow/providers/standard/triggers/file.py,sha256=2i8-RwSjEgdOwQNcHCqLmSdpE3Ehqg4GQJ8nE3-fHxo,4886
 airflow/providers/standard/triggers/temporal.py,sha256=Aub7Cp3HsPdeardF2jp-Z5nIRwzqtK9-aOlWtfKQfcg,4809
 airflow/providers/standard/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/standard/utils/python_virtualenv.py,sha256=FR3241l5Obuo2BBwwBs-s87pRpCLyJnh3sUtHxrgRuM,7759
-airflow/providers/standard/utils/python_virtualenv_script.jinja2,sha256=bn_QOYOj8Q2k-RE77LKgCy3iDTuv9vllyBAD4yeCb-A,2502
+airflow/providers/standard/utils/python_virtualenv_script.jinja2,sha256=3Z334hVq6hQ9EHkOoGnAHc2_XNkZQkOJGxZArDKLc-c,2770
 airflow/providers/standard/utils/sensor_helper.py,sha256=BeaWt9X4PUE49V3QAG8WPHj3fWwUGeZngS5_Y8g_auA,4401
-apache_airflow_providers_standard-0.1.1rc1.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
-apache_airflow_providers_standard-0.1.1rc1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-apache_airflow_providers_standard-0.1.1rc1.dist-info/METADATA,sha256=5u58PWUwqYsyk8idmEmc38OFJd14B3wWBurY33HV0LI,3788
-apache_airflow_providers_standard-0.1.1rc1.dist-info/RECORD,,
+airflow/providers/standard/utils/skipmixin.py,sha256=XkhDozcXUHZ7C6AxzEW8ZYrqbra1oJGGR3ZieNQ-N0M,7791
+airflow/providers/standard/utils/weekday.py,sha256=ySDrIkWv-lqqxURo9E98IGInDqERec2O4y9o2hQTGiQ,2685
+apache_airflow_providers_standard-0.2.0.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
+apache_airflow_providers_standard-0.2.0.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+apache_airflow_providers_standard-0.2.0.dist-info/METADATA,sha256=ixBhZtySv3yscp9Elv3SnoSAQOCvFoLFsjHOKOh_SA0,3786
+apache_airflow_providers_standard-0.2.0.dist-info/RECORD,,