dv-flow-mgr 0.0.1.13468776985a1__py3-none-any.whl → 0.0.1.13489806632a1__py3-none-any.whl

dv_flow/mgr/package.py

@@ -22,7 +22,7 @@
 import dataclasses as dc
 import logging
 from typing import Any, ClassVar, Dict
-from .task import TaskCtor
+from .task_ctor import TaskCtor
 
 @dc.dataclass
 class Package(object):

dv_flow/mgr/package_def.py

@@ -33,7 +33,8 @@ from typing import Any, Dict, List, Callable, Tuple, ClassVar
 from .fragment_def import FragmentDef
 from .package import Package
 from .package_import_spec import PackageImportSpec, PackageSpec
-from .task import TaskCtor, TaskCtorProxy, TaskCtorCls, TaskCtorParam, TaskCtorParamCls
+#from .task import TaskCtorCls, TaskCtorParam, TaskCtorParamCls
+from .task_ctor import TaskCtor
 from .task_def import TaskDef, TaskSpec
 from .std.task_null import TaskNull
 from .type_def import TypeDef

dv_flow/mgr/task.py

@@ -27,174 +27,156 @@ from pydantic import BaseModel
 from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task_data import TaskData, TaskDataInput, TaskDataOutput, TaskDataResult
 from .task_memento import TaskMemento
+from .task_ctor import TaskParamsCtor
+from .task_params_ctor import TaskParamsCtor
+from .task_runner import TaskRunner
 
-@dc.dataclass
-class TaskSpec(object):
-    name : str
+# @dc.dataclass
+# class TaskSpec(object):
+#     name : str
 
-class TaskParams(BaseModel):
-    pass
+# class TaskParams(BaseModel):
+#     pass
 
 
-@dc.dataclass
-class TaskCtor(object):
-    name : str
-    uses : 'TaskCtor' = None
-    srcdir : str = None
-    depends : List[TaskSpec] = dc.field(default_factory=list)
-
-    _log : ClassVar = logging.getLogger("TaskCtor")
-
-    def mkTask(self, name : str, depends, rundir, srcdir=None, params=None):
-        if srcdir is None:
-            srcdir = self.srcdir
-        if params is None:
-            params = self.mkParams()
-
-        if self.uses is not None:
-            return self.uses.mkTask(name, depends, rundir, srcdir, params)
-        else:
-            raise NotImplementedError("TaskCtor.mkTask() not implemented for %s" % str(type(self)))
-    
-    def mkParams(self):
-        self._log.debug("--> %s::mkParams" % self.name)
-        if self.uses is not None:
-            params = self.uses.mkParams()
-        else:
-            params = TaskParams()
-        self._log.debug("<-- %s::mkParams: %s" % (self.name, str(params)))
+# @dc.dataclass
+# class TaskCtorParam(TaskCtor):
+#     params : Dict[str,Any] = dc.field(default_factory=dict)
 
-        return params
+#     _log : ClassVar = logging.getLogger("TaskCtorParam")
 
-    def applyParams(self, params):
-        if self.uses is not None:
-            self.uses.applyParams(params)
+#     def mkTask(self, name : str, depends, rundir, srcdir=None, params=None):
+#         self._log.debug("--> %s::mkTask" % self.name)
+#         if params is None:
+#             params = self.mkParams()
+#         if srcdir is None:
+#             srcdir = self.srcdir
 
+#         ret = self.uses.mkTask(name, depends, rundir, srcdir, params)
 
-@dc.dataclass
-class TaskCtorParam(TaskCtor):
-    params : Dict[str,Any] = dc.field(default_factory=dict)
-
-    _log : ClassVar = logging.getLogger("TaskCtorParam")
-
-    def mkTask(self, name : str, depends, rundir, srcdir=None, params=None):
-        self._log.debug("--> %s::mkTask" % self.name)
-        if params is None:
-            params = self.mkParams()
-        if srcdir is None:
-            srcdir = self.srcdir
-
-        ret = self.uses.mkTask(name, depends, rundir, srcdir, params)
-
-        self.applyParams(ret.params)
-        self._log.debug("<-- %s::mkTask" % self.name)
-
-        return ret
-
-    def applyParams(self, params):
-        self._log.debug("--> %s::applyParams: %s %s" % (self.name, str(type(self.params)), str(type(params))))
-        if self.params is not None:
-            for k,v in self.params.items():
-                self._log.debug("  change %s %s=>%s" % (
-                    k, 
-                    str(getattr(params, k)),
-                    str(v)))
-                setattr(params, k, v)
-        else:
-            self._log.debug("  no params")
-        self._log.debug("<-- %s::applyParams: %s" % (self.name, str(self.params)))
+#         self.applyParams(ret.params)
+#         self._log.debug("<-- %s::mkTask" % self.name)
 
-@dc.dataclass
-class TaskCtorParamCls(TaskCtor):
-    params_ctor : Callable = None
+#         return ret
 
-    _log : ClassVar = logging.getLogger("TaskCtorParamType")
+#     def applyParams(self, params):
+#         self._log.debug("--> %s::applyParams: %s %s" % (self.name, str(type(self.params)), str(type(params))))
+#         if self.params is not None:
+#             for k,v in self.params.items():
+#                 self._log.debug("  change %s %s=>%s" % (
+#                     k, 
+#                     str(getattr(params, k)),
+#                     str(v)))
+#                 setattr(params, k, v)
+#         else:
+#             self._log.debug("  no params")
+#         self._log.debug("<-- %s::applyParams: %s" % (self.name, str(self.params)))
 
-    def mkParams(self):
-        self._log.debug("--> %s::mkParams" % str(self.name))
-        params = self.params_ctor()
-        self._log.debug("<-- %s::mkParams: %s" % (str(self.name), str(type(params))))
-        return params
+# @dc.dataclass
+# class TaskCtorParamCls(TaskCtor):
+#     params_ctor : Callable = None
 
-@dc.dataclass
-class TaskCtorCls(TaskCtor):
-    task_ctor : Callable = None
+#     _log : ClassVar = logging.getLogger("TaskCtorParamType")
 
-    _log : ClassVar = logging.getLogger("TaskCtorCls")
+#     def mkParams(self):
+#         self._log.debug("--> %s::mkParams" % str(self.name))
+#         params = self.params_ctor()
+#         self._log.debug("<-- %s::mkParams: %s" % (str(self.name), str(type(params))))
+#         return params
 
-    def mkTask(self, name : str, depends, rundir, srcdir=None, params=None):
-        self._log.debug("--> %s::mkTask (%s) srcdir=%s" % (self.name, str(self.task_ctor), srcdir))
+# @dc.dataclass
+# class TaskCtorCls(TaskCtor):
+#     task_ctor : Callable = None
 
-        if srcdir is None:
-            srcdir = self.srcdir
+#     _log : ClassVar = logging.getLogger("TaskCtorCls")
 
-        if params is None:
-            params = self.mkParams()
+#     def mkTask(self, name : str, depends, rundir, srcdir=None, params=None):
+#         self._log.debug("--> %s::mkTask (%s) srcdir=%s" % (self.name, str(self.task_ctor), srcdir))
 
-        ret = self.task_ctor(
-            name=name, 
-            depends=depends, 
-            rundir=rundir, 
-            srcdir=srcdir, 
-            params=params)
+#         if srcdir is None:
+#             srcdir = self.srcdir
 
-        # Update parameters on the way back
-        self.applyParams(ret.params)
+#         if params is None:
+#             params = self.mkParams()
 
-        self._log.debug("<-- %s::mkTask" % self.name)
-        return ret
+#         ret = self.task_ctor(
+#             name=name, 
+#             depends=depends, 
+#             rundir=rundir, 
+#             srcdir=srcdir, 
+#             params=params)
 
-@dc.dataclass
-class TaskCtorProxy(TaskCtor):
-    task_ctor : TaskCtor = None
-    param_ctor : Callable = None
+#         # Update parameters on the way back
+#         self.applyParams(ret.params)
+
+#         self._log.debug("<-- %s::mkTask" % self.name)
+#         return ret
 
-    _log : ClassVar = logging.getLogger("TaskCtorProxy")
+# @dc.dataclass
+# class TaskCtorProxy(TaskCtor):
+#     task_ctor : TaskCtor = None
+#     param_ctor : Callable = None
 
-    def mkTask(self, *args, **kwargs):
-        self._log.debug("--> %s::mkTask" % self.name)
-        ret = self.task_ctor.mkTask(*args, **kwargs)
-        self._log.debug("<-- %s::mkTask" % self.name)
-        return ret
+#     _log : ClassVar = logging.getLogger("TaskCtorProxy")
 
-    def mkParams(self, params=None):
-        self._log.debug("--> %s::mkParams: %s" % (self.name, str(self.params)))
+#     def mkTask(self, *args, **kwargs):
+#         self._log.debug("--> %s::mkTask" % self.name)
+#         ret = self.task_ctor.mkTask(*args, **kwargs)
+#         self._log.debug("<-- %s::mkTask" % self.name)
+#         return ret
 
-        if params is None and self.param_ctor is not None:
-            params = self.param_ctor()
+#     def mkParams(self, params=None):
+#         self._log.debug("--> %s::mkParams: %s" % (self.name, str(self.params)))
 
-        params = self.task_ctor.mkParams(params)
+#         if params is None and self.param_ctor is not None:
+#             params = self.param_ctor()
 
-        if self.params is not None:
-            for k,v in self.params.items():
-                self._log.debug("  change %s %s=>%s" % (
-                    k, 
-                    str(getattr(params, k)),
-                    str(v)))
-                setattr(params, k, v)
-        self._log.debug("<-- %s::mkParams: %s" % (self.name, str(self.params)))
-        return params
+#         params = self.task_ctor.mkParams(params)
+
+#         if self.params is not None:
+#             for k,v in self.params.items():
+#                 self._log.debug("  change %s %s=>%s" % (
+#                     k, 
+#                     str(getattr(params, k)),
+#                     str(v)))
+#                 setattr(params, k, v)
+#         self._log.debug("<-- %s::mkParams: %s" % (self.name, str(self.params)))
+#         return params
 
 
 @dc.dataclass
 class Task(object):
     """Executable view of a task"""
+    # Ctor fields -- must specify on construction
     name : str
+    srcdir : str
+    params : TaskParamsCtor 
 
-    # Need TaskDef 
-
-    params : TaskParams # Might need to be set of instructions for building...
-    # This needs to be 'inside out' -- listed bottom to top
-    srcdir : str = dc.field(default=None)
-    rundir : str = dc.field(default=None)
-    depends    : List['Task'] = dc.field(default_factory=list)
+    # Runtime fields -- these get populated during execution
+    changed : bool = False
+    needs : List['Task'] = dc.field(default_factory=list)
     dependents : List['Task'] = dc.field(default_factory=list)
+    rundir : str = dc.field(default=None)
     output : TaskDataOutput = dc.field(default=None)
 
     _log : ClassVar = logging.getLogger("Task")
 
-    async def run(self, 
-                  input : TaskDataInput,
-                  runner : 'TaskGraphRunner') -> TaskDataResult:
+    async def run(self,
+                  runner : 'TaskRunner',
+                  input : TaskDataInput) -> TaskDataResult:
         raise NotImplementedError("TaskImpl.run() not implemented")
+    
+    @staticmethod
+    def ctor(paramT):
+        def wrapper(T):
+            def mk_task(name, srcdir, params):
+                return T(name, srcdir, params)
+            def mk_params(**params):
+                ctor = TaskParamsCtor(paramT)
+                ctor.values.append(paramT(**params))
+                return ctor
+            T.mkTask = mk_task
+            T.mkParams = mk_params
+            return T
+        return wrapper
 

dv_flow/mgr/task_ctor.py

@@ -0,0 +1,43 @@
+import os
+import json
+import dataclasses as dc
+import logging
+from pydantic import BaseModel
+from typing import Any, Callable, ClassVar, Dict, List, Tuple
+from .task_data import TaskDataOutput, TaskDataResult
+
+# TaskParamsCtor accepts an evaluation context and returns a task parameter object
+TaskParamsCtor = Callable[[object], Any]
+
+@dc.dataclass
+class TaskCtor(object):
+    name : str
+    uses : 'TaskCtor' = None
+    srcdir : str = None
+
+    _log : ClassVar = logging.getLogger("TaskCtor")
+
+    def mkTask(self, name : str, srcdir=None) -> 'Task':
+        """Creates a task object"""
+        if srcdir is None:
+            srcdir = self.srcdir
+
+        if self.uses is not None:
+            return self.uses.mkTask(name, srcdir)
+        else:
+            raise NotImplementedError("TaskCtor.mkTask() not implemented for %s" % str(type(self)))
+    
+    def mkParams(self, params=None) -> TaskParamsCtor:
+        """Creates a list of task-parameter objects used produce the params object"""
+        self._log.debug("--> %s::mkParams" % self.name)
+        if self.uses is not None:
+            params = self.uses.mkParams()
+        else:
+            params = TaskParams()
+        self._log.debug("<-- %s::mkParams: %s" % (self.name, str(params)))
+
+        return params
+
+    def applyParams(self, params):
+        if self.uses is not None:
+            self.uses.applyParams(params)

dv_flow/mgr/task_data.py

@@ -27,6 +27,16 @@ from typing import Any, ClassVar, Dict, Set, List, Tuple
 from .fileset import FileSet
 from toposort import toposort
 
+class TaskMarkerLoc(BaseModel):
+    path : str
+    line : int = dc.Field(default=-1)
+    pos : int = dc.Field(default=-1)
+
+class TaskMarker(BaseModel):
+    msg : str
+    severity : str
+    loc : TaskMarkerLoc = dc.Field(default=None)
+
 class TaskDataInput(BaseModel):
     changed : bool
     srcdir : str
@@ -35,11 +45,11 @@ class TaskDataInput(BaseModel):
     memento : Any
 
 class TaskDataResult(BaseModel):
-    changed : bool
-    output : List[Any]
-    memento : Any
-    markers : List[Any]
-    status : int
+    changed : bool = dc.Field(default=True)
+    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

dv_flow/mgr/task_def.py

@@ -40,7 +40,7 @@ class TaskDef(BaseModel):
     doc : str = dc.Field(default="")
     depends : List[Union[str,TaskSpec]] = dc.Field(default_factory=list, alias="needs")
     params: List[ParamDef] = dc.Field(default_factory=list, alias="with")
-    out: List[TaskOutput] = dc.Field(default_factory=list)
+#    out: List[TaskOutput] = dc.Field(default_factory=list)
 
     def copy(self) -> 'TaskDef':
         ret = TaskDef(

dv_flow/mgr/task_graph_builder.py

@@ -25,7 +25,7 @@ import logging
 from .package import Package
 from .package_def import PackageDef, PackageSpec
 from .pkg_rgy import PkgRgy
-from .task import Task, TaskCtor, TaskSpec
+from .task import Task
 from typing import Dict, List
 
 @dc.dataclass
@@ -37,7 +37,7 @@ class TaskGraphBuilder(object):
     _pkg_s : List[Package] = dc.field(default_factory=list)
     _pkg_m : Dict[PackageSpec,Package] = dc.field(default_factory=dict)
     _pkg_spec_s : List[PackageDef] = dc.field(default_factory=list)
-    _task_m : Dict[TaskSpec,Task] = dc.field(default_factory=dict)
+    _task_m : Dict['TaskSpec',Task] = dc.field(default_factory=dict)
     _logger : logging.Logger = None
 
     def __post_init__(self):
@@ -173,7 +173,7 @@ class TaskGraphBuilder(object):
 
         return pkg
         
-    def getTaskCtor(self, spec : TaskSpec, pkg : PackageDef = None) -> 'TaskCtor':
+    def getTaskCtor(self, spec : 'TaskSpec', pkg : PackageDef = None) -> 'TaskCtor':
         self._logger.debug("--> getTaskCtor %s" % spec.name)
         spec_e = spec.name.split(".")
         task_name = spec_e[-1]

dv_flow/mgr/task_graph_runner.py

@@ -21,20 +21,19 @@
 #****************************************************************************
 import asyncio
 import os
-import yaml
 import dataclasses as dc
-from typing import Any, Callable, ClassVar, Dict, List
+from typing import Any, Callable, ClassVar, Dict, List, Tuple
 from .task import Task
 from .task_data import TaskData
+from .task_runner import TaskRunner
 
 @dc.dataclass
-class TaskGraphRunner(object):
+class TaskGraphRunner(TaskRunner):
     """Session manages execution of a task graph"""
 
-    rundir : str
-
     _inst : ClassVar['TaskGraphRunner'] = None
 
+
     # Search path for .dfs files
     create_subprocess : Callable = asyncio.create_subprocess_exec
     _root_dir : str = None

dv_flow/mgr/task_graph_runner_local.py

@@ -30,7 +30,7 @@ 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 import Task
 from .task_data import TaskData
 from .task_graph_runner import TaskGraphRunner
 

dv_flow/mgr/task_node.py

@@ -0,0 +1,80 @@
+
+import dataclasses as dc
+import logging
+from typing import Any, Callable, ClassVar, Dict, List
+from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
+from .task_params_ctor import TaskParamsCtor
+
+@dc.dataclass
+class TaskNode(object):
+    """Executable view of a task"""
+    # Ctor fields -- must specify on construction
+    name : str
+    srcdir : str
+    # This can be the resolved parameters
+    params : TaskParamsCtor 
+
+    task : Callable[['TaskRunner','TaskDataInput'],'TaskDataResult']
+
+    # Runtime fields -- these get populated during execution
+    changed : bool = False
+    needs : List['TaskNode'] = dc.field(default_factory=list)
+    rundir : str = dc.field(default=None)
+    output : TaskDataOutput = dc.field(default=None)
+
+    _log : ClassVar = logging.getLogger("TaskNode")
+
+    def __hash__(self):
+        return id(self)
+    
+@staticmethod
+def task(paramT):
+    def wrapper(T):
+        ctor = TaskNodeCtorWrapper(T.__name__, T, paramT)
+        return ctor
+    return wrapper
+
+@dc.dataclass
+class TaskNodeCtor(object):
+    """
+    Factory for a specific task type
+    - Produces a task parameters object, applying value-setting instructions
+    - Produces a TaskNode
+    """
+    name : str
+
+
+    def mkTaskNode(self, srcdir, params, name=None) -> TaskNode:
+        raise NotImplementedError("mkTaskNode in type %s" % str(type(self)))
+
+    def mkTaskParams(self, params : Dict) -> Any:
+        raise NotImplementedError("mkTaskParams in type %s" % str(type(self)))
+
+@dc.dataclass
+class TaskNodeCtorWrapper(TaskNodeCtor):
+    T : Any
+    paramT : Any
+
+    def __call__(self, 
+                 srcdir, 
+                 name=None, 
+                 params=None, 
+                 needs=None,
+                 **kwargs):
+        """Convenience method for direct creation of tasks"""
+        if params is None:
+            params = self.mkTaskParams(kwargs)
+        
+        node = self.mkTaskNode(srcdir, params, name)
+        if needs is not None:
+            node.needs.extend(needs)
+        return node
+
+    def mkTaskNode(self, srcdir, params, name=None) -> TaskNode:
+        node = TaskNode(name, srcdir, params, self.T)
+        return node
+
+    def mkTaskParams(self, params : Dict) -> Any:
+        obj = self.paramT()
+        # TODO: apply user-specified params
+        return obj

dv_flow/mgr/task_params_ctor.py

@@ -0,0 +1,31 @@
+import dataclasses as dc
+from typing import Any, List
+
+
+@dc.dataclass
+class TaskParamsCtor(object):
+
+    paramT : Any = None
+    # List of parameter-setting sets, starting with inner-most
+    values : List[Any] = dc.field(default_factory=list)
+
+    def mk(self, input) -> Any:
+        params = self.paramT()
+
+        # Now, process each field 
+        for field in dc.fields(self.paramT):
+            # Find the outer-most setting of the value
+            last_value_i = -1
+            for i in range(len(self.values)-1, -1, -1):
+                if hasattr(self.values[i], field.name) and getattr(self.values[i], field.name) is not None:
+                    val = getattr(self.values[i], field.name)
+                    # TODO: check if 'val' is a set or mutator
+                    last_value_i = i
+                    break
+            for i in range(last_value_i, -1, -1):
+                if hasattr(self.values[i], field.name):
+                    val = getattr(self.values[i], field.name)
+                    setattr(params, field.name, val)
+
+        print("params: %s" % str(params))
+        return params

dv_flow/mgr/task_runner.py

@@ -0,0 +1,162 @@
+import asyncio
+import dataclasses as dc
+from toposort import toposort
+from typing import Any, Callable, List, Tuple, Union
+from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
+from .task_node import TaskNode
+
+@dc.dataclass
+class TaskRunner(object):
+    rundir : str
+
+    # List of [Listener:Callable[Task],Recurisve:bool]
+    listeners : List[Tuple[Callable['Task','Reason'], bool]] = dc.field(default_factory=list)
+
+    async def do_run(self, 
+                  task : 'Task',
+                  memento : Any = None) -> 'TaskDataResult':
+        return await self.run(task, memento)
+
+    async def run(self, 
+                  task : 'Task',
+                  memento : Any = None) -> 'TaskDataResult':
+        pass
+
+@dc.dataclass
+class TaskSetRunner(TaskRunner):
+    nproc : int = 8
+
+    async def run(self, task : Union[TaskNode,List[TaskNode]]):
+        # First, build a depedency map
+        tasks = task if isinstance(task, list) else [task]
+        dep_m = {}
+        for t in tasks:
+            self._buildDepMap(dep_m, t)
+
+        print("dep_m: %s" % str(dep_m))
+
+        order = list(toposort(dep_m))
+
+        active_task_l = []
+        done_task_s = set()
+        for active_s in order:
+            done = True
+            for t in active_s:
+                while len(active_task_l) >= self.nproc and t not in done_task_s:
+                    # Wait for at least one job to complete
+                    done, pending = await asyncio.wait(at[1] for at in active_task_l)
+                    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]
+                                done_task_s.add(tt)
+                                active_task_l.pop(i)
+                                break
+                if t not in done_task_s:
+                    coro = asyncio.Task(self.do_run(t))
+                    active_task_l.append((t, 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)
+
+
+        pass
+
+    async def do_run(self, 
+                  task : 'TaskNode',
+                  memento : Any = None) -> 'TaskDataResult':
+        changed = False
+        for dep in task.needs:
+            changed |= dep.changed
+
+        # TODO: create an evaluator for substituting param values
+        eval = None
+
+        for field in dc.fields(task.params):
+            print("Field: %s" % field.name)
+
+        input = TaskDataInput(
+            changed=changed,
+            srcdir=task.srcdir,
+            rundir=self.rundir,
+            params=task.params,
+            memento=memento)
+
+        # TODO: notify of task start
+        ret : TaskDataResult = await task.task(self, input)
+        # TODO: notify of task complete
+
+        # Store the result
+        task.output = TaskDataOutput(
+            changed=ret.changed,
+            output=ret.output.copy())
+
+        # # By definition, none of this have run, since we just ran        
+        # for dep in task.dependents:
+        #     is_sat = True
+        #     for need in dep.needs:
+        #         if need.output is None:
+        #             is_sat = False
+        #             break
+            
+        #     if is_sat:
+        #         # TODO: queue task for evaluation
+        #     pass
+        # TODO: 
+
+        return ret
+
+    def _buildDepMap(self, dep_m, task : TaskNode):
+        if task not in dep_m.keys():
+            dep_m[task] = set(task.needs)
+            for need in task.needs:
+                self._buildDepMap(dep_m, need)
+
+@dc.dataclass
+class SingleTaskRunner(TaskRunner):
+
+    async def run(self, 
+                  task : 'Task',
+                  memento : Any = None) -> 'TaskDataResult':
+        changed = False
+        for dep in task.needs:
+            changed |= dep.changed
+
+        # TODO: create an evaluator for substituting param values
+        eval = None
+
+        for field in dc.fields(task.params):
+            print("Field: %s" % field.name)
+
+        input = TaskDataInput(
+            changed=changed,
+            srcdir=task.srcdir,
+            rundir=self.rundir,
+            params=task.params,
+            memento=memento)
+
+        # TODO: notify of task start
+        ret : TaskDataResult = await task.task(self, input)
+        # TODO: notify of task complete
+
+        # Store the result
+        task.output = TaskDataOutput(
+            changed=ret.changed,
+            output=ret.output.copy())
+
+        # # By definition, none of this have run, since we just ran        
+        # for dep in task.dependents:
+        #     is_sat = True
+        #     for need in dep.needs:
+        #         if need.output is None:
+        #             is_sat = False
+        #             break
+            
+        #     if is_sat:
+        #         # TODO: queue task for evaluation
+        #     pass
+        # TODO: 
+
+        return ret

{dv_flow_mgr-0.0.1.13468776985a1.dist-info → dv_flow_mgr-0.0.1.13489806632a1.dist-info}/METADATA

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

@@ -5,22 +5,26 @@ dv_flow/mgr/expr_parser.py,sha256=aR8n6hgk5xmFknIaSVC02K-So-eU4pkkFtwb7zWsSPs,54
 dv_flow/mgr/fileset.py,sha256=FNvC5sU2ArxJ0OO3v8dXTv8zX-bZ5t0a0ljne0fQQ1o,1150
 dv_flow/mgr/fragment_def.py,sha256=cyzp1XeWtNOaagScmeS-BPsoXj9j2LTBbKq5ZUioz8I,1641
 dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
-dv_flow/mgr/package.py,sha256=MDnt9q4pD_Aex_hSK_EUQ38IiaxOihgxbMmk5dH1deQ,1674
-dv_flow/mgr/package_def.py,sha256=Sv3KS5pDysUrtPBWElCvmWt2pnkTipZcZGYwKr5N7Mc,14967
+dv_flow/mgr/package.py,sha256=878twhPD-E1pFlDNUtuyeFEgJ_Y89b560og4St-Iwrs,1679
+dv_flow/mgr/package_def.py,sha256=dwvs-7kGEp7wFrBK2Fybysb-vSKwtWOtxTrg1VIaL14,14975
 dv_flow/mgr/package_import_spec.py,sha256=ah3r15v5Jdub2poc3sgi6Uar1L3oGoYsCPPNiOHV-a4,1760
 dv_flow/mgr/param_def.py,sha256=e2WvRCMArbgcsKC4TKQqZTscZmCdo3WvVR6w3LN0VK8,727
 dv_flow/mgr/parsetab.py,sha256=enSOnMQ-woIsMEzHyeYiefvhAl8enxfX9Ct_o8-jkqs,3780
 dv_flow/mgr/pkg_rgy.py,sha256=2R_EaeBDJn5qUq9DzSnLc37wUP36MWSv-p0LgUjJRAg,4471
-dv_flow/mgr/task.py,sha256=jZrxTevSulUQ56RdgD0TQXrQ05859FgmXahOdxhdyT8,6349
-dv_flow/mgr/task_data.py,sha256=TCc5KYuKoQNYfemVOzIlNKkMKIw-cqVl5_EmDs03W7M,10718
-dv_flow/mgr/task_def.py,sha256=6qDDgge5RXssL5TAZR01dGb_Vjvbj72tJirg66O-Yt4,1818
+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=fkaVzQ81nJBXy4uPWPdnVCNoD9L7rvH5Abt8LXzvnJs,11098
+dv_flow/mgr/task_def.py,sha256=WAW1fPXUfUiQcfmgCx0iCMddMBKATDa5RsRztJWRbUk,1819
 dv_flow/mgr/task_exec_data.py,sha256=aT__kmVmNxqnS_GbTRS1vrYgKiv8cH-HUSmRb6YYKsI,640
-dv_flow/mgr/task_graph_builder.py,sha256=4dfy_T26MYI7ls2xiofr4V0ItZHDehU2iw6UBPt-SZQ,7074
-dv_flow/mgr/task_graph_runner.py,sha256=NwNYcOJ952lPMLwIIlYE9CoDdedqvcw2fWHYUsKFXuU,2164
-dv_flow/mgr/task_graph_runner_local.py,sha256=66JYJcu-W60LjfuT9UkbcKslNqDcD5q4UR7ZAWrSaGM,4707
+dv_flow/mgr/task_graph_builder.py,sha256=-lRSjWU2UJf3euVIFtoVIU7Qdox7MI1sKERWg1k7U_g,7058
+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_memento.py,sha256=C7VTQpBhDEoYuDmE6YTM-6TLMLnqHp6Y0Vat1aTgtCs,1096
+dv_flow/mgr/task_node.py,sha256=wcvxdtrRNwPwV494DerrB79PFYAv6bPdWZDvRGQ0V6Q,2318
 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=5vCKM2UFxdHB9OslUVIx5Ipc0r04Cizvrc2YSKGMqqI,5055
 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
@@ -30,9 +34,9 @@ dv_flow/mgr/std/fileset.py,sha256=uP7bGntRq-Tn5_GEFnt0_J_OAmfvep3GlCwCuE8by4o,27
 dv_flow/mgr/std/flow.dv,sha256=j9wLrF3Ghh1ZLbJxmk7WiNiRYUYEer-8CCUA5hsgtfk,1409
 dv_flow/mgr/std/message.py,sha256=BPTHnEMD4tBufQ9LvsS9Sa_0xjaJATbBpwqosWslvVA,193
 dv_flow/mgr/std/task_null.py,sha256=KObmjG_4D08GJ1k6neqKIQrFY72Sj0jLnwXxEkq5HA0,321
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/METADATA,sha256=C2BOmVhhEQfwS9QQ9reuEWFsP9uWupVItzxnL5lilJc,13276
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
-dv_flow_mgr-0.0.1.13468776985a1.dist-info/RECORD,,
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/METADATA,sha256=iGQC00bCbcchWcesU4kXOBNBn-ggHWurn1YqLBKB610,13276
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-0.0.1.13489806632a1.dist-info/RECORD,,