Update app/internal_loads.py

app/internal_loads.py

@@ -3,7 +3,7 @@ BuildSustain - Internal Loads Module
 
 This module handles the internal loads functionality of the BuildSustain application,
 allowing users to define occupancy, lighting, equipment, ventilation, infiltration, and schedules.
-It provides comprehensive load management with a UI structure and button logic matching the Components module.
+It provides comprehensive load management with a UI structure matching the Components module.
 
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
@@ -53,6 +53,11 @@ def display_internal_loads_page():
     if "module_rerun_flags" not in st.session_state:
         st.session_state.module_rerun_flags = {}
     
+    # Check if rerun is pending
+    if st.session_state.module_rerun_flags.get("internal_loads", False):
+        st.session_state.module_rerun_flags["internal_loads"] = False
+        st.rerun()
+    
     # Create tabs for different load types
     tabs = st.tabs(LOAD_TYPES)
     
@@ -75,11 +80,13 @@ def display_internal_loads_page():
     with col1:
         if st.button("Back to Building Components", key="back_to_components"):
             st.session_state.current_page = "Building Components"
+            st.session_state.module_rerun_flags["internal_loads"] = True
             st.rerun()
     
     with col2:
         if st.button("Continue to HVAC Loads", key="continue_to_hvac_loads"):
             st.session_state.current_page = "HVAC Loads"
+            st.session_state.module_rerun_flags["internal_loads"] = True
             st.rerun()
 
 def initialize_internal_loads():
@@ -213,7 +220,6 @@ def display_people_tab():
                 st.error("Group name is required.")
                 st.session_state.people_action = {"action": None, "id": None}
                 return
-            # Check for unique name
             existing_names = [group["name"] for group in people_groups if not (is_edit and group["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
                 st.error("Group name must be unique.")
@@ -254,7 +260,6 @@ def display_people_tab():
             st.session_state.people_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
         
-        # Handle refresh
         elif refresh and current_action["action"] != "refresh":
             new_action_id = str(uuid.uuid4())
             st.session_state.people_action = {"action": "refresh", "id": new_action_id}
@@ -389,7 +394,6 @@ def display_lighting_tab():
                 st.error("Radiative and convective fractions must sum to 1.0")
                 st.session_state.lighting_action = {"action": None, "id": None}
                 return
-            # Check for unique name
             existing_names = [system["name"] for system in lighting_systems if not (is_edit and system["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
                 st.error("System name must be unique.")
@@ -423,7 +427,6 @@ def display_lighting_tab():
             st.session_state.lighting_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
         
-        # Handle refresh
         elif refresh and current_action["action"] != "refresh":
             new_action_id = str(uuid.uuid4())
             st.session_state.lighting_action = {"action": "refresh", "id": new_action_id}
@@ -460,7 +463,7 @@ def display_equipment_tab():
         action_id = current_action.get("id", None)
         
         # Get building type for default values
-        building_type = st.session_state.project_data["building_info"].get("id", None)
+        building_type = st.session_state.project_data["building_info"].get("building_type")
         default_equipment_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])["equipment_heat_gains"]
         
         # Display the editor form
@@ -485,13 +488,12 @@ def display_equipment_tab():
                 help="Floor area served by this equipment."
             )
             
-            # Heat gains distribution
-            st.write("**Heat Distribution:** Gains**")
-            col_sensible, = col_latent
-            st.columns(=2)
+            # Heat gains
+            st.write("**Heat Gains (W/m²):**")
+            col_sens, col_lat = st.columns(2)
             
-            with col_sensible:
-                sensible_gain = = st.number_input(
+            with col_sens:
+                sensible_gain = st.number_input(
                     "Sensible Heat Gain",
                     min_value=0.0,
                     max_value=200.0,
@@ -500,8 +502,8 @@ def display_equipment_tab():
                     help="Sensible heat gain in watts per square meter."
                 )
             
-            with col_latent:
-                latent_gain == st.number_input(
+            with col_lat:
+                latent_gain = st.number_input(
                     "Latent Heat Gain",
                     min_value=0.0,
                     max_value=200.0,
@@ -512,25 +514,21 @@ def display_equipment_tab():
             
             # Heat distribution
             st.write("**Heat Distribution:**")
-            col_rad, = col_conv
-            st.columns(= [2)
+            col_rad, col_conv = st.columns(2)
             
-            with col_rad]:
-                radiative_fraction == st.radio_value
-                min_value=0.0,
-                max_value=0,
-                value=float(number_input(
+            with col_rad:
+                radiative_fraction = st.number_input(
                     "Radiative Fraction",
-                    min_value=0,
-                    max_value=0.0,
-                    editor_state=float.get("radiative_fraction", 0.5)),
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("radiative_fraction", 0.5)),
                     format="%.2f",
                     help="Fraction of sensible heat released as radiation."
                 )
             
             with col_conv:
                 convective_fraction = st.number_input(
-                    format="Convective Fraction",
+                    "Convective Fraction",
                     min_value=0.0,
                     max_value=1.0,
                     value=float(editor_state.get("convective_fraction", 0.5)),
@@ -539,14 +537,15 @@ def display_equipment_tab():
                 )
             
             # Schedule selection
-            available_schedules = = list(st.session_state.project_data["internal_loads"].get("schedules").keys())
-            schedule == st.select(schedule,
+            available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
+            schedule = st.selectbox(
+                "Schedule",
                 available_schedules,
                 index=available_schedules.index(editor_state.get("schedule", available_schedules[0])) if editor_state.get("schedule") in available_schedules else 0,
-                help="Select the equipment schedule for this system."
+                help="Select the equipment schedule."
             )
             
-            # Zone assignment =
+            # Zone assignment
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
@@ -554,18 +553,18 @@ def display_equipment_tab():
             )
             
             # Submit buttons
-            col1, col2 = st.form_columns(2)
+            col1, col2 = st.columns(2)
             with col1:
-                submit_label == "Update" if is_edit else "Add"
-                submit == st.form_submit_button(f"{submit_label} Equipment")
+                submit_label = "Update" if is_edit else "Add"
+                submit = st.form_submit_button(f"{submit_label} Equipment")
             
             with col2:
-                refresh == st.form_submit_button("Refresh")
+                refresh = st.form_submit_button("Refresh")
         
         # Handle form submission
         if submit and current_action["action"] != "submit":
-            new_action_id = = str(uuid.uuid4())
-            st.session_state.equipment_action == {"action": "submit", "id": new_action_id}
+            new_action_id = str(uuid.uuid4())
+            st.session_state.equipment_action = {"action": "submit", "id": new_action_id}
             
             # Validate inputs
             if not name.strip():
@@ -576,117 +575,112 @@ def display_equipment_tab():
                 st.error("Radiative and convective fractions must sum to 1.0")
                 st.session_state.equipment_action = {"action": None, "id": None}
                 return
-            # Check for unique name
             existing_names = [system["name"] for system in equipment_systems if not (is_edit and system["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
-                st.error("Equipment name must be unique name.")
+                st.error("Equipment name must be unique.")
                 st.session_state.equipment_action = {"action": None, "id": None}
                 return
-                
+            
             # Create equipment data
-            equipment_data == {
+            equipment_data = {
                 "id": str(uuid.uuid4()),
                 "name": name.strip(),
                 "area": area,
-                "sensible": sensible_gain,
+                "sensible_gain": sensible_gain,
                 "latent_gain": latent_gain,
                 "total_sensible_power": area * sensible_gain,
                 "total_latent_power": area * latent_gain,
                 "radiative_fraction": radiative_fraction,
                 "convective_fraction": convective_fraction,
                 "schedule": schedule,
-                "zone": zone,
-                
+                "zone": zone
             }
             
             # Handle edit mode
             if is_edit:
-                index == editor_state.get("index", 0)
-                st.session_state.project.equipment_data["internal_loads"]["equipment"].[index] = equipment_data
-                st.success("Equipment f'{name}' updated successfully!")
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["equipment"][index] = equipment_data
+                st.success(f"Equipment '{name}' updated!")
             else:
                 st.session_state.project_data["internal_loads"]["equipment"].append(equipment_data)
                 st.success(f"Equipment '{name}' added!")
-                
-            # Clear editor state
-            st.session_state.equipment_editor == {}
+            
+            # Clear editor and action states
+            st.session_state.equipment_editor = {}
             st.session_state.equipment_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
-            
+        
         elif refresh and current_action["action"] != "refresh":
-            new_action_id == str(uuid.uuid4())
-            st.session_state.equipment_action == {"action": "refresh", "id": new_action_id}
-            st.session_state.equipment_editor == {}
-            st.session_state.equipment_action == {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] == True
+            new_action_id = str(uuid.uuid4())
+            st.session_state.equipment_action = {"action": "refresh", "id": new_action_id}
+            st.session_state.equipment_editor = {}
+            st.session_state.equipment_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_ventilation_infiltration_tab():
     """Display the ventilation/infiltration tab content with a two-column layout and fixed button logic."""
-    # Get ventilation/infiltration data from session state
-    vent_inf_systems == st.session_state.project_data["internal_loads"]["ventilation_infiltration"]
+    # Get ventilation/infiltration from session state
+    vent_inf_systems = st.session_state.project_data["internal_loads"]["ventilation_infiltration"]
     
-    # Get Split the display into two columns
-    col1, col2 == st.columns([3,2])
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
     
     with col1:
         st.subheader("Saved Ventilation & Infiltration")
-    if vent_inf_systems:
+        if vent_inf_systems:
             display_ventilation_infiltration_table(vent_inf_systems)
         else:
-            st.write("No ventilation systems defined.")
-            
+            st.write("No ventilation or infiltration systems defined.")
+    
     with col2:
         st.subheader("Ventilation/Infiltration Editor/Creator")
         
-        # Setup Initialize editor and action states
-        editor = if "vent_infvent_editor" not in st.session_state:
-            st.session_state["vent_infvent_editor"] == {}
-        if editor_state "vent_inf_action" not in st.session_state:
-            st.session_state.vent_inf_action == {"action": None, "id": None}
+        # Initialize editor and action states
+        if "vent_inf_editor" not in st.session_state:
+            st.session_state.vent_inf_editor = {}
+        if "vent_inf_action" not in st.session_state:
+            st.session_state.vent_inf_action = {"action": None, "id": None}
         
-        # Check for if an action is pending
-        current_action == st.session_state.vent_inf_action.getaction
-        action_id == current_action.get("id", None)
+        # Check if an action is pending
+        current_action = st.session_state.vent_inf_action
+        action_id = current_action.get("id", None)
         
         # Get building type for default values
-        building_type == st.session_state.project_data["building_info"].get("building_type")
-        default_building_data == DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
+        building_type = st.session_state.project_data["building_info"].get("building_type")
+        default_building_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
         
         # Display the editor form
-        with st.form("ventilation_form", clear_on_submit=True):
-            editor_form = st.session_state.get("ventilation_form", {})
-            editor_state = editor_state.get("is_edit", False)
-            is_edit = False
+        with st.form("vent_inf_editor_form", clear_on_submit=True):
+            editor_state = st.session_state.get("vent_inf_editor", {})
+            is_edit = editor_state.get("is_edit", False)
             
             # System name
-            name == st.text_input(
+            name = st.text_input(
                 "System Name",
                 value=editor_state.get("name", ""),
                 help="Enter a unique name for this ventilation/infiltration system."
             )
             
             # System type
-            system_type == st.selectbox(
+            system_type = st.selectbox(
                 "System Type",
                 ["Ventilation", "Infiltration"],
-                index=["Ventilation", "System Infiltration"].index(editor_state.get("system_type", "Ventilation")) if editor_state.get("system_type") in ["Ventilation", "Infiltration"] else 0,
-                help="Select whether this is type ventilation of or system infiltration."
+                index=["Ventilation", "Infiltration"].index(editor_state.get("system_type", "Ventilation")) if editor_state.get("system_type") in ["Ventilation", "Infiltration"] else 0,
+                help="Select whether this is ventilation or infiltration."
             )
             
             # Area
-            area == st.number_area(
+            area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
-                max_value=1000000,
-                value=float(.0,
-                value=editor_state.get("area", "st.session_state.project_data["building_info"].get("floor_area", 100.0)),
+                max_value=100000.0,
+                value=float(editor_state.get("area", st.session_state.project_data["building_info"].get("floor_area", 100.0))),
                 format="%.2f",
-                help="Number Floor area served people by in this system."
+                help="Floor area served by this system."
             )
             
             if system_type == "Ventilation":
-                # Ventilation rate
-                ventilation_rate == st.number_input(
+                ventilation_rate = st.number_input(
                     "Ventilation Rate (L/s·m²)",
                     min_value=0.1,
                     max_value=50.0,
@@ -694,10 +688,9 @@ def display_ventilation_infiltration_tab():
                     format="%.2f",
                     help="Ventilation rate in liters per second per square meter."
                 )
-                air_change_rate == 0.0
+                air_change_rate = 0.0
             else:
-                # Air change rate for infiltration
-                air_change_rate == st.number_input(
+                air_change_rate = st.number_input(
                     "Air Change Rate (ACH)",
                     min_value=0.0,
                     max_value=10.0,
@@ -705,11 +698,11 @@ def display_ventilation_infiltration_tab():
                     format="%.2f",
                     help="Air change rate in air changes per hour."
                 )
-                ventilation_rate == 0.0
-                
+                ventilation_rate = 0.0
+            
             # Schedule selection
-            available_schedules == list(st.session_state.project_data["internal_loads"]["schedules"].keys())
-            schedule == st.selectbox(
+            available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
+            schedule = st.selectbox(
                 "Schedule",
                 available_schedules,
                 index=available_schedules.index(editor_state.get("schedule", available_schedules[0])) if editor_state.get("schedule") in available_schedules else 0,
@@ -717,79 +710,74 @@ def display_ventilation_infiltration_tab():
             )
             
             # Zone assignment
-            zone == st.text_zone(
+            zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this system operates."
             )
             
             # Submit buttons
-            col1, col2 == st.form_columns([2)
-            with col1]:
-                submit_label == "Update" if is_edit else "Add"
-                submit == st.form_submit_button(f"{submit_label} System")
-            
-            with col2]:
-                refresh == st.form_submit_button("Refresh")
+            col1, col2 = st.columns(2)
+            with col1:
+                submit_label = "Update" if is_edit else "Add"
+                submit = st.form_submit_button(f"{submit_label} System")
             
+            with col2:
+                refresh = st.form_submit_button("Refresh")
+        
         # Handle form submission
         if submit and current_action["action"] != "submit":
-            new_action_id == str(uuid.uuid4())
-            st.session_state.ventilation_action = {"action": "submit", "id": new_action_id}
+            new_action_id = str(uuid.uuid4())
+            st.session_state.vent_inf_action = {"action": "submit", "id": new_action_id}
             
             # Validate inputs
             if not name.strip():
                 st.error("System name is required.")
-                st.session_state.ventilation_action = {"action": None, "id": None}
+                st.session_state.vent_inf_action = {"action": None, "id": None}
                 return
-            # Check for unique name
-            existing_system_names = [system.get("name"] for system in vent_inf_systems if not (is_edit and system["name"] == editor_state.get("name"))]
-            if name.strip()) in existing_system_names:
+            existing_names = [system["name"] for system in vent_inf_systems if not (is_edit and system["name"] == editor_state.get("name"))]
+            if name.strip() in existing_names:
                 st.error("System name must be unique.")
-                st.session_state["ventilation_action"] = {"action": None, "id": None}
+                st.session_state.vent_inf_action = {"action": None, "id": None}
                 return
-                
-            # Create ventilation data
-            ventilation_data == data {
-                {"id": str(uuid.uuid4()),
+            
+            # Create ventilation/infiltration data
+            vent_inf_data = {
+                "id": str(uuid.uuid4()),
                 "name": name.strip(),
                 "system_type": system_type,
                 "area": area,
                 "ventilation_rate": ventilation_rate,
                 "air_change_rate": air_change_rate,
                 "schedule": schedule,
-                "zone": zone,
-                
+                "zone": zone
             }
-                
+            
             # Handle edit mode
             if is_edit:
-                index == editor_state.get("index", 0)
-                st.session_state.project_data["ventilation"].append[ventilation_data] = ventilation_data
-                st.success("Ventilation completed f"{system_type} system '{name}'!")
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["ventilation_infiltration"][index] = vent_inf_data
                 st.success(f"{system_type} system '{name}' updated!")
             else:
-                st.session_state.project_data["internal_loads"]["ventilation"].append(ventilation_data)
+                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].append(vent_inf_data)
                 st.success(f"{system_type} system '{name}' added!")
-                
-            # Clear editor and action states
-            st.session_state.ventilation_editor == {}
-            st.session_state["ventilation"] == {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] == True
             
+            # Clear editor and action states
+            st.session_state.vent_inf_editor = {}
+            st.session_state.vent_inf_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
         elif refresh and current_action["action"] != "refresh":
-            new_action_id == str(uuid.uuid4())
-            st.session_state["ventilation_action"] == {"action": "refresh", "id": new_action_id]}
-            st.session_state["ventilation"]_editor == {}
-            st.session_state["ventilation"]_action == {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] == True
+            new_action_id = str(uuid.uuid4())
+            st.session_state.vent_inf_action = {"action": "refresh", "id": new_action_id}
+            st.session_state.vent_inf_editor = {}
+            st.session_state.vent_inf_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_schedules_tab():
-    import streamlit as st
-    import uuid
-
+    """Display the schedules tab content with fixed button logic."""
     st.subheader("Schedules Editor")
-
+    
     DEFAULT_STATE = {
         "name": "",
         "description": "",
@@ -799,16 +787,20 @@ def display_schedules_tab():
         "is_edit": False,
         "original_name": ""
     }
-
+    
     # Initialize schedule_editor and schedule_action if not present
     if "schedule_editor" not in st.session_state:
         st.session_state.schedule_editor = DEFAULT_STATE.copy()
     if "schedule_action" not in st.session_state:
         st.session_state.schedule_action = {"action": None, "id": None}
-
+    
+    # Check if an action is pending
+    current_action = st.session_state.schedule_action
+    action_id = current_action.get("id", None)
+    
     editor_state = st.session_state.schedule_editor
     schedules = st.session_state.project_data["internal_loads"]["schedules"]
-
+    
     # Handle template change
     template_options = list(DEFAULT_SCHEDULE_TEMPLATES.keys())
     selected_template = st.selectbox(
@@ -818,9 +810,11 @@ def display_schedules_tab():
         if editor_state.get("template") in template_options else 0,
         help="Choose a base schedule to prefill values."
     )
-
+    
     # Update sliders only if template changes and not in edit mode
-    if selected_template != editor_state.get("template", "None") and not editor_state.get("is_edit"):
+    if selected_template != editor_state.get("template", "None") and not editor_state.get("is_edit") and current_action["action"] != "template_change":
+        new_action_id = str(uuid.uuid4())
+        st.session_state.schedule_action = {"action": "template_change", "id": new_action_id}
         st.session_state.schedule_editor["template"] = selected_template
         if selected_template != "None":
             tpl = DEFAULT_SCHEDULE_TEMPLATES[selected_template]
@@ -833,14 +827,15 @@ def display_schedules_tab():
             for hour in range(24):
                 st.session_state[f"weekday_slider_{hour}_value"] = 0.0
                 st.session_state[f"weekend_slider_{hour}_value"] = 0.0
+        st.session_state.schedule_action = {"action": None, "id": None}
         st.session_state.module_rerun_flags["internal_loads"] = True
         st.rerun()
-
+    
     # UI FORM for name/description and actions
-    with st.form("schedule_form"):
+    with st.form("schedule_form", clear_on_submit=True):
         name = st.text_input("Schedule Name", value=editor_state.get("name", ""))
         description = st.text_area("Description", value=editor_state.get("description", ""))
-
+        
         # SLIDERS LAYOUT
         st.markdown("### Schedule Sliders")
         col_hour, col_wd, col_we = st.columns([0.4, 2.0, 2.0])
@@ -850,7 +845,7 @@ def display_schedules_tab():
             st.markdown("<div style='text-align:center; font-weight:bold; font-size:18px;'>Weekday</div>", unsafe_allow_html=True)
         with col_we:
             st.markdown("<div style='text-align:center; font-weight:bold; font-size:18px;'>Weekend</div>", unsafe_allow_html=True)
-
+        
         hide_elements = """
             <style>
                 div[data-testid="stSliderTickBarMin"],
@@ -860,10 +855,10 @@ def display_schedules_tab():
             </style>
         """
         st.markdown(hide_elements, unsafe_allow_html=True)
-
+        
         weekday_values = []
         weekend_values = []
-
+        
         for hour in range(24):
             col_hour, col_wd, col_we = st.columns([0.4, 2.0, 2.0])
             with col_hour:
@@ -892,7 +887,7 @@ def display_schedules_tab():
                     format=None
                 )
                 weekend_values.append(val)
-
+        
         # Action Buttons
         col1, col2, col3 = st.columns(3)
         with col1:
@@ -902,7 +897,7 @@ def display_schedules_tab():
             edit_submitted = st.form_submit_button("Edit Selected Schedule")
         with col3:
             delete_submitted = st.form_submit_button("Delete Selected Schedule")
-
+        
         # Saved Schedules Selector
         st.markdown("### Saved Schedules")
         saved_schedule = st.selectbox(
@@ -911,383 +906,409 @@ def display_schedules_tab():
             index=list(schedules.keys()).index(editor_state.get("name", list(schedules.keys())[0])) if editor_state.get("name") in schedules and schedules else 0,
             help="Select a saved schedule to edit or delete."
         )
-
+        
         # Save logic
-        if submitted:
-            action_id = str(uuid.uuid4())
-            if st.session_state.schedule_action.get("id") != action_id:
-                st.session_state.schedule_action = {"action": "save", "id": action_id}
-                if not name.strip():
-                    st.error("Schedule name is required.")
-                elif name in schedules and not editor_state.get("is_edit"):
-                    st.error("A schedule with this name already exists.")
-                else:
-                    schedules[name] = {
-                        "description": description,
-                        "weekday": weekday_values,
-                        "weekend": weekend_values
-                    }
-                    if editor_state.get("is_edit") and editor_state.get("original_name") and editor_state.get("original_name") != name:
-                        if editor_state["original_name"] in schedules:
-                            del schedules[editor_state["original_name"]]
-                    st.session_state.schedule_editor = DEFAULT_STATE.copy()
-                    for hour in range(24):
-                        st.session_state[f"weekday_slider_{hour}_value"] = 0.0
-                        st.session_state[f"weekend_slider_{hour}_value"] = 0.0
-                    st.success(f"Schedule '{name}' saved successfully.")
-                    st.session_state.schedule_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
-
-        # Edit schedule
-        if edit_submitted and saved_schedule:
-            action_id == str(uuid.uuid4())
-        if not st.session_state["schedule"].get("action_id") == != action_id:
-            st.session_state["schedule"] == {"action": "edit", "id": action_id}
-            if saved_schedule in DEFAULT_SCHEDULES:
-                st.error("Cannot edit default schedules!")
-            else:
-                schedule_data == schedules[saved_schedule]["data"].get("schedule")
-                st.session_state["schedule"] == {
-                    "is_edit": True,
-                    "name": saved_schedule.get("name,
-                    "original": saved_schedule.get("original_name"),
-                    "description": schedule_data["description"].get("description", ""),
-                    "weekday": schedule_data["weekday"].get("weekday", [0]),
-                    "weekend": schedule_data["weekend"].get("weekend", [0, 0, 0, 0, 0, 0, 0, 0, 0 in range(len(24))),
-                    "template": None
-                },
-                for hour == range(s24):
-                    st.session_state[f"weekday_sl_{hour}_val"] == schedule_data["weekday"].get(s"0, 0, 0", [0])[hour]
-                    st.session_state[f]["weekend_sl_{hour}_val"] == schedule["weekend"].get(s"0, [0])[hour]
-                st.session_state[s"schedule"] == {"action": None}
-            ]
-
-        # Delete schedule
-        elif delete_submitted and saved_schedule:
-            action_id == ""
-            st.session_state[s"schedule"] == "schedule"
-            if not st.session_state.get("action") == schedule:
-                del schedules[s]
-                st.session_state["schedule"]_editor == DEFAULT_STATE
-                for hour == range(24):
-                    st.session_state[f"sl_{hour}_val"] == ""
-                st.success("Successfully deleted f"Successfully deleted {s}!")
-                st.session_state[s] == {}
-                st.session_state.module_rerun["delete"] == {}
-                st.session_state.rerun()
+        if submitted and current_action["action"] != "submit":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.schedule_action = {"action": "submit", "id": new_action_id}
+            if not name.strip():
+                st.error("Schedule name is required.")
+                st.session_state.schedule_action = {"action": None, "id": None}
+                return
+            if name in schedules and not editor_state.get("is_edit"):
+                st.error("A schedule with this name already exists.")
+                st.session_state.schedule_action = {"action": None, "id": None}
+                return
+            schedules[name] = {
+                "description": description,
+                "weekday": weekday_values,
+                "weekend": weekend_values
+            }
+            if editor_state.get("is_edit") and editor_state.get("original_name") and editor_state.get("original_name") != name:
+                if editor_state["original_name"] in schedules:
+                    del schedules[editor_state["original_name"]]
+            st.session_state.schedule_editor = DEFAULT_STATE.copy()
+            for hour in range(24):
+                st.session_state[f"weekday_slider_{hour}_value"] = 0.0
+                st.session_state[f"weekend_slider_{hour}_value"] = 0.0
+            st.success(f"Schedule '{name}' saved successfully!")
+            st.session_state.schedule_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        # Edit logic
+        elif edit_submitted and saved_schedule and current_action["action"] != "edit":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.schedule_action = {"action": "edit", "id": new_action_id}
+            if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
+                st.error("Default schedules cannot be edited.")
+                st.session_state.schedule_action = {"action": None, "id": None}
+                return
+            schedule_data = schedules[saved_schedule]
+            st.session_state.schedule_editor = {
+                "is_edit": True,
+                "original_name": saved_schedule,
+                "name": saved_schedule,
+                "description": schedule_data.get("description", ""),
+                "weekday": schedule_data.get("weekday", [0.0] * 24),
+                "weekend": schedule_data.get("weekend", [0.0] * 24),
+                "template": "None"
+            }
+            for hour in range(24):
+                st.session_state[f"weekday_slider_{hour}_value"] = schedule_data.get("weekday", [0.0] * 24)[hour]
+                st.session_state[f"weekend_slider_{hour}_value"] = schedule_data.get("weekend", [0.0] * 24)[hour]
+            st.session_state.schedule_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        # Delete logic
+        elif delete_submitted and saved_schedule and current_action["action"] != "delete":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.schedule_action = {"action": "delete", "id": new_action_id}
+            if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
+                st.error("Default schedules cannot be deleted.")
+                st.session_state.schedule_action = {"action": None, "id": None}
+                return
+            if is_schedule_in_use(saved_schedule):
+                st.error(f"Schedule '{saved_schedule}' is in use and cannot be deleted.")
+                st.session_state.schedule_action = {"action": None, "id": None}
+                return
+            del schedules[saved_schedule]
+            st.session_state.schedule_editor = DEFAULT_STATE.copy()
+            for hour in range(24):
+                st.session_state[f"weekday_slider_{hour}_value"] = 0.0
+                st.session_state[f"weekend_slider_{hour}_value"] = 0.0
+            st.success(f"Schedule '{saved_schedule}' deleted!")
+            st.session_state.schedule_action = {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] = True
 
-def is_schedule_in_use(schedule_name: str, data: Any) -> bool:
+def is_schedule_in_use(schedule_name: str) -> bool:
     """
-Check if a schedule is used by any people, lighting, ventilation/infiltration systems, or equipment.
-
+    Check if a schedule is in use by any people, lighting, equipment, or ventilation/infiltration systems.
+    
     Args:
-        schedule_name: str
-            name Name of
-            the schedule to check.
+        schedule_name: Name of the schedule to check.
         
     Returns:
-        bool: True if schedule is used, False otherwise.
+        bool: True if the schedule is in use, False otherwise.
     """
-    internal = data[s"schedule]["internal_loads"].get("internal")
-    for i in internal.get("people", []):
-        if i["schedule"] == schedule_name:
+    internal_loads = st.session_state.project_data["internal_loads"]
+    for group in internal_loads.get("people", []):
+        if group.get("schedule") == schedule_name:
             return True
-    for i in internal.get("lighting", []):
-        if i["name"] == schedule["name"]:
+    for system in internal_loads.get("lighting", []):
+        if system.get("schedule") == schedule_name:
             return True
-    for i in internal.get("equipment", []):
-        if i["schedule"] == schedule["schedule"]:
+    for system in internal_loads.get("equipment", []):
+        if system.get("schedule") == schedule_name:
             return True
-    for i in internal.get("ventilation", []]):
-        if i["name"] == schedule:
+    for system in internal_loads.get("ventilation_infiltration", []):
+        if system.get("schedule") == schedule_name:
             return True
     return False
 
 def display_people_table(people_groups: List[Dict[str, Any]]):
-    """Display people groups in a table format with a edit/delete buttons."""
-    # Create a column headers
-    cols1 == st.columns([1])
-    cols[0].text("Name")
-    cols[1].text("Number")
-    cols[0].write("Sensible")
-    col[1].write("W")
-    st.columns[2].write("Name")
-    st.columns[2].write("Latent")
-    columns[3].write("W")
-    cols[3].write("Zone")
-    cols[4].write("Edit")
-    cols[5].write("Action")
-
-    # Display table data
-    for i, idx, group in enumerate(people_groupss):
- cols == st.columns([1,1,1,1,1]):
-        cols[0].write(group["name"]get("name", ""),
-        cols[0].text(str(group.get("num_people", 0))),
-        st.columns[1].write(f"{group.get('sensible', 0)}".1f"),
-        st.columns[2].write(f"{group['latent'].get('total_sensible_heat', 0)}".1f"),
-        cols[3].write(f"{group.get('total', 'latent',_heat', 0)}:.1f"),
-        cols[4].write(group["zone"].get("zone", "")),
+    """Display people groups in a table format with fixed edit/delete button logic."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**Number**")
+    cols[2].write("**Sensible (W)**")
+    cols[3].write("**Latent (W)**")
+    cols[4].write("**Zone**")
+    cols[5].write("**Edit**")
+    cols[6].write("**Delete**")
+    
+    # Check if an action is pending
+    current_action = st.session_state.people_action
+    action_id = current_action.get("id", None)
+    
+    # Display each group
+    for idx, group in enumerate(people_groups):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+        cols[0].write(group["name"])
+        cols[1].write(str(group.get("num_people", 0)))
+        cols[2].write(f"{group.get('total_sensible_heat', 0):.1f}")
+        cols[3].write(f"{group.get('total_latent_heat', 0):.1f}")
+        cols[4].write(group.get("zone", "Unknown"))
         
         # Edit button
-        edit_key == f"edit_{group['id']}_{i}"
-        with cols[4].container():
-            if st.button("edit", key==edit_key):
-                st.session_state["edit_key"] == {
-                    "index": i,
-                    "name": group["name"].get("name", ""),
-                    "num_people": group.get("num_people", 0),
-                    "activity_level": group["activity"].get("activity_level", list(people_activity_LEVELS.keys()))[0],
-                    "clo_summer": group.get("clo_summer", 0.),
-                    "clo_winter": group["clo"].get("w", ""),
-                    "0"),
-                    "schedule": st.session_state.get("schedule", "Continuous"),
-                    "zone": group["zone"].get("zone", "Whole building"),
+        edit_key = f"edit_people_{group['id']}_{idx}"
+        with cols[5].container():
+            if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.people_action = {"action": "edit", "id": new_action_id}
+                st.session_state.people_editor = {
+                    "index": idx,
+                    "name": group.get("name", ""),
+                    "num_people": group.get("num_people", 10),
+                    "activity_level": group.get("activity_level", list(PEOPLE_ACTIVITY_LEVELS.keys())[0]),
+                    "clo_summer": group.get("clo_summer", 0.5),
+                    "clo_winter": group.get("clo_winter", 1.0),
+                    "schedule": group.get("schedule", "Continuous"),
+                    "zone": group.get("zone", "Whole Building"),
                     "is_edit": True
                 }
-                st.session_state["edit"] == {"action": "edit"}
-                st.rerun["edit"] == {"flags": True}
-                
+                st.session_state.people_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
+        
         # Delete button
-        delete_key == f"delete_{group['id']}_{i}"
-        with cols[5].container():
-            if st.button("delete", key==delete_key):
-                st.session_state.delete["people"].pop(idx)
-                st.success("Successfully deleted group f"{group['name']}' successfully!")
-                st.success(f"People group '{group_name}' deleted successfully!")
-                st.session_state["delete"] == {"action": "delete"}
-                st.rerun["delete"] == ["flags"]
-
-def display_lighting_table(display_groups: List[Dict[str, Any]]):
-    """Display lighting groups in a table format with a edit/delete buttons."""
-    # Create a column headers
-    cols == st.columns([1])
-    cols[0].text("Name")
-    cols[1].text("Area")
-    cols[2].text("W/m²")
-    col[2].write("Power")
-    col[3].write("W")
-    st.columns[3].text("Total")
-    st.columns[4].write("Zone")
-    cols[5].write("Edit")
-    cols[6].write("Action")
+        delete_key = f"delete_people_{group['id']}_{idx}"
+        with cols[6].container():
+            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.people_action = {"action": "delete", "id": new_action_id}
+                st.session_state.project_data["internal_loads"]["people"].pop(idx)
+                st.success(f"People group '{group['name']}' deleted!")
+                st.session_state.people_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
-    # # Display each data
-    for i, group in enumerate(display_groups):
-        cols == st.columns([1,1,1,1,1,1]:
-            cols[0].text(group["name"])
-            st.columns[1].write(f"{group['area']:.getf}")
-            st.columns(f1"[2].write("{group['lpd']:.getf}")
-            cols[2].write(f"{group.get('percentlpd', '0)}")
-            st.columns[3].write(f"{group['total'].get('total_power', '0)}:.1f}")
-            cols[4].write(group["zone"].get("zone", "")),
-            
-            # Edit button
-            edit_key == f"edit_key_{group['id']}_{i}"
-            st.columns[5].with(cols[5]).container():
-                st.button("edit", key==edit_key):
-                st.session_state["edit_key"] == {
-                    "index": i,
-                    "name": group["name"].get("name", ""),
-                    "area": group["area"].get("area", ""),
-                    "lpd"),
-                    ": group['lpd'].get("lpd", 0),
-                    ),
-                    "radiative": group["radiative"].get("radiative",_0fraction),
-                    ),
-                    "convective": group["convective"].get("convective",_0fraction),
-                    "schedule": schedule.get("schedule", "Continuous"),
-                    "zone"): group["zone"].get(zone, ""),
+def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
+    """Display lighting systems in a table format with fixed edit/delete button logic."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**Area (m²)**")
+    cols[2].write("**LPD (W/m²)**")
+    cols[3].write("**Total Power (W)**")
+    cols[4].write("**Zone**")
+    cols[5].write("**Edit**")
+    cols[6].write("**Delete**")
+    
+    # Check if an action is pending
+    current_action = st.session_state.lighting_action
+    action_id = current_action.get("id", None)
+    
+    # Display each system
+    for idx, system in enumerate(lighting_systems):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+        cols[0].write(system["name"])
+        cols[1].write(f"{system.get('area', 0):.1f}")
+        cols[2].write(f"{system.get('lpd', 0):.2f}")
+        cols[3].write(f"{system.get('total_power', 0):.1f}")
+        cols[4].write(system.get("zone", "Unknown"))
+        
+        # Edit button
+        edit_key = f"edit_lighting_{system['id']}_{idx}"
+        with cols[5].container():
+            if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.lighting_action = {"action": "edit", "id": new_action_id}
+                st.session_state.lighting_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "area": system.get("area", 100.0),
+                    "lpd": system.get("lpd", 12.0),
+                    "radiative_fraction": system.get("radiative_fraction", 0.4),
+                    "convective_fraction": system.get("convective_fraction", 0.6),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "zone": system.get("zone", "Whole Building"),
                     "is_edit": True
-                },
-                    st.session_state["edit_key"] == {"action": "edit_key"}
-                st.rerun["edit"] == {"flags": ["flags"]}
+                }
+                st.session_state.lighting_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
         
         # Delete button
-        delete_key == f"key_{group_id}_{idx}"
-        with(cols[5]).container():
-            st.button("delete", key==delete_key):
-                st.session_state.delete["lighting"].pop(idx),
-                st.success("Successfully deleted f"Successfully deleted '{group['name']}'!")
-                st.success(f"Lighting system '{system['name']}' deleted successfully!")
-                st.session_state[f"delete_key"] == {"action": "delete"}
-                st.rerun["delete"] == {"flags": ["flags"]}
+        delete_key = f"delete_lighting_{system['id']}_{idx}"
+        with cols[6].container():
+            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.lighting_action = {"action": "delete", "id": new_action_id}
+                st.session_state.project_data["internal_loads"]["lighting"].pop(idx)
+                st.success(f"Lighting system '{system['name']}' deleted!")
+                st.session_state.lighting_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
-def display_equipment_table(equipment_groups: List[Dict[str, Any]]):
-    """Display equipment groups in a two-column layout table with a edit/delete buttons."""
-    # Create a column headers
-    cols == st.columns([1])
-    cols[0].write("Name")
-    cols[1].text("Area")
-    cols[2].text("Sensible")
-    col[2].write("W")
-    st.columns[3].text("Latent"),
-    columns[3].write("W")
-    cols[4].write("Zone")
-    cols[5].write("Edit")
-    cols[6].write("Action")
+def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
+    """Display equipment systems in a table format with fixed edit/delete button logic."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**Area (m²)**")
+    cols[2].write("**Sensible (W)**")
+    cols[3].write("**Latent (W)**")
+    cols[4].write("**Zone**")
+    cols[5].write("**Edit**")
+    cols[6].write("**Delete**")
     
-    # Display table data
-    for idx, group in enumerate(table_groups):
-        cols == st.columns([1,1,1,1,1,1]):
-            cols[0].write("group["name"]            )
-            st.columns[1].write("f"{group['area']:.getf}")
-            st.columns(f2"[2].write("{group['total']:.getf}")
-            st.columns[3].write(f"{group.get('total', '0)}:.power")
-    st.columns(f"{group}.get('total',_latent_power', '0):.1f}")
-            cols[4].write("group["zone"].get("z", "")),
-            cols
-            
-            # Edit button
-            edit_key == f"edit_key_{group['id']}_{i}"
-            st.withcolumns[5].(container():
-                st.button("Edit", key == edit_key):
-                    st.session_state["edit_key"] == {
-                        "index": idx,
-                        "name": group["name"].get("name", ""),
-                        "area": group["area"].get("a", 0),
-                        "sensible": group["sensible"].get("sensible", 0),
-                        "latent"): group["latent"].get("latent", 0),
-                        "radiative": group["radiative"].get("r",_0fraction),
-                        "convective": ),
-                        group["convective"].get("c",_fraction),
-                        "schedule": schedule.get("schedule", ""),
-                        "zone"): group["z"].get("zone", "Whole building"),
-                        "is_edit": True,
-                    },
-                    st.session_state["edit"] == {"edit": ["edit_key"]}
-                    st.rerun["edit"] == {"f": ["flags"]}
-                    
-            # Delete button
-            delete_key == f"key_{group['id']}_{i}"
-            with cols[5].container():
-                st.button("delete", key==delete_key):
-                    st.session_state["delete"].pop(idx),
-                    st.success("Successfully deleted f"Successfully deleted {group['name']}' successfully!")
-                    st.success(f"Equipment '{group}' deleted successfully!")
-                    st.session_state["delete_key"] == {"delete": ["delete_key"}
-                    st.rerun["delete"] == {"f": ["flags"]"}
-                ]
-
-def display_ventilation_infiltration_table(ventilation_groups: List[str, Any]):
-    """
-Display all ventilation/infiltration systems in a table."""
-    """
-    # Create table headers
-    headers == st.columns([1])
-    cols[0].text("Name")
-    cols[1].text("Type")
-    cols[2].text("Area")
-    st.columns[0].write("W/m²")
-    col[2].write("Rate")
-    st.columns[3].write("Zone")
-    cols[4].write("Edit")
-    cols[5].write("Action")
+    # Check if an action is pending
+    current_action = st.session_state.equipment_action
+    action_id = current_action.get("id", None)
+    
+    # Display each system
+    for idx, system in enumerate(equipment_systems):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+        cols[0].write(system["name"])
+        cols[1].write(f"{system.get('area', 0):.1f}")
+        cols[2].write(f"{system.get('total_sensible_power', 0):.1f}")
+        cols[3].write(f"{system.get('total_latent_power', 0):.1f}")
+        cols[4].write(system.get("zone", "Unknown"))
+        
+        # Edit button
+        edit_key = f"edit_equipment_{system['id']}_{idx}"
+        with cols[5].container():
+            if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.equipment_action = {"action": "edit", "id": new_action_id}
+                st.session_state.equipment_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "area": system.get("area", 100.0),
+                    "sensible_gain": system.get("sensible_gain", 10.0),
+                    "latent_gain": system.get("latent_gain", 2.0),
+                    "radiative_fraction": system.get("radiative_fraction", 0.5),
+                    "convective_fraction": system.get("convective_fraction", 0.5),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "zone": system.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.equipment_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        # Delete button
+        delete_key = f"delete_equipment_{system['id']}_{idx}"
+        with cols[6].container():
+            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.equipment_action = {"action": "delete", "id": new_action_id}
+                st.session_state.project_data["internal_loads"]["equipment"].pop(idx)
+                st.success(f"Equipment '{system['name']}' deleted!")
+                st.session_state.equipment_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
-    # # Display system data
-    for i, idx, system in enumerate(ventilation_groups):
-        cols == st.columns([1,1,1,1,1]):1]
-            cols[0].write("system["name"]            )
-            cols[1].system["system_type"].get("s", ""),
-            cols[0].write(f"system['area']:.getf")
-            st.columns[2].append(f"{system.get('ventilation_rate', 0)}:.2f") if system["system_type"] == "Ventilation" else f"f{system.get('air_change_rate', 0)}:.2f")
-            cols[3].write("system["zone"].get("z", "")),
-            
-            # Edit button
-            edit_key == f"edit_key_{system['id']}_{i}"
-            with(cols[4]).container():
-                st.button("edit", key==edit_key):
-                    st.session_state["edit_key"] == {
-                        "index": i,
-                        "name": system["name"].get("name", ""),
-                        "system_type": system["system"].get("system_type", "Ventilation"),
-                        "area": system["area"].get("area", 0),
-                        "ventilation_rate": system["ventilation"].get("ventilation_rate", 0),
-                        "air_change_rate": system["air"].get("air_change_rate", 0),
-                        "schedule": schedule.get("schedule", "Continuous"),
-                        "zone"): system["zone"].get("z", "Whole building"),
-                        "is_edit": True
-                    },
-                    st.session_state["edit"] == {"action": "edit"}
-                    st.rerun["edit"] == {"flags": ["flags"]}
-                
-            # Delete button
-            delete_key == f"key_{system['id']}_{i}"
-            with(cols[5]).container():
-                st.button("delete", key==delete_key):
-                    st.session_state["ventilation"].pop(idx),
-                    st.success("Successfully deleted f"{system.get('system', 'System')} '{system['name']}'!")
-                    st.success(f"{system.get('system_type', 'System')} '{system['name']}' deleted successfully!")
-                    st.session_state["delete"] == {"action": "delete"}
-                    st.rerun["delete"] == {"flags": ["flags"]}
-                ]
+def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]]):
+    """Display ventilation/infiltration systems in a table format with fixed edit/delete button logic."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**Type**")
+    cols[2].write("**Area (m²)**")
+    cols[3].write("**Rate**")
+    cols[4].write("**Zone**")
+    cols[5].write("**Edit**")
+    cols[6].write("**Delete**")
+    
+    # Check if an action is pending
+    current_action = st.session_state.vent_inf_action
+    action_id = current_action.get("id", None)
+    
+    # Display each system
+    for idx, system in enumerate(vent_inf_systems):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+        cols[0].write(system["name"])
+        cols[1].write(system.get("system_type", "Unknown"))
+        cols[2].write(f"{system.get('area', 0):.1f}")
+        rate_info = f"{system.get('ventilation_rate', 0):.2f} L/s·m²" if system.get("system_type") == "Ventilation" else f"{system.get('air_change_rate', 0):.2f} ACH"
+        cols[3].write(rate_info)
+        cols[4].write(system.get("zone", "Unknown"))
+        
+        # Edit button
+        edit_key = f"edit_vent_inf_{system['id']}_{idx}"
+        with cols[5].container():
+            if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.vent_inf_action = {"action": "edit", "id": new_action_id}
+                st.session_state.vent_inf_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "system_type": system.get("system_type", "Ventilation"),
+                    "area": system.get("area", 100.0),
+                    "ventilation_rate": system.get("ventilation_rate", 10.0),
+                    "air_change_rate": system.get("air_change_rate", 1.0),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "zone": system.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.vent_inf_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        # Delete button
+        delete_key = f"delete_vent_inf_{system['id']}_{idx}"
+        with cols[6].container():
+            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
+                new_action_id = str(uuid.uuid4())
+                st.session_state.vent_inf_action = {"action": "delete", "id": new_action_id}
+                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].pop(idx)
+                st.success(f"{system.get('system_type', 'System')} '{system['name']}' deleted!")
+                st.session_state.vent_inf_action = {"action": None, "id": None}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
-def display_schedules_table(schedules_data: Dict[str, Any]):
-    """
-Display schedules in a table format with edit/delete buttons."""
-    """
-    if not schedules_data:
-        return []
+def display_schedules_table(schedules: Dict[str, Any]):
+    """Display schedules in a table format with fixed edit/delete button logic."""
+    if not schedules:
+        return
     
     # Create table data
-    table == []
-    for name, schedule in schedules_data.items():
-        weekday == max(schedule["weekday"].get("weekday", [0])),
-        weekend == max(schedule["weekend"].get("weekend", [0])),
+    table_data = []
+    for name, schedule in schedules.items():
+        weekday_peak = max(schedule.get("weekday", [0]))
+        weekend_peak = max(schedule.get("weekend", [0]))
         
-        table.append({
+        table_data.append({
             "Name": name,
-            "Description": schedule["description"].get("description", "No description"),
-            "Weekday": f"{weekday:.2f}",
-            "Weekend": f"{weekend:.2f}",
+            "Description": schedule.get("description", "No description"),
+            "Weekday Peak": f"{weekday_peak:.2f}",
+            "Weekend Peak": f"{weekend_peak:.2f}",
             "Actions": name
         })
     
-    if table:
-        df == pd.DataFrame(table)
+    if table_data:
+        df = pd.DataFrame(table_data)
         
         # Display table
         st.dataframe(df.drop('Actions', axis=1), use_container_width=True)
         
+        # Check if an action is pending
+        current_action = st.session_state.schedule_action
+        action_id = current_action.get("id", None)
+        
         # Display action buttons
         st.write("**Actions:**")
-        for i, row in enumerate(table):
-            schedule_name == row["Actions"]
+        for i, row in enumerate(table_data):
+            schedule_name = row["Actions"]
             
-            col1, col2, col3, col4 == st.columns([2,1,1,1])
+            col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
             
             with col1:
                 st.write(f"{i+1}. {schedule_name}")
             
             with col2:
-                if st.button("View", key==f"view_{schedule_name}_{i}"):
-                    schedule_data == schedules_data[schedule_name]
+                view_key = f"view_schedule_{schedule_name}_{i}"
+                if st.button("View", key=view_key) and current_action["action"] != "view":
+                    new_action_id = str(uuid.uuid4())
+                    st.session_state.schedule_action = {"action": "view", "id": new_action_id}
+                    schedule_data = schedules[schedule_name]
                     display_schedule_chart(schedule_name, schedule_data)
+                    st.session_state.schedule_action = {"action": None, "id": None}
+                    st.session_state.module_rerun_flags["internal_loads"] = True
             
             with col3:
-                if st.button("Edit", key==f"edit_{schedule_name}_{i}"):
-                    schedule_data == schedules_data[schedule_name]
-                    st.session_state["schedule"]_editor == {
+                edit_key = f"edit_schedule_{schedule_name}_{i}"
+                if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
+                    new_action_id = str(uuid.uuid4())
+                    st.session_state.schedule_action = {"action": "edit", "id": new_action_id}
+                    schedule_data = schedules[schedule_name]
+                    st.session_state.schedule_editor = {
                         "is_edit": True,
                         "original_name": schedule_name,
                         "name": schedule_name,
-                        "description": schedule_data["description"].get("description", ""),
-                        "weekday": schedule_data["weekday"].get("weekday", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-                        "weekend": schedule_data["weekend"].get("weekend", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+                        "description": schedule_data.get("description", ""),
+                        "weekday": schedule_data.get("weekday", [0.0] * 24),
+                        "weekend": schedule_data.get("weekend", [0.0] * 24)
                     }
-                    st.session_state.module_rerun["flags"]["internal_loads"] == True
-                    st.rerun()
+                    st.session_state.schedule_action = {"action": None, "id": None}
+                    st.session_state.module_rerun_flags["internal_loads"] = True
             
             with col4:
-                if schedule_name not in DEFAULT_SCHEDULES_TEMPLATES:
+                if schedule_name not in DEFAULT_SCHEDULE_TEMPLATES:
                     if is_schedule_in_use(schedule_name):
                         st.write("(In Use)")
                     else:
-                        if st.button("Delete", key==f"delete_{schedule_name}_{i}"):
-                            del schedules_data[schedule_name]
-                            st.success("Successfully deleted f"Successfully deleted '{schedule_name}'!")
-                            st.success(f"Schedule '{schedule_name}' deleted successfully!")
-                            st.session_state.module_rerun["flags"]["internal_loads"] == True
-                            st.rerun()
+                        delete_key = f"delete_schedule_{schedule_name}_{i}"
+                        if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
+                            new_action_id = str(uuid.uuid4())
+                            st.session_state.schedule_action = {"action": "delete", "id": new_action_id}
+                            del schedules[schedule_name]
+                            st.success(f"Schedule '{schedule_name}' deleted!")
+                            st.session_state.schedule_action = {"action": None, "id": None}
+                            st.session_state.module_rerun_flags["internal_loads"] = True
                 else:
                     st.write("(Default)")