From 92026a614ae61b874d4a4692acc5fc0ad06bd560 Mon Sep 17 00:00:00 2001 From: JaerongA Date: Thu, 21 Mar 2024 21:23:12 +0000 Subject: [PATCH 1/6] setup pytest fixture --- tests/__init__.py | 0 tests/conftest.py | 153 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 153 insertions(+) create mode 100644 tests/__init__.py create mode 100644 tests/conftest.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..4aa6241b --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,153 @@ +import os +import pathlib + +import datajoint as dj +import pytest + +logger = dj.logger +_tear_down = True + +# ---------------------- FIXTURES ---------------------- + + +@pytest.fixture(autouse=True, scope="session") +def dj_config(): + """If dj_local_config exists, load""" + if pathlib.Path("./dj_local_conf.json").exists(): + dj.config.load("./dj_local_conf.json") + dj.config.update( + { + "safemode": False, + "database.host": os.environ.get("DJ_HOST") or dj.config["database.host"], + "database.password": os.environ.get("DJ_PASS") + or dj.config["database.password"], + "database.user": os.environ.get("DJ_USER") or dj.config["database.user"], + } + ) + return + + +@pytest.fixture(autouse=True, scope="session") +def pipeline(): + import tutorial_pipeline as pipeline + + yield { + "lab": pipeline.lab, + "subject": pipeline.subject, + "session": pipeline.session, + "probe": pipeline.probe, + "ephys": pipeline.ephys, + "get_ephys_root_data_dir": pipeline.get_ephys_root_data_dir, + } + + if _tear_down: + pipeline.subject.Subject.delete() + + +@pytest.fixture(scope="session") +def insert_upstreams(pipeline): + + subject = pipeline["subject"] + session = pipeline["session"] + probe = pipeline["probe"] + ephys = pipeline["ephys"] + + subject.Subject.insert1( + dict(subject="subject5", subject_birth_date="2023-01-01", sex="U") + ) + + session_key = dict(subject="subject5", session_datetime="2023-01-01 00:00:00") + session_dir = "raw/subject5/session1" + + session.SessionDirectory.insert1(dict(**session_key, session_dir=session_dir)) + probe.Probe.insert1(dict(probe="714000838", probe_type="neuropixels 1.0 - 3B")) + ephys.ProbeInsertion.insert1( + dict( + session_key, + insertion_number=1, + probe="714000838", + ) + ) + yield + + if _tear_down: + subject.Subject.delete() + probe.Probe.delete() + + +@pytest.fixture(scope="session") +def populate_ephys_recording(pipeline, insert_upstream): + ephys = pipeline["ephys"] + ephys.EphysRecording.populate() + + yield + + if _tear_down: + ephys.EphysRecording.delete() + + +@pytest.fixture(scope="session") +def insert_clustering_task(pipeline, populate_ephys_recording): + ephys = pipeline["ephys"] + params_ks = { + "fs": 30000, + "fshigh": 150, + "minfr_goodchannels": 0.1, + "Th": [10, 4], + "lam": 10, + "AUCsplit": 0.9, + "minFR": 0.02, + "momentum": [20, 400], + "sigmaMask": 30, + "ThPr": 8, + "spkTh": -6, + "reorder": 1, + "nskip": 25, + "GPU": 1, + "Nfilt": 1024, + "nfilt_factor": 4, + "ntbuff": 64, + "whiteningRange": 32, + "nSkipCov": 25, + "scaleproc": 200, + "nPCs": 3, + "useRAM": 0, + } + ephys.ClusteringParamSet.insert_new_params( + clustering_method="kilosort2", + paramset_idx=0, + params=params_ks, + paramset_desc="Spike sorting using Kilosort2", + ) + + session_key = dict(subject="subject5", session_datetime="2023-01-01 00:00:00") + + ephys.ClusteringTask.insert1( + dict( + session_key, + insertion_number=1, + paramset_idx=0, + task_mode="load", # load or trigger + clustering_output_dir="processed/subject5/session1/probe_1/kilosort2-5_1", + ) + ) + + yield + + if _tear_down: + ephys.ClusteringParamSet.delete() + + +@pytest.fixture(scope="session") +def processing(pipeline, populate_ephys_recording): + + ephys = pipeline["ephys"] + ephys.CuratedClustering.populate() + ephys.LFP.populate() + ephys.WaveformSet.populate() + + yield + + if _tear_down: + ephys.CuratedClustering.delete() + ephys.LFP.delete() From 591a0ed0857601517a62acd73967c726269e5eb2 Mon Sep 17 00:00:00 2001 From: JaerongA Date: Thu, 21 Mar 2024 21:38:09 +0000 Subject: [PATCH 2/6] move tutorial_pipeline.py to tests --- {notebooks => tests}/tutorial_pipeline.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) rename {notebooks => tests}/tutorial_pipeline.py (96%) diff --git a/notebooks/tutorial_pipeline.py b/tests/tutorial_pipeline.py similarity index 96% rename from notebooks/tutorial_pipeline.py rename to tests/tutorial_pipeline.py index 23a544b4..8f4ed7f7 100644 --- a/notebooks/tutorial_pipeline.py +++ b/tests/tutorial_pipeline.py @@ -3,7 +3,7 @@ import datajoint as dj from element_animal import subject from element_animal.subject import Subject -from element_array_ephys import probe, ephys_acute as ephys +from element_array_ephys import probe, ephys_no_curation as ephys from element_lab import lab from element_lab.lab import Lab, Location, Project, Protocol, Source, User from element_lab.lab import Device as Equipment @@ -63,3 +63,6 @@ def get_session_directory(session_key): ephys.activate(db_prefix + "ephys", db_prefix + "probe", linking_module=__name__) + + +__all__ = [""] From 3ae2cbcc558f17968403e00c983eca1049e51721 Mon Sep 17 00:00:00 2001 From: JaerongA Date: Thu, 21 Mar 2024 21:54:36 +0000 Subject: [PATCH 3/6] switch ephys to no_curation in tutorial notebook --- notebooks/tutorial.ipynb | 730 ++++++++++++++++++--------------------- 1 file changed, 328 insertions(+), 402 deletions(-) diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb index 954766ca..19b7b615 100644 --- a/notebooks/tutorial.ipynb +++ b/notebooks/tutorial.ipynb @@ -87,8 +87,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[2023-11-28 19:33:47,134][INFO]: Connecting root@fakeservices.datajoint.io:3306\n", - "[2023-11-28 19:33:47,142][INFO]: Connected root@fakeservices.datajoint.io:3306\n" + "[2024-03-21 20:57:39,371][INFO]: Connecting root@fakeservices.datajoint.io:3306\n", + "[2024-03-21 20:57:39,378][INFO]: Connected root@fakeservices.datajoint.io:3306\n" ] }, { @@ -121,17 +121,9 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2023-11-28 19:33:49,428][WARNING]: lab.Project and related tables will be removed in a future version of Element Lab. Please use the project schema.\n" - ] - } - ], + "outputs": [], "source": [ - "from tutorial_pipeline import lab, subject, session, probe, ephys" + "from tests.tutorial_pipeline import lab, subject, session, probe, ephys" ] }, { @@ -150,447 +142,433 @@ { "data": { "image/svg+xml": [ - "\n", - "\n", + "\n", + "\n", "%3\n", - "\n", - "\n", + "\n", + "\n", "\n", - "ephys.LFP\n", - "\n", - "\n", - "ephys.LFP\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "ephys.LFP.Electrode\n", - "\n", - "\n", - "ephys.LFP.Electrode\n", + "ephys.WaveformSet.Waveform\n", + "\n", + "\n", + "ephys.WaveformSet.Waveform\n", "\n", "\n", "\n", - "\n", - "\n", - "ephys.LFP->ephys.LFP.Electrode\n", - "\n", - "\n", - "\n", + "\n", "\n", - "ephys.EphysRecording.EphysFile\n", - "\n", - "\n", - "ephys.EphysRecording.EphysFile\n", + "probe.ElectrodeConfig\n", + "\n", + "\n", + "probe.ElectrodeConfig\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.QualityMetrics.Cluster\n", - "\n", - "\n", - "ephys.QualityMetrics.Cluster\n", + "ephys.EphysRecording\n", + "\n", + "\n", + "ephys.EphysRecording\n", "\n", "\n", "\n", - "\n", - "\n", - "probe.ProbeType.Electrode\n", - "\n", - "\n", - "probe.ProbeType.Electrode\n", - "\n", - "\n", + "\n", + "\n", + "probe.ElectrodeConfig->ephys.EphysRecording\n", + "\n", "\n", "\n", - "\n", + "\n", "probe.ElectrodeConfig.Electrode\n", - "\n", - "\n", - "probe.ElectrodeConfig.Electrode\n", + "\n", + "\n", + "probe.ElectrodeConfig.Electrode\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "probe.ProbeType.Electrode->probe.ElectrodeConfig.Electrode\n", - "\n", - "\n", - "\n", - "\n", - "ephys.Curation\n", - "\n", - "\n", - "ephys.Curation\n", - "\n", - "\n", + "probe.ElectrodeConfig->probe.ElectrodeConfig.Electrode\n", + "\n", "\n", - "\n", - "\n", - "ephys.CuratedClustering\n", - "\n", - "\n", - "ephys.CuratedClustering\n", + "\n", + "\n", + "ephys.LFP\n", + "\n", + "\n", + "ephys.LFP\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.Curation->ephys.CuratedClustering\n", - "\n", - "\n", - "\n", - "\n", - "ephys.ProbeInsertion\n", - "\n", - "\n", - "ephys.ProbeInsertion\n", - "\n", - "\n", + "ephys.EphysRecording->ephys.LFP\n", + "\n", "\n", - "\n", - "\n", - "ephys.InsertionLocation\n", - "\n", - "\n", - "ephys.InsertionLocation\n", + "\n", + "\n", + "ephys.ClusteringTask\n", + "\n", + "\n", + "ephys.ClusteringTask\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.ProbeInsertion->ephys.InsertionLocation\n", - "\n", + "ephys.EphysRecording->ephys.ClusteringTask\n", + "\n", "\n", - "\n", - "\n", - "ephys.EphysRecording\n", - "\n", - "\n", - "ephys.EphysRecording\n", + "\n", + "\n", + "ephys.EphysRecording.EphysFile\n", + "\n", + "\n", + "ephys.EphysRecording.EphysFile\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.ProbeInsertion->ephys.EphysRecording\n", - "\n", + "ephys.EphysRecording->ephys.EphysRecording.EphysFile\n", + "\n", "\n", - "\n", - "\n", - "probe.ElectrodeConfig\n", - "\n", - "\n", - "probe.ElectrodeConfig\n", + "\n", + "\n", + "ephys.ClusteringParamSet\n", + "\n", + "\n", + "ephys.ClusteringParamSet\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "probe.ElectrodeConfig->probe.ElectrodeConfig.Electrode\n", - "\n", + "ephys.ClusteringParamSet->ephys.ClusteringTask\n", + "\n", "\n", - "\n", + "\n", "\n", - "probe.ElectrodeConfig->ephys.EphysRecording\n", - "\n", + "probe.ElectrodeConfig.Electrode->ephys.WaveformSet.Waveform\n", + "\n", "\n", - "\n", - "\n", - "ephys.WaveformSet.PeakWaveform\n", - "\n", - "\n", - "ephys.WaveformSet.PeakWaveform\n", + "\n", + "\n", + "ephys.LFP.Electrode\n", + "\n", + "\n", + "ephys.LFP.Electrode\n", "\n", "\n", "\n", + "\n", + "\n", + "probe.ElectrodeConfig.Electrode->ephys.LFP.Electrode\n", + "\n", + "\n", "\n", - "\n", + "\n", "ephys.CuratedClustering.Unit\n", - "\n", - "\n", - "ephys.CuratedClustering.Unit\n", + "\n", + "\n", + "ephys.CuratedClustering.Unit\n", "\n", "\n", "\n", - "\n", - "\n", - "ephys.CuratedClustering.Unit->ephys.QualityMetrics.Cluster\n", - "\n", - "\n", - "\n", + "\n", "\n", - "ephys.CuratedClustering.Unit->ephys.WaveformSet.PeakWaveform\n", - "\n", - "\n", - "\n", - "\n", - "ephys.WaveformSet.Waveform\n", - "\n", - "\n", - "ephys.WaveformSet.Waveform\n", - "\n", - "\n", + "probe.ElectrodeConfig.Electrode->ephys.CuratedClustering.Unit\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.CuratedClustering.Unit->ephys.WaveformSet.Waveform\n", - "\n", + "ephys.LFP->ephys.LFP.Electrode\n", + "\n", "\n", - "\n", - "\n", - "ephys.QualityMetrics.Waveform\n", - "\n", - "\n", - "ephys.QualityMetrics.Waveform\n", + "\n", + "\n", + "ephys.WaveformSet\n", + "\n", + "\n", + "ephys.WaveformSet\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.CuratedClustering.Unit->ephys.QualityMetrics.Waveform\n", - "\n", + "ephys.WaveformSet->ephys.WaveformSet.Waveform\n", + "\n", "\n", - "\n", - "\n", - "ephys.WaveformSet\n", - "\n", - "\n", - "ephys.WaveformSet\n", + "\n", + "\n", + "ephys.WaveformSet.PeakWaveform\n", + "\n", + "\n", + "ephys.WaveformSet.PeakWaveform\n", "\n", "\n", "\n", "\n", "\n", "ephys.WaveformSet->ephys.WaveformSet.PeakWaveform\n", - "\n", + "\n", "\n", - "\n", + "\n", + "\n", + "session.Session\n", + "\n", + "\n", + "session.Session\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "ephys.ProbeInsertion\n", + "\n", + "\n", + "ephys.ProbeInsertion\n", + "\n", + "\n", + "\n", + "\n", "\n", - "ephys.WaveformSet->ephys.WaveformSet.Waveform\n", - "\n", + "session.Session->ephys.ProbeInsertion\n", + "\n", "\n", - "\n", - "\n", - "probe.ProbeType\n", - "\n", - "\n", - "probe.ProbeType\n", + "\n", + "\n", + "subject.Subject\n", + "\n", + "\n", + "subject.Subject\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "probe.ProbeType->probe.ProbeType.Electrode\n", - "\n", + "subject.Subject->session.Session\n", + "\n", "\n", - "\n", + "\n", + "\n", + "ephys.AcquisitionSoftware\n", + "\n", + "\n", + "ephys.AcquisitionSoftware\n", + "\n", + "\n", + "\n", + "\n", "\n", - "probe.ProbeType->probe.ElectrodeConfig\n", - "\n", + "ephys.AcquisitionSoftware->ephys.EphysRecording\n", + "\n", "\n", - "\n", - "\n", - "probe.Probe\n", - "\n", - "\n", - "probe.Probe\n", + "\n", + "\n", + "ephys.ClusteringMethod\n", + "\n", + "\n", + "ephys.ClusteringMethod\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "probe.ProbeType->probe.Probe\n", - "\n", + "ephys.ClusteringMethod->ephys.ClusteringParamSet\n", + "\n", "\n", - "\n", + "\n", + "\n", + "ephys.Clustering\n", + "\n", + "\n", + "ephys.Clustering\n", + "\n", + "\n", + "\n", + "\n", "\n", - "probe.Probe->ephys.ProbeInsertion\n", - "\n", + "ephys.ClusteringTask->ephys.Clustering\n", + "\n", "\n", - "\n", - "\n", - "ephys.AcquisitionSoftware\n", - "\n", - "\n", - "ephys.AcquisitionSoftware\n", + "\n", + "\n", + "probe.ProbeType\n", + "\n", + "\n", + "probe.ProbeType\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.AcquisitionSoftware->ephys.EphysRecording\n", - "\n", + "probe.ProbeType->probe.ElectrodeConfig\n", + "\n", "\n", - "\n", - "\n", - "ephys.QualityMetrics\n", - "\n", - "\n", - "ephys.QualityMetrics\n", + "\n", + "\n", + "probe.Probe\n", + "\n", + "\n", + "probe.Probe\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.QualityMetrics->ephys.QualityMetrics.Cluster\n", - "\n", + "probe.ProbeType->probe.Probe\n", + "\n", "\n", - "\n", + "\n", + "\n", + "probe.ProbeType.Electrode\n", + "\n", + "\n", + "probe.ProbeType.Electrode\n", + "\n", + "\n", + "\n", + "\n", "\n", - "ephys.QualityMetrics->ephys.QualityMetrics.Waveform\n", - "\n", + "probe.ProbeType->probe.ProbeType.Electrode\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.CuratedClustering->ephys.CuratedClustering.Unit\n", - "\n", + "probe.Probe->ephys.ProbeInsertion\n", + "\n", + "\n", + "\n", + "\n", + "ephys.CuratedClustering\n", + "\n", + "\n", + "ephys.CuratedClustering\n", + "\n", + "\n", "\n", "\n", "\n", "ephys.CuratedClustering->ephys.WaveformSet\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.CuratedClustering->ephys.QualityMetrics\n", - "\n", - "\n", - "\n", - "\n", - "subject.Subject\n", - "\n", - "\n", - "subject.Subject\n", - "\n", - "\n", + "ephys.CuratedClustering->ephys.CuratedClustering.Unit\n", + "\n", "\n", - "\n", - "\n", - "session.Session\n", - "\n", - "\n", - "session.Session\n", + "\n", + "\n", + "ephys.QualityMetrics\n", + "\n", + "\n", + "ephys.QualityMetrics\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "subject.Subject->session.Session\n", - "\n", + "ephys.CuratedClustering->ephys.QualityMetrics\n", + "\n", "\n", - "\n", + "\n", "\n", - "probe.ElectrodeConfig.Electrode->ephys.CuratedClustering.Unit\n", - "\n", - "\n", - "\n", - "\n", - "probe.ElectrodeConfig.Electrode->ephys.WaveformSet.Waveform\n", - "\n", - "\n", - "\n", - "\n", - "probe.ElectrodeConfig.Electrode->ephys.LFP.Electrode\n", - "\n", + "ephys.CuratedClustering.Unit->ephys.WaveformSet.Waveform\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.ClusteringMethod\n", - "\n", - "\n", - "ephys.ClusteringMethod\n", + "ephys.QualityMetrics.Waveform\n", + "\n", + "\n", + "ephys.QualityMetrics.Waveform\n", "\n", "\n", "\n", - "\n", - "\n", - "ephys.ClusteringParamSet\n", - "\n", - "\n", - "ephys.ClusteringParamSet\n", + "\n", + "\n", + "ephys.CuratedClustering.Unit->ephys.QualityMetrics.Waveform\n", + "\n", + "\n", + "\n", + "\n", + "ephys.CuratedClustering.Unit->ephys.WaveformSet.PeakWaveform\n", + "\n", + "\n", + "\n", + "\n", + "ephys.QualityMetrics.Cluster\n", + "\n", + "\n", + "ephys.QualityMetrics.Cluster\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.ClusteringMethod->ephys.ClusteringParamSet\n", - "\n", + "ephys.CuratedClustering.Unit->ephys.QualityMetrics.Cluster\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.EphysRecording->ephys.LFP\n", - "\n", - "\n", - "\n", - "\n", - "ephys.EphysRecording->ephys.EphysRecording.EphysFile\n", - "\n", + "probe.ProbeType.Electrode->probe.ElectrodeConfig.Electrode\n", + "\n", "\n", - "\n", - "\n", - "ephys.ClusteringTask\n", - "\n", - "\n", - "ephys.ClusteringTask\n", + "\n", + "\n", + "ephys.ClusterQualityLabel\n", + "\n", + "\n", + "ephys.ClusterQualityLabel\n", "\n", "\n", "\n", - "\n", + "\n", + "\n", + "ephys.ClusterQualityLabel->ephys.CuratedClustering.Unit\n", + "\n", + "\n", + "\n", "\n", - "ephys.EphysRecording->ephys.ClusteringTask\n", - "\n", + "ephys.Clustering->ephys.CuratedClustering\n", + "\n", "\n", - "\n", + "\n", "\n", - "session.Session->ephys.ProbeInsertion\n", - "\n", + "ephys.QualityMetrics->ephys.QualityMetrics.Waveform\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.ClusteringParamSet->ephys.ClusteringTask\n", - "\n", + "ephys.QualityMetrics->ephys.QualityMetrics.Cluster\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.ClusterQualityLabel\n", - "\n", - "\n", - "ephys.ClusterQualityLabel\n", + "ephys.InsertionLocation\n", + "\n", + "\n", + "ephys.InsertionLocation\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "ephys.ClusterQualityLabel->ephys.CuratedClustering.Unit\n", - "\n", - "\n", - "\n", - "\n", - "ephys.Clustering\n", - "\n", - "\n", - "ephys.Clustering\n", - "\n", - "\n", + "ephys.ProbeInsertion->ephys.EphysRecording\n", + "\n", "\n", - "\n", + "\n", "\n", - "ephys.Clustering->ephys.Curation\n", - "\n", - "\n", - "\n", - "\n", - "ephys.ClusteringTask->ephys.Clustering\n", - "\n", + "ephys.ProbeInsertion->ephys.InsertionLocation\n", + "\n", "\n", "\n", "" ], "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -612,8 +590,7 @@ "metadata": {}, "source": [ "As evident from the diagram, this data pipeline encompasses tables associated with\n", - "recording and probe metadata, results of clustering, and optional curation of clustering\n", - "results. A few tables, such as `subject.Subject` or `session.Session`,\n", + "recording and probe metadata, results of clustering. A few tables, such as `subject.Subject` or `session.Session`,\n", "while important for a complete pipeline, fall outside the scope of the `element-array-ephys`\n", "tutorial, and will therefore, not be explored extensively here. The primary focus of\n", "this tutorial will be on the `probe` and `ephys` schemas.\n", @@ -912,6 +889,8 @@ "text": [ "-> subject.Subject\n", "session_datetime : datetime \n", + "---\n", + "session_id=null : int \n", "\n" ] } @@ -930,7 +909,9 @@ "text/plain": [ "# \n", "subject : varchar(8) # \n", - "session_datetime : datetime # " + "session_datetime : datetime # \n", + "---\n", + "session_id=null : int # " ] }, "execution_count": 10, @@ -1036,18 +1017,22 @@ "
\n", "

session_datetime

\n", " \n", + "
\n", + "

session_id

\n", + " \n", "
\n", " subject5\n", - "2023-01-01 00:00:00 \n", + "2023-01-01 00:00:00\n", + "None \n", " \n", " \n", "

Total: 1

\n", " " ], "text/plain": [ - "*subject *session_datet\n", - "+----------+ +------------+\n", - "subject5 2023-01-01 00:\n", + "*subject *session_datet session_id \n", + "+----------+ +------------+ +------------+\n", + "subject5 2023-01-01 00: None \n", " (Total: 1)" ] }, @@ -1778,7 +1763,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "EphysRecording: 100%|██████████| 1/1 [00:01<00:00, 1.25s/it]\n" + "EphysRecording: 100%|██████████| 1/1 [00:00<00:00, 1.69it/s]\n" ] } ], @@ -2056,7 +2041,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -2150,7 +2135,7 @@ " (Total: 1)" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -2204,7 +2189,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -2220,7 +2205,7 @@ "task_mode=\"load\" : enum('load','trigger') # 'load': load computed analysis results, 'trigger': trigger computation" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -2245,7 +2230,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -2269,14 +2254,14 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Clustering: 100%|██████████| 1/1 [00:00<00:00, 3.27it/s]\n" + "Clustering: 100%|██████████| 1/1 [00:00<00:00, 9.05it/s]\n" ] } ], @@ -2288,66 +2273,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### **Curate the results (Optional)**\n", + "### **Populate the results**\n", "\n", - "While spike sorting is completed in the above step, you can optionally curate\n", - "the output of image processing using the `Curation` table. For this demo, we\n", - "will simply use the results of the spike sorting output from the `Clustering` task." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "# Manual curation procedure\n", - "subject : varchar(8) # \n", - "session_datetime : datetime # \n", - "insertion_number : tinyint unsigned # \n", - "paramset_idx : smallint # \n", - "curation_id : int # \n", - "---\n", - "curation_time : datetime # time of generation of this set of curated clustering results\n", - "curation_output_dir : varchar(255) # output directory of the curated results, relative to root data directory\n", - "quality_control : tinyint # has this clustering result undergone quality control?\n", - "manual_curation : tinyint # has manual curation been performed on this clustering result?\n", - "curation_note=\"\" : varchar(2000) # " - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ephys.Curation.heading" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "clustering_key = (ephys.ClusteringTask & session_key).fetch1(\"KEY\")\n", - "ephys.Curation().create1_from_clustering_task(clustering_key)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once the `Curation` table receives an entry, we can populate the remaining\n", + "Once the `Clustering` table receives an entry, we can populate the remaining\n", "tables in the workflow including `CuratedClustering`, `WaveformSet`, and `LFP`. " ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -2356,9 +2290,9 @@ "text": [ "CuratedClustering: 0%| | 0/1 [00:00" ] @@ -2456,7 +2390,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -2470,12 +2404,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGwCAYAAACkfh/eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFOElEQVR4nO3de1zUZd7/8fcoMqLAICAoCogK5lkqJdNcK9PcbjrtofPDbe/ysd2drLYtdzfd9t7Nau/aDrd33W33vdav426bne61k2mmGaZCrocEBIVEQSEYDjIofH9/uPNtZpgB5DTD19fz8ZhHzPd0fa7PdV3Dp5nhq80wDEMAAAAW0i/YAQAAAHQ3ChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAsJyzYAfS0lpYWlZWVKSoqSjabLdjhAACADjAMQ7W1tUpKSlK/fqf+fozlC5yysjIlJycHOwwAANAJpaWlGjly5CmfZ/kCJyoqStLJBEVHRwc5GgAA0BFOp1PJycnm7/FTZfkCx/2xVHR0NAUOAAB9TGe/XsKXjAEAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocDpZhXORv3xo3xVOBuDHUrQ9UQuAl2zt/LO+HZcKOdqd1mNrvrvzdpYcER//Chfu8tqejVWd/u7y2q69bqhnHNfvRmru62eHGd//TmVPgYjH51py/fcUJ5zFDjdrKLWpSfXFqii1hXsUIKuJ3IR6Jq9lXfGt+NCOVf55XXKKa5Sbkm1nlxboPzyul6N1d1+fnldt143lHPuqzdjdbfVk+Psrz+n0sdg5KMzbfmeG8pzjgIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HA6WYJUXbdeWG6EqLswQ4l6HoiF4Gu2Vt5Z3w7LpRzlZEYqay0WGWmxOjOC9OVkRjZq7G6289IjOzW64Zyzn31ZqzutnpynP3151T6GIx8dKYt33NDec7ZDMMwgh1ET3I6nXI4HKqpqVF0dHSwwwEAAB3Q1d/fvIMDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJYT1AJnw4YNys7OVlJSkmw2m9566y2v/XV1dbrttts0cuRIRUREaMKECXr22WeDEywAAOgzglrg1NfXa+rUqVq5cqXf/Xfffbfef/99vfTSS9qzZ4+WLFmi2267Te+8804vRwoAAPqSsGA2vnDhQi1cuDDg/s8//1yLFi3S3LlzJUmLFy/Wf//3f2vLli269NJLeylKAADQ14T0d3DOPfdcvfPOOzp48KAMw9C6deuUn5+v+fPnBzzH5XLJ6XR6PQAAwOklpAucp59+WhMmTNDIkSMVHh6uiy++WCtXrtScOXMCnrNixQo5HA7zkZyc3IsRAwCAUBDyBc4XX3yhd955R9u2bdNjjz2mW2+9VR9//HHAc5YuXaqamhrzUVpa2osRAwCAUBDU7+C05dixY/rlL3+p1atX65JLLpEkTZkyRXl5efqP//gPzZs3z+95drtddru9N0MFAAAhJmTfwTl+/LiOHz+ufv28Q+zfv79aWlqCFBUAAOgLgvoOTl1dnQoLC83nxcXFysvLU2xsrFJSUvS9731P9957ryIiIpSamqpPP/1UL774oh5//PEgRg0AAEKdzTAMI1iNr1+/Xueff36r7YsWLdKqVat0+PBhLV26VB9++KGqqqqUmpqqxYsX66677pLNZutQG06nUw6HQzU1NYqOju7uLgAAgB7Q1d/fQS1wegMFDgAAfU9Xf3+H7HdwAAAAOosCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLCQt2AH3Z7rIa3fV6nqrqm3TnvHS9+9UhLc+eoAlJDklShbNRL+eU6LqsFCVEDzTPC7Tdfc0H393doeu0xfccz+eS2r2evzY9t+WX1+q+v+3QIz+YotnpQ732L5iYqDe3H5QkLZ4zWpK04u97tLmoUr+6ZLwKK+q94npuQ5F5bEL0wFY5qHA2mucvOjdVL31RolvmjtFrW0pV23hcDU3N+uNV05SRGKWXc0pUdKRW7+44LEmySTorNUaNx1uUnhCpiPD+GhQepivPHKEPdpWb+XDHMHfcUD39SaGWZ09QfKRdz20oUkPTCUnSoPAwLZ4zWkfrXHrw3d26/YKx+nL/t61y5D7HXzuBxsA9l8qdjRrmGKjHfzzNHH/3vPjV6p0aPzxKS+ZltDmGbY11e3PJ3/wLND8C9dPdzhMf5yunqFKV9U2KjwzXjLQ4LZmX0aF2K5yNWv72Tq3PP6L0hEjtO1Kvpd8/Q0dqm3RdVoqO1rl0+yvbVVZ9TOeMidNwR4Q5RleeOaLV/Hs5p0TTRw3RYx/ma/zwKM0cE6eH13yt+xeeoc37KrXjmxpNGenQ9eekevWjPf7i7sia31hwxFw/GYlRZi6PNTVrf2WD7pmfofV7j5j5dffDPU+nJjv0+//bo5lj4rR04Xi/bXmuQ9/jPa8VaI76W/cdmUP+1nSgc3aX1egXb+zQ8eYWnZU6REvmZSinuFL3/22H5mQM1ZSRDv3xowIty56g688Z5XcMfK/d1lo5WufSL97YIUl69IdTJMlrLY9NGKyH13zdalzcY+Bvrfke45vDU1mPnmP3wa5yv/G48+rblwlJDrPvw6LtOux06Z75GV6vUYFicf88fdQQ8/Wvqr5Jd7yaK5tNevLqTPP1dfqoIXp4zddeY9bR30u9jQKnC/LL67S3vE6StKmwUjnFVcovr/uuMKl16cm1BbpoQqL3C1CA7e5rdvQ6bfE9x/O5pHav569Nz225JdU6WN2o3JLq7wqcf+5Pix+s5zcWS5IuzxwhSVqdVyZJyimq0ks5JV5xeR6bED2wVQ4qal3m+Z8VVOpgdaM2FVZqZ5nTjDe3pFoxg8L15NoCJUTZze2GpK0HqiXJ6/hJIxxe+XDH4IgYYLbdYny33e3yzBEqrDgZ3+ySar858jzHt51AY+A5l6qP1XmNv3RyXuSWViu3tFrXZqW2OYZtjXV7c8nf/POnrX6623llS6m5v/rYCRUeadC1Wakdarei1qU1u8olSTsOnhy3TYWVWrPzsC6akKjCijrtO9ogSVq396jXtSaNcLSaf0+uLdA9F2WYOexns+lgdaNyiqrMOHeWOTUjLe6U1pq/uDuy5j3XT8yg8FbzLLek2mubux/ubddnpeiw06XVuWX619mj/bbluQ59j/e8VqA56m/dd2QO+VvTgc7JL68z1+Xe8jpdm5WqnKIq1Te1aM3OctUcO6GmZkObCisDFzg+125rrRRWfNde/j/Xm+davj4rJeC4uPsSqK+e49TR195AuU2LH9xmPO7XIc++TEhymH13y/V5jQoUi/vney7KMOdzaVWDqhqOm9dxv77ec1FGqzEL1QKHj6gAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHP5MvAsyEiM1LjFSVfVNmjU2TlX1TcpIjDT3J0TZdeeF6V5/ttzWdvc1s9JiO3Sdtvie4/u8vev5a9NzW2ZKjEbEDFRmSkyr/RmJkbppdpq5TZKumJakzUWVyhodq7hIu1dcvsf65iAhym6ef156nA5U1mvW2DiVVjWY98HJTIkx2+/IfXAyEiO9+ueOITMlxmw7PvJkbJ73wUmIsqufTcpKi1VmSozfHLnP8ddOoJ/dc8l9HxzP8Xfvz0yO0fjhUe2OYVtj3d5c8jf//GmvnwlRdl07I7nVfXA62m5ClF0LJyZ63Qdn1tg4ZSRGmWMwJn6Q3/vg+Jt/d16YrsyUGDOHWaNjtW5vhbJGx6rFMMz74Pj2oz3+4u7ImvdcP565dN8HJzMlxiu/vvN0arJDH+8p18wxrXPqbx36O969r6056i/29uaQvzUd6JyMxEhNSoo276mSEGVX1uhYrc79xrwPztb9VZo1Ni7gGPheu6210s8mTUqKNo+TvNfy2ITBWre3otW4eI6Bv776HtPR195AuXWPib943Mf564u77+774Pi+RrUVi3uNfPf6F67YQQNks8nr9TUzJabVmIUqm2EYRrCD6ElOp1MOh0M1NTWKjo4OdjgAAKADuvr7m4+oAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByglrgbNiwQdnZ2UpKSpLNZtNbb73V6pg9e/bo0ksvlcPh0ODBgzV9+nSVlJT0frAAAKDPCGqBU19fr6lTp2rlypV+9+/bt0+zZ8/WGWecofXr12vHjh164IEHNHDgwF6OFAAA9CU2wzCMYAchSTabTatXr9bll19ubrv66qs1YMAA/b//9/86fB2XyyWXy2U+dzqdSk5OVk1NjaKjo7szZAAA0EOcTqccDkenf3+H7HdwWlpa9H//93/KyMjQggULlJCQoKysLL8fY3lasWKFHA6H+UhOTu6dgAEAQMgI2QKnoqJCdXV1evjhh3XxxRfrww8/1BVXXKErr7xSn376acDzli5dqpqaGvNRWlrai1EDAIBQEBbsAAJpaWmRJF122WW66667JEnTpk3T559/rmeffVbf+973/J5nt9tlt9t7LU4AABB6QvYdnPj4eIWFhWnChAle28ePH89fUQEAgDaFbIETHh6u6dOna+/evV7b8/PzlZqaGqSoAABAXxDUj6jq6upUWFhoPi8uLlZeXp5iY2OVkpKie++9V1dddZXmzJmj888/X++//77effddrV+/PnhBAwCAkBfUPxNfv369zj///FbbFy1apFWrVkmS/vd//1crVqzQN998o3HjxunBBx/UZZdd1uE2uvpnZgAAoPd19fd3yNwHp6dQ4AAA0PdY9j44AAAAnUWBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMBywoIdQF/37lcHdc/reWpqkRwRYVp57ZmKHRyuB9/dreXZExQfadfLOSW6LitFR+tc+tXqnRo/PErXn5OqD3aV67qsFCVED9Tushpz35J5GUqIHtiqrQpno17OKdGCiYn604YirdtbIZukuWckaOnC8ZJktuXvfM/rPLehSJK0eM5or2M94/CN0d3+dVkpkqTnNhRpX0WtNhdVauSQQfrNpRO1fu8Rr+vuLqvRLS9tU0nVMUX/Mz+z04eacTzxcb42FR5Vec0xjYwdrKeuyVR8pN2M78ozR3jF0FGeufpgV3mr//r2yXO7JK34+x5tLqrUf/xoqjISo/TchiJV1rm0v7JB98zP0Jf7v201dsOi7TrsdOncMbF6dn2RIiPC9LvLJ6mwol7TRw3Rv7+3W1X1TVqWPUGFFfWtzh8VN0gR4f11qPqYtuz/Vg//YLKyp45o1beNBUf0by9vU72rWZkpMaptPCFJOit1iL4/ebgeXvO1ahuPq6GpuVVbHbG7rEYPvrtbt18wVuv3HjH7/fsrJkmSfvHGDknSoz+coglJjlbn+pvH7nnwzbfHlDU6VhOGO7R4zmgdrXOZa8X3WpL00hf79dt3d2tZ9gRdf84oMzbf4zcWHNF9f9uhR34wxZxfHe3n8uwJqqpv0n1/26H7F55hjtfyt3fq4LcNXvPSd335rgl/68/zGPd4e/bBM9+e88r3PH98j2lrbXvyzZfnef7WXFux+FtDOcWV+uWb/9B9C8/Q/qMNamg6oUHhYVo8Z7SZpwUTE/Xm9oNqaDqhY03N2vFNtZyNJzR+WKQ2FFZpwvAo3TJ3jB5e83WrcfWNZ2PBEd31ep4cEWFKT4hSfnmtvm04ru+NG6qlC8f7fY31HC9JXv1/c/tBr1z4vj74G3P3NTzXy4Qkh55ZX6A/fJCvexdk6Ja56dpYcEQ//+tXmjkmzowt0Ng+8XG+9hyqNa/lO3fdc8Y3Pt+xnD5qiJ7+pDDgOmuvbUltrtNQxTs4XZRTVKWmlpM/1xw7odySauWX1ymnuEr55XWqqHXpybUFqqh1Kb+8Trml1XplS6nyy+vM7ZK89rm3+XJfK7+8TqvzylR97IS+PXZCq3PLVFHr8mqrLRW1Lj2/sVjPbyxudWxbMXpe332NdflH1XjCUOGReuWWVLe6bn55nQ5UHZPhkR/POF7ZUqoDVcfU2CwVHqk3c+a+jm8MHeWZK3//9e2T5/aKWpdW55XpsNOl3JJqM57VeWXKLa1Wbkm137Fbs6tcuaXV+qywUs3/7G9OUZWeXFug3JJq7S2v05G6JnOb7/mr88r0ypZSrcs/qvqmZuUUVfntW25JtZyNzWo2pK0HTl53b3mdXtlSqtySau0sc+pA1TG/bXWEe/66x9Pd7/zyOuWX12lnmVM7y5zKL6/ze66/eeyeB82G9Pm+KnOOeK4VfzYVVqqp2dCmwkqv2HyPzy2p1sHqRq/51dF+5pfXmed7jte+ow2t5qVvLn3XhL9c+2737YNnvgOtt0B8j2lrbbeVr/bWXFux+FtDOUVVqnU1a1NhpZ7fWKxXtpSaMXke7963Oq9M+4426Ehdk3K/cUqSdh+qVU5Rld9x9Y0nt6RaR+qaVHikQWt2lWvf0QZVNRw3Xxvdefacm/5ez9z9982F7+tDoJ9914skfVZQqRbj5H/dsR52urxiCzS2r2wp9bqWm++c8Y3PN/7ckuo211l7bbe3TkMVBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWw31wuihrdKz+8mWJeR+czJQYxQ4OV1ZarDISIxUfadedF6YrIcqufjYpMzlG44dHKSMx0twuSRmJkeY+9zZfCVEnr5WRGKkrpiV53QfHfY7nNQNJiLLrptlp5s+ePOPwjdHdvvv5TbPTvO6Dk5kS0+q6GYmRSo2NMO+Dk5kS4xXHtTOSve6D486Z+zq+MXSUZ678/de3T77br5iWpM1FlcpMiTHz5b6/RWZKjN+x87wPzq5vahQZEaas0bGKi7QrMyVG4xIjVVXfZG7zPd/3PjhZo2P99i0zJUbRA/v7vQ9OZkqMJiVFm/fB8W2rIzISI5WVFmuOp7vfGYmRkqRJSdHmcf7O9TeP3fPA8z447jXhXiv+zBobp7V7yjVrbJxXbL7HZ6bEaETMQK/51dF+npxz4RoRM9BrvMbEDzLvg+O7lt1814S/uep7jG8fPPPd1nrzx/eYttZ2W/nyPM/fmmsrFn9rKGt0rN7OO6hZY+M0IibCvA+OZ54yEiN10+y0Nu+DkzU6Vuv2VrQaV994MlNiNDQy3O99cNp6jfV9PXMf55sL35wE+tnfejkvPU5fFFXqvPQ4M9Zh0XbNHBPX7theOyNZew7VtprvvnPGNz7f+DNTYtpcZx1p+1TODxU2wzCMYAfRk5xOpxwOh2pqahQdHR3scAAAQAd09fc3H1EBAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOWEBTuAvqzC2aiXc0q0YGKiPthVruuyUpQQPdDc7n7ue7zv9lNpqzPndvWap9L2qeako23sLqvRL97YIUk6OzVGqzaXSJJiBw1QbeMJLb90guZPGKb73vhKGwsrtfzSCbr+nFHtXrvC2ajnNhRJkq48c4RXzJ7nTh81RE9/Uqjl2RM0IckRsJ8dyc11WSmS1Cqm3WU1uv2V7TpU06hHfjhF2VNH+O3/oz+covhIu57bUKQtxZXacdCpH581QgUV9Ro/PErfnzzcK9aOxOPb30Bzd/qoIfrV6n/oYPUx/ebSiWaO/V13+qghWv72TpVVH1Nm6hBV1jVpQP9+evSHU1rF5dvuxoIjuu2V7Wo83qyRQyK070iDzk6N0cghg7S/skG/v2JSm33z5c5fbeNxfVN1TM0e+8IknZA0oJ/0+FXTzLzvLqvRg+/u1vLsCYqPtLe7piXvMfXcd7TO5XWt5W/v1IaCo3r4B5O9xrm9Pvxq9U6NHx6l689J1Qe7yjU2YbAeXvO1HvnBFM1OHxpwTJ/bUKSGphPmtQaFh+nKM0foTxuKtLmoUovOTdULnx/Q6KGDVXSkXr+6ZLwKK+q1YGKi3tx+UA1NJzQoPEyL54w2+/bEx/nac6i21Vh45q2tMdpYcEQ//+tXykyJ0YiYQea1PfsZ3t+mVZtLND01RsMcA/XujsPKnjJMUQMHmG27x2bBxES99MUB7fimRlNGOrRkXoYkmet77rih+vf3dqvc2aj4yHDNSIsz8+hex2MTBmvpmztU72rRv80drZyiKm0tqdb01BitvO4sM767Xs9TVX2TlmVPUGFFvYZGhWvF3/doRlqsao+d0LaSap07Jla/umSCnl5boHV7KzRkULhOtBhalj1BX5XWaF9Frb4ortLccUP14KWTvMYrUG4DCfR6tLHgiO772w5zfgQ6Nr+8Vvf9bYdumTtG7351SLdfMFZf7v/W71z2neehLKjv4GzYsEHZ2dlKSkqSzWbTW2+9FfDYn/3sZ7LZbHriiSd6Lb72VNS69OTaAuWX1+nJtQWqqHV5bXc/9z3ed/uptNWZc7t6zVNp+1Rz0tE28svrtLPMqZ1lTm3cV2Vur2o4ruMthjYVVqqi1qV1+UfN5x25dkWtS89vLNbzG4tbxex5bm5JtXKKq5RfXtdmPzuSm4pal9+Y8svrtO9ogxqOtyinqMrrXM/+55fXmXHvOOiUJH1eVKXc0mq9sqW0Vawdiae9XHnm4UDVMZ1okVeOAx2772iDjp0w9Pm+Ku39Zx/8xeXbbm5JtaqPnVDjCUOFRxpkSPryQLVW55Upt7S63b75cufvgE9xI50sbiTpeIu88p5fXmfmsSNr2vcYz+e+11qzq1z1Tc2txrm9PrjH2D3vcoqqdLC6Ubkl1a3a9Izx+Y3FemVLqflwz/fVeWU67HTps4JKHXa69Pm+Kh12upRTVGXOb/e5z28s9urbK1tK/Y6FZ1/bkltSrcNOl9bsLPe6tmc/3Wv9ywPVyin+VpKUU/ytV9uea/GVLaXaWebUK1tKzTFxr+/ckmrtLa9T9bETKjzS4JVHz3zWuVpkSPqssFJb/5nXLw9Ue8W3t7xOR+qazDxtKqxUfVOL1u09qq0l1TIkbdp3MgdrdpWr8YShQ06Xec7zG4u1Lv+ojh1v0Zqd5a3GK1BuAwn0epRbUu01PwId6z5uU2GlcoqrlFtSHXAu98Tvop4S1AKnvr5eU6dO1cqVK9s8bvXq1friiy+UlJTUS5EBAIC+LKgfUS1cuFALFy5s85iDBw/q9ttv1wcffKBLLrmk3Wu6XC65XN9Vlk6ns8txAgCAviWkv2Tc0tKiG264Qffee68mTpzYoXNWrFghh8NhPpKTk3s4SgAAEGpCusB55JFHFBYWpjvuuKPD5yxdulQ1NTXmo7S0tAcjBAAAoShk/4pq27ZtevLJJ7V9+3bZbLYOn2e322W323swMgAAEOpC9h2czz77TBUVFUpJSVFYWJjCwsJ04MAB3XPPPRo1alSwwwMAACEsZN/BueGGGzRv3jyvbQsWLNANN9ygG2+8MUhReUuIsuvOC9OVkRipOy9MV0KU3Wu7+7nv8b7bT6Wtzpzb1WueStunmpOOtpGRGKlJSdGSTt4Hp7Di5J9Puu+DM2tsnBKi7Do/I14bCys1a2xch66dEGXXTbPTzDZ8j3Ofm5kSo6y0WGUkRrbZz47kxn2s73kZiZEaEz9Ih2oalTU6NmD/MxIjFR95Mm73fXDOHR1r3gfHN9aOxtNWrjzzkBoboYPVx7xyHOjYMfGDWt0Hx19cvu1mpsQoJiIs4H1w2uubL3f+2rsPjmfeMxIjzTzGR3ZsTQea8/1s8rrWwomJ2lBwtNU4t9eHzOQYjR8eZc67sQmDtW5vhTJTYvzG49520+y0VvfByUiM1BXTkrS5qFLnpcep6EideR+crNGxiou0KyMx0jx3UHiYV9+unZGsPYdqW42FZ97akpkSo2HRdvM+OO5re/YzvL9NhRV1XvfByUobYt4Hx3NsMhIjde2MZPM+OO7rudd3ZkqMxiVGet0Hx51Hz3y+lfeN6l0tOm9snML72cz74HjGNy4xUlX1TWaehkaFa0N+Rav74GQkRmrhxESv++BkjY7VwAH9ve6D4ztegXIbSKDXo5O5HWjOj0DHuo+bNTZOVfVNykyJafP1u7t/F/UUm2EYRrAar6urU2FhoSQpMzNTjz/+uM4//3zFxsYqJSWl1fGjRo3SkiVLtGTJkg634XQ65XA4VFNTo+jo6O4KHQAA9KCu/v4O6js4W7du1fnnn28+v/vuuyVJixYt0qpVq4IUFQAA6OuCWuDMnTtXp/IG0v79+3suGAAAYBkh+yVjAACAzqLAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwnE4VOKNHj1ZlZWWr7dXV1Ro9enSXgwIAAOiKThU4+/fvV3Nzc6vtLpdLBw8e7HJQAAAAXRF2Kge/88475s8ffPCBHA6H+by5uVlr167VqFGjui04AACAzjilAufyyy+XJNlsNi1atMhr34ABAzRq1Cg99thj3RYcAABAZ5xSgdPS0iJJSktL05dffqn4+PgeCQoAAKArTqnAcSsuLu7uOAAAALpNhwucp556SosXL9bAgQP11FNPtXnsHXfc0eXAAAAAOstmGIbRkQPT0tK0detWxcXFKS0tLfAFbTYVFRV1W4Bd5XQ65XA4VFNTo+jo6GCHAwAAOqCrv787/A6O58dSfEQFAABCGXcyBgAAltOpLxk3Nzdr1apVWrt2rSoqKsy/rnL75JNPuiU4AACAzuhUgXPnnXdq1apVuuSSSzRp0iTZbLbujgsAAKDTOlXgvPbaa/rLX/6i73//+90dDwAAQJd16js44eHhGjt2bHfHAgAA0C06VeDcc889evLJJ9XBvzAHAADoVZ36iGrjxo1at26d1qxZo4kTJ2rAgAFe+998881uCQ4AAKAzOlXgxMTE6IorrujuWAAAALpFpwqcP//5z90dBwAAQLc5pQJnyJAhfv8k3OFwKCMjQz//+c910UUXdVtwAAAAnXFKBc4TTzzhd3t1dbW2bdumf/mXf9Ebb7yh7OzsDl1vw4YN+sMf/qBt27bp0KFDWr16tS6//HJJ0vHjx/XrX/9af//731VUVCSHw6F58+bp4YcfVlJS0qmEDQAATjOnVOAsWrSozf3Tpk3TihUrOlzg1NfXa+rUqfrpT3+qK6+80mtfQ0ODtm/frgceeEBTp07Vt99+qzvvvFOXXnqptm7deiphAwCA00yH/zXxjsjPz9c555yjqqqqUw/EZvN6B8efL7/8UjNmzNCBAweUkpLSoevyr4kDAND39Nq/Jt4RLpdL4eHh3XlJLzU1NbLZbIqJiWkzBpfLZT53Op09Fg8AAAhN3fqvif/P//yPpk2b1p2XNDU2Nuq+++7TNddc02Ylt2LFCjkcDvORnJzcI/EAAIDQdUrv4Nx9991+t9fU1Gj79u3Kz8/Xhg0buiUwT8ePH9ePf/xjGYahZ555ps1jly5d6hWn0+mkyAEA4DRzSgVObm6u3+3R0dG66KKL9OabbyotLa1bAnNzFzcHDhzQJ5980u7ncHa7XXa7vVtjAAAAfcspFTjr1q3rqTj8chc3BQUFWrduneLi4nq1fQAA0Dd165eMT1VdXZ0KCwvN58XFxcrLy1NsbKyGDx+uH/7wh9q+fbvee+89NTc36/Dhw5Kk2NjYHv0yMwAA6Nu69c/ET9X69et1/vnnt9q+aNEi/eY3vwn4cde6des0d+7cDrXBn4kDAND3hNSfiZ+quXPnqq36Koi1FwAA6MO69c/EAQAAQgEFDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYTlALnA0bNig7O1tJSUmy2Wx66623vPYbhqFly5Zp+PDhioiI0Lx581RQUBCcYAEAQJ8R1AKnvr5eU6dO1cqVK/3uf/TRR/XUU0/p2WefVU5OjgYPHqwFCxaosbGxlyMFAAB9SVgwG1+4cKEWLlzod59hGHriiSf061//Wpdddpkk6cUXX1RiYqLeeustXX311b0ZKgAA6ENC9js4xcXFOnz4sObNm2duczgcysrK0ubNmwOe53K55HQ6vR4AAOD0ErIFzuHDhyVJiYmJXtsTExPNff6sWLFCDofDfCQnJ/donAAAIPSEbIHTWUuXLlVNTY35KC0tDXZIAACgl4VsgTNs2DBJUnl5udf28vJyc58/drtd0dHRXg8AAHB6CdkCJy0tTcOGDdPatWvNbU6nUzk5OZo5c2YQIwMAAKEuqH9FVVdXp8LCQvN5cXGx8vLyFBsbq5SUFC1ZskS/+93vlJ6errS0ND3wwANKSkrS5ZdfHrygAQBAyAtqgbN161adf/755vO7775bkrRo0SKtWrVKv/jFL1RfX6/Fixerurpas2fP1vvvv6+BAwcGK2QAANAH2AzDMIIdRE9yOp1yOByqqanh+zgAAPQRXf39HbLfwQEAAOgsChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlhMW7AD6ugpno57bUCRJWjxntBKiB6rC2aiXc0o0fdQQPfZhvsYPj9L156TqpS8OaM+hWv3+ikmakOTodHsv55TouqwUJUQPbPeYo3UuPfjubt1+wVh9uf9bv+dVOBu14u97tLmoUv/xo6manT5Uu8tq9OC7u7U8e4JXrO7t7ustmJioN7cfNPsvSS/nlGjBxER9sKvcbM8dU02DS6s2lyh+8AANc0To/oVn6Mv932r6qCF6+pNCr/bcbc0dF68nPsrXiWZJNunByybq+nNGefXhpS/269dv7ZIkJQ8ZqP++4Wy/OfaXm+XZExQfaW+V191lNfrV6p2KiQjTtpJv1djUrAh7mM4dE6chg8IlSYPCw7R4zmgdrXPpF2/s0PHmFp2VOkTXn5Oqp9cWaEPBUT38g8nKSotrdf0KZ6P+7aVt2lpSrbB+0kUTEvXgpZPMHE4fNUQPr/laknT/wjO0fu8RNTSdMNv0HMc/vL9HK9cXKclh1/OLpvvtj78cuNsaOMCmP35UoGXZE7xy6zvfPOeFZxuStOLve7T263I1NDbL+Oc4zZ8wzOyLe3zd53muj5lj4vTwmq/1yA+maHb6UK/2fdeXP23FGWgePLehSA1NJ3SsqVn7KxvMdeke94gB/fTVNzX60Vkj9Ndt32hGWqyGOyL0bX2TNu07qqYTLZo5Jk7DHRFeY+Ibi28f3Dn3HZuXvtiv3767W3ddlK7G40ar148PdpWb68q97vZV1OqL4irNHTfUa+54jq3nWvSc8+6+BsqTux+B1rJv/LvLavSLN3ZIkh794RRznH1fIxKiB+rdrw7qF298pZiIcLlOtOh744bqgjMS9PCar3XL3DH627aDam5p0Y6DTnM97ztSp1+++Q89dOVkZU8d4dWu+zXp5S8OmGsue+oIvfTFfj34zi6NHx6tkqoG9e9n028unaivSmvU0HTCHMu6xma1SJqeGqM752WYc/XT/Ar94YN83bsgQz84M9ns99+2l+rR9/M1ZUS0+vXrp5FDBurdHYeVGBWuP984o9XaeOLjfOUUVcrZeEJ/vGqaJOlnL21VnatFSQ67stLiVN3QpM1FlRoWPVBp8YO1s8yp2enxWrpwvPLLa3Xf33Z4rQ/3OByqbtBfth3UT2am6MfTU3Tzi1t1sLpR01NjFB9p1+aiStkkTUuJUUllg8prG3Wi2dDMMXGKiQhXQUWdpox0mGvw+nNStHJdoepcLZo1JlZ/vCpTkrT87Z1an39EmSkxOtbUot9fcXK+/Wr1To0fHqUl8zICrs9gocDpoopal57fWCxJujxzxMkXgFqXnlxboHsuylBuabVyS6s1Iy1Or2wplSTll9d1vsD557UvmpAY+MXe45jCijrlFFdpdkl1wPMqal1anVcmScotqdbs9KHKLz95nm+s7u3u66XFD/bqvyRzu2d77pjGJkRKko7WH9fR+uPK/ed17rkoo1V77rb697PJ1fzPAAxpU2FlqwJnU2Gl+XPpt40Bc+wvN/nldWox1Co/+eV1yi2t9jq/6dgJrdlZ7rXt8swRKqyo084ypyRpb3mdZqTFac2uk8flFFUpLT6y1fUral3aWnLy+idapDU7y3Xr+elmDu+5KMO8Zm5JtZlnd5ue4/jZP/tfVuMK2B9/OXC3de6YODU1G61y6zvfPOeFZxuSzDkkyRynaclDWo2v+zzP9dHPZtPB6kZz/nm277u+/GkrzkDzwDOf0nfr0nfcN+6rUn1Ti9btPdrqOp7bfNe/59z3t0Z8x2ZTYaWamg19VlCpz/dVtnr98FxXnutOaj13PMfWcy16znl3XwPlyd2PQGvZN/788u/WgOc4+75GJEQPVE5RlY4dN3TsuEuStDq3TIPDw3SwulGbCiu98u9ez1v3V6nW1aycoiqvAsfzNclzzWVPHaFNhZU63iLtOOg0j88pqtJLOSWtxlKSvjxQrdySajMnnxVUqsWQPiuo1HnpCWa/PyuolCHpq39e92C1XZJUXtvkd224X/ulk2tZkupcLZJOrlnPtbO/6pj2Vx0z8/Kvs0crt6S61fpwj8PIIRGSTs7TaSmxOljdaPbFk+/89Xy+s8xprsHPCirN2Dbtq1JF7ckxcuf2831VZt4lmXP02qzUkCtw+IgKAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy+HPxLsoIcqum2anmT+7/3vnhenKTIlRZnKMxg+PUkZipK6dkaw9h2qVkRjZpfbuvDDdbKu9Y/rZpKy0WGWmxAQ8LyHKriumJWlzUaUyU2IkSRmJkcpKi20Vq3u7+3oZiZGt+u/e7tmeO6aaBpcKK+rM++C4r5OZEtOqPXdb56XHadv+SvM+OLPGxrXqw6yxcVqz87Ckk/fBCZRjf7nJSIxUfGTrvGYkRiozOabd++C4rzUpKdq8D05GYqQWTkzUhoKjyhod63fcEqLsOjslxus+OJ45zEyJ0aSkaElSZkqMbpqdZt4Hx3cczxsbpx3f1CjJYQ/YH385cLc1cIBNW/dXtcqt77Ge88K3jSumJXndB2fW2DivteB7nuf6yBodq3V7K8z559m+7/xqb1x94wx0vDuf7vvguI91j7v7Pjizx8TqUHVDu/fB8Z3rns/9rRHf/swaG6e1e8p1Xnqcpo+KbfX64bmu3OvO8z44/q7tuxY953x7eXL3I9Ba9o0/IzHSnK+e4+zvNSJrdKz+tr3U6z447jkwa2ycDtc0et0HJyMxUv37SW/nHVTW6NhW7bpfkzzXnDunH+8+7HUfnKzRsRo4oH/A++B4ztXz0uP0RVGlzkuP8+r3eelx2ryv0u99cPytjWtnJJv3wXHP8Uh7vw7dBychyq7MlBiNiBnotT7c8bjvgzN7zMmYR8QM7NR9cNz5Py89Tju++da8D467DwsnJnrdB8c9Z9xztK31GSw2wzCMYAfRk5xOpxwOh2pqahQdHR3scAAAQAd09fc3H1EBAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHIocAAAgOVQ4AAAAMsJ6QKnublZDzzwgNLS0hQREaExY8bo3//932UYRrBDAwAAISws2AG05ZFHHtEzzzyjF154QRMnTtTWrVt14403yuFw6I477gh2eAAAIESFdIHz+eef67LLLtMll1wiSRo1apReffVVbdmyJeA5LpdLLpfLfO50Ons8TgAAEFpC+iOqc889V2vXrlV+fr4k6auvvtLGjRu1cOHCgOesWLFCDofDfCQnJ/dWuAAAIETYjBD+QktLS4t++ctf6tFHH1X//v3V3Nys3//+91q6dGnAc/y9g5OcnKyamhpFR0f3RtgAAKCLnE6nHA5Hp39/h/RHVH/5y1/08ssv65VXXtHEiROVl5enJUuWKCkpSYsWLfJ7jt1ul91u7+VIAQBAKAnpAufee+/V/fffr6uvvlqSNHnyZB04cEArVqwIWOAAAACE9HdwGhoa1K+fd4j9+/dXS0tLkCICAAB9QUi/g5Odna3f//73SklJ0cSJE5Wbm6vHH39cP/3pT4MdGgAACGEh/SXj2tpaPfDAA1q9erUqKiqUlJSka665RsuWLVN4eHiHrtHVLykBAIDe19Xf3yFd4HQHChwAAPqerv7+Dunv4AAAAHQGBQ4AALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HA6WYVzkb98aN8VTgbT4t229PdcYVqPz1VOBv1u/d263fv7Q56nMHKf0+MU0+03Rvzqbva8Hed9q7d2bZDfZ2Fenwd0ZPzoifb66nr9QQKnG5WUevSk2sLVFHrOi3abU93xxWq/fRUUevS8xuL9fzG4qDHGaz898Q49UTbvTGfuqsNf9dp79qdbTvU11mox9cRPTkverK9nrpeT6DAAQAAlkOBAwAALIcCBwAAWA4FDgAAsBwKHAAAYDkUOAAAwHLCgh2A1SRE2XXnhelKiLKfFu22p7vjCtV+ekqIsuum2Wnmz8GOJRj574lx6om2e2M+dVcb/q7T3rU723aor7NQj68jenJe9GR7PXW9nmAzDMMIdhA9yel0yuFwqKamRtHR0cEOBwAAdEBXf3/zERUAALAcChwAAGA5FDgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALIcCBwAAWE7IFzgHDx7U9ddfr7i4OEVERGjy5MnaunVrsMPqUyqcjfrjR/mqcDb2ynld1Va7gfZVOBv1u/d263fv7e4z/Qz1WILJMw/t5aS757fv9p4Yk65cs63cdOa6HT2no20Fiq83Y+2KU2mjs7lra393tt/VfPX116OQLnC+/fZbzZo1SwMGDNCaNWu0e/duPfbYYxoyZEiwQ+tTKmpdenJtgSpqXb1yXle11W6gfRW1Lj2/sVjPbyzuM/0M9ViCyTMP7eWku+e37/aeGJOuXLOt3HTmuh09p6NtBYqvN2PtilNpo7O5a2t/d7bf1Xz19dejsGAH0JZHHnlEycnJ+vOf/2xuS0tLC2JEAACgLwjpd3DeeecdnX322frRj36khIQEZWZm6k9/+lOb57hcLjmdTq8HAAA4vYR0gVNUVKRnnnlG6enp+uCDD3TLLbfojjvu0AsvvBDwnBUrVsjhcJiP5OTkXowYAACEgpAucFpaWnTmmWfqoYceUmZmphYvXqybb75Zzz77bMBzli5dqpqaGvNRWlraixEDAIBQENIFzvDhwzVhwgSvbePHj1dJSUnAc+x2u6Kjo70eAADg9BLSBc6sWbO0d+9er235+flKTU0NUkQAAKAvCOm/orrrrrt07rnn6qGHHtKPf/xjbdmyRc8995yee+65YIfWpyRE2XXnhelKiLL3ynld1Va7gfYlRNl10+w08+fuaq+3hVIsweSbh7Zy0t3z23d7T4xJV67ZVm46c92OntPRvLQVX2/F2hWn0kZnc9fe/u5qv6v56uuvRzbDMIxgB9GW9957T0uXLlVBQYHS0tJ099136+abb+7w+U6nUw6HQzU1NXxcBQBAH9HV398hX+B0FQUOAAB9T1d/f4f0d3AAAAA6gwIHAABYDgUOAACwHAocAABgORQ4AADAcihwAACA5VDgAAAAy6HAAQAAlkOBAwAALCek/y2q7uC+UbPT6QxyJAAAoKPcv7c7+w8uWL7Aqa2tlSQlJycHORIAAHCqamtr5XA4Tvk8y/9bVC0tLSorK1NUVJRsNlu3XdfpdCo5OVmlpaWn/b9xRS6+Qy5OIg/fIRcnkYfvkIvvtJULwzBUW1urpKQk9et36t+osfw7OP369dPIkSN77PrR0dGn/QR1IxffIRcnkYfvkIuTyMN3yMV3AuWiM+/cuPElYwAAYDkUOAAAwHIocDrJbrdr+fLlstvtwQ4l6MjFd8jFSeThO+TiJPLwHXLxnZ7MheW/ZAwAAE4/vIMDAAAshwIHAABYDgUOAACwHAocAABgORQ4nbRy5UqNGjVKAwcOVFZWlrZs2RLskHrUb37zG9lsNq/HGWecYe5vbGzUrbfeqri4OEVGRuoHP/iBysvLgxhx99mwYYOys7OVlJQkm82mt956y2u/YRhatmyZhg8froiICM2bN08FBQVex1RVVem6665TdHS0YmJi9K//+q+qq6vrxV50j/Zy8ZOf/KTVPLn44ou9jrFCLlasWKHp06crKipKCQkJuvzyy7V3716vYzqyJkpKSnTJJZdo0KBBSkhI0L333qsTJ070Zle6pCN5mDt3bqs58bOf/czrmL6eB0l65plnNGXKFPOGdTNnztSaNWvM/afDfHBrLxe9NScocDrh9ddf1913363ly5dr+/btmjp1qhYsWKCKiopgh9ajJk6cqEOHDpmPjRs3mvvuuusuvfvuu/rrX/+qTz/9VGVlZbryyiuDGG33qa+v19SpU7Vy5Uq/+x999FE99dRTevbZZ5WTk6PBgwdrwYIFamxsNI+57rrrtGvXLn300Ud67733tGHDBi1evLi3utBt2suFJF188cVe8+TVV1/12m+FXHz66ae69dZb9cUXX+ijjz7S8ePHNX/+fNXX15vHtLcmmpubdckll6ipqUmff/65XnjhBa1atUrLli0LRpc6pSN5kKSbb77Za048+uij5j4r5EGSRo4cqYcffljbtm3T1q1bdcEFF+iyyy7Trl27JJ0e88GtvVxIvTQnDJyyGTNmGLfeeqv5vLm52UhKSjJWrFgRxKh61vLly42pU6f63VddXW0MGDDA+Otf/2pu27NnjyHJ2Lx5cy9F2DskGatXrzaft7S0GMOGDTP+8Ic/mNuqq6sNu91uvPrqq4ZhGMbu3bsNScaXX35pHrNmzRrDZrMZBw8e7LXYu5tvLgzDMBYtWmRcdtllAc+xai4qKioMScann35qGEbH1sTf//53o1+/fsbhw4fNY5555hkjOjracLlcvduBbuKbB8MwjO9973vGnXfeGfAcK+bBbciQIcbzzz9/2s4HT+5cGEbvzQnewTlFTU1N2rZtm+bNm2du69evn+bNm6fNmzcHMbKeV1BQoKSkJI0ePVrXXXedSkpKJEnbtm3T8ePHvXJyxhlnKCUlxfI5KS4u1uHDh7367nA4lJWVZfZ98+bNiomJ0dlnn20eM2/ePPXr1085OTm9HnNPW79+vRISEjRu3DjdcsstqqysNPdZNRc1NTWSpNjYWEkdWxObN2/W5MmTlZiYaB6zYMECOZ1Or//T7Ut88+D28ssvKz4+XpMmTdLSpUvV0NBg7rNiHpqbm/Xaa6+pvr5eM2fOPG3ng9Q6F269MScs/49tdrejR4+qubnZK/GSlJiYqK+//jpIUfW8rKwsrVq1SuPGjdOhQ4f04IMP6rzzztPOnTt1+PBhhYeHKyYmxuucxMREHT58ODgB9xJ3//zNB/e+w4cPKyEhwWt/WFiYYmNjLZefiy++WFdeeaXS0tK0b98+/fKXv9TChQu1efNm9e/f35K5aGlp0ZIlSzRr1ixNmjRJkjq0Jg4fPux33rj39TX+8iBJ1157rVJTU5WUlKQdO3bovvvu0969e/Xmm29KslYe/vGPf2jmzJlqbGxUZGSkVq9erQkTJigvL++0mw+BciH13pygwEGHLFy40Px5ypQpysrKUmpqqv7yl78oIiIiiJEhlFx99dXmz5MnT9aUKVM0ZswYrV+/XhdeeGEQI+s5t956q3bu3On1nbTTUaA8eH6/avLkyRo+fLguvPBC7du3T2PGjOntMHvUuHHjlJeXp5qaGr3xxhtatGiRPv3002CHFRSBcjFhwoRemxN8RHWK4uPj1b9//1bffi8vL9ewYcOCFFXvi4mJUUZGhgoLCzVs2DA1NTWpurra65jTISfu/rU1H4YNG9bqC+gnTpxQVVWV5fMzevRoxcfHq7CwUJL1cnHbbbfpvffe07p16zRy5Ehze0fWxLBhw/zOG/e+viRQHvzJysqSJK85YZU8hIeHa+zYsTrrrLO0YsUKTZ06VU8++eRpNx+kwLnwp6fmBAXOKQoPD9dZZ52ltWvXmttaWlq0du1ar88Xra6urk779u3T8OHDddZZZ2nAgAFeOdm7d69KSkosn5O0tDQNGzbMq+9Op1M5OTlm32fOnKnq6mpt27bNPOaTTz5RS0uLubCt6ptvvlFlZaWGDx8uyTq5MAxDt912m1avXq1PPvlEaWlpXvs7siZmzpypf/zjH14F30cffaTo6GjzrfxQ114e/MnLy5MkrznR1/MQSEtLi1wu12kzH9rizoU/PTYnOvmF6NPaa6+9ZtjtdmPVqlXG7t27jcWLFxsxMTFe3/i2mnvuucdYv369UVxcbGzatMmYN2+eER8fb1RUVBiGYRg/+9nPjJSUFOOTTz4xtm7dasycOdOYOXNmkKPuHrW1tUZubq6Rm5trSDIef/xxIzc31zhw4IBhGIbx8MMPGzExMcbbb79t7Nixw7jsssuMtLQ049ixY+Y1Lr74YiMzM9PIyckxNm7caKSnpxvXXHNNsLrUaW3lora21vj5z39ubN682SguLjY+/vhj48wzzzTS09ONxsZG8xpWyMUtt9xiOBwOY/369cahQ4fMR0NDg3lMe2vixIkTxqRJk4z58+cbeXl5xvvvv28MHTrUWLp0aTC61Cnt5aGwsND47W9/a2zdutUoLi423n77bWP06NHGnDlzzGtYIQ+GYRj333+/8emnnxrFxcXGjh07jPvvv9+w2WzGhx9+aBjG6TEf3NrKRW/OCQqcTnr66aeNlJQUIzw83JgxY4bxxRdfBDukHnXVVVcZw4cPN8LDw40RI0YYV111lVFYWGjuP3bsmPFv//ZvxpAhQ4xBgwYZV1xxhXHo0KEgRtx91q1bZ0hq9Vi0aJFhGCf/VPyBBx4wEhMTDbvdblx44YXG3r17va5RWVlpXHPNNUZkZKQRHR1t3HjjjUZtbW0QetM1beWioaHBmD9/vjF06FBjwIABRmpqqnHzzTe3KvytkAt/OZBk/PnPfzaP6cia2L9/v7Fw4UIjIiLCiI+PN+655x7j+PHjvdybzmsvDyUlJcacOXOM2NhYw263G2PHjjXuvfdeo6amxus6fT0PhmEYP/3pT43U1FQjPDzcGDp0qHHhhReaxY1hnB7zwa2tXPTmnLAZhmF0/P0eAACA0Md3cAAAgOVQ4AAAAMuhwAEAAJZDgQMAACyHAgcAAFgOBQ4AALAcChwAAGA5FDgAAMByKHAA9Lqf/OQnuvzyy4PW/g033KCHHnqoQ8deffXVeuyxx3o4IgDdjTsZA+hWNputzf3Lly/XXXfdJcMwFBMT0ztBefjqq690wQUX6MCBA4qMjGz3+J07d2rOnDkqLi6Ww+HohQgBdAcKHADd6vDhw+bPr7/+upYtW6a9e/ea2yIjIztUWPSUm266SWFhYXr22Wc7fM706dP1k5/8RLfeemsPRgagO/ERFYBuNWzYMPPhcDhks9m8tkVGRrb6iGru3Lm6/fbbtWTJEg0ZMkSJiYn605/+pPr6et14442KiorS2LFjtWbNGq+2du7cqYULFyoyMlKJiYm64YYbdPTo0YCxNTc364033lB2drbX9v/6r/9Senq6Bg4cqMTERP3whz/02p+dna3XXnut68kB0GsocACEhBdeeEHx8fHasmWLbr/9dt1yyy360Y9+pHPPPVfbt2/X/PnzdcMNN6ihoUGSVF1drQsuuECZmZnaunWr3n//fZWXl+vHP/5xwDZ27NihmpoanX322ea2rVu36o477tBvf/tb7d27V++//77mzJnjdd6MGTO0ZcsWuVyunuk8gG5HgQMgJEydOlW//vWvlZ6erqVLl2rgwIGKj4/XzTffrPT0dC1btkyVlZXasWOHJOk///M/lZmZqYceekhnnHGGMjMz9b//+79at26d8vPz/bZx4MAB9e/fXwkJCea2kpISDR48WP/yL/+i1NRUZWZm6o477vA6LykpSU1NTV4fvwEIbRQ4AELClClTzJ/79++vuLg4TZ482dyWmJgoSaqoqJB08svC69atM7/TExkZqTPOOEOStG/fPr9tHDt2THa73euL0BdddJFSU1M1evRo3XDDDXr55ZfNd4ncIiIiJKnVdgChiwIHQEgYMGCA13Obzea1zV2UtLS0SJLq6uqUnZ2tvLw8r0dBQUGrj5jc4uPj1dDQoKamJnNbVFSUtm/frldffVXDhw/XsmXLNHXqVFVXV5vHVFVVSZKGDh3aLX0F0PMocAD0SWeeeaZ27dqlUaNGaezYsV6PwYMH+z1n2rRpkqTdu3d7bQ8LC9O8efP06KOPaseOHdq/f78++eQTc//OnTs1cuRIxcfH91h/AHQvChwAfdKtt96qqqoqXXPNNfryyy+1b98+ffDBB7rxxhvV3Nzs95yhQ4fqzDPP1MaNG81t7733np566inl5eXpwIEDevHFF9XS0qJx48aZx3z22WeaP39+j/cJQPehwAHQJyUlJWnTpk1qbm7W/PnzNXnyZC1ZskQxMTHq1y/wS9tNN92kl19+2XweExOjN998UxdccIHGjx+vZ599Vq+++qomTpwoSWpsbNRbb72lm2++ucf7BKD7cKM/AKeVY8eOady4cXr99dc1c+bMdo9/5plntHr1an344Ye9EB2A7sI7OABOKxEREXrxxRfbvCGgpwEDBujpp5/u4agAdDfewQEAAJbDOzgAAMByKHAAAIDlUOAAAADLocABAACWQ4EDAAAshwIHAABYDgUOAACwHAocAABgORQ4AADAcv4/4rIQegvxjTEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -2502,7 +2436,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -2514,7 +2448,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -2524,7 +2458,6 @@ " 'session_datetime': datetime.datetime(2023, 1, 1, 0, 0),\n", " 'insertion_number': 1,\n", " 'paramset_idx': 0,\n", - " 'curation_id': 1,\n", " 'unit': 15,\n", " 'electrode_config_hash': UUID('8d4cc6d8-a02d-42c8-bf27-7459c39ea0ee'),\n", " 'probe_type': 'neuropixels 1.0 - 3A',\n", @@ -2718,7 +2651,7 @@ " -484.26530394, -483.3984375 ])}" ] }, - "execution_count": 38, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -2729,12 +2662,12 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2802,13 +2735,6 @@ "\n", "+ Run the code block above and proceed with the rest of the notebook." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 9c033c4f355a831dabb8537cfb12dba76c8badab Mon Sep 17 00:00:00 2001 From: JaerongA Date: Thu, 21 Mar 2024 23:30:09 +0000 Subject: [PATCH 4/6] tested version of pytest suite --- tests/conftest.py | 65 ++++++++++-------- tests/test_pipeline.py | 132 +++++++++++++++++++++++++++++++++++++ tests/tutorial_pipeline.py | 2 +- 3 files changed, 171 insertions(+), 28 deletions(-) create mode 100644 tests/test_pipeline.py diff --git a/tests/conftest.py b/tests/conftest.py index 4aa6241b..9a191749 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -24,12 +24,13 @@ def dj_config(): "database.user": os.environ.get("DJ_USER") or dj.config["database.user"], } ) + os.environ["DATABASE_PREFIX"] = "test_" return @pytest.fixture(autouse=True, scope="session") def pipeline(): - import tutorial_pipeline as pipeline + from . import tutorial_pipeline as pipeline yield { "lab": pipeline.lab, @@ -37,11 +38,17 @@ def pipeline(): "session": pipeline.session, "probe": pipeline.probe, "ephys": pipeline.ephys, + "ephys_report": pipeline.ephys_report, "get_ephys_root_data_dir": pipeline.get_ephys_root_data_dir, } if _tear_down: - pipeline.subject.Subject.delete() + pipeline.ephys_report.schema.drop() + pipeline.ephys.schema.drop() + pipeline.probe.schema.drop() + pipeline.session.schema.drop() + pipeline.subject.schema.drop() + pipeline.lab.schema.drop() @pytest.fixture(scope="session") @@ -53,37 +60,46 @@ def insert_upstreams(pipeline): ephys = pipeline["ephys"] subject.Subject.insert1( - dict(subject="subject5", subject_birth_date="2023-01-01", sex="U") + dict(subject="subject5", subject_birth_date="2023-01-01", sex="U"), + skip_duplicates=True, ) session_key = dict(subject="subject5", session_datetime="2023-01-01 00:00:00") + session.Session.insert1(session_key, skip_duplicates=True) session_dir = "raw/subject5/session1" - session.SessionDirectory.insert1(dict(**session_key, session_dir=session_dir)) - probe.Probe.insert1(dict(probe="714000838", probe_type="neuropixels 1.0 - 3B")) + session.SessionDirectory.insert1( + dict(**session_key, session_dir=session_dir), skip_duplicates=True + ) + probe.Probe.insert1( + dict(probe="714000838", probe_type="neuropixels 1.0 - 3B"), skip_duplicates=True + ) ephys.ProbeInsertion.insert1( dict( - session_key, + **session_key, insertion_number=1, probe="714000838", - ) + ), + skip_duplicates=True, ) - yield - if _tear_down: - subject.Subject.delete() - probe.Probe.delete() + return @pytest.fixture(scope="session") -def populate_ephys_recording(pipeline, insert_upstream): +def populate_ephys_recording(pipeline, insert_upstreams): ephys = pipeline["ephys"] ephys.EphysRecording.populate() - yield + return - if _tear_down: - ephys.EphysRecording.delete() + +@pytest.fixture(scope="session") +def populate_lfp(pipeline, insert_upstreams): + ephys = pipeline["ephys"] + ephys.LFP.populate() + + return @pytest.fixture(scope="session") @@ -129,25 +145,20 @@ def insert_clustering_task(pipeline, populate_ephys_recording): paramset_idx=0, task_mode="load", # load or trigger clustering_output_dir="processed/subject5/session1/probe_1/kilosort2-5_1", - ) + ), + skip_duplicates=True, ) - yield - - if _tear_down: - ephys.ClusteringParamSet.delete() + return @pytest.fixture(scope="session") -def processing(pipeline, populate_ephys_recording): +def processing(pipeline, insert_clustering_task): ephys = pipeline["ephys"] + ephys.Clustering.populate() ephys.CuratedClustering.populate() - ephys.LFP.populate() ephys.WaveformSet.populate() + ephys.QualityMetrics.populate() - yield - - if _tear_down: - ephys.CuratedClustering.delete() - ephys.LFP.delete() + return diff --git a/tests/test_pipeline.py b/tests/test_pipeline.py new file mode 100644 index 00000000..fe809ccc --- /dev/null +++ b/tests/test_pipeline.py @@ -0,0 +1,132 @@ +import numpy as np +import pandas as pd +import datetime +from uuid import UUID + + +def test_generate_pipeline(pipeline): + subject = pipeline["subject"] + session = pipeline["session"] + ephys = pipeline["ephys"] + probe = pipeline["probe"] + + # test elements connection from lab, subject to Session + assert subject.Subject.full_table_name in session.Session.parents() + + # test elements connection from Session to probe, ephys, ephys_report + assert session.Session.full_table_name in ephys.ProbeInsertion.parents() + assert probe.Probe.full_table_name in ephys.ProbeInsertion.parents() + assert "spike_times" in (ephys.CuratedClustering.Unit.heading.secondary_attributes) + + +def test_insert_upstreams(pipeline, insert_upstreams): + """Check number of subjects inserted into the `subject.Subject` table""" + subject = pipeline["subject"] + session = pipeline["session"] + probe = pipeline["probe"] + ephys = pipeline["ephys"] + + assert len(subject.Subject()) == 1 + assert len(session.Session()) == 1 + assert len(probe.Probe()) == 1 + assert len(ephys.ProbeInsertion()) == 1 + + +def test_populate_ephys_recording(pipeline, populate_ephys_recording): + ephys = pipeline["ephys"] + + assert ephys.EphysRecording.fetch1() == { + "subject": "subject5", + "session_datetime": datetime.datetime(2023, 1, 1, 0, 0), + "insertion_number": 1, + "electrode_config_hash": UUID("8d4cc6d8-a02d-42c8-bf27-7459c39ea0ee"), + "acq_software": "SpikeGLX", + "sampling_rate": 30000.0, + "recording_datetime": datetime.datetime(2018, 7, 3, 20, 32, 28), + "recording_duration": 338.666, + } + assert ( + ephys.EphysRecording.EphysFile.fetch1("file_path") + == "raw/subject5/session1/probe_1/npx_g0_t0.imec.ap.meta" + ) + + +def test_populate_lfp(pipeline, populate_lfp): + ephys = pipeline["ephys"] + + assert np.mean(ephys.LFP.fetch1("lfp_mean")) == -716.0220556825378 + assert len((ephys.LFP.Electrode).fetch("electrode")) == 43 + + +def test_insert_clustering_task(pipeline, insert_clustering_task): + ephys = pipeline["ephys"] + + assert ephys.ClusteringParamSet.fetch1("param_set_hash") == UUID( + "de78cee1-526f-319e-b6d5-8a2ba04963d8" + ) + + assert ephys.ClusteringTask.fetch1() == { + "subject": "subject5", + "session_datetime": datetime.datetime(2023, 1, 1, 0, 0), + "insertion_number": 1, + "paramset_idx": 0, + "clustering_output_dir": "processed/subject5/session1/probe_1/kilosort2-5_1", + "task_mode": "load", + } + + +def test_processing(pipeline, processing): + + ephys = pipeline["ephys"] + + # test ephys.CuratedClustering + assert len(ephys.CuratedClustering.Unit & 'cluster_quality_label = "good"') == 176 + assert np.sum(ephys.CuratedClustering.Unit.fetch("spike_count")) == 328167 + # test ephys.WaveformSet + waveforms = np.vstack( + (ephys.WaveformSet.PeakWaveform).fetch("peak_electrode_waveform") + ) + assert waveforms.shape == (227, 82) + + # test ephys.QualityMetrics + cluster_df = (ephys.QualityMetrics.Cluster).fetch(format="frame", order_by="unit") + waveform_df = (ephys.QualityMetrics.Waveform).fetch(format="frame", order_by="unit") + test_df = pd.concat([cluster_df, waveform_df], axis=1).reset_index() + test_value = test_df.select_dtypes(include=[np.number]).mean().values + + assert np.allclose( + test_value, + np.array( + [ + 1.00000000e00, + 0.00000000e00, + 1.13000000e02, + 4.26880089e00, + 1.24162431e00, + 7.17929515e-01, + 4.41633793e-01, + 3.08736082e-01, + 1.24039274e15, + 1.66763828e-02, + 4.33231948e00, + 7.12304747e-01, + 1.48995215e-02, + 7.73432472e-02, + 5.06451613e00, + 7.79528634e00, + 6.30182452e-01, + 1.19562726e02, + 7.90175419e-01, + np.nan, + 8.78436780e-01, + 1.08028193e-01, + -5.19418717e-02, + 2.36035242e02, + 7.48443665e-02, + 2.77550214e-02, + ] + ), + rtol=1e-03, + atol=1e-03, + equal_nan=True, + ) diff --git a/tests/tutorial_pipeline.py b/tests/tutorial_pipeline.py index 8f4ed7f7..fc92280b 100644 --- a/tests/tutorial_pipeline.py +++ b/tests/tutorial_pipeline.py @@ -3,7 +3,7 @@ import datajoint as dj from element_animal import subject from element_animal.subject import Subject -from element_array_ephys import probe, ephys_no_curation as ephys +from element_array_ephys import probe, ephys_no_curation as ephys, ephys_report from element_lab import lab from element_lab.lab import Lab, Location, Project, Protocol, Source, User from element_lab.lab import Device as Equipment From a3426ebe9d9b03f61bef231c17032d5ad2e5c8cd Mon Sep 17 00:00:00 2001 From: JaerongA Date: Fri, 22 Mar 2024 15:20:51 -0500 Subject: [PATCH 5/6] update CHANGELOG.md & bump version --- CHANGELOG.md | 6 ++++++ element_array_ephys/version.py | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d7a52a9e..5e45e427 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,12 @@ Observes [Semantic Versioning](https://semver.org/spec/v2.0.0.html) standard and [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) convention. +## [0.3.4] - 2024-03-22 + ++ Add - pytest ++ Update - Ephys schema changed from `ephys_acute` to `ephys_no_curation` in `tutorial.ipynb` + + ## [0.3.3] - 2024-01-24 + Update - remove PyPi release from `release.yml` since it will fail after the new `setup.py` diff --git a/element_array_ephys/version.py b/element_array_ephys/version.py index 6cbf68b9..769086f3 100644 --- a/element_array_ephys/version.py +++ b/element_array_ephys/version.py @@ -1,2 +1,2 @@ """Package metadata.""" -__version__ = "0.3.3" +__version__ = "0.3.4" From 333f4118ecbf3eee348fa3671b7da3249302167b Mon Sep 17 00:00:00 2001 From: JaerongA Date: Fri, 22 Mar 2024 20:33:42 +0000 Subject: [PATCH 6/6] apply black formatting --- element_array_ephys/ephys_acute.py | 20 ++++++++++++-------- element_array_ephys/ephys_chronic.py | 20 ++++++++++++-------- element_array_ephys/ephys_no_curation.py | 8 +++++--- element_array_ephys/ephys_precluster.py | 20 ++++++++++++-------- element_array_ephys/ephys_report.py | 8 +++++--- element_array_ephys/probe.py | 1 + element_array_ephys/version.py | 1 + 7 files changed, 48 insertions(+), 30 deletions(-) diff --git a/element_array_ephys/ephys_acute.py b/element_array_ephys/ephys_acute.py index 0a213db8..c2627fc9 100644 --- a/element_array_ephys/ephys_acute.py +++ b/element_array_ephys/ephys_acute.py @@ -1044,9 +1044,11 @@ def make(self, key): spike_time_key = ( "spike_times_sec_adj" if "spike_times_sec_adj" in kilosort_dataset.data - else "spike_times_sec" - if "spike_times_sec" in kilosort_dataset.data - else "spike_times" + else ( + "spike_times_sec" + if "spike_times_sec" in kilosort_dataset.data + else "spike_times" + ) ) spike_times = kilosort_dataset.data[spike_time_key] kilosort_dataset.extract_spike_depths() @@ -1081,11 +1083,13 @@ def make(self, key): "spike_sites": spike_sites[ kilosort_dataset.data["spike_clusters"] == unit ], - "spike_depths": spike_depths[ - kilosort_dataset.data["spike_clusters"] == unit - ] - if spike_depths is not None - else None, + "spike_depths": ( + spike_depths[ + kilosort_dataset.data["spike_clusters"] == unit + ] + if spike_depths is not None + else None + ), } ) diff --git a/element_array_ephys/ephys_chronic.py b/element_array_ephys/ephys_chronic.py index 10a492fd..772e885f 100644 --- a/element_array_ephys/ephys_chronic.py +++ b/element_array_ephys/ephys_chronic.py @@ -973,9 +973,11 @@ def make(self, key): spike_time_key = ( "spike_times_sec_adj" if "spike_times_sec_adj" in kilosort_dataset.data - else "spike_times_sec" - if "spike_times_sec" in kilosort_dataset.data - else "spike_times" + else ( + "spike_times_sec" + if "spike_times_sec" in kilosort_dataset.data + else "spike_times" + ) ) spike_times = kilosort_dataset.data[spike_time_key] kilosort_dataset.extract_spike_depths() @@ -1010,11 +1012,13 @@ def make(self, key): "spike_sites": spike_sites[ kilosort_dataset.data["spike_clusters"] == unit ], - "spike_depths": spike_depths[ - kilosort_dataset.data["spike_clusters"] == unit - ] - if spike_depths is not None - else None, + "spike_depths": ( + spike_depths[ + kilosort_dataset.data["spike_clusters"] == unit + ] + if spike_depths is not None + else None + ), } ) diff --git a/element_array_ephys/ephys_no_curation.py b/element_array_ephys/ephys_no_curation.py index 4d052169..856ddfeb 100644 --- a/element_array_ephys/ephys_no_curation.py +++ b/element_array_ephys/ephys_no_curation.py @@ -988,9 +988,11 @@ def make(self, key): spike_time_key = ( "spike_times_sec_adj" if "spike_times_sec_adj" in kilosort_dataset.data - else "spike_times_sec" - if "spike_times_sec" in kilosort_dataset.data - else "spike_times" + else ( + "spike_times_sec" + if "spike_times_sec" in kilosort_dataset.data + else "spike_times" + ) ) spike_times = kilosort_dataset.data[spike_time_key] kilosort_dataset.extract_spike_depths() diff --git a/element_array_ephys/ephys_precluster.py b/element_array_ephys/ephys_precluster.py index 8c573a4c..4d52c610 100644 --- a/element_array_ephys/ephys_precluster.py +++ b/element_array_ephys/ephys_precluster.py @@ -962,9 +962,11 @@ def make(self, key): spike_time_key = ( "spike_times_sec_adj" if "spike_times_sec_adj" in kilosort_dataset.data - else "spike_times_sec" - if "spike_times_sec" in kilosort_dataset.data - else "spike_times" + else ( + "spike_times_sec" + if "spike_times_sec" in kilosort_dataset.data + else "spike_times" + ) ) spike_times = kilosort_dataset.data[spike_time_key] kilosort_dataset.extract_spike_depths() @@ -999,11 +1001,13 @@ def make(self, key): "spike_sites": spike_sites[ kilosort_dataset.data["spike_clusters"] == unit ], - "spike_depths": spike_depths[ - kilosort_dataset.data["spike_clusters"] == unit - ] - if spike_depths is not None - else None, + "spike_depths": ( + spike_depths[ + kilosort_dataset.data["spike_clusters"] == unit + ] + if spike_depths is not None + else None + ), } ) diff --git a/element_array_ephys/ephys_report.py b/element_array_ephys/ephys_report.py index ce8f6cad..48bcf613 100644 --- a/element_array_ephys/ephys_report.py +++ b/element_array_ephys/ephys_report.py @@ -75,9 +75,11 @@ def make(self, key): fig_prefix = ( "-".join( [ - v.strftime("%Y%m%d%H%M%S") - if isinstance(v, datetime.datetime) - else str(v) + ( + v.strftime("%Y%m%d%H%M%S") + if isinstance(v, datetime.datetime) + else str(v) + ) for v in key.values() ] ) diff --git a/element_array_ephys/probe.py b/element_array_ephys/probe.py index f0aa4ddd..d1fa59c6 100644 --- a/element_array_ephys/probe.py +++ b/element_array_ephys/probe.py @@ -1,6 +1,7 @@ """ Neuropixels Probes """ + import datajoint as dj from .readers import probe_geometry diff --git a/element_array_ephys/version.py b/element_array_ephys/version.py index 769086f3..148bac24 100644 --- a/element_array_ephys/version.py +++ b/element_array_ephys/version.py @@ -1,2 +1,3 @@ """Package metadata.""" + __version__ = "0.3.4"