Update app.py

app.py

@@ -1,157 +1,31 @@
-import gradio as gr
-import math
-import re
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, field_validator
-
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from backend import app as backend_app
+from frontend import create_interface
+import threading
+
+# Create the main FastAPI app
 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"
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-def clear(expression):
-    return "0"
+# Include the backend routes
+app.include_router(backend_app)
 
-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; }
-"""
+# Create the Gradio interface
+iface = create_interface()
 
-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)
+# Mount the Gradio app
+app = gr.mount_gradio_app(app, iface, path="/")
 
-iface.launch()
+if __name__ == "__main__":
+    # Run the FastAPI server
+    uvicorn.run(app, host="0.0.0.0", port=7860)