Create calculator.py

calculator.py

@@ -0,0 +1,228 @@
+# calculator.py
+import re
+import math
+import operator
+from typing import List, Dict, Optional
+from contextlib import contextmanager
+import signal
+from functools import reduce
+from fractions import Fraction
+
+
+# TIMEOUT 
+@contextmanager
+def timeout(duration: int = 1):
+    def handler(signum, frame):
+        raise TimeoutError(f"Timeout after {duration}s")
+
+    signal.signal(signal.SIGALRM, handler)
+    signal.alarm(duration)
+    try:
+        yield
+    finally:
+        signal.alarm(0)
+
+
+# SAFE EVAL  
+def safe_eval(expr: str) -> Optional[float]:
+    expr = expr.strip().replace(",", "").replace("^", "**")
+
+    # SECURITY: BLOCK __class__, .., .x
+    if ".." in expr or "__" in expr:
+        return None
+    if re.search(r'\.\w', expr) and not re.search(r'\d\.', expr):
+        return None
+
+    # BLOCK GIANT EXPONENTS
+    if "**" in expr:
+        try:
+            _, exp_str = expr.split("**", 1)
+            exp = float(re.split(r'[\s+\-*/)]', exp_str)[0])
+            if abs(exp) > 20:
+                return None
+        except:
+            pass
+
+    # BLOCK SCIENTIFIC NOTATION OVERFLOW
+    sci_match = re.search(r'\d+e[+\-]?\d+', expr, re.IGNORECASE)
+    if sci_match:
+        try:
+            exp = int(re.search(r'e([+\-]?\d+)', sci_match.group(0), re.IGNORECASE).group(1))
+            if abs(exp) > 50:
+                return None
+        except:
+            return None
+
+    # FRACTION SIMPLIFICATION
+    if "/" in expr and not re.search(r'//', expr):
+        try:
+            parts = [p.strip() for p in expr.split("/", 1)]
+            if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
+                return float(Fraction(int(parts[0]), int(parts[1])))
+        except:
+            pass
+
+    # ALLOW % (modulo)
+    expr = expr.replace("%", " % ")
+
+    if not re.match(r'^[0-9+\-*/().%\s\*\^]+$', expr):
+        return None
+
+    try:
+        with timeout(1):
+            result = eval(expr, {"__builtins__": {}})
+            return float(result)
+    except:
+        return None
+
+
+# EXTRACT << (GREEDY RIGHTMOST) 
+def extract_calc(text: str) -> Optional[str]:
+    match = re.search(r'<<([^>]*)(?:>>|$)', text)
+    if not match:
+        return None
+    expr = match.group(1).strip()
+    return expr if expr else None
+
+
+# VARIABLE REPLACEMENT (longest first) 
+def substitute_variables(expr: str, context: Dict[str, float]) -> str:
+    for var in sorted(context.keys(), key=len, reverse=True):
+        expr = re.sub(rf'\b{re.escape(var)}\b', str(context[var]), expr)
+    return expr
+
+
+#  NESTED FUNCTION PARSER  
+def parse_nested_func(expr: str, allowed_funcs: set = None) -> Optional[float]:
+    if allowed_funcs is None:
+        allowed_funcs = {"sqrt", "log", "pow", "max", "min", "abs", "sin", "cos", "tan", "exp"}
+
+    def eval_inner(inner: str) -> float:
+        inner = inner.strip()
+        if inner.startswith("(") and inner.endswith(")"):
+            inner = inner[1:-1]
+        return parse_nested_func(inner, allowed_funcs) or safe_eval(inner) or 0.0
+
+    match = re.match(r'^([a-zA-Z_]\w*)\((.+)\)$', expr.strip())
+    if not match:
+        return None
+    func_name, args_str = match.groups()
+
+    if func_name not in allowed_funcs:
+        return None
+
+    # Split top-level commas
+    args = []
+    depth = 0
+    current = ""
+    for char in args_str:
+        if char == "," and depth == 0:
+            args.append(current)
+            current = ""
+        else:
+            current += char
+            if char == "(": depth += 1
+            if char == ")": depth -= 1
+    if current:
+        args.append(current)
+
+    try:
+        arg_vals = [eval_inner(a) for a in args]
+
+        # BLOCK GIANT pow() AND exp()
+        if func_name == "pow" and len(arg_vals) >= 2 and abs(arg_vals[1]) > 20:
+            return None
+        if func_name == "exp" and arg_vals and abs(arg_vals[0]) > 20:
+            return None
+
+        func_map = {
+            "sqrt": lambda x: math.sqrt(x[0]),
+            "log": lambda x: math.log(x[0], x[1]) if len(x) > 1 else math.log(x[0]),
+            "pow": lambda x: x[0] ** x[1],
+            "max": lambda x: max(x),
+            "min": lambda x: min(x),
+            "abs": lambda x: abs(x[0]),
+            "sin": lambda x: math.sin(x[0]),
+            "cos": lambda x: math.cos(x[0]),
+            "tan": lambda x: math.tan(x[0]),
+            "exp": lambda x: math.exp(x[0]),
+        }
+        return func_map[func_name](arg_vals)
+    except:
+        return None
+
+
+# === SEQUENCE + RANGE (NESTED) ===
+def parse_range(range_str: str) -> List[float]:
+    match = re.match(r'(-?\d+)\.\.(-?\d+)', range_str.strip())
+    if not match:
+        return []
+    start, end = map(int, match.groups())
+    step = 1 if start <= end else -1
+    return list(range(start, end + step, step))
+
+
+def evaluate_sequence(expr: str) -> Optional[float]:
+    match = re.match(r'(sum|prod|mean)\((.*)\)', expr.replace(" ", ""))
+    if not match:
+        return None
+    op, args_str = match.groups()
+
+    def parse_arg(arg: str):
+        arg = arg.strip()
+        if ".." in arg:
+            return parse_range(arg)
+        val = parse_nested_func(arg) or safe_eval(arg)
+        return [val] if val is not None else []
+
+    args = []
+    depth = 0
+    current = ""
+    for char in args_str:
+        if char == "," and depth == 0:
+            args.extend(parse_arg(current))
+            current = ""
+        else:
+            current += char
+            if char == "(": depth += 1
+            if char == ")": depth -= 1
+    if current:
+        args.extend(parse_arg(current))
+
+    if not args:
+        return None
+
+    if op == "sum": return sum(args)
+    if op == "prod": return reduce(operator.mul, args, 1)
+    if op == "mean": return sum(args) / len(args)
+    return None
+
+
+# CALCULATOR 
+def calculate(expr: str, context: Dict[str, float] = None) -> Optional[str]:
+    if context is None:
+        context = {}
+    expr = substitute_variables(expr, context)
+
+    seq = evaluate_sequence(expr)
+    if seq is not None:
+        return f"{expr}={seq}>>"
+
+    func = parse_nested_func(expr)
+    if func is not None:
+        return f"{expr}={func}>>"
+
+    basic = safe_eval(expr)
+    if basic is not None:
+        return f"{expr}={basic}>>"
+
+    return None
+
+
+# PUBLIC API 
+def use_calculator(text: str, context: Dict[str, float] = None) -> Optional[str]:
+    expr = extract_calc(text)
+    if not expr:
+        return None
+    return calculate(expr, context)
+