Upload 3 files

README.md

@@ -1,12 +1,29 @@
----
-title: Time Costcalculator
-emoji: 📈
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# EV Home Charging: Time & Cost Estimator (Gradio)
+
+A simple Gradio app to estimate how long a home charging session will take for your EV and what it will cost.
+
+## Features
+- Inputs: battery capacity (kWh), current/target SoC, charger power, efficiency, and electricity tariff.
+- Pricing modes: flat rate or Time-of-Day (ToD) blended.
+- Outputs: battery energy added, wall energy consumed (incl. losses), charging time (hours), and session cost.
+
+## How to run locally
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Deploy to Hugging Face Spaces (SDK: Gradio)
+1. Create a new Space: https://huggingface.co/spaces → **Create new Space** → SDK **Gradio**.
+2. Upload `app.py` and `requirements.txt` (drag & drop or `git push`).
+3. Wait for the build logs to finish. The app will appear on your Space URL.
+
+## Formulas
+- Energy on battery (kWh) = `battery_kwh * (target_soc - current_soc)/100`
+- Wall energy (kWh) = `battery_energy / efficiency`
+- Time (hours) = `wall_energy / charger_power_kW`
+- Cost (₹) = `wall_energy * rate` (or blended ToD rate)
+
+## Disclaimer
+Tariffs and fixed charges differ by utility and may change. Use your latest bill and adjust the inputs accordingly.

app.py

@@ -0,0 +1,155 @@
+
+import gradio as gr
+
+TITLE = "EV Home Charging: Time & Cost Estimator"
+DESCRIPTION = (
+    "Calculate how long it takes to charge your EV at home and how much it costs. "
+    "Enter your battery size, current/target state-of-charge (SoC), charger power, "
+    "efficiency, and your electricity price."
+)
+
+def compute(ev_battery_kwh: float, soc_current: float, soc_target: float,
+            power_choice: str, custom_power_kw: float,
+            efficiency_pct: float,
+            pricing_mode: str,
+            flat_rate_rs_per_kwh: float,
+            peak_rate_rs_per_kwh: float,
+            off_rate_rs_per_kwh: float,
+            peak_share_pct: float):
+    # sanitize inputs
+    soc_current = max(0.0, min(100.0, soc_current))
+    soc_target = max(0.0, min(100.0, soc_target))
+    if soc_target <= soc_current:
+        return (
+            "Target SoC must be greater than current SoC.",
+            None, None, None, None
+        )
+    efficiency = max(1e-3, min(100.0, efficiency_pct)) / 100.0
+
+    # determine charger power (kW)
+    if power_choice == "2.3 kW (10A, single-phase)":
+        charger_kw = 2.3
+    elif power_choice == "3.3 kW (15A, single-phase)":
+        charger_kw = 3.3
+    elif power_choice == "7.4 kW (32A, single-phase)":
+        charger_kw = 7.4
+    elif power_choice == "11 kW (3-phase)":
+        charger_kw = 11.0
+    elif power_choice == "22 kW (3-phase)":
+        charger_kw = 22.0
+    else:  # custom
+        charger_kw = max(0.1, custom_power_kw)
+
+    # energy needed on battery side (kWh)
+    energy_battery_kwh = ev_battery_kwh * (soc_target - soc_current) / 100.0
+    # account for charging losses -> wall energy
+    energy_wall_kwh = energy_battery_kwh / efficiency
+    # time (hours)
+    charge_hours = energy_wall_kwh / charger_kw
+
+    # price calculation
+    if pricing_mode == "Flat rate":
+        cost_rs = energy_wall_kwh * max(0.0, flat_rate_rs_per_kwh)
+        breakdown = (
+            f"Flat: {energy_wall_kwh:.2f} kWh × ₹{flat_rate_rs_per_kwh:.2f}/kWh"
+        )
+    else:
+        peak_share = max(0.0, min(100.0, peak_share_pct)) / 100.0
+        blended_rate = peak_share * max(0.0, peak_rate_rs_per_kwh) + (1 - peak_share) * max(0.0, off_rate_rs_per_kwh)
+        cost_rs = energy_wall_kwh * blended_rate
+        breakdown = (
+            f"ToD blended rate: peak {peak_share*100:.0f}% at ₹{peak_rate_rs_per_kwh:.2f}/kWh, "
+            f"off-peak {100-peak_share*100:.0f}% at ₹{off_rate_rs_per_kwh:.2f}/kWh"
+        )
+
+    summary = (
+        f"Battery energy added: {energy_battery_kwh:.2f} kWh
+"
+        f"Wall energy consumed (incl. losses): {energy_wall_kwh:.2f} kWh
+"
+        f"Estimated charging time: {charge_hours:.2f} hours (at {charger_kw:.2f} kW)
+"
+        f"Estimated session cost: ₹{cost_rs:.2f}
+"
+        f"Pricing: {breakdown}"
+    )
+
+    # structured outputs
+    return (
+        summary,
+        energy_battery_kwh,
+        energy_wall_kwh,
+        charge_hours,
+        cost_rs
+    )
+
+with gr.Blocks(title=TITLE) as demo:
+    gr.Markdown(f"# {TITLE}
+{DESCRIPTION}")
+
+    with gr.Row():
+        with gr.Column():
+            ev_battery_kwh = gr.Number(label="Battery capacity (kWh)", value=50.0, precision=2)
+            soc_current = gr.Slider(label="Current SoC (%)", minimum=0, maximum=100, value=20, step=1)
+            soc_target = gr.Slider(label="Target SoC (%)", minimum=1, maximum=100, value=80, step=1)
+
+        with gr.Column():
+            power_choice = gr.Radio(
+                label="Home charger power",
+                choices=[
+                    "2.3 kW (10A, single-phase)",
+                    "3.3 kW (15A, single-phase)",
+                    "7.4 kW (32A, single-phase)",
+                    "11 kW (3-phase)",
+                    "22 kW (3-phase)",
+                    "Custom (kW)"
+                ],
+                value="7.4 kW (32A, single-phase)"
+            )
+            custom_power_kw = gr.Number(label="Custom power (kW)", value=3.5, precision=2)
+            efficiency_pct = gr.Slider(label="Charging efficiency (%)", minimum=70, maximum=100, value=90, step=1)
+
+    with gr.Row():
+        with gr.Column():
+            pricing_mode = gr.Radio(label="Pricing mode", choices=["Flat rate", "Time-of-Day (ToD)"] , value="Flat rate")
+            flat_rate = gr.Number(label="Flat rate (₹/kWh)", value=7.00, precision=2)
+        with gr.Column():
+            peak_rate = gr.Number(label="Peak rate (₹/kWh)", value=8.50, precision=2, visible=False)
+            off_rate = gr.Number(label="Off-peak rate (₹/kWh)", value=6.00, precision=2, visible=False)
+            peak_share = gr.Slider(label="Share of charging during peak (%)", minimum=0, maximum=100, value=30, step=1, visible=False)
+
+    btn = gr.Button("Estimate")
+
+    summary = gr.Textbox(label="Results", lines=6)
+    energy_battery = gr.Number(label="Battery energy added (kWh)")
+    energy_wall = gr.Number(label="Wall energy consumed (kWh)")
+    time_hours = gr.Number(label="Charging time (hours)")
+    cost_rs = gr.Number(label="Session cost (₹)")
+
+    def toggle_inputs(pricing_mode):
+        show_tod = pricing_mode == "Time-of-Day (ToD)"
+        return (
+            gr.update(visible=show_tod),
+            gr.update(visible=show_tod),
+            gr.update(visible=show_tod)
+        )
+
+    pricing_mode.change(toggle_inputs, inputs=[pricing_mode], outputs=[peak_rate, off_rate, peak_share])
+
+    btn.click(
+        compute,
+        inputs=[ev_battery_kwh, soc_current, soc_target, power_choice, custom_power_kw, efficiency_pct,
+                pricing_mode, flat_rate, peak_rate, off_rate, peak_share],
+        outputs=[summary, energy_battery, energy_wall, time_hours, cost_rs]
+    )
+
+    gr.Markdown("""
+### Notes
+- **Charging efficiency** accounts for AC charging losses (cable, converter, battery). Typical values are 88–95%.
+- **Home charger power** is the sustained AC power delivered to the car. Real-world values may vary due to voltage, wiring, and thermal limits.
+- **Tariffs** vary by state/utility and may be slab-based or ToD. Use your latest bill for accurate rates.
+- **This tool estimates** session time & cost; it does not model tapering at very high SoC.
+""")
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.44.0