Release v0.4.0. (#42)

Author: tobiasraabe

.pre-commit-config.yaml

@@ -61,13 +61,10 @@ repos:
     rev: 'v1.5.1'
     hooks:
     -   id: mypy
-        args: [
-            --no-strict-optional,
-            --ignore-missing-imports,
-        ]
         additional_dependencies: [
             attrs>=21.3.0,
             click,
+            pytask>=0.4.0,
             types-PyYAML,
             types-setuptools
         ]

CHANGES.md

@@ -5,6 +5,10 @@ chronological order. Releases follow [semantic versioning](https://semver.org/)
 releases are available on [PyPI](https://pypi.org/project/pytask-r) and
 [Anaconda.org](https://anaconda.org/conda-forge/pytask-r).
 
+## 0.4.0 - 2023-10-08
+
+- {pull}`42` makes the package compatible with pytask v0.4.0.
+
 ## 0.3.0 - 2023-xx-xx
 
 - {pull}`33` deprecates INI configurations and aligns the plugin with pytask v0.3.

README.md

@@ -96,11 +96,10 @@ The `.json` file is stored in the same folder as the task in a `.pytask` directo
 To parse the JSON file, you need to install
 [jsonlite](https://github.com/jeroen/jsonlite).
 
-You can also pass any other information to your script by using the `@pytask.mark.task`
-decorator.
+You can also pass any other information to your script by using the `@task` decorator.
 
 ```python
-@pytask.mark.task(kwargs={"number": 1})
+@task(kwargs={"number": 1})
 @pytask.mark.r(script="script.r")
 @pytask.mark.produces("out.rds")
 def task_run_r_script():
@@ -146,20 +145,20 @@ different outputs.
 ```python
 for i in range(2):
 
-    @pytask.mark.task
+    @task
     @pytask.mark.r(script=f"script_{i}.r")
     @pytask.mark.produces(f"out_{i}.csv")
     def task_execute_r_script():
         pass
 ```
 
 If you want to pass different inputs to the same R script, pass these arguments with the
-`kwargs` keyword of the `@pytask.mark.task` decorator.
+`kwargs` keyword of the `@task` decorator.
 
 ```python
 for i in range(2):
 
-    @pytask.mark.task(kwargs={"i": i})
+    @task(kwargs={"i": i})
     @pytask.mark.r(script="script.r")
     @pytask.mark.produces(f"output_{i}.csv")
     def task_execute_r_script():

environment.yml

@@ -2,6 +2,8 @@ name: pytask-r
 
 channels:
   - conda-forge
+  - conda-forge/label/pytask_rc
+  - conda-forge/label/pytask_parallel_rc
   - nodefaults
 
 dependencies:
@@ -10,14 +12,9 @@ dependencies:
   - setuptools_scm
   - toml
 
-  # Conda
-  - anaconda-client
-  - conda-build
-  - conda-verify
-
   # Package dependencies
-  - pytask >=0.3
-  - pytask-parallel >=0.3
+  - pytask >=0.4.0
+  - pytask-parallel >=0.4.0
 
   - r-base >4
   - r-jsonlite

pyproject.toml

@@ -25,7 +25,7 @@ ignore_errors = true
 
 
 [tool.ruff]
-target-version = "py37"
+target-version = "py38"
 select = ["ALL"]
 fix = true
 extend-ignore = [
@@ -67,7 +67,7 @@ convention = "numpy"
 
 [tool.pytest.ini_options]
 # Do not add src since it messes with the loading of pytask-parallel as a plugin.
-testpaths = ["test"]
+testpaths = ["tests"]
 markers = [
     "wip: Tests that are work-in-progress.",
     "unit: Flag for unit tests which target mainly a single function.",

setup.cfg

@@ -26,8 +26,8 @@ project_urls =
 packages = find:
 install_requires =
     click
-    pybaum>=0.1.1
-    pytask>=0.3
+    pluggy>=1.0.0
+    pytask>=0.4.0
 python_requires = >=3.8
 include_package_data = True
 package_dir = =src

src/pytask_r/collect.py

@@ -1,47 +1,53 @@
 """Collect tasks."""
 from __future__ import annotations
 
-import functools
 import subprocess
+import warnings
 from pathlib import Path
-from types import FunctionType
 from typing import Any
 
-from pytask import depends_on
 from pytask import has_mark
 from pytask import hookimpl
+from pytask import is_task_function
 from pytask import Mark
-from pytask import parse_nodes
-from pytask import produces
+from pytask import NodeInfo
+from pytask import parse_dependencies_from_task_function
+from pytask import parse_products_from_task_function
+from pytask import PathNode
+from pytask import PTask
+from pytask import PythonNode
 from pytask import remove_marks
 from pytask import Session
 from pytask import Task
+from pytask import TaskWithoutPath
+from pytask_r.serialization import create_path_to_serialized
 from pytask_r.serialization import SERIALIZERS
 from pytask_r.shared import r
-from pytask_r.shared import R_SCRIPT_KEY
 
 
-def run_r_script(script: Path, options: list[str], serialized: Path) -> None:
+def run_r_script(
+    _script: Path, _options: list[str], _serialized: Path, **kwargs: Any  # noqa: ARG001
+) -> None:
     """Run an R script."""
-    cmd = ["Rscript", script.as_posix(), *options, str(serialized)]
+    cmd = ["Rscript", _script.as_posix(), *_options, str(_serialized)]
     print("Executing " + " ".join(cmd) + ".")  # noqa: T201
     subprocess.run(cmd, check=True)  # noqa: S603
 
 
 @hookimpl
 def pytask_collect_task(
-    session: Session, path: Path, name: str, obj: Any
-) -> Task | None:
+    session: Session, path: Path | None, name: str, obj: Any
+) -> PTask | None:
     """Perform some checks."""
     __tracebackhide__ = True
 
     if (
         (name.startswith("task_") or has_mark(obj, "task"))
-        and callable(obj)
+        and is_task_function(obj)
         and has_mark(obj, "r")
     ):
+        # Parse @pytask.mark.r decorator.
         obj, marks = remove_marks(obj, "r")
-
         if len(marks) > 1:
             raise ValueError(
                 f"Task {name!r} has multiple @pytask.mark.r marks, but only one is "
@@ -54,40 +60,97 @@ def pytask_collect_task(
             default_serializer=session.config["r_serializer"],
             default_suffix=session.config["r_suffix"],
         )
-        script, options, _, _ = r(**marks[0].kwargs)
+        script, options, _, suffix = r(**marks[0].kwargs)
 
         obj.pytask_meta.markers.append(mark)
 
-        dependencies = parse_nodes(session, path, name, obj, depends_on)
-        products = parse_nodes(session, path, name, obj, produces)
+        # Collect the nodes in @pytask.mark.julia and validate them.
+        path_nodes = Path.cwd() if path is None else path.parent
 
-        markers = obj.pytask_meta.markers if hasattr(obj, "pytask_meta") else []
-        kwargs = obj.pytask_meta.kwargs if hasattr(obj, "pytask_meta") else {}
-
-        task = Task(
-            base_name=name,
-            path=path,
-            function=_copy_func(run_r_script),  # type: ignore[arg-type]
-            depends_on=dependencies,
-            produces=products,
-            markers=markers,
-            kwargs=kwargs,
-        )
+        if isinstance(script, str):
+            warnings.warn(
+                "Passing a string to the @pytask.mark.r parameter 'script' is "
+                "deprecated. Please, use a pathlib.Path instead.",
+                stacklevel=1,
+            )
+            script = Path(script)
 
         script_node = session.hook.pytask_collect_node(
-            session=session, path=path, node=script
+            session=session,
+            path=path_nodes,
+            node_info=NodeInfo(
+                arg_name="_script",
+                path=(),
+                value=script,
+                task_path=path,
+                task_name=name,
+            ),
+        )
+
+        if not (isinstance(script_node, PathNode) and script_node.path.suffix == ".r"):
+            raise ValueError(
+                "The 'script' keyword of the @pytask.mark.r decorator must point "
+                f"to Julia file with the .r suffix, but it is {script_node}."
+            )
+
+        options_node = session.hook.pytask_collect_node(
+            session=session,
+            path=path_nodes,
+            node_info=NodeInfo(
+                arg_name="_options",
+                path=(),
+                value=options,
+                task_path=path,
+                task_name=name,
+            ),
+        )
+
+        dependencies = parse_dependencies_from_task_function(
+            session, path, name, path_nodes, obj
+        )
+        products = parse_products_from_task_function(
+            session, path, name, path_nodes, obj
         )
 
-        if isinstance(task.depends_on, dict):
-            task.depends_on[R_SCRIPT_KEY] = script_node
-            task.attributes["r_keep_dict"] = True
+        # Add script
+        dependencies["_script"] = script_node
+        dependencies["_options"] = options_node
+
+        markers = obj.pytask_meta.markers if hasattr(obj, "pytask_meta") else []
+
+        task: PTask
+        if path is None:
+            task = TaskWithoutPath(
+                name=name,
+                function=run_r_script,
+                depends_on=dependencies,
+                produces=products,
+                markers=markers,
+            )
         else:
-            task.depends_on = {0: task.depends_on, R_SCRIPT_KEY: script_node}
-            task.attributes["r_keep_dict"] = False
+            task = Task(
+                base_name=name,
+                path=path,
+                function=run_r_script,
+                depends_on=dependencies,
+                produces=products,
+                markers=markers,
+            )
 
-        task.function = functools.partial(
-            task.function, script=task.depends_on[R_SCRIPT_KEY].path, options=options
+        # Add serialized node that depends on the task id.
+        serialized = create_path_to_serialized(task, suffix)  # type: ignore[arg-type]
+        serialized_node = session.hook.pytask_collect_node(
+            session=session,
+            path=path_nodes,
+            node_info=NodeInfo(
+                arg_name="_serialized",
+                path=(),
+                value=PythonNode(value=serialized),
+                task_path=path,
+                task_name=name,
+            ),
         )
+        task.depends_on["_serialized"] = serialized_node
 
         return task
     return None
@@ -120,28 +183,3 @@ def _parse_r_mark(
 
     mark = Mark("r", (), parsed_kwargs)
     return mark
-
-
-def _copy_func(func: FunctionType) -> FunctionType:
-    """Create a copy of a function.
-
-    Based on https://stackoverflow.com/a/13503277/7523785.
-
-    Example
-    -------
-    >>> def _func(): pass
-    >>> copied_func = _copy_func(_func)
-    >>> _func is copied_func
-    False
-
-    """
-    new_func = FunctionType(
-        func.__code__,
-        func.__globals__,
-        name=func.__name__,
-        argdefs=func.__defaults__,
-        closure=func.__closure__,
-    )
-    new_func = functools.update_wrapper(new_func, func)
-    new_func.__kwdefaults__ = func.__kwdefaults__
-    return new_func