simplify

Author: wpbonelli

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

@@ -17,28 +17,39 @@ def _get_template_env():
     )
     env.filters["field_type"] = filters.field_type
     env.filters["record_child_type"] = filters.record_child_type
-    env.filters["keystring_children"] = filters.keystring_children
-    env.filters["group_period_fields"] = filters.group_period_fields
-    env.filters["get_recarray_name"] = filters.get_recarray_name
-    env.filters["get_all_grouped_field_names"] = filters.get_all_grouped_field_names
     return env
 
 
 def _compute_block_metadata(blocks):
     """Pre-compute block metadata for template rendering."""
-    block_metadata = {}
+    blocks_list = []
     for block_name, block_fields in blocks.items():
         period_groups = filters.group_period_fields(block_fields)
-        recarray_name = filters.get_recarray_name(block_name) if period_groups else None
         has_index = block_name == "period"
 
-        block_metadata[block_name] = {
-            "fields": block_fields,
-            "period_groups": period_groups,
-            "recarray_name": recarray_name,
-            "has_index": has_index,
-        }
-    return block_metadata
+        # Build recarrays list
+        recarrays = []
+        grouped_field_names = set()
+        if period_groups:
+            for field_names in period_groups.values():
+                recarray_name = filters.get_recarray_name(block_name)
+                recarrays.append({"name": recarray_name, "fields": field_names})
+                grouped_field_names.update(field_names)
+
+        # Get standalone fields (not in any recarray)
+        all_field_names = list(block_fields.keys())
+        standalone_fields = [f for f in all_field_names if f not in grouped_field_names]
+
+        blocks_list.append(
+            {
+                "name": block_name,
+                "has_index": has_index,
+                "standalone_fields": standalone_fields,
+                "recarrays": recarrays,
+            }
+        )
+
+    return blocks_list
 
 
 def make_grammar(dfn: Dfn, outdir: PathLike):
@@ -49,15 +60,11 @@ def make_grammar(dfn: Dfn, outdir: PathLike):
     target_path = outdir / f"{dfn.name}.lark"
 
     # Pre-compute block metadata
-    block_metadata = _compute_block_metadata(dfn.blocks)
+    blocks_list = _compute_block_metadata(dfn.blocks)
 
     with open(target_path, "w") as f:
         name = dfn.name
-        f.write(
-            template.render(
-                name=name, blocks=dfn.blocks, fields=dfn.fields, block_metadata=block_metadata
-            )
-        )
+        f.write(template.render(name=name, blocks=blocks_list, fields=dfn.fields))
 
 
 def make_all_grammars(dfns: dict[str, Dfn], outdir: PathLike):

flopy4/mf6/codec/reader/grammar/templates/component.lark.jinja

@@ -9,37 +9,33 @@
 
 // Top-level structure
 start: block*
-block: {% for block_name in blocks.keys() %}
-{{- block_name }}_block
+block: {% for block in blocks %}
+{{- block.name }}_block
 {%- if not loop.last %} | {% endif %}
 {%- endfor %}
 
 // Block definitions
-{% for block_name, meta in block_metadata.items() %}
-{{ m.block_def(block_name, meta.has_index) }}
+{% for block in blocks %}
+{{ m.block_def(block.name, block.has_index) }}
 {% endfor %}
-{% if block_metadata.values()|selectattr('has_index')|list %}
+{% if blocks|selectattr('has_index')|list %}
 block_index: integer
 {% endif %}
 // Block field lists
-{% for block_name, meta in block_metadata.items() %}
-{% if meta.period_groups %}
-{% set grouped_field_names = meta.period_groups.values()|first %}
-{% set field_names = [] %}
-{% for field_name in meta.fields.keys() %}
-{%- if field_name not in grouped_field_names %}
-{%- set _ = field_names.append(field_name) %}
-{%- endif %}
-{%- endfor %}
-{{ m.field_list(block_name, field_names, meta.recarray_name) }}
+{% for block in blocks %}
+{% if block.recarrays %}
+{% set recarray_name = block.recarrays[0].name %}
+{{ m.field_list(block.name, block.standalone_fields, recarray_name) }}
 {% else %}
-{{ m.field_list(block_name, meta.fields.keys()|list, none) }}
+{{ m.field_list(block.name, block.standalone_fields, none) }}
 {% endif %}
 {% endfor %}
 // Individual field rules
-{% set grouped_fields = blocks|get_all_grouped_field_names %}
-{% for field_name, field in fields.items() %}
-{% if field_name not in grouped_fields %}
+{% set generated_rules = [] %}
+{% for block in blocks %}
+{% for field_name in block.standalone_fields %}
+{% if field_name not in generated_rules %}
+{% set field = fields[field_name] %}
 {% set field_type = field|field_type %}
 {% if field.type == 'record' and field.children is not none %}
 {{ m.record_field(field_name, field) }}
@@ -48,11 +44,14 @@ block_index: integer
 {% else %}
 {{ m.simple_field(field_name, field, field_type) }}
 {% endif %}
+{% set _ = generated_rules.append(field_name) %}
 {% endif %}
 {% endfor %}
+{% endfor %}
 {# Generate union rules for nested unions within records #}
 {% set unions_generated = [] %}
-{% for field_name, field in fields.items() %}
+{% for field_name in generated_rules %}
+{% set field = fields[field_name] %}
 {% if field.type == 'record' and field.children is not none %}
 {% for child_name, child in field.children.items() %}
 {% if child.type == 'union' and child_name not in unions_generated %}
@@ -63,10 +62,10 @@ block_index: integer
 {% endif %}
 {% endfor %}
 // Recarray rules for period data (stress_period_data, etc.)
-{% for block_name, meta in block_metadata.items() %}
-{% if meta.recarray_name %}
-{{ meta.recarray_name }}: record+
-{% endif %}
+{% for block in blocks %}
+{% for recarray in block.recarrays %}
+{{ recarray.name }}: record+
+{% endfor %}
 {% endfor %}
 
 %import typed.integer -> integer