dv-flow-mgr 0.0.1.12672327205a1__py3-none-any.whl → 0.0.1.12703462647a1__py3-none-any.whl

dv_flow_mgr/fragment_def.py

@@ -23,11 +23,9 @@ import pydantic.dataclasses as dc
 import json
 from pydantic import BaseModel
 from typing import Any, Dict, List
-from .flow import Flow
 from .package import Package
-from .package_def import PackageImportSpec
-from .task import TaskParamCtor
-from .task_def import TaskDef, TaskSpec
+from .package_import_spec import PackageImportSpec
+from .task_def import TaskDef
 
 class FragmentDef(BaseModel):
     tasks : List[TaskDef] = dc.Field(default_factory=list)

dv_flow_mgr/package_def.py

@@ -24,36 +24,12 @@ import json
 from pydantic import BaseModel
 from typing import Any, Dict, List
 from .flow import Flow
+from .fragment_def import FragmentDef
 from .package import Package
+from .package_import_spec import PackageImportSpec, PackageSpec
 from .task import TaskParamCtor
 from .task_def import TaskDef, TaskSpec
 
-@dc.dataclass
-class PackageSpec(object):
-    name : str
-    params : Dict[str,Any] = dc.Field(default_factory=dict)
-    _fullname : str = None
-
-    def get_fullname(self) -> str:
-        if self._fullname is None:
-            if len(self.params) != 0:
-                self._fullname = "%s%s}" % (
-                    self.name,
-                    json.dumps(self.params, separators=(',', ':')))
-            else:
-                self._fullname = self.name
-        return self._fullname    
-    
-    def __hash__(self):
-        return hash(self.get_fullname())
-
-    def __eq__(self, value):
-        return isinstance(value, PackageSpec) and value.get_fullname() == self.get_fullname()
-
-@dc.dataclass
-class PackageImportSpec(PackageSpec):
-    path : str = dc.Field(default=None, alias="from")
-    alias : str = dc.Field(default=None, alias="as")
 
 class PackageDef(BaseModel):
     name : str
@@ -63,6 +39,8 @@ class PackageDef(BaseModel):
     imports : List[PackageImportSpec] = dc.Field(default_factory=list)
     fragments: List[str] = dc.Field(default_factory=list)
 
+    fragment_l : List['FragmentDef'] = dc.Field(default_factory=list, exclude=True)
+
 #    import_m : Dict['PackageSpec','Package'] = dc.Field(default_factory=dict)
 
     basedir : str = None
@@ -90,8 +68,31 @@ class PackageDef(BaseModel):
                     basedir=self.basedir,
                     depend_refs=task.depends)
             else:
+                # We use the Null task from the std package
                 raise Exception("")
             ret.tasks[task.name] = ctor_t
 
+        for frag in self.fragment_l:
+            for task in frag.tasks:
+                if task.type is not None:
+                    # Find package (not package_def) that implements this task
+                    # Insert an indirect reference to that tasks's constructor
+
+                    # Only call getTaskCtor if the task is in a different package
+                    task_t = task.type if isinstance(task.type, TaskSpec) else TaskSpec(task.type)
+                    ctor_t = session.getTaskCtor(task_t, self)
+
+                    ctor_t = TaskParamCtor(
+                        base=ctor_t, 
+                        params=task.params, 
+                        basedir=frag.basedir,
+                        depend_refs=task.depends)
+                else:
+                    # We use the Null task from the std package
+                    raise Exception("")
+                if task.name in ret.tasks:
+                    raise Exception("Task %s already defined" % task.name)
+                ret.tasks[task.name] = ctor_t
+
         return ret
 

dv_flow_mgr/package_import_spec.py

@@ -0,0 +1,31 @@
+
+import pydantic.dataclasses as dc
+import json
+from typing import Dict, Any
+
+@dc.dataclass
+class PackageSpec(object):
+    name : str
+    params : Dict[str,Any] = dc.Field(default_factory=dict)
+    _fullname : str = None
+
+    def get_fullname(self) -> str:
+        if self._fullname is None:
+            if len(self.params) != 0:
+                self._fullname = "%s%s}" % (
+                    self.name,
+                    json.dumps(self.params, separators=(',', ':')))
+            else:
+                self._fullname = self.name
+        return self._fullname    
+    
+    def __hash__(self):
+        return hash(self.get_fullname())
+
+    def __eq__(self, value):
+        return isinstance(value, PackageSpec) and value.get_fullname() == self.get_fullname()
+
+@dc.dataclass
+class PackageImportSpec(PackageSpec):
+    path : str = dc.Field(default=None, alias="from")
+    alias : str = dc.Field(default=None, alias="as")

dv_flow_mgr/session.py

@@ -24,6 +24,7 @@ import os
 import yaml
 import dataclasses as dc
 from typing import Any, Callable, Dict, List
+from .fragment_def import FragmentDef
 from .package import Package
 from .package_def import PackageDef, PackageSpec
 from .task import Task,TaskSpec
@@ -47,14 +48,15 @@ class Session(object):
     _task_list : List[Task] = dc.field(default_factory=list)
     _task_m : Dict[TaskSpec,Task] = dc.field(default_factory=dict)
     _task_id : int = 0
-    _rundir_s : List[str] = dc.field(default_factory=list)
 
     def __post_init__(self):
         from .tasklib.std.pkg_std import PackageStd
+        from .tasklib.hdl.sim.vcs_pkg import VcsPackage
         from .tasklib.hdl.sim.vlt_pkg import VltPackage
         from .tasklib.hdl.sim.mti_pkg import MtiPackage
         self._pkg_m[PackageSpec("std")] = PackageStd("std")
         self._pkg_m[PackageSpec("hdl.sim.mti")] = MtiPackage("hdl.sim.mti")
+        self._pkg_m[PackageSpec("hdl.sim.vcs")] = VcsPackage("hdl.sim.vcs")
         self._pkg_m[PackageSpec("hdl.sim.vlt")] = VltPackage("hdl.sim.vlt")
 
     def load(self, root : str):
@@ -73,27 +75,25 @@ class Session(object):
         self._pkg_s.clear()
         self._task_m.clear()
 
-        self._rundir_s.clear()
-        self._rundir_s.append(self.rundir)
-
-        return self._mkTaskGraph(task)
+        return self._mkTaskGraph(task, self.rundir)
         
-    def _mkTaskGraph(self, task : str, params : dict = None) -> Task:
+    def _mkTaskGraph(self, task : str, parent_rundir : str, params : dict = None) -> Task:
 
         elems = task.split(".")
 
         pkg_name = ".".join(elems[0:-1])
         task_name = elems[-1]
 
-        self._rundir_s.append(os.path.join(self._rundir_s[-1], pkg_name, task_name))
-
         if pkg_name == "":
             if len(self._pkg_spec_s) == 0:
                 raise Exception("No package context for %s" % task)
             pkg_spec = self._pkg_spec_s[-1]
+            pkg_name = pkg_spec.name
         else:
             pkg_spec = PackageSpec(pkg_name)
 
+        rundir = os.path.join(parent_rundir, pkg_name, task_name)
+
         self._pkg_spec_s.append(pkg_spec)
         pkg = self.getPackage(pkg_spec)
         
@@ -115,20 +115,19 @@ class Session(object):
             self,
             params,
             depends)
-        task.rundir = self._rundir_s[-1]
+        task.rundir = rundir
         
         for i,d in enumerate(task.depend_refs):
             if d in self._task_m.keys():
                 task.depends.append(self._task_m[d])
             else:
                 print("mkTaskGraph: %s" % d)
-                task.depends.append(self._mkTaskGraph(d))
+                task.depends.append(self._mkTaskGraph(d, parent_rundir))
 
         self._task_m[task.name] = task
 
         self._pkg_s.pop()
         self._pkg_spec_s.pop()
-        self._rundir_s.pop()
 
         return task
     
@@ -147,6 +146,7 @@ class Session(object):
         file_s.append(root)
         ret = None
         with open(root, "r") as fp:
+            print("open %s" % root)
             doc = yaml.load(fp, Loader=yaml.FullLoader)
             if "package" not in doc.keys():
                 raise Exception("Missing 'package' key in %s" % root)
@@ -167,13 +167,55 @@ class Session(object):
                 self._pkg_spec_s.append(PackageSpec(pkg.name))
 
         print("pkg: %s" % str(pkg))
-        
-        # TODO: read in fragments
+
+        print("fragments: %s" % str(pkg.fragments))
+        for spec in pkg.fragments:
+            self._load_fragment_spec(pkg, spec, file_s)
 
         self._pkg_spec_s.pop()
         file_s.pop()
 
         return pkg
+    
+    def _load_fragment_spec(self, pkg : PackageDef, spec : str, file_s : List[str]):
+
+        # We're either going to have:
+        # - File path
+        # - Directory path
+
+        if os.path.isfile(os.path.join(pkg.basedir, spec)):
+            self._load_fragment_file(pkg, spec, file_s)
+        elif os.path.isdir(os.path.join(pkg.basedir, spec)):
+            self._load_fragment_dir(pkg, os.path.join(pkg.basedir, spec), file_s)
+        else:
+            raise Exception("Fragment spec %s not found" % spec)
+        
+
+    def _load_fragment_dir(self, pkg : PackageDef, dir : str, file_s : List[str]):
+
+        for file in os.listdir(dir):
+            if os.path.isdir(os.path.join(dir, file)):
+                self._load_fragment_dir(pkg, os.path.join(dir, file), file_s)
+            elif os.path.isfile(os.path.join(dir, file)):
+                self._load_fragment_file(pkg, os.path.join(dir, file), file_s)
+
+    def _load_fragment_file(self, pkg : PackageDef, file : str, file_s : List[str]):
+
+        if file in file_s:
+            raise Exception("Recursive file processing @ %s: %s" % (file, ",".join(self._file_s)))
+        file_s.append(file)
+
+        with open(file, "r") as fp:
+            doc = yaml.load(fp, Loader=yaml.FullLoader)
+            if "fragment" in doc.keys():
+                # Merge the package definition
+                frag = FragmentDef(**(doc["fragment"]))
+                frag.basedir = os.path.dirname(file)
+                pkg.fragment_l.append(frag)
+            else:
+                print("Warning: file %s is not a fragment" % file)
+        
+
 
     def getPackage(self, spec : PackageSpec) -> Package:
         pkg_spec = self._pkg_spec_s[-1]

dv_flow_mgr/share/flow.json

@@ -23,7 +23,6 @@
         }
     ],
     "defs": {
-
         "package-def": {
             "title": "Package Definition",
             "$$target": "#/defs/package-def",
@@ -156,21 +155,23 @@
                         "$ref": "#/defs/param"
                     }
                 },
-                "depends": {
-                    "oneOf": [
-                        {
+                "oneOf": [
+                    {
+                        "needs": {
                             "type": "array",
                             "items": {
                                 "$ref": "#/defs/task-dep"
                             }
-                        }, {
+                        }
+                    }, {
+                        "needs": {
                             "type": "array",
                             "items": {
                                 "type": "string"
                             }
                         }
-                    ]
-                }
+                    }
+                ]
             }
         }
     }

dv_flow_mgr/task.py

@@ -143,6 +143,9 @@ class Task(object):
     def setMemento(self, memento : TaskMemento):
         self.memento = memento
 
+    async def isUpToDate(self, memento) -> bool:
+        return False
+
     async def do_run(self) -> TaskData:
         print("do_run: %s - %d depends" % (self.name, len(self.depends)))
         if len(self.depends) > 0:

dv_flow_mgr/task_def.py

@@ -33,7 +33,7 @@ class TaskDef(BaseModel):
     """Holds definition information (ie the YAML view) for a task"""
     name : str
     type : (str|TaskSpec) = dc.Field(default_factory=list)
-    depends : List[(str|TaskSpec)] = dc.Field(default_factory=list)
+    depends : List[(str|TaskSpec)] = dc.Field(default_factory=list, alias="needs")
     params: Dict[str,Any] = dc.Field(default_factory=dict, alias="with")
 
     def copy(self) -> 'TaskDef':

dv_flow_mgr/tasklib/hdl/sim/mti_task_sim_image.py

@@ -15,10 +15,10 @@ from svdep import FileCollection, TaskCheckUpToDate, TaskBuildFileCollection
 class TaskMtiSimImage(VlTaskSimImage):
 
     def getRefTime(self):
-        if os.path.isdir(os.path.join(self.rundir, 'work.d')):
+        if os.path.isfile(os.path.join(self.rundir, 'work.d')):
             return os.path.getmtime(os.path.join(self.rundir, 'work.d'))
         else:
-            raise Exception("work.d not found")
+            raise Exception("work.d not found (%s)")
     
     async def build(self, files : List[str], incdirs : List[str]):
         if not os.path.isdir(os.path.join(self.rundir, 'work')):
@@ -53,7 +53,7 @@ class TaskMtiSimImage(VlTaskSimImage):
         await proc.wait()
 
         with open(os.path.join(self.rundir, 'work.d'), "w") as fp:
-            pass
+            fp.write("\n")
 
         if proc.returncode != 0:
             raise Exception("Questa opt failed")

dv_flow_mgr/tasklib/hdl/sim/vcs_pkg.py

@@ -0,0 +1,14 @@
+import dataclasses as dc
+from .pkg_hdl_sim import PackageHdlSim
+from .vcs_task_sim_image import TaskVcsSimImageCtor
+from .vcs_task_sim_run import TaskVcsSimRunCtor
+
+@dc.dataclass
+class VcsPackage(PackageHdlSim):
+
+    def __post_init__(self):
+        print("PackageVcs::__post_init__", flush=True)
+        self.tasks["SimImage"] = TaskVcsSimImageCtor()
+        self.tasks["SimRun"] = TaskVcsSimRunCtor()
+    pass
+

dv_flow_mgr/tasklib/hdl/sim/vcs_task_sim_image.py

@@ -0,0 +1,49 @@
+import os
+import fnmatch
+import dataclasses as dc
+from ....fileset import FileSet
+from ....package import TaskCtor
+from ....task import Task, TaskParams, TaskCtorT
+from ....task_data import TaskData
+from ....task_memento import TaskMemento
+from .vl_task_sim_image import VlTaskSimImage, VlTaskSimImageParams, VlTaskSimImageMemento
+from typing import List, Tuple
+
+from svdep import FileCollection, TaskCheckUpToDate, TaskBuildFileCollection
+
+@dc.dataclass
+class TaskVcsSimImage(VlTaskSimImage):
+
+    def getRefTime(self):
+        if os.path.isdir(os.path.join(self.rundir, 'simv')):
+            return os.path.getmtime(os.path.join(self.rundir, 'simv'))
+        else:
+            raise Exception
+    
+    async def build(self, files : List[str], incdirs : List[str]):
+        cmd = ['vcs', '-sverilog']
+
+        for incdir in incdirs:
+            cmd.append('+incdir+%s' % incdir)
+
+        cmd.extend(files)
+
+        if len(self.params.top):
+            cmd.extend(['-top', "+".join(self.params.top)])
+
+        proc = await self.session.create_subprocess(*cmd,
+                                                        cwd=self.rundir)
+        await proc.wait()
+
+        if proc.returncode != 0:
+            raise Exception("VCS simv failed")
+
+class TaskVcsSimImageParams(VlTaskSimImageParams):
+    pass
+
+class TaskVcsSimImageMemento(VlTaskSimImageMemento):
+    pass
+
+class TaskVcsSimImageCtor(TaskCtorT):
+    def __init__(self):
+        super().__init__(TaskVcsSimImageParams, TaskVcsSimImage)

dv_flow_mgr/tasklib/hdl/sim/vcs_task_sim_run.py

@@ -0,0 +1,45 @@
+import os
+import fnmatch
+import pydantic.dataclasses as dc
+from ....fileset import FileSet
+from ....package import TaskCtor
+from ....task import Task, TaskParams, TaskCtorT
+from ....task_data import TaskData
+from ....task_memento import TaskMemento
+from typing import List, Tuple
+
+class TaskVcsSimRun(Task):
+
+    async def run(self, input : TaskData) -> TaskData:
+        vl_fileset = input.getFileSets("simBinary")
+
+        build_dir = vl_fileset[0].basedir
+
+        cmd = [
+            os.path.join(build_dir, 'simv'),
+        ]
+
+        fp = open(os.path.join(self.rundir, 'sim.log'), "w")
+        proc = await self.session.create_subprocess(*cmd,
+                                                    cwd=self.rundir,
+                                                    stdout=fp)
+
+        await proc.wait()
+
+        fp.close()
+
+        output = TaskData()
+        output.addFileSet(FileSet(src=self.name, type="simRunDir", basedir=self.rundir))
+
+        return output
+
+class TaskVcsSimRunParams(TaskParams):
+    pass
+
+class TaskVcsSimRunMemento(TaskMemento):
+    pass
+
+class TaskVcsSimRunCtor(TaskCtorT):
+    def __init__(self):
+        super().__init__(TaskVcsSimRunParams, TaskVcsSimRun)
+

dv_flow_mgr/tasklib/hdl/sim/vl_task_sim_image.py

@@ -41,7 +41,7 @@ class VlTaskSimImage(Task):
                 info = FileCollection.from_dict(ex_memento.svdeps)
                 in_changed = not TaskCheckUpToDate(files, incdirs).check(info, ref_mtime)
             except Exception as e:
-                print("Unexpected output-directory format. Rebuilding")
+                print("Unexpected output-directory format (%s). Rebuilding" % str(e))
                 shutil.rmtree(self.rundir)
                 os.makedirs(self.rundir)
                 in_changed = True
@@ -56,7 +56,7 @@ class VlTaskSimImage(Task):
             await self.build(files, incdirs) 
 
         output = TaskData()
-        output.addFileSet(FileSet(src=self.name, type="verilatorBinary", basedir=self.rundir))
+        output.addFileSet(FileSet(src=self.name, type="simDir", basedir=self.rundir))
         output.changed = in_changed
 
         self.setMemento(memento)

dv_flow_mgr/tasklib/hdl/sim/vlt_task_sim_run.py

@@ -11,7 +11,7 @@ from typing import List, Tuple
 class TaskVltSimRun(Task):
 
     async def run(self, input : TaskData) -> TaskData:
-        vl_fileset = input.getFileSets("verilatorBinary")
+        vl_fileset = input.getFileSets("simBinary")
 
         build_dir = vl_fileset[0].basedir
 

{dv_flow_mgr-0.0.1.12672327205a1.dist-info → dv_flow_mgr-0.0.1.12703462647a1.dist-info}/METADATA

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

@@ -2,34 +2,38 @@ dv_flow_mgr/__init__.py,sha256=GLfYxZONxJNNUplfmlsXrcycJ2VhTc8gvXN6qdlH7kg,97
 dv_flow_mgr/__main__.py,sha256=4xXA4XCqLELlIak6bs-H6rRHp2URucipHPvCiVdR01c,513
 dv_flow_mgr/fileset.py,sha256=89knoTNsDF85QJwrctLiM6ryqHS1oxW25Gd5jgpX-IQ,1123
 dv_flow_mgr/flow.py,sha256=UdgJOIqBS2wTRpO-sNWCCqO9oQFxDfGPGVD0r42aTrA,1562
-dv_flow_mgr/fragment_def.py,sha256=s6RLDTUDc2ktzaz8VtExkjgHqhe70GeH9zWgJLTyTcg,1597
+dv_flow_mgr/fragment_def.py,sha256=_c-mmfNjdKctSK6Omnm-3otx9-fIX8hw8yh06vSlozE,1540
 dv_flow_mgr/package.py,sha256=jFhXgKDEYSRfs_VRUjKY4C7KScQfmrNLEXQgtWKaBfI,2767
-dv_flow_mgr/package_def.py,sha256=1Oz3uiPXEQ6XXqcimpYcO3VNBmTMwgvKil4f2bRtAgY,3399
+dv_flow_mgr/package_def.py,sha256=Js8bZj8bSmJQ6Wk9xAhIBJScNGJOHNbXNhw_zkDVU5w,3834
+dv_flow_mgr/package_import_spec.py,sha256=bStPa727wAKMcixydVY1Ht6ylzXsSMy2K31HWPXhc9k,921
 dv_flow_mgr/parameters.py,sha256=kUjRss5VtMMz5eL3-Z_M6BS-wFs7MhQu3ANXO54UPo0,896
-dv_flow_mgr/session.py,sha256=KMCXW_fDhH5G1iBjD89cyk_FVEBTa5s1lWNX5ndjy6c,8939
-dv_flow_mgr/task.py,sha256=C3GRK2wvypq5b4xfk164irsN8pY3-OJ3lWMsHmncBY4,7245
+dv_flow_mgr/session.py,sha256=M13VGMMrB9Eko0T4dEpqBuTHxsVpaKTNw5JhGRc2rTA,10726
+dv_flow_mgr/task.py,sha256=Lx5eXIlP-m1yseVLh_1_p7Gy1dj36zU3dSH7LyE6JaY,7316
 dv_flow_mgr/task_data.py,sha256=tIerZoe8yt1ig1m6IPQ6N64SI2rQlUoVY5oOjFYICws,2590
-dv_flow_mgr/task_def.py,sha256=Dn5EN9tu0e1R_GsbkrZHY0idRG1omOs-XI60uGhH62I,1500
+dv_flow_mgr/task_def.py,sha256=qFB_koWGgziH_Uh96dqFjRI38dY6s2OTDpn-uEwYtUo,1515
 dv_flow_mgr/task_memento.py,sha256=C7VTQpBhDEoYuDmE6YTM-6TLMLnqHp6Y0Vat1aTgtCs,1096
 dv_flow_mgr/cmds/cmd_run.py,sha256=ii48_jdxCxh4MOJCeKKX66Cui4IvQQy_RrJEIixsph8,733
-dv_flow_mgr/share/flow.json,sha256=h2Jeh2lfGJUe6xE_o5nMO8zkcrGL_GVS2taEqFzKr5g,5042
+dv_flow_mgr/share/flow.json,sha256=lNmZex9NXkYbyb2aZseQfUOkV9CMyfH0iLODEI7EPBw,5096
 dv_flow_mgr/tasklib/hdl/sim/mti_pkg.py,sha256=l_jerOEQrVSmxT6qJx0PlsorZsK037Y-arQvWzdm9No,348
-dv_flow_mgr/tasklib/hdl/sim/mti_task_sim_image.py,sha256=tp0AlxIp-zu6YuNk9eleveDlPls0m56eToSvoTjVFio,2213
+dv_flow_mgr/tasklib/hdl/sim/mti_task_sim_image.py,sha256=U1XADvEGaH412n_JujS1Maz08GJ07UL6mRT4B4qihZQ,2229
 dv_flow_mgr/tasklib/hdl/sim/mti_task_sim_run.py,sha256=QkKYOs0OhQ42F5bUbfCsezE4L50TfiIm7lVflVY4On8,1290
 dv_flow_mgr/tasklib/hdl/sim/pkg_hdl_sim.py,sha256=hPk5w7dN3Uq3mLRBNCEtE7jkLavi2MAczJlle_xGoQ8,166
 dv_flow_mgr/tasklib/hdl/sim/task_sim_image.py,sha256=DOSxzH-0EZQZlm-EwSq1q7_nz_yru6al36Ji1Q6z5F4,375
-dv_flow_mgr/tasklib/hdl/sim/vl_task_sim_image.py,sha256=pjdkZtei1eGAm_P5HXNNinZ-x8WBAE3warpj_YR8N4o,2263
+dv_flow_mgr/tasklib/hdl/sim/vcs_pkg.py,sha256=65W8NP54_EdtHo6lsmCejT8diPvizT9e3AjjTXJC_u0,413
+dv_flow_mgr/tasklib/hdl/sim/vcs_task_sim_image.py,sha256=HlUMT185VQ_j70C6WTV1GXTXIGgIFb7xelU23jrTVj4,1492
+dv_flow_mgr/tasklib/hdl/sim/vcs_task_sim_run.py,sha256=DDwq_iiv8TYpXMf59pZuttG75lI71CjbNKwAXbCAlBA,1194
+dv_flow_mgr/tasklib/hdl/sim/vl_task_sim_image.py,sha256=2UD2IXSP9Kf-g4J7bMTSR2cgx761DtXzMVIkIPQpLdg,2268
 dv_flow_mgr/tasklib/hdl/sim/vlt_pkg.py,sha256=Pu9mWAR93kiTNT8GZJrX-VDjMOfr9P5ddcSPt1BElQQ,413
 dv_flow_mgr/tasklib/hdl/sim/vlt_task_sim_image.py,sha256=9RDJ3r37C4tA4PIa7tDUYYgRpIh19up-Y9HTOwKxr0I,1564
-dv_flow_mgr/tasklib/hdl/sim/vlt_task_sim_run.py,sha256=kUuiwNdvyYY8HUNSCgC8UWf5gL7sIK0eNp5TrPAs2sc,1208
+dv_flow_mgr/tasklib/hdl/sim/vlt_task_sim_run.py,sha256=Qhufu0NjzPLev-4BjWBftfgA0sogeXpTmygapRrk9VM,1202
 dv_flow_mgr/tasklib/std/fileset.py,sha256=u88qjKQpIip_eETk0k6J1AGxk9blKlqAqYinHGKwco8,61
 dv_flow_mgr/tasklib/std/pkg_std.py,sha256=ERDd515qtetQaldk9opUH19MyNwo8nP4-GLz-ke-5gE,370
 dv_flow_mgr/tasklib/std/std.dfs,sha256=An2NUvvWaR9xI4U-kRQ4NN6U-GhX6GQmd3mNyRkW4NQ,68
 dv_flow_mgr/tasklib/std/task_fileset.py,sha256=ISsI-g8v8bKYYQiGd1Ju2VlyEOxEziNgXtssEEmnu6s,3095
 dv_flow_mgr/tasklib/std/task_null.py,sha256=bQH1HN4r-TtdUaJxfnmvoqKZSY4MWO48eK7z_yngdNU,599
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/METADATA,sha256=IFGISfbNIMqisxzkYNavsm92ORxBaVEyxOAYYh8ZKJI,13252
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/entry_points.txt,sha256=VHxIon5AeHCtK73fYb1veDImAGwv76hrtBiuZePmzhI,51
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/top_level.txt,sha256=FGuhGIxN1FgD_YBkPcDq05fTxZcwaX9G_O8FFBvrTk4,12
-dv_flow_mgr-0.0.1.12672327205a1.dist-info/RECORD,,
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/METADATA,sha256=inlwQMpO8cBPHqz-NZoEYrmDDp2Sd57rkkz2hIBz68c,13252
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/entry_points.txt,sha256=VHxIon5AeHCtK73fYb1veDImAGwv76hrtBiuZePmzhI,51
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/top_level.txt,sha256=FGuhGIxN1FgD_YBkPcDq05fTxZcwaX9G_O8FFBvrTk4,12
+dv_flow_mgr-0.0.1.12703462647a1.dist-info/RECORD,,

{dv_flow_mgr-0.0.1.12672327205a1.dist-info → dv_flow_mgr-0.0.1.12703462647a1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.7.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any