Update app/component_selection.py

app/component_selection.py

@@ -331,247 +331,222 @@ class ComponentSelectionInterface:
         self.shading_system = shading_system
         self.reference_data = reference_data
 
-    def display_component_selection(self, session_state: Any) -> None:
-        st.title("Building Components")
+    # ... other methods like display_component_selection, _display_component_tab, etc. ...
+
+    def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
+        type_name = component_type.value.lower()
+        preset_components = self.component_library.get_preset_components_by_type(component_type)
         
-        if 'components' not in session_state:
-            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
+        # Add a flag to prevent infinite rerun
+        if f"add_{type_name}_submitted" not in session_state:
+            session_state[f"add_{type_name}_submitted"] = False
         
-        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
+        with st.form(f"add_{type_name}_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", f"New {type_name.capitalize()}")
+                area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], index=0)
+                else:
+                    orientation = Orientation.HORIZONTAL.value
+            
+            with col2:
+                selection_method = st.radio(f"{type_name.capitalize()} Selection Method", ["Select from Presets", "Custom Properties"])
+                if selection_method == "Select from Presets" and preset_components:
+                    preset_options = {comp.name: comp.id for comp in preset_components}
+                    selected_preset = st.selectbox(f"Select Preset {type_name.capitalize()}", options=list(preset_options.keys()))
+                    component = self.component_library.get_component(preset_options[selected_preset])
+                    u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
+                    if component_type == ComponentType.WALL:
+                        st.text_input("Wall Type", value=component.wall_type, disabled=True)
+                        st.text_input("Wall Group", value=component.wall_group, disabled=True)
+                    elif component_type == ComponentType.ROOF:
+                        st.text_input("Roof Type", value=component.roof_type, disabled=True)
+                        st.text_input("Roof Group", value=component.roof_group, disabled=True)
+                    elif component_type == ComponentType.FLOOR:
+                        st.text_input("Floor Type", value=component.floor_type, disabled=True)
+                    elif component_type == ComponentType.WINDOW:
+                        st.number_input("SHGC", value=component.shgc, disabled=True)
+                        st.number_input("VT", value=component.vt, disabled=True)
+                        st.text_input("Window Type", value=component.window_type, disabled=True)
+                    elif component_type == ComponentType.DOOR:
+                        st.text_input("Door Type", value=component.door_type, disabled=True)
+                else:
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=0.5, step=0.01)
+                    if component_type == ComponentType.WALL:
+                        wall_type = st.text_input("Wall Type", "Custom")
+                        wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], index=1)
+                    elif component_type == ComponentType.ROOF:
+                        roof_type = st.text_input("Roof Type", "Custom")
+                        roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], index=2)
+                    elif component_type == ComponentType.FLOOR:
+                        floor_type = st.text_input("Floor Type", "Custom")
+                    elif component_type == ComponentType.WINDOW:
+                        shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
+                        vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
+                        window_type = st.text_input("Window Type", "Custom")
+                        glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=1)
+                        gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], index=0)
+                        low_e_coating = st.checkbox("Low-E Coating")
+                        shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
+                        shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
+                        coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, value=100.0, step=5.0)
+                        device = self.shading_system.get_device(shading_options[shading_device])
+                        device.coverage_percentage = coverage
+                        st.write(f"Effective SHGC: {self.shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                    elif component_type == ComponentType.DOOR:
+                        door_type = st.text_input("Door Type", "Custom")
+            
+            submitted = st.form_submit_button("Add Component")
+            if submitted and not session_state[f"add_{type_name}_submitted"]:
+                if not name:
+                    st.error(f"{type_name.capitalize()} name is required!")
+                elif area <= 0:
+                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
+                elif u_value <= 0:
+                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                else:
+                    try:
+                        if selection_method == "Select from Presets" and preset_components:
+                            component_id = preset_options[selected_preset]
+                            component = self.component_library.get_component(component_id)
+                            new_component = component.__class__(
+                                id=str(uuid.uuid4()), name=name, area=area, 
+                                orientation=Orientation(orientation), **component.__dict__
+                            )
+                            del new_component.__dict__["id"]
+                        else:
+                            if component_type == ComponentType.WALL:
+                                new_component = Wall(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation(orientation), wall_type=wall_type, wall_group=wall_group
+                                )
+                            elif component_type == ComponentType.ROOF:
+                                new_component = Roof(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation(orientation), roof_type=roof_type, roof_group=roof_group
+                                )
+                            elif component_type == ComponentType.FLOOR:
+                                new_component = Floor(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation(orientation), floor_type=floor_type
+                                )
+                            elif component_type == ComponentType.WINDOW:
+                                new_component = Window(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation(orientation), shgc=shgc, vt=vt, window_type=window_type,
+                                    glazing_layers=glazing_layers, gas_fill=gas_fill, low_e_coating=low_e_coating,
+                                    shading_device_id=shading_options[shading_device]
+                                )
+                            elif component_type == ComponentType.DOOR:
+                                new_component = Door(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation(orientation), door_type=door_type
+                                )
+                        self.component_library.add_component(new_component)
+                        session_state.components[type_name + 's'].append(new_component)
+                        st.success(f"Added {new_component.name}")
+                        session_state[f"add_{type_name}_submitted"] = True  # Set flag to prevent rerun loop
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
         
-        with tabs[0]:
-            self._display_component_tab(session_state, ComponentType.WALL)
-        with tabs[1]:
-            self._display_component_tab(session_state, ComponentType.ROOF)
-        with tabs[2]:
-            self._display_component_tab(session_state, ComponentType.FLOOR)
-        with tabs[3]:
-            self._display_component_tab(session_state, ComponentType.WINDOW)
-        with tabs[4]:
-            self._display_component_tab(session_state, ComponentType.DOOR)
-        with tabs[5]:
-            self._display_u_value_calculator_tab(session_state)
+        # Reset the flag after rerun to allow new submissions
+        if session_state[f"add_{type_name}_submitted"]:
+            session_state[f"add_{type_name}_submitted"] = False
+
+    # ... other methods ...
+
+    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
+        st.subheader("U-Value Calculator")
         
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Save Components"):
-                self._save_components(session_state)
-        with col2:
-            uploaded_file = st.file_uploader("Load Components", type=["json"])
-            if uploaded_file and st.button("Load Uploaded Components"):
-                self._load_components(session_state, uploaded_file)
-
-    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
-        type_name = component_type.value.lower()
-        st.subheader(f"{type_name.capitalize()} Components")
+        if "material_layers" not in session_state:
+            session_state.material_layers = []
         
-        with st.expander(f"Add {type_name.capitalize()}", expanded=False):
-            self._display_add_component_form(session_state, component_type)
+        if "u_value_applied" not in session_state:
+            session_state.u_value_applied = False
         
-        components = session_state.components.get(type_name + 's', [])
-        if components:
-            st.subheader(f"Existing {type_name.capitalize()} Components")
-            self._display_components_table(session_state, component_type, components)
-        else:
-            st.info(f"No {type_name} components defined yet.")
-
-     def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
-    type_name = component_type.value.lower()
-    preset_components = self.component_library.get_preset_components_by_type(component_type)
-    
-    # Add a flag to prevent infinite rerun
-    if f"add_{type_name}_submitted" not in session_state:
-        session_state[f"add_{type_name}_submitted"] = False
-    
-    with st.form(f"add_{type_name}_form"):
-        col1, col2 = st.columns(2)
-        with col1:
-            name = st.text_input("Name", f"New {type_name.capitalize()}")
-            area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
-            if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
-                orientation = st.selectbox("Orientation", [o.value for o in Orientation], index=0)
-            else:
-                orientation = Orientation.HORIZONTAL.value
+        components = []
+        for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
+            components.extend(session_state.components[type_name])
         
-        with col2:
-            selection_method = st.radio(f"{type_name.capitalize()} Selection Method", ["Select from Presets", "Custom Properties"])
-            if selection_method == "Select from Presets" and preset_components:
-                preset_options = {comp.name: comp.id for comp in preset_components}
-                selected_preset = st.selectbox(f"Select Preset {type_name.capitalize()}", options=list(preset_options.keys()))
-                component = self.component_library.get_component(preset_options[selected_preset])
-                u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
-                # ... preset display logic ...
-            else:
-                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=0.5, step=0.01)
-                if component_type == ComponentType.WALL:
-                    wall_type = st.text_input("Wall Type", "Custom")
-                    wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], index=1)
-                elif component_type == ComponentType.ROOF:
-                    roof_type = st.text_input("Roof Type", "Custom")
-                    roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], index=2)
-                elif component_type == ComponentType.FLOOR:
-                    floor_type = st.text_input("Floor Type", "Custom")
-                elif component_type == ComponentType.WINDOW:
-                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
-                    vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
-                    window_type = st.text_input("Window Type", "Custom")
-                    glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=1)
-                    gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], index=0)
-                    low_e_coating = st.checkbox("Low-E Coating")
-                    shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
-                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
-                    coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, value=100.0, step=5.0)
-                    device = self.shading_system.get_device(shading_options[shading_device])
-                    device.coverage_percentage = coverage
-                    st.write(f"Effective SHGC: {self.shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
-                elif component_type == ComponentType.DOOR:
-                    door_type = st.text_input("Door Type", "Custom")
+        if not components:
+            st.warning("No components available. Add components first.")
+            return
         
-        submitted = st.form_submit_button("Add Component")
-        if submitted and not session_state[f"add_{type_name}_submitted"]:
-            if not name:
-                st.error(f"{type_name.capitalize()} name is required!")
-            elif area <= 0:
-                st.error(f"{type_name.capitalize()} area must be greater than zero!")
-            elif u_value <= 0:
-                st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
-            else:
-                try:
-                    if selection_method == "Select from Presets" and preset_components:
-                        component_id = preset_options[selected_preset]
-                        component = self.component_library.get_component(component_id)
-                        new_component = component.__class__(
-                            id=str(uuid.uuid4()), name=name, area=area, 
-                            orientation=Orientation(orientation), **component.__dict__
-                        )
-                        del new_component.__dict__["id"]
-                    else:
-                        if component_type == ComponentType.WALL:
-                            new_component = Wall(
-                                id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                orientation=Orientation(orientation), wall_type=wall_type, wall_group=wall_group
-                            )
-                        elif component_type == ComponentType.ROOF:
-                            new_component = Roof(
-                                id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                orientation=Orientation(orientation), roof_type=roof_type, roof_group=roof_group
-                            )
-                        elif component_type == ComponentType.FLOOR:
-                            new_component = Floor(
-                                id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                orientation=Orientation(orientation), floor_type=floor_type
-                            )
-                        elif component_type == ComponentType.WINDOW:
-                            new_component = Window(
-                                id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                orientation=Orientation(orientation), shgc=shgc, vt=vt, window_type=window_type,
-                                glazing_layers=glazing_layers, gas_fill=gas_fill, low_e_coating=low_e_coating,
-                                shading_device_id=shading_options[shading_device]
-                            )
-                        elif component_type == ComponentType.DOOR:
-                            new_component = Door(
-                                id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                orientation=Orientation(orientation), door_type=door_type
-                            )
-                    self.component_library.add_component(new_component)
-                    session_state.components[type_name + 's'].append(new_component)
-                    st.success(f"Added {new_component.name}")
-                    session_state[f"add_{type_name}_submitted"] = True  # Set flag to prevent rerun loop
-                    st.rerun()
-                except ValueError as e:
-                    st.error(f"Error: {str(e)}")
-    
-    # Reset the flag after rerun to allow new submissions
-    if session_state[f"add_{type_name}_submitted"]:
-        session_state[f"add_{type_name}_submitted"] = False
-
-def _display_u_value_calculator_tab(self, session_state: Any) -> None:
-    st.subheader("U-Value Calculator")
-    
-    if "material_layers" not in session_state:
-        session_state.material_layers = []
-    
-    if "u_value_applied" not in session_state:
-        session_state.u_value_applied = False
-    
-    components = []
-    for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
-        components.extend(session_state.components[type_name])
-    
-    if not components:
-        st.warning("No components available. Add components first.")
-        return
-    
-    selected_component = st.selectbox("Select Component", options=[c.name for c in components])
-    component = next((c for c in components if c.name == selected_component), None)
-    if not component:
-        st.error("Component not found.")
-        return
-    
-    if session_state.material_layers:
-        st.write("Current Material Layers (outside to inside):")
-        layer_data = [{"Layer": i+1, "Material": l["name"], "Thickness (mm)": l["thickness"], 
-                      "Conductivity (W/m·K)": l["conductivity"], "R-Value (m²·K/W)": l["thickness"] / 1000 / l["conductivity"]} 
-                      for i, l in enumerate(session_state.material_layers)]
-        st.dataframe(pd.DataFrame(layer_data), use_container_width=True)
+        selected_component = st.selectbox("Select Component", options=[c.name for c in components])
+        component = next((c for c in components if c.name == selected_component), None)
+        if not component:
+            st.error("Component not found.")
+            return
         
-        u_value = self.u_value_calculator.calculate_u_value(session_state.material_layers)
+        if session_state.material_layers:
+            st.write("Current Material Layers (outside to inside):")
+            layer_data = [{"Layer": i+1, "Material": l["name"], "Thickness (mm)": l["thickness"], 
+                          "Conductivity (W/m·K)": l["conductivity"], "R-Value (m²·K/W)": l["thickness"] / 1000 / l["conductivity"]} 
+                          for i, l in enumerate(session_state.material_layers)]
+            st.dataframe(pd.DataFrame(layer_data), use_container_width=True)
+            
+            u_value = self.u_value_calculator.calculate_u_value(session_state.material_layers)
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total R-Value", f"{1/u_value if u_value > 0 else 0:.3f} m²·K/W")
+            with col2:
+                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
+            with col3:
+                if st.button("Use This U-Value") and not session_state.u_value_applied:
+                    component.u_value = u_value
+                    self.component_library.update_component(component.id, component)
+                    session_state.material_layers = []
+                    st.success(f"U-Value set to {u_value:.3f} W/m²·K for {component.name}")
+                    session_state.u_value_applied = True  # Set flag to prevent rerun loop
+                    st.rerun()
         
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.metric("Total R-Value", f"{1/u_value if u_value > 0 else 0:.3f} m²·K/W")
-        with col2:
-            st.metric("U-Value", f"{u_value:.3f} W/m²·K")
-        with col3:
-            if st.button("Use This U-Value") and not session_state.u_value_applied:
-                component.u_value = u_value
-                self.component_library.update_component(component.id, component)
-                session_state.material_layers = []
-                st.success(f"U-Value set to {u_value:.3f} W/m²·K for {component.name}")
-                session_state.u_value_applied = True  # Set flag to prevent rerun loop
-                st.rerun()
-    
-    # Reset the flag after rerun to allow new calculations
-    if session_state.u_value_applied:
-        session_state.u_value_applied = False
-    
-    with st.form("material_layer_form"):
-        col1, col2 = st.columns(2)
-        with col1:
-            material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
-            if material_selection == "Select from Presets":
-                preset_materials = self.u_value_calculator.get_preset_materials()
-                material_options = {m["name"]: m for m in preset_materials}
-                material_name = st.selectbox("Material", options=list(material_options.keys()))
-                conductivity = material_options[material_name]["conductivity"]
-                st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
-            else:
-                material_name = st.text_input("Material Name", "Custom Material")
-                conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
+        # Reset the flag after rerun to allow new calculations
+        if session_state.u_value_applied:
+            session_state.u_value_applied = False
         
-        with col2:
-            thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
-            if conductivity > 0:
-                r_value = thickness / 1000 / conductivity
-                st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
+        with st.form("material_layer_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
+                if material_selection == "Select from Presets":
+                    preset_materials = self.u_value_calculator.get_preset_materials()
+                    material_options = {m["name"]: m for m in preset_materials}
+                    material_name = st.selectbox("Material", options=list(material_options.keys()))
+                    conductivity = material_options[material_name]["conductivity"]
+                    st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
+                else:
+                    material_name = st.text_input("Material Name", "Custom Material")
+                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
+            
+            with col2:
+                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
+                if conductivity > 0:
+                    r_value = thickness / 1000 / conductivity
+                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
+            
+            submitted = st.form_submit_button("Add Layer")
+            if submitted:
+                if not material_name:
+                    st.error("Material name is required!")
+                elif thickness <= 0:
+                    st.error("Thickness must be greater than zero!")
+                elif conductivity <= 0:
+                    st.error("Conductivity must be greater than zero!")
+                else:
+                    session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
+                    st.success(f"Added layer: {material_name}")
+                    st.rerun()
         
-        submitted = st.form_submit_button("Add Layer")
-        if submitted:
-            if not material_name:
-                st.error("Material name is required!")
-            elif thickness <= 0:
-                st.error("Thickness must be greater than zero!")
-            elif conductivity <= 0:
-                st.error("Conductivity must be greater than zero!")
-            else:
-                session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
-                st.success(f"Added layer: {material_name}")
+        if st.button("Remove Last Layer"):
+            if session_state.material_layers:
+                session_state.material_layers.pop()
                 st.rerun()
-    
-    if st.button("Remove Last Layer"):
-        if session_state.material_layers:
-            session_state.material_layers.pop()
-            st.rerun()
+
+    # ... other methods like _display_components_table, _save_components, etc. ...
             
         with st.form("material_layer_form"):
             col1, col2 = st.columns(2)