dv-flow-mgr 1.10.15961872557rc0__py3-none-any.whl → 1.11.16383233052rc0__py3-none-any.whl

dv_flow/mgr/__init__.py

@@ -27,11 +27,93 @@ from .task_def import *
 from .task_graph_builder import TaskGraphBuilder
 from .task_run_ctxt import TaskRunCtxt
 from .task_runner import TaskRunner
-from .task_node_ctor_wrapper import task
 from .task_runner import TaskSetRunner
 from .task_listener_log import TaskListenerLog
 
-VERSION="1.10.0"
-SUFFIX="15961872557rc0"
+VERSION="1.11.0"
+SUFFIX="16383233052rc0"
 __version__="%s%s" % (VERSION, SUFFIX)
 
+def task(paramT,passthrough=PassthroughE.Unused,consumes=ConsumesE.All):
+    """Decorator to wrap a task method as a TaskNodeCtor"""
+
+    def wrapper(T):
+        from dv_flow.mgr.task_node_leaf import TaskNodeLeaf
+        from .param import Param
+        task_mname = T.__module__
+        task_module = sys.modules[task_mname]
+        task_passthrough = passthrough
+        task_consumes = consumes
+
+        def mkTaskParams(params : Dict) -> Any:
+            obj = 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
+
+        def ctor(
+                builder=None, 
+                name=None, 
+                srcdir=None, 
+                params=None, 
+                needs=None, 
+                passthrough=None, 
+                consumes=None, 
+                **kwargs):
+            if params is None:
+                params = mkTaskParams(kwargs)
+            if passthrough is None:
+                passthrough = task_passthrough
+            if consumes is None:
+                consumes = task_consumes
+            if srcdir is None:
+                srcdir=os.path.dirname(os.path.abspath(task_module.__file__))
+            
+            print("needs: %s" % str(needs))
+
+            task_mname = T.__module__
+            task_module = sys.modules[task_mname]
+            node = TaskNodeLeaf(
+                name=T.__name__,
+                params=params,
+                task=T,
+                srcdir=srcdir,
+                ctxt=None,
+                passthrough=passthrough,
+                consumes=consumes,
+                needs=needs)
+            return node
+        # ctor = TaskNodeCtorWrapper(
+        #     name=T.__name__,
+        #     srcdir=os.path.dirname(os.path.abspath(task_module.__file__)),
+        #     paramT=paramT,
+        #     passthrough=passthrough,
+        #     consumes=consumes,
+        #     needs=[],
+        #     T=T)
+        return ctor
+    return wrapper
+

dv_flow/mgr/exec_callable.py

@@ -10,6 +10,7 @@ from .task_data import TaskDataResult
 @dc.dataclass
 class ExecCallable(object):
     body : str
+    srcdir : str
     shell: str = "pytask"
     _log : ClassVar = logging.getLogger("ExecCallable")
 
@@ -30,6 +31,9 @@ class ExecCallable(object):
                 # have a file to load
                 file = self.body[:ci]
                 method = self.body[ci+2:]
+                if not os.path.isabs(file):
+                    file = os.path.join(input.srcdir, file)
+
                 spec = importlib.util.spec_from_file_location(input.name, file)
                 module = importlib.util.module_from_spec(spec)
                 sys.modules[input.name] = module

dv_flow/mgr/exec_gen_callable.py

@@ -10,6 +10,7 @@ from .task_data import TaskDataResult
 @dc.dataclass
 class ExecGenCallable(object):
     body : str
+    srcdir : str
     _log : ClassVar = logging.getLogger("ExecGenCallable")
 
     def __call__(self, ctxt, input):

dv_flow/mgr/package_loader.py

@@ -27,7 +27,9 @@ class EmptyParams(pydantic.BaseModel):
 class SymbolScope(object):
     name : str
     task_m : Dict[str,Task] = dc.field(default_factory=dict)
+    task_elab_m : Dict[str,bool] = dc.field(default_factory=dict)
     type_m : Dict[str,Type] = dc.field(default_factory=dict)
+    type_elab_m : Dict[str,bool] = dc.field(default_factory=dict)
     override_m : Dict[str,Any] = dc.field(default_factory=dict)
 
     def add(self, task, name):
@@ -599,6 +601,8 @@ class PackageLoader(object):
 
     def _loadTasks(self, pkg, taskdefs : List[TaskDef], basedir : str):
         self._log.debug("--> _loadTasks %s" % pkg.name)
+
+
         # Declare first
         tasks = []
         for taskdef in taskdefs:
@@ -618,7 +622,8 @@ class PackageLoader(object):
                 desc=desc,
                 doc=doc,
                 package=pkg,
-                srcinfo=taskdef.srcinfo)
+                srcinfo=taskdef.srcinfo,
+                taskdef=taskdef)
 
             if taskdef.iff is not None:
                 task.iff = taskdef.iff
@@ -629,81 +634,92 @@ class PackageLoader(object):
 
         # Now, build out tasks
         for taskdef, task in tasks:
+            task.taskdef = taskdef
+            self._elabTask(task)
 
-            if taskdef.uses is not None:
-                task.uses = self._findTaskOrType(taskdef.uses)
+        self._log.debug("<-- _loadTasks %s" % pkg.name)
 
-                if task.uses is None:
-                    self.error("failed to resolve task-uses %s" % taskdef.uses, taskdef.srcinfo)
-                    continue
-            
-            passthrough, consumes, rundir = self._getPTConsumesRundir(taskdef, task.uses)
+    def _elabTask(self, task):
+        self._log.debug("--> _elabTask %s" % task.name)
+        taskdef = task.taskdef
 
-            task.passthrough = passthrough
-            task.consumes = consumes
-            task.rundir = rundir
+        task.taskdef = None
+        if taskdef.uses is not None:
+            task.uses = self._findTaskOrType(taskdef.uses)
 
-            task.paramT = self._getParamT(
-                taskdef, 
-                task.uses.paramT if task.uses is not None else None)
+            if task.uses is None:
+                self.error("failed to resolve task-uses %s" % taskdef.uses, taskdef.srcinfo)
+                return
 
-            for need in taskdef.needs:
-                nt = None
+        self._eval.set("srcdir", os.path.dirname(taskdef.srcinfo.file))
+        
+        passthrough, consumes, rundir = self._getPTConsumesRundir(taskdef, task.uses)
 
-                need_name = None
-                if isinstance(need, str):
-                    need_name = need
-                    nt = self._findTask(need)
-                elif isinstance(need, TaskDef):
-                    need_name = need.name
-                else:
-                    raise Exception("Unknown need type %s" % str(type(need)))
-                
-                if need_name.endswith(".needs"):
-                    # Find the original task first
-                    nt = self._findTask(need_name[:-len(".needs")])
-                    if nt is None:
-                        self.error("failed to find task %s" % need, taskdef.srcinfo)
-                        raise Exception("Failed to find task %s" % need)
-                    for nn in nt.needs:
-                        task.needs.append(nn)
-                else:
-                    nt = self._findTask(need_name)
-                
-                    if nt is None:
-                        self.error("failed to find task %s" % need, taskdef.srcinfo)
-                        raise Exception("Failed to find task %s" % need)
-                    task.needs.append(nt)
-
-            if taskdef.strategy is not None:
-                self._log.debug("Task %s strategy: %s" % (task.name, str(taskdef.strategy)))
-                if taskdef.strategy.generate is not None:
-                    shell = taskdef.strategy.generate.shell
-                    if shell is None:
-                        shell = "pytask"
-                    task.strategy = Strategy(
-                        generate=StrategyGenerate(
-                            shell=shell,
-                            run=taskdef.strategy.generate.run))
+        task.passthrough = passthrough
+        task.consumes = consumes
+        task.rundir = rundir
+
+        task.paramT = self._getParamT(
+            taskdef, 
+            task.uses.paramT if task.uses is not None else None)
+
+        for need in taskdef.needs:
+            nt = None
+
+            need_name = None
+            if isinstance(need, str):
+                need_name = need
+                nt = self._findTask(need)
+            elif isinstance(need, TaskDef):
+                need_name = need.name
+            else:
+                raise Exception("Unknown need type %s" % str(type(need)))
+            
+            if need_name.endswith(".needs"):
+                # Find the original task first
+                nt = self._findTask(need_name[:-len(".needs")])
+                if nt is None:
+                    self.error("failed to find task %s" % need, taskdef.srcinfo)
+                    raise Exception("Failed to find task %s" % need)
+                for nn in nt.needs:
+                    task.needs.append(nn)
+            else:
+                nt = self._findTask(need_name)
+            
+                if nt is None:
+                    self.error("failed to find task %s" % need, taskdef.srcinfo)
+                    raise Exception("Failed to find task %s" % need)
+                task.needs.append(nt)
+
+        if taskdef.strategy is not None:
+            self._log.debug("Task %s strategy: %s" % (task.name, str(taskdef.strategy)))
+            if taskdef.strategy.generate is not None:
+                shell = taskdef.strategy.generate.shell
+                if shell is None:
+                    shell = "pytask"
+                task.strategy = Strategy(
+                    generate=StrategyGenerate(
+                        shell=shell,
+                        run=taskdef.strategy.generate.run))
 
 #                task.strategy = taskdef.strategy
 
 
-            # Determine how to implement this task
-            if taskdef.body is not None and len(taskdef.body) > 0:
-                self._mkTaskBody(task, taskdef)
-            elif taskdef.run is not None:
-                task.run = taskdef.run
-                if taskdef.shell is not None:
-                    task.shell = taskdef.shell
-            elif taskdef.pytask is not None: # Deprecated case
-                task.run = taskdef.pytask
-                task.shell = "pytask"
-            elif task.uses is not None and isinstance(task.uses, Task) and task.uses.run is not None:
-                task.run = task.uses.run
-                task.shell = task.uses.shell
+        # Determine how to implement this task
+        if taskdef.body is not None and len(taskdef.body) > 0:
+            self._mkTaskBody(task, taskdef)
+        elif taskdef.run is not None:
+            task.run = self._eval.eval(taskdef.run)
+            if taskdef.shell is not None:
+                task.shell = taskdef.shell
+        elif taskdef.pytask is not None: # Deprecated case
+            task.run = taskdef.pytask
+            task.shell = "pytask"
+        elif task.uses is not None and isinstance(task.uses, Task) and task.uses.run is not None:
+            task.run = task.uses.run
+            task.shell = task.uses.shell
 
-        self._log.debug("<-- _loadTasks %s" % pkg.name)
+        self._log.debug("<-- _elabTask %s" % task.name)
 
     def _loadTypes(self, pkg, typedefs):
         self._log.debug("--> _loadTypes")
@@ -712,25 +728,36 @@ class PackageLoader(object):
             tt = Type(
                 name=self._getScopeFullname(td.name),
                 doc=td.doc,
-                srcinfo=td.srcinfo)
+                srcinfo=td.srcinfo,
+                typedef=td)
             pkg.type_m[tt.name] = tt
             self._pkg_s[-1].addType(tt, td.name)
             types.append((td, tt))
         
         # Now, resolve 'uses' and build out
         for td,tt in types:
-            if td.uses is not None:
-                tt.uses = self._findType(td.uses)
-                if tt.uses is None:
-                    raise Exception("Failed to find type %s" % td.uses)
-            tt.paramT = self._getParamT(
-                td, 
-                tt.uses.paramT if tt.uses is not None else None,
-                typename=tt.name,
-                is_type=True)
+            self._elabType(tt)
+
         self._log.debug("<-- _loadTypes")
         pass
 
+    def _elabType(self, tt):
+        self._log.debug("--> _elabType %s" % tt.name)
+        td = tt.typedef
+
+        tt.typedef = None
+        if td.uses is not None:
+            tt.uses = self._findType(td.uses)
+            if tt.uses is None:
+                raise Exception("Failed to find type %s" % td.uses)
+        tt.paramT = self._getParamT(
+            td, 
+            tt.uses.paramT if tt.uses is not None else None,
+            typename=tt.name,
+            is_type=True)
+        self._log.debug("<-- _elabType %s" % tt.name)
+
+
     def _mkTaskBody(self, task, taskdef):
         self._pkg_s[-1].push_scope(TaskScope(name=taskdef.name))
         pkg = self.package_scope()
@@ -836,6 +863,11 @@ class PackageLoader(object):
 
         if uses is None:
             uses = self._findType(name)
+            if uses is not None and uses.typedef:
+                self._elabType(uses)
+                pass
+        elif uses.taskdef:
+            self._elabTask(uses)
 
         self._log.debug("<-- _findTaskOrType %s (%s)" % (name, ("found" if uses is not None else "not found")))
         return uses

dv_flow/mgr/param_ref_eval.py

@@ -60,9 +60,6 @@ class ParamRefEval(object):
                 # Replacing [idx..eidx+2] with len(exp_val)
                 val = val[:idx] + exp_val + val[eidx+2:]
                 idx += len(exp_val)
-
-
-
             else:
                 break
 

dv_flow/mgr/shell_callable.py

@@ -8,6 +8,7 @@ from .task_data import TaskDataResult
 @dc.dataclass
 class ShellCallable(object):
     body : str
+    srcdir : str
     shell : str
     _log : ClassVar = logging.getLogger("ShellCallable")
 

dv_flow/mgr/std/flow.dv

@@ -85,6 +85,16 @@ package:
       incdir: 
         type: bool
         value: false
+  - name: SetFileType
+    consumes:
+    - type: std.FileSet 
+    desc: Outputs all input filesets with the specified filetype
+    shell: pytask
+    run: dv_flow.mgr.std.set_file_type.SetFileType
+    with:
+      filetype:
+        type: str
+        value: ""
   - name: IncDirs
     shell: pytask
     run: dv_flow.mgr.std.incdirs.IncDirs

dv_flow/mgr/std/set_file_type.py

@@ -0,0 +1,18 @@
+from dv_flow.mgr import TaskDataResult, TaskDataInput, TaskRunCtxt
+
+async def SetFileType(ctxt: TaskRunCtxt, inputs: TaskDataInput) -> TaskDataResult:
+    output = []
+
+    for inp in inputs.inputs:
+        if inp.type == "std.FileSet":
+            inp = inp.copy()
+            inp.filetype = inputs.params.filetype
+            inp.src = None
+            inp.seq = -1
+            output.append(inp)
+
+    return TaskDataResult(
+        changed=inputs.changed,
+        output=output,
+        status=0
+    )

dv_flow/mgr/task.py

@@ -2,7 +2,6 @@ import dataclasses as dc
 from typing import Any, Callable, Dict, List, Tuple, Union
 from .srcinfo import SrcInfo
 from .task_def import TaskDef, RundirE, PassthroughE, ConsumesE
-from .task_node_ctor import TaskNodeCtor
 
 @dc.dataclass
 class Need(object):
@@ -45,6 +44,7 @@ class Task(object):
     run : str = None
     shell : str = "bash"
     srcinfo : SrcInfo = None
+    taskdef : 'TaskDef' = None
 
     @property
     def leafname(self):

dv_flow/mgr/task_graph_builder.py

@@ -36,7 +36,6 @@ from .task_def import RundirE
 from .task_data import TaskMarker, TaskMarkerLoc, SeverityE
 from .task_gen_ctxt import TaskGenCtxt, TaskGenInputData
 from .task_node import TaskNode
-from .task_node_ctor import TaskNodeCtor
 from .task_node_compound import TaskNodeCompound
 from .task_node_ctxt import TaskNodeCtxt
 from .task_node_leaf import TaskNodeLeaf
@@ -76,7 +75,6 @@ class TaskGraphBuilder(object):
     _type_m : Dict[str,Type] = dc.field(default_factory=dict)
     _task_node_m : Dict['TaskSpec',TaskNode] = dc.field(default_factory=dict)
     _type_node_m : Dict[str,Any] = dc.field(default_factory=dict)
-    _task_ctor_m : Dict[Task,TaskNodeCtor] = dc.field(default_factory=dict)
     _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)
@@ -574,7 +572,7 @@ class TaskGraphBuilder(object):
 
         res = None
         if task.strategy.generate is not None:
-            callable = ExecGenCallable(body=task.strategy.generate.run)
+            callable = ExecGenCallable(body=task.strategy.generate.run, srcdir=srcdir)
             input = TaskGenInputData(params=params)
 
             res = callable(ctxt, input)
@@ -702,7 +700,10 @@ class TaskGraphBuilder(object):
             shell = task.shell if task.shell is not None else "shell"
             if shell in self._shell_m.keys():
                 self._log.debug("Use shell implementation")
-                callable = self._shell_m[shell](task.run, task.shell)
+                callable = self._shell_m[shell](
+                    task.run, 
+                    os.path.dirname(task.srcinfo.file), 
+                    task.shell)
             else:
                 raise Exception("Shell %s not found" % shell)
             

dv_flow/mgr/task_node_leaf.py

@@ -193,6 +193,10 @@ class TaskNodeLeaf(TaskNode):
                                     getattr(out, "type", "<unknown>"),
                                     getattr(out, "src", "<unknown>")))
                                 output.append(out)
+                            else:
+                                self._log.debug("Skipping consumed type %s from %s" % (
+                                    getattr(out, "type", "<unknown>"),
+                                    getattr(out, "src", "<unknown>")))
         else:
             self._log.debug("non-passthrough: %s (only local outputs propagated) %s" % (
                 self.name,
@@ -204,9 +208,11 @@ class TaskNodeLeaf(TaskNode):
 
         # Add our own output
         local_out = self.result.output.copy()
+        self._log.debug("local_out of %s: %d" % (self.name, len(local_out)))
         for i,out in enumerate(local_out):
             out.src = self.name
             out.seq = i
+            self._log.debug("Adding output of type %s" % out.type)
             output.append(out)
 
         self._log.debug("output dep_m: %s %s" % (self.name, str(dep_m)))

dv_flow/mgr/task_runner.py

@@ -123,7 +123,9 @@ class TaskSetRunner(TaskRunner):
             for t in active_s:
                 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])
+                    done, pending = await asyncio.wait(
+                        [at[1] for at in active_task_l],
+                        return_when=asyncio.FIRST_COMPLETED)
                     self._completeTasks(active_task_l, done_task_s, done, dst_memento)
 
                 if self.status == 0 and t not in done_task_s:
@@ -174,7 +176,9 @@ class TaskSetRunner(TaskRunner):
             # Wait for them to all complete
             while len(active_task_l):
                 # TODO: Shouldn't gather here -- reach to each completion
-                done, pending = await asyncio.wait([at[1] for at in active_task_l])
+                done, pending = await asyncio.wait(
+                    [at[1] for at in active_task_l],
+                    return_when=asyncio.FIRST_COMPLETED)
                 self._completeTasks(active_task_l, done_task_s, done, dst_memento)
             
             if self.status != 0:

dv_flow/mgr/type.py

@@ -19,6 +19,7 @@ class Type(object):
     paramT : Any = None
     uses : 'Type' = None
     srcinfo : SrcInfo = None
+    typedef : 'TypeDef' = None
 
     def dump(self):
         ret = {}

{dv_flow_mgr-1.10.15961872557rc0.dist-info → dv_flow_mgr-1.11.16383233052rc0.dist-info}/METADATA

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

@@ -1,12 +1,12 @@
-dv_flow/mgr/__init__.py,sha256=TDnf3NvqRsuA-vVf7BwacMdQDSQE6C9eJpUpXWY6rOM,1316
+dv_flow/mgr/__init__.py,sha256=B69GdAfXkRhts17J4aSKHnylAd1C3A1v-MQkFttNUAk,4385
 dv_flow/mgr/__main__.py,sha256=yrNrvz-jYEovBGpY1E9aS1iZ9S_9MQv0lT-XUQSp0vc,4141
 dv_flow/mgr/cond_def.py,sha256=2ZkzPusqVkN1fFMTvkDl9O_OJLPdD_cK3xzX9J75RMw,343
 dv_flow/mgr/config.py,sha256=b2MVlVVNB0psk8x4bQRAYshkpNJrtyMtV1Ymhmx9AfM,137
 dv_flow/mgr/config_def.py,sha256=N5nBc_2VPrx0pCDyIe-VPhQ7ItnbyJqrak3ZiPEAbtI,1040
 dv_flow/mgr/data_callable.py,sha256=-GeMgBUdUEcdAkWsqvUYcpKqUd5BQsFgi6ARflnp2B8,687
 dv_flow/mgr/eval_jq.py,sha256=bRsHtaN51qIOiZK1VJV52W0-vj5VH0nQ7XIFebZi5kI,1129
-dv_flow/mgr/exec_callable.py,sha256=tB2kBJeBPvq8pYOnZCaCvTYeu_MiezFfHUEqTAW3GQA,3143
-dv_flow/mgr/exec_gen_callable.py,sha256=KLAKgu0c6nrEzfy85qeogH64VOFDBa6anslSBajykOE,3039
+dv_flow/mgr/exec_callable.py,sha256=rpo1N68ZZcvNcuHsH23dZCIMvZ1lylXeUO_RFfKduvc,3265
+dv_flow/mgr/exec_gen_callable.py,sha256=tn14TGFlSnjpTi5q-E2pTa804zd1tEMsG-O-Yfz_g1w,3056
 dv_flow/mgr/expr_eval.py,sha256=ojHo3U_QGqm0CWVSEGtFJRo3jrjiTKhy_B58yRNxN8g,4814
 dv_flow/mgr/expr_parser.py,sha256=LMLe4RTbgcQVIpuZIi1vowHsKRgRmzKzomGvlJL8kJI,7110
 dv_flow/mgr/ext_rgy.py,sha256=rf8lDXGbISBu4S7WuwX36b-sOiZ22d5dtjPAu2anogo,6307
@@ -21,22 +21,22 @@ dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
 dv_flow/mgr/package.py,sha256=oKzYQypF-to4OXr8BKwPz7Z8cf7AC6eF6CiYj1jCyTI,4585
 dv_flow/mgr/package_def.py,sha256=h3_FIKQB0vqfcu1jRAZuB8W8Kozr62oaKNchxeNjpWk,5898
 dv_flow/mgr/package_import_spec.py,sha256=aZMpnS9a5NFY76_pYXEuO3-Mkc_xFzy73fdrUe_54Dc,1760
-dv_flow/mgr/package_loader.py,sha256=bLoVVdAp0cUIJWrSwXkgu8YothjtjIFsbZcINduTl_4,36315
+dv_flow/mgr/package_loader.py,sha256=0vUMiA0LBRsEanVVYE1wq5W44z3sLLi7ModdoKDKmfE,36976
 dv_flow/mgr/package_node.py,sha256=CccD2ECiIXy9JBkRR3c7qDxeBiLiPbRT9CqR-Al_niI,214
 dv_flow/mgr/param.py,sha256=kkxMRGf6mPjSZJsjgLKH2vJL62Sn0ZESvjBLkEYOp20,1386
 dv_flow/mgr/param_def.py,sha256=GnaolV5QOrjBpqNj9yYo9nnrwEBpp4J_4ZYe14bsfO4,1939
-dv_flow/mgr/param_ref_eval.py,sha256=x15lGEJNkWthXXfX3rRTh6tP7Y7A7cmNdo-iOHeOPKw,2179
+dv_flow/mgr/param_ref_eval.py,sha256=n39PIQ_Ht-7lO8oYLHLfMek90mE6nqJpXck5HmWSGsQ,2176
 dv_flow/mgr/parser.out,sha256=mWx6hgqORUFhM2OlxV2gp43Y7w3sX2u4ua4t-5wqmck,27566
 dv_flow/mgr/parsetab.py,sha256=S2o2FfobhhVWKwZg_GA7zFg62VwT7tiRxxNZJIyqP98,4351
 dv_flow/mgr/pytask_callable.py,sha256=JiFN2vq6qanI6FXJBeidwiBSn6t0oC0izPJ01c5QJTE,688
 dv_flow/mgr/root_package.py,sha256=nYLOpZVQEDbY0Ui5X5UNeUHXOvqRENew7B2zpC2V2gQ,136
-dv_flow/mgr/shell_callable.py,sha256=2b51yewHTFsoDMAldaB44ZMXkG2LaLR3go0DdM72HEs,1051
+dv_flow/mgr/shell_callable.py,sha256=-3UchnpYVohqOwxs-d3Vn2xBXQQnOO64oLIxrELd-3M,1068
 dv_flow/mgr/srcinfo.py,sha256=xrfp-relVr7hYNbxOjY5jqX4H0nNMm9HK5AAM6_Piyk,366
-dv_flow/mgr/task.py,sha256=XQ-mVyDGvpU4gB6GmnNeTQhxKqFXiblShh7qd_-SIbM,2387
+dv_flow/mgr/task.py,sha256=oEaMrviXccz8IFSAHUtq2TqgHzelBga4jfq5vFnSGbM,2377
 dv_flow/mgr/task_data.py,sha256=lN7Iq8YTitEMGG4rZqYQi6Ri2HuPgBQ5oGQbW-63T8c,12436
 dv_flow/mgr/task_def.py,sha256=lhiOL7E_TfW7Ytg5qipE6d2cqTkfVqAOs1MZgtCqeLg,5257
 dv_flow/mgr/task_gen_ctxt.py,sha256=1QQqqgaCjJSlzTV0SASpTb69vINFrDq3aqjYCKUkx3s,846
-dv_flow/mgr/task_graph_builder.py,sha256=16f33f9-mWN85aGH_t9cjPLL7AoMsSiGSRUxB3leDeg,33721
+dv_flow/mgr/task_graph_builder.py,sha256=yFdL9zGek5F8NEVFgYqL-XLZFaznusmNwIJL9FUCMkk,33718
 dv_flow/mgr/task_graph_dot_writer.py,sha256=qK4Imy9o2_F1aKoU1tJ-qoBHslq2BhSMbdjAUPfpN7I,6009
 dv_flow/mgr/task_listener_log.py,sha256=XcmBT-946DyrEYwNwbg7ejnB6Q3koybE7AekSWGxNGQ,4774
 dv_flow/mgr/task_listener_trace.py,sha256=7B-V2YK8uXd_QSGBq_7USmbe5CleVvwumU0CpsmxZvg,6224
@@ -50,12 +50,12 @@ dv_flow/mgr/task_node_ctor_proxy.py,sha256=ViOFJ64JM4-CGFZNl89BghFuKSQ66kZVqSj4v
 dv_flow/mgr/task_node_ctor_task.py,sha256=d49g90TyPCMFR8BuWWqp4ym-MW5vGSdDR0V47Ru28JY,2232
 dv_flow/mgr/task_node_ctor_wrapper.py,sha256=KMSYd4ik2Si7UXhNMeXAPHBwwrFkuhpeTMeYRpWv0hw,3718
 dv_flow/mgr/task_node_ctxt.py,sha256=KHt_kQch6LDq70Oor7z2xbepiiaK2jyp4S-KWZGsRjo,205
-dv_flow/mgr/task_node_leaf.py,sha256=nULlu-veyPC-PXdoQhahkLgqpdKNzaoD0XUlCw0EuZ4,9109
+dv_flow/mgr/task_node_leaf.py,sha256=98nVAFGuv5ZJPoc1CNUEeOc-aV69xV8Wd1hEP9QLw3Y,9517
 dv_flow/mgr/task_output.py,sha256=ZwyvwnYj_gHOEFAEOH3m24Xfc4Cn77hb1j7LkX8_3C4,1086
 dv_flow/mgr/task_params_ctor.py,sha256=qlrzibGAFHmbqOu88jEoh1wOSFHu68Gwdgc259-50e8,1915
 dv_flow/mgr/task_run_ctxt.py,sha256=1c5dV0xd1XQOTkcqv1qBrXs-gs--nZ1AvLzFb6L5dNY,3967
-dv_flow/mgr/task_runner.py,sha256=l1bkVoGerPl1mw4O-JMLGHgDZdWIHukfj5fElbiNizI,10639
-dv_flow/mgr/type.py,sha256=hoJTatlPC0yOazKSWduK-5CfY38RPkc6qXFzOCcVSdM,723
+dv_flow/mgr/task_runner.py,sha256=D5XKikcR65Rk4TqMdg4URkUOzRzMOLJwRNoyBjIFdCQ,10803
+dv_flow/mgr/type.py,sha256=TYDgvaNNi3KrM8k9Y_QmmTboYuOFiuIZTzkWqrt_VTY,754
 dv_flow/mgr/type_def.py,sha256=4sge3PibO1jDnS0cXdX0PiurcKbDA3kT6rb4DGIKwEM,1176
 dv_flow/mgr/yaml_srcinfo_loader.py,sha256=29BNRiB8Hj1FepkrLtdjHSv5U_85Q432gBeeK80nKEA,1606
 dv_flow/mgr/cmds/cmd_graph.py,sha256=VQLm-zoa5xbWNfJNoCnDihKniWW8W_tmCyWZISDzwDo,3006
@@ -68,18 +68,19 @@ dv_flow/mgr/std/create_file.py,sha256=SEpKTQdiY32002C7b4kYfAiK9v_xajixOJU5WftW75
 dv_flow/mgr/std/data_item.py,sha256=olKtspEVFOvr92reUl4QaQV27UVyjSGIfIWpsy0Myvo,434
 dv_flow/mgr/std/exec.py,sha256=UChqa_tAjvdB1NjqTsvlPgFomP8hMsX2rAOPyUonNpk,3896
 dv_flow/mgr/std/fileset.py,sha256=_9IUjZ2_doygc29Qg1hJPaFPzlaIaTdvHnYTai8mE3A,4183
-dv_flow/mgr/std/flow.dv,sha256=qT3qlDjo6DMMcPXHLbW6Z0OJOouXupQK3cm_15JxSKI,3786
+dv_flow/mgr/std/flow.dv,sha256=iTVpI98PBbn3oUYyQJ6yb-S7zVReM0ZL2WmodH-hZzs,4043
 dv_flow/mgr/std/incdirs.py,sha256=F0wraOxkRJRkrhsyk9v2YvpquFtcK4ZsMO1G9sgmhmA,588
 dv_flow/mgr/std/message.py,sha256=0JHLErg8whqMLAasG1fumZ2O7R7WNWeNQ9ibJaLDpVY,1029
+dv_flow/mgr/std/set_file_type.py,sha256=t7NtTmWW3xVckoiHn3hhL2LGAPihP07n_94_4kc8_vw,504
 dv_flow/mgr/std/task_null.py,sha256=dw6LXBXVwth6gLPeduDvlz5znAhcVpDH8r1DticD-0w,1041
 dv_flow/mgr/util/__init__.py,sha256=6uuA6z5cKS2hcjJw6YyEM2M79g6OpXb6tZF_Gku-AGU,22
 dv_flow/mgr/util/__main__.py,sha256=F0LXpCDpYTPalSo0dc1h_qZkip5v1AZYYh-vcYbh5s0,983
 dv_flow/mgr/util/util.py,sha256=5wVWpkHn4U-Hcv-skaLaGC0bgoK63NaF-NH-DGpAaRM,2035
 dv_flow/mgr/util/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dv_flow/mgr/util/cmds/cmd_schema.py,sha256=IJzZdxCSEgIQ79LpYiM7UqJ9RJ-7yraqmBN2XVgAgXA,1752
-dv_flow_mgr-1.10.15961872557rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-1.10.15961872557rc0.dist-info/METADATA,sha256=wTZ2hpfetXyxoSR7sySusLGW8Dy_cNhXm34nmPnfSe4,13336
-dv_flow_mgr-1.10.15961872557rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_flow_mgr-1.10.15961872557rc0.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
-dv_flow_mgr-1.10.15961872557rc0.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
-dv_flow_mgr-1.10.15961872557rc0.dist-info/RECORD,,
+dv_flow_mgr-1.11.16383233052rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-1.11.16383233052rc0.dist-info/METADATA,sha256=4rMZ91qdQoV84kNZh5RkW95O9ALRwiWZC3ed-Z4StKs,13336
+dv_flow_mgr-1.11.16383233052rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dv_flow_mgr-1.11.16383233052rc0.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-1.11.16383233052rc0.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-1.11.16383233052rc0.dist-info/RECORD,,