py-05-calc

# Arithmetic Expression Evaluator

Implement a file **`solution.py`** containing a function:

```python
def evaluate(expr: str) -> float:
    ...
```

Evaluate an arithmetic expression given as a string and return its value as a
`float`.

Supported syntax:

- Binary operators `+`, `-`, `*`, `/` with standard precedence
  (`*` and `/` bind tighter than `+` and `-`) and left-to-right associativity.
- Parentheses `(` ... `)` for grouping.
- Unary plus and minus, e.g. `-3`, `-(2 + 1)`, `2 * -3`.
- Integer and float literals, e.g. `42`, `3.14`, `.5`, `10.`.
- Arbitrary surrounding / internal whitespace, which is ignored.

Requirements:

- Return the numeric result as a `float`. For example
  `evaluate("1 + 2 * 3") == 7.0` and `evaluate("(1 + 2) * 3") == 9.0`.
- Implement a real parser/evaluator that respects precedence and parentheses.
  **Do not** use `eval`, `exec`, or similar (the harness may inspect for this).
- Raise `ValueError` on malformed input. Malformed includes: empty / whitespace-only
  input, unbalanced parentheses, a missing operand or operator (e.g. `"1 +"`,
  `"1 2"`, `"* 3"`), and unexpected characters.
- Division by zero should raise an error (a `ZeroDivisionError` or `ValueError`
  is acceptable).

Examples:

```python
evaluate("2 + 3 * 4")      # 14.0
evaluate("(2 + 3) * 4")    # 20.0
evaluate("10 / 4")         # 2.5
evaluate("-3 + 2")         # -1.0
evaluate("2 * (1 + -1.5)") # -1.0
```

import pytest

from solution import evaluate


def test_simple_addition():
    assert evaluate("1 + 2") == 3.0


def test_precedence():
    assert evaluate("2 + 3 * 4") == 14.0
    assert evaluate("1 + 2 * 3") == 7.0


def test_parentheses_override_precedence():
    assert evaluate("(2 + 3) * 4") == 20.0
    assert evaluate("(1 + 2) * 3") == 9.0


def test_division_is_float():
    assert evaluate("10 / 4") == 2.5
    assert isinstance(evaluate("4 / 2"), float)


def test_unary_minus():
    assert evaluate("-3 + 2") == -1.0
    assert evaluate("2 * -3") == -6.0
    assert evaluate("-(2 + 1)") == -3.0


def test_float_and_whitespace():
    assert evaluate("  3.14 + .86 ") == pytest.approx(4.0)
    assert evaluate("10. / 4") == 2.5


def test_left_associativity():
    assert evaluate("10 - 2 - 3") == 5.0
    assert evaluate("100 / 5 / 2") == 10.0


def test_nested_parens():
    assert evaluate("2 * (1 + (3 - 1) * 2)") == 10.0


def test_malformed_raises_value_error():
    for bad in ["", "   ", "1 +", "* 3", "1 2", "(1 + 2", "1 + 2)", "1 + * 2", "3 $ 4"]:
        with pytest.raises(ValueError):
            evaluate(bad)


def test_division_by_zero_raises():
    with pytest.raises((ValueError, ZeroDivisionError)):
        evaluate("1 / 0")

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

The task is to implement an arithmetic expression evaluator that:

1. Supports binary operators `+`, `-`, `*`, `/` with standard precedence
2. Supports parentheses for grouping
3. Supports unary plus and minus
4. Supports integer and float literals
5. Handles arbitrary whitespace
6. Returns a float
7. Does NOT use `eval`, `exec`, or similar
8. Raises `ValueError` on malformed input
9. Division by zero should raise an error

I'll implement a recursive descent parser or a shunting-yard algorithm. Let me go with a recursive descent parser as it's cleaner for this use case.

The grammar would be:
```
expression -> term (('+' | '-') term)*
term -> factor (('*' | '/') factor)*
factor -> number | '(' expression ')' | '-' factor | '+' factor
number -> integer | decimal
integer -> digit+
decimal -> digit+ '.' | '.' | digit+ '.' digit* | '.' digit+
```

Let me write the solution:

```python
import re

def evaluate(expr: str) -> float:
    # Remove all whitespace
    expr = expr.replace(' ', '')
    
    # Check for empty input
    if not expr:
        raise ValueError("Empty input")
    
    # Check for unexpected characters
    if not re.match(r'^[\d\.\+\-\(\)\/*\s]+$', expr):
        raise ValueError("Unexpected characters")
    
    # Remove whitespace again after checking
    expr = expr.replace(' ', '')
    
    # Check for balanced parentheses
    if expr.count('(') != expr.count(')'):
        raise ValueError("Unbalanced parentheses")
    
    # Check for valid characters
    if not re.match(r'^[\d\.\+\-\(\)\/*]+$', expr):
        raise ValueError("Unexpected characters")
    
    # Check for leading/trailing operators
    if expr[0] in '+-*/' or expr[-1] in '+-*/':
        raise ValueError("Missing operand")
    
    # Check for consecutive operators
    if re.search(r'[\+\-\*/][\+\-\*/]', expr):
        raise ValueError("Missing operand")
    
    # Check for consecutive numbers (no operator between)
    if re.search(r'\d[\d\.\+\-\(\)\/*]*\d', expr):
        raise ValueError("Missing operator")
    
    # Check for empty parentheses
    if re.search(r'\(\)', expr):
        raise ValueError("Empty parentheses")
    
    # Check for operator at start or end
    if expr[0] in '+-*/' or expr[-1] in '+-*/':
        raise ValueError("Missing operand")
    
    # Check for consecutive operators
    if re.search(r'[\+\-\*/][\+\-\*/]', expr):
        raise ValueError("Missing operator")
    
    # Check for consecutive numbers (no operator between)
    if re.search(r'\d[\d\.\+\-\(\)\/*]*\d', expr):
        raise ValueError("Missing operator")
    
    # Check for empty parentheses
    if re.search(r'\(\)', expr):
        raise ValueError("Empty parentheses")
    
    # Check for operator at start or end
    if expr[0] in '+-*/' or expr[-1] in '+-*/':
        raise ValueError("Missing operand")
    
    # Check for consecutive operators
    if re.search(r'[\+\-\*/][\+\-\*/]', expr):
        raise ValueError("Missing operator")
    
    # Check for consecutive numbers (no operator between)
    if re.search(r'\d[\d\.\+\-\(\)\/*]*\d', expr):
        raise ValueError("Missing operator")
    
    # Check for empty parentheses
    if re.search(r'\(\)', expr):
        raise ValueError("Empty parentheses")
    
    # Check for operator at start or end
    if expr[0] in '+-*/' or expr[-1] in '+-*/':
        raise ValueError("Missing operand")
    
    # Check for consecutive operators
    if re.search(r'[\+\-\*/][\+\-\*/]', expr):
        raise ValueError("Missing operator