labdata 0.0.25__tar.gz → 0.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.0.25
+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

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.25 → 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.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.25 → labdata-0.1.0}/labdata/dashboard/decisiontask.py

@@ -125,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], clamp=True)).title('Perf easy'),
-                    tooltip = ['subject_name','session_name','session_datetime','performance_easy','performance','n_trials']
+                    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')
@@ -204,11 +204,11 @@ def decisionmaking_tab(schema = None):
                 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]})
@@ -320,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.0.25 → labdata-0.1.0}/labdata/dashboard/index.py

@@ -196,9 +196,13 @@ def load_schema(project):
     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)
 
@@ -213,11 +217,15 @@ page_names_to_funcs = {
     "**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())

{labdata-0.0.25 → labdata-0.1.0}/labdata/dashboard/segmentation.py

@@ -29,18 +29,31 @@ def segmentation_tab(schema=None):
     def get_subjects():
         return list((schema.Subject & schema.CellSegmentation).fetch('subject_name'))
 
+    @st.cache_data
+    def get_session_counts():
+        rows = (schema.Subject * schema.CellSegmentationParams).aggr(
+            schema.CellSegmentation,
+            n_sessions='count(session_name)'
+        ).fetch(as_dict=True)
+        if not rows:
+            return pd.DataFrame()
+        df = pd.DataFrame(rows)
+        df = df[df['n_sessions'] > 0].reset_index(drop=True)
+        df['parameter_set_num'] = df['parameter_set_num'].astype(str)
+        return df
+
     @st.cache_data
     def get_sessions(subject_name):
         rows = (schema.CellSegmentation * schema.Session * schema.CellSegmentationParams
                 & dict(subject_name=subject_name)).fetch(
             'session_name', 'dataset_name', 'parameter_set_num',
-            'algorithm_name', 'n_rois', 'segmentation_datetime',
+            'algorithm_name', 'algorithm_version', 'n_rois', 'segmentation_datetime',
             'session_datetime', as_dict=True)
         if not rows:
             return pd.DataFrame()
         df = pd.DataFrame(rows)
         cols = ['session_name', 'dataset_name', 'parameter_set_num', 'algorithm_name',
-                'n_rois', 'session_datetime', 'segmentation_datetime']
+                'algorithm_version', 'n_rois', 'session_datetime', 'segmentation_datetime']
         return df[[c for c in cols if c in df.columns]].sort_values(
             'session_datetime', ascending=False).reset_index(drop=True)
 
@@ -121,7 +134,7 @@ def segmentation_tab(schema=None):
                 pass
         return pd.DataFrame(traces)
 
-    # get the seg_picked_rois from session state 
+    # get the seg_picked_rois from session state
     if 'seg_picked_rois' not in st.session_state:
         st.session_state['seg_picked_rois'] = []
 
@@ -131,6 +144,53 @@ def segmentation_tab(schema=None):
         st.write('No cell segmentation data in the database.')
         return
 
+    # sessions per subject for each parameter_set_num
+    counts_df = get_session_counts()
+    bar_param_filter = st.session_state.get('seg_bar_param_filter')
+
+    if not counts_df.empty:
+        if st.session_state.pop('seg_bar_clear_pending', False):
+            st.session_state.pop('seg_bar_param_filter', None)
+            bar_param_filter = None
+
+        _colors = ['#000000', '#d62728', '#1f77b4', '#ff7f0e', '#2ca02c',
+                   '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22']
+        param_sets = sorted(counts_df['parameter_set_num'].unique().tolist())
+        bar_color_scale = alt.Scale(
+            domain=param_sets,
+            range=[_colors[i % len(_colors)] for i in range(len(param_sets))])
+
+        bar_sel = alt.selection_point(
+            fields=['subject_name', 'parameter_set_num'], name='bar_sel')
+        chart = (
+            alt.Chart(counts_df).mark_bar().encode(
+                x=alt.X('subject_name:N', sort='ascending', title='Subject'),
+                xOffset=alt.XOffset('parameter_set_num:N', title='Param set'),
+                y=alt.Y('n_sessions:Q', title='# sessions'),
+                color=alt.Color('parameter_set_num:N', title='Param set',
+                                scale=bar_color_scale),
+                opacity=alt.condition(bar_sel, alt.value(1.0), alt.value(0.4)),
+                tooltip=['subject_name:N', 'parameter_set_num:N', 'n_sessions:Q'],
+            ).add_params(bar_sel).properties(height=200)
+        )
+        bar_event = st.altair_chart(chart, width='stretch', on_select='rerun',
+                                    key='seg_sessions_bar')
+
+        pts = (bar_event.selection or {}).get('bar_sel', [])
+        if pts and pts[0].get('subject_name'):
+            clicked_subject = pts[0]['subject_name']
+            clicked_param = str(pts[0].get('parameter_set_num', ''))
+            if clicked_subject in subjects:
+                st.session_state['seg_subject'] = clicked_subject
+            st.session_state['seg_bar_param_filter'] = clicked_param
+            bar_param_filter = clicked_param
+
+        if bar_param_filter:
+            st.write(f'**Filtered by param set:** {bar_param_filter}')
+            if st.button('Clear filter', key='seg_bar_clear'):
+                st.session_state['seg_bar_clear_pending'] = True
+                st.rerun()
+
     subject = st.selectbox('Subject', subjects, index=None, key='seg_subject')
     if not subject:
         return
@@ -140,15 +200,79 @@ def segmentation_tab(schema=None):
         st.write('No segmentation sessions found for this subject.')
         return
 
+    # Apply bar param filter when active
+    if bar_param_filter is not None:
+        filtered = sessions[
+            sessions['parameter_set_num'].astype(str) == str(bar_param_filter)]
+        if not filtered.empty:
+            sessions = filtered.reset_index(drop=True)
+
+    # Clear scatter sticky selection when subject changes
+    if st.session_state.get('seg_scatter_subject') != subject:
+        st.session_state['seg_scatter_subject'] = subject
+        st.session_state.pop('seg_scatter_sel_key', None)
+
+    _colors = ['#000000', '#d62728', '#1f77b4', '#ff7f0e', '#2ca02c',
+               '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22']
+    scatter_df = sessions.copy()
+    scatter_df['parameter_set_num'] = scatter_df['parameter_set_num'].astype(str)
+    param_sets_s = sorted(scatter_df['parameter_set_num'].unique().tolist())
+    sess_color_scale = alt.Scale(
+        domain=param_sets_s,
+        range=[_colors[i % len(_colors)] for i in range(len(param_sets_s))])
+
+    scatter_click = alt.selection_point(
+        fields=['session_name', 'dataset_name'], name='sess_click')
+    scatter_chart = (
+        alt.Chart(scatter_df).mark_circle(size=120).encode(
+            x=alt.X('session_datetime:T', title='Date'),
+            y=alt.Y('parameter_set_num:N', title='Param set'),
+            color=alt.Color('parameter_set_num:N', scale=sess_color_scale,
+                            title='Param set'),
+            opacity=alt.condition(scatter_click, alt.value(1.0), alt.value(0.4)),
+            tooltip=['session_name:N', 'dataset_name:N', 'parameter_set_num:N',
+                     alt.Tooltip('session_datetime:T', format='%Y-%m-%d'),
+                     'n_rois:Q'],
+        ).add_params(scatter_click).properties(height=150)
+    )
+    scatter_event = st.altair_chart(scatter_chart, width='stretch', on_select='rerun',
+                                    key='seg_scatter_timeline')
+
+    scatter_pts = (scatter_event.selection or {}).get('sess_click', [])
+    scatter_sel_idx = None
+    if scatter_pts and scatter_pts[0].get('session_name'):
+        sname = scatter_pts[0]['session_name']
+        dname = scatter_pts[0].get('dataset_name', '')
+        matches = sessions[(sessions['session_name'] == sname) &
+                           (sessions['dataset_name'] == dname)]
+        if not matches.empty:
+            scatter_sel_idx = int(matches.index[0])
+            st.session_state['seg_scatter_sel_key'] = f"{sname}|{dname}"
+
     event_sess = st.dataframe(
         sessions, hide_index=True, width='stretch',
         on_select='rerun', selection_mode='single-row', key='seg_sessions_table',
     )
-    sel_idx = (event_sess.selection or {}).get('rows', [])
-    if not sel_idx:
+    table_rows = (event_sess.selection or {}).get('rows', [])
+
+    if table_rows:
+        sel_idx_final = table_rows[0]
+    elif scatter_sel_idx is not None:
+        sel_idx_final = scatter_sel_idx
+    else:
+        stored = st.session_state.get('seg_scatter_sel_key', '')
+        if stored:
+            parts = stored.split('|', 1)
+            matches = sessions[(sessions['session_name'] == parts[0]) &
+                               (sessions['dataset_name'] == parts[1])]
+            sel_idx_final = int(matches.index[0]) if not matches.empty else None
+        else:
+            sel_idx_final = None
+
+    if sel_idx_final is None:
         return
 
-    row = sessions.iloc[sel_idx[0]]
+    row = sessions.iloc[sel_idx_final]
     param_set = int(row['parameter_set_num'])
     seg_key = dict(subject_name=subject, session_name=row['session_name'],
                    dataset_name=row['dataset_name'], parameter_set_num=param_set)
@@ -175,6 +299,9 @@ def segmentation_tab(schema=None):
     methods = get_selection_methods(
         subject, row['session_name'], row['dataset_name'], param_set)
 
+    if 'seg_sel_method_pending' in st.session_state:
+        st.session_state['seg_sel_method'] = st.session_state.pop('seg_sel_method_pending')
+
     cA, cB, cC = st.columns([1, 1, 2])
     show_rois  = cA.toggle('Show ROIs', value=True, key='seg_show_rois')
     show_mode  = cB.radio('ROIs to show', ['All', 'Selected'], horizontal=True,
@@ -184,10 +311,10 @@ def segmentation_tab(schema=None):
                                label_visibility='collapsed',
                                disabled=not show_rois)
 
-    # Duplicate selection to create custom labelings
+    # Duplicate / delete selection methods
     _, _, dC = st.columns([1, 1, 2])
     with dC:
-        dname, dbtn = st.columns([3, 1])
+        dname, dbtn, del_btn = st.columns([3, 1, 1])
         new_name = dname.text_input('New method name', key='seg_new_method_name',
                                      placeholder=f'Duplicate "{sel_method}" as…',
                                      label_visibility='collapsed')
@@ -208,11 +335,34 @@ def segmentation_tab(schema=None):
                             [{**r, 'selection_method': nm} for r in src_rows])
                         get_selection_methods.clear()
                         get_roi_data.clear()
-                        st.session_state['seg_sel_method'] = nm
+                        st.session_state['seg_sel_method_pending'] = nm
                         st.rerun()
                     except Exception as exc:
                         st.error(f'Insert failed: {exc}')
 
+        if del_btn.button('Delete', key='seg_del_btn', type='secondary'):
+            st.session_state['seg_del_confirm'] = sel_method
+
+    pending_del = st.session_state.get('seg_del_confirm')
+    if pending_del and pending_del == sel_method:
+        st.warning(f'Delete selection method **"{pending_del}"**? This cannot be undone.')
+        yes_col, no_col, _ = st.columns([1, 1, 6])
+        if yes_col.button('Yes, delete', key='seg_del_yes', type='primary'):
+            try:
+                schema.dj.config['safemode'] = False # disable temporarly
+                (schema.CellSegmentation.Selection
+                 & dict(seg_key, selection_method=pending_del)).delete(force=True)
+                schema.dj.config['safemode'] = True # re-enable
+                get_selection_methods.clear()
+                get_roi_data.clear()
+                st.session_state.pop('seg_del_confirm', None)
+                st.rerun()
+            except Exception as exc:
+                st.error(f'Delete failed: {exc}')
+        if no_col.button('Cancel', key='seg_del_no'):
+            st.session_state.pop('seg_del_confirm', None)
+            st.rerun()
+
     with st.spinner('Loading ROI positions…'):
         centers = get_roi_data(
             subject, row['session_name'], row['dataset_name'], param_set, sel_method)

{labdata-0.0.25 → labdata-0.1.0}/labdata/utils.py

@@ -313,6 +313,12 @@ def load_project_schema(project_name):
     # delete so it can be reloaded
     for k in [k for k in sys.modules if 'labdata.schema' in k]:
         del sys.modules[k]
+    # update plugins in-place so existing references stay valid
+    import labdata
+    labdata.plugins.clear()
+    labdata.plugins.update(load_plugins(project=project_name))
+    for _name, _mod in labdata.plugins.items():
+        setattr(labdata, _name, _mod)
     return newschema
 
 def _get_table(schema,table_name):
@@ -412,12 +418,14 @@ def find_local_filepath(path,allowed_extensions = [],local_paths = None):
                 return p # found allowed extensions (use this to find ProcessedFiles)   
     return None  # file not found
 
-def plugin_lazy_import(name):
+def plugin_lazy_import(name, modpath):
     '''
-    Lazy import function to load the plugins.
+    Lazy import function to load a plugin from modpath.
     '''
+    if 'LABDATA_VERBOSE' in os.environ.keys():
+        print(f'[labdata] Loading plugin: {name}')
     import importlib.util
-    spec = importlib.util.spec_from_file_location(name, str(Path(prefs['plugins'][name])/"__init__.py"))
+    spec = importlib.util.spec_from_file_location(name, str(Path(modpath)/"__init__.py"))
     loader = importlib.util.LazyLoader(spec.loader)
     spec.loader = loader
     module = importlib.util.module_from_spec(spec)
@@ -425,6 +433,37 @@ def plugin_lazy_import(name):
     loader.exec_module(module)
     return module
 
+
+def load_plugins(project=None):
+    '''Load plugins from preferences, filtered by project.
+
+    Plugin keys in prefs['plugins'] can be:
+      - "plugin_name"                  load for any project
+      - "plugin_name@proj1,proj2"      load only for proj1 or proj2
+
+    When project is None only always-active plugins (no "@") are loaded.
+    '''
+    result = {}
+    if 'plugins' not in prefs:
+        return result
+    for modkey, modpath in prefs['plugins'].items():
+        if '@' in modkey:
+            name, projects_str = modkey.split('@', 1)
+            allowed = [p.strip() for p in projects_str.split(',')]
+        else:
+            name = modkey
+            allowed = None  # no filter — load for any project
+
+        if allowed is not None and project not in allowed:
+            continue
+
+        try:
+            result[name] = plugin_lazy_import(name, modpath)
+        except Exception as err:
+            print(err)
+            print(f'[labdata] Failed to load plugin: {name}')
+    return result
+
 def extrapolate_time_from_clock(master_clock,master_events, slave_events):
     '''
     Extrapolates the time for synchronizing events on different streams

{labdata-0.0.25 → labdata-0.1.0}/labdata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.0.25
+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

{labdata-0.0.25 → labdata-0.1.0}/labdata.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ labdata/compute/suite2p.py
 labdata/compute/utils.py
 labdata/dashboard/__init__.py
 labdata/dashboard/compute.py
+labdata/dashboard/console.py
 labdata/dashboard/decisiontask.py
 labdata/dashboard/index.py
 labdata/dashboard/notes.py

labdata-0.0.25/labdata/__init__.py

@@ -1,16 +0,0 @@
-VERSION = "0.0.25"
-
-from .utils import *
-from .copy import copy_to_upload_server
-from .s3 import copy_to_s3
-
-plugins = {}  # to have all plugins in the same place
-if 'plugins' in prefs.keys():
-    for modkey in prefs['plugins'].keys():
-        try:
-            modpath = str(Path(prefs['plugins'][modkey])/"__init__.py")
-            exec(f"{modkey} = plugin_lazy_import('{modkey}')")
-            exec(f'plugins["{modkey}"] = {modkey}')
-        except Exception as err:
-            print(err)
-            print(f'Failed to load plugin: {modkey}')