Update app.py

app.py

@@ -3,12 +3,11 @@ import gradio as gr
 
 
 # ============================================================
-# Calculator Logic
+# Scientific Calculator Functions
 # ============================================================
 
 def format_number(value):
-    """Format numbers for clean display."""
-
+    """Format numbers neatly for display."""
     if isinstance(value, int):
         return str(value)
 
@@ -25,285 +24,201 @@ def format_number(value):
 
 
 def calculate(operation, num1, num2):
-    """Perform the selected calculator operation."""
-
-    # --------------------------------------------------------
-    # Validate first number
-    # --------------------------------------------------------
+    """Perform the selected mathematical operation."""
 
+    # Check first number
     if num1 is None:
-        return "Please enter a number.", ""
+        return "Please enter the first number.", ""
 
     try:
         num1 = float(num1)
-    except (ValueError, TypeError):
+    except (TypeError, ValueError):
         return "Error: Please enter a valid first number.", ""
 
     # --------------------------------------------------------
-    # Basic Operations
+    # Addition
     # --------------------------------------------------------
-
     if operation == "Addition (+)":
 
         if num2 is None:
             return "Please enter the second number.", ""
 
-        try:
-            num2 = float(num2)
-        except (ValueError, TypeError):
-            return "Error: Please enter a valid second number.", ""
-
-        result = num1 + num2
+        result = num1 + float(num2)
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"{format_number(num1)} + "
-            f"{format_number(num2)} = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"{format_number(num1)} + {format_number(float(num2))} = "
+            f"{format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-
+    # Subtraction
+    # --------------------------------------------------------
     elif operation == "Subtraction (-)":
 
         if num2 is None:
             return "Please enter the second number.", ""
 
-        try:
-            num2 = float(num2)
-        except (ValueError, TypeError):
-            return "Error: Please enter a valid second number.", ""
-
-        result = num1 - num2
-
-        result_text = format_number(result)
+        result = num1 - float(num2)
 
-        calculation = (
-            f"{format_number(num1)} - "
-            f"{format_number(num2)} = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"{format_number(num1)} - {format_number(float(num2))} = "
+            f"{format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-
+    # Multiplication
+    # --------------------------------------------------------
     elif operation == "Multiplication (×)":
 
         if num2 is None:
             return "Please enter the second number.", ""
 
-        try:
-            num2 = float(num2)
-        except (ValueError, TypeError):
-            return "Error: Please enter a valid second number.", ""
+        result = num1 * float(num2)
 
-        result = num1 * num2
-
-        result_text = format_number(result)
-
-        calculation = (
-            f"{format_number(num1)} × "
-            f"{format_number(num2)} = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"{format_number(num1)} × {format_number(float(num2))} = "
+            f"{format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-
+    # Division
+    # --------------------------------------------------------
     elif operation == "Division (÷)":
 
         if num2 is None:
             return "Please enter the second number.", ""
 
-        try:
-            num2 = float(num2)
-        except (ValueError, TypeError):
-            return "Error: Please enter a valid second number.", ""
+        num2 = float(num2)
 
         if num2 == 0:
             return "Error: Cannot divide by zero.", ""
 
         result = num1 / num2
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"{format_number(num1)} ÷ "
-            f"{format_number(num2)} = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"{format_number(num1)} ÷ {format_number(num2)} = "
+            f"{format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-
+    # Power
+    # --------------------------------------------------------
     elif operation == "Power (xʸ)":
 
         if num2 is None:
             return "Please enter the exponent.", ""
 
-        try:
-            num2 = float(num2)
-        except (ValueError, TypeError):
-            return "Error: Please enter a valid exponent.", ""
+        num2 = float(num2)
 
         try:
             result = num1 ** num2
-        except OverflowError:
-            return "Error: Result is too large.", ""
 
-        if isinstance(result, complex):
-            return (
-                "Error: Complex results are not supported.",
-                ""
-            )
+            if isinstance(result, complex):
+                return "Error: Complex numbers are not supported.", ""
 
-        result_text = format_number(result)
+            if not math.isfinite(result):
+                return "Error: Result is too large.", ""
 
-        calculation = (
-            f"{format_number(num1)} ^ "
-            f"{format_number(num2)} = "
-            f"{result_text}"
-        )
+            return (
+                format_number(result),
+                f"{format_number(num1)} ^ {format_number(num2)} = "
+                f"{format_number(result)}"
+            )
 
-        return result_text, calculation
+        except (OverflowError, ValueError):
+            return "Error: Cannot calculate this power.", ""
 
     # --------------------------------------------------------
     # Square Root
     # --------------------------------------------------------
-
     elif operation == "Square Root (√x)":
 
         if num1 < 0:
-            return (
-                "Error: Square root is not defined "
-                "for negative numbers.",
-                ""
-            )
+            return "Error: Square root of a negative number is not real.", ""
 
         result = math.sqrt(num1)
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"√{format_number(num1)} = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"√{format_number(num1)} = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-    # Logarithm
+    # Logarithm Base 10
     # --------------------------------------------------------
-
     elif operation == "Logarithm (log₁₀)":
 
         if num1 <= 0:
-            return (
-                "Error: Logarithm is defined only "
-                "for positive numbers.",
-                ""
-            )
+            return "Error: Logarithm requires a positive number.", ""
 
         result = math.log10(num1)
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"log₁₀({format_number(num1)}) = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"log₁₀({format_number(num1)}) = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-    # Natural Log
+    # Natural Logarithm
     # --------------------------------------------------------
-
     elif operation == "Natural Log (ln)":
 
         if num1 <= 0:
-            return (
-                "Error: Natural logarithm is defined only "
-                "for positive numbers.",
-                ""
-            )
+            return "Error: Natural logarithm requires a positive number.", ""
 
         result = math.log(num1)
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"ln({format_number(num1)}) = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"ln({format_number(num1)}) = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
     # Sine
     # --------------------------------------------------------
-
     elif operation == "Sine (sin)":
 
-        radians = math.radians(num1)
-
-        result = math.sin(radians)
+        result = math.sin(math.radians(num1))
 
-        # Remove floating-point noise.
+        # Avoid displaying very small floating-point errors
         if abs(result) < 1e-12:
             result = 0.0
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"sin({format_number(num1)}°) = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"sin({format_number(num1)}°) = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
     # Cosine
     # --------------------------------------------------------
-
     elif operation == "Cosine (cos)":
 
-        radians = math.radians(num1)
-
-        result = math.cos(radians)
+        result = math.cos(math.radians(num1))
 
-        # Remove floating-point noise.
         if abs(result) < 1e-12:
             result = 0.0
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"cos({format_number(num1)}°) = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"cos({format_number(num1)}°) = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
     # Tangent
     # --------------------------------------------------------
-
     elif operation == "Tangent (tan)":
 
         radians = math.radians(num1)
 
-        # cos(x) = 0 means tan(x) is undefined.
+        # Tangent is undefined when cos(x) = 0
         if abs(math.cos(radians)) < 1e-12:
             return (
-                "Error: Tangent is undefined "
-                "at this angle.",
+                "Error: Tangent is undefined at this angle.",
                 ""
             )
 
@@ -312,66 +227,45 @@ def calculate(operation, num1, num2):
         if abs(result) < 1e-12:
             result = 0.0
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"tan({format_number(num1)}°) = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"tan({format_number(num1)}°) = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
     # Factorial
     # --------------------------------------------------------
-
     elif operation == "Factorial (n!)":
 
         if num1 < 0:
-            return (
-                "Error: Factorial is not defined "
-                "for negative numbers.",
-                ""
-            )
+            return "Error: Factorial requires a non-negative number.", ""
 
         if not num1.is_integer():
-            return (
-                "Error: Factorial requires "
-                "a whole number.",
-                ""
-            )
+            return "Error: Factorial requires a whole number.", ""
 
         if num1 > 170:
-            return (
-                "Error: Number is too large "
-                "for factorial calculation.",
-                ""
-            )
+            return "Error: Number is too large for factorial.", ""
 
         result = math.factorial(int(num1))
 
-        result_text = format_number(result)
-
-        calculation = (
-            f"{format_number(num1)}! = "
-            f"{result_text}"
+        return (
+            format_number(result),
+            f"{format_number(num1)}! = {format_number(result)}"
         )
 
-        return result_text, calculation
-
     # --------------------------------------------------------
-    # Invalid Operation
+    # Invalid operation
     # --------------------------------------------------------
-
-    return "Please select a valid operation.", ""
+    else:
+        return "Error: Please select a valid operation.", ""
 
 
 # ============================================================
-# UI Helper Functions
+# Show / Hide Second Number
 # ============================================================
 
 def update_second_number(operation):
-    """Show second input only when required."""
+    """Show second number only for operations requiring two numbers."""
 
     binary_operations = [
         "Addition (+)",
@@ -382,20 +276,24 @@ def update_second_number(operation):
     ]
 
     if operation in binary_operations:
-        return gr.update(
-            visible=True,
-            value=None,
-            label="Second Number"
+        return gr.Number(
+            label="Second Number",
+            placeholder="Enter second number",
+            visible=True
         )
 
-    return gr.update(
-        visible=False,
-        value=None
+    return gr.Number(
+        label="Second Number",
+        visible=False
     )
 
 
+# ============================================================
+# Clear Calculator
+# ============================================================
+
 def clear_calculator():
-    """Clear the calculator."""
+    """Reset calculator fields."""
 
     return (
         None,
@@ -411,88 +309,84 @@ def clear_calculator():
 # ============================================================
 
 custom_css = """
+body {
+    background: #f5f7fb;
+}
+
 .gradio-container {
     max-width: 1100px !important;
     margin: auto !important;
+    padding: 20px !important;
 }
 
-.calculator-header {
+.header {
     text-align: center;
-    padding: 25px 10px 15px 10px;
+    padding: 25px 15px;
+    margin-bottom: 20px;
 }
 
-.calculator-title {
+.header h1 {
     font-size: 38px;
-    font-weight: 800;
+    font-weight: 700;
     margin-bottom: 8px;
 }
 
-.calculator-subtitle {
+.header p {
     font-size: 16px;
-    opacity: 0.7;
+    opacity: 0.75;
 }
 
 .calc-card {
-    border-radius: 18px !important;
-    padding: 22px !important;
+    border: 1px solid #e5e7eb;
+    border-radius: 18px;
+    padding: 25px;
+    background: white;
+    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.06);
 }
 
 .result-box textarea {
-    font-size: 28px !important;
-    font-weight: 700 !important;
+    font-size: 24px !important;
+    font-weight: 600 !important;
     text-align: center !important;
 }
 
-.calculate-btn {
-    min-height: 52px !important;
-    font-size: 17px !important;
-    font-weight: 700 !important;
-}
-
-.clear-btn {
-    min-height: 52px !important;
+.calculation-box textarea {
     font-size: 17px !important;
+    text-align: center !important;
 }
 
-.operation-dropdown {
-    font-weight: 600 !important;
-}
-
-.calculator-footer {
+.footer {
     text-align: center;
+    margin-top: 25px;
     padding: 15px;
-    margin-top: 15px;
-    opacity: 0.6;
-    font-size: 13px;
+    font-size: 14px;
+    opacity: 0.65;
 }
 
 @media (max-width: 700px) {
 
-    .calculator-title {
-        font-size: 28px;
+    .gradio-container {
+        padding: 10px !important;
     }
 
-    .calculator-subtitle {
-        font-size: 14px;
+    .header h1 {
+        font-size: 30px;
     }
 
     .calc-card {
-        padding: 14px !important;
-    }
-
-    .result-box textarea {
-        font-size: 22px !important;
+        padding: 18px;
     }
 }
 """
 
 
 # ============================================================
-# Gradio Application
+# Gradio Interface
 # ============================================================
 
 with gr.Blocks(
-    title="Scientific Calculator"
+    title="Scientific Calculator",
+    css=custom_css
 ) as app:
 
     # --------------------------------------------------------
@@ -501,35 +395,29 @@ with gr.Blocks(
 
     gr.HTML(
         """
-        <div class="calculator-header">
-
-            <div class="calculator-title">
-                Scientific Calculator
-            </div>
-
-            <div class="calculator-subtitle">
-                Perform arithmetic and scientific calculations
-                quickly and accurately.
-            </div>
-
+        <div class="header">
+            <h1>Scientific Calculator</h1>
+            <p>
+                Perform basic and scientific mathematical calculations
+                quickly and easily.
+            </p>
         </div>
         """
     )
 
     # --------------------------------------------------------
-    # Main Interface
+    # Main Layout
     # --------------------------------------------------------
 
     with gr.Row():
 
-        # ====================================================
-        # Input Panel
-        # ====================================================
+        # ----------------------------------------------------
+        # Calculator Input
+        # ----------------------------------------------------
 
-        with gr.Column(
-            scale=1,
-            elem_classes="calc-card"
-        ):
+        with gr.Column(elem_classes="calc-card"):
+
+            gr.Markdown("### Calculator")
 
             operation = gr.Dropdown(
                 choices=[
@@ -547,13 +435,12 @@ with gr.Blocks(
                     "Factorial (n!)"
                 ],
                 value="Addition (+)",
-                label="Select Operation",
-                elem_classes="operation-dropdown"
+                label="Select Operation"
             )
 
             num1 = gr.Number(
                 label="First Number",
-                placeholder="Enter a number"
+                placeholder="Enter first number"
             )
 
             num2 = gr.Number(
@@ -565,66 +452,50 @@ with gr.Blocks(
 
                 calculate_button = gr.Button(
                     "Calculate",
-                    variant="primary",
-                    elem_classes="calculate-btn"
+                    variant="primary"
                 )
 
                 clear_button = gr.Button(
                     "Clear",
-                    variant="secondary",
-                    elem_classes="clear-btn"
+                    variant="secondary"
                 )
 
-        # ====================================================
-        # Result Panel
-        # ====================================================
+        # ----------------------------------------------------
+        # Result Section
+        # ----------------------------------------------------
+
+        with gr.Column(elem_classes="calc-card"):
 
-        with gr.Column(
-            scale=1,
-            elem_classes="calc-card"
-        ):
+            gr.Markdown("### Result")
 
             result = gr.Textbox(
-                label="Result",
-                value="",
+                label="Answer",
+                placeholder="Your result will appear here",
                 interactive=False,
                 elem_classes="result-box"
             )
 
             calculation = gr.Textbox(
                 label="Calculation",
-                value="",
+                placeholder="Calculation details will appear here",
                 interactive=False,
-                lines=2,
-                placeholder="Your calculation will appear here..."
+                elem_classes="calculation-box"
             )
 
             gr.Markdown(
                 """
-### Supported Operations
+                ### Supported Operations
 
-**Arithmetic**
+                **Basic:** Addition, Subtraction, Multiplication, Division
 
-- Addition
-- Subtraction
-- Multiplication
-- Division
-- Power
+                **Advanced:** Power, Square Root, Logarithm, Natural Log
 
-**Scientific**
+                **Trigonometry:** Sine, Cosine, Tangent
 
-- Square Root
-- Logarithm
-- Natural Log
-- Sine
-- Cosine
-- Tangent
-- Factorial
+                **Other:** Factorial
 
-**Trigonometry**
-
-Angles are entered in **degrees**.
-"""
+                **Note:** Trigonometric functions use **degrees**.
+                """
             )
 
     # --------------------------------------------------------
@@ -633,8 +504,8 @@ Angles are entered in **degrees**.
 
     gr.HTML(
         """
-        <div class="calculator-footer">
-            Scientific Calculator · Python + Gradio
+        <div class="footer">
+            Scientific Calculator • Built with Python & Gradio
         </div>
         """
     )
@@ -651,15 +522,8 @@ Angles are entered in **degrees**.
 
     calculate_button.click(
         fn=calculate,
-        inputs=[
-            operation,
-            num1,
-            num2
-        ],
-        outputs=[
-            result,
-            calculation
-        ]
+        inputs=[operation, num1, num2],
+        outputs=[result, calculation]
     )
 
     clear_button.click(
@@ -676,7 +540,7 @@ Angles are entered in **degrees**.
 
 
 # ============================================================
-# Launch for Hugging Face Spaces
+# Launch
 # ============================================================
 
 if __name__ == "__main__":
@@ -684,7 +548,5 @@ if __name__ == "__main__":
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        ssr_mode=False,
-        show_error=True
+        share=False
     )