Enhance error messages in parameter operations

CLAUDE.md

@@ -0,0 +1,26 @@
+# PolicyEngine Core - Development Guide 📚
+
+## Common Commands
+- `make all`: Full development cycle (install, format, test, build)
+- `make install`: Install package in dev mode with dependencies
+- `make format`: Format code with Black (79 char line limit)
+- `make test`: Run all tests with coverage
+- `make mypy`: Run type checking
+- `pytest tests/path/to/test_file.py::test_function_name -v`: Run single test
+
+## Code Style Guidelines
+- **Formatting**: Black with 79 character line length
+- **Imports**: Standard library, third-party, local modules (standard Python grouping)
+- **Types**: Use type annotations, checked with mypy
+- **Naming**: snake_case for functions/variables, CamelCase for classes
+- **Error Handling**: Use custom error classes from policyengine_core/errors/
+- **Testing**: All new features need tests, both unit and YAML-based tests supported
+- **PRs**: Include "Fixes #{issue}" in description, add changelog entry, pass all checks
+- **Changelog**: Update changelog_entry.yaml with proper bump type and change description
+- **Dependencies**: All versions must be capped to avoid breaking changes
+- **Python**: 3.10+ required
+
+## Git Workflow
+- First push to a new branch: `git push -u origin feature/branch-name` to set up tracking
+- Subsequent pushes: just use `git push` to update the same PR
+- Always run `make format` before committing to ensure code passes style checks

changelog_entry.yaml

@@ -0,0 +1,6 @@
+- bump: minor
+  changes:
+    added:
+      - A new ParameterPathError class for improved error handling in parameter operations
+    changed:
+      - Enhanced get_parameter error handling with specific error types and helpful suggestions

policyengine_core/parameters/operations/get_parameter.py

@@ -22,12 +22,64 @@ def get_parameter(root: ParameterNode, parameter: str) -> Parameter:
                     name, index = name.split("[")
                     index = int(index[:-1])
                     node = node.children[name].brackets[index]
-                except:
+                except Exception:
+                    # Enhanced error message for bracket syntax errors
                     raise ValueError(
-                        "Invalid bracket syntax (should be e.g. tax.brackets[3].rate"
+                        f"Invalid bracket syntax at '{name}' in parameter path '{parameter}'. "
+                        "Use format: parameter_name[index], e.g., brackets[0].rate"
                     )
-        except:
+        except KeyError:
+            # Enhanced error message for parameter not found
+            similar_params = []
+            if hasattr(node, "children"):
+                similar_params = [
+                    key
+                    for key in node.children.keys()
+                    if (
+                        name.lower() in key.lower()
+                        or key.lower().startswith(name.lower())
+                    )
+                    and "[" not in name
+                ]
+
+            suggestions = (
+                f" Did you mean: {', '.join(similar_params)}?"
+                if similar_params
+                else ""
+            )
+            raise ValueError(
+                f"Parameter '{name}' not found in path '{parameter}'.{suggestions}"
+            )
+        except (IndexError, AttributeError) as e:
+            # Enhanced error message for bracket index errors
+            if isinstance(e, IndexError) and "[" in name:
+                try:
+                    name_part = name.split("[")[0]
+                    max_index = len(node.children[name_part].brackets) - 1
+                    raise ValueError(
+                        f"Bracket index out of range in '{name}' of parameter path '{parameter}'. "
+                        f"Valid indices are 0 to {max_index}."
+                    )
+                except Exception:
+                    pass
+            elif isinstance(e, AttributeError) and "[" in name:
+                name_part = name.split("[")[0]
+                raise ValueError(
+                    f"'{name_part}' in parameter path '{parameter}' does not support bracket indexing. "
+                    "Only scale parameters (like brackets) support indexing."
+                )
+
+            # Generic error message
             raise ValueError(
-                f"Could not find the parameter (failed at {name})."
+                f"Could not find the parameter '{parameter}' (failed at '{name}'). {str(e)}"
             )
+        except ValueError:
+            # Re-raise ValueError directly
+            raise
+        except Exception as e:
+            # Catch-all for other errors
+            raise ValueError(
+                f"Error accessing parameter '{parameter}' at '{name}': {str(e)}"
+            )
+
     return node

tests/core/parameters/operations/test_get_parameter.py

@@ -0,0 +1,74 @@
+import pytest
+from policyengine_core.parameters import ParameterNode
+from policyengine_core.parameters.operations import get_parameter
+
+
+def test_parameter_not_found_message():
+    """Test that not found errors have better messages."""
+    parameters = ParameterNode(
+        data={
+            "tax": {
+                "income_tax": {
+                    "rate": {
+                        "values": {
+                            "2022-01-01": 0.2,
+                        }
+                    },
+                },
+                "sales_tax": {
+                    "rate": {
+                        "values": {
+                            "2022-01-01": 0.1,
+                        }
+                    },
+                },
+            }
+        }
+    )
+
+    # Test parameter not found
+    with pytest.raises(ValueError) as excinfo:
+        get_parameter(parameters, "tax.property_tax.rate")
+
+    # Ensure the error message contains useful information
+    error_message = str(excinfo.value)
+    assert "property_tax" in error_message
+    assert "not found" in error_message
+
+    # Test parameter not found but with similar names
+    with pytest.raises(ValueError) as excinfo:
+        get_parameter(parameters, "tax.income")
+
+    # Check that the suggestion for "income" includes "income_tax"
+    error_message = str(excinfo.value)
+    assert "income" in error_message
+    assert "Did you mean" in error_message
+    assert "income_tax" in error_message
+
+
+def test_invalid_bracket_syntax_message():
+    """Test error handling with invalid bracket syntax."""
+    parameters = ParameterNode(
+        data={
+            "tax": {
+                "brackets": [
+                    {
+                        "threshold": {"values": {"2022-01-01": 0}},
+                        "rate": {"values": {"2022-01-01": 0.1}},
+                    },
+                ],
+            }
+        }
+    )
+
+    # Test invalid bracket syntax (missing closing bracket)
+    with pytest.raises(ValueError) as excinfo:
+        get_parameter(parameters, "tax.brackets[0.rate")
+
+    assert "Invalid bracket syntax" in str(excinfo.value)
+
+    # Test invalid bracket index (not an integer)
+    with pytest.raises(ValueError) as excinfo:
+        get_parameter(parameters, "tax.brackets[a].rate")
+
+    assert "Invalid bracket syntax" in str(excinfo.value)