bindmc 0.1.0__py3-none-any.whl

bindmc/webgui/components/binding_model.py

@@ -0,0 +1,330 @@
+from .base import BaseComponent
+from nicegui import ui,binding
+from ..utils import (
+    get_components_from_species,
+)
+from ..state.statemanager import StateManager
+
+
+class BindingModelPanel(BaseComponent):
+    def __init__(self, state_manager: StateManager, mode="sim"):
+        self.mode = mode
+        super().__init__(state_manager)
+        self.generate_eq_const_rows()
+
+    def setup_bindings(self):
+        """Set up data bindings and listeners."""
+
+        self.sm.add_listener("model_changed", self.generate_eq_const_rows)
+        self.sm.add_listener("model_changed", self.generate_models_dropdown)
+        self.sm.add_listener("model_changed", self.refresh_ui_bindings)
+        
+
+    def refresh_ui_bindings(self,e=None):
+        """Refresh UI bindings after model changes."""
+        # Check if UI elements exist before trying to bind them
+        if not hasattr(self, 'model_name_inp') or self.model_name_inp is None:
+            return
+            
+        binding.remove([self.model_name_inp,
+                        self.eqn_inp,
+                        self.model_dropdown_button,
+                        self.modeleq_mat,
+                        self.modelComp,
+                        self.modelSpec
+                        ])
+
+        self.model_name_inp.bind_text_from(self.sm.active_model, "name")
+        self.eqn_inp.bind_value(self.sm.active_model, "eq_str")
+        self.model_dropdown_button.bind_text_from(self.sm.active_model,"name")
+        if len(self.sm.models) > 1 or len(self.sm.active_model.eq_mat_str) > 1:
+            self.modelData.set_visibility(True)
+            self.modeleq_mat.bind_value_from(self.sm.active_model, "eq_mat_str")
+            self.modelComp.bind_value_from(self.sm.active_model, "component_names")
+            self.modelSpec.bind_value_from(self.sm.active_model, "species")
+        else:
+            self.modelData.set_visibility(False)
+
+        # if self.sm.active_model_id not in self.sm.default_model_ids:
+        #     self.edit_name_btn.props("flat").classes("ml-2").tooltip("Rename model").on('click', self.show_rename_dialog)
+        # else:
+        #     self.edit_name_btn.props("flat").classes("ml-2").tooltip("Cannot rename default model")
+
+
+    def show_model_data(self, e):
+        """Show the model data output area when a model is parsed."""
+        self.modelData.set_visibility(True)  # Show the model data output area
+
+    def setup_nicegui(self):
+        mode = self.mode
+        self.container = ui.column().classes("w-full")
+
+        with self.container:
+            with ui.row().classes("w-full"):
+                self.model_dropdown_button = (
+                    ui.dropdown_button("Choose model", auto_close=True)
+                    .bind_text_from(self.sm.active_model, "name")
+                    .classes("mb-5")
+                )
+                self.generate_models_dropdown()
+                ui.button("Add New Model", on_click=lambda e: self.add_new_model()).classes("mb-5")
+
+        with ui.row().classes("w-full mb-4"):
+            with ui.row().classes("w-full items-center"):
+                ui.label("Model Name:").style("font-weight: bold")
+
+                self.model_name_inp = (
+                    ui.label("Model Name")
+                    .bind_text_from(self.sm.active_model, "name")
+                    .tooltip(
+                        "This name will appear in the legends of any figures. Make it descriptive but short! You might mention key details about the model."
+                    )
+                )
+                # if self.sm.active_model_id not in self.sm.default_model_ids:
+                #     self.edit_name_btn = ui.button(icon="edit", on_click=self.show_rename_dialog).props("flat").classes("ml-2").tooltip("Rename model")
+                # else:
+                #     self.edit_name_btn = ui.button(icon="edit_off").props("flat").classes("ml-2").tooltip("Cannot rename default model")
+                
+        self.eqn_inp = (
+            ui.textarea("Equilibrium Equations", placeholder="H+G<=>HG")
+            .bind_value(self.sm.active_model, "eq_str")
+            .classes("w-full mb-4")
+            .tooltip(
+                "Use the format H+G=HG. Separate equations with semicolons or new lines."
+            )
+            .props("clearable rows=2 autogrow")
+            .mark("eq-input")
+        )
+
+        ui.button("Parse Equations", on_click=self.sm.parse_equations).classes("mb-4")
+
+        self.eqConstRows = ui.row().classes('w-full')
+        with self.eqConstRows:
+            ui.label("Equilibrium Constants:")
+            self.logKchk = (
+                ui.checkbox("Use log scale for constants", value=True)
+                .classes("mb-2")
+                .mark("log-scale-checkbox")
+            )  # Checkbox to toggle log scale
+            self.logKchk.set_enabled(False)
+            if len(self.sm.active_model.binding_constants) > 0:
+                self.generate_eq_const_rows(
+                    mode
+                )  # Generate equilibrium constants input rows if binding constants exist
+            else:
+                self.eqConstRows.set_visibility(
+                    False
+                )  # Placeholder for equilibrium constants input
+
+        self.modelData = ui.element("div").mark(
+            "model-setup-output"
+        )  # Placeholder for model setup output
+        self.advDetails = ui.expansion("Advanced model details")
+        # if the model already exists, show the constants/etc block
+        if len(self.sm.models) > 1 or len(self.sm.active_model.eq_mat_str) > 1:
+            self.modelData.set_visibility(True)  # Initially hidden
+        else:
+            self.modelData.set_visibility(False)  # Initially hidden
+
+        with self.modelData:
+            with self.advDetails:
+                self.modeleq_mat = (
+                    ui.textarea("Equation matrix")
+                    .props("rows=1 autogrow")
+                    .classes("w-full mb-4")
+                    .bind_value(self.sm.active_model, "eq_mat_str")
+                    .mark("eq-matrix-output")
+                )
+                self.modelComp = (
+                    ui.input("Components", value="")
+                    .classes("w-full mb-4")
+                    .mark("components-output")
+                    .bind_value(self.sm.active_model, "component_names")
+                )
+                self.modelSpec = (
+                    ui.input("Species", value="")
+                    .classes("w-full mb-4")
+                    .mark("species-output")
+                    .bind_value(self.sm.active_model, "species")
+                )
+
+                self.modeleq_mat.ignores_events_when_disabled = False
+                self.modeleq_mat.disable() 
+                self.modelComp.ignores_events_when_disabled = False
+                self.modelComp.disable()
+                self.modelSpec.ignores_events_when_disabled = False
+                self.modelSpec.disable()
+
+    def generate_models_dropdown(self, e=None):
+        """Generate the dropdown for model selection."""
+        self.model_dropdown_button.clear()
+        with self.model_dropdown_button:
+            self.model_dropdown_rows = []
+            for i,m in enumerate(self.sm.models.values()):
+                with ui.row().classes("p-1 items-center justify-between w-full no-wrap") as x:
+                    self.model_dropdown_rows.append(x)
+                    with ui.item(on_click=lambda m=m: self.load_model(m)).classes("flex-grow min-w-0 flex items-center"):
+                        ui.item_label().bind_text(
+                            m, "name"
+                        ).classes("leading-none")
+
+                    if m.id not in self.sm.default_model_ids: # default model IDs
+                        ui.icon("delete").on(
+                            "click", lambda m=m: self.delete_model(m)
+                        ).classes("cursor-pointer text-red-600 flex-shrink-0 self-center").tooltip("Delete model")
+                        ui.icon("edit").on("click", lambda m=m: self.show_rename_dialog(m)).classes("cursor-pointer flex-shrink-0 self-center").tooltip("Rename model")
+                    else:
+                        ui.icon("lock").classes("text-gray-600 flex-shrink-0 self-center").tooltip("Built-in model")     
+                        ui.icon("edit_off").classes("text-gray-600 flex-shrink-0 self-center").tooltip("Cannot rename default model")                  
+
+    #   if self.sm.active_model_id not in self.sm.default_model_ids:
+    #                 self.edit_name_btn = ui.button(icon="edit", on_click=self.show_rename_dialog).props("flat").classes("ml-2").tooltip("Rename model")
+    #             else:
+    #                 self.edit_name_btn = ui.button(icon="edit_off").props("flat").classes("ml-2").tooltip("Cannot rename default model")
+    def delete_model(self, m):
+        self.sm.delete_model(m)
+
+    async def add_new_model(self):
+        async def show_name_dialog():
+            with ui.dialog() as dialog, ui.card():
+                ui.label('Enter name for new model:')
+                name_input = ui.input('Model name', placeholder='Enter model name')
+                with ui.row():
+                    ui.button('Cancel', on_click=dialog.close)
+                    ui.button('Create', on_click=lambda: create_model_with_name(name_input.value))
+            
+            def create_model_with_name(name):
+                def add_model():
+                    self.sm.new_model(name.strip())
+                    self.modelData.set_visibility(False)  # Hide the model data output area
+                    self.eqConstRows.set_visibility(False)
+                    self.sm.notify_listeners("model_changed")  # Notify listeners to update the UI
+                    dialog.close()
+                if name.strip():
+                    if name.strip() in [m.name for m in self.sm.models.values()]:
+                        with ui.dialog() as confirm_dialog, ui.card():
+                            ui.label(f'A model named "{name.strip()}" already exists.')
+                            ui.label('Would you like to overwrite it or choose a different name?')
+                            with ui.row():
+                                ui.button('Choose Different Name', on_click=lambda: (confirm_dialog.close(), show_name_dialog()))
+                                ui.button('Overwrite', on_click=lambda: add_model())
+                        confirm_dialog.open()
+                        return
+                    else:
+                        add_model()
+                
+            dialog.open()
+
+        await show_name_dialog()
+
+    async def show_rename_dialog(self,m):
+        async def show_name_dialog():
+            with ui.dialog() as dialog, ui.card():
+                ui.label('Enter new name for model:')
+                name_input = ui.input('Model name', placeholder='Enter model name', value=m.name)
+                with ui.row():
+                    ui.button('Cancel', on_click=dialog.close)
+                    ui.button('Rename', on_click=lambda: rename_model_to(name_input.value))
+            
+            def rename_model_to(name):
+                if name.strip() and name.strip() != m.name:
+                    if name.strip() in [m.name for m in self.sm.models.values()]:
+                        with ui.dialog() as confirm_dialog, ui.card():
+                            ui.label(f'A model named "{name.strip()}" already exists.')
+                            ui.label('Please choose a different name.')
+                            with ui.row():
+                                ui.button('OK', on_click=confirm_dialog.close)
+                        confirm_dialog.open()
+                        return
+                    m.name = name.strip()
+                    self.sm.notify_listeners("model_changed")  # Notify listeners to update the UI
+                dialog.close()
+                
+            dialog.open()
+
+        await show_name_dialog()
+
+
+    def load_model(self, m):
+        """Load an existing model and update the UI accordingly."""
+        self.sm.active_model_id = m.id
+        self.sm.notify_listeners("model_changed")
+
+    def generate_eq_const_rows(self, mode="sim"):
+        """Generate the equilibrium constants input rows."""
+        # Re-generate equilibrium constants rows
+        if len(self.sm.active_model.binding_constants) < 1:
+            if len(self.sm.active_model.species)>0:
+                # If no binding constants exist, create a new one
+                self.sm.generate_binding_constants()
+            else:
+                self.eqConstRows.set_visibility(False)
+                return
+      
+
+        self.eqConstRows.set_visibility(
+            True
+        )  # Show the equilibrium constants input area
+
+        if self.logKchk.value is True:
+            logtxt = r"\\log"
+        else:
+            logtxt = ""
+        # populate binding constant definition section
+        with self.eqConstRows as block:
+
+            block.clear()  # Clear previous content                
+            # now set up binding constant blocks either with existing bound content or with the newly-instantiated
+            # BindingConstant objects
+            for i, b in enumerate(self.sm.active_model.binding_constants):
+                # if species is has no existing BC, add one
+                if b.isComp:
+                    continue
+
+                bspecies = b.species
+                comps = get_components_from_species(bspecies)
+                # i_in_full_list = self.sm.active_model.species.index(bspecies)
+
+                # comps will have format [A,B,B] for A + 2B
+                # so convert to a string like 'A + 2B'
+                with ui.card().classes("mb-2 w-72").mark(f"eq-const-row-{i+1}"):
+                    with ui.row(align_items='center').classes('w-full justify-center'):
+                        ui.label(
+                            "{} ⇋ {}".format(
+                                " + ".join(
+                                    [
+                                        f"{comps.count(c) if comps.count(c) > 1 else ''}{c}"
+                                        for c in list(dict.fromkeys(comps)) #not using set() to preserve order
+                                    ]
+                                ),
+                                bspecies,
+                            )
+                        ).props("inline").style("font-weight: bold; font-size: larger")
+                    with ui.row().classes("items-center"):
+                        ui.markdown(
+                            r"$$" + logtxt + "{K_{" + bspecies + "}} =$$", extras=["latex"]
+                        ).classes("mb-2 text-center").props("inline")
+                        ui.number('logK',placeholder="Enter binding constant").classes(
+                            "mb-2 w-20"
+                        ).mark(f"logK-{bspecies}-val").bind_value(
+                            self.sm.active_model.binding_constants[i], "logK"
+                        ).props(
+                            "inline"
+                        ).on_value_change(lambda e="k_changed": self.sm.notify_listeners(e))
+                        ui.label("(log-units)")
+                    if self.mode == "fit":
+                        with ui.row().classes("items-center"):
+                            ui.checkbox("Vary", value=True).bind_value(
+                                self.sm.active_model.binding_constants[i], "vary"
+                            )
+                            min_input = ui.number(
+                                "min", placeholder="Minimum value", value=2
+                            ).bind_value(self.sm.active_model.binding_constants[i], "min").classes("w-15")
+                            max_input = ui.number(
+                                "max", placeholder="Maxmimum value", value=20
+                            ).bind_value(self.sm.active_model.binding_constants[i], "max").classes("w-15")
+                            
+                            # Bind enabled state to the vary checkbox
+                            min_input.bind_enabled_from(self.sm.active_model.binding_constants[i], "vary")
+                            max_input.bind_enabled_from(self.sm.active_model.binding_constants[i], "vary")
+    

bindmc/webgui/components/body.py

@@ -0,0 +1,276 @@
+from .base import BaseComponent
+from nicegui import ui
+import numpy as np
+import pandas as pd
+from . import (
+    BayesPanel,
+    BindingModelPanel,
+    BindToolsHeader,
+    DataGenerationPanel,
+    DataImportPanel,
+    DataModelPanel,
+    FittingPanel,
+    SimulationPanel,
+)
+from typing import Any
+
+TabKey = tuple[str, ...]
+
+
+def _append_reason(reason_map: dict[TabKey, list[str]], tab_key: TabKey, reason: str) -> None:
+    if tab_key not in reason_map:
+        reason_map[tab_key] = []
+    if reason not in reason_map[tab_key]:
+        reason_map[tab_key].append(reason)
+
+
+def _compute_tab_disable_reasons(sm) -> dict[TabKey, list[str]]:
+    """Return deterministic disable reasons for each tab key."""
+    reasons: dict[TabKey, list[str]] = {}
+
+    active_model = getattr(sm, "active_model", None)
+    model_is_valid = True
+    if active_model is None:
+        model_is_valid = False
+    else:
+        eq_str = getattr(active_model, "eq_str", None)
+        binding_constants = getattr(active_model, "binding_constants", []) or []
+        missing_logk = any(getattr(k, "logK", None) is None for k in binding_constants)
+        model_is_valid = bool(eq_str is not None and str(eq_str).strip()) and not missing_logk
+
+    if not model_is_valid:
+        msg = "Model is incomplete. Define/parse equations and set all binding constants."
+        _append_reason(reasons, ("Simulate", "Data Generation"), msg)
+        _append_reason(reasons, ("Simulate", "Simulation"), msg)
+        _append_reason(reasons, ("Fit", "Data model"), msg)
+        _append_reason(reasons, ("Fit", "MCMC"), msg)
+
+    comp_concs = getattr(active_model, "component_concs", None) if active_model is not None else None
+    has_comp_concs = isinstance(comp_concs, pd.DataFrame) and not comp_concs.empty
+    if not has_comp_concs:
+        _append_reason(
+            reasons,
+            ("Simulate", "Simulation"),
+            "Generate component concentrations first (Simulate > Data Generation).",
+        )
+
+    active_expt = getattr(sm, "active_expt_data_or_none", None)
+    has_expt_data = (
+        active_expt is not None
+        and getattr(active_expt, "data", None) is not None
+        and not active_expt.data.empty
+    )
+    if not has_expt_data:
+        msg = "Import/select experimental data first (Fit > Import data)."
+        _append_reason(reasons, ("Fit", "Fit results"), msg)
+        _append_reason(reasons, ("Fit", "Data model"), msg)
+        _append_reason(reasons, ("Fit", "MCMC"), msg)
+
+    has_raw_for_expt = False
+    if has_expt_data:
+        raw_obj = getattr(active_expt, "raw_data", None)
+        raw_df = getattr(raw_obj, "data", None) if raw_obj is not None else None
+        has_raw_for_expt = raw_df is not None and not raw_df.empty
+    if not has_raw_for_expt:
+        _append_reason(
+            reasons,
+            ("Fit", "Data model"),
+            "Active dataset has no raw data backing it.",
+        )
+
+    if has_expt_data:
+        integ_to_spec = getattr(active_expt, "integ_to_spec", None)
+        limiting_shifts = getattr(active_expt, "limiting_shifts", None)
+        is_analytical_fast_ex = bool(getattr(active_expt, "is_analytical_fast_ex", False))
+        has_linear_obs = False
+        has_linear_obs_fn = getattr(active_expt, "has_linear_obs", None)
+        if callable(has_linear_obs_fn):
+            expt_dtypes = getattr(sm, "_expt_dtypes", {})
+            has_linear_obs = bool(has_linear_obs_fn(expt_dtypes))
+        has_integ_mapping = isinstance(integ_to_spec, np.ndarray) and integ_to_spec.size > 0
+        has_shift_mapping = isinstance(limiting_shifts, dict) and len(limiting_shifts) > 0
+        has_data_model = has_integ_mapping or has_shift_mapping or is_analytical_fast_ex or has_linear_obs
+        if not has_data_model:
+            msg = "Configure a data model first (Fit > Data model)."
+            _append_reason(reasons, ("Fit", "Fit results"), msg)
+            _append_reason(reasons, ("Fit", "MCMC"), msg)
+
+    if getattr(sm, "active_fit_id", None) is None:
+        _append_reason(reasons, ("Fit", "MCMC"), "Run a fit first (Fit > Results).")
+
+    return reasons
+
+
+def _format_disable_tooltip(reasons: list[str]) -> str:
+    if not reasons:
+        return ""
+    if len(reasons) == 1:
+        return reasons[0]
+    return "\n\n".join([f"- {reason}" for reason in reasons])
+
+
+class Body(BaseComponent):
+    
+    def setup_nicegui(self):
+        self.tabs = {}
+        self.components = {}
+        self._tab_tooltip_elements: dict[TabKey, Any] = {}
+        self._tab_help_cues: dict[TabKey, Any] = {}
+        self._generate_body()
+        self.enable_disable_tabs()
+
+    def setup_bindings(self):
+        super().setup_bindings()
+    
+        self.sm.add_listener("data_imported", self.enable_disable_tabs)
+        self.sm.add_listener("model_changed", self.enable_disable_tabs)
+        self.sm.add_listener("model_parsed", self.enable_disable_tabs)
+        self.sm.add_listener("comp_concs_updated", self.enable_disable_tabs)
+        self.sm.add_listener("k_changed", self.enable_disable_tabs)
+        self.sm.add_listener("data_model_processed", self.enable_disable_tabs)
+        self.sm.add_listener("fit_completed", self.enable_disable_tabs)
+        self.sm.add_listener("active_context_changed", self.enable_disable_tabs)
+
+    def _generate_body(self):
+        """Generate the body of the application."""
+        with ui.row().classes("w-full flex-grow p-4"):
+            with ui.tabs().classes("w-full").on(
+                "update:model-value", self.sm.save_to_storage
+            ) as tabs_main:
+                self.tabs[('Simulate',)]=ui.tab("Simulate", icon="insights")
+                self.tabs[('Fit',)]=ui.tab("Fit", icon="model_training")
+
+            with ui.tab_panels(tabs_main).classes("w-full"):
+                with ui.tab_panel("Simulate"):
+                    with ui.tabs().classes("w-full").on(
+                        "update:model-value", self.sim_tab_changed) as sim_tabs:
+                        # self.tabs[('Simulate','Model Setup')]=ui.tab("Model Setup", icon="science")
+                        self.tabs[('Simulate','Binding model setup')]=ui.tab(
+                            "Binding model setup", label="Define model", icon="settings"
+                        )
+                        self.tabs[('Simulate','Data Generation')]=ui.tab("Data Generation", icon="add")
+                        self.tabs[('Simulate','Simulation')]=ui.tab("Simulation", icon="insights")
+
+                    with ui.tab_panels(sim_tabs).classes("w-full"):
+                        with ui.tab_panel("Binding model setup"):
+                            self.components["model_setup"] = BindingModelPanel(
+                                self.sm, mode="sim"
+                            )
+
+                        with ui.tab_panel("Data Generation"):
+                            self.components["data_generation"] = DataGenerationPanel(
+                                self.sm
+                            )
+
+                        with ui.tab_panel("Simulation"):
+                            self.components["simulation"] = SimulationPanel(
+                                self.sm
+                            )
+
+                with ui.tab_panel("Fit"):
+                    with ui.tabs().classes("w-full").on(
+                        "update:model-value", self.fit_tab_changed
+                    ) as fit_tabs:
+                        self.tabs[('Fit','Binding model setup')]=ui.tab(
+                            "Binding model setup", label="Define model", icon="settings"
+                        )
+                        self.tabs[('Fit','Data import')]=ui.tab("Data import", label="Import data", icon="file_upload")
+                        self.tabs[('Fit','Data model')]=ui.tab(
+                            "Data model setup", label="Data model", icon="data_usage"
+                        )
+                        self.tabs[('Fit','Fit results')]=ui.tab("Fit results", label="Results", icon="check_circle")
+                        self.tabs[('Fit','MCMC')]=ui.tab("MCMC", label="MCMC analysis", icon="calculate")
+
+                    with ui.tab_panels(fit_tabs).classes("w-full"):
+                        with ui.tab_panel("Binding model setup"):
+                            self.components["fit_binding_model"] = BindingModelPanel(
+                                self.sm, mode="fit"
+                            )
+
+                        with ui.tab_panel("Data import"):
+                            self.components["data_import"] = DataImportPanel(
+                                self.sm
+                            )
+
+                        with ui.tab_panel("Data model setup"):
+                            self.components["data_model"] = DataModelPanel(
+                                self.sm
+                            )
+
+                        with ui.tab_panel("Fit results"):
+                            self.components["fit_results"] = FittingPanel(
+                                self.sm
+                            )
+
+                        with ui.tab_panel("MCMC"):
+                            self.components["mcmc"] = BayesPanel(
+                                self.sm
+                            )
+
+    def sim_tab_changed(self, e):
+        if e.args == 'Simulation':
+            # Ensure the simulation graph is updated when switching to the Simulation tab
+            self.components["simulation"].graph.update_graph()
+        self.sm.save_to_storage()
+
+    def fit_tab_changed(self, e):
+        if e.args == 'Data model setup':
+            # Ensure the data model is updated when switching to the Data model setup tab
+            self.components["data_model"]._populate_blocks()
+        if e.args == 'Fit Results':
+            pass
+            # Ensure the fit results graph is updated when switching to the Fit Results tab
+            # self.components["fit_results"].graph.update_graph_x()
+            # self.components["fit_results"].graph.graph.update()
+        self.sm.save_to_storage()
+
+    def enable_disable_tabs(self,e=None):
+        """Enable or disable tabs based on the current state."""
+        reason_map = _compute_tab_disable_reasons(self.sm)
+        tabs_to_disable = set(reason_map.keys())
+        tabs_to_enable = [x for x in self.tabs.keys() if x not in tabs_to_disable]
+        self.disable_tabs(reason_map)
+        self.enable_tabs(tabs_to_enable)
+
+    def _clear_tab_guidance(self, tab_key: TabKey) -> None:
+        tooltip = self._tab_tooltip_elements.pop(tab_key, None)
+        cue = self._tab_help_cues.pop(tab_key, None)
+        if tooltip is not None:
+            tooltip.delete()
+        if cue is not None:
+            cue.delete()
+
+    def disable_tabs(self, tab_reasons: dict[TabKey, list[str]]) -> None:
+        for k, reason_list in tab_reasons.items():
+            if k in self.tabs:
+                self.tabs[k].disable()
+                self._clear_tab_guidance(k)
+                # Ensure we can absolutely-position the help cue over the tab icon.
+                self.tabs[k].classes("relative overflow-visible")
+                with self.tabs[k]:
+                    cue = (
+                        ui.icon("help_outline")
+                        .classes("text-black-7")
+                        .style(
+                            "position:absolute;"
+                            "left:calc(50% + 15px);"
+                            "top:15px;"
+                            "transform:translate(-50%, -50%);"
+                            "font-size:12px;"
+                            "z-index:2;"
+                            "pointer-events:none;"
+                        )
+                    )
+                    tooltip = ui.tooltip(_format_disable_tooltip(reason_list)).style('white-space: pre-wrap')
+                self._tab_help_cues[k] = cue
+                self._tab_tooltip_elements[k] = tooltip
+            else:
+                print(f"Tab {k} not found in tabs dictionary.")
+    
+    def enable_tabs(self, tab_keys: list[TabKey]) -> None:
+        for k in tab_keys:
+            if k in self.tabs:
+                self.tabs[k].enable()
+                self._clear_tab_guidance(k)
+            else:
+                print(f"Tab {k} not found in tabs dictionary.")