dv-flow-mgr 1.0.0.14483154884a1__tar.gz → 1.0.0.14504336776a1__tar.gz

{dv_flow_mgr-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-flow-mgr
-Version: 1.0.0.14483154884a1
+Version: 1.0.0.14504336776a1
 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-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dv-flow-mgr"
-version = "1.0.0.14483154884a1"
+version = "1.0.0.14504336776a1"
 dependencies = [
     'jq',
     'pydantic',

{dv_flow_mgr-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/src/dv_flow/mgr/package.py

@@ -24,6 +24,7 @@ import logging
 from typing import Any, ClassVar, Dict, List
 from .fragment_def import FragmentDef
 from .package_def import PackageDef
+from .srcinfo import SrcInfo
 from .task import Task
 
 @dc.dataclass
@@ -37,6 +38,7 @@ class Package(object):
     types : Dict[str,Any] = dc.field(default_factory=dict)
     fragment_def_l : List[FragmentDef] = dc.field(default_factory=list)
     pkg_m : Dict[str, 'Package'] = dc.field(default_factory=dict)
+    srcinfo : SrcInfo = None
     _log : ClassVar = logging.getLogger("Package")
 
     @property

{dv_flow_mgr-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/src/dv_flow/mgr/package_loader.py

@@ -11,6 +11,7 @@ from .fragment_def import FragmentDef
 from .package_def import PackageDef
 from .package import Package
 from .ext_rgy import ExtRgy
+from .srcinfo import SrcInfo
 from .task import Task
 from .task_def import TaskDef, PassthroughE, ConsumesE, RundirE
 from .task_data import TaskMarker, TaskMarkerLoc, SeverityE
@@ -50,6 +51,7 @@ class LoaderScope(SymbolScope):
 
     def findType(self, name) -> Task:
         last_dot = name.rfind('.')
+        pkg = None
         if last_dot != -1:
             pkg_name = name[:last_dot]
             task_name = name[last_dot+1:]
@@ -59,6 +61,7 @@ class LoaderScope(SymbolScope):
             else:
                 path = self.loader.pkg_rgy.findPackagePath(pkg_name)
                 if path is not None:
+                    path = os.path.normpath(path)
                     pkg = self.loader._loadPackage(path)
                     self.loader._pkg_m[pkg_name] = pkg
             if pkg is not None and name in pkg.task_m.keys():
@@ -168,6 +171,7 @@ class PackageLoader(object):
 
     def load(self, root) -> Package:
         self._log.debug("--> load %s" % root)
+        root = os.path.normpath(root)
         ret = self._loadPackage(root, None)
         self._log.debug("<-- load %s" % root)
         return ret
@@ -182,6 +186,7 @@ class PackageLoader(object):
             pp = self.pkg_rgy.findPackagePath(nn)
             if pp is None:
                 raise Exception("Package %s not found" % nn)
+            root = os.path.normpath(pp)
             pp_n = self._loadPackage(pp)
             pkg.pkg_m[pp_n.name] = pp_n
         self._log.debug("<-- load_rgy %s" % name)
@@ -264,28 +269,34 @@ class PackageLoader(object):
 
     def _mkPackage(self, pkg_def : PackageDef, root : str) -> Package:
         self._log.debug("--> _mkPackage %s" % pkg_def.name)
-        pkg = Package(pkg_def, os.path.dirname(root))
-
-        pkg_scope = self.package_scope()
-        if pkg_scope is not None:
-            self._log.debug("Add self (%s) as a subpkg of %s" % (pkg.name, pkg_scope.pkg.name))
-            pkg_scope.pkg.pkg_m[pkg.name] = pkg
+        pkg = Package(
+            pkg_def, 
+            os.path.dirname(root),
+            srcinfo=SrcInfo(file=root))
 
         if pkg.name in self._pkg_m.keys():
-            raise Exception("Duplicate package %s" % pkg.name)
+            epkg = self._pkg_m[pkg.name]
+            if epkg.srcinfo.file != pkg.srcinfo.file:
+                self.error("Package %s already loaded from %s. Duplicate defined in %s" % (
+                    pkg.name, epkg.srcinfo.file, pkg.srcinfo.file))
+        else:
+            pkg_scope = self.package_scope()
+            if pkg_scope is not None:
+                self._log.debug("Add self (%s) as a subpkg of %s" % (pkg.name, pkg_scope.pkg.name))
+                pkg_scope.pkg.pkg_m[pkg.name] = pkg
 
-        self._pkg_m[pkg.name] = pkg
-        self._pkg_s.append(PackageScope(name=pkg.name, pkg=pkg, loader=self._loader_scope))
-        # Imports are loaded first
-        self._loadPackageImports(pkg, pkg_def.imports, pkg.basedir)
+            self._pkg_m[pkg.name] = pkg
+            self._pkg_s.append(PackageScope(name=pkg.name, pkg=pkg, loader=self._loader_scope))
+            # Imports are loaded first
+            self._loadPackageImports(pkg, pkg_def.imports, pkg.basedir)
 
-        taskdefs = pkg_def.tasks.copy()
+            taskdefs = pkg_def.tasks.copy()
 
-        self._loadFragments(pkg, pkg_def.fragments, pkg.basedir, taskdefs)
+            self._loadFragments(pkg, pkg_def.fragments, pkg.basedir, taskdefs)
 
-        self._loadTasks(pkg, taskdefs, pkg.basedir)
+            self._loadTasks(pkg, taskdefs, pkg.basedir)
 
-        self._pkg_s.pop()
+            self._pkg_s.pop()
 
         self._log.debug("<-- _mkPackage %s (%s)" % (pkg_def.name, pkg.name))
         return pkg
@@ -342,6 +353,7 @@ class PackageLoader(object):
             sub_pkg = self._pkg_path_m[imp_path]
         else:
             self._log.info("Loading imported file %s" % imp_path)
+            imp_path = os.path.normpath(imp_path)
             sub_pkg = self._loadPackage(imp_path)
             self._log.info("Loaded imported package %s" % sub_pkg.name)
 
@@ -700,10 +712,10 @@ class PackageLoader(object):
     
     def error(self, msg, loc=None):
         if loc is not None:
-            marker = TaskMarker(msg=msg, severity=TaskMarker.SeverityE.Error,
+            marker = TaskMarker(msg=msg, severity=SeverityE.Error,
                                 loc=loc)
         else:
-            marker = TaskMarker(msg=msg, severity=TaskMarker.SeverityE.Error)
+            marker = TaskMarker(msg=msg, severity=SeverityE.Error)
         self.marker(marker)
 
     def marker(self, marker):

{dv_flow_mgr-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/src/dv_flow_mgr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-flow-mgr
-Version: 1.0.0.14483154884a1
+Version: 1.0.0.14504336776a1
 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-1.0.0.14483154884a1 → dv_flow_mgr-1.0.0.14504336776a1}/tests/unit/test_load_package.py

@@ -330,3 +330,141 @@ fragment:
     assert len(t2.subtasks[0].needs) == 1
     assert t2.subtasks[0].needs[0] is not None
     assert t2.subtasks[0].needs[0].name == "foo.t1.t3"
+
+def test_dup_import(tmpdir):
+    flow_dv = """
+package:
+    name: foo
+    imports:
+    - foo2/flow.dv
+    - foo2/flow.dv
+
+    tasks:
+    - name: t1
+      body:
+      - name: t2
+      - name: t3
+    - name: t2
+      uses: t1
+      body:
+      - name: t4
+        needs: [t3]
+    - name: t4
+      need: [foo2.t5]
+
+"""
+
+    foo_dv = """
+package:
+    name: foo2
+    tasks:
+    - name: t5
+"""
+
+    rundir = os.path.join(tmpdir)
+    with open(os.path.join(rundir, "flow.dv"), "w") as fp:
+        fp.write(flow_dv)
+    os.makedirs(os.path.join(rundir, "foo2"))
+    with open(os.path.join(rundir, "foo2/flow.dv"), "w") as fp:
+        fp.write(foo_dv)
+
+    def marker_collector(m):
+        print("Marker: %s" % str(m))
+        raise Exception("Marker not expected: %s" % m)
+
+    pkg = PackageLoader(
+        marker_listeners=[marker_collector]).load(os.path.join(tmpdir, "flow.dv"))
+
+    assert pkg is not None
+    assert pkg.pkg_def is not None
+    assert pkg.name == "foo"
+    assert pkg.basedir == rundir
+    assert len(pkg.task_m) == 3
+    assert "foo.t1" in pkg.task_m.keys()
+#    assert "foo.t2" in pkg.task_m.keys()
+#    assert "foo.t5" in pkg.task_m.keys()
+
+    t1 = pkg.task_m["foo.t1"]
+    assert t1.name == "foo.t1"
+    assert len(t1.subtasks) == 2
+
+def test_dup_import_subpkg(tmpdir):
+    flow_dv = """
+package:
+    name: foo
+    imports:
+    - foo3/flow.dv
+    - foo4/flow.dv
+
+    tasks:
+    - name: t1
+      body:
+      - name: t2
+      - name: t3
+    - name: t2
+      uses: t1
+      body:
+      - name: t4
+        needs: [t3]
+    - name: t4
+      need: [foo2.t5]
+
+"""
+
+    foo2_dv = """
+package:
+    name: foo2
+    tasks:
+    - name: t5
+"""
+
+    foo3_dv = """
+package:
+    name: foo3
+    imports:
+    - ../foo2/flow.dv
+    tasks:
+    - name: t5
+"""
+
+    foo4_dv = """
+package:
+    name: foo4
+    imports:
+    - ../foo2/flow.dv
+    tasks:
+    - name: t5
+"""
+
+    rundir = os.path.join(tmpdir)
+    with open(os.path.join(rundir, "flow.dv"), "w") as fp:
+        fp.write(flow_dv)
+    os.makedirs(os.path.join(rundir, "foo2"))
+    with open(os.path.join(rundir, "foo2/flow.dv"), "w") as fp:
+        fp.write(foo2_dv)
+    os.makedirs(os.path.join(rundir, "foo3"))
+    with open(os.path.join(rundir, "foo3/flow.dv"), "w") as fp:
+        fp.write(foo3_dv)
+    os.makedirs(os.path.join(rundir, "foo4"))
+    with open(os.path.join(rundir, "foo4/flow.dv"), "w") as fp:
+        fp.write(foo4_dv)
+
+    def marker_collector(m):
+        print("Marker: %s" % str(m))
+        raise Exception("Marker not expected: %s" % m)
+
+    pkg = PackageLoader(
+        marker_listeners=[marker_collector]).load(os.path.join(tmpdir, "flow.dv"))
+
+    assert pkg is not None
+    assert pkg.pkg_def is not None
+    assert pkg.name == "foo"
+    assert pkg.basedir == rundir
+    assert len(pkg.task_m) == 3
+    assert "foo.t1" in pkg.task_m.keys()
+#    assert "foo.t2" in pkg.task_m.keys()
+#    assert "foo.t5" in pkg.task_m.keys()
+
+    t1 = pkg.task_m["foo.t1"]
+    assert t1.name == "foo.t1"
+    assert len(t1.subtasks) == 2