labdata 0.1.0__tar.gz → 0.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.0
+Version: 0.1.1
 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-0.1.1}/labdata/__init__.py

@@ -1,4 +1,4 @@
-VERSION = "0.1.0"
+VERSION = "0.1.1"
 
 from .utils import *
 from .copy import copy_to_upload_server

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

@@ -42,6 +42,18 @@ def segmentation_tab(schema=None):
         df['parameter_set_num'] = df['parameter_set_num'].astype(str)
         return df
 
+    @st.cache_data
+    def get_all_sessions():
+        rows = (schema.CellSegmentation * schema.Session * schema.CellSegmentationParams).fetch(
+            'subject_name', 'session_name', 'dataset_name', 'parameter_set_num',
+            'algorithm_name', 'algorithm_version', 'n_rois', 'session_datetime',
+            as_dict=True)
+        if not rows:
+            return pd.DataFrame()
+        df = pd.DataFrame(rows)
+        df['parameter_set_num'] = df['parameter_set_num'].astype(str)
+        return df.sort_values(['subject_name', 'session_datetime']).reset_index(drop=True)
+
     @st.cache_data
     def get_sessions(subject_name):
         rows = (schema.CellSegmentation * schema.Session * schema.CellSegmentationParams
@@ -70,6 +82,42 @@ def segmentation_tab(schema=None):
             del r['proj_im']
         return rows
 
+    @st.cache_data
+    def get_roi_color_proj(subject_name, session_name, dataset_name, parameter_set_num,
+                           sel_method, selected_only):
+        from labdata.stacks import roi_color_projection
+        key = dict(subject_name=subject_name, session_name=session_name,
+                   dataset_name=dataset_name, parameter_set_num=parameter_set_num)
+        plane_rows = (schema.CellSegmentation.Plane & key).fetch(
+            'plane_num', 'dims', as_dict=True)
+        results = []
+        for plane in plane_rows:
+            pnum = plane['plane_num']
+            if plane['dims'] is None:
+                continue
+            plane_key = dict(key, plane_num=pnum)
+            roi_table = schema.CellSegmentation.ROI & plane_key
+            roi_nums = list(roi_table.fetch('roi_num'))
+            if not roi_nums:
+                continue
+            if selected_only:
+                sel_rois = set(
+                    (schema.CellSegmentation.Selection
+                     & dict(plane_key, selection_method=sel_method, selection=1)
+                    ).fetch('roi_num'))
+                cell_indices = [i for i, rn in enumerate(roi_nums) if rn in sel_rois]
+            else:
+                cell_indices = list(range(len(roi_nums)))
+            if not cell_indices:
+                continue
+            all_masks = roi_table.get_roi_sparse_masks()
+            masks = [all_masks[i] for i in cell_indices]
+            rgb = roi_color_projection(masks)
+            h, w = rgb.shape[:2]
+            results.append(dict(plane_num=pnum, proj_name='roi color',
+                                url=_to_base64(rgb), h=h, w=w))
+        return results
+
     @st.cache_data
     def get_selection_methods(subject_name, session_name, dataset_name, parameter_set_num):
         key = dict(subject_name=subject_name, session_name=session_name,
@@ -109,6 +157,18 @@ def segmentation_tab(schema=None):
                                 db_label=db_label))
         return centers
 
+    @st.cache_data
+    def get_frame_rate(subject_name, session_name, dataset_name):
+        key = dict(subject_name=subject_name, session_name=session_name,
+                   dataset_name=dataset_name)
+        for table in (schema.TwoPhoton, schema.Miniscope):
+            try:
+                frame_rate, n_frames = (table & key).fetch1('frame_rate', 'n_frames')
+                return float(frame_rate), int(n_frames)
+            except Exception:
+                pass
+        return 1.0, 0
+
     @st.cache_data
     def get_traces(subject_name, session_name, dataset_name, parameter_set_num,
                    roi_keys, trace_type):
@@ -127,7 +187,7 @@ def segmentation_tab(schema=None):
                     data = (schema.CellSegmentation.RawTraces & roi_key).fetch1('f_trace')
                 else:
                     data = (schema.CellSegmentation.Deconvolved & roi_key).fetch1('deconv')
-                data = np.asarray(data, dtype=float)[:10000]
+                data = np.asarray(data, dtype=float)
                 for t, v in enumerate(data):
                     traces.append({'t': t, 'value': float(v), 'roi': label})
             except Exception:
@@ -146,13 +206,8 @@ def segmentation_tab(schema=None):
 
     # 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())
@@ -179,17 +234,60 @@ def segmentation_tab(schema=None):
         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()
+                subj_df = get_all_sessions()
+                subj_df = subj_df[subj_df['subject_name'] == clicked_subject]
+                if not subj_df.empty:
+                    first = subj_df.sort_values('session_datetime', ascending=False).iloc[0]
+                    st.session_state['seg_scatter_sel_key'] = (
+                        f"{first['session_name']}|{first['dataset_name']}")
+
+    # All-sessions scatter: animals on Y, dates on X, color by parameter_set_num
+    all_sessions_df = get_all_sessions()
+    if not all_sessions_df.empty:
+        scatter_all_df = all_sessions_df.copy()
+
+        param_sets_all = sorted(scatter_all_df['parameter_set_num'].unique().tolist())
+        _colors = ['#000000', '#d62728', '#1f77b4', '#ff7f0e', '#2ca02c',
+                   '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22']
+        all_color_scale = alt.Scale(
+            domain=param_sets_all,
+            range=[_colors[i % len(_colors)] for i in range(len(param_sets_all))])
+
+        all_scatter_click = alt.selection_point(
+            fields=['session_name', 'dataset_name', 'subject_name'], name='all_sess_click')
+        n_subjects = scatter_all_df['subject_name'].nunique()
+        all_scatter_chart = (
+            alt.Chart(scatter_all_df).mark_circle(size=80, opacity=0.7).encode(
+                x=alt.X('session_datetime:T', title='Date',
+                         axis=alt.Axis(tickCount='month', format='%b %Y', labelAngle=-45)),
+                y=alt.Y('subject_name:N', title='Subject name', sort='ascending'),
+                yOffset=alt.YOffset('jitter:Q', scale=alt.Scale(range=[-12, 12])),
+                color=alt.Color('parameter_set_num:N', scale=all_color_scale,
+                                title='Param set'),
+                opacity=alt.condition(all_scatter_click, alt.value(0.9), alt.value(0.35)),
+                tooltip=['subject_name:N', 'session_name:N', 'dataset_name:N',
+                         'parameter_set_num:N',
+                         alt.Tooltip('session_datetime:T', format='%Y-%m-%d'),
+                         'n_rois:Q'],
+            ).transform_calculate(jitter='random() - 0.5')
+             .add_params(all_scatter_click)
+             .properties(height=max(150, 60 * n_subjects + 60))
+        )
+        all_scatter_event = st.altair_chart(
+            all_scatter_chart, width='stretch', on_select='rerun',
+            key='seg_all_scatter')
+
+        all_pts = (all_scatter_event.selection or {}).get('all_sess_click', [])
+        if all_pts and all_pts[0].get('subject_name'):
+            clicked_subject = all_pts[0]['subject_name']
+            clicked_sname = all_pts[0].get('session_name', '')
+            clicked_dname = all_pts[0].get('dataset_name', '')
+            if clicked_subject in subjects:
+                st.session_state['seg_subject'] = clicked_subject
+            if clicked_sname:
+                st.session_state['seg_scatter_sel_key'] = f"{clicked_sname}|{clicked_dname}"
 
     subject = st.selectbox('Subject', subjects, index=None, key='seg_subject')
     if not subject:
@@ -200,54 +298,21 @@ 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', [])
+    # Resolve scatter selection before rendering the table so we can pre-select the row
+    stored = st.session_state.get('seg_scatter_sel_key', '')
     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 stored:
+        parts = stored.split('|', 1)
+        matches = sessions[(sessions['session_name'] == parts[0]) &
+                           (sessions['dataset_name'] == parts[1])]
         if not matches.empty:
             scatter_sel_idx = int(matches.index[0])
-            st.session_state['seg_scatter_sel_key'] = f"{sname}|{dname}"
+
+    # Pre-select the table row only when the scatter key is freshly set
+    if scatter_sel_idx is not None and stored != st.session_state.get('seg_scatter_applied_key'):
+        st.session_state['seg_sessions_table'] = {'selection': {'rows': [scatter_sel_idx], 'columns': []}}
+        st.session_state['seg_scatter_applied_key'] = stored
 
     event_sess = st.dataframe(
         sessions, hide_index=True, width='stretch',
@@ -260,14 +325,7 @@ def segmentation_tab(schema=None):
     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
+        sel_idx_final = None
 
     if sel_idx_final is None:
         return
@@ -282,6 +340,7 @@ def segmentation_tab(schema=None):
     if st.session_state.get('seg_current_key') != seg_key_id:
         st.session_state['seg_current_key'] = seg_key_id
         st.session_state['seg_picked_rois'] = []
+        st.session_state.pop('seg_selection_editor', None)
         for k in list(st.session_state.keys()):
             if k.startswith('seg_last_click_'):
                 del st.session_state[k]
@@ -291,9 +350,6 @@ def segmentation_tab(schema=None):
     with st.spinner('Loading projections…'):
         projections = get_projections(
             subject, row['session_name'], row['dataset_name'], param_set)
-    if not projections:
-        st.write('No projections found for this session.')
-        return
 
     # ROI display controls
     methods = get_selection_methods(
@@ -302,14 +358,14 @@ def segmentation_tab(schema=None):
     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,
-                           key='seg_show_mode', label_visibility='collapsed',
-                           disabled=not show_rois)
-    sel_method = cC.selectbox('Selection method', methods, key='seg_sel_method',
-                               label_visibility='collapsed',
-                               disabled=not show_rois)
+    cA, cB, cC, cD = st.columns([1, 1, 1, 2])
+    show_rois   = cA.toggle('Show ROI centers', value=True, key='seg_show_rois')
+    show_mode   = cB.radio('ROIs to show', ['All', 'Selected'], horizontal=True,
+                            key='seg_show_mode', label_visibility='collapsed')
+    show_traces = cC.toggle('Show traces', value=True, key='seg_show_traces')
+    sel_method  = cD.selectbox('Selection method', methods, key='seg_sel_method',
+                                label_visibility='collapsed',
+                                disabled=not show_rois)
 
     # Duplicate / delete selection methods
     _, _, dC = st.columns([1, 1, 2])
@@ -335,6 +391,7 @@ def segmentation_tab(schema=None):
                             [{**r, 'selection_method': nm} for r in src_rows])
                         get_selection_methods.clear()
                         get_roi_data.clear()
+                        get_roi_color_proj.clear()
                         st.session_state['seg_sel_method_pending'] = nm
                         st.rerun()
                     except Exception as exc:
@@ -355,6 +412,7 @@ def segmentation_tab(schema=None):
                 schema.dj.config['safemode'] = True # re-enable
                 get_selection_methods.clear()
                 get_roi_data.clear()
+                get_roi_color_proj.clear()
                 st.session_state.pop('seg_del_confirm', None)
                 st.rerun()
             except Exception as exc:
@@ -367,6 +425,13 @@ def segmentation_tab(schema=None):
         centers = get_roi_data(
             subject, row['session_name'], row['dataset_name'], param_set, sel_method)
 
+    with st.spinner('Loading ROI color projection…'):
+        roi_color_projs = get_roi_color_proj(
+            subject, row['session_name'], row['dataset_name'], param_set, sel_method,
+            selected_only=(show_mode == 'Selected'))
+
+    all_projections = roi_color_projs + list(projections)
+
     picked: list = st.session_state['seg_picked_rois']
 
     color_domain = ['cell', 'not cell', 'unclassified', 'picked']
@@ -374,13 +439,18 @@ def segmentation_tab(schema=None):
     size_domain  = ['cell', 'not cell', 'unclassified', 'picked']
     size_range   = [80, 80, 60, 160]
 
-    # projection tabs
-    proj_names = sorted(set(r['proj_name'] for r in projections))
+    # projection tabs — 'roi color' first (default), then others sorted
+    _other_names = sorted(set(r['proj_name'] for r in projections))
+    proj_names = (['roi color'] if roi_color_projs else []) + _other_names
+    if not proj_names:
+        st.write('No projections found for this session.')
+        return
+
     proj_tabs  = st.tabs(proj_names)
 
     for tab, pname in zip(proj_tabs, proj_names):
         with tab:
-            plane_imgs = sorted([r for r in projections if r['proj_name'] == pname],
+            plane_imgs = sorted([r for r in all_projections if r['proj_name'] == pname],
                                  key=lambda r: r['plane_num'])
             cols = st.columns(max(1, len(plane_imgs)))
             for col, r in zip(cols, plane_imgs):
@@ -444,9 +514,10 @@ def segmentation_tab(schema=None):
                 else:
                     display = img_layer
 
+                display = display.properties(width=350, height=350, title=f'Plane {pnum}').interactive()
+
                 event = col.altair_chart(
-                    display.properties(width=350, height=350,
-                                       title=f'Plane {pnum}').interactive(),
+                    display,
                     on_select='rerun',
                     key=f'seg_scatter_{pname}_{pnum}',
                     width='content',
@@ -464,23 +535,26 @@ def segmentation_tab(schema=None):
                             entry = {'plane_num': int(pnum_click), 'roi_num': int(roi_num)}
                             if entry in picked:
                                 picked.remove(entry)
-                            elif len(picked) < MAX_PICKED:
+                            else:
                                 picked.append(entry)
                             st.session_state['seg_picked_rois'] = picked
                             get_traces.clear()
 
-    # traces 
+    # traces
     if not picked:
-        st.caption(f'Click ROI dots on the projection to select traces (up to {MAX_PICKED}).')
+        st.caption('Click ROI dots on the projection to select traces.')
         return
 
     st.divider()
 
+    plot_picked = picked[-MAX_PICKED:]
+
     hA, hB = st.columns([3, 1])
-    hA.write(f'**Picked ROIs** ({len(picked)}/{MAX_PICKED}): '
-             + '  '.join(f'plane {p["plane_num"]}, roi {p["roi_num"]}' for p in picked))
+    hA.write(f'**ROIs** (plotting last {len(plot_picked)} of {len(picked)} selected): '
+             + '  '.join(f'plane {p["plane_num"]}, roi {p["roi_num"]}' for p in plot_picked))
     if hB.button('Clear all', key='seg_clear_picked'):
         st.session_state['seg_picked_rois'] = []
+        st.session_state.pop('seg_selection_editor', None)
         get_traces.clear()
         st.rerun()
 
@@ -493,39 +567,60 @@ def segmentation_tab(schema=None):
             st.rerun()
 
     trace_type = st.radio('Trace', ['dff', 'F', 'deconv'],
-                           horizontal=True, key='seg_trace_type')
+                           horizontal=True, key='seg_trace_type',
+                           disabled=not show_traces)
 
-    roi_keys = tuple((p['plane_num'], p['roi_num']) for p in picked)
+    roi_keys = tuple((p['plane_num'], p['roi_num']) for p in plot_picked)
 
-    with st.spinner('Loading traces…'):
-        traces_df = get_traces(subject, row['session_name'], row['dataset_name'],
-                               param_set, roi_keys, trace_type)
+    if show_traces:
+        with st.spinner('Loading traces…'):
+            traces_df = get_traces(subject, row['session_name'], row['dataset_name'],
+                                   param_set, roi_keys, trace_type)
 
-    if traces_df.empty:
-        st.write(f'No `{trace_type}` traces found for the selected ROIs.')
-    else:
-        zoom_x = alt.selection_interval(bind='scales', encodings=['x'])
-        trace_chart = (
-            alt.Chart(traces_df)
-            .mark_line(strokeWidth=1.2)
-            .encode(
-                x=alt.X('t:Q', title='Frame'),
-                y=alt.Y('value:Q', title=trace_type),
-                color=alt.Color('roi:N', title='ROI',
-                                scale=alt.Scale(
-                                    range=['#000000', '#d62728', '#1f77b4', '#ff7f0e',
-                                           '#2ca02c', '#9467bd', '#8c564b', '#e377c2',
-                                           '#7f7f7f', '#bcbd22'])),
-                tooltip=['roi:N', alt.Tooltip('t:Q', title='Frame'),
-                         alt.Tooltip('value:Q', format='.4f')],
+        if traces_df.empty:
+            st.write(f'No `{trace_type}` traces found for the selected ROIs.')
+        else:
+            frame_rate, _ = get_frame_rate(subject, row['session_name'], row['dataset_name'])
+            traces_df = traces_df.copy()
+            traces_df['t_sec'] = traces_df['t'] / frame_rate
+
+            window_s = 300.0
+            total_s = float(traces_df['t_sec'].max())
+            if total_s > window_s:
+                max_start = round(total_s - window_s, 2)
+                _lc, _sc = st.columns([1, 11])
+                _lc.markdown('**Time (s)**')
+                t_start = _sc.slider('Time (s)', 0.0, max_start, 0.0, step=30.0,
+                                     key='seg_trace_window', label_visibility='collapsed')
+            else:
+                t_start = 0.0
+            t_end = t_start + window_s
+
+            view_df = traces_df[
+                (traces_df['t_sec'] >= t_start) & (traces_df['t_sec'] <= t_end)]
+            trace_chart = (
+                alt.Chart(view_df)
+                .mark_line(strokeWidth=1.2)
+                .encode(
+                    x=alt.X('t_sec:Q', title='Time (s)',
+                             scale=alt.Scale(domain=[t_start, t_end]),
+                             axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
+                    y=alt.Y('value:Q', title=trace_type,
+                             axis=alt.Axis(tickCount=5, tickSize=5, grid=False)),
+                    color=alt.Color('roi:N', title='ROI',
+                                    scale=alt.Scale(
+                                        range=['#000000', '#d62728', '#1f77b4', '#ff7f0e',
+                                               '#2ca02c', '#9467bd', '#8c564b', '#e377c2',
+                                               '#7f7f7f', '#bcbd22'])),
+                    tooltip=['roi:N', alt.Tooltip('t_sec:Q', title='Time (s)', format='.2f'),
+                             alt.Tooltip('value:Q', format='.4f')],
+                )
+                .properties(height=220)
             )
-            .properties(height=220)
-            .add_params(zoom_x)
-        )
-        st.altair_chart(trace_chart, width='stretch')
+            st.altair_chart(trace_chart, width='stretch')
 
     # classification editor 
-    st.write('**Classification (is\_cell)**')
+    st.write('**ROI classification**')
     sel_rows = []
     for p in picked:
         roi_key = dict(seg_key, plane_num=p['plane_num'], roi_num=p['roi_num'])
@@ -558,7 +653,8 @@ def segmentation_tab(schema=None):
             except Exception as exc:
                 st.error(f'Error updating plane {erow["plane"]} roi {erow["roi"]}: {exc}')
         if changed:
-            get_roi_data.clear()
             st.success(f'Updated {changed} ROI classification(s).')
+            get_roi_data.clear()
+            get_roi_color_proj.clear()
             st.rerun()
 

labdata-0.1.1/labdata/dashboard/sorting.py

@@ -0,0 +1,207 @@
+import pandas as pd
+import streamlit as st
+import numpy as np
+import altair as alt
+
+
+colors = ['#1f77b4',
+          '#ff7f0e',
+          '#d62728',
+          '#2ca02c',
+          '#9467bd',
+          '#8c564b',
+          '#e377c2',
+          '#7f7f7f',
+          '#bcbd22']
+
+def sorting_tab(schema=None):
+
+    @st.cache_data
+    def get_all_sorting_sessions():
+        rows = (schema.SpikeSorting * schema.Session).fetch(
+            'subject_name', 'session_name', 'dataset_name',
+            'parameter_set_num', 'session_datetime', as_dict=True)
+        if not rows:
+            return pd.DataFrame()
+        df = pd.DataFrame(rows).drop_duplicates(
+            subset=['subject_name', 'session_name', 'dataset_name', 'parameter_set_num'])
+        df['parameter_set_num'] = df['parameter_set_num'].astype(str)
+        return df.sort_values(['subject_name', 'session_datetime']).reset_index(drop=True)
+
+    @st.cache_data
+    def get_session_counts():
+        rows = (schema.Subject * schema.SpikeSortingParams).aggr(
+            schema.SpikeSorting,
+            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
+
+    pars = schema.SpikeSortingParams().fetch(format='frame')[['algorithm_name', 'parameters_dict']]
+    pars.insert(0, 'Select', False)
+    edited_df = st.data_editor(pars.sort_index(),
+                               hide_index=False,
+                               disabled=['parameter_set_num',
+                                         'algorithm_name',
+                                         'parameters_dict'])
+    sessions = schema.SpikeSorting().fetch(format='frame').reset_index()
+    par_sets = edited_df[edited_df.Select == 1].reset_index()
+    from functools import partial
+    st.button('Update unit counts',
+              on_click=partial(schema.UnitCount.populate, display_progress=True))
+
+    # histogram: session counts per subject
+    counts_df = get_session_counts()
+    if not counts_df.empty:
+        # filter to selected param sets if any are chosen
+        if len(par_sets):
+            selected_params = par_sets.parameter_set_num.astype(str).tolist()
+            counts_filt = counts_df[counts_df['parameter_set_num'].isin(selected_params)]
+        else:
+            counts_filt = counts_df
+
+        if not counts_filt.empty:
+            param_sets_h = sorted(counts_filt['parameter_set_num'].unique().tolist())
+            bar_color_scale = alt.Scale(
+                domain=param_sets_h,
+                range=[colors[i % len(colors)] for i in range(len(param_sets_h))])
+
+            bar_sel = alt.selection_point(
+                fields=['subject_name', 'parameter_set_num'], name='bar_sel')
+            bar_chart = (
+                alt.Chart(counts_filt).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(bar_chart, width='stretch', on_select='rerun',
+                                        key='srt_sessions_bar')
+
+            bar_pts = (bar_event.selection or {}).get('bar_sel', [])
+            if bar_pts and bar_pts[0].get('subject_name'):
+                clicked_subj = bar_pts[0]['subject_name']
+                current = list(st.session_state.get('srt_subjects', []))
+                if clicked_subj not in current:
+                    current.append(clicked_subj)
+                    st.session_state['srt_subjects'] = current
+
+    # all-sessions scatter
+    all_sessions_df = get_all_sorting_sessions()
+    if not all_sessions_df.empty:
+        scatter_df = all_sessions_df.copy()
+        if len(par_sets):
+            selected_params = par_sets.parameter_set_num.astype(str).tolist()
+            flt = scatter_df[scatter_df['parameter_set_num'].isin(selected_params)]
+            if not flt.empty:
+                scatter_df = flt.reset_index(drop=True)
+
+        param_sets_s = sorted(scatter_df['parameter_set_num'].unique().tolist())
+        scat_color_scale = alt.Scale(
+            domain=param_sets_s,
+            range=[colors[i % len(colors)] for i in range(len(param_sets_s))])
+
+        n_subjects = scatter_df['subject_name'].nunique()
+        scat_sel = alt.selection_point(
+            fields=['subject_name', 'session_name', 'dataset_name'], name='srt_scat_sel')
+        scat_chart = (
+            alt.Chart(scatter_df).mark_circle(size=80, opacity=0.7).encode(
+                x=alt.X('session_datetime:T', title='Date',
+                         axis=alt.Axis(tickCount='month', format='%b %Y', labelAngle=-45)),
+                y=alt.Y('subject_name:N', title='Subject name', sort='ascending'),
+                yOffset=alt.YOffset('jitter:Q', scale=alt.Scale(range=[-12, 12])),
+                color=alt.Color('parameter_set_num:N', scale=scat_color_scale,
+                                title='Param set'),
+                opacity=alt.condition(scat_sel, alt.value(0.9), alt.value(0.35)),
+                tooltip=['subject_name:N', 'session_name:N', 'parameter_set_num:N',
+                         alt.Tooltip('session_datetime:T', format='%Y-%m-%d')],
+            ).transform_calculate(jitter='random() - 0.5')
+             .add_params(scat_sel)
+             .properties(height=max(150, 60 * n_subjects + 60))
+        )
+        scat_event = st.altair_chart(scat_chart, width='stretch', on_select='rerun',
+                                     key='srt_sessions_scatter')
+
+        scat_pts = (scat_event.selection or {}).get('srt_scat_sel', [])
+        if scat_pts and scat_pts[0].get('subject_name'):
+            clicked_subj = scat_pts[0]['subject_name']
+            current = list(st.session_state.get('srt_subjects', []))
+            if clicked_subj not in current:
+                current.append(clicked_subj)
+                st.session_state['srt_subjects'] = current
+
+    # subject/unit-count
+    selected_subjects = []
+    if len(par_sets):
+        sess = []
+        for p in par_sets.parameter_set_num.values:
+            sess.append(sessions[sessions.parameter_set_num == p])
+        sess = pd.concat(sess)
+        subjects = np.unique(sess.subject_name.values)
+
+        sesdict = []
+        for p in par_sets.parameter_set_num.values:
+            for subj in subjects:
+                sub = sessions[(sessions.subject_name == subj) &
+                               (sessions.parameter_set_num == p)]
+                sesdict.append({'subject_name': subj,
+                                'number_of_sessions': len(sub),
+                                'parameter_set_num': p,
+                                'number_of_probes': len(np.unique(sub.probe_num.values))})
+        sesdict = pd.DataFrame(sesdict)
+        if not len(sesdict):
+            return
+
+        selected_subjects = st.multiselect('Select subject:', subjects,
+                                           key='srt_subjects')
+
+    criteria_ids = schema.UnitCountCriteria().fetch(as_dict=True)
+    if not len(criteria_ids):
+        st.write('Add a UnitCountCriteria to the table: example '
+                 '"isi_contamination < 0.1 & amplitude_cutoff < 0.1 & '
+                 'spike_duration > 0.1 & spike_amplitude > 50 & presence_ratio > 0.6"')
+        return
+    selection = st.selectbox('Unit count criteria:',
+                             [f'[{c["unit_criteria_id"]}] -> {c["sua_criteria"]}'
+                              for c in criteria_ids])
+    if '->' in selection:
+        unit_criteria = int(int(selection.split('->')[0].strip(' []')))
+    else:
+        return
+
+    @st.cache_data
+    def get_unit_counts(s, p, unit_criteria):
+        return pd.DataFrame(
+            schema.UnitCount() * schema.Session() * schema.EphysRecording.ProbeSetting()
+            & dict(subject_name=s, parameter_set_num=p, unit_criteria_id=unit_criteria))
+
+    if len(selected_subjects):
+        units = []
+        for p in par_sets.parameter_set_num.values:
+            for s in selected_subjects:
+                units.append(get_unit_counts(s, p, unit_criteria))
+        if not len(units):
+            return
+        unit_counts = pd.concat(units).set_index('subject_name')
+        N = len(colors)
+        cc = np.array([colors[0] for c in np.arange(len(unit_counts.probe_id.values))])
+        for i, p in enumerate(np.unique(unit_counts.probe_id)):
+            idx = np.where(unit_counts.probe_id.values == p)[0]
+            cc[idx] = colors[np.mod(i, N)]
+        unit_counts['probe_color'] = cc
+        st.scatter_chart(unit_counts,
+                         x='session_datetime', y='all',
+                         x_label='Session date', y_label='Number of units',
+                         color='probe_color', size=30)
+        st.scatter_chart(unit_counts,
+                         x='session_datetime', y='sua',
+                         x_label='Session date', y_label='Number of single units',
+                         color='probe_color', size=30)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.0
+Version: 0.1.1
 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/dashboard/sorting.py

@@ -1,102 +0,0 @@
-import pandas as pd
-import streamlit as st
-import numpy as np
-
-colors = ['#1f77b4',
-          '#ff7f0e',
-          '#d62728',
-          '#2ca02c',
-          '#9467bd',
-          '#8c564b',
-          '#e377c2',
-          '#7f7f7f',
-          '#bcbd22']
-
-def sorting_tab(schema = None):
-    pars = schema.SpikeSortingParams().fetch(format='frame')[['algorithm_name','parameters_dict']]
-    pars.insert(0, "Select", False)
-    edited_df = st.data_editor(pars.sort_index(),
-                               hide_index=False,
-                               disabled = ['parameter_set_num',
-                                           'algorithm_name',
-                                           'parameters_dict'])
-    sessions = schema.SpikeSorting().fetch(format = 'frame').reset_index()
-    par_sets = edited_df[edited_df.Select == 1].reset_index()
-    from functools import partial
-    st.button('Update unit counts',on_click = partial(schema.UnitCount.populate,display_progress = True))
-     
-    selected_subjects = []
-    if len(par_sets):
-        sess = []
-        for p in par_sets.parameter_set_num.values:
-            sess.append(sessions[sessions.parameter_set_num == p])
-        sess = pd.concat(sess)
-        subjects  = np.unique(sess.subject_name.values)
-        sesdict = []
-        for p in par_sets.parameter_set_num.values:
-            for subj in subjects:
-                sub = sessions[(sessions.subject_name == subj) & (sessions.parameter_set_num == p)]
-                sesdict.append({'subject_name' : subj,
-                                'number_of_sessions': len(sub),
-                                'parameter_set_num': p,
-                                'number_of_probes':len(np.unique(sub.probe_num.values))})
-        sesdict = pd.DataFrame(sesdict)
-        if not len(sesdict):
-            return
-        # st.bar_chart(sesdict.set_index('subject_name'),y='number_of_sessions')
-        import altair as alt
-        ch = (alt.Chart(sesdict).mark_bar().encode(
-            y = 'subject_name:N', #alt.Y(,type = 'nominal'),
-            x = 'number_of_sessions:Q',#alt.X(,type = 'quantitative'),
-        color='parameter_set_num:N').configure_axis(labelLimit=3000))#alt.Color('color',type = 'nominal')))
-        st.altair_chart(ch,width="stretch")
-        selected_subjects = st.multiselect('Select subject:',subjects)
-    
-
-    
-    criteria_ids = schema.UnitCountCriteria().fetch(as_dict = True)
-    if not len(criteria_ids):
-        st.write('Add a UnitCountCriteria to the table: example "isi_contamination < 0.1 & amplitude_cutoff < 0.1 & spike_duration > 0.1 & spike_amplitude > 50 & presence_ratio > 0.6"')
-        return
-    selection = st.selectbox('Unit count criteria:',
-                             [f'[{c["unit_criteria_id"]}] -> {c["sua_criteria"]}' for c in criteria_ids])
-    if '->' in selection:
-        unit_criteria = int(int(selection.split('->')[0].strip(' []')))
-    else:
-        return
-    @st.cache_data
-    def get_unit_counts(s,p,unit_criteria):
-        return pd.DataFrame(schema.UnitCount()*schema.Session()*schema.EphysRecording.ProbeSetting() & dict(
-                        subject_name = s,
-                        parameter_set_num = p,
-                        unit_criteria_id = unit_criteria))
-    
-    if len(selected_subjects):   
-        units = []
-        for p in par_sets.parameter_set_num.values:
-            for s in selected_subjects:
-                units.append(get_unit_counts(s,p,unit_criteria))
-        if not len(units):
-            return
-        unit_counts = pd.concat(units).set_index('subject_name')        
-        # make the probe color
-        N = len(colors)
-        cc = np.array([colors[0] for c in np.arange(len(unit_counts.probe_id.values))])
-        for i,p in enumerate(np.unique(unit_counts.probe_id)):
-            idx = np.where(unit_counts.probe_id.values == p)[0]
-            cc[idx] = colors[np.mod(i,N)]
-        unit_counts['probe_color'] = cc
-        st.scatter_chart(unit_counts,
-                         x = 'session_datetime',
-                         y = 'all',
-                         x_label = 'Session date',
-                         y_label = 'Number of units',
-                         color = 'probe_color',
-                         size = 30)
-        st.scatter_chart(unit_counts,
-                         x = 'session_datetime',
-                         y = 'sua',
-                        x_label = 'Session date',
-                         y_label = 'Number of single units',
-                         color = 'probe_color',
-                         size = 30)