labdata 0.0.25__tar.gz → 0.1.1__tar.gz

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

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

@@ -0,0 +1,11 @@
+VERSION = "0.1.1"
+
+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.1}/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.1/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.1}/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.1}/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())