renamed task_def_as/from_dict to task_class_as/from_dict

Author: tclose

docs/source/tutorial/7-canonical-form.ipynb

@@ -246,7 +246,7 @@
     "\n",
     "As well as the dataclass-like canonical form, it is also possible to represent all tasks\n",
     "in a nested dictionary form, which could be written to a static file (e.g. in JSON or\n",
-    "YAML format). The dictionary form of a class can be generated by the `pydra.utils.task_def_as_dict`\n",
+    "YAML format). The dictionary form of a class can be generated by the `pydra.utils.task_class_as_dict`\n",
     "function. For example, the following shell command"
    ]
   },
@@ -278,9 +278,9 @@
    "outputs": [],
    "source": [
     "from pprint import pprint\n",
-    "from pydra.utils import task_def_as_dict\n",
+    "from pydra.utils import task_class_as_dict\n",
     "\n",
-    "my_cmd_dict = task_def_as_dict(MyCmd)\n",
+    "my_cmd_dict = task_class_as_dict(MyCmd)\n",
     "\n",
     "pprint(my_cmd_dict)"
    ]
@@ -301,7 +301,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "cp_with_size_dict = task_def_as_dict(CpFileWithSize)\n",
+    "cp_with_size_dict = task_class_as_dict(CpFileWithSize)\n",
     "\n",
     "pprint(cp_with_size_dict)"
    ]
@@ -311,7 +311,7 @@
    "metadata": {},
    "source": [
     "To unserialize the general dictionary form back into a Task class, you can use the\n",
-    "`pydra.utils.task_def_from_dict` method"
+    "`pydra.utils.task_class_from_dict` method"
    ]
   },
   {
@@ -320,9 +320,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pydra.utils import task_def_from_dict\n",
+    "from pydra.utils import task_class_from_dict\n",
     "\n",
-    "ReloadedCpFileWithSize = task_def_from_dict(cp_with_size_dict)"
+    "ReloadedCpFileWithSize = task_class_from_dict(cp_with_size_dict)"
    ]
   },
   {

pydra/utils/__init__.py

@@ -5,8 +5,8 @@
     show_workflow,
     task_help,
     print_help,
-    task_def_as_dict,
-    task_def_from_dict,
+    task_class_as_dict,
+    task_class_from_dict,
 )
 from ._version import __version__
 
@@ -18,6 +18,6 @@
     "show_workflow",
     "task_help",
     "print_help",
-    "task_def_as_dict",
-    "task_def_from_dict",
+    "task_class_as_dict",
+    "task_class_from_dict",
 ]

pydra/utils/general.py

@@ -587,21 +587,21 @@ def get_plugin_classes(namespace: types.ModuleType, class_name: str) -> dict[str
     }
 
 
-def task_def_as_dict(
-    task_def: "type[Task]",
+def task_class_as_dict(
+    task_class: "type[Task]",
     filter: ty.Callable[[attrs.Attribute, ty.Any], bool] | None = None,
     value_serializer: (
         ty.Callable[[ty.Any, attrs.Attribute, ty.Any], ty.Any] | None
     ) = None,
     **kwargs: ty.Any,
 ) -> ty.Dict[str, ty.Any]:
     """Converts a Pydra task class into a dictionary representation that can be serialized
-    and saved to a file, then read and passed to an appropriate `pydra.compose.*.define`
+    (e.g. to a file), then reread and passed to an appropriate `pydra.compose.*.define`
     method to recreate the task.
 
     Parameters
     ----------
-    task_def : type[pydra.compose.base.Task]
+    task_class : type[pydra.compose.base.Task]
         The Pydra task class to convert.
     filter : callable, optional
         A function to filter out certain attributes from the task definition passed
@@ -626,54 +626,54 @@ def task_def_as_dict(
     if filter is None:
         filter = _filter_out_defaults
 
-    input_fields = task_fields(task_def)
-    executor = input_fields.pop(task_def._executor_name).default
+    input_fields = task_fields(task_class)
+    executor = input_fields.pop(task_class._executor_name).default
     input_dicts = [
         attrs.asdict(i, filter=filter, value_serializer=value_serializer, **kwargs)
         for i in input_fields
         if (
             not isinstance(i, Out)  # filter out outarg fields
-            and i.name not in task_def.BASE_ATTRS
+            and i.name not in task_class.BASE_ATTRS
         )
     ]
     output_dicts = [
         attrs.asdict(o, filter=filter, value_serializer=value_serializer, **kwargs)
-        for o in task_fields(task_def.Outputs)
-        if o.name not in task_def.Outputs.BASE_ATTRS
+        for o in task_fields(task_class.Outputs)
+        if o.name not in task_class.Outputs.BASE_ATTRS
     ]
     dct = {
-        "type": task_def._task_type(),
-        task_def._executor_name: executor,
-        "name": task_def.__name__,
+        "type": task_class._task_type(),
+        task_class._executor_name: executor,
+        "name": task_class.__name__,
         "inputs": {d.pop("name"): d for d in input_dicts},
         "outputs": {d.pop("name"): d for d in output_dicts},
     }
-    class_attrs = {a: getattr(task_def, "_" + a) for a in task_def.TASK_CLASS_ATTRS}
+    class_attrs = {a: getattr(task_class, "_" + a) for a in task_class.TASK_CLASS_ATTRS}
     if value_serializer:
-        attrs_fields = {f.name: f for f in attrs.fields(task_def)}
+        attrs_fields = {f.name: f for f in attrs.fields(task_class)}
         class_attrs = {
-            n: value_serializer(task_def, attrs_fields[n], v)
+            n: value_serializer(task_class, attrs_fields[n], v)
             for n, v in class_attrs.items()
         }
     dct.update(class_attrs)
 
     return dct
 
 
-def task_def_from_dict(task_def_dict: dict[str, ty.Any]) -> type["Task"]:
-    """Unserializes a task definition from a dictionary created by `task_def_as_dict`
+def task_class_from_dict(task_class_dict: dict[str, ty.Any]) -> type["Task"]:
+    """Unserializes a task definition from a dictionary created by `task_class_as_dict`
 
     Parameters
     ----------
-    task_def_dict: dict[str, Any]
+    task_class_dict: dict[str, Any]
         the dictionary representation to unserialize
 
     Returns
     -------
     type[pydra.compose.base.Task]
         the unserialized task class
     """
-    dct = copy(task_def_dict)
+    dct = copy(task_class_dict)
     task_type = dct.pop("type")
     mod = importlib.import_module(f"pydra.compose.{task_type}")
     return mod.define(dct.pop(mod.Task._executor_name), **dct)

pydra/utils/tests/test_general.py

@@ -1,10 +1,10 @@
 from pydra.compose import python, workflow, shell
 from fileformats.generic import File
-from pydra.utils.general import task_def_as_dict, task_def_from_dict, task_fields
+from pydra.utils.general import task_class_as_dict, task_class_from_dict, task_fields
 from pydra.utils.tests.utils import SpecificFuncTask, Concatenate
 
 
-def test_python_task_def_as_dict():
+def test_python_task_class_as_dict():
 
     @python.define(outputs=["out_int"], xor=["b", "c"])
     def Add(a: int, b: int | None = None, c: int | None = None) -> int:
@@ -25,23 +25,23 @@ def Add(a: int, b: int | None = None, c: int | None = None) -> int:
         """
         return a + (b if b is not None else c)
 
-    dct = task_def_as_dict(Add)
-    Reloaded = task_def_from_dict(dct)
+    dct = task_class_as_dict(Add)
+    Reloaded = task_class_from_dict(dct)
     assert task_fields(Add) == task_fields(Reloaded)
 
 
-def test_shell_task_def_as_dict():
+def test_shell_task_class_as_dict():
 
     MyCmd = shell.define(
         "my-cmd <in_file> <out|out_file> --an-arg <an_arg:int=2> --a-flag<a_flag>"
     )
 
-    dct = task_def_as_dict(MyCmd)
-    Reloaded = task_def_from_dict(dct)
+    dct = task_class_as_dict(MyCmd)
+    Reloaded = task_class_from_dict(dct)
     assert task_fields(MyCmd) == task_fields(Reloaded)
 
 
-def test_workflow_task_def_as_dict():
+def test_workflow_task_class_as_dict():
 
     @workflow.define
     def AWorkflow(in_file: File, a_param: int) -> tuple[File, File]:
@@ -53,6 +53,6 @@ def AWorkflow(in_file: File, a_param: int) -> tuple[File, File]:
         )
         return concatenate.out_file
 
-    dct = task_def_as_dict(AWorkflow)
-    Reloaded = task_def_from_dict(dct)
+    dct = task_class_as_dict(AWorkflow)
+    Reloaded = task_class_from_dict(dct)
     assert task_fields(AWorkflow) == task_fields(Reloaded)