labdata 0.0.24__tar.gz → 0.1.0__tar.gz

{labdata-0.0.24 → labdata-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.0.24
+Version: 0.1.0
 Summary: Package to manage data in experimental neuroscience labs
 Author-email: Joao Couto <jpcouto@gmail.com>
 Project-URL: Homepage, https://github.com/jcouto/labdata
@@ -23,7 +23,7 @@ Requires-Dist: dash; extra == "dashboard"
 Requires-Dist: dash_bootstrap_components; extra == "dashboard"
 Requires-Dist: dash-extensions; extra == "dashboard"
 Requires-Dist: plotly; extra == "dashboard"
-Requires-Dist: streamlit>1.34; extra == "dashboard"
+Requires-Dist: streamlit>1.54; extra == "dashboard"
 Requires-Dist: streamlit-bokeh; extra == "dashboard"
 Requires-Dist: scipy; extra == "dashboard"
 Requires-Dist: scikit-image; extra == "dashboard"

labdata-0.1.0/labdata/__init__.py

@@ -0,0 +1,11 @@
+VERSION = "0.1.0"
+
+from .utils import *
+from .copy import copy_to_upload_server
+from .s3 import copy_to_s3
+
+_default_project = (prefs.get('database', {}) or {}).get('database.project', None)
+plugins = load_plugins(project=_default_project)
+for _name, _mod in plugins.items():
+    globals()[_name] = _mod
+

{labdata-0.0.24 → labdata-0.1.0}/labdata/cli.py

@@ -60,6 +60,8 @@ Server commands (don't run on experimental computers):
         parser.add_argument('--spike-sorting' ,action = 'store_true', default = False)
         parser.add_argument('--cell-segmentation' ,action = 'store_true', default = False)
         parser.add_argument('--debug' ,action = 'store_true', default = False, help = 'To debug the dash (dashboard) errors.')
+        parser.add_argument('--console', action = 'store_true', default = False,
+                            help = 'Include the IPython console tab in the dashboard.')
         project = _get_project()
         parser.add_argument('-p','--project',
                             default = project,
@@ -91,6 +93,8 @@ Server commands (don't run on experimental computers):
             command = f'streamlit run {str(main_webpage_path)}'
             if not args.project is None:
                 command += f' project={args.project}'
+            if args.console:
+                command += ' console=1'
             sub.run(command.split(' '))
     
     def subjects(self):

{labdata-0.0.24 → labdata-0.1.0}/labdata/dashboard/compute.py

@@ -44,7 +44,7 @@ def _jobs_panel(table, status_field, target_field, cols, delete_key):
             x='Jobs:Q',
             color=alt.Color('color:N').scale(None)
         ).configure_axis(labelLimit=3000))
-        st.altair_chart(ch, use_container_width=True)
+        st.altair_chart(ch, width="stretch")
 
     # filtered table
     selected_states = st.multiselect('Select status:', STATES, default=STATES[1:], key=f'{delete_key}_filter')
@@ -58,7 +58,7 @@ def _jobs_panel(table, status_field, target_field, cols, delete_key):
         display_df,
         column_config={'Select': st.column_config.CheckboxColumn(required=True)},
         disabled=[c for c in display_df.columns if c != 'Select'],
-        use_container_width=True,
+        width="stretch",
         key=f'{delete_key}_editor',
     )
     selected_jobs = edited[edited['Select'] == True].index.tolist()

labdata-0.1.0/labdata/dashboard/console.py

@@ -0,0 +1,166 @@
+import streamlit as st
+import base64
+
+
+def _execute_silent(kc, code):
+    """Fire-and-forget execution (used for kernel init)."""
+    kc.execute(code, silent=True)
+    while True:
+        try:
+            msg = kc.get_iopub_msg(timeout=60)
+        except Exception:
+            break
+        if (msg['msg_type'] == 'status' and
+                msg['content'].get('execution_state') == 'idle'):
+            break
+
+
+def _execute(kc, code):
+    """Execute code and collect text outputs, inline images, and errors."""
+    kc.execute(code)
+    outputs = []   # list of (kind, text)  kind in ('stream','result')
+    images  = []   # list of base-64 PNG strings
+    error   = None
+    while True:
+        try:
+            msg = kc.get_iopub_msg(timeout=60)
+        except Exception:
+            break
+        mtype   = msg['msg_type']
+        content = msg['content']
+        if mtype == 'stream':
+            outputs.append(('stream', content['text']))
+        elif mtype in ('execute_result', 'display_data'):
+            img = content['data'].get('image/png')
+            if img:
+                images.append(img)
+            else:
+                text = content['data'].get('text/plain', '')
+                if text:
+                    outputs.append(('result', text))
+        elif mtype == 'error':
+            error = '\n'.join(content['traceback'])
+        elif mtype == 'status' and content.get('execution_state') == 'idle':
+            break
+    return outputs, images, error
+
+
+def _start_kernel(project_name):
+    import jupyter_client
+    km = jupyter_client.KernelManager(kernel_name='python3')
+    km.start_kernel()
+    kc = km.client()
+    kc.start_channels()
+    kc.wait_for_ready(timeout=60)
+
+    # Configure matplotlib for inline PNG output, then preload labdata
+    init_lines = [
+        "import matplotlib",
+        "matplotlib.use('Agg')",
+        "import pylab as plt",
+        "%matplotlib inline",
+    ]
+    if project_name:
+        init_lines += [
+            "import os",
+            f"os.environ['LABDATA_DATABASE_PROJECT'] = {project_name!r}",
+        ]
+    init_lines += [
+        "from labdata import *",
+        "from labdata.schema import *",
+    ]
+    _execute_silent(kc, '\n'.join(init_lines))
+
+    st.session_state['_console_km']    = km
+    st.session_state['_console_kc']    = kc
+    st.session_state['_console_hist']  = []
+    st.session_state['_console_n']     = 0
+
+
+def _shutdown_kernel():
+    km = st.session_state.pop('_console_km', None)
+    st.session_state.pop('_console_kc', None)
+    st.session_state.pop('_console_hist', None)
+    st.session_state.pop('_console_n', None)
+    if km is not None:
+        try:
+            km.shutdown_kernel(now=True)
+        except Exception:
+            pass
+
+
+def console_tab(schema=None):
+    project_name = getattr(schema, 'schema_project', None) if schema else None
+
+    # kernel status bar
+    alive = '_console_km' in st.session_state
+    status_col, btn_col = st.columns([4, 1])
+    with status_col:
+        if alive:
+            st.success("Kernel running  •  `from labdata import *` and `from labdata.schema import *` pre-loaded")
+        else:
+            st.info("Kernel not started. Click **Start kernel** to launch an IPython kernel.")
+    with btn_col:
+        if not alive:
+            if st.button("Start kernel", type="primary", use_container_width=True):
+                with st.spinner("Starting IPython kernel…"):
+                    _start_kernel(project_name)
+                st.rerun()
+        else:
+            if st.button("Restart kernel", type="secondary", use_container_width=True):
+                _shutdown_kernel()
+                with st.spinner("Restarting…"):
+                    _start_kernel(project_name)
+                st.rerun()
+
+    if not alive:
+        return
+
+    kc      = st.session_state['_console_kc']
+    history = st.session_state['_console_hist']
+
+    # cell history
+    for entry in history:
+        n = entry['n']
+        st.code(f"In [{n}]:\n{entry['input']}", language='python')
+        for kind, text in entry['outputs']:
+            if kind == 'result':
+                st.text(f"Out [{n}]: {text.rstrip()}")
+            else:
+                st.text(text.rstrip())
+        for b64 in entry['images']:
+            st.image(base64.b64decode(b64))
+        if entry['error']:
+            st.error(entry['error'])
+
+    if history:
+        st.divider()
+
+    # input area 
+    code = st.text_area(
+        "code_input",
+        height=130,
+        placeholder="Python / IPython code — plots are displayed inline",
+        label_visibility='collapsed',
+        key='_console_code',
+    )
+
+    run_col, clear_col, _ = st.columns([1, 1, 6])
+    with run_col:
+        run_pressed = st.button("▶ Run", type="primary", use_container_width=True)
+    with clear_col:
+        if st.button("Clear", use_container_width=True):
+            st.session_state['_console_hist'] = []
+            st.session_state['_console_n']    = 0
+            st.rerun()
+
+    if run_pressed and code.strip():
+        with st.spinner("Running…"):
+            outputs, images, error = _execute(kc, code)
+        n = st.session_state['_console_n'] + 1
+        st.session_state['_console_n'] = n
+        history.append(dict(n=n, input=code,
+                            outputs=outputs, images=images, error=error))
+        st.rerun()
+
+        

{labdata-0.0.24 → labdata-0.1.0}/labdata/dashboard/decisiontask.py

@@ -106,11 +106,15 @@ def decisionmaking_tab(schema = None):
                     lambda x: x.strftime("%y-%m-%d"))
         return summarysource
 
+    if st.button('Refresh', icon=':material/refresh:'):
+        get_subjects_last_ran.clear()
+        get_summary_data.clear()
+
     all_subjects,subjects,max_date = get_subjects_last_ran()
     if not len(subjects):
         st.write('There are no sessions.')
         return
-    
+
     selected_indices = st.multiselect('Select subjects:',all_subjects,default = [s['subject_name'] for s in subjects])
     if len(selected_indices):
         # cache data to run faster
@@ -121,11 +125,11 @@ def decisionmaking_tab(schema = None):
         point_selector = alt.selection_point(on="click")
         chart = alt.Chart(summarysource).mark_rect().encode(
             x=alt.X('session_datetime:T',timeUnit = 'yearmonthdate',
-                    scale=alt.Scale(nice={'interval': 'day', 'step': 1})).axis(labelAngle=45,format='%Y-%m-%d').title('Date'),  
+                    scale=alt.Scale(nice={'interval': 'day', 'step': 1})).axis(labelAngle=45,format='%Y-%m-%d').title('Date'),
             y=alt.Y('subject_name:O').title('Subject name'),
                     color=alt.Color('performance_easy:Q',
-                    scale=alt.Scale(scheme='spectral', reverse=True,domain = [0.5,1])).title('Perf easy'),
-                    tooltip = ['subject_name','session_name','session_datetime','performance_easy','performance','n_trials']
+                    scale=alt.Scale(scheme='spectral', reverse=True, domain=[0.5,1], clamp=True)).title('Perf easy'),
+                    tooltip = ['subject_name:N','session_name:N','session_datetime:T','performance_easy:Q','performance:Q','n_trials:Q']
 
         ).properties(width=1000, title ='Behavioral performance').add_params(point_selector)
         event_data = st.altair_chart(chart.interactive(), on_select='rerun')
@@ -160,6 +164,10 @@ def decisionmaking_tab(schema = None):
                         & dict(subject_name=subject_name, session_name=session_name)
                         ).fetch(*cols, as_dict=True)
 
+            if st.button('Refresh sessions', icon=':material/refresh:'):
+                get_subject_data.clear()
+                get_session_trials.clear()
+
             trialset, weights, watering = get_subject_data(subject_name)
             sessions = sorted(trialset['session_datetime'].unique())
 
@@ -192,15 +200,15 @@ def decisionmaking_tab(schema = None):
 
             with col_summary:
                 black, orange = '#000000','#ff7f0e'
-                perf_val = trialset.dropna(subset=['performance_easy','performance']).sort_values('session_datetime').drop_duplicates('session_datetime').iloc[[-20]]
+                perf_val = trialset.dropna(subset=['performance_easy','performance']).sort_values('session_datetime').drop_duplicates('session_datetime').iloc[[-1]]
                 x_enc = alt.X('session_datetime:T', axis=axis).title('Session date')
                 perf_chart = (
                     alt.Chart(trialset).mark_line(color=black).encode(x=x_enc, y=alt.Y('performance_easy:Q', axis=axis).title('Performance')).properties(width=1000) +
-                    alt.Chart(trialset).mark_point(color=black).encode(x=x_enc, y=alt.Y('performance_easy:Q'), tooltip=['session_name','session_datetime','performance_easy','performance']) +
+                    alt.Chart(trialset).mark_point(color=black).encode(x=x_enc, y=alt.Y('performance_easy:Q'), tooltip=['session_name:N','session_datetime:T','performance_easy:Q','performance:Q']) +
                     alt.Chart(perf_val).mark_text(align='left', dx=6, dy=100, color=black).encode(x=x_enc, y=alt.Y('performance_easy:Q'), text=alt.value('easy')) +
                     alt.Chart(trialset).mark_line(color=orange).encode(x=x_enc, y=alt.Y('performance:Q', axis=axis)) +
                     alt.Chart(trialset).mark_point(color=orange).encode(x=x_enc, y=alt.Y('performance:Q'),
-                                                                        tooltip=['session_name','session_datetime','performance_easy','performance']) +
+                                                                        tooltip=['session_name:N','session_datetime:T','performance_easy:Q','performance:Q']) +
                     alt.Chart(perf_val).mark_text(align='left', dx=6, dy=100, color=orange).encode(x=x_enc, y=alt.Y('performance:Q'), text=alt.value('all trials'))
                 )
                 ruler_df = pd.DataFrame({'t': [selected_dt]})
@@ -224,7 +232,7 @@ def decisionmaking_tab(schema = None):
                     chartw    + make_ruler('weighing_datetime'),
                     charth2o  + make_ruler('watering_datetime'),
                 ).resolve_scale(x='shared')
-                st.altair_chart(linked.interactive(), use_container_width=True)
+                st.altair_chart(linked.interactive(), width="stretch")
 
             with col_psych:
 
@@ -251,7 +259,7 @@ def decisionmaking_tab(schema = None):
                     lines = base.mark_line().encode(y=alt.Y('proportion:Q'))
                     st.altair_chart((lines + errorbars + pts).properties(
                         width=400, height=500, title=f'{pd.Timestamp(selected_dt).strftime("%Y-%m-%d %H:%M")}'
-                    ).interactive(), use_container_width=True)
+                    ).interactive(), width="stretch")
 
                     # reaction time per condition
                     rt_rows = []
@@ -291,9 +299,9 @@ def decisionmaking_tab(schema = None):
                         rt_lines = rt_base.mark_line().encode(y=alt.Y('median_rt:Q'))
                         st.altair_chart((rt_lines + rt_err + rt_pts).properties(
                             width=400, height=300, title='Reaction time per condition'
-                        ).interactive(), use_container_width=True)
+                        ).interactive(), width="stretch")
                 else:
-                    st.write('No response data available for this session.')
+                    st.error('No data available for this session.')
 
                 if len(snames) > 1:
                     st.slider('Session', min_value=0, max_value=len(snames)-1,
@@ -312,12 +320,11 @@ def decisionmaking_tab(schema = None):
                         st.caption(f"*{n['notetaker']} — {pd.Timestamp(n['note_datetime']).strftime('%Y-%m-%d %H:%M')}*")
                         st.write(n['notes'])
 
-def line_point_plot(data,x,y,tooltip,color):
-    scatter = alt.Chart(data).mark_point(color = color).encode(
-                x=x,
-                y=y,
-                tooltip=tooltip)
+def line_point_plot(data, x, y, tooltip, color):
+    if data is None or not len(data):
+        return alt.Chart(pd.DataFrame()).mark_point()
+    scatter = alt.Chart(data).mark_point(color=color).encode(
+                x=x, y=y, tooltip=tooltip)
     line = alt.Chart(data).mark_line(color=color).encode(
-                x=x,
-                y=y,).properties(width=1000)
-    return scatter+line
+                x=x, y=y).properties(width=1000)
+    return scatter + line

labdata-0.1.0/labdata/dashboard/index.py

@@ -0,0 +1,233 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from functools import partial
+
+import sys
+
+def intro_tab(user_name = None, schema = None):
+    @st.cache_data
+    def get_subjects():
+        if user_name is not None:
+            df = pd.DataFrame((schema.Subject() & f'user_name = "{user_name}"').fetch())
+        else:
+            df = pd.DataFrame(schema.Subject().fetch())
+        return df.sort_values("subject_name").reset_index(drop=True)
+
+    @st.cache_data
+    def get_sessions(subject_names):
+        dfs = [pd.DataFrame((schema.Session() * schema.Dataset() &
+                              f'subject_name = "{s}"').fetch()) for s in subject_names]
+        dfs = [d for d in dfs if len(d)]
+        if not dfs:
+            return None
+        return pd.concat(dfs).sort_values("session_datetime").reset_index(drop=True)
+
+    @st.cache_data
+    def get_files(dataset_keys_frozen):
+        keys = [dict(k) for k in dataset_keys_frozen]
+        rows = (schema.Dataset.DataFiles * schema.File & keys).fetch(
+            'subject_name', 'session_name', 'dataset_name',
+            'file_path', 'file_size', 'file_datetime', 'storage', as_dict=True)
+        if not rows:
+            return pd.DataFrame()
+        df = pd.DataFrame(rows)
+        df['size'] = df['file_size'].apply(
+            lambda b: f'{b/1e9:.2f} GB' if b >= 1e9 else f'{b/1e6:.1f} MB' if b >= 1e6 else f'{b/1e3:.0f} KB')
+        return df.drop(columns='file_size')
+
+    @st.cache_data
+    def get_users():
+        return list(schema.LabMember.fetch('user_name'))
+
+    @st.cache_data
+    def get_strains():
+        return list(schema.Strain().fetch('strain_name'))
+
+    list_tab, add_tab, edit_tab = st.tabs(['Subjects/Sessions', 'New', 'Update'])
+
+    with list_tab:
+        subjects = get_subjects()
+        event_subjects = st.dataframe(
+            subjects,
+            hide_index=True,
+            width="stretch",
+            on_select='rerun',
+            selection_mode='multi-row',
+            key='subjects_table',
+        )
+        sel_subj_idx = (event_subjects.selection or {}).get('rows', [])
+        selected_names = list(subjects.iloc[sel_subj_idx]['subject_name']) if sel_subj_idx else []
+        if selected_names:
+            st.session_state['subjects_selected'] = selected_names
+
+        sessions = get_sessions(selected_names) if selected_names else None
+        if sessions is None:
+            st.write('No subjects selected.')
+        else:
+            dtype_vals = [s if s is not None else 'None' for s in sessions.dataset_type.values]
+            uniqueds = np.unique(dtype_vals)
+            metric_cols = st.columns(max(1, len(uniqueds)))
+            for col, d in zip(metric_cols, uniqueds):
+                col.metric(d, sum(1 for v in dtype_vals if v == d))
+
+            # color palette for dataset types (light backgrounds, readable text)
+            type_palette = ['#d0e8ff', '#ffd6d6', '#d4f5d4', '#fff0cc',
+                            '#e8d4f5', '#ffd9b3', '#d4f0f5', '#f5d4e8',
+                            '#e8f5d4', '#f5e8d4']
+            dtype_list = [s if s is not None else 'None' for s in sessions['dataset_type'].values]
+            unique_types = list(dict.fromkeys(dtype_list))  # preserve order, deduplicate
+            type_color = {t: type_palette[i % len(type_palette)] for i, t in enumerate(unique_types)}
+
+            def _color_rows(row):
+                dt = row.get('dataset_type')
+                dt = dt if dt is not None else 'None'
+                bg = type_color.get(dt, '')
+                return [f'background-color: {bg}'] * len(row)
+
+            sess_styled = sessions.style.apply(_color_rows, axis=1)
+            event_sessions = st.dataframe(
+                sess_styled,
+                hide_index=True,
+                width="stretch",
+                on_select='rerun',
+                selection_mode='multi-row',
+                key='sessions_table',
+            )
+            sel_indices = (event_sessions.selection or {}).get('rows', [])
+            sel_datasets = sessions.iloc[sel_indices] if sel_indices else pd.DataFrame()
+            if len(sel_datasets):
+                dataset_keys = sel_datasets[['subject_name', 'session_name', 'dataset_name']].to_dict('records')
+                file_stats = get_files(tuple(frozenset(d.items()) for d in dataset_keys))
+                if len(file_stats):
+                    st.write('### Files')
+                    ds_order = list(dict.fromkeys(file_stats['dataset_name'].values))
+                    even_color, odd_color = '#dceeff', '#fff3dc'
+                    ds_color = {ds: (even_color if i % 2 == 0 else odd_color)
+                                for i, ds in enumerate(ds_order)}
+
+                    def _color_file_rows(row):
+                        bg = ds_color.get(row['dataset_name'], '')
+                        return [f'background-color: {bg}'] * len(row)
+
+                    file_styled = file_stats.style.apply(_color_file_rows, axis=1)
+                    event_files = st.dataframe(
+                        file_styled,
+                        hide_index=True,
+                        width="stretch",
+                        on_select='rerun',
+                        selection_mode='multi-row',
+                        key='files_table',
+                    )
+                    sel_file_idx = (event_files.selection or {}).get('rows', [])
+                    if sel_file_idx:
+                        sel_files = file_stats.iloc[sel_file_idx]
+                        st.caption(f'{len(sel_file_idx)} file(s) selected')
+                        if st.button('Download files', key='download_files_btn'):
+                            keys = sel_files[['file_path', 'storage']].to_dict('records')
+                            with st.spinner(f'Downloading {len(sel_file_idx)} file(s)…'):
+                                local = (schema.File & keys).get()
+                            if local:
+                                st.success(f'Downloaded {len(local)} file(s).')
+                                for p in local:
+                                    st.code(str(p))
+                else:
+                    st.write('No files found for the selected datasets.')
+
+    with add_tab:
+        users = get_users()
+        available_strains = get_strains()
+        project_users = list((schema.Project.User() & f'project_name = "{schema.schema_project}"').fetch('user_name'))
+        userindex = users.index(project_users[0]) if project_users and project_users[0] in users else None
+        with st.form('add_subject'):
+            insert_dict = dict()
+            insert_dict['user_name'] = st.selectbox('User Name', users, index=userindex)
+            insert_dict['subject_name'] = st.text_input('Subject ID', value=None)
+            insert_dict['subject_dob'] = st.date_input('Date of Birth')
+            sex = st.selectbox('Sex', ['M', 'F', 'Unknown'])
+            insert_dict['subject_sex'] = 'U' if sex == 'Unknown' else sex
+            insert_dict['strain_name'] = st.selectbox('Strain', available_strains)
+            if st.form_submit_button('Add Subject', type='primary'):
+                schema.Subject().insert1(insert_dict)
+                get_subjects.clear()
+                st.success(f'Added subject {insert_dict["subject_name"]}.')
+                st.rerun()
+
+    with edit_tab:
+        users = get_users()
+        available_strains = get_strains()
+        selected_names = st.session_state.get('subjects_selected', [])
+        if not selected_names:
+            st.info('Select a subject in the Subjects/Sessions tab first.')
+        else:
+            selected_subject = selected_names[0]
+            st.write(f'### Edit subject: {selected_subject}')
+            with st.form('edit_subject'):
+                edit_dict = (schema.Subject & dict(subject_name=selected_subject)).fetch1()
+                edit_dict['subject_dob'] = st.date_input('Date of Birth', value=edit_dict['subject_dob'])
+                edit_dict['subject_sex'] = st.selectbox('Sex', ['M', 'F', 'U'],
+                                                         index=['M', 'F', 'U'].index(edit_dict['subject_sex']))
+                edit_dict['strain_name'] = st.selectbox('Strain', available_strains,
+                                                         index=available_strains.index(edit_dict['strain_name']))
+                if st.form_submit_button('Save changes', type='primary'):
+                    schema.Subject().update1(edit_dict)
+                    get_subjects.clear()
+                    st.success(f'Updated {selected_subject}.')
+                    st.rerun()
+st.set_page_config(
+    page_title="labdata dashboard",
+    page_icon="🧪",
+    layout="wide",
+      initial_sidebar_state="auto")
+
+
+from procedures import procedures_tab
+from notes import notes_tab
+from sorting import sorting_tab
+from segmentation import segmentation_tab
+from video import video_tab
+from decisiontask import decisionmaking_tab
+from compute import compute_tab
+
+@st.cache_resource
+def load_schema(project):
+    # load project
+    from labdata import load_project_schema
+    return load_project_schema(project)
+
+project = None
+show_console = False
+for k in sys.argv:
+    if 'project=' in k:
+        project = k.replace('project=','')
+    if k == 'console=1':
+        from console import console_tab
+        show_console = True
+with st.spinner(f'Connecting to {"project " + project if project else "database"}…'):
+    schema = load_schema(project)
+
+page_names_to_funcs = {
+    "**Subjects**": partial(intro_tab, schema = schema),
+    "**Procedures**": partial(procedures_tab, schema = schema),
+    "**Notes**": partial(notes_tab, schema = schema),
+    "**Spike sorting**": partial(sorting_tab, schema = schema),
+    "**Cell Segmentation**": partial(segmentation_tab, schema = schema),
+    "**Video**": partial(video_tab, schema = schema),
+    "**Decision-making behavior**": partial(decisionmaking_tab, schema = schema),
+    "**Compute/Upload**": partial(compute_tab, schema = schema),
+}
+
+if show_console:
+    page_names_to_funcs["**Console**"] = partial(console_tab, schema=schema)
+
+from labdata import plugins
+for p in plugins.keys():
+    if hasattr(plugins[p],'dashboard_function'):
+        page_names_to_funcs[plugins[p].dashboard_name] = partial(plugins[p].dashboard_function, schema = schema)
+
+
+tab_name = st.sidebar.radio(
+    "``labdata dashboard``",
+    page_names_to_funcs.keys())
+
+page_names_to_funcs[tab_name]()