"Vibe-Trading: Your Personal Trading Agent"
Python ai-agentalgorithmic-tradingbacktestingfintechllmmcpmulti-agentpythonquantitative-financetrading
fix(grounding): normalize percent operands before evaluating arithmetic
Haozhe Wu34cb267e7bb6
diff --git a/agent/src/agent/grounding/policies.py b/agent/src/agent/grounding/policies.pyindex bd7d3f4dc..2a9fa82f9 100644--- a/agent/src/agent/grounding/policies.py+++ b/agent/src/agent/grounding/policies.py@@ -295,11 +295,17 @@ def _unanchored_term(tree: ast.Expression, observed: Callable[[float], bool]) ->return visit(tree.body, False)-def _evaluate_formula(expression: str) -> tuple[float, list[float], ast.Expression] | None:+def _evaluate_formula(+ expression: str,+ *,+ operand_transform: Callable[[float], float] | None = None,+) -> tuple[float, list[float], ast.Expression] | None:"""Evaluate a numeric ``+ - * /`` expression without executing code.Args:expression: An arithmetic run, possibly using ``× ÷ −`` and commas.+ operand_transform: Optional unit conversion for numeric operands;+ recorded input magnitudes and power exponents remain unchanged.Returns:``(result, operands, parsed tree)``, or None when the run is not a@@ -332,13 +338,13 @@ def _evaluate_formula(expression: str) -> tuple[float, list[float], ast.Expressireturn Noneinputs: list[float] = []- def visit(node: ast.AST) -> float:+ def visit(node: ast.AST, *, unit_one: bool = False, factor: bool = False) -> float:if isinstance(node, ast.Expression):return visit(node.body)if isinstance(node, ast.Constant) and _is_number(node.value):value = float(node.value)inputs.append(value)- return value+ return operand_transform(value) if operand_transform and not (unit_one and value == 1) else valueif isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):value = visit(node.operand)return value if isinstance(node.op, ast.UAdd) else -value@@ -351,8 +357,14 @@ def _evaluate_formula(expression: str) -> tuple[float, list[float], ast.Expressiif isinstance(node, ast.BinOp) and isinstance(node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div)):- left = visit(node.left)- right = visit(node.right)+ multiplicative = isinstance(node.op, (ast.Mult, ast.Div))+ unit_factor = factor and _is_unit_factor(node)+ left = visit(node.left, factor=multiplicative, unit_one=(+ multiplicative or unit_factor or (isinstance(node.right, ast.BinOp) and isinstance(node.right.op, ast.Div))+ ))+ right = visit(node.right, factor=multiplicative, unit_one=(+ multiplicative or unit_factor or (isinstance(node.left, ast.BinOp) and isinstance(node.left.op, ast.Div))+ ))if isinstance(node.op, ast.Add):return left + rightif isinstance(node.op, ast.Sub):@@ -1857,7 +1869,6 @@ class _PolicyMixin:# Normalize ONLY an outer, trailing literal *100 back to a fraction;# do not broaden result matching or exempt any inner data operand.# Numeric magnitude elsewhere never decides whether an operand is data.- normalized_x100 = Falseif (percentand isinstance(tree.body, ast.BinOp)@@ -1869,7 +1880,6 @@ class _PolicyMixin:result /= 100operands = operands[:-1]tree = ast.Expression(body=tree.body.left)- normalized_x100 = True# Two instruments' bars and no resolved symbol: arithmetic anchored on# the session's pools, or on one instrument's prints the ref names,# would look anchored with nothing to anchor it to. Only evidence that@@ -1958,11 +1968,26 @@ class _PolicyMixin:# trailing *100 was normalized above, anything else is a fraction.points = (percent- and not normalized_x100and self._operands_read_as_points(operands, symbol, records, scalar_parameters))+ if points:+ # Convert the inputs before evaluating: two point-valued inputs+ # divided by each other yield a fraction, not another point value.+ # Keep the original magnitudes for all anchoring checks above.+ def as_fraction(value: float) -> float:+ if any(+ math.isclose(abs(value), abs(parameter), rel_tol=1e-12, abs_tol=0.0)+ for parameter in scalar_parameters+ ):+ return value+ return value / 100.0++ normalized = _evaluate_formula(ast.unparse(tree), operand_transform=as_fraction)+ if normalized is None:+ return "formula_not_evaluable"+ result = normalized[0] * 100.0return result, operands, pointsdef _operands_read_as_points(@@ -1984,8 +2009,7 @@ class _PolicyMixin:data = [operandfor operand in operands- if operand != 1- and not any(+ if not any(math.isclose(abs(operand), abs(parameter), rel_tol=1e-12, abs_tol=0.0)for parameter in scalar_parameters)@@ -2019,6 +2043,8 @@ class _PolicyMixin:saw_percent = Trueelse:saw_plain = True+ if operand == 1 and not saw_percent and not saw_plain:+ continue # Structural multiplicative identity, not a data unit.if not saw_percent or saw_plain:return Falsereturn Truediff --git a/agent/tests/test_grounding_keyed_metric_paths.py b/agent/tests/test_grounding_keyed_metric_paths.pyindex 66f9811f4..4c19ffd9b 100644--- a/agent/tests/test_grounding_keyed_metric_paths.py+++ b/agent/tests/test_grounding_keyed_metric_paths.py@@ -59,7 +59,7 @@ def test_scalar_contribution_is_not_reclassified_as_an_instrument_map(tmp_path):ledger = _ledger(tmp_path, {"contribution_pct": 0.125})(entry,) = ledger._analysis_metricsassert entry["instrument_scoped"] is False- assert ledger._metric_pool("AAPL.US") == [0.125]+ assert set(ledger._metric_pool("AAPL.US")) == {0.125}def test_correlation_matrix_cells_have_two_axes_and_no_single_symbol(tmp_path):diff --git a/agent/tests/test_grounding_percent_unit_fields.py b/agent/tests/test_grounding_percent_unit_fields.pyindex 76f6b3ae0..ca506bcbc 100644--- a/agent/tests/test_grounding_percent_unit_fields.py+++ b/agent/tests/test_grounding_percent_unit_fields.py@@ -18,6 +18,8 @@ from __future__ import annotationsimport jsonfrom pathlib import Path+import pytest+from src.agent.grounding import GroundingLedger@@ -123,3 +125,40 @@ def test_mixed_fields_keep_the_fraction_reading(tmp_path: Path) -> None:valid, reasons = _verdict(ledger, "1.93%", "0.52 + 1.41")assert not validassert "derivation_result_mismatch" in reasons+++ "expression,correct,wrong",+ [+ ("0.52 / 1.41", "36.88%", "0.37%"),+ ("0.52 / 1.41 * 100", "36.88%", "0.37%"),+ ("(0.52 - 1.41) / 1.41", "-63.12%", "-0.63%"),+ ("0.52 * 1.41", "0.007332%", "0.7332%"),+ ("(1 + 0.52) * (1 + 1.41)", "101.937332%", "366.32%"),+ ],+)+def test_percent_operand_units_follow_the_formula(+ tmp_path: Path, expression: str, correct: str, wrong: str+) -> None:+ """Percentage-point inputs are converted before arithmetic, not after it."""+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "changepercent": 0.52},+ {"trade_date": "2026-08-04", "changepercent": 1.41},+ ],+ )+ valid, reasons = _verdict(ledger, correct, expression)+ assert valid, reasons+ valid, reasons = _verdict(ledger, wrong, expression)+ assert not valid+ assert "derivation_result_mismatch" in reasons+++def test_one_point_is_data_in_an_additive_sum(tmp_path):+ ledger = _ledger_with_rows(tmp_path, [+ {"trade_date": "2026-08-03", "changepercent": 1.0},+ {"trade_date": "2026-08-04", "changepercent": 2.0},+ ])+ assert _verdict(ledger, "3%", "1 + 2")[0]+ assert not _verdict(ledger, "102%", "1 + 2")[0]