dv-flow-mgr 0.0.1.13577785562a1__tar.gz → 0.0.1.13644197178a1__tar.gz

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.13577785562a1
+Version: 0.0.1.13644197178a1
 Summary: DV Flow Manager is a build system for silicon design
 Author-email: Matthew Ballance <matt.ballance@gmail.com>
 License:                                  Apache License

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/docs/Steps.md

@@ -115,4 +115,31 @@ with:
   # List-of 
   - append-list: 
 
+# Why PSS?
+- Key usecases
+
+# Open Source and PSS
+
+# YAML basics
+- Load packages and create TaskNodeCtor objects from a YAML file
+- Define types in YAML
+- Implement a 'task factory'
+  - Support package overrides (config setting?)
+  - 
+
+# TaskNode, TaskNodeCtor
+- TaskNodeCtor exists for each node type
+  - Every node declaration in a YAML file
+  - Node types accessed via the Python API
+- A new node -- likely with different parameter values -- can be created via the API
+- A node created via the YAML spec has a dedicated node ctor
+
+When created via the 
+
+# Early Differentiators
+- Library of tools with aggressive work avoidance (faster turnaround)
+- Cross-tool support (strategy for category support)
+- Extract and display markers (easier identification of failures)
+
+
 

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dv-flow-mgr"
-version = "0.0.1.13577785562a1"
+version = "0.0.1.13644197178a1"
 dependencies = [
     'pydantic',
     'pyyaml',

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/__init__.py

@@ -7,4 +7,5 @@ from .task_data import *
 from .task_graph_runner import TaskGraphRunner
 from .task_graph_runner_local import TaskGraphRunnerLocal
 from .task_graph_builder import TaskGraphBuilder
+from .task_node import task
 

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/package_def.py

@@ -33,7 +33,7 @@ from typing import Any, Dict, List, Callable, Tuple, ClassVar
 from .fragment_def import FragmentDef
 from .package import Package
 from .package_import_spec import PackageImportSpec, PackageSpec
-#from .task import TaskCtorCls, TaskCtorParam, TaskCtorParamCls
+from .task_node import TaskNodeCtor, TaskNodeCtorProxy, TaskNodeCtorTask
 from .task_ctor import TaskCtor
 from .task_def import TaskDef, TaskSpec
 from .std.task_null import TaskNull
@@ -151,20 +151,7 @@ class PackageDef(BaseModel):
             if decl_params:
                 self._log.debug("Type declares new parameters")
                 # We need to combine base parameters with new parameters
-                ptype_m = {
-                    "str" : str,
-                    "int" : int,
-                    "float" : float,
-                    "bool" : bool,
-                    "list" : List
-                }
-                pdflt_m = {
-                    "str" : "",
-                    "int" : 0,
-                    "float" : 0.0,
-                    "bool" : False,
-                    "list" : []
-                }
+
                 for p in task.params.keys():
                     param = task.params[p]
                     self._log.debug("param: %s" % str(param))
@@ -221,16 +208,24 @@ class PackageDef(BaseModel):
 
     def mkTaskCtor(self, session, task, srcdir, tasks_m) -> TaskCtor:
         self._log.debug("--> %s::mkTaskCtor %s (srcdir: %s)" % (self.name, task.name, srcdir))
+        base_ctor_t : TaskCtor = None
         ctor_t : TaskCtor = None
+        base_params : BaseModel = None
+        callable = None
+        needs = [] if task.needs is None else task.needs.copy()
+
+        if task.uses is not None:
+            base_ctor_t = self.getTaskCtor(session, task.uses, tasks_m)
+            base_params = base_ctor_t.mkTaskParams()
 
         # Determine the implementation constructor first
-        if task.pyclass is not None:
+        if task.pytask is not None:
             # Built-in impl
             # Now, lookup the class
-            self._log.debug("Use PyClass implementation")
-            last_dot = task.pyclass.rfind('.')
-            clsname = task.pyclass[last_dot+1:]
-            modname = task.pyclass[:last_dot]
+            self._log.debug("Use PyTask implementation")
+            last_dot = task.pytask.rfind('.')
+            clsname = task.pytask[last_dot+1:]
+            modname = task.pytask[:last_dot]
 
             try:
                 if modname not in sys.modules:
@@ -245,26 +240,26 @@ class PackageDef(BaseModel):
                 
             if not hasattr(mod, clsname):
                 raise Exception("Class %s not found in module %s" % (clsname, modname))
-            task_ctor = getattr(mod, clsname)
-
-            # Determine if we need to use a new 
-
-            if task.uses is not None:
-                uses = self.getTaskCtor(session, task.uses, tasks_m)
-            else:
-                uses = None
+            callable = getattr(mod, clsname)
 
-            ctor_t = TaskCtorCls(
+        # Determine if we need to use a new 
+        paramT = self._getParamT(task, base_params)
+        
+        if callable is not None:
+            ctor_t = TaskNodeCtorTask(
                 name=task.name,
-                uses=uses,
-                task_ctor=task_ctor,
-                srcdir=srcdir)
-        elif task.uses is not None:
+                srcdir=srcdir,
+                paramT=paramT, # TODO: need to determine the parameter type
+                needs=needs, # TODO: need to determine the needs
+                task=callable)
+        elif base_ctor_t is not None:
             # Use the existing (base) to create the implementation
-            ctor_t = TaskCtor(
+            ctor_t = TaskNodeCtorProxy(
                 name=task.name,
-                uses=self.getTaskCtor(session, task.uses, tasks_m),
-                srcdir=srcdir)
+                srcdir=srcdir,
+                paramT=paramT, # TODO: need to determine the parameter type
+                needs=needs,
+                uses=base_ctor_t)
         else:
             self._log.debug("Use 'Null' as the class implementation")
             ctor_t = TaskCtorCls(
@@ -272,11 +267,77 @@ class PackageDef(BaseModel):
                 task_ctor=TaskNull,
                 srcdir=srcdir)
 
-        ctor_t = self.handleParams(task, ctor_t)
-        ctor_t.depends.extend(task.depends)
+# TODO:
+#        ctor_t = self.handleParams(task, ctor_t)
+#        ctor_t.depends.extend(task.depends)
 
         self._log.debug("<-- %s::mkTaskCtor %s" % (self.name, task.name))
         return ctor_t
+    
+    def _getParamT(self, task, base_t : BaseModel):
+        # Get the base parameter type (if available)
+        # We will build a new type with updated fields
+
+        ptype_m = {
+            "str" : str,
+            "int" : int,
+            "float" : float,
+            "bool" : bool,
+            "list" : List
+        }
+        pdflt_m = {
+            "str" : "",
+            "int" : 0,
+            "float" : 0.0,
+            "bool" : False,
+            "list" : []
+        }
+
+        fields = []
+        field_m : Dict[str,int] = {}
+
+        # First, pull out existing fields (if there's a base type)
+        if base_t is not None:
+            self._log.debug("Base type: %s" % str(base_t))
+            for name,f in base_t.model_fields.items():
+                ff : dc.Field = f
+                fields.append(f)
+                field_m[name] = (f.annotation, getattr(base_t, name))
+        else:
+            self._log.debug("No base type")
+
+        for p in task.params.keys():
+            param = task.params[p]
+            self._log.debug("param: %s %s (%s)" % (p, str(param), str(type(param))))
+            if hasattr(param, "type") and param.type is not None:
+                ptype_s = param.type
+                if ptype_s not in ptype_m.keys():
+                    raise Exception("Unknown type %s" % ptype_s)
+                ptype = ptype_m[ptype_s]
+
+                if p in field_m.keys():
+                    raise Exception("Duplicate field %s" % p)
+                if param.value is not None:
+                    field_m[p] = (ptype, param.value)
+                else:
+                    field_m[p] = (ptype, pdflt_m[ptype_s])
+                self._log.debug("Set param=%s to %s" % (p, str(field_m[p][1])))
+            else:
+                if p not in field_m.keys():
+                    raise Exception("Field %s not found" % p)
+                if type(param) != dict:
+                    value = param
+                elif "value" in param.keys():
+                    value = param["value"]
+                else:
+                    raise Exception("No value specified for param %s: %s" % (
+                        p, str(param)))
+                field_m[p] = (field_m[p][0], value)
+                self._log.debug("Set param=%s to %s" % (p, str(field_m[p][1])))
+
+        params_t = pydantic.create_model("Task%sParams" % task.name, **field_m)
+
+        return params_t
 
     @staticmethod
     def load(path, exp_pkg_name=None):

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/param_def.py

@@ -14,7 +14,6 @@ class ComplexType(BaseModel):
     map : Union[MapType, None] = None
 
 class ParamDef(BaseModel):
-    name : str
     doc : str = None
     type : Union[str, 'ComplexType'] = None
     value : Union[Any, None] = None

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/param_ref_eval.py

@@ -7,8 +7,8 @@ from .eval_jq import eval_jq
 @dc.dataclass
 class ParamRefEval(object):
 
-    parser : ExprParser = ExprParser()
-    expr_eval : ExprEval = ExprEval()
+    parser : ExprParser = dc.field(default_factory=ExprParser)
+    expr_eval : ExprEval = dc.field(default_factory=ExprEval)
 
     def __post_init__(self):
         self.expr_eval.methods["jq"] = eval_jq

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/task_def.py

@@ -35,11 +35,11 @@ class TaskDef(BaseModel):
     name : str
 #    type : Union[str,TaskSpec] = dc.Field(default_factory=list)
     uses : str = dc.Field(default=None)
-    pyclass : str = dc.Field(default=None)
+    pytask : str = dc.Field(default=None)
     desc : str = dc.Field(default="")
     doc : str = dc.Field(default="")
-    depends : List[Union[str,TaskSpec]] = dc.Field(default_factory=list, alias="needs")
-    params: List[ParamDef] = dc.Field(default_factory=list, alias="with")
+    needs : List[Union[str,TaskSpec]] = dc.Field(default_factory=list, alias="needs")
+    params: Dict[str,Union[str,ParamDef]] = dc.Field(default_factory=dict, alias="with")
 #    out: List[TaskOutput] = dc.Field(default_factory=list)
 
     def copy(self) -> 'TaskDef':

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/task_graph_builder.py

@@ -96,20 +96,26 @@ class TaskGraphBuilder(object):
 
         self._logger.debug("ctor_t: %s" % ctor_t.name)
 
-        depends = []
+        needs = []
 
-        for dep in ctor_t.depends:
-            if not dep in self._task_m.keys():
-                task = self._mkTaskGraph(dep, rundir)
-                self._task_m[dep] = task
-                pass
-            depends.append(self._task_m[dep])
+        # for dep in ctor_t.depends:
+        #     if not dep in self._task_m.keys():
+        #         task = self._mkTaskGraph(dep, rundir)
+        #         self._task_m[dep] = task
+        #         pass
+        #     depends.append(self._task_m[dep])
 
         # The returned task should have all param references resolved
-        task = ctor_t.mkTask(
+        params = ctor_t.mkTaskParams()
+
+        if params is None:
+            raise Exception("ctor %s returned None for params" % str(ctor_t))
+
+        task = ctor_t.mkTaskNode(
+            params=params,
             name=task_name,
-            depends=depends,
-            rundir=rundir)
+            needs=needs)
+        task.rundir = rundir
         
         self._task_m[task.name] = task
 

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow/mgr/task_node.py

@@ -1,4 +1,5 @@
-
+import os
+import sys
 import dataclasses as dc
 import pydantic.dataclasses as pdc
 import logging
@@ -27,6 +28,10 @@ class TaskNode(object):
 
     _log : ClassVar = logging.getLogger("TaskNode")
 
+    def __post_init__(self):
+        if self.needs is None:
+            self.needs = []
+
     async def do_run(self, 
                   runner,
                   rundir,
@@ -96,38 +101,110 @@ class TaskNodeCtor(object):
     - Produces a TaskNode
     """
     name : str
+    srcdir : str
+    paramT : Any
 
-    def mkTaskNode(self, srcdir, params, name=None) -> TaskNode:
+    def getNeeds(self) -> List[str]:
+        return []
+
+    def mkTaskNode(self,
+                   params,
+                   srcdir=None,
+                   name=None,
+                   needs=None) -> TaskNode:
         raise NotImplementedError("mkTaskNode in type %s" % str(type(self)))
 
-    def mkTaskParams(self, params : Dict) -> Any:
-        raise NotImplementedError("mkTaskParams in type %s" % str(type(self)))
+    def mkTaskParams(self, params : Dict = None) -> Any:
+        obj = self.paramT()
+
+        # Apply user-specified params
+        if params is not None:
+            for key,value in params.items():
+                if not hasattr(obj, key):
+                    raise Exception("Parameters class %s does not contain field %s" % (
+                        str(type(obj)),
+                        key))
+                else:
+                    if isinstance(value, Param):
+                        if value.append is not None:
+                            ex_value = getattr(obj, key, [])
+                            ex_value.extend(value.append)
+                            setattr(obj, key, ex_value)
+                        elif value.prepend is not None:
+                            ex_value = getattr(obj, key, [])
+                            value = value.copy()
+                            value.extend(ex_value)
+                            setattr(obj, key, value)
+                            pass
+                        else:
+                            raise Exception("Unhandled value spec: %s" % str(value))
+                    else:
+                        setattr(obj, key, value)
+        return obj
+
+@dc.dataclass
+class TaskNodeCtorDefBase(TaskNodeCtor):
+    """Task defines its own needs, that will need to be filled in"""
+    needs : List['str']
+
+    def __post_init__(self):
+        if self.needs is None:
+            self.needs = []
+
+    def getNeeds(self) -> List[str]:
+        return self.needs
+
+@dc.dataclass
+class TaskNodeCtorProxy(TaskNodeCtorDefBase):
+    """Task has a 'uses' clause, so we delegate creation of the node"""
+    uses : TaskNodeCtor
+
+    def mkTaskNode(self, params, srcdir=None, name=None, needs=None) -> TaskNode:
+        if srcdir is None:
+            srcdir = self.srcdir
+        node = self.uses.mkTaskNode(params=params, srcdir=srcdir, name=name, needs=needs)
+        return node
+    
+@dc.dataclass
+class TaskNodeCtorTask(TaskNodeCtorDefBase):
+    task : Callable[['TaskRunner','TaskDataInput'],'TaskDataResult']
+
+    def mkTaskNode(self, params, srcdir=None, name=None, needs=None) -> TaskNode:
+        if srcdir is None:
+            srcdir = self.srcdir
+
+        node = TaskNode(name, srcdir, params, self.task, needs=needs)
+        node.task = self.task
+
+        return node
 
 @dc.dataclass
 class TaskNodeCtorWrapper(TaskNodeCtor):
     T : Any
-    paramT : Any
 
     def __call__(self, 
-                 srcdir, 
-                 name=None, 
-                 params=None, 
+                 name=None,
+                 srcdir=None,
+                 params=None,
                  needs=None,
                  **kwargs):
         """Convenience method for direct creation of tasks"""
         if params is None:
             params = self.mkTaskParams(kwargs)
         
-        node = self.mkTaskNode(srcdir, params, name)
-        if needs is not None:
-            node.needs.extend(needs)
+        node = self.mkTaskNode(
+            srcdir=srcdir, 
+            params=params, 
+            name=name, 
+            needs=needs)
+
         return node
 
-    def mkTaskNode(self, srcdir, params, name=None) -> TaskNode:
-        node = TaskNode(name, srcdir, params, self.T)
+    def mkTaskNode(self, params, srcdir=None, name=None, needs=None) -> TaskNode:
+        node = TaskNode(name, srcdir, params, self.T, needs=needs)
         return node
 
-    def mkTaskParams(self, params : Dict) -> Any:
+    def mkTaskParams(self, params : Dict = None) -> Any:
         obj = self.paramT()
 
         # Apply user-specified params
@@ -155,7 +232,16 @@ class TaskNodeCtorWrapper(TaskNodeCtor):
         return obj
 
 def task(paramT):
+    """Decorator to wrap a task method as a TaskNodeCtor"""
     def wrapper(T):
-        ctor = TaskNodeCtorWrapper(T.__name__, T, paramT)
+        task_mname = T.__module__
+        task_module = sys.modules[task_mname]
+        ctor = TaskNodeCtorWrapper(
+            T.__name__, 
+            os.path.dirname(os.path.abspath(task_module.__file__)), 
+            paramT,
+            T)
         return ctor
     return wrapper
+
+

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/src/dv_flow_mgr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.13577785562a1
+Version: 0.0.1.13644197178a1
 Summary: DV Flow Manager is a build system for silicon design
 Author-email: Matthew Ballance <matt.ballance@gmail.com>
 License:                                  Apache License

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/tests/unit/test_pyclass.py

@@ -3,6 +3,7 @@ import os
 import asyncio
 import pytest
 from dv_flow.mgr import TaskGraphBuilder, TaskGraphRunnerLocal, PackageDef
+from dv_flow.mgr.task_runner import TaskSetRunner
 #from dv_flow_mgr.tasklib.builtin_pkg import TaskPyClass, TaskPyClassParams
 
 # def test_smoke(tmpdir):
@@ -36,20 +37,18 @@ package:
   name: pkg1
   tasks:
   - name: foo
-    pyclass: my_module.foo
+    pytask: my_module.foo
     with:
       param1:
         type: str
         value: "1"
 """
     module = """
-from dv_flow.mgr import Task, TaskData
-
-class foo(Task):
-    async def run(self, input : TaskData) -> TaskData:
-        print("foo::run", flush=True)
-        print("params: %s" % str(self.params), flush=True)
-        return input
+from dv_flow.mgr import TaskDataResult
+async def foo(runner, input):
+    print("foo::run", flush=True)
+    print("params: %s" % str(input.params), flush=True)
+    return TaskDataResult()
 """
 
     with open(os.path.join(tmpdir, "my_module.py"), "w") as f:
@@ -62,7 +61,7 @@ class foo(Task):
     builder = TaskGraphBuilder(
         root_pkg=pkg_def,
         rundir=os.path.join(tmpdir, "rundir"))
-    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskSetRunner(os.path.join(tmpdir, "rundir"))
 
     task = builder.mkTaskGraph("pkg1.foo")
     output = asyncio.run(runner.run(task))
@@ -75,7 +74,7 @@ package:
   name: pkg1
   tasks:
   - name: foo
-    pyclass: my_module.foo
+    pytask: my_module.foo
     with:
       param1:
         type: str
@@ -84,13 +83,12 @@ package:
     uses: foo
 """
     module = """
-from dv_flow.mgr import Task, TaskData
+from dv_flow.mgr import TaskDataResult
 
-class foo(Task):
-    async def run(self, input : TaskData) -> TaskData:
-        print("foo::run", flush=True)
-        print("params: %s" % str(self.params), flush=True)
-        return input
+async def foo(runner, input) -> TaskDataResult:
+    print("foo::run", flush=True)
+    print("params: %s" % str(input.params), flush=True)
+    return TaskDataResult()
 """
 
     with open(os.path.join(tmpdir, "my_module.py"), "w") as f:
@@ -102,7 +100,7 @@ class foo(Task):
     builder = TaskGraphBuilder(
         root_pkg=pkg_def,
         rundir=os.path.join(tmpdir, "rundir"))
-    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskSetRunner(rundir=os.path.join(tmpdir, "rundir"))
 
     task = builder.mkTaskGraph("pkg1.foo2")
     output = asyncio.run(runner.run(task))
@@ -114,7 +112,7 @@ package:
   name: pkg1
   tasks:
   - name: foo
-    pyclass: my_module.foo
+    pytask: my_module.foo
     with:
       param1:
         type: str
@@ -126,13 +124,12 @@ package:
 
 """
     module = """
-from dv_flow.mgr import Task, TaskData
+from dv_flow.mgr import TaskDataResult
 
-class foo(Task):
-    async def run(self, input : TaskData) -> TaskData:
+async def foo(runner, input) -> TaskDataResult:
         print("foo::run", flush=True)
-        print("params: %s" % str(self.params), flush=True)
-        return input
+        print("params: %s" % str(input.params), flush=True)
+        return TaskDataResult()
 """
 
     with open(os.path.join(tmpdir, "my_module.py"), "w") as f:
@@ -144,9 +141,9 @@ class foo(Task):
     builder = TaskGraphBuilder(
         root_pkg=pkg_def,
         rundir=os.path.join(tmpdir, "rundir"))
-    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskSetRunner(rundir=os.path.join(tmpdir, "rundir"))
 
-    task = builder.mkTaskGraph("pkg1.foo")
+    task = builder.mkTaskGraph("pkg1.foo2")
     output = asyncio.run(runner.run(task))
 
 def test_class_use_with_new_param(tmpdir):

{dv_flow_mgr-0.0.1.13577785562a1 → dv_flow_mgr-0.0.1.13644197178a1}/tests/unit/test_pytask_smoke.py

@@ -20,17 +20,17 @@ def test_smoke_1(tmpdir):
 
     called = False
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask(runner, input):
             nonlocal called
             called = True
             print("Hello from run")
             return TaskDataResult()
 
-    task = MyTask("srcdir", p1="p1")
+    task1 = MyTask(srcdir="srcdir", p1="p1")
     runner = SingleTaskRunner("rundir")
 
-    result = asyncio.run(runner.run(task))
+    result = asyncio.run(runner.run(task1))
 
     assert called
 
@@ -41,22 +41,19 @@ def test_smoke_2(tmpdir):
         p1 : str = None
 
     called = False
-    @Task.ctor(Params)
-    class MyTask(Task):
-        async def run(self, runner, input):
-            nonlocal called
-            called = True
-            print("Hello from run")
-            return TaskDataResult(
-                markers=[TaskMarker(msg="testing", severity="info")]
-            )
-
-    task = MyTask.mkTask("task1", "srcdir", MyTask.mkParams(
-        p1="p1"
-    ))
+    @task(Params)
+    async def MyTask(runner, input):
+        nonlocal called
+        called = True
+        print("Hello from run")
+        return TaskDataResult(
+            markers=[TaskMarker(msg="testing", severity="info")]
+        )
+
+    task1 = MyTask(name="task1", srcdir="srcdir", p1="p1")
     runner = SingleTaskRunner("rundir")
 
-    result = asyncio.run(runner.run(task))
+    result = asyncio.run(runner.run(task1))
 
     assert called
     assert result is not None
@@ -64,33 +61,32 @@ def test_smoke_2(tmpdir):
 
 def test_smoke_3(tmpdir):
 
-    @dc.dataclass
-    class Params(object):
+    class Params(BaseModel):
         p1 : str = None
 
     called = []
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask1(runner, input):
             nonlocal called
             called.append(("MyTask1", input.params.p1))
             return TaskDataResult()
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask2(runner, input):
             nonlocal called
             called.append(("MyTask2", input.params.p1))
             return TaskDataResult()
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask3(runner, input):
             nonlocal called
             called.append(("MyTask3", input.params.p1))
             return TaskDataResult()
 
-    task1 = MyTask1("srcdir", p1="1")
-    task2 = MyTask2("srcdir", p1="2")
-    task3 = MyTask3("srcdir", p1="3", needs=[task1, task2])
+    task1 = MyTask1(srcdir="srcdir", p1="1")
+    task2 = MyTask2(srcdir="srcdir", p1="2")
+    task3 = MyTask3(srcdir="srcdir", p1="3", needs=[task1, task2])
     runner = TaskSetRunner("rundir")
 
     result = asyncio.run(runner.run(task3))
@@ -109,7 +105,7 @@ def test_smoke_4(tmpdir):
 
     called = []
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask1(runner, input):
             nonlocal called
             called.append(("MyTask1", input.params.p1))
@@ -117,7 +113,7 @@ def test_smoke_4(tmpdir):
                   output=[TaskData(val=1)]
             )
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask2(runner, input):
             nonlocal called
             called.append(("MyTask2", input.params.p1))
@@ -125,16 +121,16 @@ def test_smoke_4(tmpdir):
                   output=[TaskData(val=2)]
             )
 
-    @t_decorator(Params)
+    @task(Params)
     async def MyTask3(runner, input):
             nonlocal called
             called.append(("MyTask3", input.params.p1))
             return TaskDataResult()
 
-    task1 = MyTask1("srcdir", p1="1")
-    task2 = MyTask2("srcdir", p1="2")
-    task3 = MyTask3("srcdir", 
-                    p1="${{ in | jq('.[] .val') }}", 
+    task1 = MyTask1(srcdir="srcdir", p1="1")
+    task2 = MyTask2(srcdir="srcdir", p1="2")
+    task3 = MyTask3(srcdir="srcdir", 
+                    p1="${{ in | jq('[.[] .val]') }}", 
                     needs=[task1, task2])
     runner = TaskSetRunner("rundir")
 
@@ -176,9 +172,9 @@ def test_smoke_5(tmpdir):
             called.append(("MyTask3", input.params.p1))
             return TaskDataResult()
 
-    task1 = MyTask1("srcdir", p1="1")
-    task2 = MyTask2("srcdir", p1="2")
-    task3 = MyTask3("srcdir", 
+    task1 = MyTask1(srcdir="srcdir", p1="1")
+    task2 = MyTask2(srcdir="srcdir", p1="2")
+    task3 = MyTask3(srcdir="srcdir", 
                     p1="${{ in | jq('[.[] .files]') | jq('flatten') }}", 
 #                    p1="${{ in | jq('.[] .files') }}", 
                     needs=[task1, task2])
@@ -222,9 +218,9 @@ def test_smoke_6(tmpdir):
             called.append(("MyTask3", input.params.p1))
             return TaskDataResult()
 
-    task1 = MyTask1("srcdir", p1="3")
-    task2 = MyTask2("srcdir", p1=Param(append=["4"]))
-    task3 = MyTask3("srcdir", 
+    task1 = MyTask1(srcdir="srcdir", p1="3")
+    task2 = MyTask2(srcdir="srcdir", p1=Param(append=["4"]))
+    task3 = MyTask3(srcdir="srcdir", 
                     p1="${{ in | jq('[.[] .files]') | jq('flatten') }}", 
 #                    p1="${{ in | jq('.[] .files') }}", 
                     needs=[task1, task2])