working?

Author: wpbonelli

flopy4/mf6/__init__.py

@@ -28,8 +28,16 @@ class WriteError(Exception):
 
 def _load_mf6(cls, path: Path) -> Component:
     """Load MF6 format file into a component instance."""
+    from flopy4.mf6.binding import resolve_bindings
+
     with open(path, "r") as fp:
-        return structure(load_mf6(fp), path, cls)
+        # Parse and transform
+        data = load_mf6(fp, component_type=cls)
+        # Structure into component
+        component = structure(data, path, cls)
+        # Resolve any child component bindings
+        component = resolve_bindings(component, path.parent)
+        return component
 
 
 def _load_json(cls, path: Path) -> Component:

flopy4/mf6/binding.py

@@ -135,3 +135,76 @@ def to_component(cls, binding_tuple: tuple | list, workspace: Path) -> Component
             component.name = terms[0]  # type: ignore[attr-defined]
 
         return component  # type: ignore[return-value]
+
+
+def resolve_bindings(component: Component, workspace: Path) -> Component:
+    """
+    Recursively resolve binding tuples to component instances.
+
+    Processes a component after structuring to:
+    1. Detect binding lists (list of tuples with type/fname/terms)
+    2. Recursively load referenced components via Binding.to_component()
+    3. Replace binding lists with dicts of component instances
+
+    Parameters
+    ----------
+    component : Component
+        Component to process (may contain binding lists)
+    workspace : Path
+        Workspace directory for resolving file paths
+
+    Returns
+    -------
+    Component
+        Component with bindings resolved to component instances
+    """
+    from flopy4.mf6.simulation import Simulation
+
+    # Check if this is a Simulation - resolve models, solutions, exchanges
+    if isinstance(component, Simulation):
+        # Resolve models: list of binding tuples → dict of Model instances
+        if hasattr(component, "models") and isinstance(component.models, list):
+            resolved_models = {}
+            for binding_tuple in component.models:
+                if isinstance(binding_tuple, (tuple, list)):
+                    model = Binding.to_component(binding_tuple, workspace)
+                    # Use the name from the binding terms as the key
+                    key = binding_tuple[2] if len(binding_tuple) > 2 else model.name  # type: ignore
+                    resolved_models[key] = model
+            component.models = resolved_models  # type: ignore
+
+        # Resolve solutions: dict[group, list of tuples] → dict[name, Solution]
+        if hasattr(component, "solutions") and isinstance(component.solutions, dict):
+            resolved_solutions = {}
+            for group_key, bindings in list(component.solutions.items()):  # type: ignore
+                if isinstance(bindings, list):
+                    for binding_tuple in bindings:
+                        if isinstance(binding_tuple, (tuple, list)):
+                            solution = Binding.to_component(binding_tuple, workspace)
+                            # Use the name from the binding terms as the key
+                            key = (
+                                binding_tuple[2] if len(binding_tuple) > 2 else solution.name  # type: ignore
+                            )
+                            resolved_solutions[key] = solution
+            component.solutions = resolved_solutions  # type: ignore
+
+        # Resolve exchanges: list of binding tuples → dict of Exchange instances
+        if hasattr(component, "exchanges") and isinstance(component.exchanges, list):
+            resolved_exchanges = {}
+            for binding_tuple in component.exchanges:
+                if isinstance(binding_tuple, (tuple, list)):
+                    exchange = Binding.to_component(binding_tuple, workspace)
+                    # Use exchange type + model names as key
+                    key = f"{exchange.__class__.__name__}_{binding_tuple[2]}_{binding_tuple[3]}"  # type: ignore
+                    resolved_exchanges[key] = exchange
+            component.exchanges = resolved_exchanges  # type: ignore
+
+        # Resolve TDIS if it's a binding
+        if hasattr(component, "tdis") and isinstance(component.tdis, (tuple, list)):
+            component.tdis = Binding.to_component(component.tdis, workspace)  # type: ignore
+
+    # For Model components, resolve package bindings if needed
+    # (currently packages are typically in griddata/perioddata fields, not as bindings)
+    # This can be extended in the future if needed
+
+    return component

flopy4/mf6/codec/reader/__init__.py

@@ -1,42 +1,61 @@
-from typing import IO, Any
+from typing import IO, TYPE_CHECKING, Any
 
 from flopy4.mf6.codec.reader.parser import get_basic_parser
-from flopy4.mf6.codec.reader.transformer import BasicTransformer
+from flopy4.mf6.codec.reader.transformer import BasicTransformer, TypedTransformer
+
+if TYPE_CHECKING:
+    from flopy4.mf6.component import Component
 
 BASIC_PARSER = get_basic_parser()
 BASIC_TRANSFORMER = BasicTransformer()
 
 
-def load(fp: IO[str]) -> Any:
+def load(fp: IO[str], component_type: type["Component"] | None = None) -> Any:
     """
     Load and parse an MF6 input file.
 
     Parameters
     ----------
-    path : str | PathLike
-        Path to the MF6 input file
+    fp : IO[str]
+        File-like object containing MF6 input file content
+    component_type : type[Component], optional
+        Component class to use for typed transformation.
+        If provided, uses TypedTransformer with the component's DFN.
+        If None, uses BasicTransformer for untyped parsing.
 
     Returns
     -------
     Any
         Parsed MF6 input file structure
     """
-    return loads(fp.read())
+    return loads(fp.read(), component_type=component_type)
 
 
-def loads(data: str) -> Any:
+def loads(data: str, component_type: type["Component"] | None = None) -> Any:
     """
     Parse MF6 input file content from string.
 
     Parameters
     ----------
     data : str
         MF6 input file content as string
+    component_type : type[Component], optional
+        Component class to use for typed transformation.
+        If provided, uses TypedTransformer with the component's attrs specification.
+        If None, uses BasicTransformer for untyped parsing.
 
     Returns
     -------
     Any
         Parsed MF6 input file structure
     """
+    tree = BASIC_PARSER.parse(data)
+
+    if component_type is not None:
+        # Use TypedTransformer with the component's attrs specification
+        transformer = TypedTransformer(component_type=component_type)
+    else:
+        # Fall back to BasicTransformer
+        transformer = BASIC_TRANSFORMER
 
-    return BASIC_TRANSFORMER.transform(BASIC_PARSER.parse(data))
+    return transformer.transform(tree)