apache-airflow-providers-standard 0.2.0rc1__py3-none-any.whl → 0.3.0rc2__py3-none-any.whl

airflow/providers/standard/__init__.py

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

airflow/providers/standard/decorators/__init__.py

@@ -0,0 +1,16 @@
+# 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.

airflow/providers/standard/decorators/bash.py

@@ -0,0 +1,111 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Collection, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
+
+from airflow.decorators.base import DecoratedOperator, TaskDecorator, task_decorator_factory
+from airflow.providers.standard.operators.bash import BashOperator
+from airflow.sdk.definitions._internal.types import SET_DURING_EXECUTION
+from airflow.utils.context import context_merge
+from airflow.utils.operator_helpers import determine_kwargs
+
+if TYPE_CHECKING:
+    from airflow.sdk.definitions.context import Context
+
+
+class _BashDecoratedOperator(DecoratedOperator, BashOperator):
+    """
+    Wraps a Python callable and uses the callable return value as the Bash command to be executed.
+
+    :param python_callable: A reference to an object that is callable.
+    :param op_kwargs: A dictionary of keyword arguments that will get unpacked
+        in your function (templated).
+    :param op_args: A list of positional arguments that will get unpacked when
+        calling your callable (templated).
+    """
+
+    template_fields: Sequence[str] = (*DecoratedOperator.template_fields, *BashOperator.template_fields)
+    template_fields_renderers: ClassVar[dict[str, str]] = {
+        **DecoratedOperator.template_fields_renderers,
+        **BashOperator.template_fields_renderers,
+    }
+
+    custom_operator_name: str = "@task.bash"
+    overwrite_rtif_after_execution: bool = True
+
+    def __init__(
+        self,
+        *,
+        python_callable: Callable,
+        op_args: Collection[Any] | None = None,
+        op_kwargs: Mapping[str, Any] | None = None,
+        **kwargs,
+    ) -> None:
+        if kwargs.pop("multiple_outputs", None):
+            warnings.warn(
+                f"`multiple_outputs=True` is not supported in {self.custom_operator_name} tasks. Ignoring.",
+                UserWarning,
+                stacklevel=3,
+            )
+
+        super().__init__(
+            python_callable=python_callable,
+            op_args=op_args,
+            op_kwargs=op_kwargs,
+            bash_command=SET_DURING_EXECUTION,
+            multiple_outputs=False,
+            **kwargs,
+        )
+
+    def execute(self, context: Context) -> Any:
+        context_merge(context, self.op_kwargs)
+        kwargs = determine_kwargs(self.python_callable, self.op_args, context)
+
+        self.bash_command = self.python_callable(*self.op_args, **kwargs)
+
+        if not isinstance(self.bash_command, str) or self.bash_command.strip() == "":
+            raise TypeError("The returned value from the TaskFlow callable must be a non-empty string.")
+
+        self._is_inline_cmd = self._is_inline_command(bash_command=self.bash_command)
+        context["ti"].render_templates()  # type: ignore[attr-defined]
+
+        return super().execute(context)
+
+
+def bash_task(
+    python_callable: Callable | None = None,
+    **kwargs,
+) -> TaskDecorator:
+    """
+    Wrap a function into a BashOperator.
+
+    Accepts kwargs for operator kwargs. Can be reused in a single DAG. This function is only used only used
+    during type checking or auto-completion.
+
+    :param python_callable: Function to decorate.
+
+    :meta private:
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        decorated_operator_class=_BashDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/branch_external_python.py

@@ -0,0 +1,57 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchExternalPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _BranchExternalPythonDecoratedOperator(_PythonDecoratedOperator, BranchExternalPythonOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = BranchExternalPythonOperator.template_fields
+    custom_operator_name: str = "@task.branch_external_python"
+
+
+def branch_external_python_task(
+    python_callable: Callable | None = None, multiple_outputs: bool | None = None, **kwargs
+) -> TaskDecorator:
+    """
+    Wrap a python function into a BranchExternalPythonOperator.
+
+    For more information on how to use this operator, take a look at the guide:
+    :ref:`concepts:branching`
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: if set, function return value will be
+        unrolled to multiple XCom values. Dict will unroll to xcom values with keys as XCom keys.
+        Defaults to False.
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_BranchExternalPythonDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/branch_python.py

@@ -0,0 +1,57 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _BranchPythonDecoratedOperator(_PythonDecoratedOperator, BranchPythonOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = BranchPythonOperator.template_fields
+    custom_operator_name: str = "@task.branch"
+
+
+def branch_task(
+    python_callable: Callable | None = None, multiple_outputs: bool | None = None, **kwargs
+) -> TaskDecorator:
+    """
+    Wrap a python function into a BranchPythonOperator.
+
+    For more information on how to use this operator, take a look at the guide:
+    :ref:`concepts:branching`
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: if set, function return value will be
+        unrolled to multiple XCom values. Dict will unroll to xcom values with keys as XCom keys.
+        Defaults to False.
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_BranchPythonDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/branch_virtualenv.py

@@ -0,0 +1,57 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchPythonVirtualenvOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _BranchPythonVirtualenvDecoratedOperator(_PythonDecoratedOperator, BranchPythonVirtualenvOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = BranchPythonVirtualenvOperator.template_fields
+    custom_operator_name: str = "@task.branch_virtualenv"
+
+
+def branch_virtualenv_task(
+    python_callable: Callable | None = None, multiple_outputs: bool | None = None, **kwargs
+) -> TaskDecorator:
+    """
+    Wrap a python function into a BranchPythonVirtualenvOperator.
+
+    For more information on how to use this operator, take a look at the guide:
+    :ref:`concepts:branching`
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: if set, function return value will be
+        unrolled to multiple XCom values. Dict will unroll to xcom values with keys as XCom keys.
+        Defaults to False.
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_BranchPythonVirtualenvDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/external_python.py

@@ -0,0 +1,65 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import ExternalPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _PythonExternalDecoratedOperator(_PythonDecoratedOperator, ExternalPythonOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = ExternalPythonOperator.template_fields
+    custom_operator_name: str = "@task.external_python"
+
+
+def external_python_task(
+    python: str | None = None,
+    python_callable: Callable | None = None,
+    multiple_outputs: bool | None = None,
+    **kwargs,
+) -> TaskDecorator:
+    """
+    Wrap a callable into an Airflow operator to run via a Python virtual environment.
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    This function is only used during type checking or auto-completion.
+
+    :meta private:
+
+    :param python: Full path string (file-system specific) that points to a Python binary inside
+        a virtualenv that should be used (in ``VENV/bin`` folder). Should be absolute path
+        (so usually start with "/" or "X:/" depending on the filesystem/os used).
+    :param python_callable: Function to decorate
+    :param multiple_outputs: If set to True, the decorated function's return value will be unrolled to
+        multiple XCom values. Dict will unroll to XCom values with its keys as XCom keys.
+        Defaults to False.
+    """
+    return task_decorator_factory(
+        python=python,
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_PythonExternalDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/python.py

@@ -0,0 +1,81 @@
+# 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 Sequence
+from typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import DecoratedOperator, task_decorator_factory
+from airflow.providers.standard.operators.python import PythonOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _PythonDecoratedOperator(DecoratedOperator, PythonOperator):
+    """
+    Wraps a Python callable and captures args/kwargs when called for execution.
+
+    :param python_callable: A reference to an object that is callable
+    :param op_kwargs: a dictionary of keyword arguments that will get unpacked
+        in your function (templated)
+    :param op_args: a list of positional arguments that will get unpacked when
+        calling your callable (templated)
+    :param multiple_outputs: If set to True, the decorated function's return value will be unrolled to
+        multiple XCom values. Dict will unroll to XCom values with its keys as XCom keys. Defaults to False.
+    """
+
+    template_fields: Sequence[str] = ("templates_dict", "op_args", "op_kwargs")
+    template_fields_renderers = {"templates_dict": "json", "op_args": "py", "op_kwargs": "py"}
+
+    custom_operator_name: str = "@task"
+
+    def __init__(self, *, python_callable, op_args, op_kwargs, **kwargs) -> None:
+        kwargs_to_upstream = {
+            "python_callable": python_callable,
+            "op_args": op_args,
+            "op_kwargs": op_kwargs,
+        }
+        super().__init__(
+            kwargs_to_upstream=kwargs_to_upstream,
+            python_callable=python_callable,
+            op_args=op_args,
+            op_kwargs=op_kwargs,
+            **kwargs,
+        )
+
+
+def python_task(
+    python_callable: Callable | None = None,
+    multiple_outputs: bool | None = None,
+    **kwargs,
+) -> TaskDecorator:
+    """
+    Wrap a function into an Airflow operator.
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: If set to True, the decorated function's return value will be unrolled to
+        multiple XCom values. Dict will unroll to XCom values with its keys as XCom keys. Defaults to False.
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_PythonDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/python_virtualenv.py

@@ -0,0 +1,60 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import PythonVirtualenvOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _PythonVirtualenvDecoratedOperator(_PythonDecoratedOperator, PythonVirtualenvOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = PythonVirtualenvOperator.template_fields
+    custom_operator_name: str = "@task.virtualenv"
+
+
+def virtualenv_task(
+    python_callable: Callable | None = None,
+    multiple_outputs: bool | None = None,
+    **kwargs,
+) -> TaskDecorator:
+    """
+    Wrap a callable into an Airflow operator to run via a Python virtual environment.
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    This function is only used only used during type checking or auto-completion.
+
+    :meta private:
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: If set to True, the decorated function's return value will be unrolled to
+        multiple XCom values. Dict will unroll to XCom values with its keys as XCom keys.
+        Defaults to False.
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_PythonVirtualenvDecoratedOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/sensor.py

@@ -0,0 +1,76 @@
+# 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 Sequence
+from typing import TYPE_CHECKING, Callable, ClassVar
+
+from airflow.decorators.base import get_unique_task_id, task_decorator_factory
+from airflow.providers.standard.sensors.python import PythonSensor
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class DecoratedSensorOperator(PythonSensor):
+    """
+    Wraps a Python callable and captures args/kwargs when called for execution.
+
+    :param python_callable: A reference to an object that is callable
+    :param task_id: task Id
+    :param op_args: a list of positional arguments that will get unpacked when
+        calling your callable (templated)
+    :param op_kwargs: a dictionary of keyword arguments that will get unpacked
+        in your function (templated)
+    :param kwargs_to_upstream: For certain operators, we might need to upstream certain arguments
+        that would otherwise be absorbed by the DecoratedOperator (for example python_callable for the
+        PythonOperator). This gives a user the option to upstream kwargs as needed.
+    """
+
+    template_fields: Sequence[str] = ("op_args", "op_kwargs")
+    template_fields_renderers: ClassVar[dict[str, str]] = {"op_args": "py", "op_kwargs": "py"}
+
+    custom_operator_name = "@task.sensor"
+
+    # since we won't mutate the arguments, we should just do the shallow copy
+    # there are some cases we can't deepcopy the objects (e.g protobuf).
+    shallow_copy_attrs: Sequence[str] = ("python_callable",)
+
+    def __init__(
+        self,
+        *,
+        task_id: str,
+        **kwargs,
+    ) -> None:
+        kwargs["task_id"] = get_unique_task_id(task_id, kwargs.get("dag"), kwargs.get("task_group"))
+        super().__init__(**kwargs)
+
+
+def sensor_task(python_callable: Callable | None = None, **kwargs) -> TaskDecorator:
+    """
+    Wrap a function into an Airflow operator.
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+    :param python_callable: Function to decorate
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=False,
+        decorated_operator_class=DecoratedSensorOperator,
+        **kwargs,
+    )

airflow/providers/standard/decorators/short_circuit.py

@@ -0,0 +1,59 @@
+# 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 typing import TYPE_CHECKING, Callable
+
+from airflow.decorators.base import task_decorator_factory
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import ShortCircuitOperator
+
+if TYPE_CHECKING:
+    from airflow.decorators.base import TaskDecorator
+
+
+class _ShortCircuitDecoratedOperator(_PythonDecoratedOperator, ShortCircuitOperator):
+    """Wraps a Python callable and captures args/kwargs when called for execution."""
+
+    template_fields = ShortCircuitOperator.template_fields
+    custom_operator_name: str = "@task.short_circuit"
+
+
+def short_circuit_task(
+    python_callable: Callable | None = None,
+    multiple_outputs: bool | None = None,
+    **kwargs,
+) -> TaskDecorator:
+    """
+    Wrap a function into an ShortCircuitOperator.
+
+    Accepts kwargs for operator kwarg. Can be reused in a single DAG.
+
+    This function is only used only used during type checking or auto-completion.
+
+    :param python_callable: Function to decorate
+    :param multiple_outputs: If set to True, the decorated function's return value will be unrolled to
+        multiple XCom values. Dict will unroll to XCom values with its keys as XCom keys. Defaults to False.
+
+    :meta private:
+    """
+    return task_decorator_factory(
+        python_callable=python_callable,
+        multiple_outputs=multiple_outputs,
+        decorated_operator_class=_ShortCircuitDecoratedOperator,
+        **kwargs,
+    )

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": 1742480519,
-        "versions": ["0.2.0", "0.1.1", "0.1.0", "0.0.3", "0.0.2", "0.0.1"],
+        "source-date-epoch": 1743477899,
+        "versions": ["0.3.0", "0.2.0", "0.1.1", "0.1.0", "0.0.3", "0.0.2", "0.0.1"],
         "integrations": [
             {
                 "integration-name": "Standard",
@@ -106,6 +106,35 @@ def get_provider_info():
                 },
             }
         },
+        "task-decorators": [
+            {"class-name": "airflow.providers.standard.decorators.python.python_task", "name": "python"},
+            {"class-name": "airflow.providers.standard.decorators.bash.bash_task", "name": "bash"},
+            {
+                "class-name": "airflow.providers.standard.decorators.branch_external_python.branch_external_python_task",
+                "name": "branch_external_python",
+            },
+            {
+                "class-name": "airflow.providers.standard.decorators.branch_python.branch_task",
+                "name": "branch",
+            },
+            {
+                "class-name": "airflow.providers.standard.decorators.branch_virtualenv.branch_virtualenv_task",
+                "name": "branch_virtualenv",
+            },
+            {
+                "class-name": "airflow.providers.standard.decorators.external_python.external_python_task",
+                "name": "external_python",
+            },
+            {
+                "class-name": "airflow.providers.standard.decorators.python_virtualenv.virtualenv_task",
+                "name": "virtualenv",
+            },
+            {"class-name": "airflow.providers.standard.decorators.sensor.sensor_task", "name": "sensor"},
+            {
+                "class-name": "airflow.providers.standard.decorators.short_circuit.short_circuit_task",
+                "name": "short_circuit",
+            },
+        ],
         "dependencies": ["apache-airflow>=2.9.0"],
         "devel-dependencies": [],
     }

airflow/providers/standard/operators/bash.py

@@ -253,7 +253,7 @@ class BashOperator(BaseOperator):
         """
         with working_directory(cwd=self.cwd) as cwd:
             with tempfile.NamedTemporaryFile(mode="w", dir=cwd, suffix=".sh") as file:
-                file.write(cast(str, self.bash_command))
+                file.write(cast("str", self.bash_command))
                 file.flush()
 
                 bash_script = os.path.basename(file.name)

airflow/providers/standard/operators/datetime.py

@@ -77,9 +77,14 @@ class BranchDateTimeOperator(BaseBranchOperator):
 
     def choose_branch(self, context: Context) -> str | Iterable[str]:
         if self.use_task_logical_date:
-            now = context["logical_date"]
+            now = context.get("logical_date")
+            if not now:
+                dag_run = context.get("dag_run")
+                now = dag_run.run_after  # type: ignore[union-attr, assignment]
         else:
             now = timezone.coerce_datetime(timezone.utcnow())
+        if TYPE_CHECKING:
+            assert isinstance(now, datetime.datetime)
         lower, upper = target_times_as_dates(now, self.target_lower, self.target_upper)
         lower = timezone.coerce_datetime(lower, self.dag.timezone)
         upper = timezone.coerce_datetime(upper, self.dag.timezone)

airflow/providers/standard/operators/python.py

@@ -56,7 +56,7 @@ if AIRFLOW_V_3_0_PLUS:
     from airflow.providers.standard.utils.skipmixin import SkipMixin
 else:
     from airflow.models.skipmixin import SkipMixin
-    from airflow.operators.branch import BranchMixIn
+    from airflow.operators.branch import BranchMixIn  # type: ignore[no-redef]
 
 
 log = logging.getLogger(__name__)
@@ -460,8 +460,7 @@ class _BasePythonVirtualenvOperator(PythonOperator, metaclass=ABCMeta):
         serializer = serializer or "pickle"
         if serializer not in _SERIALIZERS:
             msg = (
-                f"Unsupported serializer {serializer!r}. "
-                f"Expected one of {', '.join(map(repr, _SERIALIZERS))}"
+                f"Unsupported serializer {serializer!r}. Expected one of {', '.join(map(repr, _SERIALIZERS))}"
             )
             raise AirflowException(msg)
 
@@ -1142,7 +1141,6 @@ def _get_current_context() -> Mapping[str, Any]:
 
     if not _CURRENT_CONTEXT:
         raise RuntimeError(
-            "Current context was requested but no context was found! "
-            "Are you running within an Airflow task?"
+            "Current context was requested but no context was found! Are you running within an Airflow task?"
         )
     return _CURRENT_CONTEXT[-1]

airflow/providers/standard/operators/weekday.py

@@ -116,10 +116,13 @@ class BranchDayOfWeekOperator(BaseBranchOperator):
 
     def choose_branch(self, context: Context) -> str | Iterable[str]:
         if self.use_task_logical_date:
-            now = context["logical_date"]
+            now = context.get("logical_date")
+            if not now:
+                dag_run = context.get("dag_run")
+                now = dag_run.run_after  # type: ignore[union-attr, assignment]
         else:
             now = timezone.make_naive(timezone.utcnow(), self.dag.timezone)
 
-        if now.isoweekday() in self._week_day_num:
+        if now.isoweekday() in self._week_day_num:  # type: ignore[union-attr]
             return self.follow_task_ids_if_true
         return self.follow_task_ids_if_false

airflow/providers/standard/sensors/external_task.py

@@ -31,21 +31,26 @@ from airflow.providers.standard.operators.empty import EmptyOperator
 from airflow.providers.standard.triggers.external_task import WorkflowTrigger
 from airflow.providers.standard.utils.sensor_helper import _get_count, _get_external_task_group_task_ids
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
-from airflow.sensors.base import BaseSensorOperator
 from airflow.utils.file import correct_maybe_zipped
 from airflow.utils.session import NEW_SESSION, provide_session
 from airflow.utils.state import State, TaskInstanceState
 
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.sensor import BaseSensorOperator
+else:
+    from airflow.sensors.base import BaseSensorOperator
+
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
-    from airflow.models.baseoperator import BaseOperator
     from airflow.models.taskinstancekey import TaskInstanceKey
 
     try:
+        from airflow.sdk import BaseOperator
         from airflow.sdk.definitions.context import Context
     except ImportError:
         # TODO: Remove once provider drops support for Airflow 2
+        from airflow.models.baseoperator import BaseOperator
         from airflow.utils.context import Context
 
 
@@ -65,15 +70,16 @@ class ExternalDagLink(BaseOperatorLink):
     name = "External DAG"
 
     def get_link(self, operator: BaseOperator, *, ti_key: TaskInstanceKey) -> str:
-        from airflow.models.renderedtifields import RenderedTaskInstanceFields
-
         if TYPE_CHECKING:
             assert isinstance(operator, (ExternalTaskMarker, ExternalTaskSensor))
 
-        if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
-            external_dag_id: str = template_fields.get("external_dag_id", operator.external_dag_id)
-        else:
-            external_dag_id = operator.external_dag_id
+        external_dag_id = operator.external_dag_id
+
+        if not AIRFLOW_V_3_0_PLUS:
+            from airflow.models.renderedtifields import RenderedTaskInstanceFields
+
+            if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
+                external_dag_id: str = template_fields.get("external_dag_id", operator.external_dag_id)  # type: ignore[no-redef]
 
         if AIRFLOW_V_3_0_PLUS:
             from airflow.utils.helpers import build_airflow_dagrun_url
@@ -245,16 +251,22 @@ class ExternalTaskSensor(BaseSensorOperator):
         self.poll_interval = poll_interval
 
     def _get_dttm_filter(self, context):
+        logical_date = context.get("logical_date")
+        if logical_date is None:
+            dag_run = context.get("dag_run")
+            if TYPE_CHECKING:
+                assert dag_run
+
+            logical_date = dag_run.run_after
         if self.execution_delta:
-            dttm = context["logical_date"] - self.execution_delta
+            dttm = logical_date - self.execution_delta
         elif self.execution_date_fn:
             dttm = self._handle_execution_date_fn(context=context)
         else:
-            dttm = context["logical_date"]
+            dttm = logical_date
         return dttm if isinstance(dttm, list) else [dttm]
 
-    @provide_session
-    def poke(self, context: Context, session: Session = NEW_SESSION) -> bool:
+    def poke(self, context: Context) -> bool:
         # delay check to poke rather than __init__ in case it was supplied as XComArgs
         if self.external_task_ids and len(self.external_task_ids) > len(set(self.external_task_ids)):
             raise ValueError("Duplicate task_ids passed in external_task_ids parameter")
@@ -285,15 +297,62 @@ class ExternalTaskSensor(BaseSensorOperator):
                 serialized_dttm_filter,
             )
 
-        # In poke mode this will check dag existence only once
-        if self.check_existence and not self._has_checked_existence:
-            self._check_for_existence(session=session)
+        if AIRFLOW_V_3_0_PLUS:
+            return self._poke_af3(context, dttm_filter)
+        else:
+            return self._poke_af2(dttm_filter)
+
+    def _poke_af3(self, context: Context, dttm_filter: list[datetime.datetime]) -> bool:
+        self._has_checked_existence = True
+        ti = context["ti"]
+
+        def _get_count(states: list[str]) -> int:
+            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,
+                    states=states,
+                )
+            elif self.external_task_group_id:
+                return ti.get_ti_count(
+                    dag_id=self.external_dag_id,
+                    task_group_id=self.external_task_group_id,
+                    logical_dates=dttm_filter,
+                    states=states,
+                )
+            else:
+                return ti.get_dr_count(
+                    dag_id=self.external_dag_id,
+                    logical_dates=dttm_filter,
+                    states=states,
+                )
 
-        count_failed = -1
         if self.failed_states:
-            count_failed = self.get_count(dttm_filter, session, self.failed_states)
+            count = _get_count(self.failed_states)
+            count_failed = self._calculate_count(count, dttm_filter)
+            self._handle_failed_states(count_failed)
 
-        # Fail if anything in the list has failed.
+        if self.skipped_states:
+            count = _get_count(self.skipped_states)
+            count_skipped = self._calculate_count(count, dttm_filter)
+            self._handle_skipped_states(count_skipped)
+
+        count = _get_count(self.allowed_states)
+        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:
+        """Calculate the normalized count based on the type of check."""
+        if self.external_task_ids:
+            return count / len(self.external_task_ids)
+        elif self.external_task_group_id:
+            return count / len(dttm_filter)
+        else:
+            return count
+
+    def _handle_failed_states(self, count_failed: float | int) -> None:
+        """Handle failed states and raise appropriate exceptions."""
         if count_failed > 0:
             if self.external_task_ids:
                 if self.soft_fail:
@@ -315,7 +374,6 @@ class ExternalTaskSensor(BaseSensorOperator):
                     f"The external task_group '{self.external_task_group_id}' "
                     f"in DAG '{self.external_dag_id}' failed."
                 )
-
             else:
                 if self.soft_fail:
                     raise AirflowSkipException(
@@ -323,12 +381,8 @@ class ExternalTaskSensor(BaseSensorOperator):
                     )
                 raise AirflowException(f"The external DAG {self.external_dag_id} failed.")
 
-        count_skipped = -1
-        if self.skipped_states:
-            count_skipped = self.get_count(dttm_filter, session, self.skipped_states)
-
-        # Skip if anything in the list has skipped. Note if we are checking multiple tasks and one skips
-        # before another errors, we'll skip first.
+    def _handle_skipped_states(self, count_skipped: float | int) -> None:
+        """Handle skipped states and raise appropriate exceptions."""
         if count_skipped > 0:
             if self.external_task_ids:
                 raise AirflowSkipException(
@@ -346,7 +400,19 @@ class ExternalTaskSensor(BaseSensorOperator):
                     "Skipping."
                 )
 
-        # only go green if every single task has reached an allowed state
+    @provide_session
+    def _poke_af2(self, dttm_filter: list[datetime.datetime], session: Session = NEW_SESSION) -> bool:
+        if self.check_existence and not self._has_checked_existence:
+            self._check_for_existence(session=session)
+
+        if self.failed_states:
+            count_failed = self.get_count(dttm_filter, session, self.failed_states)
+            self._handle_failed_states(count_failed)
+
+        if self.skipped_states:
+            count_skipped = self.get_count(dttm_filter, session, self.skipped_states)
+            self._handle_skipped_states(count_skipped)
+
         count_allowed = self.get_count(dttm_filter, session, self.allowed_states)
         return count_allowed == len(dttm_filter)
 
@@ -398,8 +464,7 @@ class ExternalTaskSensor(BaseSensorOperator):
             for external_task_id in self.external_task_ids:
                 if not refreshed_dag_info.has_task(external_task_id):
                     raise AirflowException(
-                        f"The external task {external_task_id} in "
-                        f"DAG {self.external_dag_id} does not exist."
+                        f"The external task {external_task_id} in DAG {self.external_dag_id} does not exist."
                     )
 
         if self.external_task_group_id:
@@ -482,6 +547,9 @@ class ExternalTaskMarker(EmptyOperator):
     """
 
     template_fields = ["external_dag_id", "external_task_id", "logical_date"]
+    if not AIRFLOW_V_3_0_PLUS:
+        template_fields.append("execution_date")
+
     ui_color = "#4db7db"
     operator_extra_links = [ExternalDagLink()]
 
@@ -509,6 +577,9 @@ class ExternalTaskMarker(EmptyOperator):
                 f"Expected str or datetime.datetime type for logical_date. Got {type(logical_date)}"
             )
 
+        if not AIRFLOW_V_3_0_PLUS:
+            self.execution_date = self.logical_date
+
         if recursion_depth <= 0:
             raise ValueError("recursion_depth should be a positive integer")
         self.recursion_depth = recursion_depth

airflow/providers/standard/triggers/external_task.py

@@ -208,4 +208,4 @@ class DagStateTrigger(BaseTrigger):
             )
             .scalar()
         )
-        return typing.cast(int, count)
+        return typing.cast("int", count)

airflow/providers/standard/utils/sensor_helper.py

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING, cast
 from sqlalchemy import func, select, tuple_
 
 from airflow.models import DagBag, DagRun, TaskInstance
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
 from airflow.utils.session import NEW_SESSION, provide_session
 
 if TYPE_CHECKING:
@@ -71,10 +72,12 @@ def _get_count(
                         tuple_(TI.task_id, TI.map_index).in_(external_task_group_task_ids)
                     )
                 )
-            ) / len(external_task_group_task_ids)
+                / len(external_task_group_task_ids)
+                * len(dttm_filter)
+            )
     else:
         count = session.scalar(_count_stmt(DR, states, dttm_filter, external_dag_id))
-    return cast(int, count)
+    return cast("int", count)
 
 
 def _count_stmt(model, states, dttm_filter, external_dag_id) -> Executable:
@@ -86,8 +89,10 @@ def _count_stmt(model, states, dttm_filter, external_dag_id) -> Executable:
     :param dttm_filter: date time filter for logical date
     :param external_dag_id: The ID of the external DAG.
     """
+    date_field = model.logical_date if AIRFLOW_V_3_0_PLUS else model.execution_date
+
     return select(func.count()).where(
-        model.dag_id == external_dag_id, model.state.in_(states), model.logical_date.in_(dttm_filter)
+        model.dag_id == external_dag_id, model.state.in_(states), date_field.in_(dttm_filter)
     )
 
 
@@ -104,11 +109,13 @@ def _get_external_task_group_task_ids(dttm_filter, external_task_group_id, exter
     task_group = refreshed_dag_info.task_group_dict.get(external_task_group_id)
 
     if task_group:
+        date_field = TaskInstance.logical_date if AIRFLOW_V_3_0_PLUS else TaskInstance.execution_date
+
         group_tasks = session.scalars(
             select(TaskInstance).filter(
                 TaskInstance.dag_id == external_dag_id,
                 TaskInstance.task_id.in_(task.task_id for task in task_group),
-                TaskInstance.logical_date.in_(dttm_filter),
+                date_field.in_(dttm_filter),
             )
         )
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-standard
-Version: 0.2.0rc1
+Version: 0.3.0rc2
 Summary: Provider package apache-airflow-providers-standard for Apache Airflow
 Keywords: airflow-provider,standard,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
 Requires-Dist: apache-airflow>=2.9.0rc0
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-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: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.3.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.3.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
@@ -54,7 +54,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-standard``
 
-Release: ``0.2.0``
+Release: ``0.3.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.2.0/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.3.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.2.0/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.3.0/changelog.html>`_.
 

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

@@ -1,41 +1,51 @@
 airflow/providers/standard/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-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/__init__.py,sha256=84Hgrj5AurK3EjrkTXn2CChxmmQY0FCSNo6nzNwAxT0,1495
+airflow/providers/standard/get_provider_info.py,sha256=L-tNd8ZwiC77cY0mDXdUyp29VQu0h5ChdXy-fdwBxnQ,6435
 airflow/providers/standard/version_compat.py,sha256=aHg90_DtgoSnQvILFICexMyNlHlALBdaeWqkX3dFDug,1605
+airflow/providers/standard/decorators/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/standard/decorators/bash.py,sha256=dknHzPFfVwiCrcC0FzMlGKoOMi66EaA9uKR3JSsitno,4128
+airflow/providers/standard/decorators/branch_external_python.py,sha256=-z6JmLQrTzqQg2yqsdA91VPip52JeWp0Wnd9JDX_DeI,2352
+airflow/providers/standard/decorators/branch_python.py,sha256=ornGzksOiTSbvAiCgthkZw4iJaMsNCnKBasWdOS8wfA,2272
+airflow/providers/standard/decorators/branch_virtualenv.py,sha256=jcpxyoX86zXvzEJ8eIIf177EZZrt5TxoZbEum8blxI0,2354
+airflow/providers/standard/decorators/external_python.py,sha256=6_K9kjLQJQFwcxqfW51BP9BwMZDrI9ihomsR4xftavk,2673
+airflow/providers/standard/decorators/python.py,sha256=f-pl62ilgX45zvW6seCXKI0FoV3nypbWmjOIQauo6Y0,3219
+airflow/providers/standard/decorators/python_virtualenv.py,sha256=CKzMtaQr9nK-e9APm7jtXmIdc-Qc-xIV13PymdbEJAM,2359
+airflow/providers/standard/decorators/sensor.py,sha256=N2sKQl6xPop0gKnYWhtqnjl5yzSZa_56MQ7I5HrnG4Y,3004
+airflow/providers/standard/decorators/short_circuit.py,sha256=xo4h8eoZ9UXJ_8IhEhvlWat_Q_w1Y6bJmEXcAvsKZlY,2301
 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=dwi_TgXxeaQBVTuBZLq-omh5-Ul4ktCXzubuQWeS-0c,11405
+airflow/providers/standard/operators/bash.py,sha256=dPpaAbLRPyVo1207npt0Fr9ShdzvKsT0r9-sjYON6JI,11407
 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/datetime.py,sha256=bYDdbfAyAlEXRRHjOgB06UhgDum6SPdd5I3u-ylPSaw,5005
 airflow/providers/standard/operators/empty.py,sha256=C7_uLWJK6kExzlNc7xdMo8VAQ_ONWITvEQ2FImrMepM,1324
 airflow/providers/standard/operators/latest_only.py,sha256=OdUbeJA0_HuqxPFo8zFefkysUWtGpvdvoVEfIy0yJPo,3377
-airflow/providers/standard/operators/python.py,sha256=_ssens0qUAaUkSlAq9RsgLj9Y4Mo4Av6LEDqC5S4HWo,50115
+airflow/providers/standard/operators/python.py,sha256=l0aj8d9Cwg_B8snBZA815QKy8MKhRvISfbmHEteTGTk,50106
 airflow/providers/standard/operators/smooth.py,sha256=d3OV38EzV_wlfMYN3JGWGwyzsFonx8VbqgGfXSw0_bM,1382
 airflow/providers/standard/operators/trigger_dagrun.py,sha256=xXGVZOaIB8Ru2tALmmS-IWjzKhA3dFhiOpa3GTuKxeQ,14231
-airflow/providers/standard/operators/weekday.py,sha256=5tDS3V4hhKdE_POgmhQkyGQ9UyG6VdxjqAknW9EYu84,4898
+airflow/providers/standard/operators/weekday.py,sha256=Qg7LhXYtybVSGZn8uQqF-r7RB7zOXfe3R6vSGVa_rJk,5083
 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
-airflow/providers/standard/sensors/external_task.py,sha256=LJhmPg0dSxcZQ7OfNf5CmBNfujOss-bV7cVlwCA1IRU,24276
+airflow/providers/standard/sensors/external_task.py,sha256=LI8kYU8SNSfaq93MKgwyqEQF3-tFn9-2CvtEhjovb7M,27033
 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=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/external_task.py,sha256=-80zAq7pPbKElcS2sNgi3rE2rXPvEZe3Sj4nsJdxLGU,8478
 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=3Z334hVq6hQ9EHkOoGnAHc2_XNkZQkOJGxZArDKLc-c,2770
-airflow/providers/standard/utils/sensor_helper.py,sha256=BeaWt9X4PUE49V3QAG8WPHj3fWwUGeZngS5_Y8g_auA,4401
+airflow/providers/standard/utils/sensor_helper.py,sha256=vrCdz4lY3Iy8Mom5KuyNidg-IAyngMRqWhStEXVsyT0,4692
 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.0rc1.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
-apache_airflow_providers_standard-0.2.0rc1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-apache_airflow_providers_standard-0.2.0rc1.dist-info/METADATA,sha256=u4AZTbkUwgaJ_rc-aYjE0xVaS4x9AUreGEggrj6-7CY,3792
-apache_airflow_providers_standard-0.2.0rc1.dist-info/RECORD,,
+apache_airflow_providers_standard-0.3.0rc2.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
+apache_airflow_providers_standard-0.3.0rc2.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+apache_airflow_providers_standard-0.3.0rc2.dist-info/METADATA,sha256=Nkhhr0r7FcXIMtjVOpZIYFUHH2NBrM8h8siVojyP398,3792
+apache_airflow_providers_standard-0.3.0rc2.dist-info/RECORD,,