dv-flow-mgr 0.0.1.13657597614a1__py3-none-any.whl → 0.0.1.13667970156a1__py3-none-any.whl

dv_flow/mgr/__init__.py

@@ -8,4 +8,6 @@ from .task_graph_runner import TaskGraphRunner
 from .task_graph_runner_local import TaskGraphRunnerLocal
 from .task_graph_builder import TaskGraphBuilder
 from .task_node import task
+from .task_runner import TaskSetRunner
+from .task_listener_log import TaskListenerLog
 

dv_flow/mgr/expr_parser.py

@@ -143,7 +143,6 @@ class ExprParser(object):
     t_RPAREN  = r'\)'
     t_ID      = r'[a-zA-Z_][a-zA-Z0-9_]*'
     t_PIPE    = r'\|'
-    t_STRING2 = r'\'.*\''
     
     def t_NUMBER(self, t):
         r'\d+'
@@ -155,8 +154,15 @@ class ExprParser(object):
         return t
     
     def t_STRING1(self, t):
-        r'(\'|\")([^\\\n]|(\\.))*?(\'|\")'
-        t.value = t.value[1:-1].replace('\\"', '"').replace("\\'", "'").replace('\\n', '\n').replace('\\t', '\t').replace('\\\\', '\\')
+        r'"([^"\\]*(\\.[^"\\]*)*)"'
+        t.value = t.value[1:-1].replace(r'\"', '"').replace(r'\\', '\\')
+
+    def t_STRING2(self, t):
+        r'\'([^\'\\]*(\\.[^\'\\]*)*)\''
+        t.value = t.value[1:-1].replace(r'\'', '"').replace(r'\\', '\\')
+
+#        r'(\'|\")([^\\\n]|(\\.))*?(\'|\")'
+#        t.value = t.value[1:-1].replace('\\"', '"').replace("\\'", "'").replace('\\n', '\n').replace('\\t', '\t').replace('\\\\', '\\')
         return t
     
     # Ignored characters

dv_flow/mgr/fileset.py

@@ -24,7 +24,8 @@ from pydantic import BaseModel
 from typing import Any, Dict, List, Tuple
 
 class FileSet(BaseModel):
-    type : str
+    type: str = "std.FileSet"
+    filetype : str
     basedir : str
     name : str = ""
     src : str = None

dv_flow/mgr/package_def.py

@@ -56,6 +56,10 @@ class PackageDef(BaseModel):
     basedir : str = None
     _log : ClassVar = logging.getLogger("PackageDef")
 
+    def __post_init__(self):
+        for t in self.tasks:
+            t.fullname = self.name + "." + t.name
+
     def getTask(self, name : str) -> 'TaskDef':
         for t in self.tasks:
             if t.name == name:
@@ -83,11 +87,13 @@ class PackageDef(BaseModel):
         # Now we have a unified map of the tasks declared in this package
         for name in list(tasks_m.keys()):
             task_i = tasks_m[name]
+            fullname = self.name + "." + name
             if len(task_i) < 3:
                 # Need to create the task ctor
                 ctor_t = self.mkTaskCtor(session, task_i[0], task_i[1], tasks_m)
                 tasks_m[name] = (task_i[0], task_i[1], ctor_t)
             ret.tasks[name] = tasks_m[name][2]
+            ret.tasks[fullname] = tasks_m[name][2]
 
         session.pop_package(ret)
 
@@ -95,7 +101,7 @@ class PackageDef(BaseModel):
         return ret
     
     def getTaskCtor(self, session, task_name, tasks_m):
-        self._log.debug("--> getTaskCtor")
+        self._log.debug("--> getTaskCtor %s" % task_name)
         # Find package (not package_def) that implements this task
         # Insert an indirect reference to that tasks's constructor
         last_dot = task_name.rfind('.')
@@ -132,6 +138,7 @@ class PackageDef(BaseModel):
         needs = [] if task.needs is None else task.needs.copy()
 
         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()
 
@@ -160,7 +167,7 @@ class PackageDef(BaseModel):
             callable = getattr(mod, clsname)
 
         # Determine if we need to use a new 
-        paramT = self._getParamT(task, base_params)
+        paramT = self._getParamT(session, task, base_params)
         
         if callable is not None:
             ctor_t = TaskNodeCtorTask(
@@ -184,7 +191,7 @@ class PackageDef(BaseModel):
             ctor_t = TaskNodeCtorTask(
                 name=task.name,
                 srcdir=srcdir,
-                paramT=TaskNullParams,
+                paramT=paramT,
                 passthrough=passthrough,
                 needs=needs,
                 task=TaskNull)
@@ -192,7 +199,8 @@ class PackageDef(BaseModel):
         self._log.debug("<-- %s::mkTaskCtor %s" % (self.name, task.name))
         return ctor_t
     
-    def _getParamT(self, task, base_t : BaseModel):
+    def _getParamT(self, session, task, base_t : BaseModel):
+        self._log.debug("--> _getParamT %s" % task.fullname)
         # Get the base parameter type (if available)
         # We will build a new type with updated fields
 
@@ -214,6 +222,8 @@ class PackageDef(BaseModel):
         fields = []
         field_m : Dict[str,int] = {}
 
+        pkg = session.package()
+
         # First, pull out existing fields (if there's a base type)
         if base_t is not None:
             self._log.debug("Base type: %s" % str(base_t))
@@ -255,6 +265,11 @@ class PackageDef(BaseModel):
 
         params_t = pydantic.create_model("Task%sParams" % task.name, **field_m)
 
+        self._log.debug("== Params")
+        for name,info in params_t.model_fields.items():
+            self._log.debug("  %s: %s" % (name, str(info)))
+
+        self._log.debug("<-- _getParamT %s" % task.name)
         return params_t
 
     @staticmethod
@@ -273,7 +288,15 @@ class PackageDef(BaseModel):
             doc = yaml.load(fp, Loader=yaml.FullLoader)
             if "package" not in doc.keys():
                 raise Exception("Missing 'package' key in %s" % root)
-            pkg = PackageDef(**(doc["package"]))
+            try:
+                pkg = PackageDef(**(doc["package"]))
+
+                for t in pkg.tasks:
+                    t.fullname = pkg.name + "." + t.name
+
+            except Exception as e:
+                PackageDef._log.error("Failed to load package from %s" % root)
+                raise e
             pkg.basedir = os.path.dirname(root)
 
 #            for t in pkg.tasks:

dv_flow/mgr/parsetab.py

@@ -27,18 +27,18 @@ for _k, _v in _lr_goto_items.items():
 del _lr_goto_items
 _lr_productions = [
   ("S' -> expression","S'",1,None,None,None),
-  ('expression -> ID LPAREN RPAREN','expression',3,'p_call','expr_parser.py',160),
-  ('expression -> ID LPAREN args RPAREN','expression',4,'p_call','expr_parser.py',161),
-  ('args -> expression','args',1,'p_args','expr_parser.py',165),
-  ('args -> args COMMA expression','args',3,'p_args','expr_parser.py',166),
-  ('expression -> expression PLUS expression','expression',3,'p_expression_binop','expr_parser.py',174),
-  ('expression -> expression MINUS expression','expression',3,'p_expression_binop','expr_parser.py',175),
-  ('expression -> expression TIMES expression','expression',3,'p_expression_binop','expr_parser.py',176),
-  ('expression -> expression PIPE expression','expression',3,'p_expression_binop','expr_parser.py',177),
-  ('expression -> expression DIVIDE expression','expression',3,'p_expression_binop','expr_parser.py',178),
-  ('expression -> LPAREN expression RPAREN','expression',3,'p_expression_group','expr_parser.py',189),
-  ('expression -> NUMBER','expression',1,'p_expression_number','expr_parser.py',193),
-  ('expression -> ID','expression',1,'p_expression_name','expr_parser.py',197),
-  ('expression -> STRING1','expression',1,'p_expression_string1','expr_parser.py',201),
-  ('expression -> STRING2','expression',1,'p_expression_string2','expr_parser.py',205),
+  ('expression -> ID LPAREN RPAREN','expression',3,'p_call','expr_parser.py',180),
+  ('expression -> ID LPAREN args RPAREN','expression',4,'p_call','expr_parser.py',181),
+  ('args -> expression','args',1,'p_args','expr_parser.py',185),
+  ('args -> args COMMA expression','args',3,'p_args','expr_parser.py',186),
+  ('expression -> expression PLUS expression','expression',3,'p_expression_binop','expr_parser.py',194),
+  ('expression -> expression MINUS expression','expression',3,'p_expression_binop','expr_parser.py',195),
+  ('expression -> expression TIMES expression','expression',3,'p_expression_binop','expr_parser.py',196),
+  ('expression -> expression PIPE expression','expression',3,'p_expression_binop','expr_parser.py',197),
+  ('expression -> expression DIVIDE expression','expression',3,'p_expression_binop','expr_parser.py',198),
+  ('expression -> LPAREN expression RPAREN','expression',3,'p_expression_group','expr_parser.py',209),
+  ('expression -> NUMBER','expression',1,'p_expression_number','expr_parser.py',213),
+  ('expression -> ID','expression',1,'p_expression_name','expr_parser.py',217),
+  ('expression -> STRING1','expression',1,'p_expression_string1','expr_parser.py',221),
+  ('expression -> STRING2','expression',1,'p_expression_string2','expr_parser.py',225),
 ]

dv_flow/mgr/std/fileset.py

@@ -23,7 +23,12 @@ async def FileSet(runner, input) -> TaskDataResult:
 
 
     changed = False
-    ex_memento = input.memento
+    # 
+    try:
+        ex_memento = TaskFileSetMemento(**input.memento) if input.memento is not None else None
+    except Exception as e:
+        _log.error("Failed to load memento: %s" % str(e))
+        ex_memento = None 
     memento = TaskFileSetMemento()
 
     _log.debug("ex_memento: %s" % str(ex_memento))
@@ -39,8 +44,8 @@ async def FileSet(runner, input) -> TaskDataResult:
         _log.debug("glob_root: %s" % glob_root)
 
         fs = _FileSet(
+                filetype=input.params.type,
                 src=input.name, 
-                type=input.params.type,
                 basedir=glob_root)
 
         if not isinstance(input.params.include, list):

dv_flow/mgr/task_data.py

@@ -38,6 +38,7 @@ class TaskMarker(BaseModel):
     loc : TaskMarkerLoc = dc.Field(default=None)
 
 class TaskParameterSet(BaseModel):
+    type : str = None
     task : str = None # Name of the task that produced this param set
     seq : int  = -1 # Order in which the param-set must appear
 
@@ -51,14 +52,14 @@ class TaskDataInput(BaseModel):
 
 class TaskDataResult(BaseModel):
     changed : bool = dc.Field(default=True)
-    output : List[TaskParameterSet] = dc.Field(default_factory=list)
+    output : List[Any] = dc.Field(default_factory=list)
     memento : Any = dc.Field(default=None)
     markers : List[TaskMarker] = dc.Field(default_factory=list)
     status : int = dc.Field(default=0)
 
 class TaskDataOutput(BaseModel):
     changed : bool = True
-    output : List[TaskParameterSet] = dc.Field(default_factory=list)
+    output : List[Any] = dc.Field(default_factory=list)
     dep_m : Dict[str,List[str]] = dc.Field(default_factory=dict)
 
 class TaskDataParamOpE(enum.Enum):

dv_flow/mgr/task_def.py

@@ -33,6 +33,7 @@ class TaskSpec(object):
 class TaskDef(BaseModel):
     """Holds definition information (ie the YAML view) for a task"""
     name : str
+    fullname : str = dc.Field(default=None)
 #    type : Union[str,TaskSpec] = dc.Field(default_factory=list)
     uses : str = dc.Field(default=None)
     pytask : str = dc.Field(default=None)

dv_flow/mgr/task_graph_builder.py

@@ -27,7 +27,7 @@ from .package_def import PackageDef, PackageSpec
 from .pkg_rgy import PkgRgy
 from .task import Task
 from .task_node import TaskNodeCtor
-from typing import Dict, List
+from typing import Dict, List, Union
 
 @dc.dataclass
 class TaskGraphBuilder(object):
@@ -178,8 +178,21 @@ class TaskGraphBuilder(object):
         self._logger.debug("<-- getPackage: %s" % str(pkg))
 
         return pkg
+    
+    def mkTaskNode(self, typename, name=None, srcdir=None, needs=None, **kwargs):
+        ctor = self.getTaskCtor(typename)
+        params = ctor.mkTaskParams(**kwargs)
+        return ctor.mkTaskNode(
+            params=params,
+            name=name, 
+            srcdir=srcdir, 
+            needs=needs)
         
-    def getTaskCtor(self, spec : 'TaskSpec', pkg : PackageDef = None) -> 'TaskCtor':
+    def getTaskCtor(self, spec : Union[str,'TaskSpec'], pkg : PackageDef = None) -> 'TaskCtor':
+        from .task_def import TaskSpec
+        if type(spec) == str:
+            spec = TaskSpec(spec)
+
         self._logger.debug("--> getTaskCtor %s" % spec.name)
         spec_e = spec.name.split(".")
         task_name = spec_e[-1]

dv_flow/mgr/task_listener_log.py

@@ -1,15 +1,21 @@
 import dataclasses as dc
+from rich.console import Console
 
+@dc.dataclass
 class TaskListenerLog(object):
+    console : Console = dc.field(default_factory=Console)
+    level : int = 0
 
     def event(self, task : 'Task', reason : 'Reason'):
         if reason == 'enter':
-            print("> Task %s" % task.name, flush=True)
+            self.level += 1
+            self.console.print("[green]>[%d][/green] Task %s" % (self.level, task.name))
         elif reason == 'leave':
             for m in task.result.markers:
                 print("  %s" % m)
-            print("< Task %s" % task.name, flush=True)
+            self.console.print("[green]<[%d][/green] Task %s" % (self.level, task.name))
+            self.level -= 1
         else:
-            print("- Task %s" % task.name, flush=True)
+            self.console.print("[red]-[/red] Task %s" % task.name)
         pass
 

dv_flow/mgr/task_node.py

@@ -108,6 +108,29 @@ class TaskNodeCtor(object):
     paramT : Any
     passthrough : bool
 
+    def __call__(self, 
+                 name=None,
+                 srcdir=None,
+                 params=None,
+                 needs=None,
+                 passthrough=None,
+                 **kwargs):
+        """Convenience method for direct creation of tasks"""
+        if params is None:
+            params = self.mkTaskParams(kwargs)
+        
+        node = self.mkTaskNode(
+            srcdir=srcdir, 
+            params=params, 
+            name=name, 
+            needs=needs)
+        if passthrough is not None:
+            node.passthrough = passthrough
+        else:
+            node.passthrough = self.passthrough
+
+        return node
+
     def getNeeds(self) -> List[str]:
         return []
 
@@ -188,28 +211,7 @@ class TaskNodeCtorTask(TaskNodeCtorDefBase):
 class TaskNodeCtorWrapper(TaskNodeCtor):
     T : Any
 
-    def __call__(self, 
-                 name=None,
-                 srcdir=None,
-                 params=None,
-                 needs=None,
-                 passthrough=None,
-                 **kwargs):
-        """Convenience method for direct creation of tasks"""
-        if params is None:
-            params = self.mkTaskParams(kwargs)
-        
-        node = self.mkTaskNode(
-            srcdir=srcdir, 
-            params=params, 
-            name=name, 
-            needs=needs)
-        if passthrough is not None:
-            node.passthrough = passthrough
-        else:
-            node.passthrough = self.passthrough
 
-        return node
 
     def mkTaskNode(self, params, srcdir=None, name=None, needs=None) -> TaskNode:
         node = TaskNode(name, srcdir, params, self.T, needs=needs)

dv_flow/mgr/task_runner.py

@@ -140,6 +140,13 @@ class TaskSetRunner(TaskRunner):
         with open(os.path.join(self.rundir, "cache", "mementos.json"), "w") as f:
             json.dump(dst_memento, f)
 
+        if isinstance(task, list):
+            return list(t.output for t in task)
+        else:
+            return task.output
+
+
+
         pass
 
     def _buildDepMap(self, dep_m, task : TaskNode):

{dv_flow_mgr-0.0.1.13657597614a1.dist-info → dv_flow_mgr-0.0.1.13667970156a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.13657597614a1
+Version: 0.0.1.13667970156a1
 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.13657597614a1.dist-info → dv_flow_mgr-0.0.1.13667970156a1.dist-info}/RECORD

@@ -1,47 +1,47 @@
-dv_flow/mgr/__init__.py,sha256=_IH_cJws79HRCdn0-Q11WHFuMQYA6oPCZIufeXT-BOc,317
+dv_flow/mgr/__init__.py,sha256=2iTpSe1M8g_u2UlAQFa3XFfqcw8gBOWdBvrstce1c5E,403
 dv_flow/mgr/__main__.py,sha256=uik6gDAvtZNG0yyDKYc4FTl6R1QHAR543jNG2lCAa6E,1771
 dv_flow/mgr/eval_jq.py,sha256=Ue-qkyNW6uOu2Wy8u6nrTbPPY7ujaHd0-4iki0eV3Ec,294
 dv_flow/mgr/expr_eval.py,sha256=Mp0TvrV6gZWcj1uYwLfPNI-ARwwdAfwntE5byLBfBuY,2276
-dv_flow/mgr/expr_parser.py,sha256=aR8n6hgk5xmFknIaSVC02K-So-eU4pkkFtwb7zWsSPs,5474
-dv_flow/mgr/fileset.py,sha256=FNvC5sU2ArxJ0OO3v8dXTv8zX-bZ5t0a0ljne0fQQ1o,1150
+dv_flow/mgr/expr_parser.py,sha256=FhBTkKKkJXubGHUzmcMWubPfPklYLGzVz1jK4-dYb44,5702
+dv_flow/mgr/fileset.py,sha256=ewyjKLzuOecZg0vtabN_UkbzNEnk1sXgrH8uDyeKB60,1184
 dv_flow/mgr/fragment_def.py,sha256=cyzp1XeWtNOaagScmeS-BPsoXj9j2LTBbKq5ZUioz8I,1641
 dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
 dv_flow/mgr/package.py,sha256=878twhPD-E1pFlDNUtuyeFEgJ_Y89b560og4St-Iwrs,1679
-dv_flow/mgr/package_def.py,sha256=EdKwyxqvWT8xQmALGa6BbNv0PMbDLZTr3A27L9coIzc,13761
+dv_flow/mgr/package_def.py,sha256=ek60ERvWFOVlL71_Fgk1-RWQMrkxNt4USrfZXwLS2d0,14603
 dv_flow/mgr/package_import_spec.py,sha256=ah3r15v5Jdub2poc3sgi6Uar1L3oGoYsCPPNiOHV-a4,1760
 dv_flow/mgr/param.py,sha256=3BY-ucig6JRw73FhjyJQL-vpd57qhAzixgZ8I5FoUpw,553
 dv_flow/mgr/param_def.py,sha256=gLua-EQiY8V2CFX-2svLRIlrs8PEeGh4-EPtn4a2Mng,712
 dv_flow/mgr/param_ref_eval.py,sha256=U8QhDf1n_9bLnExdc1oQamq5-pOUXrFalOX4oyR9UoM,1138
-dv_flow/mgr/parsetab.py,sha256=enSOnMQ-woIsMEzHyeYiefvhAl8enxfX9Ct_o8-jkqs,3780
+dv_flow/mgr/parsetab.py,sha256=I-p3nC60t9jiNtPhKyl_sE92SiP96zJLnNdydcLy33g,3780
 dv_flow/mgr/pkg_rgy.py,sha256=2R_EaeBDJn5qUq9DzSnLc37wUP36MWSv-p0LgUjJRAg,4471
 dv_flow/mgr/task.py,sha256=kLQSvnVwj9ROIDtxq8lLu-4mJizTxOqvUeogmgN6QAA,5976
 dv_flow/mgr/task_ctor.py,sha256=hlfl-UVvyjzLFN6D0Oel9eBs0xUQPqCX7gQ0uEHoL7o,1382
-dv_flow/mgr/task_data.py,sha256=gzs7BfwTLPKUEpaiGMwvA3MNfebTKHv_wDFppvWHo8A,11413
-dv_flow/mgr/task_def.py,sha256=PORXrUBoynoj_oYAVISR5NW53OZevZ6hL4T7TutkkHo,1879
+dv_flow/mgr/task_data.py,sha256=F0X-e0IHTh06Z0F67TWIUPKuJYf6JPzZyMPrDzOJvK0,11409
+dv_flow/mgr/task_def.py,sha256=T06dvQegPJunH8ekuN5aPxIVcaUWiv5qkfqbZnCacLk,1923
 dv_flow/mgr/task_exec_data.py,sha256=aT__kmVmNxqnS_GbTRS1vrYgKiv8cH-HUSmRb6YYKsI,640
-dv_flow/mgr/task_graph_builder.py,sha256=sswBPUZg71dFT8kaB0towbWIadhNdbTy5gLgvC2uiVA,7276
+dv_flow/mgr/task_graph_builder.py,sha256=okqJDDu6qyubXQoyI-r0jUTd53Tq7ISSYCymZh_Cppw,7708
 dv_flow/mgr/task_graph_runner.py,sha256=jUGI49QvxUCfQoKQDDk2psbeapIcCg72qNOW1JipHzM,2182
 dv_flow/mgr/task_graph_runner_local.py,sha256=OrydPwtQ8E7hYWvSXx0h7lI3nfUNFyklULhsyMwz9dA,4687
 dv_flow/mgr/task_impl_data.py,sha256=bFPijoKrh9x7fZN2DsvRJp0UHo-gGM0VjtDQISyfhFk,321
-dv_flow/mgr/task_listener_log.py,sha256=B9-LEgSF2QwcUREBoUjEsS0rRYg1_ilFHBUKlNeT5YA,444
+dv_flow/mgr/task_listener_log.py,sha256=5N-WG6ii-R6XPbgPR6zcfKjABOoGYab6I_04Lfwux5Q,705
 dv_flow/mgr/task_memento.py,sha256=C7VTQpBhDEoYuDmE6YTM-6TLMLnqHp6Y0Vat1aTgtCs,1096
-dv_flow/mgr/task_node.py,sha256=iQKiDTC8Oz8tQwLzJF4NpsREg8JPXI-rju5tG7P6dfw,8448
+dv_flow/mgr/task_node.py,sha256=BxkjUJU7WdIhyBbP7FMBFY6EgHenhnnYGGdGW3Xukck,8450
 dv_flow/mgr/task_output.py,sha256=l-W-FvVo6YDah1RQS-I9N0KUtB3vp-kl7lxIdmNz0l4,178
 dv_flow/mgr/task_params_ctor.py,sha256=aXgB8o9xFPjaEjGW_xYkEC0N0apzGzGUPDj7g2ZLvus,1112
-dv_flow/mgr/task_runner.py,sha256=Xv5bPwAKV793R9W5Ksu1u_WBoRUzlpfHpGtGLXdsIlY,6940
+dv_flow/mgr/task_runner.py,sha256=Ky10BWKy_NhvJp2nsbB0pyS8n1K0pKatBEmTdD1ZKOc,7071
 dv_flow/mgr/type.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dv_flow/mgr/type_def.py,sha256=KdhuNlfw-NKU-4VZFCnMPyj775yEB7cpr5tz73a9yuQ,259
 dv_flow/mgr/util.py,sha256=06eVyURF4ga-s8C9Sd3ZSDebwO4QS0XXaB8xADVbWRc,1437
 dv_flow/mgr/cmds/cmd_run.py,sha256=eths8kT7mBmpZqwOuMtpKAaux4rg-f7hPBxxTHbpKT4,2903
 dv_flow/mgr/share/flow.json,sha256=lNmZex9NXkYbyb2aZseQfUOkV9CMyfH0iLODEI7EPBw,5096
 dv_flow/mgr/std/exec.py,sha256=ETx9xSxhdCD_iw6pcmhrafDCJ-41AneyEAPwQf3q-3w,452
-dv_flow/mgr/std/fileset.py,sha256=r2s2H45FuBhTLsjvjqn26Zb6EsR-psvV00ObMIyEGNA,2486
+dv_flow/mgr/std/fileset.py,sha256=abHgTxz25FD1ep5QXlCZKt4gCyfplJsjx6LyfQ11f_Q,2683
 dv_flow/mgr/std/flow.dv,sha256=jlFOh3xVECOzHws7x6YvJ9eCIGHM5gsPeEnheiGOukY,1553
 dv_flow/mgr/std/message.py,sha256=CWrBKImbXKe2d7hJ223U3Ifuxo54zLpFPJviE8BUJvk,188
 dv_flow/mgr/std/task_null.py,sha256=UKwUnqwFPBY8BO44ZAPcgehQB59kHZFa1qyZc1TwUqE,196
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/METADATA,sha256=HVQUNoijJOwkTY6DfEDvnWzRDQ3JVzQFeR-9brAOQus,13276
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
-dv_flow_mgr-0.0.1.13657597614a1.dist-info/RECORD,,
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/METADATA,sha256=KkpZBeRE5Av-3wHTQewdBoyjAtM3voZTDxeXsjrsjhs,13276
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-0.0.1.13667970156a1.dist-info/RECORD,,