Update app.py

app.py

@@ -1,57 +1,53 @@
 import gradio as gr
 import pandas as pd
-import matplotlib.pyplot as plt
-from io import BytesIO
 
-# Updated Calculation Function
-def load_calculator(load_rating, num_of_loads, voltage, power_factor, safety_factor, phase_type):
+# Updated Calculation Function (No Safety Factor)
+def load_calculator(load_rating, num_of_loads, voltage, power_factor, phase_type):
     try:
+        # Check if any input is invalid
+        if not all([load_rating, num_of_loads, voltage, power_factor]):
+            raise ValueError("All input fields must be filled with valid numbers.")
+
+        # Step 1: Calculate total load in kW
         total_load = load_rating * num_of_loads  # Total Load in kW
-        total_current = (total_load * 1000) / (voltage * power_factor)  # Current in Amperes
+        print(f"Total Load (kW): {total_load}")
 
-        if phase_type == "Three-Phase":
-            total_current /= (3 ** 0.5)
+        # Step 2: Calculate current based on the type of phase (Single or Three Phase)
+        total_load_watts = total_load * 1000  # Convert kW to Watts
+        print(f"Total Load (W): {total_load_watts}")
 
-        # Adjust breaker and cable sizes using safety factor
-        breaker_size = total_current * safety_factor
-        cable_size = total_current * safety_factor * 0.75  # Example adjustment for cable size
-        apparent_power = total_load / power_factor  # Apparent Power in kVA
+        # Current formula for Single Phase: I = P / (V * PF)
+        if phase_type == "Single-Phase":
+            total_current = total_load_watts / (voltage * power_factor)
+            print(f"Total Current (A - Single-Phase): {total_current}")
+        else:  # Three-Phase: I = P / (sqrt(3) * V * PF)
+            total_current = total_load_watts / (3 ** 0.5 * voltage * power_factor)
+            print(f"Total Current (A - Three-Phase): {total_current}")
 
-        # Prepare results
-        results = pd.DataFrame({
-            "Metric": ["Total Load (kW)", "Total Current (A)", "Breaker Size (A)", "Cable Size (mm²)", "Apparent Power (kVA)"],
-            "Value": [total_load, total_current, breaker_size, cable_size, apparent_power],
-        })
+        # Step 3: Calculate breaker size (no safety factor)
+        breaker_size = total_current  # Breaker size in Amperes
+        print(f"Breaker Size (A): {breaker_size}")
 
-        # Generate bar chart
-        plt.figure(figsize=(6, 4))
-        plt.bar(results["Metric"], results["Value"], color="skyblue")
-        plt.title("Load Calculation Results")
-        plt.xticks(rotation=45, ha='right')
-        plt.tight_layout()
-        
-        # Save the plot to a BytesIO object
-        buf = BytesIO()
-        plt.savefig(buf, format='png')
-        buf.seek(0)
-        plt.close()
+        # Step 4: Calculate cable size (assuming 0.75mm² per Ampere of current as an example)
+        cable_size = total_current * 0.75  # Cable size in mm²
+        print(f"Cable Size (mm²): {cable_size}")
 
-        # Save Excel data to a BytesIO object
-        excel_buf = BytesIO()
-        results.to_excel(excel_buf, index=False)
-        excel_buf.seek(0)
+        # Step 5: Calculate apparent power in kVA
+        apparent_power = total_load / power_factor  # Apparent Power in kVA
+        print(f"Apparent Power (kVA): {apparent_power}")
 
+        # Prepare results for returning to Gradio
         return (
-            round(total_load, 2),
-            round(total_current, 2),
-            round(breaker_size, 2),
-            round(cable_size, 2),
-            round(apparent_power, 2),
-            buf,
-            excel_buf,
+            str(round(total_load, 2)),
+            str(round(total_current, 2)),
+            str(round(breaker_size, 2)),
+            str(round(cable_size, 2)),
+            str(round(apparent_power, 2))
         )
+    
     except Exception as e:
-        return f"An error occurred: {e}"
+        # Return the error message if any exception occurs
+        return f"An error occurred: {str(e)}"
 
 # Gradio Interface
 def interface():
@@ -59,7 +55,6 @@ def interface():
     num_of_loads = gr.Number(label="Number of Loads")
     voltage = gr.Number(label="Voltage (230V for single-phase, 400V for three-phase)")
     power_factor = gr.Number(label="Power Factor (0.8 for inductive loads, 1 for resistive)")
-    safety_factor = gr.Number(label="Safety Factor (e.g., 1.25)", value=1.25)
     phase_type = gr.Radio(["Single-Phase", "Three-Phase"], label="Phase Type")
 
     # Outputs
@@ -68,18 +63,16 @@ def interface():
         gr.Textbox(label="Total Current (A)"),
         gr.Textbox(label="Recommended Breaker Size (A)"),
         gr.Textbox(label="Recommended Cable Size (mm²)"),
-        gr.Textbox(label="Total Apparent Power (kVA)"),
-        gr.Image(label="Graphical Visualization"),  # Graph output
-        gr.File(label="Download Excel Results"),  # Excel file output
+        gr.Textbox(label="Total Apparent Power (kVA)")
     ]
 
     # Launch Interface
     gr.Interface(
         fn=load_calculator,
-        inputs=[load_rating, num_of_loads, voltage, power_factor, safety_factor, phase_type],
+        inputs=[load_rating, num_of_loads, voltage, power_factor, phase_type],
         outputs=outputs,
-        title="Enhanced Load Calculation Assistant",
-        description="Calculate electrical loads with safety factors, export results, and visualize data.",
+        title="Load Calculation Assistant",
+        description="Calculate electrical loads and get the results."
     ).launch()
 
 interface()