np-workflows 1.6.87__py3-none-any.whl → 1.6.91__py3-none-any.whl

np_workflows/experiments/task_trained_network/camstim_scripts/ttn_opto_script.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 optotagging.py
 
@@ -9,37 +8,30 @@ by joshs@alleninstitute.org
 (c) 2018 Allen Institute for Brain Science
 
 """
-import camstim  # ensures "magic" gets setup properly by importing first
-import logging  # must occur after camstim import for "magic"
-from camstim.zro import agent
-
-import numpy as np
-from toolbox.IO.nidaq import AnalogOutput
-from toolbox.IO.nidaq import DigitalOutput
 
 import datetime
-import numpy as np
-import time
+import logging  # must occur after camstim import for "magic"
 import pickle as pkl
+import time
 
+import numpy as np
+from camstim.zro import agent
+from toolbox.IO.nidaq import AnalogOutput, DigitalOutput
 
 # %%
 
 
-def run_optotagging(levels, conditions, waveforms, isis, sampleRate=10000.):
-
-    from toolbox.IO.nidaq import AnalogOutput
-    from toolbox.IO.nidaq import DigitalOutput
+def run_optotagging(levels, conditions, waveforms, isis, sampleRate=10000.0):
 
     sweep_on = np.array([0, 0, 1, 0, 0, 0, 0, 0], dtype=np.uint8)
     stim_on = np.array([0, 0, 1, 1, 0, 0, 0, 0], dtype=np.uint8)
     stim_off = np.array([0, 0, 1, 0, 0, 0, 0, 0], dtype=np.uint8)
     sweep_off = np.array([0, 0, 0, 0, 0, 0, 0, 0], dtype=np.uint8)
 
-    ao = AnalogOutput('Dev1', channels=[1])
+    ao = AnalogOutput("Dev1", channels=[1])
     ao.cfg_sample_clock(sampleRate)
 
-    do = DigitalOutput('Dev1', 2)
+    do = DigitalOutput("Dev1", 2)
 
     do.start()
     ao.start()
@@ -62,71 +54,123 @@ def run_optotagging(levels, conditions, waveforms, isis, sampleRate=10000.):
     do.clear()
     ao.clear()
 
+
 # %%
 
 
-def generatePulseTrain(pulseWidth, pulseInterval, numRepeats, riseTime, sampleRate=10000.):
+def generatePulseTrain(
+    pulseWidth, pulseInterval, numRepeats, riseTime, sampleRate=10000.0
+):
 
     data = np.zeros((int(sampleRate),), dtype=np.float64)
-   # rise_samples =
+    # rise_samples =
 
     rise_and_fall = (
-        ((1 - np.cos(np.arange(sampleRate*riseTime/1000., dtype=np.float64)*2*np.pi/10))+1)-1)/2
+        (
+            (
+                1
+                - np.cos(
+                    np.arange(sampleRate * riseTime / 1000.0, dtype=np.float64)
+                    * 2
+                    * np.pi
+                    / 10
+                )
+            )
+            + 1
+        )
+        - 1
+    ) / 2
     half_length = rise_and_fall.size / 2
     rise = rise_and_fall[:half_length]
     fall = rise_and_fall[half_length:]
 
-    peak_samples = int(sampleRate*(pulseWidth-riseTime*2)/1000)
+    peak_samples = int(sampleRate * (pulseWidth - riseTime * 2) / 1000)
     peak = np.ones((peak_samples,))
 
-    pulse = np.concatenate((rise,
-                            peak,
-                            fall))
+    pulse = np.concatenate((rise, peak, fall))
 
-    interval = int(pulseInterval*sampleRate/1000.)
+    interval = int(pulseInterval * sampleRate / 1000.0)
 
     for i in range(0, numRepeats):
-        data[i*interval:i*interval+pulse.size] = pulse
+        data[i * interval : i * interval + pulse.size] = pulse
 
     return data
 
 
 # %% create waveforms
 
-def optotagging(mouseID, operation_mode='experiment', level_list=[1.15, 1.28, 1.345], genotype=None):
+
+def optotagging(
+    mouseID, operation_mode="experiment", level_list=[1.15, 1.28, 1.345], genotype=None
+):
 
     sampleRate = 10000
 
     # 1 s cosine ramp:
-    data_cosine = (((1 - np.cos(np.arange(sampleRate, dtype=np.float64)
-                                * 2*np.pi/sampleRate)) + 1) - 1)/2  # create raised cosine waveform
+    data_cosine = (
+        (
+            (
+                1
+                - np.cos(
+                    np.arange(sampleRate, dtype=np.float64) * 2 * np.pi / sampleRate
+                )
+            )
+            + 1
+        )
+        - 1
+    ) / 2  # create raised cosine waveform
 
     # 1 ms cosine ramp:
     rise_and_fall = (
-        ((1 - np.cos(np.arange(sampleRate*0.001, dtype=np.float64)*2*np.pi/10))+1)-1)/2
+        (
+            (
+                1
+                - np.cos(
+                    np.arange(sampleRate * 0.001, dtype=np.float64) * 2 * np.pi / 10
+                )
+            )
+            + 1
+        )
+        - 1
+    ) / 2
     half_length = rise_and_fall.size / 2
 
     # pulses with cosine ramp:
-    pulse_2ms = np.concatenate((rise_and_fall[:half_length], np.ones(
-        (int(sampleRate*0.001),)), rise_and_fall[half_length:]))
-    pulse_5ms = np.concatenate((rise_and_fall[:half_length], np.ones(
-        (int(sampleRate*0.004),)), rise_and_fall[half_length:]))
-    pulse_10ms = np.concatenate((rise_and_fall[:half_length], np.ones(
-        (int(sampleRate*0.009),)), rise_and_fall[half_length:]))
+    pulse_2ms = np.concatenate(
+        (
+            rise_and_fall[:half_length],
+            np.ones((int(sampleRate * 0.001),)),
+            rise_and_fall[half_length:],
+        )
+    )
+    pulse_5ms = np.concatenate(
+        (
+            rise_and_fall[:half_length],
+            np.ones((int(sampleRate * 0.004),)),
+            rise_and_fall[half_length:],
+        )
+    )
+    pulse_10ms = np.concatenate(
+        (
+            rise_and_fall[:half_length],
+            np.ones((int(sampleRate * 0.009),)),
+            rise_and_fall[half_length:],
+        )
+    )
 
     data_2ms_10Hz = np.zeros((sampleRate,), dtype=np.float64)
 
     for i in range(0, 10):
         interval = sampleRate / 10
-        data_2ms_10Hz[i*interval:i*interval+pulse_2ms.size] = pulse_2ms
+        data_2ms_10Hz[i * interval : i * interval + pulse_2ms.size] = pulse_2ms
 
     data_5ms = np.zeros((sampleRate,), dtype=np.float64)
-    data_5ms[:pulse_5ms.size] = pulse_5ms
+    data_5ms[: pulse_5ms.size] = pulse_5ms
 
     data_10ms = np.zeros((sampleRate,), dtype=np.float64)
-    data_10ms[:pulse_10ms.size] = pulse_10ms
+    data_10ms[: pulse_10ms.size] = pulse_10ms
 
-    data_10s = np.zeros((sampleRate*10,), dtype=np.float64)
+    data_10s = np.zeros((sampleRate * 10,), dtype=np.float64)
     data_10s[:-2] = 1
 
     # %% for experiment
@@ -138,8 +182,8 @@ def optotagging(mouseID, operation_mode='experiment', level_list=[1.15, 1.28, 1.
     condition_list = [2, 3]
     waveforms = [data_2ms_10Hz, data_5ms, data_10ms, data_cosine]
 
-    opto_levels = np.array(level_list*numRepeats*len(condition_list))  # BLUE
-    opto_conditions = condition_list*numRepeats*len(level_list)
+    opto_levels = np.array(level_list * numRepeats * len(condition_list))  # BLUE
+    opto_conditions = condition_list * numRepeats * len(level_list)
     opto_conditions = np.sort(opto_conditions)
     opto_isis = np.random.random(opto_levels.shape) * isi_rand + isi
 
@@ -151,7 +195,7 @@ def optotagging(mouseID, operation_mode='experiment', level_list=[1.15, 1.28, 1.
 
     # %% for testing
 
-    if operation_mode == 'test_levels':
+    if operation_mode == "test_levels":
         isi = 2.0
         isi_rand = 0.0
 
@@ -160,60 +204,69 @@ def optotagging(mouseID, operation_mode='experiment', level_list=[1.15, 1.28, 1.
         condition_list = [0]
         waveforms = [data_10s, data_10s]
 
-        opto_levels = np.array(level_list*numRepeats *
-                               len(condition_list))  # BLUE
-        opto_conditions = condition_list*numRepeats*len(level_list)
+        opto_levels = np.array(level_list * numRepeats * len(condition_list))  # BLUE
+        opto_conditions = condition_list * numRepeats * len(level_list)
         opto_conditions = np.sort(opto_conditions)
         opto_isis = np.random.random(opto_levels.shape) * isi_rand + isi
 
-    elif operation_mode == 'pretest':
+    elif operation_mode == "pretest":
         numRepeats = 1
 
         condition_list = [0]
-        data_2s = data_10s[-sampleRate*2:]
+        data_2s = data_10s[-sampleRate * 2 :]
         waveforms = [data_2s]
 
-        opto_levels = np.array(level_list*numRepeats *
-                               len(condition_list))  # BLUE
-        opto_conditions = condition_list*numRepeats*len(level_list)
+        opto_levels = np.array(level_list * numRepeats * len(condition_list))  # BLUE
+        opto_conditions = condition_list * numRepeats * len(level_list)
         opto_conditions = np.sort(opto_conditions)
-        opto_isis = [1]*len(opto_conditions)
+        opto_isis = [1] * len(opto_conditions)
     # %%
 
     outputDirectory = agent.OUTPUT_DIR
-    fileDate = str(datetime.datetime.now()).replace(':', '').replace(
-        '.', '').replace('-', '').replace(' ', '')[2:14]
-    fileName = outputDirectory  + "/" + fileDate + '_'+mouseID + '.opto.pkl'
-
-    print('saving info to: ' + fileName)
-    fl = open(fileName, 'wb')
+    fileDate = (
+        str(datetime.datetime.now())
+        .replace(":", "")
+        .replace(".", "")
+        .replace("-", "")
+        .replace(" ", "")[2:14]
+    )
+    fileName = outputDirectory + "/" + fileDate + "_" + mouseID + ".opto.pkl"
+
+    print("saving info to: " + fileName)
+    fl = open(fileName, "wb")
     output = {}
 
-    output['opto_levels'] = opto_levels
-    output['opto_conditions'] = opto_conditions
-    output['opto_ISIs'] = opto_isis
-    output['opto_waveforms'] = waveforms
+    output["opto_levels"] = opto_levels
+    output["opto_conditions"] = opto_conditions
+    output["opto_ISIs"] = opto_isis
+    output["opto_waveforms"] = waveforms
 
     pkl.dump(output, fl)
     fl.close()
-    print('saved.')
+    print("saved.")
 
     # %%
-    run_optotagging(opto_levels, opto_conditions,
-                    waveforms, opto_isis, float(sampleRate))
+    run_optotagging(
+        opto_levels, opto_conditions, waveforms, opto_isis, float(sampleRate)
+    )
 
 
 # %%
 if __name__ == "__main__":
-    import json
     import argparse
+    import json
 
     parser = argparse.ArgumentParser()
-    parser.add_argument('json_params', type=str, )
+    parser.add_argument(
+        "json_params",
+        type=str,
+    )
     args, _ = parser.parse_known_args()
 
-    with open(args.json_params, 'r', ) as f:
+    with open(
+        args.json_params,
+    ) as f:
         json_params = json.load(f)
 
-    logging.info('Optotagging with params: %s' % json_params)
+    logging.info("Optotagging with params: %s" % json_params)
     optotagging(**json_params)

np_workflows/experiments/task_trained_network/main_ttn_pilot.py

@@ -1,39 +1,28 @@
-import configparser
 import contextlib
 import copy
-import dataclasses
-import datetime
-import enum
 import functools
 import pathlib
-import platform
 import shutil
-import threading
 import time
 import zlib
-from typing import ClassVar, Literal, NamedTuple, NoReturn, Optional, TypedDict
+from typing import Literal
 
-import IPython
-import IPython.display
-import ipywidgets as ipw
 import np_config
 import np_logging
-import np_services
 import np_session
-import np_workflows
-import PIL.Image
-import pydantic
-from pyparsing import Any
 from np_services import (
-    Service,
     Finalizable,
-    ScriptCamstim,
+    MouseDirector,
+    NewScaleCoordinateRecorder,
     OpenEphys,
+    ScriptCamstim,
+    Service,
     Sync,
     VideoMVR,
-    NewScaleCoordinateRecorder,
-    MouseDirector,
 )
+from pyparsing import Any
+
+import np_workflows
 
 from .ttn_stim_config import (
     TTNSession,
@@ -41,6 +30,8 @@ from .ttn_stim_config import (
     per_session_main_stim_params,
     per_session_mapping_params,
     per_session_opto_params,
+)
+from .ttn_stim_config import (
     default_ttn_params as DEFAULT_STIM_PARAMS,
 )
 
@@ -49,36 +40,36 @@ logger = np_logging.getLogger(__name__)
 
 class TTNMixin:
     """Provides TTN-specific methods and attributes, mainly related to camstim scripts."""
-    
+
     ttn_session: TTNSession
     """Enum for session type, e.g. PRETEST, HAB_60, HAB_90, EPHYS."""
 
     @property
     def script_root_on_stim(self) -> pathlib.Path:
         "Path to local copy on Stim, from Stim."
-        return pathlib.Path('C:/ProgramData/StimulusFiles/dev')
-    
+        return pathlib.Path("C:/ProgramData/StimulusFiles/dev")
+
     @property
     def script_root_on_local(self) -> pathlib.Path:
         "Path to version controlled scripts on local machine."
-        return (pathlib.Path(__file__).parent / 'camstim_scripts')
-    
+        return pathlib.Path(__file__).parent / "camstim_scripts"
+
     @property
     def script_names(self) -> dict[Literal["main", "mapping", "opto"], str]:
         return {
             label: f"ttn_{label}_script.py" for label in ("main", "mapping", "opto")
         }
-        
+
     @property
     def stim_root_on_stim(self) -> pathlib.Path:
         "Path to dev folder on Stim computer, as seen from local machine."
         return np_config.local_to_unc(self.rig.stim, self.script_root_on_stim)
-    
+
     @property
     def stim_root_on_local(self) -> pathlib.Path:
         "Path to version controlled stim files on local machine."
-        return self.script_root_on_local / 'stims'
-        
+        return self.script_root_on_local / "stims"
+
     @property
     def recorders(self) -> tuple[Service, ...]:
         """Services to be started before stimuli run, and stopped after. Session-dependent."""
@@ -91,10 +82,10 @@ class TTNMixin:
     @property
     def stims(self) -> tuple[Service, ...]:
         return (ScriptCamstim,)
-    
+
     def initialize_and_test_services(self) -> None:
         """Configure, initialize (ie. reset), then test all services."""
-        
+
         MouseDirector.user = self.user.id
         MouseDirector.mouse = self.mouse.id
 
@@ -107,59 +98,68 @@ class TTNMixin:
 
         super().initialize_and_test_services()
 
-
     def update_state(self) -> None:
         "Store useful but non-essential info."
-        self.mouse.state['last_session'] = self.session.id
-        self.mouse.state['last_ttn_session'] = str(self.ttn_session)
+        self.mouse.state["last_session"] = self.session.id
+        self.mouse.state["last_ttn_session"] = str(self.ttn_session)
         if self.mouse == 366122:
             return
         match self.ttn_session:
             case TTNSession.PRETEST:
                 return
             case TTNSession.HAB_60 | TTNSession.HAB_90 | TTNSession.HAB_120:
-                self.session.project.state['latest_hab'] = self.session.id
+                self.session.project.state["latest_hab"] = self.session.id
             case TTNSession.EPHYS:
-                self.session.project.state['latest_ephys'] = self.session.id
-                self.session.project.state['sessions'] = self.session.project.state.get('sessions', []) + [self.session.id]
-                
+                self.session.project.state["latest_ephys"] = self.session.id
+                self.session.project.state["sessions"] = self.session.project.state.get(
+                    "sessions", []
+                ) + [self.session.id]
+
     def run_stim_scripts(self) -> None:
         self.validate_or_copy_stim_files()
         self.update_state()
-        
-        for stim in ('mapping', 'main', 'opto'):
-            
+
+        for stim in ("mapping", "main", "opto"):
+
             if not (params := self.params[stim]):
-                logger.info("%s script skipped this session: %r", stim, self.ttn_session)
+                logger.info(
+                    "%s script skipped this session: %r", stim, self.ttn_session
+                )
                 continue
-            
+
             ScriptCamstim.params = params
             ScriptCamstim.script = self.scripts[stim]
-            
+
             logger.debug("Starting %s script", stim)
-            
+
             ScriptCamstim.start()
-            
+
             with contextlib.suppress(Exception):
-                np_logging.web(f'ttn_{self.ttn_session.name.lower()}').info(f"{stim.capitalize()} stim started")
-            
+                np_logging.web(f"ttn_{self.ttn_session.name.lower()}").info(
+                    f"{stim.capitalize()} stim started"
+                )
+
             with contextlib.suppress(Exception):
                 while not ScriptCamstim.is_ready_to_start():
                     time.sleep(2.5)
-                
+
             if isinstance(ScriptCamstim, Finalizable):
                 ScriptCamstim.finalize()
 
             with contextlib.suppress(Exception):
-                np_logging.web(f'ttn_{self.ttn_session.name.lower()}').info(f"{stim.capitalize()} stim finished")
-    
+                np_logging.web(f"ttn_{self.ttn_session.name.lower()}").info(
+                    f"{stim.capitalize()} stim finished"
+                )
+
     def validate_or_copy_stim_files(self):
         for vc_copy in self.stim_root_on_local.iterdir():
             stim_copy = self.stim_root_on_stim / vc_copy.name
             validate_or_overwrite(validate=stim_copy, src=vc_copy)
-            
+
     @property
-    def params(self) -> dict[Literal["main", "mapping", "opto", "system"], dict[str, Any]]:
+    def params(
+        self,
+    ) -> dict[Literal["main", "mapping", "opto", "system"], dict[str, Any]]:
         params = copy.deepcopy(DEFAULT_STIM_PARAMS)
         params["mouse_id"] = str(self.mouse)
         params["user_id"] = str(self.user)
@@ -167,26 +167,27 @@ class TTNMixin:
             params["system"] = system
         params["main"] = per_session_main_stim_params(self.ttn_session)
         params["mapping"] = per_session_mapping_params(self.ttn_session)
-        params["opto"] =  per_session_opto_params(self.ttn_session, self.mouse)
+        params["opto"] = per_session_opto_params(self.ttn_session, self.mouse)
         return params
 
     @functools.cached_property
     def scripts(self) -> dict[Literal["main", "mapping", "opto"], str]:
         """Local path on Stim computer to each script.
-        
+
         Verifies Stim copy matches v.c., or overwrites on Stim.
         """
         for label in ("main", "mapping", "opto"):
             script = self.script_names[label]
             vc_copy = self.script_root_on_local / script
             stim_copy = np_config.local_to_unc(
-                self.rig.stim, self.script_root_on_stim / script,
+                self.rig.stim,
+                self.script_root_on_stim / script,
             )
-            
+
             validate_or_overwrite(validate=stim_copy, src=vc_copy)
-            
+
         return {
-            label: str(self.script_root_on_stim / script) 
+            label: str(self.script_root_on_stim / script)
             for label, script in self.script_names.items()
         }
 
@@ -194,8 +195,8 @@ class TTNMixin:
     def system_camstim_params(self) -> dict[str, Any]:
         "System config on Stim computer, if accessible."
         return camstim_defaults()
-    
-    
+
+
 class Hab(TTNMixin, np_workflows.PipelineHab):
     def __init__(self, *args, **kwargs):
         self.services = (
@@ -240,24 +241,28 @@ def new_experiment(
         case _:
             raise ValueError(f"Invalid session type: {session}")
     experiment.ttn_session = session
-    
+
     with contextlib.suppress(Exception):
-        np_logging.web(f'ttn_{experiment.ttn_session.name.lower()}').info(f"{experiment} created")
-            
+        np_logging.web(f"ttn_{experiment.ttn_session.name.lower()}").info(
+            f"{experiment} created"
+        )
+
     return experiment
 
 
 # --------------------------------------------------------------------------------------
 
+
 def validate_or_overwrite(validate: str | pathlib.Path, src: str | pathlib.Path):
     "Checksum validate against `src`, (over)write `validate` as `src` if different."
     validate, src = pathlib.Path(validate), pathlib.Path(src)
+
     def copy():
         logger.debug("Copying %s to %s", src, validate)
         shutil.copy2(src, validate)
-    while (
-        validate.exists() == False
-        or (v := zlib.crc32(validate.read_bytes())) != (c := zlib.crc32(pathlib.Path(src).read_bytes()))
-        ):
+
+    while validate.exists() == False or (v := zlib.crc32(validate.read_bytes())) != (
+        c := zlib.crc32(pathlib.Path(src).read_bytes())
+    ):
         copy()
-    logger.debug("Validated %s CRC32: %08X", validate, (v & 0xFFFFFFFF) )
+    logger.debug("Validated %s CRC32: %08X", validate, (v & 0xFFFFFFFF))

np_workflows/experiments/task_trained_network/ttn_session_widget.py

@@ -1,17 +1,6 @@
-import configparser
-import contextlib
-import copy
-import enum
-import functools
-from typing import ClassVar, Literal, NamedTuple, NoReturn, Optional, TypedDict
-
 import IPython.display
 import ipywidgets as ipw
-import np_config
-import np_logging
 import np_session
-import np_workflows
-from pyparsing import Any
 
 from .ttn_stim_config import TTNSession
 
@@ -20,6 +9,7 @@ global_state = {}
 
 # for widget, before creating a experiment --------------------------------------------- #
 
+
 class TTNSelectedSession:
     def __init__(self, session: str | TTNSession, mouse: str | int | np_session.Mouse):
         if isinstance(session, str):
@@ -48,17 +38,19 @@ def stim_session_select_widget(
         options=tuple(_.value for _ in TTNSession),
         description="Session",
     )
-        
+
     def update_selection():
         selection.__init__(str(session_dropdown.value), str(mouse))
-        
-    if (previously_selected_value := global_state.get('selected_session')):
+
+    if previously_selected_value := global_state.get("selected_session"):
         session_dropdown.value = previously_selected_value
         update_selection()
-        
+
     console = ipw.Output()
     with console:
-        if last_session := np_session.Mouse(selection.mouse).state.get('last_ttn_session'):
+        if last_session := np_session.Mouse(selection.mouse).state.get(
+            "last_ttn_session"
+        ):
             print(f"{mouse} last session: {last_session}")
         print(f"Selected: {selection.session}")
 
@@ -74,9 +66,9 @@ def stim_session_select_widget(
         update_selection()
         with console:
             print(f"Selected: {selection.session}")
-        global_state['selected_session'] = selection.session.value
-        
-    session_dropdown.observe(update, names='value')
+        global_state["selected_session"] = selection.session.value
+
+    session_dropdown.observe(update, names="value")
 
     IPython.display.display(ipw.VBox([session_dropdown, console]))