Remove ways to generate tasks based on returns.

Author: tobiasraabe

docs/source/how_to_guides/provisional_nodes_and_task_generators.md

@@ -81,3 +81,7 @@ content to a `.txt` file.
 
 ```{literalinclude} ../../../docs_src/how_to_guides/delayed_tasks_task_generator.py
 ```
+
+```{important}
+The generated tasks need to be decoratored with {func}`@task <pytask.task>` to be collected.
+```

docs/source/reference_guides/api.md

@@ -136,7 +136,8 @@ For example:
 
 ```python
 @pytask.mark.timeout(10, "slow", method="thread")
-def task_function(): ...
+def task_function():
+    ...
 ```
 
 Will create and attach a {class}`Mark <pytask.Mark>` object to the collected
@@ -153,7 +154,8 @@ Example for using multiple custom markers:
 ```python
 @pytask.mark.timeout(10, "slow", method="thread")
 @pytask.mark.slow
-def task_function(): ...
+def task_function():
+    ...
 ```
 
 ### Classes

docs/source/tutorials/repeating_tasks_with_different_inputs.md

@@ -268,7 +268,8 @@ the {func}`@task <pytask.task>` decorator to pass keyword arguments to the task.
 for id_, kwargs in ID_TO_KWARGS.items():
 
     @task(id=id_, kwargs=kwargs)
-    def task_create_random_data(seed, produces): ...
+    def task_create_random_data(seed, produces):
+        ...
 ```
 
 Writing a function that creates `ID_TO_KWARGS` would be even more pythonic.
@@ -288,7 +289,8 @@ ID_TO_KWARGS = create_parametrization()
 for id_, kwargs in ID_TO_KWARGS.items():
 
     @task(id=id_, kwargs=kwargs)
-    def task_create_random_data(i, produces): ...
+    def task_create_random_data(i, produces):
+        ...
 ```
 
 The {doc}`best-practices guide on parametrizations <../how_to_guides/bp_scaling_tasks>`

docs/source/tutorials/selecting_tasks.md

@@ -91,7 +91,8 @@ from pytask import task
 for i in range(2):
 
     @task
-    def task_parametrized(i=i): ...
+    def task_parametrized(i=i):
+        ...
 ```
 
 To run the task where `i = 1`, run this command.

docs/source/tutorials/skipping_tasks.md

@@ -44,7 +44,8 @@ from config import NO_LONG_RUNNING_TASKS
 @pytask.mark.skipif(NO_LONG_RUNNING_TASKS, reason="Skip long-running tasks.")
 def task_that_takes_really_long_to_run(
     path: Path = Path("time_intensive_product.pkl"),
-): ...
+):
+    ...
 ```
 
 ## Further reading

docs/source/tutorials/write_a_task.md

@@ -117,14 +117,16 @@ from pytask import task
 
 
 @task
-def create_random_data(): ...
+def create_random_data():
+    ...
 
 
 # The id will be ".../task_data_preparation.py::create_data".
 
 
 @task(name="create_data")
-def create_random_data(): ...
+def create_random_data():
+    ...
 ```
 
 ## Customize task module names

src/_pytask/delayed.py

@@ -23,7 +23,6 @@
 from _pytask.task_utils import parse_collected_tasks_with_task_marker
 from _pytask.tree_util import tree_map
 from _pytask.tree_util import tree_map_with_path
-from _pytask.typing import is_task_function
 from _pytask.typing import is_task_generator
 from pytask import TaskOutcome
 
@@ -49,13 +48,8 @@ def _safe_load(node: PNode | PProvisionalNode, task: PTask, is_product: bool) ->
         raise NodeLoadError(msg) from e
 
 
-_ERROR_TASK_GENERATOR_RETURN = """\
-Could not collect return of task generator. The return should be a task function or a \
-task class but received {} instead."""
-
-
 @hookimpl
-def pytask_execute_task(session: Session, task: PTask) -> None:  # noqa: C901, PLR0912
+def pytask_execute_task(session: Session, task: PTask) -> None:
     """Execute task generators and collect the tasks."""
     if is_task_generator(task):
         kwargs = {}
@@ -67,9 +61,7 @@ def pytask_execute_task(session: Session, task: PTask) -> None:  # noqa: C901, P
             if name in parameters:
                 kwargs[name] = tree_map(lambda x: _safe_load(x, task, True), value)
 
-        out = task.execute(**kwargs)
-        if inspect.isgenerator(out):
-            out = list(out)
+        task.execute(**kwargs)
 
         # Parse tasks created with @task.
         name_to_function: Mapping[str, Callable[..., Any] | PTask]
@@ -80,23 +72,8 @@ def pytask_execute_task(session: Session, task: PTask) -> None:  # noqa: C901, P
             tasks = COLLECTED_TASKS.pop(None)
             name_to_function = parse_collected_tasks_with_task_marker(tasks)
         else:
-            # Parse individual tasks.
-            if is_task_function(out) or isinstance(out, PTask):
-                out = [out]
-            # Parse tasks from iterable.
-            if hasattr(out, "__iter__"):
-                name_to_function = {}
-                for obj in out:
-                    if is_task_function(obj):
-                        name_to_function[obj.__name__] = obj
-                    elif isinstance(obj, PTask):
-                        name_to_function[obj.name] = obj
-                    else:
-                        msg = _ERROR_TASK_GENERATOR_RETURN.format(obj)
-                        raise ValueError(msg)
-            else:
-                msg = _ERROR_TASK_GENERATOR_RETURN.format(out)
-                raise ValueError(msg)
+            msg = "The task generator {task.name!r} did not create any tasks."
+            raise RuntimeError(msg)
 
         new_reports = []
         for name, function in name_to_function.items():

tests/test_execute.py

@@ -1093,108 +1093,6 @@ def task_copy(
     assert tmp_path.joinpath("b-copy.txt").exists()
 
 
-@pytest.mark.end_to_end()
-def test_delayed_task_generation_with_generator(runner, tmp_path):
-    source = """
-    from typing_extensions import Annotated
-    from pytask import DirectoryNode, task
-    from pathlib import Path
-
-    def task_produces() -> Annotated[None, DirectoryNode(pattern="[ab].txt")]:
-        path = Path(__file__).parent
-        path.joinpath("a.txt").write_text("Hello, ")
-        path.joinpath("b.txt").write_text("World!")
-
-    @task(after=task_produces, is_generator=True)
-    def task_depends(
-        paths = DirectoryNode(pattern="[ab].txt")
-    ) -> ...:
-        for path in paths:
-
-            @task
-            def task_copy(
-                path: Path = path
-            ) -> Annotated[str, path.with_name(path.stem + "-copy.txt")]:
-                return path.read_text()
-
-            yield task_copy
-    """
-    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, [tmp_path.as_posix()])
-    assert result.exit_code == ExitCode.OK
-    assert "4  Collected tasks" in result.output
-    assert "4  Succeeded" in result.output
-    assert tmp_path.joinpath("a-copy.txt").exists()
-    assert tmp_path.joinpath("b-copy.txt").exists()
-
-
-@pytest.mark.end_to_end()
-def test_delayed_task_generation_with_single_function(runner, tmp_path):
-    source = """
-    from typing_extensions import Annotated
-    from pytask import DirectoryNode, task
-    from pathlib import Path
-
-    def task_produces() -> Annotated[None, DirectoryNode(pattern="[a].txt")]:
-        path = Path(__file__).parent
-        path.joinpath("a.txt").write_text("Hello, ")
-
-    @task(after=task_produces, is_generator=True)
-    def task_depends(
-        paths = DirectoryNode(pattern="[a].txt")
-    ) -> ...:
-        path = paths[0]
-
-        def task_copy(
-            path: Path = path
-        ) -> Annotated[str, path.with_name(path.stem + "-copy.txt")]:
-            return path.read_text()
-        return task_copy
-    """
-    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, [tmp_path.as_posix()])
-    assert result.exit_code == ExitCode.OK
-    assert "3  Collected tasks" in result.output
-    assert "3  Succeeded" in result.output
-    assert tmp_path.joinpath("a-copy.txt").exists()
-
-
-@pytest.mark.end_to_end()
-def test_delayed_task_generation_with_task_node(runner, tmp_path):
-    source = """
-    from typing_extensions import Annotated
-    from pytask import DirectoryNode, TaskWithoutPath, task, PathNode
-    from pathlib import Path
-
-    def task_produces() -> Annotated[None, DirectoryNode(pattern="[a].txt")]:
-        path = Path(__file__).parent
-        path.joinpath("a.txt").write_text("Hello, ")
-
-    @task(after=task_produces, is_generator=True)
-    def task_depends(
-        paths = DirectoryNode(pattern="[a].txt")
-    ) -> ...:
-        path = paths[0]
-
-        task_copy = TaskWithoutPath(
-            name="task_copy",
-            function=lambda path: path.read_text(),
-            depends_on={"path": PathNode(path=path)},
-            produces={"return": PathNode(path=path.with_name(path.stem + "-copy.txt"))},
-        )
-        return task_copy
-    """
-    tmp_path.joinpath("task_module.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, [tmp_path.as_posix()])
-    assert result.exit_code == ExitCode.OK
-    assert "3  Collected tasks" in result.output
-    assert "3  Succeeded" in result.output
-    assert tmp_path.joinpath("a-copy.txt").exists()
-
-
 @pytest.mark.end_to_end()
 def test_gracefully_fail_when_task_generator_raises_error(runner, tmp_path):
     source = """