clean up unnecessary stuff

Author: wpbonelli

autotest/test_dfnmap.py

@@ -36,14 +36,6 @@ def dfn_dir(module_tmpdir):
     return path
 
 
-@pytest.fixture(scope="module", params=FORMATS)
-def converted_v1_1(request, dfn_dir, module_tmpdir):
-    fmt = request.param
-    out = module_tmpdir / f"v1.1-{fmt}"
-    migrate(dfn_dir, out, schema_version="1.1", fmt=fmt)
-    return out, fmt
-
-
 @pytest.fixture(scope="module", params=FORMATS)
 def converted_v2(request, dfn_dir, module_tmpdir):
     fmt = request.param
@@ -52,17 +44,6 @@ def converted_v2(request, dfn_dir, module_tmpdir):
     return out, fmt
 
 
-@requires_pkg("boltons")
-def test_convert_v1_1(converted_v1_1):
-    out, fmt = converted_v1_1
-    files = list(out.glob(f"*.{fmt}"))
-    assert files
-    for p in files:
-        data = _load(p, fmt)
-        assert data["name"] == p.stem
-        assert data["schema_version"] == "1.1"
-
-
 @requires_pkg("boltons")
 def test_convert_v2(converted_v2):
     out, fmt = converted_v2

modflow_devtools/dfn/__init__.py

@@ -4,6 +4,7 @@
 from pathlib import Path
 
 from modflow_devtools.dfn.schema import (
+    _SCALAR_TYPES,
     Dfn,
     Dfns,
     Field,
@@ -13,14 +14,15 @@
     Reader,
     Ref,
     Sln,
-    _SCALAR_TYPES,
     get_fields,
 )
 from modflow_devtools.download import download_and_unzip
 
 SCALAR_TYPES = _SCALAR_TYPES
 
 __all__ = [
+    "SCALAR_TYPES",
+    "_SCALAR_TYPES",
     "Dfn",
     "Dfns",
     "Field",
@@ -29,8 +31,6 @@
     "FormatVersion",
     "Reader",
     "Ref",
-    "SCALAR_TYPES",
-    "_SCALAR_TYPES",
     "Sln",
     "fetch_dfns",
     "get_fields",

modflow_devtools/dfn/mapper.py

@@ -827,39 +827,3 @@ def resolve_parent(dfn: Dfn) -> Dfn:
 def resolve_parents(dfns: Dfns) -> Dfns:
     """Infer and set component parents using naming conventions."""
     return {name: resolve_parent(dfn) for name, dfn in dfns.items()}
-
-
-def to_tree(dfns: Dfns) -> Dfn:
-    """Condense flat definitions to a hierarchical definition."""
-
-    first_dfn = next(iter(dfns.values()), None)
-    if first_dfn is None:
-        raise ValueError("No definitions found")
-    if first_dfn["schema_version"] != "1":
-        raise ValueError(f"Expected schema version 1, got {first_dfn['schema_version']!r}")
-
-    dfns = resolve_parents(dfns)
-    roots = {name: dfn for name, dfn in dfns.items() if dfn["parent"] is None}
-    if (nroots := len(roots)) != 1:
-        raise ValueError(f"Expected one root component, found {nroots}")
-
-    def _to_tree(dfn: Dfn) -> Dfn:
-        children = {name: _dfn for name, _dfn in dfns.items() if _dfn["parent"] == dfn["name"]}
-        dfn["children"] = {name: _to_tree(_dfn) for name, _dfn in children.items()} or None
-        return dfn
-
-    return _to_tree(next(iter(roots.values())))
-
-
-def to_flat(dfn: Dfn) -> Dfns:
-    """Flatten a hierarchical definition into its constituent definitions."""
-
-    def _to_flat(_dfn: Dfn) -> Dfns:
-        children = dict(_dfn.get("children") or {})
-        result: Dfns = {_dfn["name"]: _dfn}
-        result[_dfn["name"]]["children"] = None
-        for child in children.values():
-            result.update(_to_flat(child))
-        return result
-
-    return _to_flat(dfn)

modflow_devtools/dfn/schema.py

@@ -0,0 +1,21 @@
+"""Convert DFNs to TOML (v1.1 schema). Compatibility shim for consumers of the old API."""
+
+from os import PathLike
+from pathlib import Path
+
+import tomli_w
+from boltons.iterutils import remap
+
+from modflow_devtools.dfn import Dfn
+
+
+def _drop_none_or_empty(path, key, value):
+    return not (value is None or value == "" or value == [] or value == {})
+
+
+def convert(indir: str | PathLike, outdir: str | PathLike) -> None:
+    outdir = Path(outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+    for dfn in Dfn.load_all(Path(indir)).values():  # type: ignore
+        with (outdir / f"{dfn['name']}.toml").open("wb") as f:
+            tomli_w.dump(remap(dfn, visit=_drop_none_or_empty), f)

modflow_devtools/dfn2toml.py

@@ -11,7 +11,6 @@
 from pydantic import BaseModel
 
 from modflow_devtools.dfn import schema as v1
-from modflow_devtools.dfn.mapper import map as map_v1_1
 from modflow_devtools.dfns.mapper import map as map_v2
 
 Format = Literal["yaml", "toml", "json"]
@@ -37,7 +36,7 @@ def _serialize_safe(obj: Any) -> Any:
         )
     if isinstance(obj, dict):
         result = {k: _serialize_safe(v) for k, v in obj.items() if v is not None}
-        # Strip redundant name from v1/v1.1 field dicts — name is the dict key in the parent block.
+        # Strip redundant name from field dicts — name is the dict key in the parent block.
         if "name" in result and "type" in result:
             del result["name"]
         return result
@@ -81,7 +80,7 @@ def migrate(
     schema_version: str = "2",
     fmt: Format = "yaml",
 ) -> None:
-    """Migrate DFN files' schema version and serialize to the given format.
+    """Migrate DFN files to the v2 schema and serialize to the given format.
 
     Parameters
     ----------
@@ -90,7 +89,7 @@ def migrate(
     outdir : str or PathLike
         Output directory.
     schema_version : str, optional
-        Target schema version: "1.1" or "2". Default "2".
+        Target schema version. Default "2".
     fmt : str, optional
         Output format: "yaml", "toml", or "json". Default "yaml".
     """
@@ -111,27 +110,11 @@ def migrate(
         with inpath.open() as f:
             dfn = v1.Dfn.load(f, name=inpath.stem, common=common)
 
-        if schema_version == "1.1":
-            dfn = map_v1_1(dfn)
-        elif schema_version == "2":
-            dfn = map_v2(dfn)
-        else:
-            raise ValueError(f"Got schema version {schema_version}, supported versions are: 1.1, 2")
-
-        _write(_serialize_safe(dfn), outdir / f"{inpath.stem}{ext}", fmt)
+        _write(_serialize_safe(map_v2(dfn)), outdir / f"{inpath.stem}{ext}", fmt)
     else:
         dfns = v1.load_all(inpath)
-
-        if schema_version == "1.1":
-            dfns = v1.to_flat(v1.to_tree(dfns))
-            dfns = {name: map_v1_1(dfn) for name, dfn in dfns.items()}
-        elif schema_version == "2":
-            dfns = {name: map_v2(dfn) for name, dfn in dfns.items()}
-        else:
-            raise ValueError(f"Got schema version {schema_version}, supported versions are: 1.1, 2")
-
         for dfn_name, dfn in dfns.items():
-            _write(_serialize_safe(dfn), outdir / f"{dfn_name}{ext}", fmt)
+            _write(_serialize_safe(map_v2(dfn)), outdir / f"{dfn_name}{ext}", fmt)
 
 
 if __name__ == "__main__":
@@ -154,7 +137,6 @@ def migrate(
         "--schema-version",
         "-s",
         default="2",
-        choices=["1.1", "2"],
         help="Target schema version (default: 2).",
     )
     parser.add_argument(