dv-flow-mgr 1.6.14849587166rc0__py3-none-any.whl → 1.6.14872991111rc0__py3-none-any.whl

dv_flow/mgr/__init__.py

@@ -32,6 +32,6 @@ from .task_runner import TaskSetRunner
 from .task_listener_log import TaskListenerLog
 
 VERSION="1.6.0"
-SUFFIX="14849587166rc0"
+SUFFIX="14872991111rc0"
 __version__="%s%s" % (VERSION, SUFFIX)
 

dv_flow/mgr/config.py

@@ -1,7 +1,8 @@
 
 import dataclasses as dc
-from typing import List
+from typing import Any, List
 
 @dc.dataclass
 class Config(object):
     overrides : List
+    paramT : Any = None

dv_flow/mgr/config_def.py

@@ -7,10 +7,8 @@ from .param_def import ParamDef
 
 class OverrideDef(BaseModel):
     """Override definition"""
-    package : Union[str, None] = pdc.Field(
-        description="Package to override")
-    task : Union[str, None] = pdc.Field(
-        description="Task to override")
+    override : Union[str, None] = pdc.Field(
+        description="Task or package to override")
     value : str = pdc.Field(
         description="Override to use",
         alias="with")

dv_flow/mgr/data_callable.py

@@ -0,0 +1,26 @@
+import dataclasses as dc
+from typing import Any
+from .task_data import TaskDataResult, TaskDataInput
+from .task_run_ctxt import TaskRunCtxt
+
+@dc.dataclass
+class DataCallable(object):
+    paramT : Any
+
+    async def __call__(self, ctxt : TaskRunCtxt, input : TaskDataInput) -> TaskDataResult:
+        output = []
+        status = 0
+
+        data = self.paramT()
+
+        # Now, copy in the parameter values
+        for key in self.paramT.model_fields.keys():
+            if hasattr(input.params, key):
+                setattr(data, key, getattr(input.params, key))
+
+        output.append(data)
+
+        return TaskDataResult(
+            status=status,
+            output=output
+        )

dv_flow/mgr/expr_eval.py

@@ -21,26 +21,40 @@
 #****************************************************************************
 import dataclasses as dc
 import json
-from typing import Any, Callable, Dict, List
-from .expr_parser import ExprVisitor, Expr, ExprBin, ExprBinOp
+from typing import Any, Callable, Dict, List, Optional
+from .expr_parser import ExprParser, ExprVisitor, Expr, ExprBin, ExprBinOp
 from .expr_parser import ExprCall, ExprHId, ExprId, ExprString, ExprInt
+from .name_resolution import NameResolutionContext
 
 @dc.dataclass
 class ExprEval(ExprVisitor):
-    methods : Dict[str, Callable] = dc.field(default_factory=dict)
-    variables : Dict[str, object] = dc.field(default_factory=dict)
-    value : Any = None
+    methods: Dict[str, Callable] = dc.field(default_factory=dict)
+    name_resolution: Optional[NameResolutionContext] = None
+    variables: Dict[str, object] = dc.field(default_factory=dict)
+    value: Any = None
 
-    def set(self, name : str, value : object):
+    def set(self, name: str, value: object):
         self.variables[name] = value
 
-    def eval(self, e : Expr) -> str:
-        self.value = None
-        e.accept(self)
+    def set_name_resolution(self, ctx: NameResolutionContext):
+        self.name_resolution = ctx
 
-        val = self._toString(self.value)
+    def eval(self, expr_s: str) -> str:
+        if expr_s is None:
+            return None
+        elif isinstance(expr_s, Expr):
+            expr_s.accept(self)
+            return self._toString(self.value)
+        elif isinstance(expr_s, bool):
+            return expr_s
+        else:
+            parser = ExprParser()
+            ast = parser.parse(expr_s)
 
-        return val
+            self.value = None
+            ast.accept(self)
+            val = self._toString(self.value)
+            return val
     
     def _toString(self, val):
         rval = val
@@ -48,11 +62,6 @@ class ExprEval(ExprVisitor):
             obj = self._toObject(val)
             rval = json.dumps(obj)
         return rval
-#        if isinstance(val, list):
-#            val = '[' + ",".join(self._toString(v) for v in val) + ']'
-#        elif hasattr(val, "model_dump_json"):
-#            val = val.model_dump_json()
-#        return val
     
     def _toObject(self, val):
         rval = val
@@ -63,33 +72,47 @@ class ExprEval(ExprVisitor):
 
         return rval
 
-    def visitExprHId(self, e : ExprHId):
-        print("Hid: %s" % ".".join(e.id))
-        if e.id[0] in self.variables:
-            # Always represent data as a JSON object
-            root = self.variables[e.id[0]]
-            for i in range(1, len(e.id)):
-                if isinstance(root, dict):
-                    if e.id[i] in root.keys():
-                        root = root[e.id[i]]
-                    else:
-                        raise Exception("Sub-element '%s' not found in '%s'" % (e.id[i], ".".join(e.id)))
-                elif hasattr(root, e.id[i]):
-                    root = getattr(root, e.id[i])
+    def visitExprHId(self, e: ExprHId):
+        # First try to resolve using name resolution context
+        value = None
+
+        if self.name_resolution:
+            value = self.name_resolution.resolve_variable(e.id[0])
+
+        # Fall back to variables dict
+        if value is None and e.id[0] in self.variables:
+            value = self.variables[e.id[0]]
+
+        if value is None:
+            raise Exception("Variable '%s' not found" % e.id[0])
+
+        for i in range(1, len(e.id)):
+            if isinstance(value, dict):
+                if e.id[i] in value.keys():
+                    value = value[e.id[i]]
                 else:
                     raise Exception("Sub-element '%s' not found in '%s'" % (e.id[i], ".".join(e.id)))
-            self.value = root
-        else:
-            raise Exception("Variable '%s' not found" % e.id[0])
+            elif hasattr(value, e.id[i]):
+                value = getattr(value, e.id[i])
+            else:
+                raise Exception("Sub-element '%s' not found in '%s' (%s)" % (e.id[i], ".".join(e.id), value))
+        self.value = value
+
+    def visitExprId(self, e: ExprId):
+        # First try to resolve using name resolution context
+        if self.name_resolution:
+            resolved = self.name_resolution.resolve_variable(e.id)
+            if resolved is not None:
+                self.value = resolved
+                return
 
-    def visitExprId(self, e : ExprId):
+        # Fall back to variables dict
         if e.id in self.variables:
-            # Always represent data as a JSON object
             self.value = self._toObject(self.variables[e.id])
         else:
             raise Exception("Variable '%s' not found" % e.id)
 
-    def visitExprString(self, e : ExprString):
+    def visitExprString(self, e: ExprString):
         self.value = e.value
     
     def visitExprBin(self, e):
@@ -101,7 +124,7 @@ class ExprEval(ExprVisitor):
         elif e.op == ExprBinOp.Plus:
             pass
     
-    def visitExprCall(self, e : ExprCall):
+    def visitExprCall(self, e: ExprCall):
         if e.id in self.methods:
             # Need to gather up argument values
             in_value = self.value
@@ -115,5 +138,5 @@ class ExprEval(ExprVisitor):
         else:
             raise Exception("Method %s not found" % e.id)
         
-    def visitExprInt(self, e : ExprInt):
+    def visitExprInt(self, e: ExprInt):
         self.value = e.value

dv_flow/mgr/name_resolution.py

@@ -0,0 +1,73 @@
+#****************************************************************************
+#* name_resolution.py
+#*
+#* Copyright 2023-2025 Matthew Ballance and Contributors
+#*
+#* Licensed under the Apache License, Version 2.0 (the "License"); you may 
+#* not use this file except in compliance with the License.  
+#* You may obtain a copy of the License at:
+#*
+#*   http://www.apache.org/licenses/LICENSE-2.0
+#*
+#* Unless required by applicable law or agreed to in writing, software 
+#* distributed under the License is distributed on an "AS IS" BASIS, 
+#* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+#* See the License for the specific language governing permissions and 
+#* limitations under the License.
+#*
+#****************************************************************************
+
+import dataclasses as dc
+from typing import Any, Dict, List
+from .package import Package
+from .task_node import TaskNode
+
+@dc.dataclass
+class TaskNameResolutionScope:
+    """Represents a single task scope in the name resolution stack"""
+    task: TaskNode
+    variables: Dict[str, Any] = dc.field(default_factory=dict)
+
+@dc.dataclass
+class NameResolutionContext:
+    """Represents a complete name resolution context"""
+    builder: 'TaskGraphBuilder'  # Forward reference to avoid circular import
+    package: Package
+    task_scopes: List[TaskNameResolutionScope] = dc.field(default_factory=list)
+
+    def resolve_variable(self, name: str) -> Any:
+        """
+        Resolve a variable name following scoping rules:
+        1. Current task scope
+        2. Enclosing compound-task scopes
+        3. Current package variables
+        4. Package-qualified variables
+        """
+        # Check if this is a package-qualified reference
+        ret = None
+
+        if name in self.builder._pkg_params_m.keys():
+            # Check if this is a package-qualified reference
+            ret = self.builder._pkg_params_m[name]
+
+        # Check task scopes from innermost to outermost
+        if ret is None:
+            for scope in reversed(self.task_scopes):
+                if name in scope.variables.keys():
+                    ret = scope.variables[name]
+                    break
+                elif hasattr(scope.task.params, name):
+                    # Check task parameters
+                    ret = getattr(scope.task.params, name)
+                    break
+
+        # Check package variables
+        if ret is None and hasattr(self.package.paramT, name):
+            ret = getattr(self.package.paramT, name)
+
+#        if ret is None and name in self.builder._pkg_m.keys():
+#            pkg = self.builder._pkg_m[name]
+#            ret = pkg.paramT
+
+        print("<-- resolve: %s" % type(ret))
+        return ret

dv_flow/mgr/package_loader.py

@@ -6,7 +6,7 @@ import pydantic
 import sys
 import yaml
 from pydantic import BaseModel
-from typing import Any, Callable, ClassVar, Dict, List, Tuple
+from typing import Any, Callable, ClassVar, Dict, List, Tuple, Union
 from .fragment_def import FragmentDef
 from .package_def import PackageDef
 from .package import Package
@@ -93,8 +93,6 @@ class LoaderScope(SymbolScope):
                 pkg = find_pkg(pkg_name)
                 if pkg is not None:
                     break;
-        else:
-            raise Exception("Task name %s is not fully qualified" % name)
 
         if pkg is not None and name in pkg.task_m.keys():
             ret = pkg.task_m[name]
@@ -106,6 +104,7 @@ class LoaderScope(SymbolScope):
     def findType(self, name) -> Type:
         self._log.debug("--> findType: %s" % name)
         ret = None
+        pkg = None
         last_dot = name.rfind('.')
         if last_dot != -1:
             pkg_name = name[:last_dot]
@@ -410,31 +409,21 @@ class PackageLoader(object):
         self._log.info("Loading imported package %s" % imp_path)
 
         if not os.path.isabs(imp_path):
-            self._log.debug("_basedir: %s ; imp_path: %s" % (basedir, imp_path))
-            imp_path = os.path.join(basedir, imp_path)
-            
-        # Search down the tree looking for a flow.dv file
-        if os.path.isdir(imp_path):
-            path = imp_path
+            for root in (basedir, os.path.dirname(self._file_s[0])):
+                self._log.debug("Search basedir: %s ; imp_path: %s" % (root, imp_path))
 
-            while path is not None and os.path.isdir(path) and not os.path.isfile(os.path.join(path, "flow.dv")):
-                # Look one directory down
-                next_dir = None
-                for dir in os.listdir(path):
-                    if os.path.isdir(os.path.join(path, dir)):
-                        if next_dir is None:
-                            next_dir = dir
-                        else:
-                            path = None
-                            break
-                if path is not None:
-                    path = next_dir
+                resolved_path = self._findFlowDvInDir(root, imp_path)
 
-            if path is not None and os.path.isfile(os.path.join(path, "flow.dv")):
-                imp_path = os.path.join(path, "flow.dv")
+                if resolved_path is not None and os.path.isfile(resolved_path):
+                    self._log.debug("Found root file: %s" % resolved_path)
+                    imp_path = resolved_path
+                    break
 
         if not os.path.isfile(imp_path):
-            raise Exception("Import file %s not found" % imp_path)
+            self.error("Import file %s not found" % imp_path, pkg.srcinfo)
+            # Don't want to error out 
+            return
+#            raise Exception("Import file %s not found" % imp_path)
 
         if imp_path in self._pkg_path_m.keys():
             sub_pkg = self._pkg_path_m[imp_path]
@@ -446,7 +435,34 @@ class PackageLoader(object):
 
         pkg.pkg_m[sub_pkg.name] = sub_pkg
         self._log.debug("<-- _loadPackageImport %s" % str(imp))
-        pass
+
+    def _findFlowDvInDir(self, base, leaf):
+        """Search down the tree looking for a flow.dv file"""
+        self._log.debug("--> _findFlowDvInDir (%s, %s)" % (base, leaf))
+        imp_path = None
+        if os.path.isfile(os.path.join(base, leaf)):
+            imp_path = os.path.join(base, leaf)
+            self._log.debug("Found: %s" % imp_path)
+        elif os.path.isdir(os.path.join(base, leaf)):
+            path = os.path.join(base, leaf)
+
+            while path is not None and os.path.isdir(path) and not os.path.isfile(os.path.join(path, "flow.dv")):
+                # Look one directory down
+                next_dir = None
+                for dir in os.listdir(path):
+                    if os.path.isdir(os.path.join(path, dir)):
+                        if next_dir is None:
+                            next_dir = dir
+                        else:
+                            path = None
+                            break
+                if path is not None:
+                    path = next_dir
+            if path is not None and os.path.isfile(os.path.join(path, "flow.dv")):
+                imp_path = os.path.join(path, "flow.dv")
+                self._log.debug("Found: %s" % imp_path)
+        self._log.debug("<-- _findFlowDvInDir %s" % imp_path)
+        return imp_path
 
     def _loadFragments(self, pkg, fragments, basedir, taskdefs, typedefs):
         for spec in fragments:
@@ -549,6 +565,7 @@ class PackageLoader(object):
                 name=self._getScopeFullname(taskdef.name),
                 desc=desc,
                 doc=doc,
+                package=pkg,
                 srcinfo=taskdef.srcinfo)
 
             if taskdef.iff is not None:
@@ -562,7 +579,7 @@ class PackageLoader(object):
         for taskdef, task in tasks:
 
             if taskdef.uses is not None:
-                task.uses = self._findTask(taskdef.uses)
+                task.uses = self._findTaskOrType(taskdef.uses)
 
                 if task.uses is None:
                     self.error("failed to resolve task-uses %s" % taskdef.uses, taskdef.srcinfo)
@@ -592,6 +609,7 @@ class PackageLoader(object):
                     raise Exception("Failed to find task %s" % need)
                 task.needs.append(nt)
 
+            # 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:
@@ -601,7 +619,7 @@ class PackageLoader(object):
             elif taskdef.pytask is not None: # Deprecated case
                 task.run = taskdef.pytask
                 task.shell = "pytask"
-            elif task.uses is not None and task.uses.run is not None:
+            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
 
@@ -628,12 +646,14 @@ class PackageLoader(object):
             tt.paramT = self._getParamT(
                 td, 
                 tt.uses.paramT if tt.uses is not None else None,
-                typename=tt.name)
+                typename=tt.name,
+                is_type=True)
         self._log.debug("<-- _loadTypes")
         pass
 
     def _mkTaskBody(self, task, taskdef):
         self._pkg_s[-1].push_scope(TaskScope(name=taskdef.name))
+        pkg = self.package_scope()
 
         # Need to add subtasks from 'uses' scope?
         if task.uses is not None:
@@ -653,6 +673,7 @@ class PackageLoader(object):
                 name=self._getScopeFullname(td.name),
                 desc=desc,
                 doc=doc,
+                package=pkg.pkg,
                 srcinfo=td.srcinfo)
 
             if td.iff is not None:
@@ -726,6 +747,16 @@ class PackageLoader(object):
             return self._pkg_s[-1].findTask(name)
         else:
             return self._loader_scope.findTask(name)
+        
+    def _findTaskOrType(self, name):
+        self._log.debug("--> _findTaskOrType %s" % name)
+        uses = self._findTask(name)
+
+        if uses is None:
+            uses = self._findType(name)
+
+        self._log.debug("<-- _findTaskOrType %s (%s)" % (name, ("found" if uses is not None else "not found")))
+        return uses
 
     
     def _getScopeFullname(self, leaf=None):
@@ -735,14 +766,14 @@ class PackageLoader(object):
         # Determine 
         pass
 
-    def _getPTConsumesRundir(self, taskdef : TaskDef, base_t : Task):
+    def _getPTConsumesRundir(self, taskdef : TaskDef, base_t : Union[Task,Type]):
         self._log.debug("_getPTConsumesRundir %s" % taskdef.name)
         passthrough = taskdef.passthrough
         consumes = taskdef.consumes.copy() if isinstance(taskdef.consumes, list) else taskdef.consumes
         rundir = taskdef.rundir
 #        needs = [] if task.needs is None else task.needs.copy()
 
-        if base_t is not None:
+        if base_t is not None and isinstance(base_t, Task):
             if passthrough is None:
                 passthrough = base_t.passthrough
             if consumes is None:
@@ -758,7 +789,12 @@ class PackageLoader(object):
 
         return (passthrough, consumes, rundir)
 
-    def _getParamT(self, taskdef, base_t : BaseModel, typename=None):
+    def _getParamT(
+            self, 
+            taskdef, 
+            base_t : BaseModel, 
+            typename=None,
+            is_type=False):
         self._log.debug("--> _getParamT %s" % taskdef.name)
         # Get the base parameter type (if available)
         # We will build a new type with updated fields
@@ -768,14 +804,16 @@ class PackageLoader(object):
             "int" : int,
             "float" : float,
             "bool" : bool,
-            "list" : List
+            "list" : List,
+            "map" : Dict
         }
         pdflt_m = {
             "str" : "",
             "int" : 0,
             "float" : 0.0,
             "bool" : False,
-            "list" : []
+            "list" : [],
+            "map" : {}
         }
 
         fields = []
@@ -795,6 +833,9 @@ class PackageLoader(object):
                 field_m[name] = (f.annotation, getattr(base_o, name))
         else:
             self._log.debug("No base type")
+            if is_type:
+                field_m["src"] = (str, "")
+                field_m["seq"] = (int, "")
 
         for p in taskdef.params.keys():
             param = taskdef.params[p]
@@ -860,6 +901,5 @@ class PackageLoader(object):
         self.marker(marker)
 
     def marker(self, marker):
-        print("listeners: %d" % len(self.marker_listeners))
         for l in self.marker_listeners:
             l(marker)

dv_flow/mgr/package_node.py

@@ -0,0 +1,10 @@
+import dataclasses as dc
+from .package import Package
+from .config import Config
+
+@dc.dataclass
+class PackageNode(object):
+    """Represents a specific package specialization"""
+    pkg : Package
+    cfg : Config
+

dv_flow/mgr/param_ref_eval.py

@@ -37,6 +37,9 @@ class ParamRefEval(object):
     def set(self, name : str, value : object):
         self.expr_eval.set(name, value)
 
+    def set_name_resolution(self, ctx: 'NameResolutionContext'):
+        self.expr_eval.set_name_resolution(ctx)
+
     def eval(self, val : str) -> str:
         idx = 0
 
@@ -51,8 +54,8 @@ class ParamRefEval(object):
                 
                 ref = val[idx+3:eidx].strip()
 
-                expr_ast = self.parser.parse(ref)
-                exp_val = self.expr_eval.eval(expr_ast)
+#                expr_ast = self.parser.parse(ref)
+                exp_val = self.expr_eval.eval(ref)
 
                 # Replacing [idx..eidx+2] with len(exp_val)
                 val = val[:idx] + exp_val + val[eidx+2:]

dv_flow/mgr/std/create_file.py

@@ -76,6 +76,9 @@ async def CreateFile(runner, input) -> TaskDataResult:
                 src=input.name, 
                 basedir=input.rundir,
                 files=[input.params.filename])
+    
+    if input.params.incdir:
+        fs.incdirs = [input.rundir]
 
     _log.debug("<-- FileSet(%s) changed=%s" % (input.name, changed))
 

dv_flow/mgr/std/data_item.py

@@ -0,0 +1,17 @@
+from ..task_data import TaskDataInput, TaskDataResult
+from ..task_run_ctxt import TaskRunCtxt
+
+async def DataItem(ctxt : TaskRunCtxt, input : TaskDataInput) -> TaskDataResult:
+    status = 0
+    output = []
+
+    print("DataItem: %s" % input.params)
+
+    with_c = getattr(input.params, "with")
+    item = ctxt.mkDataItem(type=input.params.type, **with_c)
+
+    return TaskDataResult(
+        status=status,
+        output=output
+    )
+

dv_flow/mgr/std/flow.dv

@@ -82,6 +82,9 @@ package:
         type: str
       content:
         type: str
+      incdir: 
+        type: bool
+        value: false
   - name: IncDirs
     shell: pytask
     run: dv_flow.mgr.std.incdirs.IncDirs
@@ -116,6 +119,18 @@ package:
         doc: |
           Optional timestamp file to determine if running 
           the command changed the output
+
+  - name: DataItem
+    shell: pytask
+    run: dv_flow.mgr.std.data_item.DataItem
+    doc: |
+      Creates and outputs a data item
+    with:
+      type:
+        type: str
+        value: ""
+      with:
+        type: map
   types:
   - name: DataItem
     with:

dv_flow/mgr/task.py

@@ -23,6 +23,7 @@ class Task(object):
     doc : str = ""
     paramT : Any = None
     uses : 'Task' = None
+    package : 'Package' = None
     iff : str = None
     needs : List[str] = dc.field(default_factory=list)
     consumes : Union[ConsumesE, List[Dict[str, Any]]] = dc.field(default=None)

dv_flow/mgr/task_graph_builder.py

@@ -28,22 +28,19 @@ from .package import Package
 from .package_def import PackageDef, PackageSpec
 from .package_loader import PackageLoader
 from .param_ref_eval import ParamRefEval
+from .name_resolution import NameResolutionContext, TaskNameResolutionScope
 from .ext_rgy import ExtRgy
 from .task import Task
 from .task_def import RundirE
 from .task_data import TaskMarker, TaskMarkerLoc, SeverityE
 from .task_node import TaskNode
 from .task_node_ctor import TaskNodeCtor
-from .task_node_ctor_compound import TaskNodeCtorCompound
-from .task_node_ctor_compound_proxy import TaskNodeCtorCompoundProxy
-from .task_node_ctor_proxy import TaskNodeCtorProxy
-from .task_node_ctor_task import TaskNodeCtorTask
-from .task_node_ctor_wrapper import TaskNodeCtorWrapper
 from .task_node_compound import TaskNodeCompound
 from .task_node_ctxt import TaskNodeCtxt
 from .task_node_leaf import TaskNodeLeaf
 from .type import Type
 from .std.task_null import TaskNull
+from .data_callable import DataCallable
 from .exec_callable import ExecCallable
 from .null_callable import NullCallable
 from .shell_callable import ShellCallable
@@ -80,6 +77,7 @@ class TaskGraphBuilder(object):
     _ns_scope_s : List[TaskNamespaceScope] = dc.field(default_factory=list)
     _compound_task_ctxt_s : List[CompoundTaskCtxt] = dc.field(default_factory=list)
     _task_rundir_s : List[List[str]] = dc.field(default_factory=list)
+    _name_resolution_stack : List[NameResolutionContext] = dc.field(default_factory=list)
     _task_node_s : List[TaskNode] = dc.field(default_factory=list)
     _eval : ParamRefEval = dc.field(default_factory=ParamRefEval)
     _ctxt : TaskNodeCtxt = None
@@ -136,6 +134,8 @@ class TaskGraphBuilder(object):
 
     def _addPackageTasks(self, pkg, pkg_s):
 
+        self._pkg_m[pkg.name] = pkg
+
         # Build out the package parameters
         params = pkg.paramT()
         self._expandParams(params, self._eval)
@@ -265,40 +265,81 @@ class TaskGraphBuilder(object):
     def mkTaskGraph(self, task : str, rundir=None) -> TaskNode:
         return self.mkTaskNode(task, rundir=rundir)
         
+    def push_name_resolution_context(self, pkg: Package):
+        """Create and push a new name resolution context"""
+        ctx = NameResolutionContext(
+            builder=self,
+            package=pkg)
+        self._name_resolution_stack.append(ctx)
+
+    def pop_name_resolution_context(self):
+        """Pop the current name resolution context"""
+        if self._name_resolution_stack:
+            self._name_resolution_stack.pop()
+
+    def push_task_scope(self, task: TaskNode):
+        """Push a new task scope onto the current context"""
+        if self._name_resolution_stack:
+            scope = TaskNameResolutionScope(task=task)
+            # Add task parameters as 'this' in the scope's variables
+            if isinstance(task, TaskNodeCompound):
+                scope.variables['this'] = task.params
+            self._name_resolution_stack[-1].task_scopes.append(scope)
+
+    def task_scope(self):
+        """Get the current task scope"""
+        if self._name_resolution_stack and self._name_resolution_stack[-1].task_scopes:
+            return self._name_resolution_stack[-1].task_scopes[-1]
+        return None
+
+    def pop_task_scope(self):
+        """Pop the current task scope"""
+        if self._name_resolution_stack and self._name_resolution_stack[-1].task_scopes:
+            self._name_resolution_stack[-1].task_scopes.pop()
+
+    def resolve_variable(self, name: str) -> Any:
+        """Resolve a variable using the current name resolution context"""
+        if self._name_resolution_stack:
+            ret = self._name_resolution_stack[-1].resolve_variable(name)
+        return ret
+
     def mkTaskNode(self, task_t, name=None, srcdir=None, needs=None, **kwargs):
         self._log.debug("--> mkTaskNode: %s" % task_t)
 
         if task_t in self._task_m.keys():
             task = self._task_m[task_t]
+            # Get the package for this task
+            self.push_name_resolution_context(task.package)
         elif self.loader is not None:
             task = self.loader.getTask(task_t)
-
             if task is None:
                 raise Exception("task_t (%s) not present" % str(task_t))
+            self.push_name_resolution_context(task.package)
         else:
             raise Exception("task_t (%s) not present" % str(task_t))
-        
-        # TODO: need to obtain the package
 
-        
-        ret = self._mkTaskNode(
-            task, 
-            name=name, 
-            srcdir=srcdir,
-            eval=self._eval)
+        try:
+            ret = self._mkTaskNode(
+                task, 
+                name=name, 
+                srcdir=srcdir,
+                eval=self._eval)
 
-        if needs is not None:
-            for need in needs:
-                ret.needs.append((need, False))
+            if needs is not None:
+                for need in needs:
+                    ret.needs.append((need, False))
 
-        for k,v in kwargs.items():
-            if hasattr(ret.params, k):
-                setattr(ret.params, k, v)
-            else:
-                raise Exception("Task %s parameters do not include %s" % (task.name, k))
+            for k,v in kwargs.items():
+                if hasattr(ret.params, k):
+                    setattr(ret.params, k, v)
+                else:
+                    raise Exception("Task %s parameters do not include %s" % (task.name, k))
 
-        self._log.debug("<-- mkTaskNode: %s (%d needs)" % (task_t, len(ret.needs)))
-        return ret
+            self._log.debug("<-- mkTaskNode: %s (%d needs)" % (task_t, len(ret.needs)))
+            return ret
+        finally:
+            # Clean up package context if we created one
+            self.pop_name_resolution_context()
     
     def mkDataItem(self, name, **kwargs):
         self._log.debug("--> mkDataItem: %s" % name)
@@ -448,10 +489,13 @@ class TaskGraphBuilder(object):
         return ret        
     
     def _isCompound(self, task):
-        if task.subtasks is not None and len(task.subtasks):
-            return True
-        elif task.uses is not None:
-            return self._isCompound(task.uses)
+        if isinstance(task, Task):
+            if task.subtasks is not None and len(task.subtasks):
+                return True
+            elif task.uses is not None:
+                return self._isCompound(task.uses)
+        else:
+            return False
     
     def _getTaskNode(self, name):
         if name in self._task_node_m.keys():
@@ -460,7 +504,8 @@ class TaskGraphBuilder(object):
             return self.mkTaskNode(name)
     
     def _mkTaskLeafNode(self, 
-                        task : Task, name=None, 
+                        task : Task, 
+                        name=None, 
                         srcdir=None, 
                         params=None, 
                         hierarchical=False,
@@ -476,19 +521,22 @@ class TaskGraphBuilder(object):
         if params is None:
             params = task.paramT()
 
-            eval.set("rundir", "/".join([str(e) for e in self.get_rundir()]))
-
-#            self._log.debug("in_params[2]: %s" % ",".join(p.src for p in in_params))
-#            eval.setVar("in", in_params)
-#            eval.setVar("rundir", rundir)
-
-            # Set variables from the inputs
-            # for need in self.needs:
-            #     for name,value in {"rundir" : need[0].rundir}.items():
-            #         eval.setVar("%s.%s" % (need[0].name, name), value)
+        # Create and push task scope for parameter resolution
+        node = TaskNodeLeaf(
+            name=name,
+            srcdir=srcdir,
+            params=params,
+            ctxt=self._ctxt,
+            passthrough=task.passthrough,
+            consumes=task.consumes,
+            task=None)  # We'll set this later
+            
+        self.push_task_scope(node)
 
-            # expand any variable references
-            self._expandParams(params, eval)
+        self.task_scope().variables["rundir"] = "/".join([str(e) for e in self.get_rundir()])
+        
+        # Now expand parameters in the scope context
+        self._expandParams(params, eval)
 
 
         if task.rundir == RundirE.Unique:
@@ -496,26 +544,29 @@ class TaskGraphBuilder(object):
 
         # TODO: handle callable in light of overrides
 
-
         callable = None
+
         if task.run is not None:
             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]
+                callable = self._shell_m[shell](task.run)
             else:
                 raise Exception("Shell %s not found" % shell)
-        else:
-            callable = NullCallable
+            
+        # Setup the callable
+        if callable is None and task.uses is not None:
+            if isinstance(task.uses, Type):
+                callable = DataCallable(task.uses.paramT)
+            else:
+                uses = self._getTaskNode(task.uses.name)
+                callable = uses.task
+        
+        if callable is None:
+            callable = NullCallable(task.run)
+
+        node.task = callable
 
-        node = TaskNodeLeaf(
-            name=name,
-            srcdir=srcdir,
-            params=params,
-            ctxt=self._ctxt,
-            passthrough=task.passthrough,
-            consumes=task.consumes,
-            task=callable(task.run))
         self._task_node_m[name] = node
         node.rundir = self.get_rundir()
 
@@ -530,6 +581,9 @@ class TaskGraphBuilder(object):
         if task.rundir == RundirE.Unique:
             self.leave_rundir()
 
+        # Clean up
+        self.pop_task_scope()
+        
         self._log.debug("<-- _mkTaskLeafNode %s" % task.name)
         return node
     
@@ -554,6 +608,13 @@ class TaskGraphBuilder(object):
             # expand any variable references
             self._expandParams(params, eval)
 
+        # Create a new task scope for this compound task
+        node = TaskNodeCompound(
+            name=name,
+            srcdir=srcdir,
+            params=params,
+            ctxt=self._ctxt)
+
         if task.rundir == RundirE.Unique:
             self.enter_rundir(name)
 
@@ -566,8 +627,9 @@ class TaskGraphBuilder(object):
                 # Determine whether this task is overridden
                 task_uses = self._findOverride(task_uses)
 
+            self.push_task_scope(node)  # Push scope before enter_uses
             self.enter_uses()
-            node = self._mkTaskNode(
+            uses_node = self._mkTaskNode(
                 task_uses,
                 name=name, 
                 srcdir=srcdir,
@@ -576,16 +638,18 @@ class TaskGraphBuilder(object):
                 eval=eval)
             self.leave_uses()
             
-            if not isinstance(node, TaskNodeCompound):
+            if not isinstance(uses_node, TaskNodeCompound):
                 # TODO: need to enclose the leaf node in a compound wrapper
                 raise Exception("Task %s is not compound" % task_uses)
+            
+            # Copy properties from uses_node to our node
+            node.tasks = uses_node.tasks
+            node.input = uses_node.input
+            node.needs = uses_node.needs
+            self.pop_task_scope()  # Pop the scope
         else:
             # Node represents the terminal node of the sub-DAG
-            node = TaskNodeCompound(
-                name=name,
-                srcdir=srcdir,
-                params=params,
-                ctxt=self._ctxt)
+            self.push_task_scope(node)  # Push scope for non-uses compound task
 
         if len(self._task_node_s):
             node.parent = self._task_node_s[-1]
@@ -617,10 +681,10 @@ class TaskGraphBuilder(object):
         # Need a local map of name -> task 
         # For now, build out local tasks and link up the needs
         tasks = []
+
         for t in task.subtasks:
             nn = self._mkTaskNode(t, hierarchical=True, eval=eval)
             node.tasks.append(nn)
-#            tasks.append((t, self._getTaskNode(t.name)))
             tasks.append((t, nn))
 
         # Pop the node stack, since we're done constructing the body
@@ -669,6 +733,10 @@ class TaskGraphBuilder(object):
         if task.rundir == RundirE.Unique:
             self.leave_rundir()
 
+        # Clean up task scope if we created one for a non-uses compound task
+        if not task.uses:
+            self.pop_task_scope()
+
         return node
 
     def _expandParams(self, params, eval):
@@ -681,21 +749,25 @@ class TaskGraphBuilder(object):
         new_val = value
         if type(value) == str:
             if value.find("${{") != -1:
-                print("Expr: %s" % str(value), flush=True)
+                if len(self._name_resolution_stack) > 0:
+                    eval.set_name_resolution(self._name_resolution_stack[-1])
                 new_val = eval.eval(value)
                 self._log.debug("Param: Evaluate expression \"%s\" => \"%s\"" % (value, new_val))
         elif isinstance(value, list):
             new_val = []
             for i,elem in enumerate(value):
                 if elem.find("${{") != -1:
-                    new_val.append(eval.eval(elem))
+                    if len(self._name_resolution_stack) > 0:
+                        eval.set_name_resolution(self._name_resolution_stack[-1])
+                    resolved = eval.eval(elem)
+                    new_val.append(resolved)
                 else:
                     new_val.append(elem)
         return new_val
 
     def _gatherNeeds(self, task_t, node):
         self._log.debug("--> _gatherNeeds %s (%d)" % (task_t.name, len(task_t.needs)))
-        if task_t.uses is not None:
+        if task_t.uses is not None and isinstance(task_t.uses, Task):
             self._gatherNeeds(task_t.uses, node)
 
         for need in task_t.needs:
@@ -717,4 +789,3 @@ class TaskGraphBuilder(object):
 
     def _findOverride(self, task):
         return task
-

dv_flow/mgr/task_run_ctxt.py

@@ -27,6 +27,22 @@ class TaskRunCtxt(object):
     @property
     def root_rundir(self):
         return self.ctxt.root_rundir
+    
+    def mkDataItem(self, type, **kwargs):
+        """
+        Create a data item in the task's rundir. The data item will be
+        created in the task's rundir, and will be available to the
+        task's implementation.
+        """
+        try:
+            item = self.runner.mkDataItem(
+                type=type,
+                rundir=self.rundir,
+                **kwargs)
+        except Exception as e:
+            self.error("Failed to create data item: %s" % str(e))
+            raise e
+        
 
     async def exec(self, 
                    cmd : List[str],

dv_flow/mgr/task_runner.py

@@ -59,6 +59,7 @@ class TaskRunner(object):
 
 @dc.dataclass
 class TaskSetRunner(TaskRunner):
+    builder : 'TaskGraphBuilder' = None
     nproc : int = -1
     status : int = 0
 
@@ -186,6 +187,11 @@ class TaskSetRunner(TaskRunner):
         else:
             return None
         
+    def mkDataItem(self, name, **kwargs):
+        if self.builder is None:
+            raise Exception("TaskSetRunner.mkDataItem() requires a builder")
+        return self.builder.mkDataItem(name, **kwargs)
+        
     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)):

{dv_flow_mgr-1.6.14849587166rc0.dist-info → dv_flow_mgr-1.6.14872991111rc0.dist-info}/METADATA

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

@@ -1,37 +1,40 @@
-dv_flow/mgr/__init__.py,sha256=9mRjpm5vmhbWvAY9D7YbIvlye23-47AHmVk5KuvjkmU,1315
+dv_flow/mgr/__init__.py,sha256=0V0QkBX5fatUjS-uCcdDJ2UmB1zKt0se6Kpki-C__Ko,1315
 dv_flow/mgr/__main__.py,sha256=BogNdBkXhgg05E8_IumNkVoag6WwvfbpiI8346oOtPo,3844
 dv_flow/mgr/cond_def.py,sha256=2ZkzPusqVkN1fFMTvkDl9O_OJLPdD_cK3xzX9J75RMw,343
-dv_flow/mgr/config.py,sha256=nF_hM-RwJLvgfbwRe11a1wsAu_SihSd5qOxQi7I6lvU,108
-dv_flow/mgr/config_def.py,sha256=Gnvhu2sc5wAEIytYGQtF27pXVaxPUSPdT73FqquZGX0,1112
+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=NbhTVqvrTd-vsTi3cJ3iGrpVe8tfAqxFsSopaNXApRE,3117
-dv_flow/mgr/expr_eval.py,sha256=6AmXWt9ototbOdLlCpxZrFoX6HhTBhSERpc2dQgaQGY,4086
+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=BeHbTjB6KFcI5xhbl_O00YQW7MQ8efCFTD_Y8xf7I44,5651
 dv_flow/mgr/extend_def.py,sha256=Ndh4z4XqqimtoS8-6ZNMDOvkVpVmEaWZsNEPM26PDZ0,653
 dv_flow/mgr/fileset.py,sha256=kSjz-RiuQdKGMVjmbGK5YlwY-vJKSHmgggu-1_H0DHU,1320
 dv_flow/mgr/fragment_def.py,sha256=2qx6KWiHCDvnb9JXnqIOb4n6kemAClAYuBoM6ex6xJE,1696
 dv_flow/mgr/listener_list.py,sha256=BfqvEO2AyJvyc4ClU-hPgDPqWSlqvSdG-yaFEHvUrMc,272
+dv_flow/mgr/name_resolution.py,sha256=yeOQuPRWaZRWbEc-82W7qO854RY1qicqC4IYxk8jpvQ,2727
 dv_flow/mgr/need_def.py,sha256=X52FJnhukwFsGCkIM-W6apZEdxqS5Gmm-rRO-TS83aU,173
 dv_flow/mgr/null_callable.py,sha256=x6hlJ9EL6xFLSGFgd14eXbxSWxsUGF56jpbLhERjPtg,243
 dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
 dv_flow/mgr/package.py,sha256=L1ba5xguOZWuyg9s4MfafKgSoIka3SgAQzYAmcV7XgQ,4430
 dv_flow/mgr/package_def.py,sha256=1O1SBJATnw-zeYKRNENgw-RWxZK0hxNQhnncfE_NR-U,5674
 dv_flow/mgr/package_import_spec.py,sha256=aZMpnS9a5NFY76_pYXEuO3-Mkc_xFzy73fdrUe_54Dc,1760
-dv_flow/mgr/package_loader.py,sha256=gd-V9kfP47mlYDR743FJPuvf_UOx_WvldDLfTGzfir0,31845
+dv_flow/mgr/package_loader.py,sha256=HBLhrMgqaZ9xxA9SmQEnNMlo5PK3T8hN3TGvqkRNwYA,33457
+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=9uO-7UI4OotYixQBo8Nwb2o8FQRFxxJylYCZm9rjt48,1917
-dv_flow/mgr/param_ref_eval.py,sha256=i5j7aDKkNKnMljXysux_gL27EJse0xnd0E5OWNZKMrw,2069
+dv_flow/mgr/param_ref_eval.py,sha256=x15lGEJNkWthXXfX3rRTh6tP7Y7A7cmNdo-iOHeOPKw,2179
 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=IWb0C4L-v_hfnvnhS3g2rhXqutURex_U-dBJgdNxP7I,302
 dv_flow/mgr/srcinfo.py,sha256=xrfp-relVr7hYNbxOjY5jqX4H0nNMm9HK5AAM6_Piyk,366
-dv_flow/mgr/task.py,sha256=HC9hejvBqRELsYLYd1ssEMGU-sYY7K1pqF6RWutgVic,2057
+dv_flow/mgr/task.py,sha256=n3v9A9HvgMWNeQhXVB_L2qRjgjounXMs9-bbxtyEau8,2088
 dv_flow/mgr/task_data.py,sha256=lN7Iq8YTitEMGG4rZqYQi6Ri2HuPgBQ5oGQbW-63T8c,12436
 dv_flow/mgr/task_def.py,sha256=8NPwtTROfWDkMqcO9mKXV4dw0sC4mCMmnsNuv8uTdTY,5094
-dv_flow/mgr/task_graph_builder.py,sha256=Qew5e8V-lMP7r6sxXi9oBuO3LxYy6pJLjDPCuN-lYes,25185
+dv_flow/mgr/task_graph_builder.py,sha256=w3el95hS9vUOb8xKb4lHDdpaP1Z4V0_i3_wYBdybN0c,28171
 dv_flow/mgr/task_graph_dot_writer.py,sha256=qK4Imy9o2_F1aKoU1tJ-qoBHslq2BhSMbdjAUPfpN7I,6009
 dv_flow/mgr/task_listener_log.py,sha256=Ai-6X5BOoGsaNTgnlXEW0-czrjJm7__ShNK501CUmko,4337
 dv_flow/mgr/task_node.py,sha256=3L1qqwisV_qRdbUdRG25uzcsO57T2Z7fbvXYF87Ta1U,5191
@@ -47,8 +50,8 @@ dv_flow/mgr/task_node_ctxt.py,sha256=dQp68ppFENK0zGo7TKaFXHInPCCsFai1yZwoBKDwJ20
 dv_flow/mgr/task_node_leaf.py,sha256=od6INBSqMkKZTbCAGJFXzZ3_eD-g7_rt_v3HNa61cQ8,8926
 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=n7oDozaCguzpQfjKwhwXR6ylSlNmtSJ5rkEsLQtqW3Q,3306
-dv_flow/mgr/task_runner.py,sha256=TDPN3jUdVgm43nWrSlNu0V5MFrq7ChfxfC3KdGuEQwQ,9984
+dv_flow/mgr/task_run_ctxt.py,sha256=Nm3QSB9iZtxwFaaQQ3h2ffU5aStDlO1p1vVKmvL6i8I,3817
+dv_flow/mgr/task_runner.py,sha256=P94Fn3exSRX6McnSkh-6GpgiWrjjVjJhbe_BpTAL7ws,10240
 dv_flow/mgr/type.py,sha256=hoJTatlPC0yOazKSWduK-5CfY38RPkc6qXFzOCcVSdM,723
 dv_flow/mgr/type_def.py,sha256=4sge3PibO1jDnS0cXdX0PiurcKbDA3kT6rb4DGIKwEM,1176
 dv_flow/mgr/yaml_srcinfo_loader.py,sha256=29BNRiB8Hj1FepkrLtdjHSv5U_85Q432gBeeK80nKEA,1606
@@ -56,10 +59,11 @@ dv_flow/mgr/cmds/cmd_graph.py,sha256=yg5KbNrGvm3dySiI0Qei_pMWZkOE9GtEyaQ4IdNVmoE
 dv_flow/mgr/cmds/cmd_run.py,sha256=vjlgpoMPkSCrJErlGSC9DPRCrRmVuUqyLXNKrb8BKW0,3690
 dv_flow/mgr/cmds/cmd_show.py,sha256=JOIFaVXt8YCf9bKXfq6qzV5wQdxdLHqE-yCj0ecGREs,3755
 dv_flow/mgr/share/flow.json,sha256=lNmZex9NXkYbyb2aZseQfUOkV9CMyfH0iLODEI7EPBw,5096
-dv_flow/mgr/std/create_file.py,sha256=TAUhpXlTmUDUYw4Dw0cI9FPuYI84yCVkoadnWZxi_8U,2888
+dv_flow/mgr/std/create_file.py,sha256=SEpKTQdiY32002C7b4kYfAiK9v_xajixOJU5WftW75I,2957
+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=yd9nwuK5MQ3uM6zqqxpF4xsieNfxfgMIC1eP1o9XElA,3729
+dv_flow/mgr/std/flow.dv,sha256=vizP3u3yU5iyCmsAeVFeIKy2Ikvhol-_NjCYWOcJCOE,4003
 dv_flow/mgr/std/incdirs.py,sha256=F0wraOxkRJRkrhsyk9v2YvpquFtcK4ZsMO1G9sgmhmA,588
 dv_flow/mgr/std/message.py,sha256=0JHLErg8whqMLAasG1fumZ2O7R7WNWeNQ9ibJaLDpVY,1029
 dv_flow/mgr/std/task_null.py,sha256=dw6LXBXVwth6gLPeduDvlz5znAhcVpDH8r1DticD-0w,1041
@@ -69,9 +73,9 @@ dv_flow/mgr/util/util.py,sha256=BO7iqP_c9ttmXkojq7nKDN-g8wl1_Pco9k-KnrXxjwE,1889
 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/util/cmds/cmd_workspace.py,sha256=egmaIXpe5L-TePwmcfisfrG6tdiTUWSjqa9Za5WChVs,890
-dv_flow_mgr-1.6.14849587166rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-1.6.14849587166rc0.dist-info/METADATA,sha256=k4olLNb07GvvqElD6ZC4ZI3Ux-vjEoRq1rZmpf1bZrU,13335
-dv_flow_mgr-1.6.14849587166rc0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-dv_flow_mgr-1.6.14849587166rc0.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
-dv_flow_mgr-1.6.14849587166rc0.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
-dv_flow_mgr-1.6.14849587166rc0.dist-info/RECORD,,
+dv_flow_mgr-1.6.14872991111rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-1.6.14872991111rc0.dist-info/METADATA,sha256=qCLOakAO4rA0KSzWyRKZPPqsJD3GPzt4UhRwsNEEBKs,13335
+dv_flow_mgr-1.6.14872991111rc0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+dv_flow_mgr-1.6.14872991111rc0.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-1.6.14872991111rc0.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-1.6.14872991111rc0.dist-info/RECORD,,