dv-flow-mgr 0.0.1.12911707440a1__tar.gz → 0.0.1.12922457458a1__tar.gz

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.12911707440a1
+Version: 0.0.1.12922457458a1
 Summary: DV Flow Manager is a build system for silicon design
 Author-email: Matthew Ballance <matt.ballance@gmail.com>
 License:                                  Apache License
@@ -206,6 +206,7 @@ License:                                  Apache License
            limitations under the License.
         
 License-File: LICENSE
+Requires-Dist: pydantic
 Requires-Dist: pyyaml
 Requires-Dist: toposort
 Requires-Dist: svdep

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/ivpm.yaml

@@ -15,12 +15,7 @@ package:
     deps:
     - name: pytest
       src: pypi
-    - name: svdep
-      url: https://github.com/fvutils/svdep.git
-      anonymous: True
-    - name: dv-flow-lib-hdlsim
-      url: http://github.com/dv-flow/dv-flow-lib-hdlsim.git
-    - name: ply 
+    - name: pydantic
       src: pypi
     - name: pyyaml
       src: pypi

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/pyproject.toml

@@ -5,9 +5,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dv-flow-mgr"
-version = "0.0.1.12911707440a1"
+version = "0.0.1.12922457458a1"
 dependencies = [
-    "pyyaml",
+    'pydantic',
+    'pyyaml',
     "toposort",
     "svdep"
 ]

dv_flow_mgr-0.0.1.12922457458a1/src/dv_flow/mgr/__init__.py

@@ -0,0 +1,9 @@
+
+from .package_def import *
+from .task_graph_runner import *
+from .task import *
+from .task_data import *
+from .task_graph_runner import TaskGraphRunner
+from .task_graph_runner_local import TaskGraphRunnerLocal
+from .task_graph_builder import TaskGraphBuilder
+

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/src/dv_flow/mgr/package_def.py

@@ -215,7 +215,7 @@ class PackageDef(BaseModel):
             if len(task.params) > 0:
                 ctor_t.params = task.params
             if len(task.depends) > 0:
-                ctor_t.depends.extends(task.depends)
+                ctor_t.depends.extend(task.depends)
 
         return ctor_t
 

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/src/dv_flow/mgr/task_graph_builder.py

@@ -70,6 +70,13 @@ class TaskGraphBuilder(object):
 
         depends = []
 
+        for dep in ctor_t.depends:
+            if not dep in self._task_m.keys():
+                task = self._mkTaskGraph(dep, rundir)
+                self._task_m[dep] = task
+                pass
+            depends.append(self._task_m[dep])
+
         # The returned task should have all param references resolved
         print("task_ctor=%s" % str(ctor_t.task_ctor), flush=True)
         task = ctor_t.task_ctor(
@@ -99,7 +106,6 @@ class TaskGraphBuilder(object):
         print("getPackage: %s len: %d" % (spec.name, len(self._pkg_spec_s)))
         if len(self._pkg_spec_s) > 0:
             pkg_spec = self._pkg_spec_s[-1]
-            print("pkg_spec: %s ; root_pkg: %s" % (pkg_spec.name, self.root_pkg.name))
             if self.root_pkg.name == pkg_spec.name:
                 pkg_def = self.root_pkg
             else:

dv_flow_mgr-0.0.1.12922457458a1/src/dv_flow/mgr/task_graph_runner_local.py

@@ -0,0 +1,137 @@
+#****************************************************************************
+#* task_graph_runner_local.py
+#*
+#* Copyright 2023 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.
+#*
+#* Created on:
+#*     Author: 
+#*
+#****************************************************************************
+import asyncio
+import os
+import yaml
+import dataclasses as dc
+from toposort import toposort
+from typing import Any, Callable, ClassVar, Coroutine, Dict, List, Tuple, Union
+from .fragment_def import FragmentDef
+from .package import Package
+from .pkg_rgy import PkgRgy
+from .package_def import PackageDef, PackageSpec
+from .task import Task, TaskSpec, TaskCtor
+from .task_data import TaskData
+from .task_graph_runner import TaskGraphRunner
+
+@dc.dataclass
+class TaskGraphRunnerLocal(TaskGraphRunner):
+    """Session manages execution of a task graph"""
+
+    rundir : str
+    nproc : int = 4
+    done_task_m : Dict = dc.field(default_factory=dict)
+    _workers : List = dc.field(default_factory=list)
+
+    _inst : ClassVar['TaskGraphRunner'] = None
+
+    # Search path for .dfs files
+    create_subprocess : Callable = asyncio.create_subprocess_exec
+    _root_dir : str = None
+
+    def __post_init__(self):
+        if self.nproc == -1:
+            self.nproc = os.cpu_count()
+        for _ in range(self.nproc):
+            self._workers.append(LocalRunnerWorker(self))
+
+
+    async def exec(self, *args, **kwargs):
+        return await self.create_subprocess(*args, **kwargs)
+
+    async def run(self, task : Union[Task,List[Task]]) -> List['TaskData']:
+        if isinstance(task, Task):
+            unwrap = True
+            task = [task]
+        else:
+            unwrap = False
+
+        dep_m = {}
+        task_m = {}
+
+        for t in task:
+            self._mkDeps(dep_m, task_m, t)
+
+        print("dep_m: %s" % str(dep_m))
+
+        order = list(toposort(dep_m))
+
+        active_task_l : List[Tuple[Task,Coroutine]]= []
+        # Now, iterate over the concurrent sets
+        for active_s in order:
+
+            # Check to see if all tasks are complete
+            done = True
+            for t in active_s:
+                while len(active_task_l) >= self.nproc and t not in self.done_task_m.keys():
+                    # Wait for at least one job to complete
+                    done, pending = await asyncio.wait(at[1] for at in active_task_l)
+                    for d in done:
+                        for i in range(len(active_task_l)):
+                            if active_task_l[i][1] == d:
+                                tt = active_task_l[i][0]
+                                self.done_task_m[tt.name] = tt
+                                active_task_l.pop(i)
+                                break
+                if t not in self.done_task_m.keys():
+                    task = task_m[t]
+                    coro = asyncio.Task(task.do_run())
+                    active_task_l.append((task, coro))
+               
+            # Now, wait for tasks to complete
+            if len(active_task_l):
+                coros = list(at[1] for at in active_task_l)
+                res = await asyncio.gather(*coros)
+
+#        print("order: %s" % str(order))
+#        
+#        run_o = list(t.do_run() for t in task)
+
+#        ret = await asyncio.gather(*run_o)
+        ret = None
+
+        if unwrap:
+            return task.output
+        else:
+            return list(t.output for t in task)
+        
+    def _mkDeps(self, dep_m, task_m, task):
+        if task.name not in dep_m.keys():
+            task_m[task.name] = task
+            dep_m[task.name] = set(t.name for t in task.depends)
+            for d in task.depends:
+                self._mkDeps(dep_m, task_m, d)
+    
+    async def runTask(self, task : Task) -> 'TaskData':
+        return await task.do_run()
+    
+    def queueTask(self, task : Task):
+        """Queue a task for execution"""
+        pass
+
+@dc.dataclass
+class LocalRunnerWorker(object):
+    runner : TaskGraphRunnerLocal
+    task_s : List = dc.field(default_factory=list)
+
+
+

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/src/dv_flow_mgr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dv-flow-mgr
-Version: 0.0.1.12911707440a1
+Version: 0.0.1.12922457458a1
 Summary: DV Flow Manager is a build system for silicon design
 Author-email: Matthew Ballance <matt.ballance@gmail.com>
 License:                                  Apache License
@@ -206,6 +206,7 @@ License:                                  Apache License
            limitations under the License.
         
 License-File: LICENSE
+Requires-Dist: pydantic
 Requires-Dist: pyyaml
 Requires-Dist: toposort
 Requires-Dist: svdep

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/src/dv_flow_mgr.egg-info/requires.txt

@@ -1,3 +1,4 @@
+pydantic
 pyyaml
 toposort
 svdep

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/tests/unit/test_data_merge.py

@@ -5,10 +5,9 @@ import dataclasses as dc
 import pytest
 from typing import List
 import yaml
-from dv_flow_mgr import TaskData, FileSet, Session, TaskData, TaskDataParamKindE
+from dv_flow.mgr import TaskData, FileSet, TaskData, TaskDataParamKindE
 from pydantic import BaseModel
 from shutil import copytree
-from .tasklib import TaskNull
 
 def test_empty_in():
 

dv_flow_mgr-0.0.1.12922457458a1/tests/unit/test_fileset.py

@@ -0,0 +1,54 @@
+import asyncio
+import io
+import os
+import dataclasses as dc
+import pytest
+from typing import List
+import yaml
+from dv_flow.mgr import PackageDef, TaskGraphBuilder, TaskGraphRunnerLocal
+from pydantic import BaseModel
+from shutil import copytree
+
+def test_fileset_1(tmpdir):
+    """"""
+    datadir = os.path.join(os.path.dirname(__file__), "data/fileset")
+
+    copytree(
+        os.path.join(datadir, "test1"), 
+        os.path.join(tmpdir, "test1"))
+    
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "test1", "flow.dv"))
+    builder = TaskGraphBuilder(
+        pkg_def,
+        os.path.join(tmpdir, "rundir"))
+    task = builder.mkTaskGraph("test1.files1")
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    out = asyncio.run(runner.run(task))
+    assert out.changed == True
+
+    # Now, re-run using the same run directory.
+    # Since the files haven't changed, the output must indicate that
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "test1", "flow.dv"))
+    builder = TaskGraphBuilder(
+        pkg_def,
+        os.path.join(tmpdir, "rundir"))
+    task = builder.mkTaskGraph("test1.files1")
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    out = asyncio.run(runner.run(task))
+    assert out.changed == False
+
+    # Now, add a files
+    with open(os.path.join(tmpdir, "test1", "files1", "file1_3.sv"), "w") as f:
+        f.write("// file1_3.sv\n")
+
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "test1", "flow.dv"))
+    builder = TaskGraphBuilder(
+        pkg_def,
+        os.path.join(tmpdir, "rundir"))
+    task = builder.mkTaskGraph("test1.files1")
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    out = asyncio.run(runner.run(task))
+    assert out.changed == True

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/tests/unit/test_pyclass.py

@@ -2,7 +2,7 @@
 import os
 import asyncio
 import pytest
-from dv_flow_mgr import Session, TaskData
+from dv_flow.mgr import TaskGraphBuilder, TaskGraphRunnerLocal, PackageDef
 #from dv_flow_mgr.tasklib.builtin_pkg import TaskPyClass, TaskPyClassParams
 
 # def test_smoke(tmpdir):
@@ -43,7 +43,7 @@ package:
         value: "1"
 """
     module = """
-from dv_flow_mgr import Task, TaskData
+from dv_flow.mgr import Task, TaskData
 
 class foo(Task):
     async def run(self, input : TaskData) -> TaskData:
@@ -58,10 +58,15 @@ class foo(Task):
         f.write(flow)
 
     rundir = os.path.join(tmpdir, "rundir")
-    session = Session(os.path.join(tmpdir), rundir)
-    session.load()
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "flow.dv"))
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    task = builder.mkTaskGraph("pkg1.foo")
+    output = asyncio.run(runner.run(task))
 
-    output = asyncio.run(session.run("pkg1.foo"))
 
 def test_class_use(tmpdir):
     # Test that we can 
@@ -79,7 +84,7 @@ package:
     uses: foo
 """
     module = """
-from dv_flow_mgr import Task, TaskData
+from dv_flow.mgr import Task, TaskData
 
 class foo(Task):
     async def run(self, input : TaskData) -> TaskData:
@@ -93,11 +98,14 @@ class foo(Task):
     with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
         f.write(flow)
 
-    rundir = os.path.join(tmpdir, "rundir")
-    session = Session(os.path.join(tmpdir), rundir)
-    session.load()
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "flow.dv"))
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
 
-    output = asyncio.run(session.run("pkg1.foo2"))
+    task = builder.mkTaskGraph("pkg1.foo2")
+    output = asyncio.run(runner.run(task))
 
 def test_class_use_with(tmpdir):
     # Test that we can 
@@ -118,7 +126,7 @@ package:
 
 """
     module = """
-from dv_flow_mgr import Task, TaskData
+from dv_flow.mgr import Task, TaskData
 
 class foo(Task):
     async def run(self, input : TaskData) -> TaskData:
@@ -132,11 +140,14 @@ class foo(Task):
     with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
         f.write(flow)
 
-    rundir = os.path.join(tmpdir, "rundir")
-    session = Session(os.path.join(tmpdir), rundir)
-    session.load()
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "flow.dv"))
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
 
-    output = asyncio.run(session.run("pkg1.foo2"))
+    task = builder.mkTaskGraph("pkg1.foo")
+    output = asyncio.run(runner.run(task))
 
 def test_class_use_with_new_param(tmpdir):
     # Test that we can 
@@ -160,7 +171,7 @@ package:
 
 """
     module = """
-from dv_flow_mgr import Task, TaskData
+from dv_flow.mgr import Task, TaskData
 
 class foo(Task):
     async def run(self, input : TaskData) -> TaskData:
@@ -174,8 +185,60 @@ class foo(Task):
     with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
         f.write(flow)
 
-    rundir = os.path.join(tmpdir, "rundir")
-    session = Session(os.path.join(tmpdir), rundir)
-    session.load()
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "flow.dv"))
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    task = builder.mkTaskGraph("pkg1.foo2")
+    output = asyncio.run(runner.run(task))
+
+def test_broad_parallel(tmpdir):
+    # Test that we can 
+    flow = """
+package:
+  name: pkg1
+  tasks:
+  - name: foo
+    pyclass: my_module.foo
+    with:
+      param1:
+        type: str
+        value: "1"
+"""
+
+    count = 1000
+
+    for t in range(count):
+        flow += "  - name: foo_%02d\n" % t
+        flow += "    uses: foo\n"
+        flow += "    with:\n"
+        flow += "      param1: \"%d\"\n" % t
+    flow += "  - name: final\n"
+    flow += "    needs: [" + ",".join("foo_%02d" % t for t in range(count)) + "]\n"
+
+    module = """
+from dv_flow.mgr import Task, TaskData
+
+class foo(Task):
+    async def run(self, input : TaskData) -> TaskData:
+        print("foo::run", flush=True)
+        print("params: %s" % str(self.params), flush=True)
+        return input
+"""
+
+    with open(os.path.join(tmpdir, "my_module.py"), "w") as f:
+        f.write(module)
+    with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
+        f.write(flow)
+
+    pkg_def = PackageDef.load(os.path.join(tmpdir, "flow.dv"))
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=os.path.join(tmpdir, "rundir"))
+    runner = TaskGraphRunnerLocal(rundir=os.path.join(tmpdir, "rundir"))
+
+    task = builder.mkTaskGraph("pkg1.final")
+    output = asyncio.run(runner.run(task))
 
-    output = asyncio.run(session.run("pkg1.foo2"))

{dv_flow_mgr-0.0.1.12911707440a1 → dv_flow_mgr-0.0.1.12922457458a1}/tests/unit/test_smoke.py

@@ -5,7 +5,7 @@ import dataclasses as dc
 import pytest
 from typing import List
 import yaml
-from dv_flow_mgr import FileSet, PackageDef, Session, TaskData
+from dv_flow.mgr import FileSet, PackageDef, TaskData
 from pydantic import BaseModel
 from shutil import copytree
 

dv_flow_mgr-0.0.1.12922457458a1/tests/unit/test_stdlib.py

@@ -0,0 +1,35 @@
+import os
+import asyncio
+import pytest
+from dv_flow.mgr import TaskGraphBuilder, TaskGraphRunnerLocal, PackageDef
+from dv_flow.mgr.util import loadProjPkgDef
+
+def test_message(tmpdir, capsys):
+    flow = """
+package:
+  name: pkg1
+  tasks:
+  - name: foo
+    uses: std.Message
+    with:
+      msg: "Hello, World!"
+"""
+
+    with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
+        f.write(flow)
+
+    rundir = os.path.join(tmpdir, "rundir")
+
+    pkg_def = loadProjPkgDef(os.path.join(tmpdir))
+    assert pkg_def is not None
+    builder = TaskGraphBuilder(
+        root_pkg=pkg_def,
+        rundir=rundir)
+    runner = TaskGraphRunnerLocal(rundir=rundir)
+
+    task = builder.mkTaskGraph("pkg1.foo")
+
+    output = asyncio.run(runner.run(task))
+
+    captured = capsys.readouterr()
+    assert captured.out.find("Hello, World!") >= 0

dv_flow_mgr-0.0.1.12911707440a1/src/dv_flow/mgr/__init__.py

@@ -1,6 +0,0 @@
-
-from .package_def import *
-from .task_graph_runner import *
-from .task import *
-from .task_data import *
-

dv_flow_mgr-0.0.1.12911707440a1/src/dv_flow/mgr/task_graph_runner_local.py

@@ -1,79 +0,0 @@
-#****************************************************************************
-#* session.py
-#*
-#* Copyright 2023 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.
-#*
-#* Created on:
-#*     Author: 
-#*
-#****************************************************************************
-import asyncio
-import os
-import yaml
-import dataclasses as dc
-from typing import Any, Callable, ClassVar, Dict, List, Union
-from .fragment_def import FragmentDef
-from .package import Package
-from .pkg_rgy import PkgRgy
-from .package_def import PackageDef, PackageSpec
-from .task import Task, TaskSpec, TaskCtor
-from .task_data import TaskData
-from .task_graph_runner import TaskGraphRunner
-
-@dc.dataclass
-class TaskGraphRunnerLocal(TaskGraphRunner):
-    """Session manages execution of a task graph"""
-
-    rundir : str
-    nproc : int = -1
-    _workers : List = dc.field(default_factory=list)
-
-    _inst : ClassVar['TaskGraphRunner'] = None
-
-    # Search path for .dfs files
-    create_subprocess : Callable = asyncio.create_subprocess_exec
-    _root_dir : str = None
-
-    def __post_init__(self):
-        if self.nproc == -1:
-            self.nproc = os.cpu_count()
-        for _ in range(self.nproc):
-            self._workers.append(LocalRunnerWorker(self))
-
-
-    async def exec(self, *args, **kwargs):
-        return await self.create_subprocess(*args, **kwargs)
-
-    async def run(self, task : Union[Task,List[Task]]) -> List['TaskData']:
-        if isinstance(task, Task):
-            task = [task]
-        
-        run_o = list(t.do_run() for t in task)
-
-        return await asyncio.gather(*run_o)
-    
-    async def runTask(self, task : Task) -> 'TaskData':
-        return await task.do_run()
-    
-    def queueTask(self, task : Task):
-        """Queue a task for execution"""
-        pass
-
-@dc.dataclass
-class LocalRunnerWorker(object):
-    runner : TaskGraphRunnerLocal
-    pass
-
-

dv_flow_mgr-0.0.1.12911707440a1/tests/unit/test_fileset.py

@@ -1,48 +0,0 @@
-import asyncio
-import io
-import os
-import dataclasses as dc
-import pytest
-from typing import List
-import yaml
-from dv_flow_mgr import FileSet, PackageDef, Session, TaskData
-from pydantic import BaseModel
-from shutil import copytree
-
-def test_fileset_1(tmpdir):
-    """"""
-    datadir = os.path.join(os.path.dirname(__file__), "data/fileset")
-
-    copytree(
-        os.path.join(datadir, "test1"), 
-        os.path.join(tmpdir, "test1"))
-    
-    session = Session(
-        os.path.join(tmpdir, "test1"),
-        os.path.join(tmpdir, "rundir"))
-    session.load()
-
-    out = asyncio.run(session.run("test1.files1"))
-    assert out.changed == True
-
-    # Now, re-run using the same run directory.
-    # Since the files haven't changed, the output must indicate that
-    session = Session(
-        os.path.join(tmpdir, "test1"),
-        os.path.join(tmpdir, "rundir"))
-    session.load()
-
-    out = asyncio.run(session.run("test1.files1"))
-    assert out.changed == False
-
-    # Now, manually change one of the files
-    with open(os.path.join(tmpdir, "test1", "files1", "file1_1.sv"), "w") as f:
-        f.write("// file1_1.sv\n")
-
-    session = Session(
-        os.path.join(tmpdir, "test1"),
-        os.path.join(tmpdir, "rundir"))
-    session.load()
-
-    out = asyncio.run(session.run("test1.files1"))
-    assert out.changed == True

dv_flow_mgr-0.0.1.12911707440a1/tests/unit/test_stdlib.py

@@ -1,27 +0,0 @@
-import os
-import asyncio
-import pytest
-from dv_flow_mgr import Session, TaskData
-
-def test_message(tmpdir, capsys):
-    flow = """
-package:
-  name: pkg1
-  tasks:
-  - name: foo
-    uses: std.Message
-    with:
-      msg: "Hello, World!"
-"""
-
-    with open(os.path.join(tmpdir, "flow.dv"), "w") as f:
-        f.write(flow)
-
-    rundir = os.path.join(tmpdir, "rundir")
-    session = Session(os.path.join(tmpdir), rundir)
-    session.load()
-
-    output = asyncio.run(session.run("pkg1.foo"))
-
-    captured = capsys.readouterr()
-    assert captured.out.find("Hello, World!") >= 0