dv-flow-mgr 0.0.1.13979842530a1__py3-none-any.whl → 0.0.1.14097297609a1__py3-none-any.whl

dv_flow/mgr/task_node_leaf.py

@@ -0,0 +1,170 @@
+import enum
+import os
+import sys
+import dataclasses as dc
+import pydantic.dataclasses as pdc
+import logging
+import toposort
+from typing import Any, Callable, ClassVar, Dict, List, Tuple
+from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
+from .task_node import TaskNode
+from .task_params_ctor import TaskParamsCtor
+from .param_ref_eval import ParamRefEval
+from .param import Param
+
+@dc.dataclass
+class TaskNodeLeaf(TaskNode):
+    task : Callable[['TaskRunner','TaskDataInput'],'TaskDataResult'] = dc.field(default=None)
+
+    async def do_run(self, 
+                  runner,
+                  rundir,
+                  memento : Any = None) -> 'TaskDataResult':
+        self._log.debug("--> do_run: %s" % self.name)
+        changed = False
+        for dep,_ in self.needs:
+            changed |= dep.changed
+
+        self.rundir = rundir
+
+        # TODO: Form dep-map from inputs
+
+        dep_m = {}
+        for need,block in self.needs:
+            self._log.debug("dep %s dep_m: %s" % (need.name, str(dep_m)))
+            if not block:
+                for subdep in need.output.dep_m.keys():
+                    if subdep not in dep_m.keys():
+                        dep_m[subdep] = []
+                    for dep in need.output.dep_m[subdep]:
+                        if dep not in dep_m[subdep]:
+                            dep_m[subdep].append(dep)
+        self._log.debug("input dep_m: %s %s" % (self.name, str(dep_m)))
+
+        sorted = toposort.toposort(dep_m)
+
+        in_params_m = {}
+        added_srcs = set()
+        for need,block in self.needs:
+            self._log.debug("Process need=%s block=%s" % (need.name, block))
+            if not block:
+                for p in need.output.output:
+
+                    # Avoid adding parameters from a single task more than once
+                    key = (p.src, p.seq)
+                    if key not in added_srcs:
+                        added_srcs.add(key)
+                        if p.src not in in_params_m.keys():
+                            in_params_m[p.src] = []
+                        in_params_m[p.src].append(p)
+
+        # in_params holds parameter sets ordered by dependency
+        in_params = []
+        for sorted_s in sorted:
+            self._log.debug("sorted_s: %s" % str(sorted_s))
+            for dep in sorted_s:
+                if dep in in_params_m.keys():
+                    self._log.debug("(%s) Extend with: %s" % (dep, str(in_params_m[dep])))
+                    in_params.extend(in_params_m[dep])
+
+        self._log.debug("in_params[1]: %s" % ",".join(p.src for p in in_params))
+
+        # Create an evaluator for substituting param values
+        eval = ParamRefEval()
+
+        self._log.debug("in_params[2]: %s" % ",".join(p.src for p in in_params))
+        eval.setVar("in", in_params)
+        eval.setVar("rundir", rundir)
+
+        # Set variables from the inputs
+        for need in self.needs:
+            for name,value in {"rundir" : need[0].rundir}.items():
+                eval.setVar("%s.%s" % (need[0].name, name), value)
+
+        # Default inputs is the list of parameter sets that match 'consumes'
+        inputs = []
+        if self.consumes is not None and len(self.consumes):
+            for in_p in in_params:
+                if self._matches(in_p, self.consumes):
+                    inputs.append(in_p)
+
+        for name,field in self.params.model_fields.items():
+            value = getattr(self.params, name)
+            if type(value) == str:
+                if value.find("${{") != -1:
+                    new_val = eval.eval(value)
+                    self._log.debug("Param %s: Evaluate expression \"%s\" => \"%s\"" % (name, value, new_val))
+                    setattr(self.params, name, new_val)
+            elif isinstance(value, list):
+                for i,elem in enumerate(value):
+                    if elem.find("${{") != -1:
+                        new_val = eval.eval(elem)
+                        value[i] = new_val
+
+        input = TaskDataInput(
+            name=self.name,
+            changed=changed,
+            srcdir=self.srcdir,
+            rundir=rundir,
+            params=self.params,
+            inputs=inputs,
+            memento=memento)
+
+        self._log.debug("--> Call task method %s" % str(self.task))
+        self.result : TaskDataResult = await self.task(self, input)
+        self._log.debug("<-- Call task method %s" % str(self.task))
+
+        output=self.result.output.copy()
+        for i,out in enumerate(output):
+            out.src = self.name
+            out.seq = i
+
+        self._log.debug("output[1]: %s" % str(output))
+
+        # Pass-through all dependencies
+        # Add an entry for ourselves
+        dep_m[self.name] = list(need.name for need,_ in self.needs)
+
+        if self.passthrough:
+            self._log.debug("passthrough: %s" % self.name)
+
+            if self.consumes is None or len(self.consumes) == 0:
+                self._log.debug("Propagating all input parameters to output")
+                for need,block in self.needs:
+                    if not block:
+                        output.extend(need.output.output)
+            else:
+                # Filter out parameter sets that were consumed
+                self._log.debug("Propagating non-consumed input parameters to output")
+                self._log.debug("consumes: %s" % str(self.consumes))
+                for need,block in self.needs:
+                    if not block:
+                        for out in need.output.output:
+                            if not self._matches(out, self.consumes):
+                                self._log.debug("Propagating type %s from %s" % (
+                                    getattr(out, "type", "<unknown>"),
+                                    getattr(out, "src", "<unknown>")))
+                                output.append(out)
+        else:
+            self._log.debug("non-passthrough: %s (only local outputs propagated)" % self.name)
+            # empty dependency map
+#            dep_m = {
+#                self.name : []
+#            }
+
+        self._log.debug("output dep_m: %s %s" % (self.name, str(dep_m)))
+        self._log.debug("output[2]: %s" % str(output))
+
+        # Store the result
+        self.output = TaskDataOutput(
+            changed=self.result.changed,
+            dep_m=dep_m,
+            output=output)
+
+        # TODO: 
+        self._log.debug("<-- do_run: %s" % self.name)
+
+        return self.result
+
+    def __hash__(self):
+        return id(self)

dv_flow/mgr/task_runner.py

@@ -27,7 +27,7 @@ import dataclasses as dc
 import logging
 from datetime import datetime
 from toposort import toposort
-from typing import Any, Callable, ClassVar, List, Tuple, Union
+from typing import Any, Callable, ClassVar, Dict, List, Set, Tuple, Union
 from .task_data import TaskDataInput, TaskDataOutput, TaskDataResult
 from .task_node import TaskNode, RundirE
 
@@ -92,11 +92,7 @@ class TaskSetRunner(TaskRunner):
 
 
         # First, build a depedency map
-        tasks = task if isinstance(task, list) else [task]
-        dep_m = {}
-        self._anon_tid = 1
-        for t in tasks:
-            self._buildDepMap(dep_m, t)
+        dep_m = self.buildDepMap(task)
 
         if self._log.isEnabledFor(logging.DEBUG):
             self._log.debug("Deps:")
@@ -191,6 +187,15 @@ class TaskSetRunner(TaskRunner):
             return list(t.output for t in task)
         else:
             return task.output
+        
+    def buildDepMap(self, task : Union[TaskNode, List[TaskNode]]) -> Dict[TaskNode, Set[TaskNode]]:
+        tasks = task if isinstance(task, list) else [task]
+        dep_m = {}
+        self._anon_tid = 1
+        for t in tasks:
+            self._buildDepMap(dep_m, t)
+
+        return dep_m
 
     def _buildDepMap(self, dep_m, task : TaskNode):
         if task.name is None:

dv_flow/mgr/util/__init__.py

@@ -0,0 +1,3 @@
+
+from .util import *
+

dv_flow/mgr/util/__main__.py

@@ -0,0 +1,36 @@
+import argparse
+import logging
+from .cmds.cmd_schema import CmdSchema
+
+def get_parser():
+    parser = argparse.ArgumentParser(description="dv-flow-mgr.util")
+    parser.add_argument("--log-level", 
+                        help="Configures debug level [INFO, DEBUG]",
+                        choices=("NONE", "INFO", "DEBUG"))
+
+    subparsers = parser.add_subparsers(required=True)
+
+    schema = subparsers.add_parser('schema', help='Write schema')
+    schema.add_argument("-o", "--output", 
+                        help="Destination file", 
+                        default="-")
+    schema.set_defaults(f=CmdSchema())
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.log_level is not None and args.log_level != "NONE":
+        opt_m = {
+            "INFO": logging.INFO,
+            "DEBUG": logging.DEBUG
+        }
+        logging.basicConfig(level=opt_m[args.log_level])
+
+    args.f(args)
+
+if __name__ == "__main__":
+    main()

dv_flow/mgr/util/cmds/cmd_schema.py

@@ -0,0 +1,63 @@
+
+import json
+import sys
+from pydantic import BaseModel
+import pydantic.dataclasses as pdc
+from typing import Union
+from ...fragment_def import FragmentDef
+from ...package_def import PackageDef
+
+class DvFlowSchema(BaseModel):
+    root : Union[PackageDef,FragmentDef] = pdc.Field(default=None)
+
+class CmdSchema(object):
+
+    def __call__(self, args):
+        if args.output == "-":
+            fp = sys.stdout
+        else:
+            fp = open(args.output, "w")
+
+        root_s = DvFlowSchema.model_json_schema(
+            ref_template="#/defs/{model}"
+        )
+        pkg_s = PackageDef.model_json_schema(
+            ref_template="#/defs/{model}"
+        )
+        frag_s = FragmentDef.model_json_schema(
+            ref_template="#/defs/{model}"
+        )
+
+        defs = {}
+        print("root_s keys: %s" % " ".join(root_s.keys()))
+        print("root_s defs: %s" % " ".join(root_s["$defs"].keys()))
+        defs.update(root_s["$defs"])
+#        defs.update(pkg_s["$defs"])
+#        defs.update(frag_s["$defs"])
+
+        for td in defs.keys():
+            defs[td]["$$target"] = "#/defs/%s" % td
+
+        root = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://dv-flow.github.io/flow.dv.schema.json",
+            "title": "DV Flow-specification schema",
+            "description": "Flow-specification schema",
+            "type": "object",
+            "properties": {
+                "package": {
+                    "$ref": "#/defs/PackageDef",
+                    "title": "Package Definition",
+                    "description": "Package Definition"
+                },
+                "fragment": {
+                    "$ref": "#/defs/FragmentDef"
+                }
+            },
+            "defs": defs,
+        }
+
+        fp.write(json.dumps(root, indent=2))
+
+        if fp != sys.stdout:
+            fp.close()

dv_flow/mgr/{util.py → util/util.py}

@@ -21,7 +21,7 @@
 #****************************************************************************
 import os
 import yaml
-from .package_def import PackageDef
+from ..package_def import PackageDef
 
 def loadProjPkgDef(path):
     """Locates the project's flow spec and returns the PackageDef"""

{dv_flow_mgr-0.0.1.13979842530a1.dist-info → dv_flow_mgr-0.0.1.14097297609a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-flow-mgr
-Version: 0.0.1.13979842530a1
+Version: 0.0.1.14097297609a1
 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.14097297609a1.dist-info/RECORD

@@ -0,0 +1,57 @@
+dv_flow/mgr/__init__.py,sha256=EL7krYGBmN53z3HKvdrIiyHTD4TRx94LegCgx8whUAo,1130
+dv_flow/mgr/__main__.py,sha256=ExLZCOjDZtxqPk_SSF5SZKkbYUjMmVca4sT2OeePv10,3437
+dv_flow/mgr/eval_jq.py,sha256=bRsHtaN51qIOiZK1VJV52W0-vj5VH0nQ7XIFebZi5kI,1129
+dv_flow/mgr/expr_eval.py,sha256=N_8hRIgzJK9JVqhRt8F9rc4S7AAdKHMMltafqk6KhJs,3113
+dv_flow/mgr/expr_parser.py,sha256=P6u2FdSXeZbdamC3zpEnYKLcK2RULQJfSoev2Ol75fE,6543
+dv_flow/mgr/fileset.py,sha256=4izm4-qldWLiZxWDUa5Em0iFizzS-S-O0YU6zvtbUUs,1264
+dv_flow/mgr/fragment_def.py,sha256=AHx3ITbiNbGCzlDk5FM8Iimm0GJnWXDDRAoRC1b41jM,1647
+dv_flow/mgr/out,sha256=d8GGBi3J43fhdLBlnsUbzBfRe0TD0QTP3nOTz54l2bI,200
+dv_flow/mgr/package.py,sha256=9FhOu1hKYKzlD88zehwrI6KAcs1E7TbXDnq4v54dqDQ,1701
+dv_flow/mgr/package_def.py,sha256=L6KzBLSgArDgKPdjRAkkkq1c771BwV0NU-fMZRMMwws,20581
+dv_flow/mgr/package_import_spec.py,sha256=aZMpnS9a5NFY76_pYXEuO3-Mkc_xFzy73fdrUe_54Dc,1760
+dv_flow/mgr/param.py,sha256=kkxMRGf6mPjSZJsjgLKH2vJL62Sn0ZESvjBLkEYOp20,1386
+dv_flow/mgr/param_def.py,sha256=mkAw3DanIxcVWRYeh9lUAfUMkpqDFly_Ku_iobr4ix8,1745
+dv_flow/mgr/param_ref_eval.py,sha256=5yH37oIX6f2qmk7GfRgNT5qZx0jm3CJFgB9lLDZZ1yQ,1981
+dv_flow/mgr/parsetab.py,sha256=I-p3nC60t9jiNtPhKyl_sE92SiP96zJLnNdydcLy33g,3780
+dv_flow/mgr/pkg_rgy.py,sha256=d1nIjRm3ymMNJT-yiMDxCS6bFisTPvLMqh5VrfsHVKM,5404
+dv_flow/mgr/task_data.py,sha256=lN7Iq8YTitEMGG4rZqYQi6Ri2HuPgBQ5oGQbW-63T8c,12436
+dv_flow/mgr/task_def.py,sha256=TlDXDfmPKBewDIT0IIwNEaaT-trbeEtTnoPSKM6te7k,3474
+dv_flow/mgr/task_graph_builder.py,sha256=3jDlC6UinOHNZO1scO4g6bdDdLZKJEjtexxV9RXy0_4,14371
+dv_flow/mgr/task_graph_dot_writer.py,sha256=GxqiYwQJbFgUQdnPCS9vpIYmYFbSXwnXCSbGmjbxC3M,2418
+dv_flow/mgr/task_listener_log.py,sha256=hrJEjSRXXoovDTcD1Cmhi3Spzw7uEJ-WP6tv6JUaa6s,4060
+dv_flow/mgr/task_node.py,sha256=mMQlvYLxBBlWpZD-D97th2Hzy4T9E5i4H3V_i9bFxcM,3431
+dv_flow/mgr/task_node_compound.py,sha256=y8_jzsfT9Vnm-tCWc_-hFHFoSat95zBXFibySu38YRA,1696
+dv_flow/mgr/task_node_ctor.py,sha256=COFGvm5PR2B92H3uW1yhDIUCmppo9U4IfOcv_Jrsreo,3952
+dv_flow/mgr/task_node_ctor_compound.py,sha256=inJeqOtlkVa7QRCzktqvVkkZ0vZALHFadIGlRZyDTD8,4006
+dv_flow/mgr/task_node_ctor_compound_proxy.py,sha256=fkH_b35xE0dABbRn9Boa80WWx_tR4L9v1mhX6faefpg,1999
+dv_flow/mgr/task_node_ctor_def_base.py,sha256=C2EeKgjeHB9xdC7nkLMBOcektwDoLhdP-4wQLY8OZ4g,1562
+dv_flow/mgr/task_node_ctor_proxy.py,sha256=e1pfLBnJHAgQvkyNcB8sKw5DJdAPRphQz1-DT9Oheho,2017
+dv_flow/mgr/task_node_ctor_task.py,sha256=9HT39F3KcEpnOBd0SbUqE6FaeSY5fFp_tN1bzGNfFKk,2237
+dv_flow/mgr/task_node_ctor_wrapper.py,sha256=fRwO2RRJbt7IB1Ziwobmg0-nU5vFYsXoNV4IXfsS7mw,3435
+dv_flow/mgr/task_node_leaf.py,sha256=52qv1hwp5FLG9PuPvYVPLlTdzi1TcG4OTqMZC54iIwc,6481
+dv_flow/mgr/task_output.py,sha256=ZwyvwnYj_gHOEFAEOH3m24Xfc4Cn77hb1j7LkX8_3C4,1086
+dv_flow/mgr/task_params_ctor.py,sha256=BPkbnoCtzhCxc1g8CJ6VimCcm5UAu92PXeDMhQ4lYsQ,1957
+dv_flow/mgr/task_runner.py,sha256=6Tq-ADmCjWzDmUktHs0yHsmJovUXAxcbZdOuJovdR2M,9117
+dv_flow/mgr/type.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dv_flow/mgr/type_def.py,sha256=NDeyplKrPnWwEv4yHkhXEMK9d9j39b5MOeLB-1Mchqo,1095
+dv_flow/mgr/cmds/cmd_graph.py,sha256=Ykw__EdwamDBZZKxQZVbtMtFl7koq5dJMShTBXSM2pk,2672
+dv_flow/mgr/cmds/cmd_run.py,sha256=VL0LU0zYnClQ8Id30sxMN_fHJzQFJsOuj7qDG7GTT60,3198
+dv_flow/mgr/cmds/cmd_show.py,sha256=CZlgwB3Hcu-6HS-diqnWjCcPPpO-kjIIXU3DgWXvsf4,3773
+dv_flow/mgr/share/flow.json,sha256=lNmZex9NXkYbyb2aZseQfUOkV9CMyfH0iLODEI7EPBw,5096
+dv_flow/mgr/std/create_file.py,sha256=wmn5N_mObx_wr2LPdKOVbNmdM71hhs3UXOv6Ap9l3Ts,2726
+dv_flow/mgr/std/exec.py,sha256=UChqa_tAjvdB1NjqTsvlPgFomP8hMsX2rAOPyUonNpk,3896
+dv_flow/mgr/std/fileset.py,sha256=5IxS6T-x0wzA6fdEQcfHZ9kNP8IpH9hfJ3UMhL4A6Iw,3911
+dv_flow/mgr/std/flow.dv,sha256=rl0VZt_H-TyIJq0iERai07aDDZHI86mNozs4gUxidDA,3759
+dv_flow/mgr/std/message.py,sha256=0JHLErg8whqMLAasG1fumZ2O7R7WNWeNQ9ibJaLDpVY,1029
+dv_flow/mgr/std/task_null.py,sha256=dw6LXBXVwth6gLPeduDvlz5znAhcVpDH8r1DticD-0w,1041
+dv_flow/mgr/util/__init__.py,sha256=6uuA6z5cKS2hcjJw6YyEM2M79g6OpXb6tZF_Gku-AGU,22
+dv_flow/mgr/util/__main__.py,sha256=F0LXpCDpYTPalSo0dc1h_qZkip5v1AZYYh-vcYbh5s0,983
+dv_flow/mgr/util/util.py,sha256=yg9oTPRiO87mkCSOQpOtlG9vyKPQzY3qp4OJkEMbWyY,1443
+dv_flow/mgr/util/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dv_flow/mgr/util/cmds/cmd_schema.py,sha256=lrEI-Jwb8j4I4yYOn9hq7_7NYbK8leVxLesrHyEWm-E,1879
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/METADATA,sha256=IlTwE8Jw4l2MnwXv0JkjznsQabW7cYXyVi0qTop1uUU,13336
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/entry_points.txt,sha256=1roy8wAFM48LabOvr6jiOw0MUs-qE8X3Vf8YykPazxk,50
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/top_level.txt,sha256=amfVTkggzYPtWwLqNmRukfz1Buu0pGS2SrYBBLhXm04,8
+dv_flow_mgr-0.0.1.14097297609a1.dist-info/RECORD,,

{dv_flow_mgr-0.0.1.13979842530a1.dist-info → dv_flow_mgr-0.0.1.14097297609a1.dist-info}/WHEEL

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

dv_flow/mgr/task.py

@@ -1,181 +0,0 @@
-#****************************************************************************
-#* task.py
-#*
-#* Copyright 2023-2025 Matthew Ballance and Contributors
-#*
-#* Licensed under the Apache License, Version 2.0 (the "License"); you may 
-#* not use this file except in compliance with the License.  
-#* You may obtain a copy of the License at:
-#*
-#*   http://www.apache.org/licenses/LICENSE-2.0
-#*
-#* Unless required by applicable law or agreed to in writing, software 
-#* distributed under the License is distributed on an "AS IS" BASIS, 
-#* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
-#* See the License for the specific language governing permissions and 
-#* limitations under the License.
-#*
-#* Created on:
-#*     Author: 
-#*
-#****************************************************************************
-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 TaskData, TaskDataInput, TaskDataOutput, TaskDataResult
-from .task_ctor import TaskParamsCtor
-from .task_params_ctor import TaskParamsCtor
-from .task_runner import TaskRunner
-
-# @dc.dataclass
-# class TaskSpec(object):
-#     name : str
-
-# class TaskParams(BaseModel):
-#     pass
-
-
-# @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)))
-
-# @dc.dataclass
-# class TaskCtorParamCls(TaskCtor):
-#     params_ctor : Callable = None
-
-#     _log : ClassVar = logging.getLogger("TaskCtorParamType")
-
-#     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 TaskCtorCls(TaskCtor):
-#     task_ctor : Callable = None
-
-#     _log : ClassVar = logging.getLogger("TaskCtorCls")
-
-#     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))
-
-#         if srcdir is None:
-#             srcdir = self.srcdir
-
-#         if params is None:
-#             params = self.mkParams()
-
-#         ret = self.task_ctor(
-#             name=name, 
-#             depends=depends, 
-#             rundir=rundir, 
-#             srcdir=srcdir, 
-#             params=params)
-
-#         # Update parameters on the way back
-#         self.applyParams(ret.params)
-
-#         self._log.debug("<-- %s::mkTask" % self.name)
-#         return ret
-
-# @dc.dataclass
-# class TaskCtorProxy(TaskCtor):
-#     task_ctor : TaskCtor = None
-#     param_ctor : Callable = None
-
-#     _log : ClassVar = logging.getLogger("TaskCtorProxy")
-
-#     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
-
-#     def mkParams(self, params=None):
-#         self._log.debug("--> %s::mkParams: %s" % (self.name, str(self.params)))
-
-#         if params is None and self.param_ctor is not None:
-#             params = self.param_ctor()
-
-#         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 
-
-    # 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,
-                  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

@@ -1,64 +0,0 @@
-#****************************************************************************
-#* task_ctor.py
-#*
-#* Copyright 2023-2025 Matthew Ballance and Contributors
-#*
-#* Licensed under the Apache License, Version 2.0 (the "License"); you may 
-#* not use this file except in compliance with the License.  
-#* You may obtain a copy of the License at:
-#*  
-#*   http://www.apache.org/licenses/LICENSE-2.0
-#*  
-#* Unless required by applicable law or agreed to in writing, software 
-#* distributed under the License is distributed on an "AS IS" BASIS, 
-#* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
-#* See the License for the specific language governing permissions and 
-#* limitations under the License.
-#*
-#* Created on:
-#*     Author: 
-#*
-#****************************************************************************
-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) -> 'TaskNode':
-        """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)