apache-airflow-providers-standard 1.2.0__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

airflow/providers/standard/__init__.py

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

airflow/providers/standard/example_dags/__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/example_dags/example_bash_decorator.py

@@ -0,0 +1,114 @@
+# 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 pendulum
+
+from airflow.exceptions import AirflowSkipException
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.providers.standard.utils.weekday import WeekDay
+from airflow.sdk import chain, dag, task
+from airflow.utils.trigger_rule import TriggerRule
+
+
+@dag(schedule=None, start_date=pendulum.datetime(2023, 1, 1, tz="UTC"), catchup=False)
+def example_bash_decorator():
+    @task.bash
+    def run_me(sleep_seconds: int, task_instance_key_str: str) -> str:
+        return f"echo {task_instance_key_str} && sleep {sleep_seconds}"
+
+    run_me_loop = [run_me.override(task_id=f"runme_{i}")(sleep_seconds=i) for i in range(3)]
+
+    # [START howto_decorator_bash]
+    @task.bash
+    def run_after_loop() -> str:
+        return "echo https://airflow.apache.org/"
+
+    run_this = run_after_loop()
+    # [END howto_decorator_bash]
+
+    # [START howto_decorator_bash_template]
+    @task.bash
+    def also_run_this() -> str:
+        return 'echo "ti_key={{ task_instance_key_str }}"'
+
+    also_this = also_run_this()
+    # [END howto_decorator_bash_template]
+
+    # [START howto_decorator_bash_context_vars]
+    @task.bash
+    def also_run_this_again(task_instance_key_str) -> str:
+        return f'echo "ti_key={task_instance_key_str}"'
+
+    also_this_again = also_run_this_again()
+    # [END howto_decorator_bash_context_vars]
+
+    # [START howto_decorator_bash_skip]
+    @task.bash
+    def this_will_skip() -> str:
+        return 'echo "hello world"; exit 99;'
+
+    this_skips = this_will_skip()
+    # [END howto_decorator_bash_skip]
+
+    run_this_last = EmptyOperator(task_id="run_this_last", trigger_rule=TriggerRule.ALL_DONE)
+
+    # [START howto_decorator_bash_conditional]
+    @task.bash
+    def sleep_in(day: str) -> str:
+        if day in (WeekDay.SATURDAY, WeekDay.SUNDAY):
+            return f"sleep {60 * 60}"
+        raise AirflowSkipException("No sleeping in today!")
+
+    sleep_in(day="{{ dag_run.logical_date.strftime('%A').lower() }}")
+    # [END howto_decorator_bash_conditional]
+
+    # [START howto_decorator_bash_parametrize]
+    @task.bash(env={"BASE_DIR": "{{ dag_run.logical_date.strftime('%Y/%m/%d') }}"}, append_env=True)
+    def make_dynamic_dirs(new_dirs: str) -> str:
+        return f"mkdir -p $AIRFLOW_HOME/$BASE_DIR/{new_dirs}"
+
+    make_dynamic_dirs(new_dirs="foo/bar/baz")
+    # [END howto_decorator_bash_parametrize]
+
+    # [START howto_decorator_bash_build_cmd]
+    def _get_files_in_cwd() -> list[str]:
+        from pathlib import Path
+
+        dir_contents = Path.cwd().glob("airflow-core/src/airflow/example_dags/*.py")
+        files = [str(elem) for elem in dir_contents if elem.is_file()]
+
+        return files
+
+    @task.bash
+    def get_file_stats() -> str:
+        from shlex import join
+
+        files = _get_files_in_cwd()
+        cmd = join(["stat", *files])
+
+        return cmd
+
+    get_file_stats()
+    # [END howto_decorator_bash_build_cmd]
+
+    chain(run_me_loop, run_this)
+    chain([also_this, also_this_again, this_skips, run_this], run_this_last)
+
+
+example_bash_decorator()

airflow/providers/standard/example_dags/example_bash_operator.py

@@ -0,0 +1,74 @@
+#
+# 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.
+"""Example DAG demonstrating the usage of the BashOperator."""
+
+from __future__ import annotations
+
+import datetime
+
+import pendulum
+
+from airflow.providers.standard.operators.bash import BashOperator
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.sdk import DAG
+
+with DAG(
+    dag_id="example_bash_operator",
+    schedule="0 0 * * *",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    dagrun_timeout=datetime.timedelta(minutes=60),
+    tags=["example", "example2"],
+    params={"example_key": "example_value"},
+) as dag:
+    run_this_last = EmptyOperator(
+        task_id="run_this_last",
+    )
+
+    # [START howto_operator_bash]
+    run_this = BashOperator(
+        task_id="run_after_loop",
+        bash_command="echo https://airflow.apache.org/",
+    )
+    # [END howto_operator_bash]
+
+    run_this >> run_this_last
+
+    for i in range(3):
+        task = BashOperator(
+            task_id=f"runme_{i}",
+            bash_command='echo "{{ task_instance_key_str }}" && sleep 1',
+        )
+        task >> run_this
+
+    # [START howto_operator_bash_template]
+    also_run_this = BashOperator(
+        task_id="also_run_this",
+        bash_command='echo "ti_key={{ task_instance_key_str }}"',
+    )
+    # [END howto_operator_bash_template]
+    also_run_this >> run_this_last
+
+# [START howto_operator_bash_skip]
+this_will_skip = BashOperator(
+    task_id="this_will_skip",
+    bash_command='echo "hello world"; exit 99;',
+    dag=dag,
+)
+# [END howto_operator_bash_skip]
+this_will_skip >> run_this_last

airflow/providers/standard/example_dags/example_branch_datetime_operator.py

@@ -0,0 +1,105 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Example DAG demonstrating the usage of DateTimeBranchOperator with datetime as well as time objects as
+targets.
+"""
+
+from __future__ import annotations
+
+import pendulum
+
+from airflow.providers.standard.operators.datetime import BranchDateTimeOperator
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.sdk import DAG
+
+dag1 = DAG(
+    dag_id="example_branch_datetime_operator",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+    schedule="@daily",
+)
+
+# [START howto_branch_datetime_operator]
+empty_task_11 = EmptyOperator(task_id="date_in_range", dag=dag1)
+empty_task_21 = EmptyOperator(task_id="date_outside_range", dag=dag1)
+
+cond1 = BranchDateTimeOperator(
+    task_id="datetime_branch",
+    follow_task_ids_if_true=["date_in_range"],
+    follow_task_ids_if_false=["date_outside_range"],
+    target_upper=pendulum.datetime(2020, 10, 10, 15, 0, 0),
+    target_lower=pendulum.datetime(2020, 10, 10, 14, 0, 0),
+    dag=dag1,
+)
+
+# Run empty_task_11 if cond1 executes between 2020-10-10 14:00:00 and 2020-10-10 15:00:00
+cond1 >> [empty_task_11, empty_task_21]
+# [END howto_branch_datetime_operator]
+
+
+dag2 = DAG(
+    dag_id="example_branch_datetime_operator_2",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+    schedule="@daily",
+)
+# [START howto_branch_datetime_operator_next_day]
+empty_task_12 = EmptyOperator(task_id="date_in_range", dag=dag2)
+empty_task_22 = EmptyOperator(task_id="date_outside_range", dag=dag2)
+
+cond2 = BranchDateTimeOperator(
+    task_id="datetime_branch",
+    follow_task_ids_if_true=["date_in_range"],
+    follow_task_ids_if_false=["date_outside_range"],
+    target_upper=pendulum.time(0, 0, 0),
+    target_lower=pendulum.time(15, 0, 0),
+    dag=dag2,
+)
+
+# Since target_lower happens after target_upper, target_upper will be moved to the following day
+# Run empty_task_12 if cond2 executes between 15:00:00, and 00:00:00 of the following day
+cond2 >> [empty_task_12, empty_task_22]
+# [END howto_branch_datetime_operator_next_day]
+
+dag3 = DAG(
+    dag_id="example_branch_datetime_operator_3",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+    schedule="@daily",
+)
+# [START howto_branch_datetime_operator_logical_date]
+empty_task_13 = EmptyOperator(task_id="date_in_range", dag=dag3)
+empty_task_23 = EmptyOperator(task_id="date_outside_range", dag=dag3)
+
+cond3 = BranchDateTimeOperator(
+    task_id="datetime_branch",
+    use_task_logical_date=True,
+    follow_task_ids_if_true=["date_in_range"],
+    follow_task_ids_if_false=["date_outside_range"],
+    target_upper=pendulum.datetime(2020, 10, 10, 15, 0, 0),
+    target_lower=pendulum.datetime(2020, 10, 10, 14, 0, 0),
+    dag=dag3,
+)
+
+# Run empty_task_13 if cond3 executes between 2020-10-10 14:00:00 and 2020-10-10 15:00:00
+cond3 >> [empty_task_13, empty_task_23]
+# [END howto_branch_datetime_operator_logical_date]

airflow/providers/standard/example_dags/example_branch_day_of_week_operator.py

@@ -0,0 +1,61 @@
+#
+# 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.
+"""
+Example DAG demonstrating the usage of BranchDayOfWeekOperator.
+"""
+
+from __future__ import annotations
+
+import pendulum
+
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.providers.standard.operators.weekday import BranchDayOfWeekOperator
+from airflow.providers.standard.utils.weekday import WeekDay
+from airflow.sdk import DAG
+
+with DAG(
+    dag_id="example_weekday_branch_operator",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+    schedule="@daily",
+) as dag:
+    # [START howto_operator_day_of_week_branch]
+    empty_task_1 = EmptyOperator(task_id="branch_true")
+    empty_task_2 = EmptyOperator(task_id="branch_false")
+    empty_task_3 = EmptyOperator(task_id="branch_weekend")
+    empty_task_4 = EmptyOperator(task_id="branch_mid_week")
+
+    branch = BranchDayOfWeekOperator(
+        task_id="make_choice",
+        follow_task_ids_if_true="branch_true",
+        follow_task_ids_if_false="branch_false",
+        week_day="Monday",
+    )
+    branch_weekend = BranchDayOfWeekOperator(
+        task_id="make_weekend_choice",
+        follow_task_ids_if_true="branch_weekend",
+        follow_task_ids_if_false="branch_mid_week",
+        week_day={WeekDay.SATURDAY, WeekDay.SUNDAY},
+    )
+
+    # Run empty_task_1 if branch executes on Monday, empty_task_2 otherwise
+    branch >> [empty_task_1, empty_task_2]
+    # Run empty_task_3 if it's a weekend, empty_task_4 otherwise
+    empty_task_2 >> branch_weekend >> [empty_task_3, empty_task_4]
+    # [END howto_operator_day_of_week_branch]

airflow/providers/standard/example_dags/example_branch_operator.py

@@ -0,0 +1,166 @@
+#
+# 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.
+"""Example DAG demonstrating the usage of the Classic branching Python operators.
+
+It is showcasing the basic BranchPythonOperator and its sisters BranchExternalPythonOperator
+and BranchPythonVirtualenvOperator."""
+
+from __future__ import annotations
+
+import random
+import sys
+import tempfile
+from pathlib import Path
+
+import pendulum
+
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.providers.standard.operators.python import (
+    BranchExternalPythonOperator,
+    BranchPythonOperator,
+    BranchPythonVirtualenvOperator,
+    ExternalPythonOperator,
+    PythonOperator,
+    PythonVirtualenvOperator,
+)
+from airflow.sdk import DAG, Label
+from airflow.utils.trigger_rule import TriggerRule
+
+PATH_TO_PYTHON_BINARY = sys.executable
+
+with DAG(
+    dag_id="example_branch_operator",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    schedule="@daily",
+    tags=["example", "example2"],
+) as dag:
+    run_this_first = EmptyOperator(
+        task_id="run_this_first",
+    )
+
+    options = ["a", "b", "c", "d"]
+
+    # Example branching on standard Python tasks
+
+    # [START howto_operator_branch_python]
+    branching = BranchPythonOperator(
+        task_id="branching",
+        python_callable=lambda: f"branch_{random.choice(options)}",
+    )
+    # [END howto_operator_branch_python]
+    run_this_first >> branching
+
+    join = EmptyOperator(
+        task_id="join",
+        trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS,
+    )
+
+    for option in options:
+        t = PythonOperator(
+            task_id=f"branch_{option}",
+            python_callable=lambda: print("Hello World"),
+        )
+
+        empty_follow = EmptyOperator(
+            task_id="follow_" + option,
+        )
+
+        # Label is optional here, but it can help identify more complex branches
+        branching >> Label(option) >> t >> empty_follow >> join
+
+    # Example the same with external Python calls
+
+    # [START howto_operator_branch_ext_py]
+    def branch_with_external_python(choices):
+        import random
+
+        return f"ext_py_{random.choice(choices)}"
+
+    branching_ext_py = BranchExternalPythonOperator(
+        task_id="branching_ext_python",
+        python=PATH_TO_PYTHON_BINARY,
+        python_callable=branch_with_external_python,
+        op_args=[options],
+    )
+    # [END howto_operator_branch_ext_py]
+    join >> branching_ext_py
+
+    join_ext_py = EmptyOperator(
+        task_id="join_ext_python",
+        trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS,
+    )
+
+    def hello_world_with_external_python():
+        print("Hello World from external Python")
+
+    for option in options:
+        t = ExternalPythonOperator(
+            task_id=f"ext_py_{option}",
+            python=PATH_TO_PYTHON_BINARY,
+            python_callable=hello_world_with_external_python,
+        )
+
+        # Label is optional here, but it can help identify more complex branches
+        branching_ext_py >> Label(option) >> t >> join_ext_py
+
+    # Example the same with Python virtual environments
+
+    # [START howto_operator_branch_virtualenv]
+    # Note: Passing a caching dir allows to keep the virtual environment over multiple runs
+    #       Run the example a second time and see that it reuses it and is faster.
+    VENV_CACHE_PATH = Path(tempfile.gettempdir())
+
+    def branch_with_venv(choices):
+        import random
+
+        import numpy as np
+
+        print(f"Some numpy stuff: {np.arange(6)}")
+        return f"venv_{random.choice(choices)}"
+
+    branching_venv = BranchPythonVirtualenvOperator(
+        task_id="branching_venv",
+        requirements=["numpy~=1.26.0"],
+        venv_cache_path=VENV_CACHE_PATH,
+        python_callable=branch_with_venv,
+        op_args=[options],
+    )
+    # [END howto_operator_branch_virtualenv]
+    join_ext_py >> branching_venv
+
+    join_venv = EmptyOperator(
+        task_id="join_venv",
+        trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS,
+    )
+
+    def hello_world_with_venv():
+        import numpy as np
+
+        print(f"Hello World with some numpy stuff: {np.arange(6)}")
+
+    for option in options:
+        t = PythonVirtualenvOperator(
+            task_id=f"venv_{option}",
+            requirements=["numpy~=1.26.0"],
+            venv_cache_path=VENV_CACHE_PATH,
+            python_callable=hello_world_with_venv,
+        )
+
+        # Label is optional here, but it can help identify more complex branches
+        branching_venv >> Label(option) >> t >> join_venv

airflow/providers/standard/example_dags/example_branch_operator_decorator.py

@@ -0,0 +1,142 @@
+#
+# 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.
+"""Example DAG demonstrating the usage of the branching TaskFlow API decorators.
+
+It shows how to use standard Python ``@task.branch`` as well as the external Python
+version ``@task.branch_external_python`` which calls an external Python interpreter and
+the ``@task.branch_virtualenv`` which builds a temporary Python virtual environment.
+"""
+
+from __future__ import annotations
+
+import random
+import sys
+import tempfile
+
+import pendulum
+
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.sdk import DAG, Label, task
+from airflow.utils.trigger_rule import TriggerRule
+
+PATH_TO_PYTHON_BINARY = sys.executable
+
+with DAG(
+    dag_id="example_branch_python_operator_decorator",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    schedule="@daily",
+    tags=["example", "example2"],
+) as dag:
+    run_this_first = EmptyOperator(task_id="run_this_first")
+
+    options = ["a", "b", "c", "d"]
+
+    # Example branching on standard Python tasks
+
+    # [START howto_operator_branch_python]
+    @task.branch()
+    def branching(choices: list[str]) -> str:
+        return f"branch_{random.choice(choices)}"
+
+    # [END howto_operator_branch_python]
+
+    random_choice_instance = branching(choices=options)
+
+    run_this_first >> random_choice_instance
+
+    join = EmptyOperator(task_id="join", trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS)
+
+    for option in options:
+
+        @task(task_id=f"branch_{option}")
+        def some_task():
+            print("doing something in Python")
+
+        t = some_task()
+        empty = EmptyOperator(task_id=f"follow_{option}")
+
+        # Label is optional here, but it can help identify more complex branches
+        random_choice_instance >> Label(option) >> t >> empty >> join
+
+    # Example the same with external Python calls
+
+    # [START howto_operator_branch_ext_py]
+    @task.branch_external_python(python=PATH_TO_PYTHON_BINARY)
+    def branching_ext_python(choices) -> str:
+        import random
+
+        return f"ext_py_{random.choice(choices)}"
+
+    # [END howto_operator_branch_ext_py]
+
+    random_choice_ext_py = branching_ext_python(choices=options)
+
+    join >> random_choice_ext_py
+
+    join_ext_py = EmptyOperator(task_id="join_ext_py", trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS)
+
+    for option in options:
+
+        @task.external_python(task_id=f"ext_py_{option}", python=PATH_TO_PYTHON_BINARY)
+        def some_ext_py_task():
+            print("doing something in external Python")
+
+        t = some_ext_py_task()
+
+        # Label is optional here, but it can help identify more complex branches
+        random_choice_ext_py >> Label(option) >> t >> join_ext_py
+
+    # Example the same with Python virtual environments
+
+    # [START howto_operator_branch_virtualenv]
+    # Note: Passing a caching dir allows to keep the virtual environment over multiple runs
+    #       Run the example a second time and see that it reuses it and is faster.
+    VENV_CACHE_PATH = tempfile.gettempdir()
+
+    @task.branch_virtualenv(requirements=["numpy~=1.26.0"], venv_cache_path=VENV_CACHE_PATH)
+    def branching_virtualenv(choices) -> str:
+        import random
+
+        import numpy as np
+
+        print(f"Some numpy stuff: {np.arange(6)}")
+        return f"venv_{random.choice(choices)}"
+
+    # [END howto_operator_branch_virtualenv]
+
+    random_choice_venv = branching_virtualenv(choices=options)
+
+    join_ext_py >> random_choice_venv
+
+    join_venv = EmptyOperator(task_id="join_venv", trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS)
+
+    for option in options:
+
+        @task.virtualenv(
+            task_id=f"venv_{option}", requirements=["numpy~=1.26.0"], venv_cache_path=VENV_CACHE_PATH
+        )
+        def some_venv_task():
+            import numpy as np
+
+            print(f"Some numpy stuff: {np.arange(6)}")
+
+        t = some_venv_task()
+
+        # Label is optional here, but it can help identify more complex branches
+        random_choice_venv >> Label(option) >> t >> join_venv