structure dfn attr (still broken)

Author: wpbonelli

flopy/mf6/data/mfdatautil.py

@@ -1054,89 +1054,3 @@ def empty(
                 return template
         else:
             return rec_array
-
-
-class MFDocString:
-    """
-    Helps build a python class doc string
-
-    Parameters
-    ----------
-    description : string
-        description of the class
-
-    Attributes
-    ----------
-    indent: string
-        indent to use in doc string
-    description : string
-        description of the class
-    parameter_header : string
-        header for parameter section of doc string
-    parameters : list
-        list of docstrings for class parameters
-
-    Methods
-    -------
-    add_parameter : (param_descr : string, beginning_of_list : bool)
-        adds doc string for a parameter with description 'param_descr' to the
-        end of the list unless beginning_of_list is True
-    get_doc_string : () : string
-        builds and returns the docstring for the class
-    """
-
-    def __init__(self, description):
-        self.indent = "    "
-        self.description = description
-        self.parameter_header = (
-            f"{self.indent}Parameters\n{self.indent}----------"
-        )
-        self.parameters = []
-        self.model_parameters = []
-
-    def add_parameter(
-        self, param_descr, beginning_of_list=False, model_parameter=False
-    ):
-        if beginning_of_list:
-            self.parameters.insert(0, param_descr)
-            if model_parameter:
-                self.model_parameters.insert(0, param_descr)
-        else:
-            self.parameters.append(param_descr)
-            if model_parameter:
-                self.model_parameters.append(param_descr)
-
-    def get_doc_string(self, model_doc_string=False, sim_doc_string=False):
-        doc_string = '{}"""\n{}{}\n\n{}\n'.format(
-            self.indent, self.indent, self.description, self.parameter_header
-        )
-        if model_doc_string:
-            param_list = self.model_parameters
-            doc_string = (
-                "{}    modelname : string\n        name of the "
-                "model\n    model_nam_file : string\n"
-                "        relative path to the model name file from "
-                "model working folder\n    version : string\n"
-                "        version of modflow\n    exe_name : string\n"
-                "        model executable name\n"
-                "    model_ws : string\n"
-                "        model working folder path"
-                "\n".format(doc_string)
-            )
-        else:
-            param_list = self.parameters
-        for parameter in param_list:
-            if sim_doc_string:
-                pclean = parameter.strip()
-                if (
-                    pclean.startswith("simulation")
-                    or pclean.startswith("loading_package")
-                    or pclean.startswith("filename")
-                    or pclean.startswith("pname")
-                    or pclean.startswith("parent_file")
-                ):
-                    continue
-            doc_string += f"{parameter}\n"
-        if not (model_doc_string or sim_doc_string):
-            doc_string += f'\n{self.indent}"""'
-        return doc_string

flopy/mf6/data/mfstructure.py

@@ -1781,7 +1781,6 @@ class MFInputFileStructure:
 
     def __init__(self, dfn_file, path, common, model_file):
         # initialize
-        self.valid = True
         self.file_type = dfn_file.package_type
         self.file_prefix = dfn_file.package_prefix
         self.dfn_type = dfn_file.dfn_type

flopy/mf6/mfsimbase.py

@@ -483,15 +483,6 @@ def __init__(
             self.simulation_data.lazy_io = True
         self._package_container = PackageContainer(self.simulation_data)
 
-        # verify metadata
-        fpdata = mfstructure.MFStructure()
-        if not fpdata.valid:
-            excpt_str = (
-                "Invalid package metadata.  Unable to load MODFLOW "
-                "file structure metadata."
-            )
-            raise FlopyException(excpt_str)
-
         # initialize
         self.dimensions = None
         self.type = "Simulation"
@@ -503,7 +494,7 @@ def __init__(
         self._exchange_files = {}
         self._solution_files = {}
         self._other_files = {}
-        self.structure = fpdata.sim_struct
+        self.structure = mfstructure.MFStructure().sim_struct
         self.model_type = None
 
         self._exg_file_num = {}

flopy/mf6/utils/codegen/__init__.py

@@ -2,17 +2,16 @@
 from os import PathLike
 from pathlib import Path
 
-from flopy.utils import import_optional_dependency
-
 __all__ = ["make_init", "make_targets", "make_all"]
 
 
 def _get_template_env():
     # import here instead of module so we don't
     # expect optional deps at module init time
-    jinja = import_optional_dependency("jinja2")
-    loader = jinja.PackageLoader("flopy", "mf6/utils/codegen/templates/")
-    env = jinja.Environment(
+    import jinja2
+
+    loader = jinja2.PackageLoader("flopy", "mf6/utils/codegen/templates/")
+    env = jinja2.Environment(
         loader=loader,
         trim_blocks=True,
         lstrip_blocks=True,
@@ -22,22 +21,24 @@ def _get_template_env():
 
     from flopy.mf6.utils.codegen.filters import Filters
 
-    env.filters["base"] = Filters.Cls.base
-    env.filters["title"] = Filters.Cls.title
-    env.filters["description"] = Filters.Cls.description
-    env.filters["prefix"] = Filters.Cls.prefix
-    env.filters["parent"] = Filters.Cls.parent
-    env.filters["skip_init"] = Filters.Cls.skip_init
-    env.filters["package_abbr"] = Filters.Cls.package_abbr
-    env.filters["attrs"] = Filters.Vars.attrs
-    env.filters["init"] = Filters.Vars.init
-    env.filters["untag"] = Filters.Var.untag
-    env.filters["type"] = Filters.Var.type
+    env.filters["base"] = Filters.base
+    env.filters["title"] = Filters.title
+    env.filters["description"] = Filters.description
+    env.filters["prefix"] = Filters.prefix
+    env.filters["parent"] = Filters.parent
+    env.filters["skip_init"] = Filters.skip_init
+    env.filters["package_abbr"] = Filters.package_abbr
+    env.filters["attrs"] = Filters.attrs
+    env.filters["init"] = Filters.init
+    env.filters["untag"] = Filters.untag
+    env.filters["type"] = Filters.type
     env.filters["safe_name"] = Filters.safe_name
     env.filters["escape_trailing_underscore"] = (
         Filters.escape_trailing_underscore
     )
     env.filters["value"] = Filters.value
+    env.filters["math"] = Filters.math
+    env.filters["clean"] = Filters.clean
 
     return env
 
@@ -73,7 +74,7 @@ def make_targets(dfn, outdir: PathLike, verbose: bool = False):
 
     def _get_template_name(ctx_name) -> str:
         """The template file to use."""
-        base = Filters.Cls.base(ctx_name)
+        base = Filters.base(ctx_name)
         if base == "MFSimulationBase":
             return "simulation.py.jinja"
         elif base == "MFModel":
@@ -87,7 +88,7 @@ def _get_template_name(ctx_name) -> str:
 
     for context in Context.from_dfn(dfn):
         name = context["name"]
-        target_path = outdir / f"mf{Filters.Cls.title(name)}.py"
+        target_path = outdir / f"mf{Filters.title(name)}.py"
         template = env.get_template(_get_template_name(name))
         with open(target_path, "w") as f:
             f.write(template.render(**context))

flopy/mf6/utils/codegen/context.py

@@ -6,8 +6,6 @@
     TypedDict,
 )
 
-from modflow_devtools.dfn import Dfn, Vars
-
 
 class Context(TypedDict):
     """
@@ -37,12 +35,15 @@ class Name(NamedTuple):
         r: Optional[str]
 
         @staticmethod
-        def from_dfn(dfn: Dfn) -> List["Context.Name"]:
+        def from_dfn(dfn: dict) -> List["Context.Name"]:
             """
             Returns a list of context names this definition produces.
             An input definition may produce one or more input contexts.
             """
-            name = dfn["name"].split("-")
+            name = dfn.get("name", None)
+            if not name:
+                raise ValueError(f"DFN must have a 'name' entry")
+            name = name.split("-")
             if name[1] == "nam":
                 if name[0] == "sim":
                     return [
@@ -67,22 +68,24 @@ def from_dfn(dfn: Dfn) -> List["Context.Name"]:
             return [Context.Name(*name)]
 
     name: Name
-    vars: Vars
 
     @staticmethod
-    def from_dfn(dfn: Dfn) -> Iterator["Context"]:
+    def from_dfn(dfn: dict) -> Iterator["Context"]:
         """
-        Extract context class descriptor(s) from an input definition.
-        These are structured representations of input context classes.
-
-        Each input definition yields one or more input contexts.
+        Extract context(s) from an input definition.
+        Each definition yields one or more contexts.
         """
 
-        def _ctx(name, _dfn):
-            _dfn = _dfn.copy()
-            _dfn.pop("name", None)
-            _vars = _dfn.pop("vars", dict())
-            return Context(name=name, vars=_vars, **_dfn)
+        def get_vars(dfn_):
+            vars_ = dict()
+            blocks = dfn_.get("blocks", dict())
+            for block in blocks.values():
+                for name, var in block.items():
+                    vars_[name] = var
+            return vars_
 
         for name in Context.Name.from_dfn(dfn):
-            yield _ctx(name, dfn)
+            dfn_ = dfn.copy()
+            dfn_.pop("name", None)
+            vars_ = get_vars(dfn_)
+            yield Context(name=name, vars=vars_, **dfn_)