dv-flow-mgr 0.0.1.14116344455a1__py3-none-any.whl → 0.0.1.14147547123a1__py3-none-any.whl

dv_flow/mgr/package_def.py

@@ -33,7 +33,7 @@ from .fragment_def import FragmentDef
 from .package import Package
 from .package_import_spec import PackageImportSpec, PackageSpec
 from .param_def import ParamDef
-from .task_def import TaskDef, PassthroughE, ConsumesE
+from .task_def import TaskDef, PassthroughE, ConsumesE, RundirE
 from .task_node_ctor import TaskNodeCtor
 from .task_node_ctor_proxy import TaskNodeCtorProxy
 from .task_node_ctor_task import TaskNodeCtorTask
@@ -182,30 +182,21 @@ class PackageDef(BaseModel):
         ctor_t : TaskNodeCtor = None
         base_params : BaseModel = None
         callable = None
-        passthrough = task.passthrough
-        consumes = task.consumes.copy() if isinstance(task.consumes, list) else task.consumes
-        needs = [] if task.needs is None else task.needs.copy()
         fullname = self.name + "." + task.name
+        rundir = task.rundir
 
         if task.uses is not None:
             self._log.debug("Uses: %s" % task.uses)
             base_ctor_t = self.getTaskCtor(session, task.uses, tasks_m)
             base_params = base_ctor_t.mkTaskParams()
 
-            if passthrough is None:
-                passthrough = base_ctor_t.passthrough
-            if consumes is None:
-                consumes = base_ctor_t.consumes
 
             if base_ctor_t is None:
                 self._log.error("Failed to load task ctor %s" % task.uses)
         else:
             self._log.debug("No 'uses' specified")
 
-        if passthrough is None:
-            passthrough = PassthroughE.No
-        if consumes is None:
-            consumes = ConsumesE.All
+        passthrough, consumes, needs = self._getPTConsumesNeeds(task, base_ctor_t)
 
         # Determine the implementation constructor first
         if task.pytask is not None:
@@ -242,7 +233,8 @@ class PackageDef(BaseModel):
                 passthrough=passthrough,
                 consumes=consumes,
                 needs=needs, # TODO: need to determine the needs
-                task=callable)
+                task=callable,
+                rundir=rundir)
         elif base_ctor_t is not None:
             # Use the existing (base) to create the implementation
             ctor_t = TaskNodeCtorProxy(
@@ -252,6 +244,7 @@ class PackageDef(BaseModel):
                 passthrough=passthrough,
                 consumes=consumes,
                 needs=needs,
+                rundir=rundir,
                 uses=base_ctor_t)
         else:
             self._log.debug("Use 'Null' as the class implementation")
@@ -262,6 +255,7 @@ class PackageDef(BaseModel):
                 passthrough=passthrough,
                 consumes=consumes,
                 needs=needs,
+                rundir=rundir,
                 task=TaskNull)
 
         self._log.debug("<-- %s::mkTaskCtor %s" % (self.name, task.name))
@@ -273,9 +267,7 @@ class PackageDef(BaseModel):
         ctor_t : TaskNodeCtor = None
         base_params : BaseModel = None
         callable = None
-        passthrough = task.passthrough
-        consumes = [] if task.consumes is None else task.consumes.copy()
-        needs = [] if task.needs is None else task.needs.copy()
+
         fullname = self.name + "." + task.name
 
 
@@ -284,13 +276,11 @@ class PackageDef(BaseModel):
             base_ctor_t = self.getTaskCtor(session, task.uses, tasks_m)
             base_params = base_ctor_t.mkTaskParams()
 
-            # Once we have passthrough, we can't turn it off
-            passthrough |= base_ctor_t.passthrough
-            consumes.extend(base_ctor_t.consumes)
-
             if base_ctor_t is None:
                 self._log.error("Failed to load task ctor %s" % task.uses)
 
+        passthrough, consumes, needs = self._getPTConsumesNeeds(task, base_ctor_t)
+
         # Determine if we need to use a new 
         paramT = self._getParamT(session, task, base_params)
 
@@ -321,6 +311,25 @@ class PackageDef(BaseModel):
         
         self._log.debug("<-- %s::mkTaskCtor %s (%d)" % (self.name, task.name, len(ctor_t.tasks)))
         return ctor_t
+    
+    def _getPTConsumesNeeds(self, task, base_ctor_t):
+        passthrough = task.passthrough
+        consumes = task.consumes.copy() if isinstance(task.consumes, list) else task.consumes
+        needs = [] if task.needs is None else task.needs.copy()
+
+        if self.uses is not None:
+            if passthrough is None:
+                passthrough = base_ctor_t.passthrough
+            if consumes is None:
+                consumes = base_ctor_t.consumes
+
+        if passthrough is None:
+            passthrough = PassthroughE.No
+        if consumes is None:
+            consumes = ConsumesE.All
+
+
+        return (passthrough, consumes, needs)
 
     def _getParamT(self, session, task, base_t : BaseModel):
         self._log.debug("--> _getParamT %s" % task.fullname)

dv_flow/mgr/task_graph_builder.py

@@ -25,6 +25,7 @@ import logging
 from .package import Package
 from .package_def import PackageDef, PackageSpec
 from .pkg_rgy import PkgRgy
+from .task_def import RundirE
 from .task_node import TaskNode
 from .task_node_ctor import TaskNodeCtor
 from typing import Dict, List, Union
@@ -37,6 +38,7 @@ class TaskNamespaceScope(object):
 class CompoundTaskCtxt(object):
     parent : 'TaskGraphBuilder'
     task : 'TaskNode'
+    rundir : RundirE
     task_m : Dict[str,TaskNode] = dc.field(default_factory=dict)
     uses_s : List[Dict[str, TaskNode]] = dc.field(default_factory=list)
 
@@ -53,6 +55,7 @@ class TaskGraphBuilder(object):
     _override_m : Dict[str,str] = dc.field(default_factory=dict)
     _ns_scope_s : List[TaskNamespaceScope] = dc.field(default_factory=list)
     _compound_task_ctxt_s : List[CompoundTaskCtxt] = dc.field(default_factory=list)
+    _rundir_s : List[str] = dc.field(default_factory=list)
     _uses_count : int = 0
 
     _logger : logging.Logger = None
@@ -97,7 +100,7 @@ class TaskGraphBuilder(object):
             for subpkg in pkg.subpkg_m.values():
                 self._registerPackages(subpkg, visited)
 
-
+    
     def push_package(self, pkg : Package, add=False):
         self._pkg_s.append(pkg)
         if add:
@@ -109,6 +112,18 @@ class TaskGraphBuilder(object):
     def package(self):
         return self._pkg_s[-1]
 
+    def enter_rundir(self, rundir : str):
+        self._rundir_s.append(rundir)
+
+    def get_rundir(self, rundir=None):
+        ret = self._rundir_s.copy()
+        if rundir is not None:
+            ret.append(rundir)
+        return ret
+    
+    def leave_rundir(self):
+        self._rundir_s.pop()
+
     def enter_uses(self):
         self._uses_count += 1
 
@@ -117,9 +132,13 @@ class TaskGraphBuilder(object):
     
     def leave_uses(self):
         self._uses_count -= 1
-    
-    def enter_compound(self, task : TaskNode):
-        self._compound_task_ctxt_s.append(CompoundTaskCtxt(parent=self, task=task))
+
+    def enter_compound(self, task : TaskNode, rundir=None):
+        self._compound_task_ctxt_s.append(CompoundTaskCtxt(
+            parent=self, task=task, rundir=rundir))
+
+        if rundir is None or rundir == RundirE.Unique:
+            self._rundir_s.append(task.name)
 
     def get_name_prefix(self):
         if len(self._compound_task_ctxt_s) > 0:
@@ -151,6 +170,7 @@ class TaskGraphBuilder(object):
 
     def addTask(self, name, task : TaskNode):
         self._logger.debug("--> addTask: %s" % name)
+
         if len(self._compound_task_ctxt_s) == 0:
             self._task_m[name] = task
         else:
@@ -179,7 +199,9 @@ class TaskGraphBuilder(object):
         return task
 
     def leave_compound(self, task : TaskNode):
-        self._compound_task_ctxt_s.pop()
+        ctxt = self._compound_task_ctxt_s.pop()
+        if ctxt.rundir is None or ctxt.rundir == RundirE.Unique:
+            self._rundir_s.pop()
 
     def mkTaskGraph(self, task : str) -> TaskNode:
         self._pkg_s.clear()

dv_flow/mgr/task_node.py

@@ -48,8 +48,8 @@ class TaskNode(object):
     passthrough : bool = False
     consumes : List[Any] = dc.field(default_factory=list)
     needs : List[Tuple['TaskNode',bool]] = dc.field(default_factory=list)
-    rundir : str = dc.field(default=None)
-    rundir_t : RundirE = dc.field(default=RundirE.Unique)
+    rundir : List[str] = dc.field(default=None)
+#    rundir_t : RundirE = dc.field(default=RundirE.Unique)
     output : TaskDataOutput = dc.field(default=None)
     result : TaskDataResult = dc.field(default=None)
     start : float = dc.field(default=None)
@@ -58,6 +58,8 @@ class TaskNode(object):
     _log : ClassVar = logging.getLogger("TaskNode")
 
     def __post_init__(self):
+        # Give this a default run directory based on the task name
+        self.rundir = [self.name]
         if self.needs is None:
             self.needs = []
         else:
@@ -69,7 +71,7 @@ class TaskNode(object):
                   runner,
                   rundir,
                   memento : Any = None) -> 'TaskDataResult':
-        pass
+        raise NotImplementedError("do_run not implemented for %s" % self.__class__.__name__)
 
     def __hash__(self):
         return id(self)

dv_flow/mgr/task_node_compound.py

@@ -20,12 +20,17 @@
 #*
 #****************************************************************************
 import dataclasses as dc
+from pydantic import BaseModel
+from .task_def import ConsumesE
 from .task_node import TaskNode
 from .task_node_leaf import TaskNodeLeaf
 from .task_data import TaskDataResult, TaskDataInput, TaskDataOutput
 from .task_runner import TaskRunner
 from typing import Any, List
 
+class NullParams(BaseModel):
+    pass
+
 @dc.dataclass
 class TaskNodeCompound(TaskNode):
     """A Compound task node is the 'out' node in the subgraph"""
@@ -33,17 +38,55 @@ class TaskNodeCompound(TaskNode):
     input : TaskNode = None
 
     def __post_init__(self):
+        async def null_run(runner, input):
+            return TaskDataResult()
+        
         self.input = TaskNodeLeaf(
-            self.name + ".in",
+            name=self.name + ".in",
             srcdir=self.srcdir,
-            params=None)
+            params=NullParams())
+        self.input.task = null_run
         return super().__post_init__()
 
     async def do_run(self, 
                      runner : TaskRunner, 
                      rundir, 
                      memento : Any=None) -> TaskDataResult:
-        pass
+        self._log.debug("Compound task %s (%d)" % (self.name, len(self.needs)))
+
+        add_s = set()
+        output = []
+        status = 0
+        changed = False
+
+        for n in self.needs:
+            status |= n[0].result.status
+            changed |= n[0].output.changed
+            for o in n[0].output.output:
+                o_id = (o.src, o.seq)
+                if not o_id in add_s:
+                    if self.consumes is not None or self.consumes == ConsumesE.All:
+                        add_s.add(o_id)
+                        output.append(o)
+                    elif isinstance(self.consumes, list) and self._matches(o, self.consumes):
+                        add_s.add(o_id)
+                        output.append(o)
+
+        self.result = TaskDataResult(
+            status=status,
+            changed=changed,
+            output=output
+        )
+
+        # TODO: Handle passthrough and deps
+
+        self.output = TaskDataOutput(
+            changed=changed,
+            output=output,
+            dep_m={})
+
+        return 0
 
     def __hash__(self):
-        return id(self)
+        return id(self)
+    

dv_flow/mgr/task_node_ctor_compound.py

@@ -25,7 +25,7 @@ import dataclasses as dc
 import logging
 from pydantic import BaseModel
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
-from .task_def import TaskDef
+from .task_def import TaskDef, RundirE
 from .task_data import TaskDataOutput, TaskDataResult
 from .task_node import TaskNode
 from .task_node_ctor import TaskNodeCtor
@@ -44,14 +44,18 @@ class TaskNodeCtorCompound(TaskNodeCtor):
         if srcdir is None:
             srcdir = self.srcdir
 
+        if params is None:
+            raise Exception("params is None")
+
         node = TaskNodeCompound(
             name=name, 
             srcdir=srcdir,
             params=params,
             needs=needs)
+        # Use the compound task's rundir
+        node.input.rundir = builder.get_rundir()
 
-
-        builder.enter_compound(node)
+        builder.enter_compound(node, self.task_def.rundir)
         builder.addTask("in", node.input)
 
         self._buildSubGraph(builder, node)

dv_flow/mgr/task_node_ctor_compound_proxy.py

@@ -26,6 +26,9 @@ class TaskNodeCtorCompoundProxy(TaskNodeCtorCompound):
         if srcdir is None:
             srcdir = self.srcdir
 
+        if params is None:
+            raise Exception("params is None")
+
         is_compound_uses = builder.is_compound_uses()
 
         if not is_compound_uses:

dv_flow/mgr/task_node_ctor_def_base.py

@@ -28,15 +28,14 @@ import logging
 import toposort
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
-from .task_params_ctor import TaskParamsCtor
-from .param_ref_eval import ParamRefEval
-from .param import Param
+from .task_def import RundirE
 from .task_node_ctor import TaskNodeCtor
 
 @dc.dataclass
 class TaskNodeCtorDefBase(TaskNodeCtor):
     """Task defines its own needs, that will need to be filled in"""
     needs : List['str']
+    rundir : RundirE 
 
     def __post_init__(self):
         if self.needs is None:

dv_flow/mgr/task_node_ctor_proxy.py

@@ -28,9 +28,6 @@ import logging
 import toposort
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
-from .task_params_ctor import TaskParamsCtor
-from .param_ref_eval import ParamRefEval
-from .param import Param
 from .task_node import TaskNode
 from .task_node_ctor import TaskNodeCtor
 from .task_node_ctor_def_base import TaskNodeCtorDefBase

dv_flow/mgr/task_node_ctor_task.py

@@ -28,12 +28,9 @@ import logging
 import toposort
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
-from .task_params_ctor import TaskParamsCtor
-from .param_ref_eval import ParamRefEval
-from .param import Param
+from .task_def import RundirE
 from .task_node import TaskNode
 from .task_node_leaf import TaskNodeLeaf
-from .task_node_ctor import TaskNodeCtor
 from .task_node_ctor_def_base import TaskNodeCtorDefBase
 
 @dc.dataclass
@@ -49,6 +46,9 @@ class TaskNodeCtorTask(TaskNodeCtorDefBase):
         if srcdir is None:
             srcdir = self.srcdir
 
+        if params is None:
+            raise Exception("params is None")
+
         node = TaskNodeLeaf(
             name=name, 
             srcdir=srcdir, 
@@ -58,6 +58,7 @@ class TaskNodeCtorTask(TaskNodeCtorDefBase):
         node.passthrough = self.passthrough
         node.consumes = self.consumes
         node.task = self.task
+        node.rundir = builder.get_rundir()
         builder.addTask(name, node)
 
         self._log.debug("<-- mkTaskNode")

dv_flow/mgr/task_node_ctor_wrapper.py

@@ -28,19 +28,20 @@ import logging
 import toposort
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
-from .task_params_ctor import TaskParamsCtor
-from .param_ref_eval import ParamRefEval
 from .param import Param
 from .task_node import TaskNode
 from .task_node_leaf import TaskNodeLeaf
 from .task_node_ctor import TaskNodeCtor
-from .task_node_ctor_def_base import TaskNodeCtorDefBase
 
 @dc.dataclass
 class TaskNodeCtorWrapper(TaskNodeCtor):
     T : Any
+    _count : int = 0
 
     def mkTaskNode(self, builder, params, srcdir=None, name=None, needs=None) -> TaskNode:
+        if params is None:
+            raise Exception("params is None")
+
         node = TaskNodeLeaf(
             name=name, 
             srcdir=srcdir, 
@@ -49,6 +50,14 @@ class TaskNodeCtorWrapper(TaskNodeCtor):
             needs=needs)
         node.passthrough = self.passthrough
         node.consumes = self.consumes
+        if name is None:
+            name = "%s_%d" % (self.name, self._count)
+            self._count += 1
+
+        if builder is not None:
+            node.rundir = builder.get_rundir(name)
+        else:
+            node.rundir = [name]
         return node
 
     def mkTaskParams(self, params : Dict = None) -> Any:

dv_flow/mgr/task_node_leaf.py

@@ -9,7 +9,6 @@ from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
 from .task_def import ConsumesE, PassthroughE
 from .task_node import TaskNode
-from .task_params_ctor import TaskParamsCtor
 from .param_ref_eval import ParamRefEval
 from .param import Param
 
@@ -28,6 +27,9 @@ class TaskNodeLeaf(TaskNode):
 
         self.rundir = rundir
 
+        if self.params is None:
+            raise Exception("params is None (%s)" % str(self))
+
         # TODO: Form dep-map from inputs
 
         dep_m = {}

dv_flow/mgr/task_runner.py

@@ -106,7 +106,7 @@ class TaskSetRunner(TaskRunner):
         if self._log.isEnabledFor(logging.DEBUG):
             self._log.debug("Order:")
             for active_s in order:
-                self._log.debug("- {%s}", ",".join(t.name for t in active_s))
+                self._log.debug("- {%s}", ",".join(str(t.name) for t in active_s))
 
         active_task_l = []
         done_task_s = set()
@@ -117,33 +117,28 @@ class TaskSetRunner(TaskRunner):
                 while len(active_task_l) >= self.nproc and t not in done_task_s:
                     # Wait for at least one job to complete
                     done, pending = await asyncio.wait(at[1] for at in active_task_l)
-                    for d in done:
-                        for i in range(len(active_task_l)):
-                            if active_task_l[i][1] == d:
-                                tt = active_task_l[i][0]
-                                tt.end = datetime.now()
-                                if tt.result.memento is not None:
-                                    dst_memento[tt.name] = tt.result.memento.model_dump()
-                                else:
-                                    dst_memento[tt.name] = None
-                                self.status |= tt.result.status 
-                                self._notify(tt, "leave")
-                                done_task_s.add(tt)
-                                active_task_l.pop(i)
-                                break
+                    self._completeTasks(active_task_l, done_task_s, done, dst_memento)
 
                 if self.status == 0 and t not in done_task_s:
                     memento = src_memento.get(t.name, None)
-                    dirname = t.name
+#                    dirname = t.name
                     invalid_chars_pattern = r'[\/:*?"<>|#%&{}\$\\!\'`;=@+]'
 
-                    if t.rundir_t == RundirE.Unique:
-                        # Replace invalid characters with the replacement string.
-                        dirname = re.sub(invalid_chars_pattern, '_', dirname)
+                    # TaskNode rundir is a list of path elements relative
+                    # to the root rundir
+                    rundir = self.rundir
 
-                        rundir = os.path.join(self.rundir, dirname)
-                    else:
-                        rundir = self.rundir
+                    for rundir_e in t.rundir:
+                        rundir_e = re.sub(invalid_chars_pattern, '_', rundir_e)
+                        rundir = os.path.join(rundir, rundir_e)
+
+                    # if t.rundir_t == RundirE.Unique:
+                    #     # Replace invalid characters with the replacement string.
+                    #     dirname = re.sub(invalid_chars_pattern, '_', dirname)
+
+                    #     rundir = os.path.join(self.rundir, dirname)
+                    # else:
+                    #     rundir = self.rundir
 
                     if not os.path.isdir(rundir):
                         os.makedirs(rundir, exist_ok=True)
@@ -162,19 +157,10 @@ class TaskSetRunner(TaskRunner):
                
             # All pending tasks in the task-group have been launched
             # Wait for them to all complete
-            if len(active_task_l):
+            while len(active_task_l):
                 # TODO: Shouldn't gather here -- reach to each completion
-                coros = list(at[1] for at in active_task_l)
-                res = await asyncio.gather(*coros)
-                for tt in active_task_l:
-                    tt[0].end = datetime.now()
-                    if tt[0].result.memento is not None:
-                        dst_memento[tt[0].name] = tt[0].result.memento.model_dump()
-                    else:
-                        dst_memento[tt[0].name] = None
-                    self.status |= tt[0].result.status
-                    self._notify(tt[0], "leave")
-                active_task_l.clear()
+                done, pending = await asyncio.wait(at[1] for at in active_task_l)
+                self._completeTasks(active_task_l, done_task_s, done, dst_memento)
             
             if self.status != 0:
                 self._log.debug("Exiting due to status: %d", self.status)
@@ -196,6 +182,25 @@ class TaskSetRunner(TaskRunner):
         else:
             return None
         
+    def _completeTasks(self, active_task_l, done_task_s, done_l, dst_memento):
+        for d in done_l:
+            for i in range(len(active_task_l)):
+                if active_task_l[i][1] == d:
+                    tt = active_task_l[i][0]
+                    tt.end = datetime.now()
+                    if tt.result is None:
+                        raise Exception("Task %s did not produce a result" % tt.name)
+                    if tt.result.memento is not None:
+                        dst_memento[tt.name] = tt.result.memento.model_dump()
+                    else:
+                        dst_memento[tt.name] = None
+                    self.status |= tt.result.status 
+                    self._notify(tt, "leave")
+                    done_task_s.add(tt)
+                    active_task_l.pop(i)
+                    break
+    pass
+        
     def buildDepMap(self, task : Union[TaskNode, List[TaskNode]]) -> Dict[TaskNode, Set[TaskNode]]:
         tasks = task if isinstance(task, list) else [task]
         dep_m = {}

{dv_flow_mgr-0.0.1.14116344455a1.dist-info → dv_flow_mgr-0.0.1.14147547123a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-flow-mgr
-Version: 0.0.1.14116344455a1
+Version: 0.0.1.14147547123a1
 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.14116344455a1.dist-info → dv_flow_mgr-0.0.1.14147547123a1.dist-info}/RECORD

@@ -7,7 +7,7 @@ dv_flow/mgr/fileset.py,sha256=4izm4-qldWLiZxWDUa5Em0iFizzS-S-O0YU6zvtbUUs,1264
 dv_flow/mgr/fragment_def.py,sha256=AHx3ITbiNbGCzlDk5FM8Iimm0GJnWXDDRAoRC1b41jM,1647
 dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
 dv_flow/mgr/package.py,sha256=9FhOu1hKYKzlD88zehwrI6KAcs1E7TbXDnq4v54dqDQ,1701
-dv_flow/mgr/package_def.py,sha256=WdVVpWVe4Pip5mR717iz2UWoZPkIfKrH8KzPIK-t73Y,20777
+dv_flow/mgr/package_def.py,sha256=pyuwgTszJ9n4r3WXuITSkrJuIoN6RwS6saX-_XmHgGk,20880
 dv_flow/mgr/package_import_spec.py,sha256=aZMpnS9a5NFY76_pYXEuO3-Mkc_xFzy73fdrUe_54Dc,1760
 dv_flow/mgr/param.py,sha256=kkxMRGf6mPjSZJsjgLKH2vJL62Sn0ZESvjBLkEYOp20,1386
 dv_flow/mgr/param_def.py,sha256=mkAw3DanIxcVWRYeh9lUAfUMkpqDFly_Ku_iobr4ix8,1745
@@ -16,22 +16,22 @@ dv_flow/mgr/parsetab.py,sha256=I-p3nC60t9jiNtPhKyl_sE92SiP96zJLnNdydcLy33g,3780
 dv_flow/mgr/pkg_rgy.py,sha256=d1nIjRm3ymMNJT-yiMDxCS6bFisTPvLMqh5VrfsHVKM,5404
 dv_flow/mgr/task_data.py,sha256=lN7Iq8YTitEMGG4rZqYQi6Ri2HuPgBQ5oGQbW-63T8c,12436
 dv_flow/mgr/task_def.py,sha256=9_VJfY8hfZI7x9LFqDxALurg6oWMQQw6rdsppcjTweM,3669
-dv_flow/mgr/task_graph_builder.py,sha256=3jDlC6UinOHNZO1scO4g6bdDdLZKJEjtexxV9RXy0_4,14371
+dv_flow/mgr/task_graph_builder.py,sha256=J5C9PhVmiYuQRlEXkWVCzsX06rWUgxrWrFc5sIwUhbw,15029
 dv_flow/mgr/task_graph_dot_writer.py,sha256=GxqiYwQJbFgUQdnPCS9vpIYmYFbSXwnXCSbGmjbxC3M,2418
 dv_flow/mgr/task_listener_log.py,sha256=hrJEjSRXXoovDTcD1Cmhi3Spzw7uEJ-WP6tv6JUaa6s,4060
-dv_flow/mgr/task_node.py,sha256=xkcdFZyEIIO6Natk-v4-5eyLZGI5kV0516kfjgqzQ34,3540
-dv_flow/mgr/task_node_compound.py,sha256=y8_jzsfT9Vnm-tCWc_-hFHFoSat95zBXFibySu38YRA,1696
+dv_flow/mgr/task_node.py,sha256=twCozRjXcWWeQXJBSOmKM51qpJMEPr5sj9mMK_QiE6A,3728
+dv_flow/mgr/task_node_compound.py,sha256=mNu4nf9hVqu2698ue5fpE3FeAOkvJH0Ke2W9V0G3-As,2975
 dv_flow/mgr/task_node_ctor.py,sha256=COFGvm5PR2B92H3uW1yhDIUCmppo9U4IfOcv_Jrsreo,3952
-dv_flow/mgr/task_node_ctor_compound.py,sha256=inJeqOtlkVa7QRCzktqvVkkZ0vZALHFadIGlRZyDTD8,4006
-dv_flow/mgr/task_node_ctor_compound_proxy.py,sha256=fkH_b35xE0dABbRn9Boa80WWx_tR4L9v1mhX6faefpg,1999
-dv_flow/mgr/task_node_ctor_def_base.py,sha256=C2EeKgjeHB9xdC7nkLMBOcektwDoLhdP-4wQLY8OZ4g,1562
-dv_flow/mgr/task_node_ctor_proxy.py,sha256=e1pfLBnJHAgQvkyNcB8sKw5DJdAPRphQz1-DT9Oheho,2017
-dv_flow/mgr/task_node_ctor_task.py,sha256=9HT39F3KcEpnOBd0SbUqE6FaeSY5fFp_tN1bzGNfFKk,2237
-dv_flow/mgr/task_node_ctor_wrapper.py,sha256=fRwO2RRJbt7IB1Ziwobmg0-nU5vFYsXoNV4IXfsS7mw,3435
-dv_flow/mgr/task_node_leaf.py,sha256=YofovCK8ozKOXyAAnoRq9fKcNh2kGGWxsQXh6l9K8t0,7276
+dv_flow/mgr/task_node_ctor_compound.py,sha256=WBSdREZEATEN9dbamZo7P3oN87E7wu7r3pcUCLqDRt4,4200
+dv_flow/mgr/task_node_ctor_compound_proxy.py,sha256=D8x54nD8Pd-2-_mr1syhqVeSFfIVf100ldi3bdzmSfI,2073
+dv_flow/mgr/task_node_ctor_def_base.py,sha256=_8QQHKDkONio_ve0Z409yxC0AMO8ocNBPDjRiNED1FI,1503
+dv_flow/mgr/task_node_ctor_proxy.py,sha256=ViOFJ64JM4-CGFZNl89BghFuKSQ66kZVqSj4v2PA6VA,1906
+dv_flow/mgr/task_node_ctor_task.py,sha256=d49g90TyPCMFR8BuWWqp4ym-MW5vGSdDR0V47Ru28JY,2232
+dv_flow/mgr/task_node_ctor_wrapper.py,sha256=Nb1CVcPHZofnb-iLWDHQWAxlTOdbRrnR9DdSxY8yOec,3626
+dv_flow/mgr/task_node_leaf.py,sha256=iEz-O4943SupriqO0aI5Ai7MIvkFRMkPitN8G85-G9g,7327
 dv_flow/mgr/task_output.py,sha256=ZwyvwnYj_gHOEFAEOH3m24Xfc4Cn77hb1j7LkX8_3C4,1086
 dv_flow/mgr/task_params_ctor.py,sha256=BPkbnoCtzhCxc1g8CJ6VimCcm5UAu92PXeDMhQ4lYsQ,1957
-dv_flow/mgr/task_runner.py,sha256=Ho-u4xhiTVrOhSgjtcv-6pA0euwI3JFNNAHRdmSVBaA,9477
+dv_flow/mgr/task_runner.py,sha256=-919VntXAe2XSuFW2dFpgvUre-NkILBnDBbAKBZYn5w,9594
 dv_flow/mgr/type.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dv_flow/mgr/type_def.py,sha256=NDeyplKrPnWwEv4yHkhXEMK9d9j39b5MOeLB-1Mchqo,1095
 dv_flow/mgr/cmds/cmd_graph.py,sha256=Ykw__EdwamDBZZKxQZVbtMtFl7koq5dJMShTBXSM2pk,2672
@@ -49,9 +49,9 @@ dv_flow/mgr/util/__main__.py,sha256=F0LXpCDpYTPalSo0dc1h_qZkip5v1AZYYh-vcYbh5s0,
 dv_flow/mgr/util/util.py,sha256=yg9oTPRiO87mkCSOQpOtlG9vyKPQzY3qp4OJkEMbWyY,1443
 dv_flow/mgr/util/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dv_flow/mgr/util/cmds/cmd_schema.py,sha256=lrEI-Jwb8j4I4yYOn9hq7_7NYbK8leVxLesrHyEWm-E,1879
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/METADATA,sha256=eCspmsiQjw9KIDGVt0zXfKIQufdktI71Mn-LkQcL6Vc,13336
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
-dv_flow_mgr-0.0.1.14116344455a1.dist-info/RECORD,,
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/METADATA,sha256=61gFcfnbRS1QgZKLPgpwMtYTkObC6pF2R5l35Mqz6M8,13336
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-0.0.1.14147547123a1.dist-info/RECORD,,