use v2 dfns

Author: wpbonelli

.gitignore

@@ -9,3 +9,4 @@ venv/
 *.egg-info
 temp/
 .coverage
+flopy4/mf6/codec/reader/grammar/generated/*.lark

flopy4/mf6/codec/filters.py

@@ -0,0 +1,31 @@
+"""Filters shared by both reader and writer."""
+
+from typing import Any
+
+import xarray as xr
+from modflow_devtools.dfn.schema.field import Field
+from modflow_devtools.dfn.schema.v2 import FieldType
+
+
+def field_type(value: Any) -> FieldType:
+    """Get a value's type according to the MF6 specification."""
+
+    if isinstance(value, Field):
+        return value.type
+    if isinstance(value, bool):
+        return "keyword"
+    if isinstance(value, int):
+        return "integer"
+    if isinstance(value, float):
+        return "double"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, tuple):
+        return "record"
+    if isinstance(value, xr.DataArray):
+        if value.dtype == "object":
+            return "list"
+        return "array"
+    if isinstance(value, (list, dict, xr.Dataset)):
+        return "list"
+    raise ValueError(f"Unsupported field type: {type(value)}")

flopy4/mf6/codec/reader/dfn2lark.py

@@ -4,7 +4,7 @@
 from os import PathLike
 from pathlib import Path
 
-from modflow_devtools.dfn import Dfn
+from modflow_devtools.dfn import load_flat, map
 
 from flopy4.mf6.codec.reader.grammar import make_all_grammars
 
@@ -17,11 +17,13 @@ def generate(dfndir: PathLike, outdir: PathLike):
     dfndir = Path(dfndir).expanduser().absolute()
     outdir = Path(outdir).expanduser().absolute()
     outdir.mkdir(exist_ok=True, parents=True)
-    dfns = Dfn.load_all(dfndir, version=2)
-    make_all_grammars(dfns, outdir)
+    dfns_v1 = load_flat(dfndir)
+    dfns_v2 = {name: map(dfn, schema_version=2) for name, dfn in dfns_v1.items()}
+    # TODO fix devtools v1 -> v2 map, it's not converting the field type
+    make_all_grammars(dfns_v2, outdir)
 
 
-if __name__ == "__main__":
+def main():
     parser = argparse.ArgumentParser(description="Generate lark grammars from DFNs.")
     parser.add_argument(
         "--dfndir",
@@ -37,3 +39,7 @@ def generate(dfndir: PathLike, outdir: PathLike):
     )
     args = parser.parse_args()
     generate(args.dfndir, args.outdir)
+
+
+if __name__ == "__main__":
+    main()

flopy4/mf6/codec/reader/grammar/__init__.py

@@ -2,13 +2,9 @@
 from pathlib import Path
 
 import jinja2
-from modflow_devtools.dfn import Dfn, get_blocks, get_fields
+from modflow_devtools.dfn import Dfn
 
-from flopy4.mf6.codec.reader.grammar.filters import (
-    field_type,
-    keystring_children,
-    record_child_type,
-)
+from flopy4.mf6.codec.reader.grammar import filters
 
 
 def _get_template_env():
@@ -19,9 +15,9 @@ def _get_template_env():
         lstrip_blocks=True,
         keep_trailing_newline=True,
     )
-    env.filters["field_type"] = field_type
-    env.filters["record_child_type"] = record_child_type
-    env.filters["keystring_children"] = keystring_children
+    env.filters["field_type"] = filters.field_type
+    env.filters["record_child_type"] = filters.record_child_type
+    env.filters["keystring_children"] = filters.keystring_children
     return env
 
 
@@ -30,12 +26,10 @@ def make_grammar(dfn: Dfn, outdir: PathLike):
     outdir = Path(outdir).expanduser().resolve().absolute()
     env = _get_template_env()
     template = env.get_template("component.lark.jinja")
-    target_path = outdir / f"{dfn['name']}.lark"
+    target_path = outdir / f"{dfn.name}.lark"
     with open(target_path, "w") as f:
-        name = dfn["name"]
-        blocks = get_blocks(dfn)
-        fields = get_fields(dfn)
-        f.write(template.render(name=name, blocks=blocks, fields=fields))
+        name = dfn.name
+        f.write(template.render(name=name, blocks=dfn.blocks, fields=dfn.fields))
 
 
 def make_all_grammars(dfns: dict[str, Dfn], outdir: PathLike):

flopy4/mf6/codec/reader/grammar/filters.py

@@ -1,39 +1,33 @@
-from modflow_devtools.dfn import Field
+from modflow_devtools.dfn.schema.v2 import FieldV2
 
 
-def field_type(field: Field) -> str:
-    match field["type"]:
-        case t if t in ["string", "integer", "double precision"] and "shape" in field:
-            if "period" in field["block"]:
+def field_type(field: FieldV2) -> str:
+    match field.type:
+        case t if t in ["string", "integer", "double"] and field.shape:
+            if "period" in field.block:
                 return "list"
             return "array"
         case "keyword":
             return ""
-        case "keystring":
+        case "union":
             return ""  # keystrings generate their own union rules
         case _:
-            return field["type"]
+            return field.type
 
 
-def record_child_type(field: Field) -> str:
+def record_child_type(field: FieldV2) -> str:
     """Get the grammar type for a field within a record context."""
-    match field["type"]:
-        case "string":
-            return "string"
-        case "integer":
-            return "integer"
-        case "double precision":
-            return "double"
+    match field.type:
+        case t if t in ["string", "double", "integer"]:
+            return t
         case "keyword":
             return ""
-        case "keystring":
+        case "union":
             return ""  # keystrings generate their own union rules
         case _:
-            return field["type"]
+            return field.type
 
 
-def keystring_children(field: Field) -> dict:
+def keystring_children(field: FieldV2) -> dict:
     """Get the children of a keystring field for union generation."""
-    if field["type"] != "keystring":
-        return {}
-    return field.get("children", {})
+    return {} if field.type != "union" else field.children

flopy4/mf6/codec/reader/grammar/generated/chf-cdb.lark

@@ -14,9 +14,9 @@ boundnames: "boundnames"i
 print_input: "print_input"i 
 print_flows: "print_flows"i 
 save_flows: "save_flows"i 
-obs_filerecord: "obs6"i "filein"i string
+obs_filerecord: "filein"i "obs6"i string
 maxbound: "maxbound"i integer
 idcxs: "idcxs"i list
-width: "width"i list
-aux: "aux"i list
+width: "width"i double precision
+aux: "aux"i double precision
 boundname: "boundname"i list

flopy4/mf6/codec/reader/grammar/generated/chf-chd.lark

@@ -16,8 +16,8 @@ print_input: "print_input"i
 print_flows: "print_flows"i 
 save_flows: "save_flows"i 
 ts_filerecord: "ts6"i "filein"i string
-obs_filerecord: "obs6"i "filein"i string
+obs_filerecord: "filein"i "obs6"i string
 maxbound: "maxbound"i integer
-head: "head"i list
-aux: "aux"i list
+head: "head"i double precision
+aux: "aux"i double precision
 boundname: "boundname"i list

flopy4/mf6/codec/reader/grammar/generated/chf-dfw.lark

@@ -16,5 +16,5 @@ save_velocity: "save_velocity"i
 obs_filerecord: "obs6"i "filein"i string
 export_array_ascii: "export_array_ascii"i 
 dev_swr_conductance: "dev_swr_conductance"i 
-manningsn: "manningsn"i array
+manningsn: "manningsn"i double precision
 idcxs: "idcxs"i array

flopy4/mf6/codec/reader/grammar/generated/chf-disv1d.lark

@@ -23,8 +23,8 @@ export_array_ascii: "export_array_ascii"i
 crs: "crs"i array
 nodes: "nodes"i integer
 nvert: "nvert"i integer
-width: "width"i array
-bottom: "bottom"i array
+width: "width"i double precision
+bottom: "bottom"i double precision
 idomain: "idomain"i array
 vertices: "vertices"i recarray
 cell1d: "cell1d"i recarray

flopy4/mf6/codec/reader/grammar/generated/chf-evp.lark

@@ -16,8 +16,8 @@ print_input: "print_input"i
 print_flows: "print_flows"i 
 save_flows: "save_flows"i 
 ts_filerecord: "ts6"i "filein"i string
-obs_filerecord: "obs6"i "filein"i string
+obs_filerecord: "filein"i "obs6"i string
 maxbound: "maxbound"i integer
-evaporation: "evaporation"i list
-aux: "aux"i list
+evaporation: "evaporation"i double precision
+aux: "aux"i double precision
 boundname: "boundname"i list