Update app.py

app.py

@@ -1,126 +1,118 @@
 import streamlit as st
 import pandas as pd
-import plotly.graph_objects as go
-from datetime import datetime
-import difflib  # For string similarity matching
-
-# Function to create the luminous indicator
-def create_glowing_indicator(color, status):
-    return f"<div style='width: 50px; height: 50px; border-radius: 25px; background: {color}; box-shadow: 0 0 20px {color}; margin: auto;'>{status}</div>"
-
-# Function to load data
+import datetime
+from difflib import get_close_matches
+
+# Function to standardize and find the closest column name
+def get_closest_column(columns, target, threshold=0.6):
+    target = target.lower().replace(" ", "").replace("(", "").replace(")", "").replace("-", "")
+    columns_cleaned = [col.lower().replace(" ", "").replace("(", "").replace(")", "").replace("-", "") for col in columns]
+    matches = get_close_matches(target, columns_cleaned, n=1, cutoff=threshold)
+    if matches:
+        return columns[columns_cleaned.index(matches[0])]
+    return None
+
+# Load the dataset
 @st.cache_data
 def load_data():
     try:
-        # Load the Excel data
-        data = pd.read_excel("grid_load_data.xlsx")
-        
-        # Normalize the column names to lowercase for easy comparison
-        data.columns = [col.strip().lower() for col in data.columns]  # Strip spaces and convert to lowercase
-        
-        # Find the closest match for the 'time' column
-        time_column = difflib.get_close_matches('time', data.columns, n=1, cutoff=0.8)  # 80% similarity
-
-        # Check if a close match is found
-        if time_column:
-            time_column_name = time_column[0]
-            data[time_column_name] = pd.to_datetime(data[time_column_name])
-        else:
-            st.error("No 'Time' column found or a close match.")
-            return pd.DataFrame()  # Return an empty DataFrame to avoid further errors
-        
-        return data
+        df = pd.read_excel("grid_load_data.xlsx")
+
+        # Identify the closest matches for required columns
+        grid_load_col = get_closest_column(df.columns, "Grid Load (kW)")
+        time_col = get_closest_column(df.columns, "Time")
+
+        if not grid_load_col or not time_col:
+            st.error("The dataset must include columns similar to 'Grid Load (kW)' and 'Time'. Please check the formatting.")
+            return None, None
+
+        # Rename columns for consistent processing
+        df = df.rename(columns={grid_load_col: "Grid Load (kW)", time_col: "Time"})
+
+        # Ensure 'Time' column is datetime formatted
+        df["Time"] = pd.to_datetime(df["Time"], errors="coerce")
+        return df, "Grid Load (kW)"
+
+    except FileNotFoundError:
+        st.error("The file 'grid_load_data.xlsx' was not found. Please upload the correct file.")
+        return None, None
     except Exception as e:
-        st.error(f"Error loading data: {e}")
-        return pd.DataFrame()  # Return an empty DataFrame in case of an error
+        st.error(f"An error occurred while loading the dataset: {e}")
+        return None, None
+
+# Function to calculate the predicted grid load for the current hour of the day
+def calculate_predicted_grid_load(df, current_time, grid_load_col):
+    if df is None:
+        st.error("Dataset is not loaded correctly.")
+        return None
+
+    # Extract the hour and day from the current time
+    current_hour = current_time.hour
+
+    # Filter dataset for the given hour across all days
+    df["Hour"] = df["Time"].dt.hour
+    hourly_data = df[df["Hour"] == current_hour]
 
+    if not hourly_data.empty:
+        # Calculate the average grid load for the given hour across all days
+        avg_grid_load = hourly_data[grid_load_col].mean()
+        return avg_grid_load
+    else:
+        st.warning("No data found for the current hour. Using default value.")
+        return 0  # Default to 0 if no data is found for the given hour
+
+# Display the live clock
+def display_clock():
+    current_time = datetime.datetime.now()
+    st.sidebar.markdown(f"### 🕒 {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
+    return current_time
+
+# Main app
 def main():
-    st.set_page_config(layout="wide")  # Set page config first
+    st.title("Optimized EV Charging and Grid Management")
 
     # Load dataset
-    df = load_data()
+    df, grid_load_col = load_data()
+    if df is None or grid_load_col is None:
+        return  # Exit if the dataset is not loaded properly
 
-    # Check if data is empty (in case of error)
-    if df.empty:
-        st.stop()  # Stop the app if the data is not loaded correctly
+    # Sidebar for user inputs
+    with st.sidebar:
+        st.header("User Inputs")
 
-    # Sidebar options
-    mode = st.sidebar.radio("Select Mode", ["Automatic", "Manual"])
+        # Battery details (manually entered)
+        state_of_charge = st.number_input("State of Charge (SOC) in kWh", min_value=0, max_value=100, step=1)
+        battery_capacity = st.number_input("Battery Capacity (kWh)", min_value=10, max_value=200, step=1)
 
-    # Current time
-    current_time = datetime.now()
-    current_hour = current_time.hour
+        # ON/OFF button for exporting battery power to the grid
+        export_power = st.checkbox("Export Power to Grid (ON/OFF)")
 
-    # Dynamic controls for manual mode
-    if mode == "Manual":
-        grid_load = st.sidebar.slider("Select Grid Load (kW)", min_value=0, max_value=5000, value=2500, step=100)
-    else:
-        current_grid_data = df[df['time'].dt.hour == current_hour]  # Assuming 'time' column after processing
-        grid_load = current_grid_data['Grid Load (kW)'].mean() if not current_grid_data.empty else 2500
-
-    # Displaying grid load meter
-    st.markdown("### Grid Load Meter")
-    fig_grid = go.Figure(go.Indicator(
-        mode="gauge+number",
-        value=grid_load,
-        gauge={
-            "axis": {"range": [0, 5000]},
-            "steps": [
-                {"range": [0, 3000], "color": "lightgreen"},
-                {"range": [3000, 3500], "color": "yellow"},
-                {"range": [3500, 5000], "color": "red"}
-            ],
-            "threshold": {"line": {"color": "red", "width": 4}, "thickness": 0.75, "value": 3000}
-        },
-        title={"text": "Grid Load (kW)"}
-    ))
-    st.plotly_chart(fig_grid, use_container_width=True)
-
-    # Alarm indicators
-    left_indicator_color = "green" if grid_load < 3000 else "red"
-    right_indicator_color = "green" if grid_load >= 3000 else "red"
-
-    left_alarm = create_glowing_indicator(left_indicator_color, "")
-    right_alarm = create_glowing_indicator(right_indicator_color, "")
-
-    st.markdown(f"""
-    <div style='display: flex; justify-content: space-between;'>
-        {left_alarm}
-        {right_alarm}
-    </div>
-    """, unsafe_allow_html=True)
-
-    # EV Section
-    st.markdown("### EV Section")
-
-    # EV Connection Toggle
-    ev_export_toggle = st.checkbox("Allow EV Energy Export to Grid", value=False)
-
-    # EVs and Grid Calculation
-    ev_power = 50  # Assume each EV contributes 50 kW
-
-    if grid_load > 3000:
-        excess_load = grid_load - 3000
-        evs_required = -(-excess_load // ev_power)  # Round up EVs required
-
-        st.warning(f"Grid is overloaded by {excess_load} kW. Approximately {evs_required} EVs are needed to stabilize the grid.")
-
-        if ev_export_toggle:
-            # Add EVs slider
-            evs_to_connect = st.slider("Number of EVs to Connect", min_value=0, max_value=int(evs_required), value=0, step=1)
-
-            # Update grid load dynamically
-            grid_load = max(0, grid_load - evs_to_connect * ev_power)
-            st.success(f"{evs_to_connect} EVs connected. Updated Grid Load: {grid_load} kW.")
-
-    elif grid_load <= 3000:
-        remaining_capacity = 3000 - grid_load
-        ev_slots_available = remaining_capacity // ev_power
-        st.success(f"Grid is stable. Approximately {ev_slots_available} EV slots available for charging.")
-
-    # Updated Grid Load Meter
-    fig_grid.update_traces(value=grid_load)
-    st.plotly_chart(fig_grid, use_container_width=True)
+    # Display live clock
+    current_time = display_clock()
+
+    # Predicted grid load
+    predicted_grid_load = calculate_predicted_grid_load(df, current_time, grid_load_col)
+    if predicted_grid_load is not None:
+        st.write(f"### Predicted Grid Load at {current_time.strftime('%H:%M:%S')}: **{predicted_grid_load:.2f} kW**")
+
+        # Evaluate grid status based on the predicted load
+        if predicted_grid_load > 3400:
+            st.error("Grid is Overloaded! EV Charging Disallowed")
+            st.write("🚫 Red Light: EV Charging is Disconnected.")
+        else:
+            st.success("Grid is Stable! EV Charging Allowed")
+            st.write("✅ Green Light: EV Charging is Active.")
+
+        # Calculate available EV slots
+        available_capacity = 3400 - predicted_grid_load
+        ev_slots = available_capacity // 50  # Assuming each EV slot requires 50kW
+        st.write(f"### Available EV Slots: **{ev_slots}**")
+
+        # Export power status
+        if export_power:
+            st.warning("Battery is exporting power to the grid.")
+        else:
+            st.info("Battery is not exporting power.")
 
 if __name__ == "__main__":
     main()