labdata 0.1.6__tar.gz → 0.1.8__tar.gz

{labdata-0.1.6 → labdata-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labdata
-Version: 0.1.6
+Version: 0.1.8
 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.8/labdata/__init__.py

@@ -0,0 +1,15 @@
+VERSION = "0.1.8"
+
+from .utils import *
+from .copy import copy_to_upload_server
+from .s3 import copy_to_s3
+
+_project = (prefs.get('database', {}) or {}).get('database.project', None)
+if 'LABDATA_DATABASE_PROJECT' in os.environ.keys():
+    if len(os.environ['LABDATA_DATABASE_PROJECT']):
+        _project = os.environ['LABDATA_DATABASE_PROJECT']
+
+plugins = load_plugins(project=_project)
+for _name, _mod in plugins.items():
+    globals()[_name] = _mod
+

{labdata-0.1.6 → labdata-0.1.8}/labdata/cli.py

@@ -91,15 +91,18 @@ Server commands (don't run on experimental computers):
                                       open_browser = True)
         else:
             import subprocess as sub
+            import os
             main_webpage_path = Path(__file__).parent / 'dashboard' / 'index.py'
-            command = f'streamlit run {str(main_webpage_path)}'
+            command = f'streamlit run --server.showEmailPrompt=False --browser.gatherUsageStats=False {str(main_webpage_path)}'
+            if 'LABDATA_VERBOSE' in os.environ.keys():
+                print(f'Running streamlit dashboard: {command}')
             if not args.project is None:
                 command += f' project={args.project}'
             if args.console:
                 command += ' console=1'
             if args.admin:
                 command += ' admin=1'
-            sub.run(command.split(' '))
+            sub.run(command,shell=True)
     
     def subjects(self):
         parser = argparse.ArgumentParser(

{labdata-0.1.6 → labdata-0.1.8}/labdata/compute/utils.py

@@ -279,7 +279,8 @@ class BaseCompute():
         self.dataset_key = None
         self.is_container = False
         if allow_s3 is None:
-            self.allow_s3 = prefs['allow_s3_download']
+            allow_s3 = prefs['allow_s3_download']
+        self.allow_s3 = allow_s3
         if 'LABDATA_CONTAINER' in os.environ.keys():
             # then it is running inside a container
             self.is_container = True

{labdata-0.1.6 → labdata-0.1.8}/labdata/dashboard/decisiontask.py

@@ -105,7 +105,8 @@ def decisionmaking_tab(schema = None):
         date_str = end_date.strftime('%Y-%m-%d')
         date_filter = (f'session_datetime > (DATE("{date_str}") - INTERVAL 3 MONTH) '
                        f'AND DATE(session_datetime) <= "{date_str}"')
-        summarysource = pd.DataFrame((schema.Session*schema.DecisionTask.TrialSet() & keys & 'trialset_description NOT LIKE "%opto%"'
+        summarysource = pd.DataFrame((schema.Session * schema.DecisionTask.TrialSet() * schema.Subject() & keys
+                                    & 'trialset_description NOT LIKE "%opto%"'
                                     & date_filter).fetch())
         if not len(summarysource):
             return []
@@ -113,14 +114,66 @@ def decisionmaking_tab(schema = None):
                     lambda x: x.strftime("%y-%m-%d"))
         return summarysource
 
-    ctrl_col, date_col, _ = st.columns([1, 2, 6])
+    @st.cache_data
+    def get_session_setups(selected_indices, end_date):
+        keys = [dict(subject_name=i) for i in selected_indices]
+        date_str = end_date.strftime('%Y-%m-%d')
+        date_filter = (f'session_datetime > (DATE("{date_str}") - INTERVAL 3 MONTH) '
+                       f'AND DATE(session_datetime) <= "{date_str}"')
+        try:
+            df = pd.DataFrame(
+                (schema.Session() * schema.Dataset() & keys & date_filter).fetch(
+                    'subject_name', 'session_name', 'setup_name', as_dict=True)
+            )
+            if len(df):
+                return (df.dropna(subset=['setup_name'])
+                          .drop_duplicates(['subject_name', 'session_name'])
+                          [['subject_name', 'session_name', 'setup_name']])
+        except Exception:
+            pass
+        return pd.DataFrame(columns=['subject_name', 'session_name', 'setup_name'])
+
+    @st.cache_data
+    def get_sort_data(subject_names):
+        keys = [dict(subject_name=s) for s in subject_names]
+        try:
+            subjects_df = pd.DataFrame(
+                (schema.Subject() & keys).fetch('subject_name', 'subject_dob', 'strain_name', as_dict=True)
+            )
+        except Exception:
+            subjects_df = pd.DataFrame({'subject_name': list(subject_names)})
+        try:
+            last_setups = pd.DataFrame(
+                (schema.Session() * schema.Dataset() & keys).fetch(
+                    'subject_name', 'session_datetime', 'setup_name', as_dict=True)
+            )
+            if len(last_setups):
+                last_setups = (last_setups.sort_values('session_datetime')
+                               .drop_duplicates('subject_name', keep='last')
+                               [['subject_name', 'setup_name']])
+                subjects_df = subjects_df.merge(last_setups, on='subject_name', how='left')
+            else:
+                subjects_df['setup_name'] = None
+        except Exception:
+            subjects_df['setup_name'] = None
+        return subjects_df
+
+    ctrl_col, date_col, sort_col, _ = st.columns([1, 2, 2, 5])
     with ctrl_col:
         if st.button('Refresh', icon=':material/refresh:'):
             get_max_date.clear()
             get_subjects_last_ran.clear()
             get_summary_data.clear()
+            get_sort_data.clear()
+            get_session_setups.clear()
     with date_col:
         end_date = st.date_input('End date', value=get_max_date(), label_visibility='collapsed')
+    with sort_col:
+        lbl, sel = st.columns([1, 2])
+        lbl.markdown('Sort by')
+        with sel:
+            sort_by = st.selectbox('Sort by', ['Name', 'Age', 'Strain', 'Last setup'],
+                                   label_visibility='collapsed')
 
     if end_date is None:
         return
@@ -137,6 +190,33 @@ def decisionmaking_tab(schema = None):
             st.write('Could not find sessions for the specified dates..')
             return
 
+        # Merge per-session setup into summary
+        setup_df = get_session_setups(tuple(selected_indices), end_date)
+        if len(setup_df):
+            summarysource = summarysource.merge(setup_df, on=['subject_name', 'session_name'], how='left')
+
+        # Compute Y-axis sort order
+        if sort_by == 'Last setup' and 'setup_name' in summarysource.columns:
+            last_setup = (summarysource[['subject_name', 'session_datetime', 'setup_name']]
+                          .dropna(subset=['setup_name'])
+                          .sort_values('session_datetime')
+                          .drop_duplicates('subject_name', keep='last'))
+            ordered = last_setup.sort_values('setup_name')['subject_name'].tolist()
+            sort_order = ordered + [s for s in selected_indices if s not in ordered]
+        else:
+            sort_field_map = {
+                'Name': ('subject_name', True),
+                'Age': ('subject_dob', True),
+                'Strain': ('strain_name', True),
+            }
+            sort_field, ascending = sort_field_map.get(sort_by, ('subject_name', True))
+            sort_df = get_sort_data(tuple(selected_indices))
+            if sort_field in sort_df.columns:
+                sort_order = (sort_df[sort_df['subject_name'].isin(selected_indices)]
+                              .sort_values(sort_field, ascending=ascending)['subject_name'].tolist())
+            else:
+                sort_order = sorted(selected_indices)
+
         # Build heatmap chart
         has_perf = 'performance_easy' in summarysource.columns and 'performance' in summarysource.columns
         point_selector = alt.selection_point(on="click")
@@ -144,6 +224,10 @@ def decisionmaking_tab(schema = None):
                      scale=alt.Scale(scheme='spectral', reverse=True, domain=[0.5,1], clamp=True)).title('Perf easy')
                      if has_perf else alt.value('#4477AA'))
         tooltip_fields = ['subject_name:N', 'session_name:N', 'session_datetime:T']
+        if 'strain_name' in summarysource.columns:
+            tooltip_fields.append('strain_name:N')
+        if 'setup_name' in summarysource.columns:
+            tooltip_fields.append('setup_name:N')
         if has_perf:
             tooltip_fields += ['performance_easy:Q', 'performance:Q']
         if 'n_trials' in summarysource.columns:
@@ -151,7 +235,7 @@ def decisionmaking_tab(schema = None):
         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'),
-            y=alt.Y('subject_name:O').title('Subject name'),
+            y=alt.Y('subject_name:O', sort=sort_order).title('Subject name'),
             color=color_enc,
             tooltip=tooltip_fields,
         ).properties(title='Behavioral performance').add_params(point_selector)

{labdata-0.1.6 → labdata-0.1.8}/labdata/dashboard/index.py

@@ -289,4 +289,23 @@ tab_name = st.sidebar.radio(
     index=_tab_options.index(_tab_default),
     key='sidebar_tab')
 
-page_names_to_funcs[tab_name]()
+try:
+    page_names_to_funcs[tab_name]()
+except Exception as _e:
+    import pymysql, datajoint as dj
+    def _is_mysql_err(exc):
+        return isinstance(exc, pymysql.err.Error) or (
+            hasattr(exc, '__cause__') and isinstance(exc.__cause__, pymysql.err.Error))
+    if _is_mysql_err(_e):
+        try:
+            conn = dj.conn()
+            if conn._conn is not None:
+                try:
+                    conn._conn.close()
+                except Exception:
+                    pass
+            conn.connect()
+        except Exception:
+            pass
+        st.rerun()
+    raise

{labdata-0.1.6 → labdata-0.1.8}/labdata/dashboard/segmentation.py

@@ -584,6 +584,7 @@ def segmentation_tab(schema=None):
                 return cell_list.index(tup)
         return -1
 
+    _btn_clicked = False
     nav_prev, nav_next, *_ = st.columns([1, 1, 6])
     if nav_prev.button('**p**rev cell', key='seg_prev_cell', disabled=not cell_list):
         idx = _nav_cursor()
@@ -591,14 +592,14 @@ def segmentation_tab(schema=None):
         pn, rn = cell_list[idx]
         st.session_state['seg_picked_rois'] = [{'plane_num': pn, 'roi_num': rn}]
         get_traces.clear()
-        st.rerun()
+        _btn_clicked = True
     if nav_next.button('**n**ext cell', key='seg_next_cell', disabled=not cell_list):
         idx = _nav_cursor()
         idx = (idx + 1) % len(cell_list)
         pn, rn = cell_list[idx]
         st.session_state['seg_picked_rois'] = [{'plane_num': pn, 'roi_num': rn}]
         get_traces.clear()
-        st.rerun()
+        _btn_clicked = True
 
     # Keyboard: w or p/s or n = prev/next cell, d/a = time forward/back
     _kb_html = """
@@ -714,7 +715,7 @@ def segmentation_tab(schema=None):
                     width='content',
                 )
 
-                if scatter is not None:
+                if scatter is not None and not _btn_clicked:
                     click_key = f'seg_last_click_{pname}_{pnum}'
                     current_click = (event.selection or {}).get('roi_click', [])
                     if current_click and current_click != st.session_state.get(click_key, []):