feat: extend LATEX_VAR_TOKEN_RE to support up to 5 levels of nested braces and add related tests

Author: phillipus85

CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.29][0.6.29] - 2026-03-23
+
+### Fixed
+
+- Extended `LATEX_VAR_TOKEN_RE` regex in `patterns.py` to support up to 5 levels of nested braces in subscripts (previously only 1 level)
+  - Now `MonteCarlo.run()` can handle expressions contain deeply nested subscript variables
+  - Added composable brace-nesting helpers (`_BRACE_L0`..`_BRACE_L4`) for readable regex construction
+- Added deep nesting test cases to `test_data.py`, `test_patterns.py`, and `test_parser.py`
+
 ## [0.6.28][0.6.28] - 2026-03-19
 
 ### Fixed
@@ -801,6 +810,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Experimentation phase before formal semantic versioning, establishing core dimensional analysis concepts and data structures.
 
+[0.6.29]: https://github.com/DASA-Design/PyDASA/compare/v0.6.28...v0.6.29
 [0.6.28]: https://github.com/DASA-Design/PyDASA/compare/v0.6.27...v0.6.28
 [0.6.27]: https://github.com/DASA-Design/PyDASA/compare/v0.6.26...v0.6.27
 [0.6.26]: https://github.com/DASA-Design/PyDASA/compare/v0.6.25...v0.6.26

src/pydasa/validations/patterns.py

@@ -24,16 +24,25 @@
 """
 
 # :attr: LATEX_VAR_TOKEN_RE
+# Brace nesting helpers – each level wraps the previous one so that
+# the overall pattern supports up to 5 levels of nested braces inside
+# subscripts (e.g. M_{a*(c*t_{R_{P*(A*(C*S))}})}).
+_BRACE_L0: str = r"[^{}]*"
+_BRACE_L1: str = r"(?:[^{}]|\{" + _BRACE_L0 + r"\})*"
+_BRACE_L2: str = r"(?:[^{}]|\{" + _BRACE_L1 + r"\})*"
+_BRACE_L3: str = r"(?:[^{}]|\{" + _BRACE_L2 + r"\})*"
+_BRACE_L4: str = r"(?:[^{}]|\{" + _BRACE_L3 + r"\})*"
+
 LATEX_VAR_TOKEN_RE: str = (
     r"(\\[A-Za-z]+|[A-Za-z][A-Za-z0-9]*)"
-    r"(?:_(?:[A-Za-z0-9]+|\{(?:[^{}]|\{[^{}]*\})+\}))?"
+    r"(?:_(?:[A-Za-z0-9]+|\{" + _BRACE_L4 + r"\}))?"
 )
 """
 Regex pattern to match LaTeX-like variable tokens with optional subscripts,
-including one nested brace level inside subscripts.
+supporting up to 5 levels of nested braces inside subscripts.
 
 Examples:
-    '\\alpha', '\\mu_{1}', 'M_{buf_{AS}}'
+    '\\alpha', '\\mu_{1}', 'M_{buf_{AS}}', 'M_{a*(c*t_{R_{P*(A*(C*S))}})}'
 """
 
 # NOTE: OG REGEX!

tests/pydasa/data/test_data.py

@@ -32,7 +32,10 @@ def get_config_test_data():
         "DC_CAT_KEYS": ["COMPUTED", "DERIVED"],
         "SENS_ANSYS_KEYS": ["SYM", "NUM"],
         "VALID_LATEX": ["alpha", "\\alpha", "beta_1", "\\beta_{1}", "\\Pi_{0}"],
-        "VALID_LATEX_VAR_TOKEN": ["M_{buf_{AS}}", "M_{a*(c*t_{A*S})}", "\\alpha", "\\mu_{1}"],
+        "VALID_LATEX_VAR_TOKEN": [
+            "M_{buf_{AS}}", "M_{a*(c*t_{A*S})}", "\\alpha", "\\mu_{1}",
+            "M_{a*(c*t_{R_{PACS}})}", "M_{a*(c*t_{R_{P*(A*(C*S))}})}"
+        ],
         "VALID_DIMENSIONS": ["M", "L*T", "M*L^-1*T^-2", "L^2*T^-1", "T^-1"],
         "INVALID_DIMENSIONS": ["X", "M*X", "M**2", "M^2.5", "M L", ""],
         "PHYSICAL_DIMS": [
@@ -162,8 +165,13 @@ def get_latex_test_data():
         },
         "COMPLEX_EXPR": "\\alpha + \\beta_{1} + \\gamma_{2}",
         "NESTED_SUBSCRIPT_CASES": [
+            # 1-level nesting
             ("M_{act_{AS}}", "M_act_AS"),
             ("M_{buf_{AS}}", "M_buf_AS"),
+            # 2-level nesting
+            ("M_{a*(c*t_{R_{PACS}})}", "M_a*(c*t_R_PACS)"),
+            # 3-level nesting (the real-world failure case)
+            ("M_{a*(c*t_{R_{P*(A*(C*S))}})}", "M_a*(c*t_R_P*(A*(C*S)))"),
         ],
         "PHYSICS_EXPR": "\\frac{U * y_{2}}{d} + \\frac{P * d^{2}}{\\mu_{1} * U}",
         "DIMENSIONAL_CASES": [

tests/pydasa/serialization/test_parser.py

@@ -318,3 +318,20 @@ def test_expression_with_powers(self) -> None:
         py_vars = list(latex_to_py.values())
         assert any("d" in v for v in py_vars)
         assert any("P" in v for v in py_vars)
+
+    def test_deeply_nested_subscript_real_world(self) -> None:
+        """Test extraction from deeply nested subscript (real-world failure case)."""
+        expr = "M_{a*(c*t_{R_{P*(A*(C*S))}})}"
+        latex_to_py, py_to_latex = extract_latex_vars(expr)
+
+        assert expr in latex_to_py, f"Token not found in latex_to_py: {expr}"
+        assert latex_to_py[expr] == "M_a*(c*t_R_P*(A*(C*S)))"
+
+    def test_deeply_nested_create_mapping(self) -> None:
+        """Test create_latex_mapping handles deeply nested subscripts end-to-end."""
+        expr = "M_{a*(c*t_{R_{P*(A*(C*S))}})}"
+        symbol_map, py_symbol_map, latex_to_py, py_to_latex = create_latex_mapping(expr)
+
+        assert expr in latex_to_py
+        py_name = latex_to_py[expr]
+        assert py_name in py_symbol_map, f"Python name '{py_name}' missing from py_symbol_map"

tests/pydasa/validations/test_patterns.py

@@ -109,6 +109,20 @@ def test_latex_var_token_re_matches_nested_subscripts(self) -> None:
         for case in self.test_data["VALID_LATEX_VAR_TOKEN"]:
             assert pattern.search(case), f"Failed to match: {case}"
 
+    def test_latex_var_token_re_fullmatch_deep_nesting(self) -> None:
+        """Test that LATEX_VAR_TOKEN_RE captures the full token for deeply nested subscripts."""
+        pattern = re.compile(pat.LATEX_VAR_TOKEN_RE)
+        deep_cases = [
+            "M_{a*(c*t_{R_{PACS}})}",
+            "M_{a*(c*t_{R_{P*(A*(C*S))}})}",
+        ]
+        for case in deep_cases:
+            match = pattern.search(case)
+            assert match is not None, f"Failed to match: {case}"
+            assert match.group(0) == case, (
+                f"Partial match for {case}: got '{match.group(0)}'"
+            )
+
     # Cross-Pattern Tests
     def test_all_patterns_exist(self) -> None:
         """Test that all expected pattern variables exist."""