Update app.py

app.py

@@ -3,216 +3,305 @@ import gradio as gr
 
 
 # ============================================================
-# Calculator Functions
+# Helper Functions
 # ============================================================
 
-def calculate(operation, num1, num2=None):
+def format_number(value):
+    """Format a number for clean display."""
+
+    if isinstance(value, int):
+        return str(value)
+
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            return str(value)
+
+        if value.is_integer():
+            return str(int(value))
+
+        return f"{value:.12g}"
+
+    return str(value)
+
+
+def calculate(operation, num1, num2):
     """
     Perform the selected calculator operation.
     """
 
-    try:
-        # Convert input to numbers
-        if num1 is None or str(num1).strip() == "":
-            return "Please enter a number.", ""
+    # --------------------------------------------------------
+    # Validate first number
+    # --------------------------------------------------------
+
+    if num1 is None:
+        return "Please enter a number.", ""
 
+    try:
         num1 = float(num1)
+    except (ValueError, TypeError):
+        return "Error: Please enter a valid first number.", ""
 
-        # ----------------------------------------------------
-        # Basic Arithmetic
-        # ----------------------------------------------------
+    # --------------------------------------------------------
+    # Binary Operations
+    # --------------------------------------------------------
 
-        if operation == "Addition (+)":
-            if num2 is None or str(num2).strip() == "":
-                return "Please enter the second number.", ""
+    binary_operations = {
+        "Addition (+)": "+",
+        "Subtraction (-)": "-",
+        "Multiplication (×)": "×",
+        "Division (÷)": "÷",
+        "Power (xʸ)": "^"
+    }
+
+    if operation in binary_operations:
 
+        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.", ""
+
+        # Addition
+        if operation == "Addition (+)":
             result = num1 + num2
 
+        # Subtraction
         elif operation == "Subtraction (-)":
-            if num2 is None or str(num2).strip() == "":
-                return "Please enter the second number.", ""
-
-            num2 = float(num2)
             result = num1 - num2
 
+        # Multiplication
         elif operation == "Multiplication (×)":
-            if num2 is None or str(num2).strip() == "":
-                return "Please enter the second number.", ""
-
-            num2 = float(num2)
             result = num1 * num2
 
+        # Division
         elif operation == "Division (÷)":
-            if num2 is None or str(num2).strip() == "":
-                return "Please enter the second number.", ""
-
-            num2 = float(num2)
 
             if num2 == 0:
                 return "Error: Cannot divide by zero.", ""
 
             result = num1 / num2
 
+        # Power
         elif operation == "Power (xʸ)":
-            if num2 is None or str(num2).strip() == "":
-                return "Please enter the exponent.", ""
 
-            num2 = float(num2)
-            result = num1 ** num2
+            try:
+                result = num1 ** num2
+            except OverflowError:
+                return "Error: Result is too large.", ""
 
-        # ----------------------------------------------------
-        # Scientific Functions
-        # ----------------------------------------------------
+        symbol = binary_operations[operation]
 
-        elif operation == "Square Root (√x)":
+        result_text = format_number(result)
 
-            if num1 < 0:
-                return "Error: Square root is not defined for negative numbers.", ""
+        calculation = (
+            f"{format_number(num1)} "
+            f"{symbol} "
+            f"{format_number(num2)} = "
+            f"{result_text}"
+        )
 
-            result = math.sqrt(num1)
+        return result_text, calculation
 
-        elif operation == "Logarithm (log₁₀)":
+    # --------------------------------------------------------
+    # Square Root
+    # --------------------------------------------------------
 
-            if num1 <= 0:
-                return "Error: Logarithm is defined only for positive numbers.", ""
+    if operation == "Square Root (√x)":
 
-            result = math.log10(num1)
+        if num1 < 0:
+            return (
+                "Error: Square root is not defined "
+                "for negative numbers.",
+                ""
+            )
 
-        elif operation == "Natural Log (ln)":
+        result = math.sqrt(num1)
 
-            if num1 <= 0:
-                return "Error: Natural logarithm is defined only for positive numbers.", ""
+        result_text = format_number(result)
 
-            result = math.log(num1)
+        calculation = (
+            f"√{format_number(num1)} = {result_text}"
+        )
 
-        elif operation == "Sine (sin)":
+        return result_text, calculation
 
-            result = math.sin(math.radians(num1))
+    # --------------------------------------------------------
+    # Logarithm
+    # --------------------------------------------------------
 
-        elif operation == "Cosine (cos)":
+    if operation == "Logarithm (log₁₀)":
 
-            result = math.cos(math.radians(num1))
+        if num1 <= 0:
+            return (
+                "Error: Logarithm is defined only "
+                "for positive numbers.",
+                ""
+            )
 
-        elif operation == "Tangent (tan)":
+        result = math.log10(num1)
 
-            # Tangent is undefined at 90 + 180k degrees.
-            if math.isclose(
-                math.cos(math.radians(num1)),
-                0,
-                abs_tol=1e-12
-            ):
-                return "Error: Tangent is undefined at this angle.", ""
+        result_text = format_number(result)
 
-            result = math.tan(math.radians(num1))
+        calculation = (
+            f"log₁₀({format_number(num1)}) = "
+            f"{result_text}"
+        )
 
-        elif operation == "Factorial (n!)":
+        return result_text, calculation
 
-            if num1 < 0:
-                return "Error: Factorial is not defined for negative numbers.", ""
+    # --------------------------------------------------------
+    # Natural Logarithm
+    # --------------------------------------------------------
 
-            if not num1.is_integer():
-                return "Error: Factorial requires a whole number.", ""
+    if operation == "Natural Log (ln)":
 
-            if num1 > 170:
-                return "Error: Number is too large for factorial calculation.", ""
+        if num1 <= 0:
+            return (
+                "Error: Natural logarithm is defined "
+                "only for positive numbers.",
+                ""
+            )
 
-            result = math.factorial(int(num1))
+        result = math.log(num1)
 
-        else:
-            return "Please select a valid operation.", ""
+        result_text = format_number(result)
 
-        # ----------------------------------------------------
-        # Format Result
-        # ----------------------------------------------------
+        calculation = (
+            f"ln({format_number(num1)}) = "
+            f"{result_text}"
+        )
 
-        formatted_result = format_result(result)
+        return result_text, calculation
 
-        # Create calculation history entry
-        if operation in [
-            "Addition (+)",
-            "Subtraction (-)",
-            "Multiplication (×)",
-            "Division (÷)",
-            "Power (xʸ)"
-        ]:
-            symbol = {
-                "Addition (+)": "+",
-                "Subtraction (-)": "-",
-                "Multiplication (×)": "×",
-                "Division (÷)": "÷",
-                "Power (xʸ)": "^"
-            }[operation]
+    # --------------------------------------------------------
+    # Sine
+    # --------------------------------------------------------
 
-            history = f"{format_number(num1)} {symbol} {format_number(num2)} = {formatted_result}"
+    if operation == "Sine (sin)":
 
-        elif operation == "Square Root (√x)":
-            history = f"√{format_number(num1)} = {formatted_result}"
+        radians = math.radians(num1)
+        result = math.sin(radians)
 
-        elif operation == "Logarithm (log₁₀)":
-            history = f"log₁₀({format_number(num1)}) = {formatted_result}"
+        # Avoid values such as 6.123e-17 for sin(180)
+        if abs(result) < 1e-12:
+            result = 0.0
 
-        elif operation == "Natural Log (ln)":
-            history = f"ln({format_number(num1)}) = {formatted_result}"
+        result_text = format_number(result)
 
-        elif operation == "Sine (sin)":
-            history = f"sin({format_number(num1)}°) = {formatted_result}"
+        calculation = (
+            f"sin({format_number(num1)}°) = "
+            f"{result_text}"
+        )
 
-        elif operation == "Cosine (cos)":
-            history = f"cos({format_number(num1)}°) = {formatted_result}"
+        return result_text, calculation
 
-        elif operation == "Tangent (tan)":
-            history = f"tan({format_number(num1)}°) = {formatted_result}"
+    # --------------------------------------------------------
+    # Cosine
+    # --------------------------------------------------------
 
-        elif operation == "Factorial (n!)":
-            history = f"{format_number(num1)}! = {formatted_result}"
+    if operation == "Cosine (cos)":
 
-        else:
-            history = ""
+        radians = math.radians(num1)
+        result = math.cos(radians)
 
-        return formatted_result, history
+        # Avoid values such as 6.123e-17 for cos(90)
+        if abs(result) < 1e-12:
+            result = 0.0
 
-    except ValueError:
-        return "Error: Please enter valid numbers.", ""
+        result_text = format_number(result)
 
-    except OverflowError:
-        return "Error: The result is too large to calculate.", ""
+        calculation = (
+            f"cos({format_number(num1)}°) = "
+            f"{result_text}"
+        )
 
-    except ZeroDivisionError:
-        return "Error: Cannot divide by zero.", ""
+        return result_text, calculation
 
-    except Exception as error:
-        return f"Unexpected error: {error}", ""
+    # --------------------------------------------------------
+    # Tangent
+    # --------------------------------------------------------
 
+    if operation == "Tangent (tan)":
 
-def format_result(value):
-    """
-    Format calculator results for a clean UI.
-    """
+        radians = math.radians(num1)
 
-    if isinstance(value, int):
-        return str(value)
+        # Tangent is undefined when cos(x) = 0
+        if abs(math.cos(radians)) < 1e-12:
+            return (
+                "Error: Tangent is undefined "
+                "at this angle.",
+                ""
+            )
 
-    if math.isfinite(value) and value.is_integer():
-        return str(int(value))
+        result = math.tan(radians)
 
-    return f"{value:.12g}"
+        if abs(result) < 1e-12:
+            result = 0.0
 
+        result_text = format_number(result)
 
-def format_number(value):
-    """
-    Format input numbers for history.
-    """
+        calculation = (
+            f"tan({format_number(num1)}°) = "
+            f"{result_text}"
+        )
 
-    if float(value).is_integer():
-        return str(int(value))
+        return result_text, calculation
 
-    return f"{float(value):.12g}"
+    # --------------------------------------------------------
+    # Factorial
+    # --------------------------------------------------------
 
+    if operation == "Factorial (n!)":
+
+        if num1 < 0:
+            return (
+                "Error: Factorial is not defined "
+                "for negative numbers.",
+                ""
+            )
 
-def update_second_input(operation):
+        if not num1.is_integer():
+            return (
+                "Error: Factorial requires "
+                "a whole number.",
+                ""
+            )
+
+        if num1 > 170:
+            return (
+                "Error: Number is too large "
+                "for factorial calculation.",
+                ""
+            )
+
+        result = math.factorial(int(num1))
+
+        result_text = format_number(result)
+
+        calculation = (
+            f"{format_number(num1)}! = "
+            f"{result_text}"
+        )
+
+        return result_text, calculation
+
+    # --------------------------------------------------------
+    # Invalid Operation
+    # --------------------------------------------------------
+
+    return "Please select a valid operation.", ""
+
+
+# ============================================================
+# UI Functions
+# ============================================================
+
+def update_second_number(operation):
     """
-    Show/hide the second input field depending on the operation.
+    Show the second number input only for
+    operations that require two numbers.
     """
 
     binary_operations = [
@@ -224,6 +313,7 @@ def update_second_input(operation):
     ]
 
     if operation in binary_operations:
+
         return gr.update(
             visible=True,
             label="Second Number",
@@ -237,9 +327,7 @@ def update_second_input(operation):
 
 
 def clear_calculator():
-    """
-    Reset the calculator.
-    """
+    """Reset all calculator fields."""
 
     return (
         None,
@@ -254,8 +342,8 @@ def clear_calculator():
 # Custom CSS
 # ============================================================
 
-css = """
-/* Main application */
+custom_css = """
+/* Main container */
 .gradio-container {
     max-width: 1100px !important;
     margin: auto !important;
@@ -264,24 +352,24 @@ css = """
 /* Header */
 .calculator-header {
     text-align: center;
-    padding: 20px 10px 10px 10px;
+    padding: 25px 10px 15px 10px;
 }
 
 .calculator-title {
-    font-size: 36px;
+    font-size: 38px;
     font-weight: 800;
-    margin-bottom: 5px;
+    margin-bottom: 8px;
 }
 
 .calculator-subtitle {
     font-size: 16px;
-    opacity: 0.75;
+    opacity: 0.7;
 }
 
-/* Cards */
+/* Calculator cards */
 .calc-card {
     border-radius: 18px !important;
-    padding: 20px !important;
+    padding: 22px !important;
 }
 
 /* Result */
@@ -293,16 +381,17 @@ css = """
 
 /* Buttons */
 .calculate-btn {
-    font-size: 18px !important;
-    font-weight: 700 !important;
     min-height: 52px !important;
+    font-size: 17px !important;
+    font-weight: 700 !important;
 }
 
 .clear-btn {
     min-height: 52px !important;
+    font-size: 17px !important;
 }
 
-/* Operation dropdown */
+/* Operation selector */
 .operation-dropdown {
     font-weight: 600 !important;
 }
@@ -310,13 +399,13 @@ css = """
 /* Footer */
 .calculator-footer {
     text-align: center;
-    margin-top: 20px;
-    padding: 10px;
-    opacity: 0.65;
+    padding: 15px;
+    margin-top: 15px;
+    opacity: 0.6;
     font-size: 13px;
 }
 
-/* Mobile responsiveness */
+/* Mobile */
 @media (max-width: 700px) {
 
     .calculator-title {
@@ -339,13 +428,11 @@ css = """
 
 
 # ============================================================
-# Gradio Interface
+# Gradio Application
 # ============================================================
 
 with gr.Blocks(
-    title="Scientific Calculator",
-    theme=gr.themes.Soft(),
-    css=css
+    title="Scientific Calculator"
 ) as app:
 
     # --------------------------------------------------------
@@ -355,25 +442,30 @@ 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.
+                A simple and powerful calculator for
+                arithmetic and scientific operations.
             </div>
+
         </div>
         """
     )
 
     # --------------------------------------------------------
-    # Calculator
+    # Main Calculator
     # --------------------------------------------------------
 
     with gr.Row():
 
-        # Left side
+        # ====================================================
+        # Calculator Input Section
+        # ====================================================
+
         with gr.Column(
             scale=1,
             elem_classes="calc-card"
@@ -411,19 +503,22 @@ with gr.Blocks(
 
             with gr.Row():
 
-                calculate_btn = gr.Button(
+                calculate_button = gr.Button(
                     "Calculate",
                     variant="primary",
                     elem_classes="calculate-btn"
                 )
 
-                clear_btn = gr.Button(
+                clear_button = gr.Button(
                     "Clear",
                     variant="secondary",
                     elem_classes="clear-btn"
                 )
 
-        # Right side
+        # ====================================================
+        # Result Section
+        # ====================================================
+
         with gr.Column(
             scale=1,
             elem_classes="calc-card"
@@ -436,36 +531,40 @@ with gr.Blocks(
                 elem_classes="result-box"
             )
 
-            history = gr.Textbox(
+            calculation = gr.Textbox(
                 label="Calculation",
                 value="",
                 interactive=False,
-                lines=3,
+                lines=2,
                 placeholder="Your calculation will appear here..."
             )
 
             gr.Markdown(
                 """
-                ### Supported Functions
-
-                **Arithmetic**
-                - Addition
-                - Subtraction
-                - Multiplication
-                - Division
-                - Power
-
-                **Scientific**
-                - Square Root
-                - Logarithm
-                - Natural Log
-                - Sine
-                - Cosine
-                - Tangent
-                - Factorial
-
-                **Trigonometry:** Angles are entered in degrees.
-                """
+### Supported Operations
+
+**Arithmetic**
+
+- Addition
+- Subtraction
+- Multiplication
+- Division
+- Power
+
+**Scientific**
+
+- Square Root
+- Logarithm
+- Natural Log
+- Sine
+- Cosine
+- Tangent
+- Factorial
+
+**Trigonometry**
+
+Angles are entered in **degrees**.
+"""
             )
 
     # --------------------------------------------------------
@@ -475,28 +574,35 @@ with gr.Blocks(
     gr.HTML(
         """
         <div class="calculator-footer">
-            Scientific Calculator • Built with Python & Gradio
+            Scientific Calculator · Python + Gradio
         </div>
         """
     )
 
-    # --------------------------------------------------------
-    # Events
-    # --------------------------------------------------------
+    # ========================================================
+    # Event Handlers
+    # ========================================================
 
     operation.change(
-        fn=update_second_input,
+        fn=update_second_number,
         inputs=operation,
         outputs=num2
     )
 
-    calculate_btn.click(
+    calculate_button.click(
         fn=calculate,
-        inputs=[operation, num1, num2],
-        outputs=[result, history]
+        inputs=[
+            operation,
+            num1,
+            num2
+        ],
+        outputs=[
+            result,
+            calculation
+        ]
     )
 
-    clear_btn.click(
+    clear_button.click(
         fn=clear_calculator,
         inputs=[],
         outputs=[
@@ -504,14 +610,18 @@ with gr.Blocks(
             num2,
             operation,
             result,
-            history
+            calculation
         ]
     )
 
 
 # ============================================================
-# Launch Application
+# Launch
 # ============================================================
 
 if __name__ == "__main__":
-    app.launch()
+
+    app.launch(
+        theme=gr.themes.Soft(),
+        css=custom_css
+    )