apache-airflow-providers-standard 0.3.0rc1__py3-none-any.whl → 0.4.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.3.0"
+__version__ = "0.4.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,121 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import DecoratedOperator, TaskDecorator, task_decorator_factory
+else:
+    from airflow.decorators.base import (  # type: ignore[no-redef]
+        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,63 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchExternalPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,62 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,62 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import BranchPythonVirtualenvOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,70 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import ExternalPythonOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,86 @@
+# 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.providers.standard.operators.python import PythonOperator
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import DecoratedOperator, task_decorator_factory
+else:
+    from airflow.decorators.base import DecoratedOperator, task_decorator_factory  # type: ignore[no-redef]
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,67 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+
+
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import PythonVirtualenvOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,83 @@
+# 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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import get_unique_task_id, task_decorator_factory
+else:
+    from airflow.decorators.base import get_unique_task_id, task_decorator_factory  # type: ignore[no-redef]
+
+
+from airflow.providers.standard.sensors.python import PythonSensor
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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,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.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk.bases.decorator import task_decorator_factory
+else:
+    from airflow.decorators.base import task_decorator_factory  # type: ignore[no-redef]
+
+from airflow.providers.standard.decorators.python import _PythonDecoratedOperator
+from airflow.providers.standard.operators.python import ShortCircuitOperator
+
+if TYPE_CHECKING:
+    from airflow.sdk.bases.decorator 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

@@ -26,9 +26,6 @@ def get_provider_info():
         "package-name": "apache-airflow-providers-standard",
         "name": "Standard",
         "description": "Airflow Standard Provider\n",
-        "state": "ready",
-        "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 +103,33 @@ def get_provider_info():
                 },
             }
         },
-        "dependencies": ["apache-airflow>=2.9.0"],
-        "devel-dependencies": [],
+        "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",
+            },
+        ],
     }

airflow/providers/standard/operators/latest_only.py

@@ -25,10 +25,12 @@ from typing import TYPE_CHECKING
 import pendulum
 
 from airflow.providers.standard.operators.branch import BaseBranchOperator
+from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
 from airflow.utils.types import DagRunType
 
 if TYPE_CHECKING:
     from airflow.models import DAG, DagRun
+    from airflow.timetables.base import DagRunInfo
 
     try:
         from airflow.sdk.definitions.context import Context
@@ -46,6 +48,10 @@ class LatestOnlyOperator(BaseBranchOperator):
 
     Note that downstream tasks are never skipped if the given DAG_Run is
     marked as externally triggered.
+
+    Note that when used with timetables that produce zero-length or point-in-time data intervals
+    (e.g., ``DeltaTriggerTimetable``), this operator assumes each run is the latest
+    and does not skip downstream tasks.
     """
 
     ui_color = "#e9ffdb"  # nyanza
@@ -58,8 +64,7 @@ class LatestOnlyOperator(BaseBranchOperator):
             self.log.info("Manually triggered DAG_Run: allowing execution to proceed.")
             return list(context["task"].get_direct_relative_ids(upstream=False))
 
-        dag: DAG = context["dag"]  # type: ignore[assignment]
-        next_info = dag.next_dagrun_info(dag.get_run_data_interval(dag_run), restricted=False)
+        next_info = self._get_next_run_info(context, dag_run)
         now = pendulum.now("UTC")
 
         if next_info is None:
@@ -74,6 +79,15 @@ class LatestOnlyOperator(BaseBranchOperator):
             now,
         )
 
+        if left_window == right_window:
+            self.log.info(
+                "Zero-length interval [%s, %s) from timetable (%s); treating current run as latest.",
+                left_window,
+                right_window,
+                self.dag.timetable.__class__,
+            )
+            return list(context["task"].get_direct_relative_ids(upstream=False))
+
         if not left_window < now <= right_window:
             self.log.info("Not latest execution, skipping downstream.")
             # we return an empty list, thus the parent BaseBranchOperator
@@ -82,3 +96,21 @@ class LatestOnlyOperator(BaseBranchOperator):
         else:
             self.log.info("Latest, allowing execution to proceed.")
             return list(context["task"].get_direct_relative_ids(upstream=False))
+
+    def _get_next_run_info(self, context: Context, dag_run: DagRun) -> DagRunInfo | None:
+        dag: DAG = context["dag"]  # type: ignore[assignment]
+
+        if AIRFLOW_V_3_0_PLUS:
+            from airflow.timetables.base import DataInterval, TimeRestriction
+
+            time_restriction = TimeRestriction(earliest=None, latest=None, catchup=True)
+            current_interval = DataInterval(start=dag_run.data_interval_start, end=dag_run.data_interval_end)
+
+            next_info = dag.timetable.next_dagrun_info(
+                last_automated_data_interval=current_interval,
+                restriction=time_restriction,
+            )
+
+        else:
+            next_info = dag.next_dagrun_info(dag.get_run_data_interval(dag_run), restricted=False)
+        return next_info

airflow/providers/standard/operators/trigger_dagrun.py

@@ -41,9 +41,9 @@ from airflow.models.dagrun import DagRun
 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.session import NEW_SESSION, provide_session
 from airflow.utils.state import DagRunState
-from airflow.utils.types import DagRunType
+from airflow.utils.types import NOTSET, ArgNotSet, DagRunType
 
 XCOM_LOGICAL_DATE_ISO = "trigger_logical_date_iso"
 XCOM_RUN_ID = "trigger_run_id"
@@ -153,7 +153,7 @@ class TriggerDagRunOperator(BaseOperator):
         trigger_dag_id: str,
         trigger_run_id: str | None = None,
         conf: dict | None = None,
-        logical_date: str | datetime.datetime | None = None,
+        logical_date: str | datetime.datetime | None | ArgNotSet = NOTSET,
         reset_dag_run: bool = False,
         wait_for_completion: bool = False,
         poke_interval: int = 60,
@@ -180,19 +180,23 @@ class TriggerDagRunOperator(BaseOperator):
             self.failed_states = [DagRunState.FAILED]
         self.skip_when_already_exists = skip_when_already_exists
         self._defer = deferrable
-
-        if logical_date is not None and not isinstance(logical_date, (str, datetime.datetime)):
-            type_name = type(logical_date).__name__
+        self.logical_date = logical_date
+        if logical_date is NOTSET:
+            self.logical_date = NOTSET
+        elif logical_date is None or isinstance(logical_date, (str, datetime.datetime)):
+            self.logical_date = logical_date
+        else:
             raise TypeError(
-                f"Expected str or datetime.datetime type for parameter 'logical_date'. Got {type_name}"
+                f"Expected str, datetime.datetime, or None for parameter 'logical_date'. Got {type(logical_date).__name__}"
             )
 
-        self.logical_date = logical_date
-
     def execute(self, context: Context):
-        if self.logical_date is None or isinstance(self.logical_date, datetime.datetime):
-            parsed_logical_date = self.logical_date
-        else:
+        if self.logical_date is NOTSET:
+            # If no logical_date is provided we will set utcnow()
+            parsed_logical_date = timezone.utcnow()
+        elif self.logical_date is None or isinstance(self.logical_date, datetime.datetime):
+            parsed_logical_date = self.logical_date  # type: ignore
+        elif isinstance(self.logical_date, str):
             parsed_logical_date = timezone.parse(self.logical_date)
 
         try:
@@ -231,10 +235,9 @@ class TriggerDagRunOperator(BaseOperator):
             allowed_states=self.allowed_states,
             failed_states=self.failed_states,
             poke_interval=self.poke_interval,
+            deferrable=self._defer,
         )
 
-        # TODO: Support deferral
-
     def _trigger_dag_af_2(self, context, run_id, parsed_logical_date):
         try:
             dag_run = trigger_dag(
@@ -304,8 +307,40 @@ class TriggerDagRunOperator(BaseOperator):
                     self.log.info("%s finished with allowed state %s", self.trigger_dag_id, state)
                     return
 
+    def execute_complete(self, context: Context, event: tuple[str, dict[str, Any]]):
+        if AIRFLOW_V_3_0_PLUS:
+            self._trigger_dag_run_af_3_execute_complete(event=event)
+        else:
+            self._trigger_dag_run_af_2_execute_complete(event=event)
+
+    def _trigger_dag_run_af_3_execute_complete(self, event: tuple[str, dict[str, Any]]):
+        run_ids = event[1]["run_ids"]
+        event_data = event[1]
+        failed_run_id_conditions = []
+
+        for run_id in run_ids:
+            state = event_data.get(run_id)
+            if state in self.failed_states:
+                failed_run_id_conditions.append(run_id)
+                continue
+            if state in self.allowed_states:
+                self.log.info(
+                    "%s finished with allowed state %s for run_id %s",
+                    self.trigger_dag_id,
+                    state,
+                    run_id,
+                )
+
+        if failed_run_id_conditions:
+            raise AirflowException(
+                f"{self.trigger_dag_id} failed with failed states {self.failed_states} for run_ids"
+                f" {failed_run_id_conditions}"
+            )
+
     @provide_session
-    def execute_complete(self, context: Context, session: Session, event: tuple[str, dict[str, Any]]):
+    def _trigger_dag_run_af_2_execute_complete(
+        self, event: tuple[str, dict[str, Any]], session: Session = NEW_SESSION
+    ):
         # This logical_date is parsed from the return trigger event
         provided_logical_date = event[1]["execution_dates"][0]
         try:

airflow/providers/standard/sensors/external_task.py

@@ -346,8 +346,6 @@ class ExternalTaskSensor(BaseSensorOperator):
         """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
 
@@ -421,16 +419,22 @@ class ExternalTaskSensor(BaseSensorOperator):
         if not self.deferrable:
             super().execute(context)
         else:
+            dttm_filter = self._get_dttm_filter(context)
+            logical_or_execution_dates = (
+                {"logical_dates": dttm_filter} if AIRFLOW_V_3_0_PLUS else {"execution_date": dttm_filter}
+            )
             self.defer(
                 timeout=self.execution_timeout,
                 trigger=WorkflowTrigger(
                     external_dag_id=self.external_dag_id,
                     external_task_group_id=self.external_task_group_id,
                     external_task_ids=self.external_task_ids,
-                    logical_dates=self._get_dttm_filter(context),
                     allowed_states=self.allowed_states,
+                    failed_states=self.failed_states,
+                    skipped_states=self.skipped_states,
                     poke_interval=self.poll_interval,
                     soft_fail=self.soft_fail,
+                    **logical_or_execution_dates,
                 ),
                 method_name="execute_complete",
             )

airflow/providers/standard/triggers/external_task.py

@@ -50,6 +50,7 @@ class WorkflowTrigger(BaseTrigger):
     :param allowed_states: States considered as successful for external tasks.
     :param poke_interval: The interval (in seconds) for poking the external tasks.
     :param soft_fail: If True, the trigger will not fail the entire dag on external task failure.
+    :param logical_dates: A list of logical dates for the external dag.
     """
 
     def __init__(
@@ -57,6 +58,7 @@ class WorkflowTrigger(BaseTrigger):
         external_dag_id: str,
         run_ids: list[str] | None = None,
         execution_dates: list[datetime] | None = None,
+        logical_dates: list[datetime] | None = None,
         external_task_ids: typing.Collection[str] | None = None,
         external_task_group_id: str | None = None,
         failed_states: typing.Iterable[str] | None = None,
@@ -76,6 +78,7 @@ class WorkflowTrigger(BaseTrigger):
         self.poke_interval = poke_interval
         self.soft_fail = soft_fail
         self.execution_dates = execution_dates
+        self.logical_dates = logical_dates
         super().__init__(**kwargs)
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
@@ -92,6 +95,7 @@ class WorkflowTrigger(BaseTrigger):
         }
         if AIRFLOW_V_3_0_PLUS:
             data["run_ids"] = self.run_ids
+            data["logical_dates"] = self.logical_dates
         else:
             data["execution_dates"] = self.execution_dates
 
@@ -99,9 +103,16 @@ class WorkflowTrigger(BaseTrigger):
 
     async def run(self) -> typing.AsyncIterator[TriggerEvent]:
         """Check periodically tasks, task group or dag status."""
+        if AIRFLOW_V_3_0_PLUS:
+            get_count_func = self._get_count_af_3
+            run_id_or_dates = (self.run_ids or self.logical_dates) or []
+        else:
+            get_count_func = self._get_count
+            run_id_or_dates = self.execution_dates or []
+
         while True:
             if self.failed_states:
-                failed_count = await self._get_count(self.failed_states)
+                failed_count = await get_count_func(self.failed_states)
                 if failed_count > 0:
                     yield TriggerEvent({"status": "failed"})
                     return
@@ -109,18 +120,43 @@ class WorkflowTrigger(BaseTrigger):
                     yield TriggerEvent({"status": "success"})
                     return
             if self.skipped_states:
-                skipped_count = await self._get_count(self.skipped_states)
+                skipped_count = await get_count_func(self.skipped_states)
                 if skipped_count > 0:
                     yield TriggerEvent({"status": "skipped"})
                     return
-            allowed_count = await self._get_count(self.allowed_states)
-            _dates = self.run_ids if AIRFLOW_V_3_0_PLUS else self.execution_dates
-            if allowed_count == len(_dates):  # type: ignore[arg-type]
+            allowed_count = await get_count_func(self.allowed_states)
+
+            if allowed_count == len(run_id_or_dates):  # type: ignore[arg-type]
                 yield TriggerEvent({"status": "success"})
                 return
             self.log.info("Sleeping for %s seconds", self.poke_interval)
             await asyncio.sleep(self.poke_interval)
 
+    async def _get_count_af_3(self, states):
+        from airflow.sdk.execution_time.task_runner import RuntimeTaskInstance
+
+        if self.external_task_ids or self.external_task_group_id:
+            count = await sync_to_async(RuntimeTaskInstance.get_ti_count)(
+                dag_id=self.external_dag_id,
+                task_ids=self.external_task_ids,
+                task_group_id=self.external_task_group_id,
+                logical_dates=self.logical_dates,
+                run_ids=self.run_ids,
+                states=states,
+            )
+        else:
+            count = await sync_to_async(RuntimeTaskInstance.get_dr_count)(
+                dag_id=self.external_dag_id,
+                logical_dates=self.logical_dates,
+                run_ids=self.run_ids,
+                states=states,
+            )
+
+        if self.external_task_ids:
+            return count / len(self.external_task_ids)
+        else:
+            return count
+
     @sync_to_async
     def _get_count(self, states: typing.Iterable[str] | None) -> int:
         """
@@ -170,29 +206,58 @@ class DagStateTrigger(BaseTrigger):
             "dag_id": self.dag_id,
             "states": self.states,
             "poll_interval": self.poll_interval,
+            "run_ids": self.run_ids,
+            "execution_dates": self.execution_dates,
         }
 
-        if AIRFLOW_V_3_0_PLUS:
-            data["run_ids"] = self.run_ids
-        else:
-            data["execution_dates"] = self.execution_dates
-
         return "airflow.providers.standard.triggers.external_task.DagStateTrigger", data
 
     async def run(self) -> typing.AsyncIterator[TriggerEvent]:
         """Check periodically if the dag run exists, and has hit one of the states yet, or not."""
+        runs_ids_or_dates = 0
+        if self.run_ids:
+            runs_ids_or_dates = len(self.run_ids)
+        elif self.execution_dates:
+            runs_ids_or_dates = len(self.execution_dates)
+
+        if AIRFLOW_V_3_0_PLUS:
+            event = await self.validate_count_dags_af_3(runs_ids_or_dates_len=runs_ids_or_dates)
+            yield TriggerEvent(event)
+            return
+        else:
+            while True:
+                num_dags = await self.count_dags()  # type: ignore[call-arg]
+                if num_dags == runs_ids_or_dates:
+                    yield TriggerEvent(self.serialize())
+                    return
+                await asyncio.sleep(self.poll_interval)
+
+    async def validate_count_dags_af_3(self, runs_ids_or_dates_len: int = 0) -> tuple[str, dict[str, Any]]:
+        from airflow.sdk.execution_time.task_runner import RuntimeTaskInstance
+
+        cls_path, data = self.serialize()
+
         while True:
-            # mypy confuses typing here
-            num_dags = await self.count_dags()  # type: ignore[call-arg]
-            _dates = self.run_ids if AIRFLOW_V_3_0_PLUS else self.execution_dates
-            if num_dags == len(_dates):  # type: ignore[arg-type]
-                yield TriggerEvent(self.serialize())
-                return
+            num_dags = await sync_to_async(RuntimeTaskInstance.get_dr_count)(
+                dag_id=self.dag_id,
+                run_ids=self.run_ids,
+                states=self.states,  # type: ignore[arg-type]
+                logical_dates=self.execution_dates,
+            )
+            if num_dags == runs_ids_or_dates_len:
+                if isinstance(self.run_ids, list):
+                    for run_id in self.run_ids:
+                        state = await sync_to_async(RuntimeTaskInstance.get_dagrun_state)(
+                            dag_id=self.dag_id,
+                            run_id=run_id,
+                        )
+                        data[run_id] = state
+                        return cls_path, data
             await asyncio.sleep(self.poll_interval)
 
     @sync_to_async
     @provide_session
-    def count_dags(self, *, session: Session = NEW_SESSION) -> int | None:
+    def count_dags(self, *, session: Session = NEW_SESSION) -> int:
         """Count how many dag runs in the database match our criteria."""
         _dag_run_date_condition = (
             DagRun.run_id.in_(self.run_ids)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-standard
-Version: 0.3.0rc1
+Version: 0.4.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,10 +20,10 @@ 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.3.0/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.3.0
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.4.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-standard/0.4.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.3.0``
+Release: ``0.4.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.3.0/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.4.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.3.0/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-standard/0.4.0/changelog.html>`_.
 

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

@@ -1,7 +1,17 @@
 airflow/providers/standard/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/standard/__init__.py,sha256=84Hgrj5AurK3EjrkTXn2CChxmmQY0FCSNo6nzNwAxT0,1495
-airflow/providers/standard/get_provider_info.py,sha256=aq0vO2Gw7CjHS9d3pgBWN_Vb10JYU996DianpWgetQ0,5010
+airflow/providers/standard/__init__.py,sha256=qhDil5br-GkCarIJ4gSk1fMsAIsX1W5Yi7YNNmB_ktE,1495
+airflow/providers/standard/get_provider_info.py,sha256=96C-S4JowGsq9zyHVtmzZWm2VdugMee-0XZIvvgBqZI,6198
 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=J13t48yrRv7XpDV8_QWtI0IXbqNiqxW9Ct0ngmrQAdE,4396
+airflow/providers/standard/decorators/branch_external_python.py,sha256=M6JwUxKQj8KOHZL8cHtKmn37leEz4DKoGDrexNH2aAA,2557
+airflow/providers/standard/decorators/branch_python.py,sha256=MbtK3Zv5fKynrhv0PFeOzPQQ1IiW9PcurGq1bqotLqo,2476
+airflow/providers/standard/decorators/branch_virtualenv.py,sha256=m_3VE88QcuMj_yFg5h6MANVsfz1cKg9TyBbJ_t6zBA8,2558
+airflow/providers/standard/decorators/external_python.py,sha256=FxrsihfFy9oVjbyLugtFLDq7VkOdVXJScH0kuua1ApE,2877
+airflow/providers/standard/decorators/python.py,sha256=9Fdk8CRQJ7HQzhKT1Qh-CzfbX0_aw12ccjbh6fdBRdc,3442
+airflow/providers/standard/decorators/python_virtualenv.py,sha256=Xhul1iA0mJlN5N1EZl1LWIs90pUhS6bawQtVSpQhqEg,2565
+airflow/providers/standard/decorators/sensor.py,sha256=04PPtcDhSr_Wa4LJct2eiBczb8JEAzjiSos2CqBu3-4,3230
+airflow/providers/standard/decorators/short_circuit.py,sha256=3_6UHDhloPMT3fGeHFDBjf3rScXQm4wtfx59n-n__Ys,2506
 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
@@ -11,22 +21,22 @@ airflow/providers/standard/operators/bash.py,sha256=dPpaAbLRPyVo1207npt0Fr9Shdzv
 airflow/providers/standard/operators/branch.py,sha256=C_AUd7TSo_U52GiWsrR7rJIsRU5KKfrybBFw84brm_c,4070
 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/latest_only.py,sha256=BVsPtkrQtaZQvBWlTAxlrJPfNThNOZWw7Vf_6we7g4o,4780
 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/trigger_dagrun.py,sha256=WJuT1jUkLSh4JxdUtIYVefEPQZWKU7JYGjRqye5KkFs,15775
 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=LI8kYU8SNSfaq93MKgwyqEQF3-tFn9-2CvtEhjovb7M,27033
+airflow/providers/standard/sensors/external_task.py,sha256=F0hvtcHFx8HQLLNvdepDx2Y9kjn8zbCyLTx1Uw7BbRA,27261
 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=-80zAq7pPbKElcS2sNgi3rE2rXPvEZe3Sj4nsJdxLGU,8478
+airflow/providers/standard/triggers/external_task.py,sha256=L55jWUWjChw7VWAF_SKI-4DsgMwHKidXpcHIs8FTo1w,11094
 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
@@ -35,7 +45,7 @@ airflow/providers/standard/utils/python_virtualenv_script.jinja2,sha256=3Z334hVq
 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.3.0rc1.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
-apache_airflow_providers_standard-0.3.0rc1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-apache_airflow_providers_standard-0.3.0rc1.dist-info/METADATA,sha256=ZZOZzM_ekFj74kGaVoSnctN_TAJaBkRT3vKhdUYlFD8,3792
-apache_airflow_providers_standard-0.3.0rc1.dist-info/RECORD,,
+apache_airflow_providers_standard-0.4.0.dist-info/entry_points.txt,sha256=mW2YRh3mVdZdaP5-iGSNgmcCh3YYdALIn28BCLBZZ40,104
+apache_airflow_providers_standard-0.4.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+apache_airflow_providers_standard-0.4.0.dist-info/METADATA,sha256=zncp6uT5_LYwv21S9dg9lubVy3-okXYK7VLkRjXqOYE,3786
+apache_airflow_providers_standard-0.4.0.dist-info/RECORD,,

{apache_airflow_providers_standard-0.3.0rc1.dist-info → apache_airflow_providers_standard-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.11.0
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py3-none-any