Calculator: history, live results and expression mode

gradio_calculator.py

@@ -1,41 +1,269 @@
+import ast
+import math
+import operator
+import re
+
 import gradio as gr
 
+OPERATIONS = {
+    "+": lambda a, b: a + b,
+    "-": lambda a, b: a - b,
+    "*": lambda a, b: a * b,
+    "/": lambda a, b: a / b,
+    "^": lambda a, b: a**b,
+    "mod": lambda a, b: a % b,
+    "√": lambda a, b: math.sqrt(a),
+    "% of": lambda a, b: a / 100 * b,
+}
+
+# Operations that only use the first number.
+UNARY_OPS = {"√"}
+
+MAX_EXPRESSION_LENGTH = 200
+MAX_HISTORY = 50
+
+
+def format_result(value):
+    """Show 5 instead of 5.0 and strip floating-point noise like 0.30000000000000004."""
+    value = round(value, 10) + 0.0  # + 0.0 turns -0.0 into 0.0
+    if value.is_integer() and abs(value) < 1e15:
+        return str(int(value))
+    return str(value)
+
+
+def check_result(result):
+    """Turn a raw numeric result into display text, or an error message."""
+    if isinstance(result, complex):
+        return "Result is not a real number"
+    if not math.isfinite(result):
+        return "Result is too large"
+    return format_result(result)
+
 
 def calculate(num1, num2, operation):
+    if operation not in OPERATIONS:
+        return "Invalid operation"
+    if num1 is None:
+        return "Please enter the first number"
+    if num2 is None and operation not in UNARY_OPS:
+        return "Please enter both numbers"
+
     try:
         num1 = float(num1)
-        num2 = float(num2)
-
-        if operation == "+":
-            result = num1 + num2
-        elif operation == "-":
-            result = num1 - num2
-        elif operation == "*":
-            result = num1 * num2
-        elif operation == "/":
-            if num2 == 0:
-                return "Cannot divide by zero"
-            result = num1 / num2
-        else:
-            return "Invalid operation"
-
-        return result
-    except ValueError:
+        num2 = float(num2) if num2 is not None else 0.0
+
+        if operation == "/" and num2 == 0:
+            return "Cannot divide by zero"
+        if operation == "mod" and num2 == 0:
+            return "Cannot take modulo by zero"
+        if operation == "√" and num1 < 0:
+            return "Cannot take square root of a negative number"
+
+        result = OPERATIONS[operation](num1, num2)
+    except OverflowError:
+        return "Result is too large"
+    except (ValueError, TypeError):
         return "Please enter valid numbers"
 
+    return check_result(result)
+
+
+# ---------------------------------------------------------------------------
+# Expression mode: a safe evaluator built on Python's ast module.
+# Only an allow-list of node types is evaluated; nothing is ever exec'd/eval'd.
+# ---------------------------------------------------------------------------
+
+_BINARY_OPS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+}
+_UNARY_OPS = {ast.UAdd: operator.pos, ast.USub: operator.neg}
+
+
+class _InvalidExpression(Exception):
+    pass
+
+
+class _NegativeSqrt(Exception):
+    pass
+
+
+def _eval_node(node):
+    if isinstance(node, ast.Constant):
+        # bool is a subclass of int, so reject it explicitly.
+        if isinstance(node.value, (int, float)) and not isinstance(node.value, bool):
+            return float(node.value)  # floats overflow fast instead of building huge ints
+        raise _InvalidExpression
+    if isinstance(node, ast.BinOp) and type(node.op) in _BINARY_OPS:
+        return _BINARY_OPS[type(node.op)](_eval_node(node.left), _eval_node(node.right))
+    if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY_OPS:
+        return _UNARY_OPS[type(node.op)](_eval_node(node.operand))
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "sqrt"
+        and len(node.args) == 1
+        and not node.keywords
+    ):
+        value = _eval_node(node.args[0])
+        if isinstance(value, complex):
+            raise _InvalidExpression
+        if value < 0:
+            raise _NegativeSqrt
+        return math.sqrt(value)
+    raise _InvalidExpression
+
+
+def _normalise_expression(text):
+    text = text.strip()
+    text = text.replace("^", "**").replace("×", "*").replace("÷", "/")
+    text = re.sub(r"\bmod\b", "%", text)
+    text = text.replace("√", "sqrt")
+    # Allow "sqrt16" / "√16" without parentheses.
+    text = re.sub(r"sqrt\s*(\d+(?:\.\d+)?)", r"sqrt(\1)", text)
+    return text
+
+
+def evaluate_expression(text):
+    if text is None or not text.strip():
+        return ""
+    if len(text) > MAX_EXPRESSION_LENGTH:
+        return "Invalid expression"
+
+    try:
+        tree = ast.parse(_normalise_expression(text), mode="eval")
+        result = _eval_node(tree.body)
+    except ZeroDivisionError:
+        return "Cannot divide by zero"
+    except _NegativeSqrt:
+        return "Cannot take square root of a negative number"
+    except OverflowError:
+        return "Result is too large"
+    except (_InvalidExpression, SyntaxError, ValueError, TypeError, RecursionError):
+        return "Invalid expression"
+
+    return check_result(result)
+
+
+# ---------------------------------------------------------------------------
+# History helpers (no Gradio dependency, so they're easy to test).
+# ---------------------------------------------------------------------------
+
+
+def _is_number(text):
+    try:
+        float(text)
+        return True
+    except (TypeError, ValueError):
+        return False
+
+
+def describe_simple(num1, num2, operation):
+    """Left-hand side of a history entry for the Simple tab, e.g. '2 + 3'."""
+    left = format_result(float(num1))
+    if operation in UNARY_OPS:
+        return f"{operation} {left}"
+    return f"{left} {operation} {format_result(float(num2))}"
+
+
+def add_to_history(history, entry_left, result):
+    """Return a new history list with 'entry_left = result' on top.
+
+    Errors and blank results are not saved, and neither is a repeat of the latest entry.
+    """
+    if not _is_number(result):
+        return history
+    entry = f"{entry_left} = {result}"
+    if history and history[0] == entry:
+        return history
+    return [entry, *history][:MAX_HISTORY]
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+
+def live_calculate(num1, num2, operation):
+    """Live result for the Simple tab: stay blank until the inputs are filled in."""
+    if num1 is None or (num2 is None and operation not in UNARY_OPS):
+        return ""
+    return calculate(num1, num2, operation)
+
+
+def save_simple(history, num1, num2, operation):
+    result = live_calculate(num1, num2, operation)
+    if _is_number(result):
+        history = add_to_history(history, describe_simple(num1, num2, operation), result)
+    return history, "\n".join(history)
+
+
+def save_expression(history, text):
+    result = evaluate_expression(text)
+    if _is_number(result):
+        history = add_to_history(history, text.strip(), result)
+    return history, "\n".join(history)
+
 
 with gr.Blocks() as demo:
     gr.Markdown("# Simple Calculator")
+    history = gr.State([])
+
+    with gr.Tabs():
+        with gr.Tab("Simple"):
+            with gr.Row():
+                num1 = gr.Number(label="First number")
+                operation = gr.Dropdown(list(OPERATIONS), label="Operation", value="+")
+                num2 = gr.Number(label="Second number")
+            simple_result = gr.Textbox(label="Result", interactive=False)
+            simple_save = gr.Button("Save to history")
+
+        with gr.Tab("Expression"):
+            expr = gr.Textbox(
+                label="Expression",
+                placeholder="e.g. (2 + 3) * 4 / 2,  2^10,  sqrt(16),  10 mod 3",
+            )
+            expr_result = gr.Textbox(label="Result", interactive=False)
+            expr_save = gr.Button("Save to history")
+
+    history_box = gr.Textbox(label="History", lines=8, interactive=False)
+    clear_button = gr.Button("Clear history")
 
-    with gr.Row():
-        num1 = gr.Number(label="First number")
-        operation = gr.Dropdown(["+", "-", "*", "/"], label="Operation", value="+")
-        num2 = gr.Number(label="Second number")
+    # Live results
+    gr.on(
+        triggers=[num1.change, num2.change, operation.change],
+        fn=live_calculate,
+        inputs=[num1, num2, operation],
+        outputs=simple_result,
+    )
+    expr.change(fn=evaluate_expression, inputs=expr, outputs=expr_result)
 
-    calc_button = gr.Button("Calculate")
-    output = gr.Textbox(label="Result")
+    # Hide the second number for square root
+    operation.change(
+        fn=lambda op: gr.update(visible=op not in UNARY_OPS),
+        inputs=operation,
+        outputs=num2,
+    )
 
-    calc_button.click(fn=calculate, inputs=[num1, num2, operation], outputs=output)
+    # Save to history: button or Enter
+    gr.on(
+        triggers=[simple_save.click, num1.submit, num2.submit],
+        fn=save_simple,
+        inputs=[history, num1, num2, operation],
+        outputs=[history, history_box],
+    )
+    gr.on(
+        triggers=[expr_save.click, expr.submit],
+        fn=save_expression,
+        inputs=[history, expr],
+        outputs=[history, history_box],
+    )
+    clear_button.click(fn=lambda: ([], ""), outputs=[history, history_box])
 
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()

test_calculator.py

@@ -0,0 +1,153 @@
+import pytest
+
+from gradio_calculator import calculate
+
+
+@pytest.mark.parametrize(
+    "num1, num2, op, expected",
+    [
+        (2, 3, "+", "5"),
+        (0.1, 0.2, "+", "0.3"),
+        (5, 8, "-", "-3"),
+        (4, 2.5, "*", "10"),
+        (7, 2, "/", "3.5"),
+        (1, 3, "/", "0.3333333333"),
+        (2, 10, "^", "1024"),
+        (10, 3, "mod", "1"),
+        (16, None, "√", "4"),
+        (2, None, "√", "1.4142135624"),
+        (15, 240, "% of", "36"),
+        (0, -5, "*", "0"),
+    ],
+)
+def test_operations(num1, num2, op, expected):
+    assert calculate(num1, num2, op) == expected
+
+
+@pytest.mark.parametrize(
+    "num1, num2, op, expected",
+    [
+        (None, 3, "+", "Please enter the first number"),
+        (2, None, "+", "Please enter both numbers"),
+        (None, None, "√", "Please enter the first number"),
+        (1, 0, "/", "Cannot divide by zero"),
+        (1, 0, "mod", "Cannot take modulo by zero"),
+        (-4, None, "√", "Cannot take square root of a negative number"),
+        (10, 1000, "^", "Result is too large"),
+        (1e308, 10, "*", "Result is too large"),
+        (-8, 0.5, "^", "Result is not a real number"),
+        (1, 2, "?", "Invalid operation"),
+    ],
+)
+def test_errors(num1, num2, op, expected):
+    assert calculate(num1, num2, op) == expected
+
+
+# --- Expression mode -------------------------------------------------------
+
+from gradio_calculator import (  # noqa: E402
+    MAX_HISTORY,
+    add_to_history,
+    describe_simple,
+    evaluate_expression,
+)
+
+
+@pytest.mark.parametrize(
+    "text, expected",
+    [
+        ("2 + 3 * 4", "14"),
+        ("(2 + 3) * 4 / 2", "10"),
+        ("2^10", "1024"),
+        ("2 ** 3", "8"),
+        ("10 mod 3", "1"),
+        ("10 % 3", "1"),
+        ("-3 + 5", "2"),
+        ("sqrt(16)", "4"),
+        ("√16", "4"),
+        ("√(9) + 1", "4"),
+        ("0.1 + 0.2", "0.3"),
+        ("6 × 7 ÷ 2", "21"),
+        ("  7  ", "7"),
+        ("", ""),
+        ("   ", ""),
+    ],
+)
+def test_expression_values(text, expected):
+    assert evaluate_expression(text) == expected
+
+
+@pytest.mark.parametrize(
+    "text, expected",
+    [
+        ("1 / 0", "Cannot divide by zero"),
+        ("5 % 0", "Cannot divide by zero"),
+        ("sqrt(-4)", "Cannot take square root of a negative number"),
+        ("9^9^9", "Result is too large"),
+        ("1e308 * 10", "Result is too large"),
+        ("(-8)^0.5", "Result is not a real number"),
+        ("2 +", "Invalid expression"),
+    ],
+)
+def test_expression_errors(text, expected):
+    assert evaluate_expression(text) == expected
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "__import__('os')",
+        "open('x')",
+        "a + 1",
+        "'abc'",
+        "(1).__class__",
+        "lambda: 1",
+        "True + 1",
+        "1j * 2",
+        "sqrt(4, 2)",
+        "pow(2, 3)",
+        "1 + " * 60 + "1",  # longer than 200 characters
+    ],
+)
+def test_expression_rejects_unsafe_input(text):
+    assert evaluate_expression(text) == "Invalid expression"
+
+
+# --- History ---------------------------------------------------------------
+
+
+def test_describe_simple():
+    assert describe_simple(2, 3, "+") == "2 + 3"
+    assert describe_simple(16, None, "√") == "√ 16"
+    assert describe_simple(15, 240, "% of") == "15 % of 240"
+    assert describe_simple(2.5, 4.0, "*") == "2.5 * 4"
+
+
+def test_history_adds_newest_first():
+    history = add_to_history([], "2 + 3", "5")
+    history = add_to_history(history, "4 * 5", "20")
+    assert history == ["4 * 5 = 20", "2 + 3 = 5"]
+
+
+def test_history_skips_errors_and_blanks():
+    assert add_to_history([], "1 / 0", "Cannot divide by zero") == []
+    assert add_to_history([], "", "") == []
+
+
+def test_history_skips_consecutive_duplicates():
+    history = add_to_history([], "2 + 3", "5")
+    assert add_to_history(history, "2 + 3", "5") == ["2 + 3 = 5"]
+
+
+def test_history_does_not_mutate_input():
+    original = ["2 + 3 = 5"]
+    add_to_history(original, "1 + 1", "2")
+    assert original == ["2 + 3 = 5"]
+
+
+def test_history_is_capped():
+    history = []
+    for i in range(MAX_HISTORY + 10):
+        history = add_to_history(history, f"{i} + 0", str(i))
+    assert len(history) == MAX_HISTORY
+    assert history[0] == f"{MAX_HISTORY + 9} + 0 = {MAX_HISTORY + 9}"