Fix docs display and add missing DEPENDENCIES entries

Fix _get_family() regex to match uppercase (chem_wrt_Y), eliminating
spurious pattern view for the general family. Skip rendering value_labels
in constraints since they are already in descriptions. Add 15 new
DEPENDENCIES entries for stretch, body force, TENO, MUSCL, surface
tension, MHD, relativity, schlieren, CFL, and integral parameters.
Fix all pylint warnings to achieve 10.00/10.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sbryngelson

toolchain/mfc/gen_case_constraints_docs.py

@@ -6,7 +6,7 @@
 maps them to parameters and stages, and emits Markdown to stdout.
 
 Also generates case design playbook from curated working examples.
-"""
+"""  # pylint: disable=too-many-lines
 
 from __future__ import annotations
 
@@ -29,7 +29,7 @@
 if _toolchain_dir not in sys.path:
     sys.path.insert(0, _toolchain_dir)
 
-from mfc.params import REGISTRY, CONSTRAINTS, DEPENDENCIES, get_value_label  # noqa: E402
+from mfc.params import CONSTRAINTS, DEPENDENCIES, get_value_label  # noqa: E402  pylint: disable=wrong-import-position
 
 
 # ---------------------------------------------------------------------------
@@ -813,10 +813,10 @@ def _format_model_requirements(val: int) -> str:
     }
 
     # Auto-populate requirements from schema
-    for _val in _model_notes:
+    for _val, _note in _model_notes.items():
         _auto_reqs = _format_model_requirements(_val)
         if _auto_reqs:
-            _model_notes[_val]["requirements"] = _auto_reqs
+            _note["requirements"] = _auto_reqs
 
     model_constraint = CONSTRAINTS["model_eqns"]
     for val in model_constraint["choices"]:

toolchain/mfc/params/definitions.py

@@ -3,7 +3,7 @@
 
 Single file containing all ~3,300 parameter definitions using loops.
 This replaces the definitions/ directory.
-"""
+"""  # pylint: disable=too-many-lines
 
 import re
 from typing import Dict, Any
@@ -582,7 +582,7 @@ def get_value_label(param_name: str, value: int) -> str:
     },
     "polydisperse": {
         "when_true": {
-            "requires": ["nb"],
+            "requires": ["nb", "poly_sigma"],
         }
     },
     "chemistry": {
@@ -607,7 +607,82 @@ def get_value_label(param_name: str, value: int) -> str:
     },
     "probe_wrt": {
         "when_true": {
-            "requires": ["num_probes"],
+            "requires": ["num_probes", "fd_order"],
+        }
+    },
+    "stretch_x": {
+        "when_true": {
+            "requires": ["a_x", "x_a", "x_b"],
+        }
+    },
+    "stretch_y": {
+        "when_true": {
+            "requires": ["a_y", "y_a", "y_b"],
+        }
+    },
+    "stretch_z": {
+        "when_true": {
+            "requires": ["a_z", "z_a", "z_b"],
+        }
+    },
+    "bf_x": {
+        "when_true": {
+            "requires": ["k_x", "w_x", "p_x", "g_x"],
+        }
+    },
+    "bf_y": {
+        "when_true": {
+            "requires": ["k_y", "w_y", "p_y", "g_y"],
+        }
+    },
+    "bf_z": {
+        "when_true": {
+            "requires": ["k_z", "w_z", "p_z", "g_z"],
+        }
+    },
+    "teno": {
+        "when_true": {
+            "requires": ["teno_CT"],
+        }
+    },
+    "recon_type": {
+        "when_value": {
+            2: {"recommends": ["muscl_order", "muscl_lim"]},
+        }
+    },
+    "surface_tension": {
+        "when_true": {
+            "requires": ["sigma"],
+        }
+    },
+    "mhd": {
+        "when_true": {
+            "recommends": ["hyper_cleaning"],
+        }
+    },
+    "relativity": {
+        "when_true": {
+            "requires": ["mhd"],
+        }
+    },
+    "schlieren_wrt": {
+        "when_true": {
+            "requires": ["fd_order"],
+        }
+    },
+    "cfl_adap_dt": {
+        "when_true": {
+            "recommends": ["cfl_target"],
+        }
+    },
+    "cfl_dt": {
+        "when_true": {
+            "recommends": ["cfl_target"],
+        }
+    },
+    "integral_wrt": {
+        "when_true": {
+            "requires": ["fd_order"],
         }
     },
 }

toolchain/mfc/params/generators/docs_gen.py

@@ -12,18 +12,17 @@
 from ..schema import ParamType
 from ..registry import REGISTRY
 from ..descriptions import get_description
-from ..definitions import CONSTRAINTS, DEPENDENCIES, get_value_label
+from ..definitions import DEPENDENCIES, get_value_label
 from .. import definitions  # noqa: F401  pylint: disable=unused-import
 
 
 def _get_family(name: str) -> str:
     """Extract family name from parameter (e.g., 'patch_icpp' from 'patch_icpp(1)%vel(1)')."""
     # Handle indexed parameters
-    match = re.match(r'^([a-z_]+)', name)
+    match = re.match(r'^([a-zA-Z_]+)', name)
     if match:
         base = match.group(1)
-        # Check if it's a known family pattern
-        if any(name.startswith(f"{base}(") or name.startswith(f"{base}%") for _ in [1]):
+        if name.startswith(f"{base}(") or name.startswith(f"{base}%"):
             return base
     return "general"
 
@@ -104,20 +103,14 @@ def _type_to_str(param_type: ParamType) -> str:
 
 
 def _format_constraints(param) -> str:
-    """Format constraints as readable string, using value_labels when available."""
+    """Format constraints as readable string, skipping choices already shown via value_labels."""
     if not param.constraints:
         return ""
 
     parts = []
     c = param.constraints
-    if "choices" in c:
-        labels = c.get("value_labels", {})
-        if labels:
-            items = [f"{v}={labels[v]}" if v in labels else str(v)
-                     for v in c["choices"]]
-            parts.append(f"Values: [{', '.join(items)}]")
-        else:
-            parts.append(f"Values: {c['choices']}")
+    if "choices" in c and "value_labels" not in c:
+        parts.append(f"Values: {c['choices']}")
     if "min" in c:
         parts.append(f"Min: {c['min']}")
     if "max" in c:

toolchain/mfc/params/validate.py

@@ -96,7 +96,7 @@ def validate_constraints(params: Dict[str, Any]) -> List[str]:
     return errors
 
 
-def _check_condition(  # pylint: disable=too-many-arguments
+def _check_condition(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     name: str,
     condition: Dict[str, Any],
     condition_label: Optional[str],