Create app.py

app.py

@@ -0,0 +1,157 @@
+import gradio as gr
+import math
+import re
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, field_validator
+
+app = FastAPI()
+
+ALLOWED_FUNCTIONS = {'sin', 'cos', 'tan', 'log', 'ln', 'sqrt', 'abs', 'pow'}
+ALLOWED_CONSTANTS = {'pi', 'e'}
+
+class Expression(BaseModel):
+    expr: str
+
+    @field_validator('expr')
+    @classmethod
+    def validate_expression(cls, v: str) -> str:
+        if not v:
+            raise ValueError("Expression cannot be empty")
+        
+        # Check for invalid characters
+        invalid_chars = re.findall(r'[^\d\s\+\-\*/\(\)\^\.\w]', v)
+        if invalid_chars:
+            raise ValueError(f"Invalid characters found: {', '.join(invalid_chars)}")
+        
+        # Check for invalid function names or constants
+        tokens = re.findall(r'\b[a-zA-Z_]\w*\b', v)
+        invalid_tokens = [token for token in tokens if token not in ALLOWED_FUNCTIONS and token not in ALLOWED_CONSTANTS]
+        if invalid_tokens:
+            raise ValueError(f"Invalid function or constant names: {', '.join(invalid_tokens)}")
+        
+        return v
+
+@app.post("/calculate")
+async def calculate_api(expression: Expression):
+    try:
+        result = evaluate_expression(expression.expr)
+        return {"result": result}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
+def evaluate_expression(expr: str) -> float:
+    safe_dict = {
+        'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
+        'log': math.log10, 'ln': math.log, 'sqrt': math.sqrt,
+        'pi': math.pi, 'e': math.e,
+        'abs': abs, 'pow': pow
+    }
+    try:
+        # Replace '^' with '**' for exponentiation
+        expr = expr.replace('^', '**')
+        return eval(expr, {"__builtins__": None}, safe_dict)
+    except ZeroDivisionError:
+        raise ValueError("Division by zero is not allowed")
+    except ValueError as e:
+        raise ValueError(f"Math domain error: {str(e)}")
+    except Exception as e:
+        raise ValueError(f"Invalid expression: {str(e)}")
+
+# Global variable to store calculation history
+history = []
+
+def calculate(expression):
+    try:
+        result = evaluate_expression(expression)
+        result_str = f"{result:.8f}".rstrip('0').rstrip('.')
+        global history
+        history.append(f"{expression} = {result_str}")
+        history = history[-5:]
+        return "0", result_str, "\n".join(reversed(history))
+    except Exception as e:
+        return expression, f"Error: {str(e)}", "\n".join(reversed(history))
+
+def update_expression(expression, value):
+    if expression == "0" and value not in ['.', '(', ')']:
+        return value
+    if value in ['sin', 'cos', 'tan', 'log', 'ln', 'sqrt']:
+        return expression + value + '('
+    return expression + value
+
+def backspace(expression):
+    return expression[:-1] if len(expression) > 1 else "0"
+
+def clear(expression):
+    return "0"
+
+css = """
+.calculator-display { font-family: 'Digital-7', 'Courier New', monospace; font-size: 24px; }
+.calculator-result { font-family: 'Digital-7', 'Courier New', monospace; font-size: 72px; }
+.calculator-button { font-family: 'Arial', sans-serif; font-size: 18px; }
+.number-button { background-color: #e0e0e0; }
+.basic-op-button { background-color: #f0f0f0; }
+.advanced-op-button { background-color: #ffa500; }
+.calculator-box { border: 1px solid #ccc; padding: 10px; margin: 5px; border-radius: 5px; }
+"""
+
+with gr.Blocks(css=css) as iface:
+    gr.Markdown("# Scientific Calculator")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            display = gr.Textbox(value="0", label="Display", elem_classes=["calculator-display"])
+        with gr.Column(scale=1):
+            result_display = gr.Textbox(value="", label="Result", elem_classes=["calculator-result"])
+    
+    with gr.Row():
+        history_display = gr.Textbox(label="History (Last 5 Calculations)", lines=5)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            with gr.Column(elem_classes=["calculator-box"]):
+                # Number pad (3x4 grid)
+                for i in range(3):
+                    with gr.Row():
+                        for j in range(3):
+                            num = str(7 - 3*i + j)
+                            gr.Button(num, elem_classes=["calculator-button", "number-button"]).click(
+                                lambda x, v=num: update_expression(x, v), inputs=display, outputs=display)
+                with gr.Row():
+                    gr.Button("0", elem_classes=["calculator-button", "number-button"]).click(
+                        lambda x: update_expression(x, "0"), inputs=display, outputs=display)
+                    gr.Button(".", elem_classes=["calculator-button", "number-button"]).click(
+                        lambda x: update_expression(x, "."), inputs=display, outputs=display)
+                    gr.Button("=", elem_classes=["calculator-button", "basic-op-button"]).click(
+                        calculate, inputs=display, outputs=[display, result_display, history_display])
+        
+        with gr.Column(scale=1):
+            with gr.Column(elem_classes=["calculator-box"]):
+                # Basic operations
+                for op, symbol in [("add", "+"), ("sub", "-"), ("mul", "*"), ("div", "/")]:
+                    gr.Button(symbol, elem_classes=["calculator-button", "basic-op-button"]).click(
+                        lambda x, v=symbol: update_expression(x, v), inputs=display, outputs=display)
+                gr.Button("(", elem_classes=["calculator-button", "basic-op-button"]).click(
+                    lambda x: update_expression(x, "("), inputs=display, outputs=display)
+                gr.Button(")", elem_classes=["calculator-button", "basic-op-button"]).click(
+                    lambda x: update_expression(x, ")"), inputs=display, outputs=display)
+                gr.Button("C", elem_classes=["calculator-button", "basic-op-button"]).click(
+                    clear, inputs=display, outputs=display)
+                gr.Button("⌫", elem_classes=["calculator-button", "basic-op-button"]).click(
+                    backspace, inputs=display, outputs=display)
+        
+        with gr.Column(scale=1):
+            with gr.Column(elem_classes=["calculator-box"]):
+                # Advanced operations
+                for func in ["sin", "cos", "tan", "log", "ln", "sqrt"]:
+                    gr.Button(func, elem_classes=["calculator-button", "advanced-op-button"]).click(
+                        lambda x, v=func: update_expression(x, v), inputs=display, outputs=display)
+                gr.Button("^", elem_classes=["calculator-button", "advanced-op-button"]).click(
+                    lambda x: update_expression(x, "^"), inputs=display, outputs=display)
+                gr.Button("π", elem_classes=["calculator-button", "advanced-op-button"]).click(
+                    lambda x: update_expression(x, "pi"), inputs=display, outputs=display)
+                gr.Button("e", elem_classes=["calculator-button", "advanced-op-button"]).click(
+                    lambda x: update_expression(x, "e"), inputs=display, outputs=display)
+
+iface.launch()