renamed task_fields to get_fields

Author: tclose

docs/source/tutorial/5-shell.ipynb

@@ -162,7 +162,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pydra.utils import task_fields\n",
+    "from pydra.utils import get_fields\n",
     "\n",
     "Cp = shell.define(\n",
     "    \"cp <in_fs_objects:fs-object+> <out|out_dir:directory> \"\n",
@@ -172,7 +172,7 @@
     "    \"--tuple-arg <tuple_arg:int,str=(1,'bar')> \"\n",
     ")\n",
     "\n",
-    "print(f\"'--int-arg' default: {task_fields(Cp).int_arg.default}\")"
+    "print(f\"'--int-arg' default: {get_fields(Cp).int_arg.default}\")"
    ]
   },
   {

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

@@ -340,7 +340,7 @@
    "source": [
     "from pathlib import Path\n",
     "import tempfile\n",
-    "from pydra.utils import task_as_dict\n",
+    "from pydra.utils import asdict\n",
     "\n",
     "tmp_dir = Path(tempfile.mkdtemp())\n",
     "\n",
@@ -350,7 +350,7 @@
     "cp_file_with_size = ReloadedCpFileWithSize(in_file=a_file)\n",
     "outputs = cp_file_with_size(cache_root=tmp_dir / \"cache\")\n",
     "\n",
-    "pprint(task_as_dict(outputs))"
+    "pprint(asdict(outputs))"
    ]
   }
  ],

pydra/compose/base/field.py

@@ -6,7 +6,7 @@
 from fileformats.core import to_mime
 from fileformats.generic import File, FileSet
 from pydra.utils.typing import TypeParser, is_optional, is_type, is_union
-from pydra.utils.general import task_fields, wrap_text
+from pydra.utils.general import get_fields, wrap_text
 import attrs
 
 if ty.TYPE_CHECKING:
@@ -66,7 +66,7 @@ class Requirement:
     def satisfied(self, inputs: "Task") -> bool:
         """Check if the requirement is satisfied by the inputs"""
         value = getattr(inputs, self.name)
-        field = {f.name: f for f in task_fields(inputs)}[self.name]
+        field = {f.name: f for f in get_fields(inputs)}[self.name]
         if value is None or field.type is bool and value is False:
             return False
         if self.allowed_values is None:

pydra/compose/base/helpers.py

@@ -4,7 +4,7 @@
 import re
 from copy import copy
 from pydra.utils.typing import is_type, is_optional
-from pydra.utils.general import task_fields
+from pydra.utils.general import get_fields
 from .field import Field, Arg, Out, NO_DEFAULT
 
 
@@ -418,7 +418,7 @@ def extract_fields(klass, field_type, auto_attribs, helps) -> dict[str, Field]:
         """Get the fields from a class"""
         fields_dict = {}
         # Get fields defined in base classes if present
-        for field in task_fields(klass):
+        for field in get_fields(klass):
             if field.name not in skip_fields:
                 fields_dict[field.name] = field
         type_hints = ty.get_type_hints(klass)

pydra/compose/base/task.py

@@ -5,7 +5,7 @@
 from typing import Self
 import attrs.validators
 from pydra.utils.typing import is_optional, is_fileset_or_union
-from pydra.utils.general import task_fields
+from pydra.utils.general import get_fields
 from pydra.utils.typing import StateArray, is_lazy
 from pydra.utils.hash import hash_function
 import os
@@ -67,7 +67,7 @@ def _from_job(cls, job: "Job[TaskType]") -> Self:
             The outputs of the job
         """
         defaults = {}
-        for output in task_fields(cls):
+        for output in get_fields(cls):
             if output.mandatory:
                 default = attrs.NOTHING
             elif isinstance(output.default, attrs.Factory):
@@ -116,18 +116,18 @@ def __getitem__(self, name_or_index: str | int) -> ty.Any:
     def __eq__(self, other: ty.Any) -> bool:
         """Check if two tasks are equal"""
         values = attrs.asdict(self)
-        fields = task_fields(self)
+        fields = get_fields(self)
         try:
             other_values = attrs.asdict(other)
         except AttributeError:
             return False
         try:
-            other_fields = task_fields(other)
+            other_fields = get_fields(other)
         except AttributeError:
             return False
         if fields != other_fields:
             return False
-        for field in task_fields(self):
+        for field in get_fields(self):
             if field.hash_eq:
                 values[field.name] = hash_function(values[field.name])
                 other_values[field.name] = hash_function(other_values[field.name])
@@ -137,7 +137,7 @@ def __repr__(self) -> str:
         """A string representation of the task"""
         fields_str = ", ".join(
             f"{f.name}={getattr(self, f.name)!r}"
-            for f in task_fields(self)
+            for f in get_fields(self)
             if getattr(self, f.name) != f.default
         )
         return f"{self.__class__.__name__}({fields_str})"
@@ -407,7 +407,7 @@ def __repr__(self) -> str:
         """A string representation of the task"""
         fields_str = ", ".join(
             f"{f.name}={getattr(self, f.name)!r}"
-            for f in task_fields(self)
+            for f in get_fields(self)
             if getattr(self, f.name) != f.default
         )
         return f"{self.__class__.__name__}({fields_str})"
@@ -416,7 +416,7 @@ def __iter__(self) -> ty.Generator[str, None, None]:
         """Iterate through all the names in the task"""
         return (
             f.name
-            for f in task_fields(self)
+            for f in get_fields(self)
             if not (f.name.startswith("_") or f.name in self.RESERVED_FIELD_NAMES)
         )
 
@@ -431,7 +431,7 @@ def __eq__(self, other: ty.Any) -> bool:
             return False
         if set(values) != set(other_values):
             return False  # Return if attribute keys don't match
-        for field in task_fields(self):
+        for field in get_fields(self):
             if field.hash_eq:
                 values[field.name] = hash_function(values[field.name])
                 other_values[field.name] = hash_function(other_values[field.name])
@@ -486,7 +486,7 @@ def _hash_changes(self):
     def _compute_hashes(self) -> ty.Tuple[bytes, ty.Dict[str, bytes]]:
         """Compute a basic hash for any given set of fields."""
         inp_dict = {}
-        for field in task_fields(self):
+        for field in get_fields(self):
             if isinstance(field, Out):
                 continue  # Skip output fields
             # removing values that are not set from hash calculation
@@ -508,7 +508,7 @@ def _rule_violations(self) -> list[str]:
 
         field: Arg
         errors = []
-        for field in task_fields(self):
+        for field in get_fields(self):
             value = self[field.name]
 
             if is_lazy(value):
@@ -625,7 +625,7 @@ def _check_resolved(self):
 @register_serializer
 def bytes_repr_task(obj: Task, cache: Cache) -> ty.Iterator[bytes]:
     yield f"task[{obj._task_type()}]:(".encode()
-    for field in task_fields(obj):
+    for field in get_fields(obj):
         yield f"{field.name}=".encode()
         yield hash_single(getattr(obj, field.name), cache)
         yield b","

pydra/compose/python.py

@@ -2,7 +2,7 @@
 import inspect
 from typing import dataclass_transform
 import attrs
-from pydra.utils.general import task_fields, task_as_dict
+from pydra.utils.general import get_fields, asdict
 from pydra.compose import base
 from pydra.compose.base import (
     ensure_field_objects,
@@ -226,12 +226,12 @@ class PythonTask(base.Task[PythonOutputsType]):
 
     def _run(self, job: "Job[PythonTask]", rerun: bool = True) -> None:
         # Prepare the inputs to the function
-        inputs = task_as_dict(self)
+        inputs = asdict(self)
         del inputs["function"]
         # Run the actual function
         returned = self.function(**inputs)
         # Collect the outputs and save them into the job.return_values dictionary
-        return_names = [f.name for f in task_fields(self.Outputs)]
+        return_names = [f.name for f in get_fields(self.Outputs)]
         if returned is None:
             job.return_values = {nm: None for nm in return_names}
         elif not return_names:

pydra/compose/shell/task.py

@@ -11,7 +11,7 @@
 from fileformats.generic import FileSet, File
 from pydra.utils.general import (
     attrs_values,
-    task_fields,
+    get_fields,
     ensure_list,
     position_sort,
 )
@@ -80,7 +80,7 @@ def _from_job(cls, job: "Job[Task]") -> ty.Self:
         """
         outputs = super()._from_job(job)
         fld: field.out
-        for fld in task_fields(cls):
+        for fld in get_fields(cls):
             if fld.name in ["return_code", "stdout", "stderr"]:
                 resolved_value = job.return_values[fld.name]
             # Get the corresponding value from the inputs if it exists, which will be
@@ -281,7 +281,7 @@ def _command_args(self, values: dict[str, ty.Any]) -> list[str]:
         self._check_rules()
         # Drop none/empty values and optional path fields that are set to false
         values = copy(values)  # Create a copy so we can drop items from the dictionary
-        for fld in task_fields(self):
+        for fld in get_fields(self):
             fld_value = values[fld.name]
             if fld_value is None or (is_multi_input(fld.type) and fld_value == []):
                 del values[fld.name]
@@ -295,7 +295,7 @@ def _command_args(self, values: dict[str, ty.Any]) -> list[str]:
             self._command_shelltask_executable(fld, self.executable),
         ]  # list for (position, command arg)
         positions_provided = [0]
-        fields = {f.name: f for f in task_fields(self)}
+        fields = {f.name: f for f in get_fields(self)}
         for field_name in values:
             pos_val = self._command_pos_args(
                 fld=fields[field_name],
@@ -449,7 +449,7 @@ def _rule_violations(self) -> list[str]:
         errors = super()._rule_violations()
         # if there is a value that has to be updated (e.g. single value from a list)
         # getting all fields that should be formatted, i.e. {field_name}, ...
-        fields = task_fields(self)
+        fields = get_fields(self)
         available_template_names = [f.name for f in fields] + ["field", "inputs"]
         for fld in fields:
             if fld.argstr:

pydra/compose/shell/templating.py

@@ -5,7 +5,7 @@
 from copy import copy
 from pathlib import Path
 from fileformats.generic import FileSet
-from pydra.utils.general import attrs_values, task_fields
+from pydra.utils.general import attrs_values, get_fields
 from pydra.utils.typing import is_lazy
 from . import field
 
@@ -32,7 +32,7 @@ def template_update(
     # Collect templated inputs for which all requirements are satisfied.
     fields_templ = [
         fld
-        for fld in task_fields(task)
+        for fld in get_fields(task)
         if isinstance(fld, field.outarg)
         and fld.path_template
         and getattr(task, fld.name)

pydra/compose/shell/tests/test_shell_fields.py

@@ -5,7 +5,7 @@
 import pytest
 import cloudpickle as cp
 from pydra.compose import shell
-from pydra.utils.general import task_fields, task_help, wrap_text
+from pydra.utils.general import get_fields, task_help, wrap_text
 from pydra.compose.shell.builder import _InputPassThrough
 from fileformats.generic import File, Directory, FsObject
 from fileformats import text, image
@@ -1032,7 +1032,7 @@ def list_entries(stdout):
 
 
 def sorted_fields(interface):
-    fields = task_fields(interface)
+    fields = get_fields(interface)
     length = len(fields) - 1
 
     def pos_key(out: shell.out) -> int:

pydra/compose/tests/test_python_equivalence.py

@@ -3,11 +3,11 @@
 import typing as ty
 from pydra.compose.base import Field
 from pydra.compose import python
-from pydra.utils.general import task_fields, attrs_values
+from pydra.utils.general import get_fields, attrs_values
 
 
 def non_func_fields(defn: python.Task) -> list[Field]:
-    return [f for f in task_fields(defn) if f.name != "function"]
+    return [f for f in get_fields(defn) if f.name != "function"]
 
 
 def non_func_values(defn: python.Task) -> dict:
@@ -79,16 +79,16 @@ def Indirect(a):
     assert non_func_fields(Direct) == non_func_fields(Partial)
     assert non_func_fields(Direct) == non_func_fields(Indirect)
 
-    assert task_fields(Direct.Outputs) == task_fields(Partial.Outputs)
-    assert task_fields(Direct.Outputs) == task_fields(Indirect.Outputs)
+    assert get_fields(Direct.Outputs) == get_fields(Partial.Outputs)
+    assert get_fields(Direct.Outputs) == get_fields(Indirect.Outputs)
 
     # Run functions to ensure behavior is unaffected
     a = random.randint(0, (1 << 32) - 3)
     assert non_func_values(Direct(a=a)) == non_func_values(Partial(a=a))
     assert non_func_values(Direct(a=a)) == non_func_values(Indirect(a=a))
 
     # checking if the annotation is properly converted to output_spec if used in task
-    assert task_fields(Direct.Outputs).out == python.out(name="out", type=int)
+    assert get_fields(Direct.Outputs).out == python.out(name="out", type=int)
 
 
 def test_annotation_equivalence_2():
@@ -117,7 +117,7 @@ def Indirect(a) -> tuple[int, float]:
     assert hashes(Direct(a=a)) == hashes(Partial(a=a)) == hashes(Indirect(a=a))
 
     # checking if the annotation is properly converted to output_spec if used in task
-    assert list(task_fields(Direct.Outputs)) == [
+    assert list(get_fields(Direct.Outputs)) == [
         python.out(name="out1", type=int),
         python.out(name="out2", type=float),
     ]
@@ -149,7 +149,7 @@ def Indirect(a):
     assert hashes(Direct(a=a)) == hashes(Partial(a=a)) == hashes(Indirect(a=a))
 
     # checking if the annotation is properly converted to output_spec if used in task
-    assert task_fields(Direct.Outputs).out1 == python.out(name="out1", type=int)
+    assert get_fields(Direct.Outputs).out1 == python.out(name="out1", type=int)
 
 
 def test_annotation_equivalence_4():
@@ -169,22 +169,22 @@ def Indirect(a):
 
     # checking if the annotations are equivalent
     assert (
-        task_fields(Direct.Outputs)
-        == task_fields(Partial.Outputs)
-        == task_fields(Indirect.Outputs)
+        get_fields(Direct.Outputs)
+        == get_fields(Partial.Outputs)
+        == get_fields(Indirect.Outputs)
     )
     assert (
-        task_fields(Direct.Outputs)
-        == task_fields(Partial.Outputs)
-        == task_fields(Indirect.Outputs)
+        get_fields(Direct.Outputs)
+        == get_fields(Partial.Outputs)
+        == get_fields(Indirect.Outputs)
     )
 
     # Run functions to ensure behavior is unaffected
     a = random.randint(0, (1 << 32) - 3)
     assert hashes(Direct(a=a)) == hashes(Partial(a=a)) == hashes(Indirect(a=a))
 
     # checking if the annotation is properly converted to output_spec if used in task
-    assert list(task_fields(Direct.Outputs)) == [
+    assert list(get_fields(Direct.Outputs)) == [
         python.out(name="sum", type=int),
         python.out(name="sub", type=int),
     ]