From 14ee56f6a5555752d9cf0c6f16a991c2f8aadaa6 Mon Sep 17 00:00:00 2001 From: pbouss Date: Tue, 15 Sep 2020 12:08:46 +0200 Subject: [PATCH 01/78] bug fixed dealing with units --- elephant/spike_train_surrogates.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index fb09bc445..2506e232b 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -1351,14 +1351,14 @@ def surrogates( bin_size = kwargs['bin_size'] binned_spiketrain = conv.BinnedSpikeTrain( spiketrain, bin_size=bin_size) - bin_grid = binned_spiketrain.bin_centers.magnitude + bin_grid = binned_spiketrain.bin_centers.simplified.magnitude max_displacement = int( - dt.rescale(pq.ms).magnitude / bin_size.rescale(pq.ms).magnitude) + dt.simplified.magnitude / bin_size.simplified.magnitude) binned_surrogates = method( binned_spiketrain, max_displacement, n_surrogates=n_surrogates) surrogate_spiketrains = [neo.SpikeTrain( bin_grid[binned_surrogate.to_bool_array()[0]] - + spiketrain.t_start.magnitude, + + spiketrain.t_start.simplified.magnitude, t_start=spiketrain.t_start, t_stop=spiketrain.t_stop, units=spiketrain.units) From 4160ca0a7940721f29d89341c96ff3d14685724e Mon Sep 17 00:00:00 2001 From: pbouss Date: Tue, 15 Sep 2020 14:51:59 +0200 Subject: [PATCH 02/78] fixed same unit error in trial shuffling --- elephant/spike_train_surrogates.py | 1 + 1 file changed, 1 insertion(+) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index 2506e232b..7b852c0ac 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -1205,6 +1205,7 @@ def _trial_shifting_of_concatenated_spiketrain( t_stop = spiketrain.t_stop.simplified.magnitude trial_length = trial_length.simplified.magnitude trial_separation = trial_separation.simplified.magnitude + dither = dither.simplified.magnitude n_trials = int((t_stop - t_start) // (trial_length + trial_separation)) t_starts = t_start + \ np.arange(n_trials) * (trial_length + trial_separation) From 1e9132b87cb07c9c67b0ae33bbf3e7626f888517 Mon Sep 17 00:00:00 2001 From: stellalessandra Date: Fri, 18 Sep 2020 12:32:48 +0200 Subject: [PATCH 03/78] added Bielefeld fim.so and adapted filtering and added window param to fpgrowth --- elephant/spade.py | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/elephant/spade.py b/elephant/spade.py index 6b3c10777..ba9332d4f 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -866,13 +866,14 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, zmin=min_z, zmax=max_z, report='a', - algo='s') + algo='s', + winlen=winlen) break else: fpgrowth_output = [(tuple(transactions[0]), len(transactions))] # Applying min/max conditions and computing extent (window positions) - fpgrowth_output = [concept for concept in fpgrowth_output - if _fpgrowth_filter(concept, winlen, max_c, min_neu)] + # fpgrowth_output = [concept for concept in fpgrowth_output + # if _fpgrowth_filter(concept, winlen, max_c, min_neu)] # filter out subsets of patterns that are found as a side-effect # of using the moving window strategy fpgrowth_output = _filter_for_moving_window_subsets( @@ -920,18 +921,18 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, return spectrum -def _fpgrowth_filter(concept, winlen, max_c, min_neu): - """ - Filter for selecting closed frequent items set with a minimum number of - neurons and a maximum number of occurrences and first spike in the first - bin position - """ - intent = np.array(concept[0]) - keep_concept = (min(intent % winlen) == 0 - and concept[1] <= max_c - and np.unique(intent // winlen).shape[0] >= min_neu - ) - return keep_concept +# def _fpgrowth_filter(concept, winlen, max_c, min_neu): +# """ +# Filter for selecting closed frequent items set with a minimum number of +# neurons and a maximum number of occurrences and first spike in the first +# bin position +# """ +# intent = np.array(concept[0]) +# keep_concept = (min(intent % winlen) == 0 +# and concept[1] <= max_c +# and np.unique(intent // winlen).shape[0] >= min_neu +# ) +# return keep_concept def _rereference_to_last_spike(transactions, winlen): From e534c706940370ebb55c0db6f3ade7afb4eff7e4 Mon Sep 17 00:00:00 2001 From: stellalessandra Date: Fri, 18 Sep 2020 16:38:44 +0200 Subject: [PATCH 04/78] removed max_occ test --- elephant/test/test_spade.py | 43 +++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index d1d7c8f3a..e71c78a9c 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -275,27 +275,28 @@ def test_parameters(self): for lags in lags_msip_max_spikes], [True] * len(lags_msip_max_spikes)) - # test max_occ parameter - output_msip_max_occ = spade.spade( - self.msip, - self.bin_size, - self.winlen, - max_occ=self.max_occ, - approx_stab_pars=dict( - n_subsets=self.n_subset), - n_surr=self.n_surr, - alpha=self.alpha, - psr_param=self.psr_param, - stat_corr='no', - output_format='patterns')['patterns'] - # collect spade output - occ_msip_max_occ = [] - for out in output_msip_max_occ: - occ_msip_max_occ.append(list(out['times'].magnitude)) - occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) - # test occurrences time - assert_array_equal(occ_msip_max_occ, [ - occ for occ in self.occ_msip if len(occ) <= self.max_occ]) + # TODO: ask Florian if it is possible to fix this + # # test max_occ parameter + # output_msip_max_occ = spade.spade( + # self.msip, + # self.bin_size, + # self.winlen, + # max_occ=self.max_occ, + # approx_stab_pars=dict( + # n_subsets=self.n_subset), + # n_surr=self.n_surr, + # alpha=self.alpha, + # psr_param=self.psr_param, + # stat_corr='no', + # output_format='patterns')['patterns'] + # # collect spade output + # occ_msip_max_occ = [] + # for out in output_msip_max_occ: + # occ_msip_max_occ.append(list(out['times'].magnitude)) + # occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) + # # test occurrences time + # assert_array_equal(occ_msip_max_occ, [ + # occ for occ in self.occ_msip if len(occ) <= self.max_occ]) # test to compare the python and the C implementation of FIM # skip this test if C code not available From 3f1d2ac9907f3a849fedb012d542d1e2a64c57f9 Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 21 Sep 2020 19:38:49 +0200 Subject: [PATCH 05/78] further unit stuff --- elephant/spike_train_surrogates.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index 7b852c0ac..62463bb92 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -1349,17 +1349,15 @@ def surrogates( return _trial_shifting_of_concatenated_spiketrain( spiketrain, dither=dt, n_surrogates=n_surrogates, **kwargs) if method is bin_shuffling: - bin_size = kwargs['bin_size'] binned_spiketrain = conv.BinnedSpikeTrain( - spiketrain, bin_size=bin_size) + spiketrain, bin_size=kwargs['bin_size']) bin_grid = binned_spiketrain.bin_centers.simplified.magnitude max_displacement = int( - dt.simplified.magnitude / bin_size.simplified.magnitude) + dt.simplified.magnitude / kwargs['bin_size'].simplified.magnitude) binned_surrogates = method( binned_spiketrain, max_displacement, n_surrogates=n_surrogates) surrogate_spiketrains = [neo.SpikeTrain( - bin_grid[binned_surrogate.to_bool_array()[0]] - + spiketrain.t_start.simplified.magnitude, + bin_grid[binned_surrogate.to_bool_array()[0]] * pq.s, t_start=spiketrain.t_start, t_stop=spiketrain.t_stop, units=spiketrain.units) From 929e202ef017b85b63ce2f2e3f32b128fcc40b3d Mon Sep 17 00:00:00 2001 From: stellalessandra Date: Tue, 9 Feb 2021 14:14:51 +0100 Subject: [PATCH 06/78] debugging for new fim version --- elephant/test/test_spade.py | 40 +++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index c2f234a58..7650fb7b8 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -308,6 +308,8 @@ def test_fpgrowth_fca(self): mining_results_fpg = spade._fpgrowth( transactions, rel_matrix=rel_matrix) + print('#################################################################') + print('mining results fpg',mining_results_fpg) # mining the data with C fim mining_results_ffca = spade._fast_fca(context) @@ -699,25 +701,25 @@ def test_signature_significance_fdr_bh_corr(self): alpha=0.15, winlen=1, corr='fdr_bh') self.assertEqual(sig_spectrum, [(2., 3., False), (2., 4., True)]) - def test_different_surrogate_method(self): - np.random.seed(0) - random.seed(0) - spiketrains = [stg.homogeneous_poisson_process(rate=20*pq.Hz) - for _ in range(2)] - surr_methods = ('dither_spikes', 'joint_isi_dithering', - 'bin_shuffling', - 'dither_spikes_with_refractory_period') - pv_specs = {'dither_spikes': [[2, 2, 0.8], [2, 3, 0.2]], - 'joint_isi_dithering': [[2, 2, 0.8]], - 'bin_shuffling': [[2, 2, 1.0], [2, 3, 0.2]], - 'dither_spikes_with_refractory_period': - [[2, 2, 0.8]]} - for surr_method in surr_methods: - pv_spec = spade.pvalue_spectrum( - spiketrains, bin_size=self.bin_size, - winlen=self.winlen, dither=15*pq.ms, - n_surr=5, surr_method=surr_method) - self.assertEqual(pv_spec, pv_specs[surr_method]) + # def test_different_surrogate_method(self): + # np.random.seed(0) + # random.seed(0) + # spiketrains = [stg.homogeneous_poisson_process(rate=20*pq.Hz) + # for _ in range(2)] + # surr_methods = ('dither_spikes', 'joint_isi_dithering', + # 'bin_shuffling', + # 'dither_spikes_with_refractory_period') + # pv_specs = {'dither_spikes': [[2, 2, 0.8], [2, 3, 0.2]], + # 'joint_isi_dithering': [[2, 2, 0.8]], + # 'bin_shuffling': [[2, 2, 1.0], [2, 3, 0.2]], + # 'dither_spikes_with_refractory_period': + # [[2, 2, 0.8]]} + # for surr_method in surr_methods: + # pv_spec = spade.pvalue_spectrum( + # spiketrains, bin_size=self.bin_size, + # winlen=self.winlen, dither=15*pq.ms, + # n_surr=5, surr_method=surr_method) + # self.assertEqual(pv_spec, pv_specs[surr_method]) def suite(): From 4bb029f024153355ba87ba739b36f7e284e4e1c0 Mon Sep 17 00:00:00 2001 From: stellalessandra Date: Wed, 17 Feb 2021 11:14:58 +0100 Subject: [PATCH 07/78] enabled multithreading in fpgrowth --- elephant/spade.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/elephant/spade.py b/elephant/spade.py index 901118763..eee9282eb 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -898,7 +898,8 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, zmax=max_z, report='a', algo='s', - winlen=winlen) + winlen=winlen, + threads=0) break else: fpgrowth_output = [(tuple(transactions[0]), len(transactions))] From bc8bf9f1e2ebd66d00d22633cd577936dd2a6032 Mon Sep 17 00:00:00 2001 From: stellalessandra Date: Wed, 17 Feb 2021 18:24:34 +0100 Subject: [PATCH 08/78] less verbose in spade --- elephant/spade.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/elephant/spade.py b/elephant/spade.py index eee9282eb..4dac99533 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -899,7 +899,8 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, report='a', algo='s', winlen=winlen, - threads=0) + threads=0, + verbose=4) break else: fpgrowth_output = [(tuple(transactions[0]), len(transactions))] From 1f40cd806f09c5eaa2868bbf639f175c11cee0bf Mon Sep 17 00:00:00 2001 From: pbouss Date: Fri, 26 Mar 2021 17:13:10 +0100 Subject: [PATCH 09/78] added correction factor to rate estimation --- elephant/statistics.py | 35 +++++++++++++++++++++++++++++++- elephant/test/test_statistics.py | 7 ++++++- 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 9bfdc154d..b3d8cd603 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -73,6 +73,7 @@ import numpy as np import quantities as pq import scipy.stats +from scipy.special import erf import elephant.conversion as conv import elephant.kernels as kernels @@ -600,7 +601,7 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): @deprecated_alias(spiketrain='spiketrains') def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, - center_kernel=True): + center_kernel=True, boundary_correction=False): """ Estimates instantaneous firing rate by kernel convolution. @@ -623,6 +624,9 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', rate estimation. Currently implemented kernel forms are rectangular, triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. + # TODO: The implementation is actually that of Shinomoto. + # The one of Shimazaki is NOT implemented in elephant. + # As it is now it is highly misleading! If 'auto', the optimized kernel width for the rate estimation is calculated according to :cite:`statistics-Shimazaki2010_171` and with this width a gaussian kernel is constructed. Automatized calculation @@ -664,6 +668,10 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. Default: True + boundary_correction : bool, optional + Apply the boundary correction as introduced in + Stella, Bouss et al. (2021) to be submitted. + Default: False Returns ------- @@ -765,6 +773,12 @@ def optimal_kernel(st): "instantaneous rate from input data.") return kernels.GaussianKernel(width_sigma * st.units) + if boundary_correction and not \ + (kernel=='auto' or isinstance(kernel, kernels.GaussianKernel)): + raise ValueError( + 'The boundary correction is only implemented' + ' for Gaussian kernels.') + if isinstance(spiketrains, neo.SpikeTrain): if kernel == 'auto': kernel = optimal_kernel(spiketrains) @@ -898,6 +912,25 @@ def optimal_kernel(st): units=pq.Hz, t_start=t_start, t_stop=t_stop, kernel=kernel_annotation) + if boundary_correction: + sigma = kernel.sigma.simplified.magnitude + times = rate.times.simplified.magnitude + correction_factor = 2 / ( + erf((t_stop.simplified.magnitude - times) / ( + np.sqrt(2.) * sigma)) + - erf((t_start.simplified.magnitude - times) / ( + np.sqrt(2.) * sigma))) + + # multiply with correction factor for stationary rate as described in + # Stella, Bouss et al. (2021) + rate *= correction_factor[:, None] + + duration = t_stop.simplified.magnitude - t_start.simplified.magnitude + # ensure integral over firing rate yield the exact number of spikes + for i, spiketrain in enumerate(spiketrains): + rate[:, i] *= len(spiketrain) / (np.mean(rate[:, i]).magnitude * duration) + + return rate diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index d40ae027c..911d75c65 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -580,6 +580,9 @@ def test_rate_estimation_consistency(self): kernels_available.append('auto') kernel_resolution = 0.01 * pq.s for kernel in kernels_available: + boundary_correction = False + if isinstance(kernel, kernels.GaussianKernel): + boundary_correction = True for center_kernel in (False, True): rate_estimate = statistics.instantaneous_rate( self.spike_train, @@ -588,7 +591,9 @@ def test_rate_estimation_consistency(self): t_start=self.st_tr[0] * pq.s, t_stop=self.st_tr[1] * pq.s, trim=False, - center_kernel=center_kernel) + center_kernel=center_kernel, + boundary_correction=boundary_correction + ) num_spikes = len(self.spike_train) auc = spint.cumtrapz( y=rate_estimate.magnitude[:, 0], From 3f3cfd4df66825bd7b5abd4a45298d87199b815e Mon Sep 17 00:00:00 2001 From: pbouss Date: Fri, 26 Mar 2021 17:32:55 +0100 Subject: [PATCH 10/78] only spiketrain with more than one spikes are corrected --- elephant/statistics.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index b3d8cd603..019c512d4 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -928,7 +928,9 @@ def optimal_kernel(st): duration = t_stop.simplified.magnitude - t_start.simplified.magnitude # ensure integral over firing rate yield the exact number of spikes for i, spiketrain in enumerate(spiketrains): - rate[:, i] *= len(spiketrain) / (np.mean(rate[:, i]).magnitude * duration) + if len(spiketrain) > 0: + rate[:, i] *= len(spiketrain) /\ + (np.mean(rate[:, i]).magnitude * duration) return rate From e52dd19a44855d631802ca16059fab97d2678aab Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 12 Apr 2021 12:38:24 +0200 Subject: [PATCH 11/78] added test of boundary correction --- elephant/statistics.py | 14 ++++++------ elephant/test/test_statistics.py | 37 +++++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 9 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 019c512d4..05ce66f4f 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -624,11 +624,9 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', rate estimation. Currently implemented kernel forms are rectangular, triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. - # TODO: The implementation is actually that of Shinomoto. - # The one of Shimazaki is NOT implemented in elephant. - # As it is now it is highly misleading! - If 'auto', the optimized kernel width for the rate estimation is - calculated according to :cite:`statistics-Shimazaki2010_171` and with + If 'auto', the optimized kernel width (that is not adaptive) + for the rate estimation is calculated according to + :cite:`statistics-Shimazaki2010_171` and with this width a gaussian kernel is constructed. Automatized calculation of the kernel width is not available for other than gaussian kernel shapes. @@ -669,8 +667,8 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', the origin of the kernel. Default: True boundary_correction : bool, optional - Apply the boundary correction as introduced in - Stella, Bouss et al. (2021) to be submitted. + Apply a boundary correction. + Only possible in the case of a Gaussian kernel. Default: False Returns @@ -922,7 +920,7 @@ def optimal_kernel(st): np.sqrt(2.) * sigma))) # multiply with correction factor for stationary rate as described in - # Stella, Bouss et al. (2021) + # Stella, Bouss et al. (2021), in prep. rate *= correction_factor[:, None] duration = t_stop.simplified.magnitude - t_start.simplified.magnitude diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 911d75c65..0861d334d 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -17,7 +17,6 @@ import scipy.integrate as spint from numpy.testing import assert_array_almost_equal, assert_array_equal, \ assert_array_less - import elephant.kernels as kernels from elephant import statistics from elephant.spike_train_generation import homogeneous_poisson_process @@ -847,6 +846,42 @@ def test_annotations(self): self.assertIn('kernel', rate.annotations) self.assertEqual(rate.annotations['kernel'], kernel_annotation) + def test_boundary_correction(self): + np.random.seed(0) + n_spiketrains = 75 + rate = 50. * pq.Hz + t_start = 0. * pq.ms + t_stop = 1000. * pq.ms + + sampling_period = 0.1 * pq.ms + + trial_list = [homogeneous_poisson_process( + rate=rate, t_start=t_start, + t_stop=t_stop) for _ in range(n_spiketrains)] + + for CORRECTION in (True, False): + rates = [] + for trial in trial_list: + # calculate instaneous rate, discard extra dimension + instantenous_rate = statistics.instantaneous_rate( + spiketrains=trial, + sampling_period=sampling_period, + kernel='auto', + boundary_correction=CORRECTION + ) + rates.append(instantenous_rate) + rate_estimated = np.mean(rates, axis=0)[:, 0] + + rtol = 0.05 # Five percent of tolerance + + if CORRECTION: + assert np.max(rate_estimated) < (1. + rtol) * rate.item() + assert np.min(rate_estimated) > (1. - rtol) * rate.item() + else: + assert np.max(rate_estimated) < (1. + rtol) * rate.item() + # The minimal rate deviates strongly in the uncorrected case. + assert not np.min(rate_estimated) > (1. - rtol) * rate.item() + class TimeHistogramTestCase(unittest.TestCase): def setUp(self): From cb331eb6c1ac4f032baef1e6cd6332781961e0b5 Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 12 Apr 2021 12:42:42 +0200 Subject: [PATCH 12/78] PEP8 --- elephant/statistics.py | 2 +- elephant/test/test_spade.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 05ce66f4f..209b10664 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -772,7 +772,7 @@ def optimal_kernel(st): return kernels.GaussianKernel(width_sigma * st.units) if boundary_correction and not \ - (kernel=='auto' or isinstance(kernel, kernels.GaussianKernel)): + (kernel == 'auto' or isinstance(kernel, kernels.GaussianKernel)): raise ValueError( 'The boundary correction is only implemented' ' for Gaussian kernels.') diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 108c3b74f..80e66f746 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -308,8 +308,9 @@ def test_fpgrowth_fca(self): mining_results_fpg = spade._fpgrowth( transactions, rel_matrix=rel_matrix) - print('#################################################################') - print('mining results fpg',mining_results_fpg) + print( + '#################################################################') + print('mining results fpg', mining_results_fpg) # mining the data with C fim mining_results_ffca = spade._fast_fca(context) From efd55a0f4e3fd6c4184c2ca3e78fa05558a7b4e7 Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 12 Apr 2021 14:04:58 +0200 Subject: [PATCH 13/78] revert wrongly merged master --- elephant/spade.py | 33 +++++++-------- elephant/test/test_spade.py | 84 ++++++++++++++++++------------------- 2 files changed, 55 insertions(+), 62 deletions(-) diff --git a/elephant/spade.py b/elephant/spade.py index 8986bdf56..a639a1976 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -881,16 +881,13 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, zmin=min_z, zmax=max_z, report='a', - algo='s', - winlen=winlen, - threads=0, - verbose=4) + algo='s') break else: fpgrowth_output = [(tuple(transactions[0]), len(transactions))] # Applying min/max conditions and computing extent (window positions) - # fpgrowth_output = [concept for concept in fpgrowth_output - # if _fpgrowth_filter(concept, winlen, max_c, min_neu)] + fpgrowth_output = [concept for concept in fpgrowth_output + if _fpgrowth_filter(concept, winlen, max_c, min_neu)] # filter out subsets of patterns that are found as a side-effect # of using the moving window strategy fpgrowth_output = _filter_for_moving_window_subsets( @@ -938,18 +935,18 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, return spectrum -# def _fpgrowth_filter(concept, winlen, max_c, min_neu): -# """ -# Filter for selecting closed frequent items set with a minimum number of -# neurons and a maximum number of occurrences and first spike in the first -# bin position -# """ -# intent = np.array(concept[0]) -# keep_concept = (min(intent % winlen) == 0 -# and concept[1] <= max_c -# and np.unique(intent // winlen).shape[0] >= min_neu -# ) -# return keep_concept +def _fpgrowth_filter(concept, winlen, max_c, min_neu): + """ + Filter for selecting closed frequent items set with a minimum number of + neurons and a maximum number of occurrences and first spike in the first + bin position + """ + intent = np.array(concept[0]) + keep_concept = (min(intent % winlen) == 0 + and concept[1] <= max_c + and np.unique(intent // winlen).shape[0] >= min_neu + ) + return keep_concept def _rereference_to_last_spike(transactions, winlen): diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 80e66f746..464fec1ba 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -272,28 +272,27 @@ def test_parameters(self): for lags in lags_msip_max_spikes], [True] * len(lags_msip_max_spikes)) - # TODO: ask Florian if it is possible to fix this - # # test max_occ parameter - # output_msip_max_occ = spade.spade( - # self.msip, - # self.bin_size, - # self.winlen, - # max_occ=self.max_occ, - # approx_stab_pars=dict( - # n_subsets=self.n_subset), - # n_surr=self.n_surr, - # alpha=self.alpha, - # psr_param=self.psr_param, - # stat_corr='no', - # output_format='patterns')['patterns'] - # # collect spade output - # occ_msip_max_occ = [] - # for out in output_msip_max_occ: - # occ_msip_max_occ.append(list(out['times'].magnitude)) - # occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) - # # test occurrences time - # assert_array_equal(occ_msip_max_occ, [ - # occ for occ in self.occ_msip if len(occ) <= self.max_occ]) + # test max_occ parameter + output_msip_max_occ = spade.spade( + self.msip, + self.bin_size, + self.winlen, + max_occ=self.max_occ, + approx_stab_pars=dict( + n_subsets=self.n_subset), + n_surr=self.n_surr, + alpha=self.alpha, + psr_param=self.psr_param, + stat_corr='no', + output_format='patterns')['patterns'] + # collect spade output + occ_msip_max_occ = [] + for out in output_msip_max_occ: + occ_msip_max_occ.append(list(out['times'].magnitude)) + occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) + # test occurrences time + assert_array_equal(occ_msip_max_occ, [ + occ for occ in self.occ_msip if len(occ) <= self.max_occ]) # test to compare the python and the C implementation of FIM # skip this test if C code not available @@ -308,9 +307,6 @@ def test_fpgrowth_fca(self): mining_results_fpg = spade._fpgrowth( transactions, rel_matrix=rel_matrix) - print( - '#################################################################') - print('mining results fpg', mining_results_fpg) # mining the data with C fim mining_results_ffca = spade._fast_fca(context) @@ -702,25 +698,25 @@ def test_signature_significance_fdr_bh_corr(self): alpha=0.15, winlen=1, corr='fdr_bh') self.assertEqual(sig_spectrum, [(2., 3., False), (2., 4., True)]) - # def test_different_surrogate_method(self): - # np.random.seed(0) - # random.seed(0) - # spiketrains = [stg.homogeneous_poisson_process(rate=20*pq.Hz) - # for _ in range(2)] - # surr_methods = ('dither_spikes', 'joint_isi_dithering', - # 'bin_shuffling', - # 'dither_spikes_with_refractory_period') - # pv_specs = {'dither_spikes': [[2, 2, 0.8], [2, 3, 0.2]], - # 'joint_isi_dithering': [[2, 2, 0.8]], - # 'bin_shuffling': [[2, 2, 1.0], [2, 3, 0.2]], - # 'dither_spikes_with_refractory_period': - # [[2, 2, 0.8]]} - # for surr_method in surr_methods: - # pv_spec = spade.pvalue_spectrum( - # spiketrains, bin_size=self.bin_size, - # winlen=self.winlen, dither=15*pq.ms, - # n_surr=5, surr_method=surr_method) - # self.assertEqual(pv_spec, pv_specs[surr_method]) + def test_different_surrogate_method(self): + np.random.seed(0) + random.seed(0) + spiketrains = [stg.homogeneous_poisson_process(rate=20*pq.Hz) + for _ in range(2)] + surr_methods = ('dither_spikes', 'joint_isi_dithering', + 'bin_shuffling', + 'dither_spikes_with_refractory_period') + pv_specs = {'dither_spikes': [[2, 2, 0.8], [2, 3, 0.2]], + 'joint_isi_dithering': [[2, 2, 0.8]], + 'bin_shuffling': [[2, 2, 1.0], [2, 3, 0.2]], + 'dither_spikes_with_refractory_period': + [[2, 2, 0.8]]} + for surr_method in surr_methods: + pv_spec = spade.pvalue_spectrum( + spiketrains, bin_size=self.bin_size, + winlen=self.winlen, dither=15*pq.ms, + n_surr=5, surr_method=surr_method) + self.assertEqual(pv_spec, pv_specs[surr_method]) def suite(): From 88ff1d5a671c0e59413338fcd1dfb9ec36e01baf Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 26 Apr 2021 10:13:41 +0200 Subject: [PATCH 14/78] renamed to border correction --- elephant/statistics.py | 8 ++++---- elephant/test/test_statistics.py | 10 +++++----- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 209b10664..339dccb34 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -601,7 +601,7 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): @deprecated_alias(spiketrain='spiketrains') def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, - center_kernel=True, boundary_correction=False): + center_kernel=True, border_correction=False): """ Estimates instantaneous firing rate by kernel convolution. @@ -666,7 +666,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. Default: True - boundary_correction : bool, optional + border_correction : bool, optional Apply a boundary correction. Only possible in the case of a Gaussian kernel. Default: False @@ -771,7 +771,7 @@ def optimal_kernel(st): "instantaneous rate from input data.") return kernels.GaussianKernel(width_sigma * st.units) - if boundary_correction and not \ + if border_correction and not \ (kernel == 'auto' or isinstance(kernel, kernels.GaussianKernel)): raise ValueError( 'The boundary correction is only implemented' @@ -910,7 +910,7 @@ def optimal_kernel(st): units=pq.Hz, t_start=t_start, t_stop=t_stop, kernel=kernel_annotation) - if boundary_correction: + if border_correction: sigma = kernel.sigma.simplified.magnitude times = rate.times.simplified.magnitude correction_factor = 2 / ( diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 0861d334d..f7a362ce4 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -579,9 +579,9 @@ def test_rate_estimation_consistency(self): kernels_available.append('auto') kernel_resolution = 0.01 * pq.s for kernel in kernels_available: - boundary_correction = False + border_correction = False if isinstance(kernel, kernels.GaussianKernel): - boundary_correction = True + border_correction = True for center_kernel in (False, True): rate_estimate = statistics.instantaneous_rate( self.spike_train, @@ -591,7 +591,7 @@ def test_rate_estimation_consistency(self): t_stop=self.st_tr[1] * pq.s, trim=False, center_kernel=center_kernel, - boundary_correction=boundary_correction + border_correction=border_correction ) num_spikes = len(self.spike_train) auc = spint.cumtrapz( @@ -846,7 +846,7 @@ def test_annotations(self): self.assertIn('kernel', rate.annotations) self.assertEqual(rate.annotations['kernel'], kernel_annotation) - def test_boundary_correction(self): + def test_border_correction(self): np.random.seed(0) n_spiketrains = 75 rate = 50. * pq.Hz @@ -867,7 +867,7 @@ def test_boundary_correction(self): spiketrains=trial, sampling_period=sampling_period, kernel='auto', - boundary_correction=CORRECTION + border_correction=CORRECTION ) rates.append(instantenous_rate) rate_estimated = np.mean(rates, axis=0)[:, 0] From 00c2fed84d72c368eeee731dde374c7432dcd39f Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 2 Aug 2021 12:18:42 +0200 Subject: [PATCH 15/78] removed paper citation --- elephant/statistics.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 339dccb34..fc16f6afc 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -919,8 +919,6 @@ def optimal_kernel(st): - erf((t_start.simplified.magnitude - times) / ( np.sqrt(2.) * sigma))) - # multiply with correction factor for stationary rate as described in - # Stella, Bouss et al. (2021), in prep. rate *= correction_factor[:, None] duration = t_stop.simplified.magnitude - t_start.simplified.magnitude @@ -930,7 +928,6 @@ def optimal_kernel(st): rate[:, i] *= len(spiketrain) /\ (np.mean(rate[:, i]).magnitude * duration) - return rate From 9cf8e8dc3f5bfa0ddd78fe76fae85c9f6c8d3e08 Mon Sep 17 00:00:00 2001 From: pbouss Date: Wed, 4 Aug 2021 11:09:35 +0200 Subject: [PATCH 16/78] not-new release of scipy --- requirements/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 7513dbd71..cde8bc955 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,6 +1,6 @@ neo>=0.9.0 numpy>=1.18.1 quantities>=0.12.1 -scipy>=1.5.4 +scipy<1.7.0 six>=1.10.0 tqdm From ad8c5b1ddb839831b6f58c170ca52f8f3886e958 Mon Sep 17 00:00:00 2001 From: pbouss Date: Wed, 4 Aug 2021 11:15:59 +0200 Subject: [PATCH 17/78] not-new release of neo --- requirements/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index cde8bc955..10bf5ce54 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,4 +1,4 @@ -neo>=0.9.0 +neo<0.10.0 numpy>=1.18.1 quantities>=0.12.1 scipy<1.7.0 From 7f28dbb219b5a130dc4cb0e731ef4a7414b6d007 Mon Sep 17 00:00:00 2001 From: pbouss Date: Thu, 19 Aug 2021 12:41:55 +0200 Subject: [PATCH 18/78] worked in review, especially adding documentation --- elephant/statistics.py | 17 +++++++++++------ elephant/test/test_statistics.py | 31 ++++++++++++++++++++----------- 2 files changed, 31 insertions(+), 17 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index fc16f6afc..f7207ad55 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -624,12 +624,13 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', rate estimation. Currently implemented kernel forms are rectangular, triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. - If 'auto', the optimized kernel width (that is not adaptive) - for the rate estimation is calculated according to - :cite:`statistics-Shimazaki2010_171` and with - this width a gaussian kernel is constructed. Automatized calculation - of the kernel width is not available for other than gaussian kernel + If 'auto', the optimized kernel width for the rate estimation is + calculated according to :cite:`statistics-Shimazaki2010_171` and a + Gaussian kernel is constructed with this width. Automatized calculation + of the kernel width is not available for other than Gaussian kernel shapes. + Note: The kernel width is not adaptive, i.e., it is calculated as + global optimum across the data. Default: 'auto' cutoff : float, optional This factor determines the cutoff of the probability distribution of @@ -667,7 +668,11 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', the origin of the kernel. Default: True border_correction : bool, optional - Apply a boundary correction. + Apply a border correction to prevent underestimating the firing rates + at the borders of the spike trains, i.e., close to t_start and t_stop. + The correction is done by estimating the mass of the kernel outside + these spike train borders under the assumption that the rate does not + change strongly. Only possible in the case of a Gaussian kernel. Default: False diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index f7a362ce4..929681f01 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -859,28 +859,37 @@ def test_border_correction(self): rate=rate, t_start=t_start, t_stop=t_stop) for _ in range(n_spiketrains)] - for CORRECTION in (True, False): + for correction in (True, False): rates = [] for trial in trial_list: - # calculate instaneous rate, discard extra dimension - instantenous_rate = statistics.instantaneous_rate( + # calculate the instantaneous rate, discard extra dimension + instantaneous_rate = statistics.instantaneous_rate( spiketrains=trial, sampling_period=sampling_period, kernel='auto', - border_correction=CORRECTION + border_correction=correction ) - rates.append(instantenous_rate) - rate_estimated = np.mean(rates, axis=0)[:, 0] + rates.append(instantaneous_rate) + + # The average estimated rate gives the average estimated value of + # the firing rate in each time bin. + # Note: the indexing [:, 0] is necessary to get the output an + # one-dimensional array. + average_estimated_rate = np.mean(rates, axis=0)[:, 0] rtol = 0.05 # Five percent of tolerance - if CORRECTION: - assert np.max(rate_estimated) < (1. + rtol) * rate.item() - assert np.min(rate_estimated) > (1. - rtol) * rate.item() + if correction: + self.assertLess(np.max(average_estimated_rate), + (1. + rtol) * rate.item()) + self.assertGreater(np.min(average_estimated_rate), + (1. - rtol) * rate.item()) else: - assert np.max(rate_estimated) < (1. + rtol) * rate.item() + self.assertLess(np.max(average_estimated_rate), + (1. + rtol) * rate.item()) # The minimal rate deviates strongly in the uncorrected case. - assert not np.min(rate_estimated) > (1. - rtol) * rate.item() + self.assertLess(np.min(average_estimated_rate), + (1. - rtol) * rate.item()) class TimeHistogramTestCase(unittest.TestCase): From c224e9d0b03f1b918db8bbf175048e130aced040 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 20 Sep 2021 15:56:21 +0200 Subject: [PATCH 19/78] First fix for unittests missing fake_neo objects --- elephant/test/generate_datasets.py | 394 +++++++++++++++++++++++++++++ elephant/test/test_neo_tools.py | 70 +++-- 2 files changed, 423 insertions(+), 41 deletions(-) create mode 100644 elephant/test/generate_datasets.py diff --git a/elephant/test/generate_datasets.py b/elephant/test/generate_datasets.py new file mode 100644 index 000000000..b8af584b1 --- /dev/null +++ b/elephant/test/generate_datasets.py @@ -0,0 +1,394 @@ +''' +Generate datasets for testing +''' + +from datetime import datetime +import random +import string +import numpy as np +from numpy.random import rand +import quantities as pq + +from neo.core import (AnalogSignal, Block, Epoch, Event, IrregularlySampledSignal, Group, + Segment, SpikeTrain, ImageSequence, ChannelView, + CircularRegionOfInterest, RectangularRegionOfInterest, + PolygonRegionOfInterest) + +TEST_ANNOTATIONS = [1, 0, 1.5, "this is a test", datetime.fromtimestamp(424242424), None] + + +def random_string(length=10): + return "".join(random.choice(string.ascii_letters) for i in range(length)) + + +def random_datetime(min_year=1990, max_year=datetime.now().year): + start = datetime(min_year, 1, 1, 0, 0, 0) + end = datetime(max_year, 12, 31, 23, 59, 59) + return start + (end - start) * random.random() + + +def random_annotations(n=1): + annotation_generators = ( + random.random, + random_datetime, + random_string, + lambda: None + ) + annotations = {} + for i in range(n): + var_name = random_string(6) + annotation_generator = random.choice(annotation_generators) + annotations[var_name] = annotation_generator() + return annotations + + +def random_signal(name=None, **annotations): + n_channels = random.randint(1, 7) + sig_length = random.randint(20, 200) + if len(annotations) == 0: + annotations = random_annotations(5) + obj = AnalogSignal( + np.random.uniform(size=(sig_length, n_channels)), + units=random.choice(("mV", "nA")), + t_start=random.uniform(0, 10) * pq.ms, + sampling_rate=random.uniform(0.1, 10) * pq.kHz, + name=name or random_string(), + file_origin=random_string(), + description=random_string(100), + array_annotations=None, # todo + **annotations + ) + return obj + + +def random_irreg_signal(name=None, **annotations): + n_channels = random.randint(1, 7) + sig_length = random.randint(20, 200) + if len(annotations) == 0: + annotations = random_annotations(5) + mean_firing_rate = np.random.uniform(0.1, 10) * pq.kHz + times = np.cumsum(np.random.uniform(1.0 / mean_firing_rate, size=(sig_length,))) * pq.ms + obj = IrregularlySampledSignal( + times, + np.random.uniform(size=(sig_length, n_channels)), + units=random.choice(("mV", "nA")), + name=name or random_string(), + file_origin=random_string(), + description=random_string(100), + array_annotations=None, # todo + **annotations + ) + return obj + + +def random_event(name=None, **annotations): + size = random.randint(1, 7) + times = np.cumsum(np.random.uniform(5, 10, size=size)) + labels = [random_string() for i in range(size)] + if len(annotations) == 0: + annotations = random_annotations(3) + obj = Event( + times=times, + labels=labels, + units="ms", + name=name or random_string(), + array_annotations=None, # todo + **annotations + ) + return obj + + +def random_epoch(): + size = random.randint(1, 7) + times = np.cumsum(np.random.uniform(5, 10, size=size)) + durations = np.random.uniform(1, 3, size=size) + labels = [random_string() for i in range(size)] + obj = Epoch( + times=times, + durations=durations, + labels=labels, + units="ms", + name=random_string(), + array_annotations=None, # todo + **random_annotations(3) + ) + return obj + + +def random_spiketrain(name=None, **annotations): + size = random.randint(1, 50) + times = np.cumsum(np.random.uniform(0.5, 10, size=size)) + if len(annotations) == 0: + annotations = random_annotations(3) + # todo: waveforms + obj = SpikeTrain( + times=times, + t_stop=times[-1] + random.uniform(0, 5), + units="ms", + name=name or random_string(), + array_annotations=None, # todo + **annotations + ) + return obj + + +def random_segment(): + seg = Segment( + name=random_string(10), + description=random_string(100), + file_origin=random_string(20), + file_datetime=random_datetime(), + rec_datetime=random_datetime(), + **random_annotations(4) + ) + n_sigs = random.randint(0, 5) + for i in range(n_sigs): + seg.analogsignals.append(random_signal()) + n_irrsigs = random.randint(0, 5) + for i in range(n_irrsigs): + seg.irregularlysampledsignals.append(random_irreg_signal()) + n_events = random.randint(0, 3) + for i in range(n_events): + seg.events.append(random_event()) + n_epochs = random.randint(0, 3) + for i in range(n_epochs): + seg.epochs.append(random_epoch()) + n_spiketrains = random.randint(0, 20) + for i in range(n_spiketrains): + seg.spiketrains.append(random_spiketrain()) + # todo: add some ImageSequence and ROI objects + + for child in seg.data_children: + child.segment = seg + return seg + + +def random_group(candidates): + if len(candidates) == 0: + return None + elif len(candidates) == 1: + objects = candidates + else: + k = random.randint(1, len(candidates)) + objects = random.sample(candidates, k) + obj = Group(objects=objects, + name=random_string(), + **random_annotations(5)) + return obj + + +def random_channelview(signal): + n_channels = signal.shape[1] + if n_channels > 2: + view_size = np.random.randint(1, n_channels - 1) + index = np.random.choice(np.arange(signal.shape[1]), view_size, replace=False) + obj = ChannelView( + signal, + index, + name=random_string(), + **random_annotations(3) + ) + return obj + else: + return None + + +def random_block(): + block = Block( + name=random_string(10), + description=random_string(100), + file_origin=random_string(20), + file_datetime=random_datetime(), + rec_datetime=random_datetime(), + **random_annotations(6) + ) + n_seg = random.randint(0, 5) + for i in range(n_seg): + seg = random_segment() + block.segments.append(seg) + seg.block = block + children = list(block.data_children_recur) + views = [] + for child in children: + if isinstance(child, (AnalogSignal, IrregularlySampledSignal)): + PROB_SIGNAL_HAS_VIEW = 0.5 + if np.random.random_sample() < PROB_SIGNAL_HAS_VIEW: + chv = random_channelview(child) + if chv: + views.append(chv) + children.extend(views) + n_groups = random.randint(0, 5) + for i in range(n_groups): + group = random_group(children) + if group: + block.groups.append(group) + group.block = block + children.append(group) # this can give us nested groups + return block + + +def simple_block(): + block = Block( + name="test block", + species="rat", + brain_region="cortex" + ) + block.segments = [ + Segment(name="test segment #1", + cell_type="spiny stellate"), + Segment(name="test segment #2", + cell_type="pyramidal", + thing="amajig") + ] + for segment in block.segments: + segment.block = block + block.segments[0].analogsignals.extend(( + random_signal(name="signal #1 in segment #1", thing="wotsit"), + random_signal(name="signal #2 in segment #1", thing="frooble"), + )) + block.segments[1].analogsignals.extend(( + random_signal(name="signal #1 in segment #2", thing="amajig"), + )) + block.segments[1].irregularlysampledsignals.extend(( + random_irreg_signal(name="signal #1 in segment #2", thing="amajig"), + )) + block.segments[0].events.extend(( + random_event(name="event array #1 in segment #1", thing="frooble"), + )) + block.segments[1].events.extend(( + random_event(name="event array #1 in segment #2", thing="wotsit"), + )) + block.segments[0].spiketrains.extend(( + random_spiketrain(name="spiketrain #1 in segment #1", thing="frooble"), + random_spiketrain(name="spiketrain #2 in segment #1", thing="wotsit") + )) + return block + + +def generate_one_simple_block(block_name='block_0', nb_segment=3, supported_objects=[], **kws): + if supported_objects and Block not in supported_objects: + raise ValueError('Block must be in supported_objects') + bl = Block() # name = block_name) + + objects = supported_objects + if Segment in objects: + for s in range(nb_segment): + seg = generate_one_simple_segment(seg_name="seg" + str(s), supported_objects=objects, + **kws) + bl.segments.append(seg) + + # if RecordingChannel in objects: + # populate_RecordingChannel(bl) + + bl.create_many_to_one_relationship() + return bl + + +def generate_one_simple_segment(seg_name='segment 0', supported_objects=[], nb_analogsignal=4, + t_start=0. * pq.s, sampling_rate=10 * pq.kHz, duration=6. * pq.s, + + nb_spiketrain=6, spikerate_range=[.5 * pq.Hz, 12 * pq.Hz], + + event_types={'stim': ['a', 'b', 'c', 'd'], + 'enter_zone': ['one', 'two'], + 'color': ['black', 'yellow', 'green'], }, + event_size_range=[5, 20], + + epoch_types={'animal state': ['Sleep', 'Freeze', 'Escape'], + 'light': ['dark', 'lighted']}, + epoch_duration_range=[.5, 3.], + # this should be multiplied by pq.s, no? + + array_annotations={'valid': np.array([True, False]), + 'number': np.array(range(5))} + + ): + if supported_objects and Segment not in supported_objects: + raise ValueError('Segment must be in supported_objects') + seg = Segment(name=seg_name) + if AnalogSignal in supported_objects: + for a in range(nb_analogsignal): + anasig = AnalogSignal(rand(int((sampling_rate * duration).simplified)), + sampling_rate=sampling_rate, + t_start=t_start, units=pq.mV, channel_index=a, + name='sig %d for segment %s' % (a, seg.name)) + seg.analogsignals.append(anasig) + + if SpikeTrain in supported_objects: + for s in range(nb_spiketrain): + spikerate = rand() * np.diff(spikerate_range) + spikerate += spikerate_range[0].magnitude + # spikedata = rand(int((spikerate*duration).simplified))*duration + # sptr = SpikeTrain(spikedata, + # t_start=t_start, t_stop=t_start+duration) + # #, name = 'spiketrain %d'%s) + spikes = rand(int((spikerate * duration).simplified)) + spikes.sort() # spikes are supposed to be an ascending sequence + sptr = SpikeTrain(spikes * duration, t_start=t_start, t_stop=t_start + duration) + sptr.annotations['channel_index'] = s + # Randomly generate array_annotations from given options + arr_ann = {key: value[(rand(len(spikes)) * len(value)).astype('i')] for (key, value) in + array_annotations.items()} + sptr.array_annotate(**arr_ann) + seg.spiketrains.append(sptr) + + if Event in supported_objects: + for name, labels in event_types.items(): + evt_size = rand() * np.diff(event_size_range) + evt_size += event_size_range[0] + evt_size = int(evt_size) + labels = np.array(labels, dtype='U') + labels = labels[(rand(evt_size) * len(labels)).astype('i')] + evt = Event(times=rand(evt_size) * duration, labels=labels) + # Randomly generate array_annotations from given options + arr_ann = {key: value[(rand(evt_size) * len(value)).astype('i')] for (key, value) in + array_annotations.items()} + evt.array_annotate(**arr_ann) + seg.events.append(evt) + + if Epoch in supported_objects: + for name, labels in epoch_types.items(): + t = 0 + times = [] + durations = [] + while t < duration: + times.append(t) + dur = rand() * (epoch_duration_range[1] - epoch_duration_range[0]) + dur += epoch_duration_range[0] + durations.append(dur) + t = t + dur + labels = np.array(labels, dtype='U') + labels = labels[(rand(len(times)) * len(labels)).astype('i')] + assert len(times) == len(durations) + assert len(times) == len(labels) + epc = Epoch(times=pq.Quantity(times, units=pq.s), + durations=pq.Quantity(durations, units=pq.s), + labels=labels,) + assert epc.times.dtype == 'float' + # Randomly generate array_annotations from given options + arr_ann = {key: value[(rand(len(times)) * len(value)).astype('i')] for (key, value) in + array_annotations.items()} + epc.array_annotate(**arr_ann) + seg.epochs.append(epc) + + # TODO : Spike, Event + + seg.create_many_to_one_relationship() + return seg + + +def generate_from_supported_objects(supported_objects): + # ~ create_many_to_one_relationship + if not supported_objects: + raise ValueError('No objects specified') + objects = supported_objects + if Block in supported_objects: + higher = generate_one_simple_block(supported_objects=objects) + elif Segment in objects: + higher = generate_one_simple_segment(supported_objects=objects) + else: + # TODO + return None + + higher.create_many_to_one_relationship() + return higher diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index c61313758..4a3da9c3a 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -5,11 +5,11 @@ :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ - +import random from itertools import chain import unittest -from neo.test.generate_datasets import fake_neo, get_fake_values +from .generate_datasets import generate_one_simple_block, generate_from_supported_objects, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema from numpy.testing.utils import assert_array_equal @@ -69,6 +69,16 @@ def strip_iter_values(targ, array_attrs=ARRAY_ATTRS): class GetAllObjsTestCase(unittest.TestCase): + def setUp(self): + random.seed(4245) + self.spiketrain = random_spiketrain('Single SpikeTrain') + self.spiketrain_list = [random_spiketrain('SpikeTrain'), + random_spiketrain('SpikeTrain')] + self.spiketrain_dict = {'a': random_spiketrain('SpikeTrain'), + 123: random_spiketrain('SpikeTrain')} + + self.random_epoch = random_epoch() + def test__get_all_objs__float_valueerror(self): value = 5. with self.assertRaises(ValueError): @@ -80,7 +90,7 @@ def test__get_all_objs__list_float_valueerror(self): nt._get_all_objs(value, 'Block') def test__get_all_objs__epoch_for_event_valueerror(self): - value = fake_neo('Epoch', n=10, seed=0) + value = random_epoch() with self.assertRaises(ValueError): nt._get_all_objs(value, 'Event') @@ -141,18 +151,16 @@ def test__get_all_objs__empty_nested_many(self): self.assertEqual(targ, res) def test__get_all_objs__spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0)] - value = fake_neo('SpikeTrain', n=10, seed=0) + value = self.spiketrain + targ = [self.spiketrain] res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) def test__get_all_objs__list_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] + value = self.spiketrain_list + targ = self.spiketrain_list res = nt._get_all_objs(value, 'SpikeTrain') @@ -169,10 +177,9 @@ def test__get_all_objs__nested_list_epoch(self): assert_same_sub_schema(targ, res) def test__get_all_objs__iter_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = iter([fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)]) + targ = self.spiketrain_list + value = iter([self.spiketrain_list[0], + self.spiketrain_list[1]]) res = nt._get_all_objs(value, 'SpikeTrain') @@ -189,21 +196,14 @@ def test__get_all_objs__nested_iter_epoch(self): assert_same_sub_schema(targ, res) def test__get_all_objs__dict_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': fake_neo('SpikeTrain', n=10, seed=0), - 'b': fake_neo('SpikeTrain', n=10, seed=1)} + targ = [self.spiketrain_dict['a'], self.spiketrain_dict[123]] + value = self.spiketrain_dict res = nt._get_all_objs(value, 'SpikeTrain') self.assertEqual(len(targ), len(res)) - for i, itarg in enumerate(targ): - for ires in res: - if itarg.annotations['seed'] == ires.annotations['seed']: - assert_same_sub_schema(itarg, ires) - break - else: - raise ValueError('Target %s not in result' % i) + for t, r in zip(targ,res): + assert_same_sub_schema(t, r) def test__get_all_objs__nested_dict_spiketrain(self): targ = [fake_neo('SpikeTrain', n=10, seed=0), @@ -223,7 +223,7 @@ def test__get_all_objs__nested_dict_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__nested_many_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), + targ = [generate_one_simple_block('SpikeTrain', n=10, seed=0), fake_neo('SpikeTrain', n=10, seed=1)] value = {'a': [fake_neo('SpikeTrain', n=10, seed=0)], 'b': iter([fake_neo('SpikeTrain', n=10, seed=1)])} @@ -240,27 +240,15 @@ def test__get_all_objs__nested_many_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__unit_spiketrain(self): - value = fake_neo('Unit', n=3, seed=0) - targ = [fake_neo('SpikeTrain', n=3, seed=train.annotations['seed']) - for train in value.spiketrains] - - for train in value.spiketrains: - train.annotations.pop('i', None) - train.annotations.pop('j', None) - + value = generate_one_simple_block('Block', n=3, seed=0) + targ = [train for train in value.spiketrains] res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) def test__get_all_objs__block_epoch(self): - value = fake_neo('Block', n=3, seed=0) - targ = [fake_neo('Epoch', n=3, seed=train.annotations['seed']) - for train in value.list_children_by_class('Epoch')] - - for epoch in value.list_children_by_class('Epoch'): - epoch.annotations.pop('i', None) - epoch.annotations.pop('j', None) - + value = generate_one_simple_block('Block', n=3, seed=0) + targ = [train for train in value.list_children_by_class('Epoch')] res = nt._get_all_objs(value, 'Epoch') assert_same_sub_schema(targ, res) From c071f69bcebff29660dd7859e92c0f6703da0055 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Mon, 13 Dec 2021 16:07:03 +0100 Subject: [PATCH 20/78] updated UE tutorial and requirements to use nixio 1.5.0 (#86) --- doc/tutorials/unitary_event_analysis.ipynb | 23 ++++++++++++---------- requirements/requirements-tutorials.txt | 2 +- 2 files changed, 14 insertions(+), 11 deletions(-) diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 48855eda4..b21aa2fd2 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -73,8 +73,8 @@ }, "outputs": [], "source": [ - "# Download data\n", - "!curl https://web.gin.g-node.org/INM-6/elephant-data/raw/master/dataset-1/dataset-1.h5 --output dataset-1.h5 --location" + "# Download trial data\n", + "!curl https://gin.g-node.org/INM-6/elephant-data/raw/87a61db4d1ac54a577f34478c98d6487bfe1a6c3/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" ] }, { @@ -464,10 +464,13 @@ }, "outputs": [], "source": [ - "block = neo.io.NeoHdf5IO(\"./dataset-1.h5\")\n", - "sts1 = block.read_block().segments[0].spiketrains\n", - "sts2 = block.read_block().segments[1].spiketrains\n", - "spiketrains = np.vstack((sts1,sts2)).T" + "io = neo.io.NixIO(\"./dataset-1.nix\")\n", + "block = io.read_block()\n", + "\n", + "spiketrains = []\n", + "# each segment contains a single trial\n", + "for ind in range(len(block.segments)):\n", + " spiketrains.append (block.segments[ind].spiketrains)" ] }, { @@ -498,9 +501,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "elephant_nixio", "language": "python", - "name": "python3" + "name": "elephant_nixio" }, "language_info": { "codemirror_mode": { @@ -512,7 +515,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.7" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -574,5 +577,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/requirements/requirements-tutorials.txt b/requirements/requirements-tutorials.txt index 6fb237785..3ee70c3cd 100644 --- a/requirements/requirements-tutorials.txt +++ b/requirements/requirements-tutorials.txt @@ -1,4 +1,4 @@ # Packages required to execute jupyter notebook tutorials matplotlib>=3.3.2 h5py>=3.1.0 -nixio==1.5.0b3 +nixio>=1.5.0 \ No newline at end of file From 6ca6dd625b7b0944c4f6cc3de21f13b7efb8b385 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 13 Dec 2021 17:53:08 +0100 Subject: [PATCH 21/78] updated links for datasets used in tutorials asset and UE --- doc/tutorials/asset.ipynb | 183 ++++----------------- doc/tutorials/unitary_event_analysis.ipynb | 2 +- 2 files changed, 33 insertions(+), 152 deletions(-) diff --git a/doc/tutorials/asset.ipynb b/doc/tutorials/asset.ipynb index bb2e7e328..08fc0d2c2 100644 --- a/doc/tutorials/asset.ipynb +++ b/doc/tutorials/asset.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:41.726957Z", @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:41.778627Z", @@ -81,11 +81,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "!curl https://web.gin.g-node.org/INM-6/elephant-data/raw/master/dataset-2/asset_showcase_500.nix --output asset_showcase_500.nix --location" + "!curl https://gin.g-node.org/INM-6/elephant-data/raw/4ce476cb9724cf86aedcf0075fa233f43e70b189/tutorials/tutorial_asset/data/asset_showcase_500.nix --output asset_showcase_500.nix --location" ] }, { @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:46.775022Z", @@ -114,25 +114,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:47.861748Z", "start_time": "2020-03-25T14:10:46.776687Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "plt.eventplot([st.magnitude for st in spiketrains], linewidths=5, linelengths=5)\n", @@ -165,25 +154,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:48.810547Z", "start_time": "2020-03-25T14:10:47.863279Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# 2.1.1) create ASSET analysis object\n", "# hint: try different bin sizes, e.g. bin_size=2.5, 3.5, 4.0 ms\n", @@ -206,35 +184,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:10:52.180959Z", "start_time": "2020-03-25T14:10:48.812449Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "compute rates by boxcar-kernel convolution...\n", - "compute the prob. that each neuron fires in each pair of bins...\n", - "compute the probability matrix by Le Cam's approximation...\n", - "substitute 0.5 to elements along the main diagonal...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pmat = asset_obj.probability_matrix_analytical(imat, kernel_width=50*pq.ms)\n", "plt.matshow(pmat)\n", @@ -254,22 +211,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:02.280463Z", "start_time": "2020-03-25T14:10:52.182029Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Joint survival function: 100%|██████████| 47838/47838 [00:06<00:00, 7400.11it/s]\n" - ] - } - ], + "outputs": [], "source": [ "os.environ['ELEPHANT_USE_OPENCL'] = '0'\n", "# try different filter_shapes, e.g. filter_shape=(7,3)\n", @@ -278,25 +227,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:02.637610Z", "start_time": "2020-03-25T14:11:02.283118Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.matshow(jmat)\n", "plt.colorbar();" @@ -317,25 +255,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:02.938666Z", "start_time": "2020-03-25T14:11:02.639331Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# hint: try different alphas for pmat and jmat\n", "# hint: try alphas in range [0.99, 1-1e-6]\n", @@ -360,26 +287,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:03.303188Z", "start_time": "2020-03-25T14:11:02.940034Z" - }, - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } - ], + }, + "outputs": [], "source": [ "# hint: you can call asset.ASSET.cluster_matrix_entries(...) without creating the asset_obj\n", "cmat = asset_obj.cluster_matrix_entries(mmat, max_distance=11, min_neighbors=10, stretch=5)\n", @@ -398,25 +313,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:04.675545Z", "start_time": "2020-03-25T14:11:03.304508Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys([1])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "sses = asset_obj.extract_synchronous_events(cmat)\n", "sses.keys()" @@ -424,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:04.685097Z", @@ -449,26 +353,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:05.868308Z", "start_time": "2020-03-25T14:11:04.686689Z" - }, - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } - ], + }, + "outputs": [], "source": [ "plt.figure()\n", "plt.eventplot([st.magnitude for st in reordered_sts], linewidths=5, linelengths=5)\n", @@ -486,25 +378,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2020-03-25T14:11:07.018185Z", "start_time": "2020-03-25T14:11:05.869587Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ordering_true = segment.annotations['spiketrain_ordering']\n", "spiketrains_ordered = [spiketrains[idx] for idx in ordering_true]\n", @@ -520,9 +401,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "elephant_nixio", "language": "python", - "name": "python3" + "name": "elephant_nixio" }, "language_info": { "codemirror_mode": { @@ -534,7 +415,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.7" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -597,5 +478,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index b21aa2fd2..14ce31c7e 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -74,7 +74,7 @@ "outputs": [], "source": [ "# Download trial data\n", - "!curl https://gin.g-node.org/INM-6/elephant-data/raw/87a61db4d1ac54a577f34478c98d6487bfe1a6c3/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" + "!curl https://gin.g-node.org/INM-6/elephant-data/raw/7c361d8143d605bf2e31a883189b0b7a92b58f2a/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" ] }, { From aa1d4a493d88f0a323d82359816c9d3821e1e6b2 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 13 Dec 2021 17:59:53 +0100 Subject: [PATCH 22/78] use 'read only' to assure backwards compatibility --- doc/tutorials/unitary_event_analysis.ipynb | 47 ++++++++++++++++++---- 1 file changed, 39 insertions(+), 8 deletions(-) diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 14ce31c7e..4b44bec6a 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:30.663173Z", @@ -64,14 +64,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:32.142189Z", "start_time": "2018-07-18T08:56:31.420462Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 1723k 0 1723k 0 0 427k 0 --:--:-- 0:00:04 --:--:-- 427k\n" + ] + } + ], "source": [ "# Download trial data\n", "!curl https://gin.g-node.org/INM-6/elephant-data/raw/7c361d8143d605bf2e31a883189b0b7a92b58f2a/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" @@ -88,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:32.920355Z", @@ -455,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:33.836628Z", @@ -464,7 +474,7 @@ }, "outputs": [], "source": [ - "io = neo.io.NixIO(\"./dataset-1.nix\")\n", + "io = neo.io.NixIO(\"./dataset-1.nix\",'ro')\n", "block = io.read_block()\n", "\n", "spiketrains = []\n", @@ -482,14 +492,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:37.042743Z", "start_time": "2018-07-18T08:56:34.926673Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kern/miniconda3/envs/elephant_nixio/lib/python3.9/site-packages/elephant/conversion.py:1168: UserWarning: Binning discarded 1 last spike(s) of the input spiketrain\n", + " warnings.warn(\"Binning discarded {} last spike(s) of the \"\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "UE = ue.jointJ_window_analysis(\n", " spiketrains, bin_size=5*pq.ms, winsize=100*pq.ms, winstep=10*pq.ms, pattern_hash=[3])\n", From b7954e94e8912efa572d35238507528c85f54cfc Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 13 Dec 2021 18:02:36 +0100 Subject: [PATCH 23/78] reset outputs of notebook --- doc/tutorials/unitary_event_analysis.ipynb | 45 ++++------------------ 1 file changed, 7 insertions(+), 38 deletions(-) diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 4b44bec6a..7df807f33 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:30.663173Z", @@ -64,24 +64,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:32.142189Z", "start_time": "2018-07-18T08:56:31.420462Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " % Total % Received % Xferd Average Speed Time Time Time Current\n", - " Dload Upload Total Spent Left Speed\n", - "100 1723k 0 1723k 0 0 427k 0 --:--:-- 0:00:04 --:--:-- 427k\n" - ] - } - ], + "outputs": [], "source": [ "# Download trial data\n", "!curl https://gin.g-node.org/INM-6/elephant-data/raw/7c361d8143d605bf2e31a883189b0b7a92b58f2a/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" @@ -98,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:32.920355Z", @@ -465,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:33.836628Z", @@ -492,35 +482,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2018-07-18T08:56:37.042743Z", "start_time": "2018-07-18T08:56:34.926673Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kern/miniconda3/envs/elephant_nixio/lib/python3.9/site-packages/elephant/conversion.py:1168: UserWarning: Binning discarded 1 last spike(s) of the input spiketrain\n", - " warnings.warn(\"Binning discarded {} last spike(s) of the \"\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "UE = ue.jointJ_window_analysis(\n", " spiketrains, bin_size=5*pq.ms, winsize=100*pq.ms, winstep=10*pq.ms, pattern_hash=[3])\n", From 78131ccefe1c68d8994df7514ed7b19f102b1d6c Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Fri, 28 Jan 2022 18:59:14 +0100 Subject: [PATCH 24/78] Changed Typo Co-authored-by: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> --- elephant/statistics.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 82eef77d0..6a3108d00 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -779,7 +779,7 @@ def optimal_kernel(st): if border_correction and not \ (kernel == 'auto' or isinstance(kernel, kernels.GaussianKernel)): raise ValueError( - 'The boundary correction is only implemented' + 'The border correction is only implemented' ' for Gaussian kernels.') if isinstance(spiketrains, neo.SpikeTrain): From b13923aef8cbff19d70de14f92afd58b8bb00f41 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Thu, 3 Feb 2022 14:21:25 +0100 Subject: [PATCH 25/78] Fixed all GetAllObjsTestCase unit tests --- elephant/test/test_neo_tools.py | 59 +++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 25 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 4a3da9c3a..f8719701f 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -9,6 +9,8 @@ from itertools import chain import unittest +import neo.core + from .generate_datasets import generate_one_simple_block, generate_from_supported_objects, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema from numpy.testing.utils import assert_array_equal @@ -71,13 +73,19 @@ def strip_iter_values(targ, array_attrs=ARRAY_ATTRS): class GetAllObjsTestCase(unittest.TestCase): def setUp(self): random.seed(4245) - self.spiketrain = random_spiketrain('Single SpikeTrain') - self.spiketrain_list = [random_spiketrain('SpikeTrain'), - random_spiketrain('SpikeTrain')] - self.spiketrain_dict = {'a': random_spiketrain('SpikeTrain'), - 123: random_spiketrain('SpikeTrain')} - - self.random_epoch = random_epoch() + self.spiketrain = random_spiketrain('Single SpikeTrain', seed=random.random()) + self.spiketrain_list = [ + random_spiketrain('SpikeTrain', seed=random.random()), + random_spiketrain('SpikeTrain', seed=random.random())] + self.spiketrain_dict = { + 'a': random_spiketrain('SpikeTrain', seed=random.random()), + 123: random_spiketrain('SpikeTrain', seed=random.random())} + + self.epoch = random_epoch() + self.epoch_list = [ + random_epoch(), random_epoch()] + self.epoch_dict = { + 'a': random_epoch(), 123: random_epoch()} def test__get_all_objs__float_valueerror(self): value = 5. @@ -167,10 +175,8 @@ def test__get_all_objs__list_spiketrain(self): assert_same_sub_schema(targ, res) def test__get_all_objs__nested_list_epoch(self): - targ = [fake_neo('Epoch', n=10, seed=0), - fake_neo('Epoch', n=10, seed=1)] - value = [[fake_neo('Epoch', n=10, seed=0)], - fake_neo('Epoch', n=10, seed=1)] + targ = self.epoch_list + value = [self.epoch_list] res = nt._get_all_objs(value, 'Epoch') @@ -186,10 +192,8 @@ def test__get_all_objs__iter_spiketrain(self): assert_same_sub_schema(targ, res) def test__get_all_objs__nested_iter_epoch(self): - targ = [fake_neo('Epoch', n=10, seed=0), - fake_neo('Epoch', n=10, seed=1)] - value = iter([iter([fake_neo('Epoch', n=10, seed=0)]), - fake_neo('Epoch', n=10, seed=1)]) + targ = self.epoch_list + value = iter([iter(self.epoch_list)]) res = nt._get_all_objs(value, 'Epoch') @@ -206,10 +210,9 @@ def test__get_all_objs__dict_spiketrain(self): assert_same_sub_schema(t, r) def test__get_all_objs__nested_dict_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': fake_neo('SpikeTrain', n=10, seed=0), - 'b': {'c': fake_neo('SpikeTrain', n=10, seed=1)}} + targ = self.spiketrain_list + value = {'a': self.spiketrain_list[0], + 'b': {'c': self.spiketrain_list[1]}} res = nt._get_all_objs(value, 'SpikeTrain') @@ -223,10 +226,9 @@ def test__get_all_objs__nested_dict_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__nested_many_spiketrain(self): - targ = [generate_one_simple_block('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': [fake_neo('SpikeTrain', n=10, seed=0)], - 'b': iter([fake_neo('SpikeTrain', n=10, seed=1)])} + targ = self.spiketrain_list + value = {'a': [self.spiketrain_list[0]], + 'b': iter([self.spiketrain_list[1]])} res = nt._get_all_objs(value, 'SpikeTrain') @@ -240,8 +242,15 @@ def test__get_all_objs__nested_many_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__unit_spiketrain(self): - value = generate_one_simple_block('Block', n=3, seed=0) - targ = [train for train in value.spiketrains] + value = neo.core.Group( + self.spiketrain_list, + name='Unit') + targ = self.spiketrain_list + + for train in value.spiketrains: + train.annotations.pop('i', None) + train.annotations.pop('j', None) + res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) From 83864c03c2fc7d46c56fdc48c3a69637d96eee48 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Thu, 3 Feb 2022 23:48:10 +0100 Subject: [PATCH 26/78] Started work on Events test case --- elephant/test/test_neo_tools.py | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index f8719701f..8040c104c 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -7,11 +7,13 @@ """ import random from itertools import chain +import copy import unittest import neo.core -from .generate_datasets import generate_one_simple_block, generate_from_supported_objects, random_epoch, random_spiketrain +from .generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ + random_event, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema from numpy.testing.utils import assert_array_equal @@ -1150,8 +1152,17 @@ def test__get_all_spiketrains__dict(self): class GetAllEventsTestCase(unittest.TestCase): + def setUp(self): + random.seed(4245) + self.event=random_event() + self.block=generate_one_simple_block( + nb_segment=2, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) + self.segment=generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.Event]) + def test__get_all_events__event(self): - obj = fake_neo('Event', seed=0, n=5) + obj = self.event res0 = nt.get_all_events(obj) targ = obj @@ -1161,11 +1172,11 @@ def test__get_all_events__event(self): assert_same_sub_schema(targ, res0[0]) def test__get_all_events__segment(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = copy.deepcopy(self.segment) obj.events.extend(obj.events) res0 = nt.get_all_events(obj) - targ = fake_neo('Segment', seed=0, n=5).events + targ = self.segment.events self.assertTrue(len(res0) > 0) From 5e8747fe96e38a337ada2e1240a7e8463d429899 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 09:28:10 +0100 Subject: [PATCH 27/78] Fixed Events test case --- elephant/test/test_neo_tools.py | 50 ++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 19 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 8040c104c..86808e050 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -1154,15 +1154,9 @@ def test__get_all_spiketrains__dict(self): class GetAllEventsTestCase(unittest.TestCase): def setUp(self): random.seed(4245) - self.event=random_event() - self.block=generate_one_simple_block( - nb_segment=2, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) - self.segment=generate_one_simple_segment( - supported_objects=[neo.core.Segment, neo.core.Event]) def test__get_all_events__event(self): - obj = self.event + obj = random_event() res0 = nt.get_all_events(obj) targ = obj @@ -1172,11 +1166,14 @@ def test__get_all_events__event(self): assert_same_sub_schema(targ, res0[0]) def test__get_all_events__segment(self): - obj = copy.deepcopy(self.segment) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.Event]) + targ = copy.deepcopy(obj) + obj.events.extend(obj.events) res0 = nt.get_all_events(obj) - targ = self.segment.events + targ = targ.events self.assertTrue(len(res0) > 0) @@ -1185,14 +1182,17 @@ def test__get_all_events__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_events__block(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) + targ = copy.deepcopy(obj) + iobj1 = obj.segments[0] obj.segments.append(iobj1) iobj2 = obj.segments[0].events[1] obj.segments[1].events.append(iobj2) res0 = nt.get_all_events(obj) - targ = fake_neo('Block', seed=0, n=3) targ = targ.list_children_by_class('Event') self.assertTrue(len(res0) > 0) @@ -1202,7 +1202,11 @@ def test__get_all_events__block(self): assert_same_sub_schema(targ, res0) def test__get_all_events__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1211,7 +1215,6 @@ def test__get_all_events__list(self): obj.append(obj[-1]) res0 = nt.get_all_events(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1222,7 +1225,11 @@ def test__get_all_events__list(self): assert_same_sub_schema(targ, res0) def test__get_all_events__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1231,7 +1238,6 @@ def test__get_all_events__tuple(self): obj.append(obj[0]) res0 = nt.get_all_events(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1242,7 +1248,11 @@ def test__get_all_events__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_events__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1251,7 +1261,6 @@ def test__get_all_events__iter(self): obj.append(obj[0]) res0 = nt.get_all_events(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1262,7 +1271,11 @@ def test__get_all_events__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_events__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1272,7 +1285,6 @@ def test__get_all_events__dict(self): obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_events(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) From 0655c494f20deafffd348e5c17065f3140f3c344 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 09:56:35 +0100 Subject: [PATCH 28/78] Fixed Epochs and Spiketrain tests --- elephant/test/test_neo_tools.py | 165 +++++++++++++++++++------------- 1 file changed, 100 insertions(+), 65 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 86808e050..d018ebd0b 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -1017,7 +1017,7 @@ def test__extract_neo_attrs__event_parents_parentfirst_array(self): class GetAllSpiketrainsTestCase(unittest.TestCase): def test__get_all_spiketrains__spiketrain(self): - obj = fake_neo('SpikeTrain', seed=0, n=5) + obj = random_spiketrain() res0 = nt.get_all_spiketrains(obj) targ = obj @@ -1026,25 +1026,32 @@ def test__get_all_spiketrains__spiketrain(self): assert_same_sub_schema(targ, res0[0]) - def test__get_all_spiketrains__unit(self): - obj = fake_neo('Unit', seed=0, n=7) - obj.spiketrains.append(obj.spiketrains[0]) - res0 = nt.get_all_spiketrains(obj) - - targ = fake_neo('Unit', seed=0, n=7).spiketrains - - self.assertTrue(len(res0) > 0) - - self.assertEqual(len(targ), len(res0)) - - assert_same_sub_schema(targ, res0) + # Todo: Units are no longer supported, but is a test for neo.Group required instead? + # def test__get_all_spiketrains__unit(self): + # obj = generate_one_simple_block( + # nb_segment=3, + # supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.Group]) + # targ = copy.deepcopy(obj) + # + # obj.groups[0].spiketrains.append(obj.groups[0].spiketrains[0]) + # res0 = nt.get_all_spiketrains(obj) + # + # targ = targ.spiketrains + # + # self.assertTrue(len(res0) > 0) + # + # self.assertEqual(len(targ), len(res0)) + # + # assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__segment(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.SpikeTrain]) + targ = copy.deepcopy(obj) obj.spiketrains.extend(obj.spiketrains) res0 = nt.get_all_spiketrains(obj) - targ = fake_neo('Segment', seed=0, n=5).spiketrains + targ = targ.spiketrains self.assertTrue(len(res0) > 0) @@ -1053,14 +1060,17 @@ def test__get_all_spiketrains__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__block(self): - obj = fake_neo('Block', seed=0, n=3) - iobj1 = obj.channel_indexes[0].units[0] - obj.channel_indexes[0].units.append(iobj1) - iobj2 = obj.channel_indexes[0].units[2].spiketrains[1] - obj.channel_indexes[1].units[1].spiketrains.append(iobj2) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + targ = copy.deepcopy(obj) + + iobj1 = obj.segments[0] + obj.segments.append(iobj1) + iobj2 = obj.segments[0].spiketrains[1] + obj.segments[1].spiketrains.append(iobj2) res0 = nt.get_all_spiketrains(obj) - targ = fake_neo('Block', seed=0, n=3) targ = targ.list_children_by_class('SpikeTrain') self.assertTrue(len(res0) > 0) @@ -1070,16 +1080,18 @@ def test__get_all_spiketrains__block(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] - obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) res0 = nt.get_all_spiketrains(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1090,16 +1102,19 @@ def test__get_all_spiketrains__list(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + targ = copy.deepcopy(obj) + obj.append(obj[-1]) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[0]) res0 = nt.get_all_spiketrains(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1110,16 +1125,19 @@ def test__get_all_spiketrains__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[1]) + res0 = nt.get_all_spiketrains(obj) res0 = nt.get_all_spiketrains(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1130,17 +1148,20 @@ def test__get_all_spiketrains__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[1]) + res0 = nt.get_all_spiketrains(obj) obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_spiketrains(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1152,9 +1173,6 @@ def test__get_all_spiketrains__dict(self): class GetAllEventsTestCase(unittest.TestCase): - def setUp(self): - random.seed(4245) - def test__get_all_events__event(self): obj = random_event() res0 = nt.get_all_events(obj) @@ -1297,7 +1315,7 @@ def test__get_all_events__dict(self): class GetAllEpochsTestCase(unittest.TestCase): def test__get_all_epochs__epoch(self): - obj = fake_neo('Epoch', seed=0, n=5) + obj = random_epoch() res0 = nt.get_all_epochs(obj) targ = obj @@ -1307,11 +1325,13 @@ def test__get_all_epochs__epoch(self): assert_same_sub_schema(targ, res0[0]) def test__get_all_epochs__segment(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.Epoch]) + targ = copy.deepcopy(obj) obj.epochs.extend(obj.epochs) res0 = nt.get_all_epochs(obj) - targ = fake_neo('Segment', seed=0, n=5).epochs + targ = targ.epochs self.assertTrue(len(res0) > 0) @@ -1320,14 +1340,17 @@ def test__get_all_epochs__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__block(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) + targ = copy.deepcopy(obj) + iobj1 = obj.segments[0] obj.segments.append(iobj1) iobj2 = obj.segments[0].epochs[1] obj.segments[1].epochs.append(iobj2) res0 = nt.get_all_epochs(obj) - targ = fake_neo('Block', seed=0, n=3) targ = targ.list_children_by_class('Epoch') self.assertTrue(len(res0) > 0) @@ -1337,7 +1360,11 @@ def test__get_all_epochs__block(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1346,7 +1373,6 @@ def test__get_all_epochs__list(self): obj.append(obj[-1]) res0 = nt.get_all_epochs(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1357,7 +1383,11 @@ def test__get_all_epochs__list(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1366,7 +1396,6 @@ def test__get_all_epochs__tuple(self): obj.append(obj[0]) res0 = nt.get_all_epochs(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1377,7 +1406,11 @@ def test__get_all_epochs__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1386,7 +1419,6 @@ def test__get_all_epochs__iter(self): obj.append(obj[0]) res0 = nt.get_all_epochs(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1397,7 +1429,11 @@ def test__get_all_epochs__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1407,7 +1443,6 @@ def test__get_all_epochs__dict(self): obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_epochs(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) From 24b5b769f18bb359d19751af1fa5e065c8904edc Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 15:31:20 +0100 Subject: [PATCH 29/78] Starting to fix ExtractNeoAttrs --- elephant/test/test_neo_tools.py | 67 +++++++++++++++++++++------------ 1 file changed, 42 insertions(+), 25 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index d018ebd0b..4285c0288 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -100,7 +100,7 @@ def test__get_all_objs__list_float_valueerror(self): nt._get_all_objs(value, 'Block') def test__get_all_objs__epoch_for_event_valueerror(self): - value = random_epoch() + value = self.epoch with self.assertRaises(ValueError): nt._get_all_objs(value, 'Event') @@ -268,7 +268,9 @@ def test__get_all_objs__block_epoch(self): class ExtractNeoAttrsTestCase(unittest.TestCase): def setUp(self): self.maxDiff = None - self.block = fake_neo('Block', seed=0) + self.block = generate_one_simple_block( + nb_segment=3, + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.Event, neo.core.Epoch]) def assert_dicts_equal(self, d1, d2): """Assert that two dictionaries are equal, taking into account arrays. @@ -310,8 +312,11 @@ def assert_dicts_equal(self, d1, d2): raise def test__extract_neo_attrs__spiketrain_noarray(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -333,9 +338,13 @@ def test__extract_neo_attrs__spiketrain_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) + for key, value in targ.copy().items(): if value is None: del targ[key] @@ -361,8 +370,10 @@ def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__epoch_noarray(self): - obj = fake_neo('Epoch', seed=0) - targ = get_fake_values('Epoch', seed=0) + obj = random_epoch() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -384,8 +395,10 @@ def test__extract_neo_attrs__epoch_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__event_noarray(self): - obj = fake_neo('Event', seed=0) - targ = get_fake_values('Event', seed=0) + obj = random_event() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -637,10 +650,14 @@ def test__extract_neo_attrs__spiketrain_noparents_array(self): def test__extract_neo_attrs__epoch_noparents_array(self): obj = self.block.list_children_by_class('Epoch')[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs - obj = self._fix_neo_issue_749(obj, targ) + # obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -653,19 +670,19 @@ def test__extract_neo_attrs__epoch_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - + # del res00['i'] + # del res10['i'] + # del res20['i'] + # del res01['i'] + # del res11['i'] + # del res21['i'] + # del res00['j'] + # del res10['j'] + # del res20['j'] + # del res01['j'] + # del res11['j'] + # del res21['j'] + # self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) From 454fc17841ad33963b1e936ad67ad8a79a3fa53d Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 17:19:34 +0100 Subject: [PATCH 30/78] 7 more failing tests for ExtractNeoAttrs --- elephant/test/test_neo_tools.py | 260 ++++++++++++++++---------------- 1 file changed, 133 insertions(+), 127 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 4285c0288..deb6ec586 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -25,7 +25,7 @@ 'times', 'durations', 'labels', - 'index', + # 'index', 'channel_names', 'channel_ids', 'coordinates', @@ -270,7 +270,10 @@ def setUp(self): self.maxDiff = None self.block = generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.Event, neo.core.Epoch]) + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, + neo.core.Event, neo.core.Epoch]) def assert_dicts_equal(self, d1, d2): """Assert that two dictionaries are equal, taking into account arrays. @@ -468,10 +471,11 @@ def _fix_neo_issue_749(obj, targ): return obj def test__extract_neo_attrs__epoch_parents_empty_array(self): - obj = fake_neo('Epoch', seed=0) - targ = get_fake_values('Epoch', seed=0) + obj = random_epoch() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -509,8 +513,10 @@ def test__extract_neo_attrs__epoch_parents_empty_array(self): self.assert_dicts_equal(targ, res211) def test__extract_neo_attrs__event_parents_empty_array(self): - obj = fake_neo('Event', seed=0) - targ = get_fake_values('Event', seed=0) + obj = random_event() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -571,7 +577,13 @@ def test__extract_neo_attrs__spiketrain_noparents_noarray(self): def test__extract_neo_attrs__epoch_noparents_noarray(self): obj = self.block.list_children_by_class('Epoch')[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -580,20 +592,17 @@ def test__extract_neo_attrs__epoch_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) def test__extract_neo_attrs__event_noparents_noarray(self): obj = self.block.list_children_by_class('Event')[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -602,13 +611,6 @@ def test__extract_neo_attrs__event_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) @@ -657,7 +659,6 @@ def test__extract_neo_attrs__epoch_noparents_array(self): targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs - # obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -670,19 +671,6 @@ def test__extract_neo_attrs__epoch_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - # del res00['i'] - # del res10['i'] - # del res20['i'] - # del res01['i'] - # del res11['i'] - # del res21['i'] - # del res00['j'] - # del res10['j'] - # del res20['j'] - # del res01['j'] - # del res11['j'] - # del res21['j'] - # self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -692,7 +680,13 @@ def test__extract_neo_attrs__epoch_noparents_array(self): def test__extract_neo_attrs__event_noparents_array(self): obj = self.block.list_children_by_class('Event')[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -705,19 +699,6 @@ def test__extract_neo_attrs__event_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -761,23 +742,25 @@ def test__extract_neo_attrs__epoch_parents_childfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Epoch', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -786,23 +769,24 @@ def test__extract_neo_attrs__event_parents_childfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Event', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -836,19 +820,24 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__event_parents_parentfirst_noarray(self): @@ -856,19 +845,24 @@ def test__extract_neo_attrs__event_parents_parentfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): @@ -906,11 +900,19 @@ def test__extract_neo_attrs__epoch_parents_childfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Epoch', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -919,11 +921,6 @@ def test__extract_neo_attrs__epoch_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - ignore_annotations = ('i', 'j') - for res in (res00, res01, res10, res11): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -934,9 +931,19 @@ def test__extract_neo_attrs__event_parents_childfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Event', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -945,15 +952,6 @@ def test__extract_neo_attrs__event_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - del res00['i'] - del res10['i'] - del res01['i'] - del res11['i'] - del res00['j'] - del res10['j'] - del res01['j'] - del res11['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -990,22 +988,25 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) @@ -1014,20 +1015,25 @@ def test__extract_neo_attrs__event_parents_parentfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + del targ['times'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) From efd152c6a64e92405d671f216d5fe45c355f15b0 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 17:31:28 +0100 Subject: [PATCH 31/78] All neo_tools tests fixed for Neo 0.10 --- elephant/test/test_neo_tools.py | 147 +++++++++++++++----------------- 1 file changed, 67 insertions(+), 80 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index deb6ec586..78e666499 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -423,8 +423,10 @@ def test__extract_neo_attrs__event_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__spiketrain_parents_empty_array(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -555,7 +557,10 @@ def test__extract_neo_attrs__event_parents_empty_array(self): def test__extract_neo_attrs__spiketrain_noparents_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -564,13 +569,6 @@ def test__extract_neo_attrs__spiketrain_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) @@ -617,7 +615,13 @@ def test__extract_neo_attrs__event_noparents_noarray(self): def test__extract_neo_attrs__spiketrain_noparents_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -630,19 +634,6 @@ def test__extract_neo_attrs__spiketrain_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -710,30 +701,25 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - rcg = self.block.channel_indexes[0] - unit = self.block.channel_indexes[0].units[0] - - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('ChannelIndex', - seed=rcg.annotations['seed'])) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('SpikeTrain', - seed=obj.annotations['seed'])) + + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -794,25 +780,24 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - rcg = self.block.channel_indexes[0] - unit = self.block.channel_indexes[0].units[0] - - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('ChannelIndex', - seed=rcg.annotations['seed'])) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__epoch_parents_parentfirst_noarray(self): @@ -869,13 +854,20 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - unit = self.block.channel_indexes[0].units[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('SpikeTrain', - seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -884,12 +876,6 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - ignore_annotations = ('i', 'j', 'channel_names', - 'channel_ids', 'coordinates') - for res in (res00, res01, res10, res11): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -961,25 +947,26 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - unit = self.block.channel_indexes[0].units[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + del targ['times'] - del targ['index'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - ignore_annotations = ('i', 'j', 'index', 'channel_names', - 'channel_ids', 'coordinates') - for res in (res0, res1): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) From 35e78beac1b02f41891666bc8e51e1e476d7c52b Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 4 Feb 2022 17:34:28 +0100 Subject: [PATCH 32/78] Enabled dataset generators from neo 0.10.0 --- elephant/test/generate_datasets.py | 394 ----------------------------- elephant/test/test_neo_tools.py | 2 +- requirements/requirements.txt | 2 +- 3 files changed, 2 insertions(+), 396 deletions(-) delete mode 100644 elephant/test/generate_datasets.py diff --git a/elephant/test/generate_datasets.py b/elephant/test/generate_datasets.py deleted file mode 100644 index b8af584b1..000000000 --- a/elephant/test/generate_datasets.py +++ /dev/null @@ -1,394 +0,0 @@ -''' -Generate datasets for testing -''' - -from datetime import datetime -import random -import string -import numpy as np -from numpy.random import rand -import quantities as pq - -from neo.core import (AnalogSignal, Block, Epoch, Event, IrregularlySampledSignal, Group, - Segment, SpikeTrain, ImageSequence, ChannelView, - CircularRegionOfInterest, RectangularRegionOfInterest, - PolygonRegionOfInterest) - -TEST_ANNOTATIONS = [1, 0, 1.5, "this is a test", datetime.fromtimestamp(424242424), None] - - -def random_string(length=10): - return "".join(random.choice(string.ascii_letters) for i in range(length)) - - -def random_datetime(min_year=1990, max_year=datetime.now().year): - start = datetime(min_year, 1, 1, 0, 0, 0) - end = datetime(max_year, 12, 31, 23, 59, 59) - return start + (end - start) * random.random() - - -def random_annotations(n=1): - annotation_generators = ( - random.random, - random_datetime, - random_string, - lambda: None - ) - annotations = {} - for i in range(n): - var_name = random_string(6) - annotation_generator = random.choice(annotation_generators) - annotations[var_name] = annotation_generator() - return annotations - - -def random_signal(name=None, **annotations): - n_channels = random.randint(1, 7) - sig_length = random.randint(20, 200) - if len(annotations) == 0: - annotations = random_annotations(5) - obj = AnalogSignal( - np.random.uniform(size=(sig_length, n_channels)), - units=random.choice(("mV", "nA")), - t_start=random.uniform(0, 10) * pq.ms, - sampling_rate=random.uniform(0.1, 10) * pq.kHz, - name=name or random_string(), - file_origin=random_string(), - description=random_string(100), - array_annotations=None, # todo - **annotations - ) - return obj - - -def random_irreg_signal(name=None, **annotations): - n_channels = random.randint(1, 7) - sig_length = random.randint(20, 200) - if len(annotations) == 0: - annotations = random_annotations(5) - mean_firing_rate = np.random.uniform(0.1, 10) * pq.kHz - times = np.cumsum(np.random.uniform(1.0 / mean_firing_rate, size=(sig_length,))) * pq.ms - obj = IrregularlySampledSignal( - times, - np.random.uniform(size=(sig_length, n_channels)), - units=random.choice(("mV", "nA")), - name=name or random_string(), - file_origin=random_string(), - description=random_string(100), - array_annotations=None, # todo - **annotations - ) - return obj - - -def random_event(name=None, **annotations): - size = random.randint(1, 7) - times = np.cumsum(np.random.uniform(5, 10, size=size)) - labels = [random_string() for i in range(size)] - if len(annotations) == 0: - annotations = random_annotations(3) - obj = Event( - times=times, - labels=labels, - units="ms", - name=name or random_string(), - array_annotations=None, # todo - **annotations - ) - return obj - - -def random_epoch(): - size = random.randint(1, 7) - times = np.cumsum(np.random.uniform(5, 10, size=size)) - durations = np.random.uniform(1, 3, size=size) - labels = [random_string() for i in range(size)] - obj = Epoch( - times=times, - durations=durations, - labels=labels, - units="ms", - name=random_string(), - array_annotations=None, # todo - **random_annotations(3) - ) - return obj - - -def random_spiketrain(name=None, **annotations): - size = random.randint(1, 50) - times = np.cumsum(np.random.uniform(0.5, 10, size=size)) - if len(annotations) == 0: - annotations = random_annotations(3) - # todo: waveforms - obj = SpikeTrain( - times=times, - t_stop=times[-1] + random.uniform(0, 5), - units="ms", - name=name or random_string(), - array_annotations=None, # todo - **annotations - ) - return obj - - -def random_segment(): - seg = Segment( - name=random_string(10), - description=random_string(100), - file_origin=random_string(20), - file_datetime=random_datetime(), - rec_datetime=random_datetime(), - **random_annotations(4) - ) - n_sigs = random.randint(0, 5) - for i in range(n_sigs): - seg.analogsignals.append(random_signal()) - n_irrsigs = random.randint(0, 5) - for i in range(n_irrsigs): - seg.irregularlysampledsignals.append(random_irreg_signal()) - n_events = random.randint(0, 3) - for i in range(n_events): - seg.events.append(random_event()) - n_epochs = random.randint(0, 3) - for i in range(n_epochs): - seg.epochs.append(random_epoch()) - n_spiketrains = random.randint(0, 20) - for i in range(n_spiketrains): - seg.spiketrains.append(random_spiketrain()) - # todo: add some ImageSequence and ROI objects - - for child in seg.data_children: - child.segment = seg - return seg - - -def random_group(candidates): - if len(candidates) == 0: - return None - elif len(candidates) == 1: - objects = candidates - else: - k = random.randint(1, len(candidates)) - objects = random.sample(candidates, k) - obj = Group(objects=objects, - name=random_string(), - **random_annotations(5)) - return obj - - -def random_channelview(signal): - n_channels = signal.shape[1] - if n_channels > 2: - view_size = np.random.randint(1, n_channels - 1) - index = np.random.choice(np.arange(signal.shape[1]), view_size, replace=False) - obj = ChannelView( - signal, - index, - name=random_string(), - **random_annotations(3) - ) - return obj - else: - return None - - -def random_block(): - block = Block( - name=random_string(10), - description=random_string(100), - file_origin=random_string(20), - file_datetime=random_datetime(), - rec_datetime=random_datetime(), - **random_annotations(6) - ) - n_seg = random.randint(0, 5) - for i in range(n_seg): - seg = random_segment() - block.segments.append(seg) - seg.block = block - children = list(block.data_children_recur) - views = [] - for child in children: - if isinstance(child, (AnalogSignal, IrregularlySampledSignal)): - PROB_SIGNAL_HAS_VIEW = 0.5 - if np.random.random_sample() < PROB_SIGNAL_HAS_VIEW: - chv = random_channelview(child) - if chv: - views.append(chv) - children.extend(views) - n_groups = random.randint(0, 5) - for i in range(n_groups): - group = random_group(children) - if group: - block.groups.append(group) - group.block = block - children.append(group) # this can give us nested groups - return block - - -def simple_block(): - block = Block( - name="test block", - species="rat", - brain_region="cortex" - ) - block.segments = [ - Segment(name="test segment #1", - cell_type="spiny stellate"), - Segment(name="test segment #2", - cell_type="pyramidal", - thing="amajig") - ] - for segment in block.segments: - segment.block = block - block.segments[0].analogsignals.extend(( - random_signal(name="signal #1 in segment #1", thing="wotsit"), - random_signal(name="signal #2 in segment #1", thing="frooble"), - )) - block.segments[1].analogsignals.extend(( - random_signal(name="signal #1 in segment #2", thing="amajig"), - )) - block.segments[1].irregularlysampledsignals.extend(( - random_irreg_signal(name="signal #1 in segment #2", thing="amajig"), - )) - block.segments[0].events.extend(( - random_event(name="event array #1 in segment #1", thing="frooble"), - )) - block.segments[1].events.extend(( - random_event(name="event array #1 in segment #2", thing="wotsit"), - )) - block.segments[0].spiketrains.extend(( - random_spiketrain(name="spiketrain #1 in segment #1", thing="frooble"), - random_spiketrain(name="spiketrain #2 in segment #1", thing="wotsit") - )) - return block - - -def generate_one_simple_block(block_name='block_0', nb_segment=3, supported_objects=[], **kws): - if supported_objects and Block not in supported_objects: - raise ValueError('Block must be in supported_objects') - bl = Block() # name = block_name) - - objects = supported_objects - if Segment in objects: - for s in range(nb_segment): - seg = generate_one_simple_segment(seg_name="seg" + str(s), supported_objects=objects, - **kws) - bl.segments.append(seg) - - # if RecordingChannel in objects: - # populate_RecordingChannel(bl) - - bl.create_many_to_one_relationship() - return bl - - -def generate_one_simple_segment(seg_name='segment 0', supported_objects=[], nb_analogsignal=4, - t_start=0. * pq.s, sampling_rate=10 * pq.kHz, duration=6. * pq.s, - - nb_spiketrain=6, spikerate_range=[.5 * pq.Hz, 12 * pq.Hz], - - event_types={'stim': ['a', 'b', 'c', 'd'], - 'enter_zone': ['one', 'two'], - 'color': ['black', 'yellow', 'green'], }, - event_size_range=[5, 20], - - epoch_types={'animal state': ['Sleep', 'Freeze', 'Escape'], - 'light': ['dark', 'lighted']}, - epoch_duration_range=[.5, 3.], - # this should be multiplied by pq.s, no? - - array_annotations={'valid': np.array([True, False]), - 'number': np.array(range(5))} - - ): - if supported_objects and Segment not in supported_objects: - raise ValueError('Segment must be in supported_objects') - seg = Segment(name=seg_name) - if AnalogSignal in supported_objects: - for a in range(nb_analogsignal): - anasig = AnalogSignal(rand(int((sampling_rate * duration).simplified)), - sampling_rate=sampling_rate, - t_start=t_start, units=pq.mV, channel_index=a, - name='sig %d for segment %s' % (a, seg.name)) - seg.analogsignals.append(anasig) - - if SpikeTrain in supported_objects: - for s in range(nb_spiketrain): - spikerate = rand() * np.diff(spikerate_range) - spikerate += spikerate_range[0].magnitude - # spikedata = rand(int((spikerate*duration).simplified))*duration - # sptr = SpikeTrain(spikedata, - # t_start=t_start, t_stop=t_start+duration) - # #, name = 'spiketrain %d'%s) - spikes = rand(int((spikerate * duration).simplified)) - spikes.sort() # spikes are supposed to be an ascending sequence - sptr = SpikeTrain(spikes * duration, t_start=t_start, t_stop=t_start + duration) - sptr.annotations['channel_index'] = s - # Randomly generate array_annotations from given options - arr_ann = {key: value[(rand(len(spikes)) * len(value)).astype('i')] for (key, value) in - array_annotations.items()} - sptr.array_annotate(**arr_ann) - seg.spiketrains.append(sptr) - - if Event in supported_objects: - for name, labels in event_types.items(): - evt_size = rand() * np.diff(event_size_range) - evt_size += event_size_range[0] - evt_size = int(evt_size) - labels = np.array(labels, dtype='U') - labels = labels[(rand(evt_size) * len(labels)).astype('i')] - evt = Event(times=rand(evt_size) * duration, labels=labels) - # Randomly generate array_annotations from given options - arr_ann = {key: value[(rand(evt_size) * len(value)).astype('i')] for (key, value) in - array_annotations.items()} - evt.array_annotate(**arr_ann) - seg.events.append(evt) - - if Epoch in supported_objects: - for name, labels in epoch_types.items(): - t = 0 - times = [] - durations = [] - while t < duration: - times.append(t) - dur = rand() * (epoch_duration_range[1] - epoch_duration_range[0]) - dur += epoch_duration_range[0] - durations.append(dur) - t = t + dur - labels = np.array(labels, dtype='U') - labels = labels[(rand(len(times)) * len(labels)).astype('i')] - assert len(times) == len(durations) - assert len(times) == len(labels) - epc = Epoch(times=pq.Quantity(times, units=pq.s), - durations=pq.Quantity(durations, units=pq.s), - labels=labels,) - assert epc.times.dtype == 'float' - # Randomly generate array_annotations from given options - arr_ann = {key: value[(rand(len(times)) * len(value)).astype('i')] for (key, value) in - array_annotations.items()} - epc.array_annotate(**arr_ann) - seg.epochs.append(epc) - - # TODO : Spike, Event - - seg.create_many_to_one_relationship() - return seg - - -def generate_from_supported_objects(supported_objects): - # ~ create_many_to_one_relationship - if not supported_objects: - raise ValueError('No objects specified') - objects = supported_objects - if Block in supported_objects: - higher = generate_one_simple_block(supported_objects=objects) - elif Segment in objects: - higher = generate_one_simple_segment(supported_objects=objects) - else: - # TODO - return None - - higher.create_many_to_one_relationship() - return higher diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 78e666499..f50f6300a 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -12,7 +12,7 @@ import neo.core -from .generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ +from neo.test.generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ random_event, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema from numpy.testing.utils import assert_array_equal diff --git a/requirements/requirements.txt b/requirements/requirements.txt index e89638ae3..25f8e040b 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,4 +1,4 @@ -neo>=0.9.0,<0.10.0 +neo>=0.10.0 numpy>=1.18.1 quantities>=0.12.1 scipy<1.7.0 From 29727f2fbf6a2900e43540a7077b3e2eb1d635ed Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 16:05:35 +0100 Subject: [PATCH 33/78] This PR adds SpikeTrainList as output of `get_all_spiketrains()`` --- elephant/neo_tools.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/elephant/neo_tools.py b/elephant/neo_tools.py index e2cd4da84..f5ebde3a5 100644 --- a/elephant/neo_tools.py +++ b/elephant/neo_tools.py @@ -19,6 +19,7 @@ from itertools import chain +from neo.core.spiketrainlist import SpikeTrainList from neo.core.container import unique_objs from elephant.utils import deprecated_alias @@ -183,7 +184,7 @@ def get_all_spiketrains(container): A list of the unique `neo.SpikeTrain` objects in `container`. """ - return _get_all_objs(container, 'SpikeTrain') + return SpikeTrainList(_get_all_objs(container, 'SpikeTrain')) def get_all_events(container): From 6d5b88f6cde25b93578b8d101f2f4ee73408af30 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 16:08:43 +0100 Subject: [PATCH 34/78] Use SpikeTrainList, work around SpikeTrainList.extend() bug. --- elephant/test/test_neo_tools.py | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index f50f6300a..9308c5b69 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -11,10 +11,14 @@ import unittest import neo.core +# TODO: In Neo 0.10.0, SpikeTrainList ist not exposed in __init__.py of neo.core. Remove the +# following line if SpikeTrainList is accessible via neo.core +from neo.core.spiketrainlist import SpikeTrainList from neo.test.generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ random_event, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema + from numpy.testing.utils import assert_array_equal import elephant.neo_tools as nt @@ -1058,7 +1062,11 @@ def test__get_all_spiketrains__segment(self): obj = generate_one_simple_segment( supported_objects=[neo.core.Segment, neo.core.SpikeTrain]) targ = copy.deepcopy(obj) - obj.spiketrains.extend(obj.spiketrains) + obj.spiketrains.append(obj.spiketrains[0]) + # TODO: The following is the original line of the test, however, this fails with Neo 0.10.0 + # Reinstate once issue is fixed + # obj.spiketrains.extend(obj.spiketrains) + res0 = nt.get_all_spiketrains(obj) targ = targ.spiketrains @@ -1081,7 +1089,7 @@ def test__get_all_spiketrains__block(self): obj.segments[1].spiketrains.append(iobj2) res0 = nt.get_all_spiketrains(obj) - targ = targ.list_children_by_class('SpikeTrain') + targ = SpikeTrainList(targ.list_children_by_class('SpikeTrain')) self.assertTrue(len(res0) > 0) @@ -1103,7 +1111,7 @@ def test__get_all_spiketrains__list(self): res0 = nt.get_all_spiketrains(obj) targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1126,7 +1134,7 @@ def test__get_all_spiketrains__tuple(self): res0 = nt.get_all_spiketrains(tuple(obj)) targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1149,7 +1157,7 @@ def test__get_all_spiketrains__iter(self): res0 = nt.get_all_spiketrains(iter(obj)) targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1173,7 +1181,7 @@ def test__get_all_spiketrains__dict(self): res0 = nt.get_all_spiketrains(obj) targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) From f9beee8ec617276efd8f3bf05d055871c0bfd8e7 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 16:09:06 +0100 Subject: [PATCH 35/78] Fix pandas_bridge tests to work without fake_neo() --- elephant/test/test_pandas_bridge.py | 687 +++++++++++++++++++--------- 1 file changed, 466 insertions(+), 221 deletions(-) diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 5a94b4a3b..892e01e31 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -13,7 +13,9 @@ import numpy as np import quantities as pq -from neo.test.generate_datasets import fake_neo +import neo.core +from neo.test.generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ + random_event, random_epoch, random_spiketrain from numpy.testing import assert_array_equal try: @@ -167,7 +169,7 @@ def test__convert_value_safe__quantity_scalar(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class SpiketrainToDataframeTestCase(unittest.TestCase): def test__spiketrain_to_dataframe__parents_empty(self): - obj = fake_neo('SpikeTrain', seed=0) + obj = random_spiketrain() res0 = ep.spiketrain_to_dataframe(obj) res1 = ep.spiketrain_to_dataframe(obj, child_first=True) @@ -270,7 +272,13 @@ def test__spiketrain_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj, parents=False) @@ -320,7 +328,13 @@ def test__spiketrain_to_dataframe__noparents(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj) res1 = ep.spiketrain_to_dataframe(obj, child_first=True) @@ -375,7 +389,13 @@ def test__spiketrain_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj, child_first=False) res1 = ep.spiketrain_to_dataframe(obj, parents=True, child_first=False) @@ -415,7 +435,7 @@ def test__spiketrain_to_dataframe__parents_parentfirst(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class EventToDataframeTestCase(unittest.TestCase): def test__event_to_dataframe__parents_empty(self): - obj = fake_neo('Event', seed=42) + obj = random_event() res0 = ep.event_to_dataframe(obj) res1 = ep.event_to_dataframe(obj, child_first=True) @@ -523,7 +543,13 @@ def test__event_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__event_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj, parents=False) @@ -573,7 +599,13 @@ def test__event_to_dataframe__noparents(self): assert_index_equal(value, level) def test__event_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj) @@ -632,7 +664,13 @@ def test__event_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__event_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj, child_first=False) res1 = ep.event_to_dataframe(obj, parents=True, child_first=False) @@ -674,7 +712,7 @@ def test__event_to_dataframe__parents_parentfirst(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class EpochToDataframeTestCase(unittest.TestCase): def test__epoch_to_dataframe__parents_empty(self): - obj = fake_neo('Epoch', seed=42) + obj = random_epoch() res0 = ep.epoch_to_dataframe(obj) res1 = ep.epoch_to_dataframe(obj, child_first=True) @@ -806,7 +844,13 @@ def test__epoch_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__epoch_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj, parents=False) @@ -867,7 +911,13 @@ def test__epoch_to_dataframe__noparents(self): assert_index_equal(value, level) def test__epoch_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj) @@ -939,7 +989,13 @@ def test__epoch_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__epoch_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj, child_first=False) @@ -995,7 +1051,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_spiketrains_to_dataframe__single(self): - obj = fake_neo('SpikeTrain', seed=0, n=5) + obj = random_spiketrain() res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False) @@ -1074,40 +1130,13 @@ def test__multi_spiketrains_to_dataframe__single(self): assert_frame_equal(targ, res7) assert_frame_equal(targ, res8) - def test__multi_spiketrains_to_dataframe__unit_default(self): - obj = fake_neo('Unit', seed=0, n=5) - - res0 = ep.multi_spiketrains_to_dataframe(obj) - - objs = obj.spiketrains - - targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs] - targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1) - - keys = ep._extract_neo_attrs_safe(objs[0], parents=True, - child_first=True).keys() - keys = list(keys) - - targwidth = len(objs) - targlen = max(len(iobj) for iobj in objs) - - self.assertGreater(len(objs), 0) - - self.assertEqual(targwidth, len(targ.columns)) - self.assertEqual(targwidth, len(res0.columns)) - - self.assertEqual(targlen, len(targ.index)) - self.assertEqual(targlen, len(res0.index)) - - self.assertCountEqual(keys, targ.columns.names) - self.assertCountEqual(keys, res0.columns.names) - - assert_array_equal(targ.values, res0.values) - - assert_frame_equal(targ, res0) - def test__multi_spiketrains_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1138,7 +1167,13 @@ def test__multi_spiketrains_to_dataframe__segment_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False, @@ -1186,7 +1221,13 @@ def test__multi_spiketrains_to_dataframe__block_noparents(self): assert_frame_equal(targ, res2) def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True) @@ -1239,7 +1280,13 @@ def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True, @@ -1280,7 +1327,15 @@ def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False, @@ -1329,7 +1384,15 @@ def test__multi_spiketrains_to_dataframe__list_noparents(self): assert_frame_equal(targ, res2) def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True) @@ -1383,7 +1446,15 @@ def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True, @@ -1425,7 +1496,15 @@ def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1458,7 +1537,15 @@ def test__multi_spiketrains_to_dataframe__tuple_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(iter(obj)) @@ -1490,7 +1577,16 @@ def test__multi_spiketrains_to_dataframe__iter_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + (i, generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1530,7 +1626,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_events_to_dataframe__single(self): - obj = fake_neo('Event', seed=0, n=5) + obj = random_event() res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=False) @@ -1609,7 +1705,12 @@ def test__multi_events_to_dataframe__single(self): assert_frame_equal(targ, res8) def test__multi_events_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj) @@ -1638,14 +1739,20 @@ def test__multi_events_to_dataframe__segment_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj, parents=False) res1 = ep.multi_events_to_dataframe(obj, parents=False, @@ -1685,22 +1792,28 @@ def test__multi_events_to_dataframe__block_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_events_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=True) @@ -1743,18 +1856,18 @@ def test__multi_events_to_dataframe__block_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -1762,7 +1875,13 @@ def test__multi_events_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_events_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj, child_first=False) res1 = ep.multi_events_to_dataframe(obj, parents=True, @@ -1797,18 +1916,26 @@ def test__multi_events_to_dataframe__block_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj, parents=False) res1 = ep.multi_events_to_dataframe(obj, parents=False, @@ -1849,22 +1976,30 @@ def test__multi_events_to_dataframe__list_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_events_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=True) @@ -1908,18 +2043,18 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -1927,7 +2062,15 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_events_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj, child_first=False) res1 = ep.multi_events_to_dataframe(obj, parents=True, @@ -1963,18 +2106,26 @@ def test__multi_events_to_dataframe__list_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = tuple([generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)]) + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) @@ -2004,14 +2155,22 @@ def test__multi_events_to_dataframe__tuple_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(iter(obj)) @@ -2040,14 +2199,23 @@ def test__multi_events_to_dataframe__iter_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + (i, generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) @@ -2077,9 +2245,9 @@ def test__multi_events_to_dataframe__dict_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) @@ -2091,7 +2259,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_epochs_to_dataframe__single(self): - obj = fake_neo('Epoch', seed=0, n=5) + obj = random_epoch() res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=False) @@ -2170,7 +2338,12 @@ def test__multi_epochs_to_dataframe__single(self): assert_frame_equal(targ, res8) def test__multi_epochs_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test1=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2185,7 +2358,7 @@ def test__multi_epochs_to_dataframe__segment_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2198,14 +2371,20 @@ def test__multi_epochs_to_dataframe__segment_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test1=5) res0 = ep.multi_epochs_to_dataframe(obj, parents=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=False, @@ -2226,7 +2405,7 @@ def test__multi_epochs_to_dataframe__block_noparents(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2245,22 +2424,28 @@ def test__multi_epochs_to_dataframe__block_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_epochs_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=True) @@ -2281,7 +2466,7 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2303,18 +2488,18 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -2322,7 +2507,13 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, child_first=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=True, @@ -2341,7 +2532,7 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2357,18 +2548,26 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, parents=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=False, @@ -2390,7 +2589,7 @@ def test__multi_epochs_to_dataframe__list_noparents(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2409,22 +2608,30 @@ def test__multi_epochs_to_dataframe__list_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_epochs_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=True) @@ -2446,7 +2653,7 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2468,18 +2675,18 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -2487,7 +2694,15 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, child_first=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=True, @@ -2507,7 +2722,7 @@ def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2523,18 +2738,26 @@ def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = tuple([generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)]) + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2551,7 +2774,7 @@ def test__multi_epochs_to_dataframe__tuple_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2564,14 +2787,22 @@ def test__multi_epochs_to_dataframe__tuple_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(iter(obj)) @@ -2587,7 +2818,7 @@ def test__multi_epochs_to_dataframe__iter_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2600,14 +2831,23 @@ def test__multi_epochs_to_dataframe__iter_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + (i, generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2624,7 +2864,7 @@ def test__multi_epochs_to_dataframe__dict_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2637,9 +2877,9 @@ def test__multi_epochs_to_dataframe__dict_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) @@ -2647,7 +2887,12 @@ def test__multi_epochs_to_dataframe__dict_default(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class SliceSpiketrainTestCase(unittest.TestCase): def setUp(self): - obj = [fake_neo('SpikeTrain', seed=i, n=3) for i in range(10)] + obj = [generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + for i in range(10)] self.obj = ep.multi_spiketrains_to_dataframe(obj) def test_single_none(self): From 0d3c9471b3fd7265ae74b820310bd2c931642644 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 16:50:44 +0100 Subject: [PATCH 36/78] PEP8 Line length corrections --- elephant/test/test_neo_tools.py | 269 ++++++++++++++++++++-------- elephant/test/test_pandas_bridge.py | 117 ++++++++---- 2 files changed, 275 insertions(+), 111 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 9308c5b69..c4287dce2 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -11,11 +11,13 @@ import unittest import neo.core -# TODO: In Neo 0.10.0, SpikeTrainList ist not exposed in __init__.py of neo.core. Remove the -# following line if SpikeTrainList is accessible via neo.core +# TODO: In Neo 0.10.0, SpikeTrainList ist not exposed in __init__.py of +# neo.core. Remove the following line if SpikeTrainList is accessible via +# neo.core from neo.core.spiketrainlist import SpikeTrainList -from neo.test.generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ +from neo.test.generate_datasets import generate_one_simple_block, \ + generate_one_simple_segment, \ random_event, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema @@ -23,7 +25,6 @@ import elephant.neo_tools as nt - # A list of neo object attributes that contain arrays. ARRAY_ATTRS = ['waveforms', 'times', @@ -79,7 +80,8 @@ def strip_iter_values(targ, array_attrs=ARRAY_ATTRS): class GetAllObjsTestCase(unittest.TestCase): def setUp(self): random.seed(4245) - self.spiketrain = random_spiketrain('Single SpikeTrain', seed=random.random()) + self.spiketrain = random_spiketrain( + 'Single SpikeTrain', seed=random.random()) self.spiketrain_list = [ random_spiketrain('SpikeTrain', seed=random.random()), random_spiketrain('SpikeTrain', seed=random.random())] @@ -158,7 +160,7 @@ def test__get_all_objs__empty_nested_iter(self): def test__get_all_objs__empty_nested_many(self): targ = [] - value = iter([[], {'c': [], 'd':(iter([]),)}]) + value = iter([[], {'c': [], 'd': (iter([]),)}]) res = nt._get_all_objs(value, 'Block') @@ -212,8 +214,8 @@ def test__get_all_objs__dict_spiketrain(self): res = nt._get_all_objs(value, 'SpikeTrain') self.assertEqual(len(targ), len(res)) - for t, r in zip(targ,res): - assert_same_sub_schema(t, r) + for t, r in zip(targ, res): + assert_same_sub_schema(t, r) def test__get_all_objs__nested_dict_spiketrain(self): targ = self.spiketrain_list @@ -322,7 +324,9 @@ def test__extract_neo_attrs__spiketrain_noarray(self): obj = random_spiketrain() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -348,7 +352,9 @@ def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): obj = random_spiketrain() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -379,7 +385,9 @@ def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): def test__extract_neo_attrs__epoch_noarray(self): obj = random_epoch() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -404,7 +412,9 @@ def test__extract_neo_attrs__epoch_noarray(self): def test__extract_neo_attrs__event_noarray(self): obj = random_event() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -429,7 +439,9 @@ def test__extract_neo_attrs__event_noarray(self): def test__extract_neo_attrs__spiketrain_parents_empty_array(self): obj = random_spiketrain() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -479,7 +491,9 @@ def _fix_neo_issue_749(obj, targ): def test__extract_neo_attrs__epoch_parents_empty_array(self): obj = random_epoch() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -521,7 +535,9 @@ def test__extract_neo_attrs__epoch_parents_empty_array(self): def test__extract_neo_attrs__event_parents_empty_array(self): obj = random_event() targ = copy.deepcopy(obj.annotations) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -563,7 +579,9 @@ def test__extract_neo_attrs__spiketrain_noparents_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -582,7 +600,9 @@ def test__extract_neo_attrs__epoch_noparents_noarray(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs @@ -603,7 +623,9 @@ def test__extract_neo_attrs__event_noparents_noarray(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -622,7 +644,9 @@ def test__extract_neo_attrs__spiketrain_noparents_array(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs @@ -650,7 +674,9 @@ def test__extract_neo_attrs__epoch_noparents_array(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs @@ -678,7 +704,9 @@ def test__extract_neo_attrs__event_noparents_array(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs @@ -707,16 +735,22 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_noarray(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -733,16 +767,22 @@ def test__extract_neo_attrs__epoch_parents_childfirst_noarray(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -760,16 +800,22 @@ def test__extract_neo_attrs__event_parents_childfirst_noarray(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) @@ -787,15 +833,21 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_noarray(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ = strip_iter_values(targ) @@ -811,15 +863,21 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_noarray(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ = strip_iter_values(targ) @@ -836,15 +894,21 @@ def test__extract_neo_attrs__event_parents_parentfirst_noarray(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ = strip_iter_values(targ) @@ -860,16 +924,22 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -891,16 +961,22 @@ def test__extract_neo_attrs__epoch_parents_childfirst_array(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -922,16 +998,22 @@ def test__extract_neo_attrs__event_parents_childfirst_array(self): seg = self.block.segments[0] targ = copy.deepcopy(blk.annotations) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(obj.annotations)) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] @@ -954,15 +1036,21 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_array(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.SpikeTrain._necessary_attrs + neo.SpikeTrain._recommended_attrs): + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) del targ['times'] @@ -981,15 +1069,21 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_array(self): targ = copy.deepcopy(obj.annotations) targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Epoch._necessary_attrs + neo.Epoch._recommended_attrs): + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) del targ['times'] @@ -1007,16 +1101,23 @@ def test__extract_neo_attrs__event_parents_parentfirst_array(self): seg = self.block.segments[0] targ = copy.deepcopy(obj.annotations) - targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) - for i, attr in enumerate(neo.Event._necessary_attrs + neo.Event._recommended_attrs): + targ["array_annotations"] = copy.deepcopy( + dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): targ[attr[0]] = getattr(obj, attr[0]) targ.update(copy.deepcopy(seg.annotations)) - for i, attr in enumerate(neo.Segment._necessary_attrs + neo.Segment._recommended_attrs): + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): targ[attr[0]] = getattr(seg, attr[0]) targ.update(copy.deepcopy(blk.annotations)) - for i, attr in enumerate(neo.Block._necessary_attrs + neo.Block._recommended_attrs): + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): targ[attr[0]] = getattr(blk, attr[0]) del targ['times'] @@ -1044,7 +1145,9 @@ def test__get_all_spiketrains__spiketrain(self): # def test__get_all_spiketrains__unit(self): # obj = generate_one_simple_block( # nb_segment=3, - # supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.Group]) + # supported_objects=[ + # neo.core.Block, neo.core.Segment, + # neo.core.SpikeTrain, neo.core.Group]) # targ = copy.deepcopy(obj) # # obj.groups[0].spiketrains.append(obj.groups[0].spiketrains[0]) @@ -1063,7 +1166,8 @@ def test__get_all_spiketrains__segment(self): supported_objects=[neo.core.Segment, neo.core.SpikeTrain]) targ = copy.deepcopy(obj) obj.spiketrains.append(obj.spiketrains[0]) - # TODO: The following is the original line of the test, however, this fails with Neo 0.10.0 + # TODO: The following is the original line of the test, however, this + # fails with Neo 0.10.0 # Reinstate once issue is fixed # obj.spiketrains.extend(obj.spiketrains) @@ -1123,7 +1227,7 @@ def test__get_all_spiketrains__tuple(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1146,7 +1250,9 @@ def test__get_all_spiketrains__iter(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for i in range(3)] targ = copy.deepcopy(obj) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1169,7 +1275,9 @@ def test__get_all_spiketrains__dict(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] targ = copy.deepcopy(obj) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1241,7 +1349,9 @@ def test__get_all_events__list(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for i in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1264,7 +1374,9 @@ def test__get_all_events__tuple(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for i in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1287,7 +1399,9 @@ def test__get_all_events__iter(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for i in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1310,7 +1424,9 @@ def test__get_all_events__dict(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for i in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1360,7 +1476,8 @@ def test__get_all_epochs__segment(self): def test__get_all_epochs__block(self): obj = generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) targ = copy.deepcopy(obj) iobj1 = obj.segments[0] @@ -1381,7 +1498,9 @@ def test__get_all_epochs__list(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for i in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1404,7 +1523,9 @@ def test__get_all_epochs__tuple(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1427,7 +1548,9 @@ def test__get_all_epochs__iter(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1450,7 +1573,9 @@ def test__get_all_epochs__dict(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Epoch]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 892e01e31..867130b7c 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -276,7 +276,8 @@ def test__spiketrain_to_dataframe__noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('SpikeTrain'): objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] @@ -332,7 +333,8 @@ def test__spiketrain_to_dataframe__parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('SpikeTrain'): objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] @@ -393,7 +395,8 @@ def test__spiketrain_to_dataframe__parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('SpikeTrain'): objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] @@ -547,7 +550,8 @@ def test__event_to_dataframe__noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Event'): objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] @@ -603,7 +607,8 @@ def test__event_to_dataframe__parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Event'): objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] @@ -668,7 +673,8 @@ def test__event_to_dataframe__parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Event'): objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] @@ -848,7 +854,8 @@ def test__epoch_to_dataframe__noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Epoch'): objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] @@ -915,7 +922,8 @@ def test__epoch_to_dataframe__parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Epoch'): objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] @@ -993,7 +1001,8 @@ def test__epoch_to_dataframe__parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in blk.list_children_by_class('Epoch'): objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] @@ -1134,7 +1143,8 @@ def test__multi_spiketrains_to_dataframe__segment_default(self): obj = generate_one_simple_segment( supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('SpikeTrain'): objs.annotate(test1=5) @@ -1171,7 +1181,8 @@ def test__multi_spiketrains_to_dataframe__block_noparents(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('SpikeTrain'): objs.annotate(test1=5) @@ -1225,7 +1236,8 @@ def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('SpikeTrain'): objs.annotate(test1=5) @@ -1284,7 +1296,8 @@ def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('SpikeTrain'): objs.annotate(test1=5) @@ -1331,7 +1344,8 @@ def test__multi_spiketrains_to_dataframe__list_noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): @@ -1388,7 +1402,8 @@ def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): @@ -1450,7 +1465,8 @@ def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): @@ -1500,7 +1516,8 @@ def test__multi_spiketrains_to_dataframe__tuple_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): @@ -1541,7 +1558,8 @@ def test__multi_spiketrains_to_dataframe__iter_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): @@ -1582,7 +1600,8 @@ def test__multi_spiketrains_to_dataframe__dict_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('SpikeTrain'): @@ -1708,7 +1727,8 @@ def test__multi_events_to_dataframe__segment_default(self): obj = generate_one_simple_segment( supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Event'): objs.annotate(test1=5) @@ -1750,7 +1770,8 @@ def test__multi_events_to_dataframe__block_noparents(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Event'): objs.annotate(test1=5) @@ -1811,7 +1832,8 @@ def test__multi_events_to_dataframe__block_parents_childfirst(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Event'): objs.annotate(test1=5) @@ -1879,7 +1901,8 @@ def test__multi_events_to_dataframe__block_parents_parentfirst(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Event'): objs.annotate(test1=5) @@ -1931,7 +1954,8 @@ def test__multi_events_to_dataframe__list_noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): @@ -1995,7 +2019,8 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): @@ -2066,7 +2091,8 @@ def test__multi_events_to_dataframe__list_parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): @@ -2121,7 +2147,8 @@ def test__multi_events_to_dataframe__tuple_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)]) for iobj in obj: for objs in iobj.list_children_by_class('Event'): @@ -2166,7 +2193,8 @@ def test__multi_events_to_dataframe__iter_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): @@ -2211,7 +2239,8 @@ def test__multi_events_to_dataframe__dict_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Event'): @@ -2341,7 +2370,8 @@ def test__multi_epochs_to_dataframe__segment_default(self): obj = generate_one_simple_segment( supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Epoch'): objs.annotate(test1=5) @@ -2382,7 +2412,8 @@ def test__multi_epochs_to_dataframe__block_noparents(self): nb_segment=2, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Epoch'): objs.annotate(test1=5) @@ -2443,7 +2474,8 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2511,7 +2543,8 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for objs in obj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2563,7 +2596,8 @@ def test__multi_epochs_to_dataframe__list_noparents(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): @@ -2627,7 +2661,8 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): @@ -2753,7 +2788,8 @@ def test__multi_epochs_to_dataframe__tuple_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)]) for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): @@ -2798,7 +2834,8 @@ def test__multi_epochs_to_dataframe__iter_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): @@ -2843,7 +2880,8 @@ def test__multi_epochs_to_dataframe__dict_default(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Epoch'): @@ -2891,7 +2929,8 @@ def setUp(self): nb_segment=1, supported_objects=[ neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) for i in range(10)] self.obj = ep.multi_spiketrains_to_dataframe(obj) From db01e3fb341f48a5fad0434cfa7a295185df97ef Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 17:01:12 +0100 Subject: [PATCH 37/78] More PEP8 finishes --- elephant/test/test_neo_tools.py | 29 +-- elephant/test/test_pandas_bridge.py | 290 +++++++++++++++------------- 2 files changed, 175 insertions(+), 144 deletions(-) diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index c4287dce2..b3e262f48 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -1141,7 +1141,8 @@ def test__get_all_spiketrains__spiketrain(self): assert_same_sub_schema(targ, res0[0]) - # Todo: Units are no longer supported, but is a test for neo.Group required instead? + # Todo: Units are no longer supported, but is a test for + # neo.Group required instead? # def test__get_all_spiketrains__unit(self): # obj = generate_one_simple_block( # nb_segment=3, @@ -1184,7 +1185,8 @@ def test__get_all_spiketrains__segment(self): def test__get_all_spiketrains__block(self): obj = generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) targ = copy.deepcopy(obj) iobj1 = obj.segments[0] @@ -1205,7 +1207,9 @@ def test__get_all_spiketrains__list(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for i in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] targ = copy.deepcopy(obj) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1227,7 +1231,9 @@ def test__get_all_spiketrains__tuple(self): obj = [ generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) for _ in range(3)] + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1252,7 +1258,7 @@ def test__get_all_spiketrains__iter(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1328,7 +1334,8 @@ def test__get_all_events__segment(self): def test__get_all_events__block(self): obj = generate_one_simple_block( nb_segment=3, - supported_objects=[neo.core.Block, neo.core.Segment, neo.core.Event]) + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) targ = copy.deepcopy(obj) iobj1 = obj.segments[0] @@ -1351,7 +1358,7 @@ def test__get_all_events__list(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.Event]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1376,7 +1383,7 @@ def test__get_all_events__tuple(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.Event]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1401,7 +1408,7 @@ def test__get_all_events__iter(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.Event]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1426,7 +1433,7 @@ def test__get_all_events__dict(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.Event]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] @@ -1500,7 +1507,7 @@ def test__get_all_epochs__list(self): nb_segment=3, supported_objects=[ neo.core.Block, neo.core.Segment, neo.core.Epoch]) - for i in range(3)] + for _ in range(3)] targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 867130b7c..291785bd8 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -14,7 +14,8 @@ import numpy as np import quantities as pq import neo.core -from neo.test.generate_datasets import generate_one_simple_block, generate_one_simple_segment, \ +from neo.test.generate_datasets import generate_one_simple_block, \ + generate_one_simple_segment, \ random_event, random_epoch, random_spiketrain from numpy.testing import assert_array_equal @@ -1340,13 +1341,14 @@ def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__list_noparents(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1398,13 +1400,14 @@ def test__multi_spiketrains_to_dataframe__list_noparents(self): assert_frame_equal(targ, res2) def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1461,13 +1464,14 @@ def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1512,13 +1516,14 @@ def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__tuple_default(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1554,13 +1559,14 @@ def test__multi_spiketrains_to_dataframe__tuple_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__iter_default(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1596,13 +1602,15 @@ def test__multi_spiketrains_to_dataframe__iter_default(self): def test__multi_spiketrains_to_dataframe__dict_default(self): obj = dict( - (i, generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event])) - for i in range(3)) + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for _ in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -1950,13 +1958,14 @@ def test__multi_events_to_dataframe__block_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__list_noparents(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): objs.annotate(test=5) @@ -2015,13 +2024,14 @@ def test__multi_events_to_dataframe__list_noparents(self): assert_frame_equal(targ, res2) def test__multi_events_to_dataframe__list_parents_childfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): objs.annotate(test=5) @@ -2087,13 +2097,14 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_events_to_dataframe__list_parents_parentfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): objs.annotate(test=5) @@ -2143,13 +2154,14 @@ def test__multi_events_to_dataframe__list_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__tuple_default(self): - obj = tuple([generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)]) + obj = tuple([ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)]) for iobj in obj: for objs in iobj.list_children_by_class('Event'): objs.annotate(test=5) @@ -2189,13 +2201,14 @@ def test__multi_events_to_dataframe__tuple_default(self): assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__iter_default(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Event'): objs.annotate(test=5) @@ -2235,13 +2248,15 @@ def test__multi_events_to_dataframe__iter_default(self): def test__multi_events_to_dataframe__dict_default(self): obj = dict( - (i, generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event])) - for i in range(3)) + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for _ in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Event'): objs.annotate(test=5) @@ -2592,13 +2607,14 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__list_noparents(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2657,13 +2673,14 @@ def test__multi_epochs_to_dataframe__list_noparents(self): assert_frame_equal(targ, res2) def test__multi_epochs_to_dataframe__list_parents_childfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2729,12 +2746,14 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2784,13 +2803,14 @@ def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__tuple_default(self): - obj = tuple([generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)]) + obj = tuple([ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)]) for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2830,13 +2850,14 @@ def test__multi_epochs_to_dataframe__tuple_default(self): assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__iter_default(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] for iobj in obj: for objs in iobj.list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2876,13 +2897,15 @@ def test__multi_epochs_to_dataframe__iter_default(self): def test__multi_epochs_to_dataframe__dict_default(self): obj = dict( - (i, generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event])) - for i in range(3)) + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for _ in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Epoch'): objs.annotate(test=5) @@ -2925,13 +2948,14 @@ def test__multi_epochs_to_dataframe__dict_default(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class SliceSpiketrainTestCase(unittest.TestCase): def setUp(self): - obj = [generate_one_simple_block( - nb_segment=1, - supported_objects=[ - neo.core.Block, neo.core.Segment, - neo.core.SpikeTrain, neo.core.AnalogSignal, - neo.core.Epoch, neo.core.Event]) - for i in range(10)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(10)] self.obj = ep.multi_spiketrains_to_dataframe(obj) def test_single_none(self): From d2667641f280d78a42d04120d5d76f35e100d5f5 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 17:03:53 +0100 Subject: [PATCH 38/78] Yet more PEP8 finishes --- elephant/test/test_pandas_bridge.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 291785bd8..569f73073 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -1610,7 +1610,7 @@ def test__multi_spiketrains_to_dataframe__dict_default(self): neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) - for _ in range(3)) + for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('SpikeTrain'): objs.annotate(test=5) @@ -2256,7 +2256,7 @@ def test__multi_events_to_dataframe__dict_default(self): neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) - for _ in range(3)) + for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Event'): objs.annotate(test=5) @@ -2905,7 +2905,7 @@ def test__multi_epochs_to_dataframe__dict_default(self): neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) - for _ in range(3)) + for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Epoch'): objs.annotate(test=5) From ee4e4286a1edd11c7a22c61088d0f2471a7d5180 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 17:06:26 +0100 Subject: [PATCH 39/78] Last PEP8 finish --- elephant/test/test_pandas_bridge.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 569f73073..78cd71635 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -2905,7 +2905,7 @@ def test__multi_epochs_to_dataframe__dict_default(self): neo.core.Block, neo.core.Segment, neo.core.SpikeTrain, neo.core.AnalogSignal, neo.core.Epoch, neo.core.Event])) - for i in range(3)) + for i in range(3)) for iobj in obj: for objs in obj[iobj].list_children_by_class('Epoch'): objs.annotate(test=5) From 95f84bf68f55ce3a98acf049d038ac7aa2345e4b Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 23:19:09 +0100 Subject: [PATCH 40/78] Handle SpikeTrainList as input for BinnedSpikeTrain --- elephant/conversion.py | 17 +++++++++-------- elephant/utils.py | 3 ++- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index 0c9615258..91c49d315 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -1223,14 +1223,14 @@ def __init__(self, t_start, t_stop, bin_size, units, sparse_matrix, self.tolerance = tolerance -def _check_neo_spiketrain(matrix): +def _check_neo_spiketrain(query): """ Checks if given input contains neo.SpikeTrain objects Parameters ---------- - matrix - Object to test for `neo.SpikeTrain`s + query + Object to test for `neo.SpikeTrain` objects Returns ------- @@ -1240,9 +1240,10 @@ def _check_neo_spiketrain(matrix): """ # Check for single spike train - if isinstance(matrix, neo.SpikeTrain): + if isinstance(query, neo.SpikeTrain): return True - # Check for list or tuple - if isinstance(matrix, (list, tuple)): - return all(map(_check_neo_spiketrain, matrix)) - return False + # Check for list, tuple, or SpikeTrainList + try: + return all(map(_check_neo_spiketrain, query)) + except: + return False diff --git a/elephant/utils.py b/elephant/utils.py index 445b74bc3..3ce1e9206 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -16,6 +16,7 @@ from functools import wraps import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq @@ -188,7 +189,7 @@ def check_neo_consistency(neo_objects, object_type, t_start=None, ValueError If input object units, t_start, or t_stop do not match across trials. """ - if not isinstance(neo_objects, (list, tuple)): + if not isinstance(neo_objects, (list, tuple, SpikeTrainList)): neo_objects = [neo_objects] try: units = neo_objects[0].units From 0e354f2782764a560a6aff0d332752c0951e25f7 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 23:19:22 +0100 Subject: [PATCH 41/78] Add corresponding regression test --- elephant/test/test_conversion.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index db5cae06e..801a0217e 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -9,6 +9,7 @@ import unittest import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from numpy.testing import (assert_array_almost_equal, assert_array_equal) @@ -185,6 +186,25 @@ def test_bin_edges_empty_binned_spiketrain(self): assert_array_equal(bst.spike_indices, [[]]) # no binned spikes self.assertEqual(bst.get_num_of_spikes(), 0) + def test_regression_431(self): + """ + Addresses issue 431 + This unittest addresses an issue where a SpikeTrainList obejct was not correctly handled by the constructor + """ + st1 = neo.SpikeTrain( + times=np.array([1, 2, 3]) * pq.ms, + t_start=0 * pq.ms, t_stop=10 * pq.ms) + st2 = neo.SpikeTrain( + times=np.array([4, 5, 6]) * pq.ms, + t_start=0 * pq.ms, t_stop=10 * pq.ms) + real_list = [st1, st2] + spiketrainlist = SpikeTrainList([st1, st2]) + + real_list_binary = cv.BinnedSpikeTrain(real_list, bin_size=1*pq.ms) + spiketrainlist_binary = cv.BinnedSpikeTrain(spiketrainlist, bin_size=1 * pq.ms) + + assert_array_equal(real_list_binary.to_array(), spiketrainlist_binary.to_array()) + class BinnedSpikeTrainTestCase(unittest.TestCase): def setUp(self): From 00dfa388e2eb858a84a69dcb2ccef6b32a88f5d8 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 7 Feb 2022 23:30:47 +0100 Subject: [PATCH 42/78] PEP 8; avoid universal try-except clause --- elephant/conversion.py | 8 +++++--- elephant/test/test_conversion.py | 9 ++++++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index 91c49d315..4ecae5fbc 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -1244,6 +1244,8 @@ def _check_neo_spiketrain(query): return True # Check for list, tuple, or SpikeTrainList try: - return all(map(_check_neo_spiketrain, query)) - except: - return False + return all(map(_check_neo_spiketrain, query)) + except TypeError: + pass + + return False diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index 801a0217e..e4bddf6a8 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -189,7 +189,8 @@ def test_bin_edges_empty_binned_spiketrain(self): def test_regression_431(self): """ Addresses issue 431 - This unittest addresses an issue where a SpikeTrainList obejct was not correctly handled by the constructor + This unittest addresses an issue where a SpikeTrainList obejct was not + correctly handled by the constructor """ st1 = neo.SpikeTrain( times=np.array([1, 2, 3]) * pq.ms, @@ -201,9 +202,11 @@ def test_regression_431(self): spiketrainlist = SpikeTrainList([st1, st2]) real_list_binary = cv.BinnedSpikeTrain(real_list, bin_size=1*pq.ms) - spiketrainlist_binary = cv.BinnedSpikeTrain(spiketrainlist, bin_size=1 * pq.ms) + spiketrainlist_binary = cv.BinnedSpikeTrain( + spiketrainlist, bin_size=1 * pq.ms) - assert_array_equal(real_list_binary.to_array(), spiketrainlist_binary.to_array()) + assert_array_equal( + real_list_binary.to_array(), spiketrainlist_binary.to_array()) class BinnedSpikeTrainTestCase(unittest.TestCase): From 2792d0ac5bd94ba80a143f31c7c7432cbbb8b5df Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Tue, 8 Feb 2022 09:11:46 +0100 Subject: [PATCH 43/78] Fixed SpikeTrainList issue in spike train synchrony class --- elephant/spike_train_synchrony.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/elephant/spike_train_synchrony.py b/elephant/spike_train_synchrony.py index c4f0ed505..8cde2d758 100644 --- a/elephant/spike_train_synchrony.py +++ b/elephant/spike_train_synchrony.py @@ -349,7 +349,11 @@ def delete_synchrofacts(self, threshold, in_place=False, mode='delete'): # replace link to spiketrain in segment new_index = self._get_spiketrain_index( segment.spiketrains, st) - segment.spiketrains[new_index] = new_st + # Todo: Simplify following lines once Neo SpikeTrainList + # implments indexed assignment of entries (i.e., stl[i]=st) + spiketrainlist = list(segment.spiketrains) + spiketrainlist[new_index] = new_st + segment.spiketrains = spiketrainlist except ValueError: # st is not in this segment even though it points to it warnings.warn(f"The SpikeTrain at index {idx} of the " From f82e0806b736d7e7ebac68d0578cc83e6ef7ee84 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Tue, 8 Feb 2022 14:21:02 +0100 Subject: [PATCH 44/78] Fixed SpikeTrainList issue in SPADE --- elephant/spade.py | 3 ++- elephant/test/test_spade.py | 29 +++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/elephant/spade.py b/elephant/spade.py index 34ecf51de..6f95e55cc 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -97,6 +97,7 @@ from itertools import chain, combinations import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from scipy import sparse @@ -614,7 +615,7 @@ def concepts_mining(spiketrains, bin_size, winlen, min_spikes=2, min_occ=2, "report has to assume of the following values:" + " 'a', '#' and '3d#,' got {} instead".format(report)) # if spiketrains is list of neo.SpikeTrain convert to conv.BinnedSpikeTrain - if isinstance(spiketrains, list) and \ + if isinstance(spiketrains, (list, SpikeTrainList)) and \ isinstance(spiketrains[0], neo.SpikeTrain): spiketrains = conv.BinnedSpikeTrain( spiketrains, bin_size=bin_size, tolerance=None) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 299bc62b7..5eb6d7368 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -10,6 +10,7 @@ import random import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from numpy.testing.utils import assert_array_equal @@ -180,6 +181,34 @@ def test_spade_msip(self): # check the lags assert_array_equal(lags_msip, self.lags_msip) + # Testing with multiple patterns input + def test_spade_msip_spiketrainlist(self): + output_msip = spade.spade(SpikeTrainList(self.msip), self.bin_size, self.winlen, + approx_stab_pars=dict( + n_subsets=self.n_subset, + stability_thresh=self.stability_thresh), + n_surr=self.n_surr, alpha=self.alpha, + psr_param=self.psr_param, + stat_corr='no', + output_format='patterns')['patterns'] + elements_msip = [] + occ_msip = [] + lags_msip = [] + # collecting spade output + for out in output_msip: + elements_msip.append(out['neurons']) + occ_msip.append(list(out['times'].magnitude)) + lags_msip.append(list(out['lags'].magnitude)) + elements_msip = sorted(elements_msip, key=len) + occ_msip = sorted(occ_msip, key=len) + lags_msip = sorted(lags_msip, key=len) + # check neurons in the patterns + assert_array_equal(elements_msip, self.elements_msip) + # check the occurrences time of the patters + assert_array_equal(occ_msip, self.occ_msip) + # check the lags + assert_array_equal(lags_msip, self.lags_msip) + def test_parameters(self): """ Test under different configuration of parameters than the default one From 6d7790bf987f0ef80f9208852c8c4f1e87f68421 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Tue, 8 Feb 2022 15:05:26 +0100 Subject: [PATCH 45/78] Pep8 issue --- elephant/test/test_spade.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 5eb6d7368..a85c1ed56 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -183,14 +183,15 @@ def test_spade_msip(self): # Testing with multiple patterns input def test_spade_msip_spiketrainlist(self): - output_msip = spade.spade(SpikeTrainList(self.msip), self.bin_size, self.winlen, - approx_stab_pars=dict( - n_subsets=self.n_subset, - stability_thresh=self.stability_thresh), - n_surr=self.n_surr, alpha=self.alpha, - psr_param=self.psr_param, - stat_corr='no', - output_format='patterns')['patterns'] + output_msip = spade.spade( + SpikeTrainList(self.msip), self.bin_size, self.winlen, + approx_stab_pars=dict( + n_subsets=self.n_subset, + stability_thresh=self.stability_thresh), + n_surr=self.n_surr, alpha=self.alpha, + psr_param=self.psr_param, + stat_corr='no', + output_format='patterns')['patterns'] elements_msip = [] occ_msip = [] lags_msip = [] From 81fd5c49d6f9d1683bbcba808fa08e1eb543597a Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 9 Feb 2022 11:44:39 +0100 Subject: [PATCH 46/78] Update elephant/neo_tools.py Co-authored-by: Michael Denker --- elephant/neo_tools.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/elephant/neo_tools.py b/elephant/neo_tools.py index f5ebde3a5..b0e11f9bb 100644 --- a/elephant/neo_tools.py +++ b/elephant/neo_tools.py @@ -181,7 +181,7 @@ def get_all_spiketrains(container): Returns ------- list - A list of the unique `neo.SpikeTrain` objects in `container`. + A `neo.SpikeTrainList` object of the unique `neo.SpikeTrain` objects in `container`. """ return SpikeTrainList(_get_all_objs(container, 'SpikeTrain')) From 4b4b523f59078f71e4e286652d24b74d87e68ee6 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Feb 2022 14:24:50 +0100 Subject: [PATCH 47/78] added CI.yml containing workflows --- .github/workflows/CI.yml | 317 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 317 insertions(+) create mode 100644 .github/workflows/CI.yml diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 000000000..9db965441 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,317 @@ +# This workflow will setup GitHub-hosted runners and install the required dependencies for elephant tests. +# On a pull requests and on pushes to master it will run different tests for elephant. + +name: tests +# define events that trigger workflow 'tests' +on: + workflow_dispatch: # enables manual triggering of workflow + inputs: + logLevel: + description: 'Log level' + required: true + default: 'warning' + type: choice + options: + - info + - warning + - debug + pull_request: + branches: + - master + types: + #- assigned + #- unassigned + - labeled + #- unlabeled + - opened + #- edited + #- closed + #- reopened + #- synchronize + #- converted_to_draft + #- ready_for_review + #- locked + #- unlocked + #- review_requested + #- review_request_removed + #- auto_merge_enabled + #- auto_merge_disabled + +# jobs define the steps that will be executed on the runner +jobs: + # install dependencies and elephant with pip and run tests with pytest + build-and-test-pip: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.6, 3.7, 3.8, 3.9] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + # used to reset cache every month + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + - uses: actions/checkout@v2 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache test_env + uses: actions/cache@v2 + with: + path: ~/test_env + # Look to see if there is a cache hit for the corresponding requirements files + # cache will be reset on changes to any requirements or every month + key: ${{ runner.os }}-venv-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + # create an environment and install everything + python -m venv ~/test_env + source ~/test_env/bin/activate + + python -m pip install --upgrade pip + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: Build + run: | + source ~/test_env/bin/activate + python setup.py install + + - name: List packages + run: | + source ~/test_env/bin/activate + pip list + python --version + + - name: Test with pytest + run: | + source ~/test_env/bin/activate + pytest --cov=elephant + + # install dependencies with conda and run tests with pytest + test-conda: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - uses: actions/checkout@v2 + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + key: ${{ runner.os }}-pip-${{hashFiles('requirements/environment-tests.yml') }}-${{ steps.date.outputs.date }} + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + + - name: Install dependencies + run: | + conda update conda + conda env update --file requirements/environment-tests.yml --name base + + activate base + conda install -c conda-forge openmpi + pip install -r requirements/requirements-tests.txt + pip install pytest==6.2.5 # hotfix for pytest 7.0.0, remove once fixed + pip install pytest-cov coveralls + pip install . + + - name: List packages + run: | + activate base + pip list + conda list + python --version + + - name: Test with pytest + run: | + activate base + pytest --cov=elephant --import-mode=importlib + + # install dependencies with pip and run tests with pytest + test-pip: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.8,] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [windows-latest] + include: + # - os: ubuntu-latest + # path: ~/.cache/pip + # - os: macos-latest + # path: ~/Library/Caches/pip + - os: windows-latest + path: ~\AppData\Local\pip\Cache + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ${{ matrix.path }} + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: List packages + run: | + pip list + python --version + + - name: Test with pytest + run: | + python --version + pytest --cov=elephant + + # install dependencies and elephant with pip and run MPI + test-pip-MPI: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.6] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + - uses: actions/checkout@v2 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache test_env + uses: actions/cache@v2 + with: + path: ~/.cache/pip + # Look to see if there is a cache hit for the corresponding requirements files + # cache will be reset on changes to any requirements or every month + key: ${{ runner.os }}-venv-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Setup enviroment + run: | + sudo apt install -y libopenmpi-dev openmpi-bin + + python -m pip install --upgrade pip + pip install mpi4py + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: List packages + run: | + pip list + python --version + + - name: Test with pytest + run: | + mpiexec -n 1 python -m mpi4py -m pytest --cov=elephant + + # install dependencies for the documentation and build .html + docs: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + steps: + + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + sudo apt install -y libopenmpi-dev openmpi-bin + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + sudo apt install -y libopenmpi-dev openmpi-bin + python -m pip install --upgrade pip + pip install -r requirements/requirements-docs.txt + pip install -r requirements/requirements-tutorials.txt + conda update conda + conda env update --file requirements/environment-tests.yml --name base + conda install -c conda-forge openmpi + conda install -c conda-forge pandoc + # run notebooks + sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py + + - name: List packages + run: | + pip list + conda list + python --version + + - name: make html + run: | + python --version + cd doc + make html \ No newline at end of file From 08e427a406d17d94b0c8e11ff300227cae8ba62a Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Feb 2022 14:26:04 +0100 Subject: [PATCH 48/78] added badge for CI tests to README.md --- README.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 0f4d28432..b7a9971e1 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ [![Statistics](https://img.shields.io/pypi/dm/elephant)](https://seladb.github.io/StarTrack-js/#/preload?r=neuralensemble,elephant) [![Gitter](https://badges.gitter.im/python-elephant/community.svg)](https://gitter.im/python-elephant/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) [![DOI Latest Release](https://zenodo.org/badge/10311278.svg)](https://zenodo.org/badge/latestdoi/10311278) - +[![tests](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml/badge.svg)](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml) *Elephant* package analyses all sorts of neurophysiological data: spike trains, LFP, analog signals. The input-output data format is either @@ -44,5 +44,4 @@ See [acknowledgments](doc/acknowledgments.rst). #### Citation -See [citations](doc/citation.rst). - +See [citations](doc/citation.rst). \ No newline at end of file From 39e69bad651d1d6ff80a7b93f2a5605af7635cff Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Feb 2022 14:29:39 +0100 Subject: [PATCH 49/78] restructured requirements, environment.yml refactored to environment-docs.yml and environment-tests.yml. --- readthedocs.yml | 4 ++-- .../{environment.yml => environment-docs.yml} | 0 requirements/environment-tests.yml | 19 +++++++++++++++++++ 3 files changed, 21 insertions(+), 2 deletions(-) rename requirements/{environment.yml => environment-docs.yml} (100%) create mode 100644 requirements/environment-tests.yml diff --git a/readthedocs.yml b/readthedocs.yml index 15fa6002f..5d6f4b6cd 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -9,7 +9,7 @@ sphinx: configuration: doc/conf.py conda: - environment: requirements/environment.yml + environment: requirements/environment-docs.yml python: install: @@ -18,4 +18,4 @@ python: extra_requirements: - docs - extras - - tutorials + - tutorials \ No newline at end of file diff --git a/requirements/environment.yml b/requirements/environment-docs.yml similarity index 100% rename from requirements/environment.yml rename to requirements/environment-docs.yml diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml new file mode 100644 index 000000000..68fdfe1a0 --- /dev/null +++ b/requirements/environment-tests.yml @@ -0,0 +1,19 @@ +name: elephant + +channels: + - conda-forge # required for MPI + +dependencies: + - python>=3.6 + - mpi4py + - numpy + - scipy + - tqdm + - pandas + - scikit-learn + - statsmodels + - jinja2 + - pip: + - neo>=0.9.0,<0.10.0 + - viziphant + # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt From f3c5ef192fda55eb0b2d72ee52df1849919b8198 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Feb 2022 14:32:56 +0100 Subject: [PATCH 50/78] adapted runners according to new new .yml files --- .github/workflows/CI.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 9db965441..de04a89c1 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -289,7 +289,7 @@ jobs: with: path: ~/.cache/pip # Look to see if there is a cache hit for the corresponding requirements files - key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ steps.date.outputs.date }} + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ hashFiles('**/environment-docs.yml') }}-${{ steps.date.outputs.date }} - name: Install dependencies run: | @@ -298,7 +298,7 @@ jobs: pip install -r requirements/requirements-docs.txt pip install -r requirements/requirements-tutorials.txt conda update conda - conda env update --file requirements/environment-tests.yml --name base + conda env update --file requirements/environment-docs.yml --name base conda install -c conda-forge openmpi conda install -c conda-forge pandoc # run notebooks @@ -312,6 +312,5 @@ jobs: - name: make html run: | - python --version cd doc make html \ No newline at end of file From 21f6d77f2a3949d5b23be9a2fbb7c9916b28bf23 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Feb 2022 16:20:40 +0100 Subject: [PATCH 51/78] re-add environment.yml for Travis, to be removed together with travis.yml --- requirements/environment.yml | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 requirements/environment.yml diff --git a/requirements/environment.yml b/requirements/environment.yml new file mode 100644 index 000000000..68fdfe1a0 --- /dev/null +++ b/requirements/environment.yml @@ -0,0 +1,19 @@ +name: elephant + +channels: + - conda-forge # required for MPI + +dependencies: + - python>=3.6 + - mpi4py + - numpy + - scipy + - tqdm + - pandas + - scikit-learn + - statsmodels + - jinja2 + - pip: + - neo>=0.9.0,<0.10.0 + - viziphant + # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt From e4c2cef98f8a39e1bd9c41e4eb9abfa3bd340b3e Mon Sep 17 00:00:00 2001 From: pbouss Date: Mon, 14 Feb 2022 12:33:23 +0100 Subject: [PATCH 52/78] instantaneous rate test -> more spiketrains to make it run --- elephant/test/test_statistics.py | 37 +++++++++++++++++--------------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index be51d7809..d693e604e 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -19,7 +19,7 @@ assert_array_less import elephant.kernels as kernels from elephant import statistics -from elephant.spike_train_generation import homogeneous_poisson_process +from elephant.spike_train_generation import StationaryPoissonProcess class isi_TestCase(unittest.TestCase): @@ -138,7 +138,8 @@ def test_mean_firing_rate_with_spiketrain(self): def test_mean_firing_rate_typical_use_case(self): np.random.seed(92) - st = homogeneous_poisson_process(rate=100 * pq.Hz, t_stop=100 * pq.s) + st = StationaryPoissonProcess( + rate=100 * pq.Hz, t_stop=100 * pq.s).generate_spiketrain() rate1 = statistics.mean_firing_rate(st) rate2 = statistics.mean_firing_rate(st, t_start=st.t_start, t_stop=st.t_stop) @@ -620,9 +621,9 @@ def test_not_center_kernel(self): def test_regression_288(self): np.random.seed(9) sampling_period = 200 * pq.ms - spiketrain = homogeneous_poisson_process(10 * pq.Hz, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + 10 * pq.Hz, t_start=0 * pq.s, t_stop=10 * pq.s + ).generate_spiketrain() kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) # check that instantaneous_rate "works" for kernels with small sigma # without triggering an incomprehensible error @@ -640,9 +641,9 @@ def test_small_kernel_sigma(self): sampling_period = 200 * pq.ms sigma = 5 * pq.ms rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate_expected, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + rate_expected, t_start=0 * pq.s, t_stop=10 * pq.s + ).generate_spiketrain() kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() if isinstance(kern_cls, type) and @@ -781,8 +782,8 @@ def test_instantaneous_rate_regression_245(self): def test_instantaneous_rate_grows_with_sampling_period(self): np.random.seed(0) rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate=rate_expected, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + rate=rate_expected, t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.GaussianKernel(sigma=100 * pq.ms) rates_mean = [] for sampling_period in np.linspace(1, 1000, num=10) * pq.ms: @@ -848,16 +849,16 @@ def test_annotations(self): def test_border_correction(self): np.random.seed(0) - n_spiketrains = 75 + n_spiketrains = 125 rate = 50. * pq.Hz t_start = 0. * pq.ms t_stop = 1000. * pq.ms sampling_period = 0.1 * pq.ms - trial_list = [homogeneous_poisson_process( - rate=rate, t_start=t_start, - t_stop=t_stop) for _ in range(n_spiketrains)] + trial_list = StationaryPoissonProcess( + rate=rate, t_start=t_start, t_stop=t_stop + ).generate_n_spiketrains(n_spiketrains) for correction in (True, False): rates = [] @@ -958,8 +959,9 @@ def test_time_histogram_output(self): def test_annotations(self): np.random.seed(1) - spiketrains = [homogeneous_poisson_process( - rate=10 * pq.Hz, t_stop=10 * pq.s) for _ in range(10)] + spiketrains = StationaryPoissonProcess( + rate=10 * pq.Hz, t_stop=10 * pq.s).generate_n_spiketrains( + n_spiketrains=10) for output in ("counts", "mean", "rate"): histogram = statistics.time_histogram(spiketrains, bin_size=3 * pq.ms, @@ -980,7 +982,8 @@ def test_complexity_pdf_deprecated(self): spiketrain_a, spiketrain_b, spiketrain_c] # runs the previous function which will be deprecated targ = np.array([0.92, 0.01, 0.01, 0.06]) - complexity = statistics.complexity_pdf(spiketrains, binsize=0.1*pq.s) + complexity = statistics.complexity_pdf( + spiketrains, bin_size=0.1*pq.s) assert_array_equal(targ, complexity.magnitude[:, 0]) self.assertEqual(1, complexity.magnitude[:, 0].sum()) self.assertEqual(len(spiketrains)+1, len(complexity)) From bf3d706d09ce0956ffa1c0ee84bbbc4c1aeb71b7 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Tue, 15 Feb 2022 16:31:19 +0100 Subject: [PATCH 53/78] fixed deprecation warnings, replaced homogeneous_poisson_process with StationaryPoissonProcess --- elephant/test/test_statistics.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 77dce6772..54800f6c2 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -20,7 +20,7 @@ import elephant.kernels as kernels from elephant import statistics -from elephant.spike_train_generation import homogeneous_poisson_process +from elephant.spike_train_generation import StationaryPoissonProcess as SPP class isi_TestCase(unittest.TestCase): @@ -139,7 +139,7 @@ def test_mean_firing_rate_with_spiketrain(self): def test_mean_firing_rate_typical_use_case(self): np.random.seed(92) - st = homogeneous_poisson_process(rate=100 * pq.Hz, t_stop=100 * pq.s) + st = SPP(rate=100 * pq.Hz, t_stop=100 * pq.s).generate_spiketrain() rate1 = statistics.mean_firing_rate(st) rate2 = statistics.mean_firing_rate(st, t_start=st.t_start, t_stop=st.t_stop) @@ -616,9 +616,9 @@ def test_not_center_kernel(self): def test_regression_288(self): np.random.seed(9) sampling_period = 200 * pq.ms - spiketrain = homogeneous_poisson_process(10 * pq.Hz, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = SPP(10 * pq.Hz, + t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) # check that instantaneous_rate "works" for kernels with small sigma # without triggering an incomprehensible error @@ -636,9 +636,9 @@ def test_small_kernel_sigma(self): sampling_period = 200 * pq.ms sigma = 5 * pq.ms rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate_expected, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = SPP(rate_expected, + t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() if isinstance(kern_cls, type) and @@ -777,8 +777,8 @@ def test_instantaneous_rate_regression_245(self): def test_instantaneous_rate_grows_with_sampling_period(self): np.random.seed(0) rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate=rate_expected, - t_stop=10 * pq.s) + spiketrain = SPP(rate=rate_expected, + t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.GaussianKernel(sigma=100 * pq.ms) rates_mean = [] for sampling_period in np.linspace(1, 1000, num=10) * pq.ms: @@ -909,8 +909,9 @@ def test_time_histogram_output(self): def test_annotations(self): np.random.seed(1) - spiketrains = [homogeneous_poisson_process( - rate=10 * pq.Hz, t_stop=10 * pq.s) for _ in range(10)] + spiketrains = [SPP(rate=10 * pq.Hz, + t_stop=10 * pq.s).generate_spiketrain() + for _ in range(10)] for output in ("counts", "mean", "rate"): histogram = statistics.time_histogram(spiketrains, bin_size=3 * pq.ms, From be17e58c493ba689967c39edcd5a1bcffc6c265a Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Thu, 17 Feb 2022 10:07:59 +0100 Subject: [PATCH 54/78] added import for scipy.signal --- elephant/statistics.py | 1 + 1 file changed, 1 insertion(+) diff --git a/elephant/statistics.py b/elephant/statistics.py index 170aad6c5..ada87b459 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -73,6 +73,7 @@ import numpy as np import quantities as pq import scipy.stats +import scipy.signal import elephant.conversion as conv import elephant.kernels as kernels From ed9d93b046012b3731c12eb90cb160cabcf98035 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 18 Feb 2022 15:25:39 +0100 Subject: [PATCH 55/78] fixed size of output for instantaneous_rate, edited unittests accordingly --- elephant/statistics.py | 41 ++++++++++++------- elephant/test/test_spike_train_generation.py | 2 +- elephant/test/test_statistics.py | 42 ++++++++++---------- 3 files changed, 49 insertions(+), 36 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index ada87b459..9158d8df4 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -648,8 +648,8 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', trim : bool, optional Accounts for the asymmetry of a kernel. If False, the output of the Fast Fourier Transformation being a longer - vector than the input vector by the size of the kernel is reduced back - to the original size of the considered time interval of the + vector than the input vector (ouput = input + kernel - 1) is reduced + back to the original size of the considered time interval of the `spiketrain` using the median of the kernel. False (no trimming) is equivalent to 'same' convolution mode for symmetrical kernels. If True, only the region of the convolved signal is returned, where @@ -823,10 +823,17 @@ def optimal_kernel(st): t_start = t_start.rescale(spiketrains[0].units) t_stop = t_stop.rescale(spiketrains[0].units) - n_bins = int(((t_stop - t_start) / sampling_period).simplified) + 1 - time_vectors = np.zeros((len(spiketrains), n_bins), dtype=np.float64) + n_bins = int(((t_stop - t_start) / sampling_period).simplified) + # if the sampling period is not an integer multiple of (t_stop - t_start) + # add one bin + if n_bins * sampling_period != t_stop: + n_bins += 1 + hist_range_end = t_stop + sampling_period.rescale(spiketrains[0].units) hist_range = (t_start.item(), hist_range_end.item()) + + # preallocation + time_vectors = np.zeros((len(spiketrains), n_bins), dtype=np.float64) for i, st in enumerate(spiketrains): time_vectors[i], _ = np.histogram(st.magnitude, bins=n_bins, range=hist_range) @@ -850,7 +857,9 @@ def optimal_kernel(st): median = kernel.icdf(0.5).rescale(units).item() else: median = 0 - t_arr = np.linspace(-cutoff_sigma + median, stop=cutoff_sigma + median, + # shift kernel using the calculated median + t_arr = np.linspace(start=-cutoff_sigma + median, + stop=cutoff_sigma + median, num=2 * n_half + 1, endpoint=True) * units if center_kernel: @@ -872,23 +881,25 @@ def optimal_kernel(st): # the convolution of non-negative vectors is non-negative rate = np.clip(rate, a_min=0, a_max=None, out=rate) - if center_kernel: # account for the kernel asymmetry + # cut off the wings from the result of "full" convolution + if center_kernel: median_id = kernel.median_index(t_arr) # the size of kernel() output matches the input size, len(t_arr) kernel_array_size = len(t_arr) if not trim: - rate = rate[median_id: -kernel_array_size + median_id] + if -kernel_array_size + median_id + 1 == 0: + rate = rate[median_id::] + else: + rate = rate[median_id: -kernel_array_size + median_id + 1] else: - rate = rate[2 * median_id: -2 * (kernel_array_size - median_id)] + if -2 * (kernel_array_size - median_id - 1) == 0: + rate = rate[2 * median_id::] + else: + rate = rate[2 * median_id: + -2 * (kernel_array_size - median_id - 1)] + t_start = t_start + median_id * units t_stop = t_stop - (kernel_array_size - median_id) * units - else: - # FIXME: don't shrink the output array - # (to be consistent with center_kernel=True) - # n points have n-1 intervals; - # instantaneous rate is a list of intervals; - # hence, the last element is excluded - rate = rate[:-1] kernel_annotation = dict(type=type(kernel).__name__, sigma=str(kernel.sigma), diff --git a/elephant/test/test_spike_train_generation.py b/elephant/test/test_spike_train_generation.py index 457e376c6..6a1434a2e 100644 --- a/elephant/test/test_spike_train_generation.py +++ b/elephant/test/test_spike_train_generation.py @@ -864,7 +864,7 @@ def test_recovered_firing_rate_profile(self): rate_recovered = rate_recovered.flatten().magnitude trim = (rate_profile.shape[0] - rate_recovered.shape[0]) // 2 rate_profile_valid = rate_profile.magnitude.squeeze() - rate_profile_valid = rate_profile_valid[trim: -trim - 1] + rate_profile_valid = rate_profile_valid[trim: -trim] assert_allclose(rate_recovered, rate_profile_valid, rtol=0, atol=rtol * rate.item()) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 54800f6c2..d31706873 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -20,10 +20,10 @@ import elephant.kernels as kernels from elephant import statistics -from elephant.spike_train_generation import StationaryPoissonProcess as SPP +from elephant.spike_train_generation import StationaryPoissonProcess as StatPP -class isi_TestCase(unittest.TestCase): +class IsiTestCase(unittest.TestCase): def setUp(self): self.test_array_2d = np.array([[0.3, 0.56, 0.87, 1.23], [0.02, 0.71, 1.82, 8.46], @@ -83,10 +83,10 @@ def test_unsorted_array(self): np.random.seed(0) array = np.random.rand(100) with self.assertWarns(UserWarning): - isi = statistics.isi(array) + statistics.isi(array) -class isi_cv_TestCase(unittest.TestCase): +class IsiCvTestCase(unittest.TestCase): def setUp(self): self.test_array_regular = np.arange(1, 6) @@ -103,7 +103,7 @@ def test_cv_isi_regular_array_is_zero(self): self.assertEqual(res, targ) -class mean_firing_rate_TestCase(unittest.TestCase): +class MeanFiringRateTestCase(unittest.TestCase): def setUp(self): self.test_array_3d = np.ones([5, 7, 13]) self.test_array_2d = np.array([[0.3, 0.56, 0.87, 1.23], @@ -139,7 +139,7 @@ def test_mean_firing_rate_with_spiketrain(self): def test_mean_firing_rate_typical_use_case(self): np.random.seed(92) - st = SPP(rate=100 * pq.Hz, t_stop=100 * pq.s).generate_spiketrain() + st = StatPP(rate=100 * pq.Hz, t_stop=100 * pq.s).generate_spiketrain() rate1 = statistics.mean_firing_rate(st) rate2 = statistics.mean_firing_rate(st, t_start=st.t_start, t_stop=st.t_stop) @@ -517,7 +517,7 @@ def test_instantaneous_rate_and_warnings(self): self.assertEqual( inst_rate.sampling_period.simplified, sampling_period.simplified) self.assertEqual(inst_rate.simplified.units, pq.Hz) - self.assertEqual(inst_rate.t_stop.simplified, st.t_stop.simplified) + self.assertEqual(st.t_stop.simplified, inst_rate.t_stop.simplified) self.assertEqual(inst_rate.t_start.simplified, st.t_start.simplified) def test_error_instantaneous_rate(self): @@ -616,9 +616,9 @@ def test_not_center_kernel(self): def test_regression_288(self): np.random.seed(9) sampling_period = 200 * pq.ms - spiketrain = SPP(10 * pq.Hz, - t_start=0 * pq.s, - t_stop=10 * pq.s).generate_spiketrain() + spiketrain = StatPP(10 * pq.Hz, + t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) # check that instantaneous_rate "works" for kernels with small sigma # without triggering an incomprehensible error @@ -636,9 +636,9 @@ def test_small_kernel_sigma(self): sampling_period = 200 * pq.ms sigma = 5 * pq.ms rate_expected = 10 * pq.Hz - spiketrain = SPP(rate_expected, - t_start=0 * pq.s, - t_stop=10 * pq.s).generate_spiketrain() + spiketrain = StatPP(rate_expected, + t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() if isinstance(kern_cls, type) and @@ -661,6 +661,7 @@ def test_spikes_on_edges(self): # spiketrain (see test_rate_estimation_consistency) cutoff = 5 sampling_period = 0.01 * pq.s + # with t_spikes = [-5, 5]s the isi is 10s, so 1/isi 0.1 Hz t_spikes = np.array([-cutoff, cutoff]) * pq.s spiketrain = neo.SpikeTrain(t_spikes, t_start=t_spikes[0], t_stop=t_spikes[-1]) @@ -680,7 +681,7 @@ def test_spikes_on_edges(self): kernel=kernel, cutoff=cutoff, trim=True, center_kernel=center_kernel) - assert_array_almost_equal(rate.magnitude, 0, decimal=3) + assert_array_almost_equal(rate.magnitude, 0, decimal=2) def test_trim_as_convolve_mode(self): cutoff = 5 @@ -701,7 +702,8 @@ def test_trim_as_convolve_mode(self): for trim in (False, True): rate_centered = statistics.instantaneous_rate( spiketrain, sampling_period=sampling_period, - kernel=kernel, cutoff=cutoff, trim=trim) + kernel=kernel, cutoff=cutoff, trim=trim, + center_kernel=True) rate_convolve = statistics.instantaneous_rate( spiketrain, sampling_period=sampling_period, @@ -750,7 +752,7 @@ def test_instantaneous_rate_regression_245(self): # This test makes sure that the correct kernel width is chosen when # selecting 'auto' as kernel spiketrain = neo.SpikeTrain( - range(1, 30) * pq.ms, t_start=0 * pq.ms, t_stop=30 * pq.ms) + pq.ms * range(1, 30), t_start=0 * pq.ms, t_stop=30 * pq.ms) # This is the correct procedure to attain the kernel: first, the result # of sskernel retrieves the kernel bandwidth of an optimal Gaussian @@ -777,8 +779,8 @@ def test_instantaneous_rate_regression_245(self): def test_instantaneous_rate_grows_with_sampling_period(self): np.random.seed(0) rate_expected = 10 * pq.Hz - spiketrain = SPP(rate=rate_expected, - t_stop=10 * pq.s).generate_spiketrain() + spiketrain = StatPP(rate=rate_expected, + t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.GaussianKernel(sigma=100 * pq.ms) rates_mean = [] for sampling_period in np.linspace(1, 1000, num=10) * pq.ms: @@ -909,8 +911,8 @@ def test_time_histogram_output(self): def test_annotations(self): np.random.seed(1) - spiketrains = [SPP(rate=10 * pq.Hz, - t_stop=10 * pq.s).generate_spiketrain() + spiketrains = [StatPP(rate=10 * pq.Hz, + t_stop=10 * pq.s).generate_spiketrain() for _ in range(10)] for output in ("counts", "mean", "rate"): histogram = statistics.time_histogram(spiketrains, From 4493a7483f6fb4eb84c38b28191c85632a6aeab0 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 18 Feb 2022 17:57:05 +0100 Subject: [PATCH 56/78] test to check length of outputs --- elephant/test/test_statistics.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index d31706873..6062455c1 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -844,6 +844,21 @@ def test_annotations(self): self.assertIn('kernel', rate.annotations) self.assertEqual(rate.annotations['kernel'], kernel_annotation) + def test_regression_374(self): + # check length of outputs for sampling_period as integer and not + # integer multiple of the duration (t_start - t_stop) + st = self.spike_train + periods = [1, 0.99, 0.35, st.duration]*pq.s + for period in periods: + rate = statistics.instantaneous_rate(st, + sampling_period=period, + kernel=self.kernel, + center_kernel=True, + trim=False) + self.assertEqual(len(np.arange(st.t_start.item(), st.t_stop.item(), + period.item())), + len(rate)) + class TimeHistogramTestCase(unittest.TestCase): def setUp(self): From 130ac38064c1d3aa497219b702f509b7d7c64d32 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Tue, 1 Mar 2022 12:54:18 +0100 Subject: [PATCH 57/78] added unittest to check consistency of rate times (should be multiple of sampling period), to get consistent ouput sizes, cutting of wings is done by fft convolve for center_kernel=True --- elephant/statistics.py | 35 +++++++------------------------- elephant/test/test_statistics.py | 20 +++++++++++++++--- 2 files changed, 24 insertions(+), 31 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 9158d8df4..c3bb9111c 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -824,12 +824,9 @@ def optimal_kernel(st): t_stop = t_stop.rescale(spiketrains[0].units) n_bins = int(((t_stop - t_start) / sampling_period).simplified) - # if the sampling period is not an integer multiple of (t_stop - t_start) - # add one bin - if n_bins * sampling_period != t_stop: - n_bins += 1 - hist_range_end = t_stop + sampling_period.rescale(spiketrains[0].units) + hist_range_end = t_start + n_bins * \ + sampling_period.rescale(spiketrains[0].units) hist_range = (t_start.item(), hist_range_end.item()) # preallocation @@ -862,11 +859,7 @@ def optimal_kernel(st): stop=cutoff_sigma + median, num=2 * n_half + 1, endpoint=True) * units - if center_kernel: - # keep the full convolve range and do the trimming afterwards; - # trimming is performed according to the kernel median index - fft_mode = 'full' - elif trim: + if trim: # no median index trimming is involved fft_mode = 'valid' else: @@ -881,25 +874,11 @@ def optimal_kernel(st): # the convolution of non-negative vectors is non-negative rate = np.clip(rate, a_min=0, a_max=None, out=rate) - # cut off the wings from the result of "full" convolution - if center_kernel: + if fft_mode == 'valid': # adjust t_start and t_stop median_id = kernel.median_index(t_arr) - # the size of kernel() output matches the input size, len(t_arr) - kernel_array_size = len(t_arr) - if not trim: - if -kernel_array_size + median_id + 1 == 0: - rate = rate[median_id::] - else: - rate = rate[median_id: -kernel_array_size + median_id + 1] - else: - if -2 * (kernel_array_size - median_id - 1) == 0: - rate = rate[2 * median_id::] - else: - rate = rate[2 * median_id: - -2 * (kernel_array_size - median_id - 1)] - - t_start = t_start + median_id * units - t_stop = t_stop - (kernel_array_size - median_id) * units + kernel_array_size = len(kernel_arr) + t_start = t_start + median_id * units + t_stop = t_stop - (kernel_array_size - median_id) * units kernel_annotation = dict(type=type(kernel).__name__, sigma=str(kernel.sigma), diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 6062455c1..4ed18d718 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -855,10 +855,24 @@ def test_regression_374(self): kernel=self.kernel, center_kernel=True, trim=False) - self.assertEqual(len(np.arange(st.t_start.item(), st.t_stop.item(), - period.item())), - len(rate)) + len_rate = int(st.duration.item() / period.item()) + self.assertEqual(len_rate, len(rate)) + def test_rate_times(self): + # check the differences between the rate.times is equal to the sampling + # period + st = self.spike_train + periods = [1, 0.99, 0.35, st.duration]*pq.s + for period in periods: + rate = statistics.instantaneous_rate(st, + sampling_period=period, + kernel=self.kernel, + center_kernel=True, + trim=False) + rate_times_diff = np.diff(rate.times) + period_times = np.full_like(rate_times_diff, period) + assert_array_almost_equal(rate_times_diff, period_times, + decimal=14) class TimeHistogramTestCase(unittest.TestCase): def setUp(self): From be4d214f5afdf44454c873dc0183471f903a9266 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Tue, 1 Mar 2022 18:29:10 +0100 Subject: [PATCH 58/78] fixed pep8, added comments, restructure --- elephant/statistics.py | 14 ++++++++++---- elephant/test/test_statistics.py | 5 +++-- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index c3bb9111c..79f26b788 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -818,13 +818,14 @@ def optimal_kernel(st): if t_stop is None: t_stop = spiketrains[0].t_stop + # rescale units for consistency units = pq.CompoundUnit( "{}*s".format(sampling_period.rescale('s').item())) t_start = t_start.rescale(spiketrains[0].units) t_stop = t_stop.rescale(spiketrains[0].units) + # calculate parameters for np.histogram n_bins = int(((t_stop - t_start) / sampling_period).simplified) - hist_range_end = t_start + n_bins * \ sampling_period.rescale(spiketrains[0].units) hist_range = (t_start.item(), hist_range_end.item()) @@ -835,6 +836,9 @@ def optimal_kernel(st): time_vectors[i], _ = np.histogram(st.magnitude, bins=n_bins, range=hist_range) + time_vectors = time_vectors.T # make it (time, units) + + # Kernel if cutoff < kernel.min_cutoff: cutoff = kernel.min_cutoff warnings.warn("The width of the kernel was adjusted to a minimally " @@ -859,6 +863,9 @@ def optimal_kernel(st): stop=cutoff_sigma + median, num=2 * n_half + 1, endpoint=True) * units + kernel_arr = np.expand_dims(kernel(t_arr).rescale(pq.Hz).magnitude, axis=1) + + # Parameters for scipy.signal.fftconvolve if trim: # no median index trimming is involved fft_mode = 'valid' @@ -866,15 +873,14 @@ def optimal_kernel(st): # no median index trimming is involved fft_mode = 'same' - time_vectors = time_vectors.T # make it (time, units) - kernel_arr = np.expand_dims(kernel(t_arr).rescale(pq.Hz).magnitude, axis=1) rate = scipy.signal.fftconvolve(time_vectors, kernel_arr, mode=fft_mode) # the convolution of non-negative vectors is non-negative rate = np.clip(rate, a_min=0, a_max=None, out=rate) - if fft_mode == 'valid': # adjust t_start and t_stop + # adjust t_start and t_stop + if fft_mode == 'valid': median_id = kernel.median_index(t_arr) kernel_array_size = len(kernel_arr) t_start = t_start + median_id * units diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 4ed18d718..d57236250 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -859,8 +859,8 @@ def test_regression_374(self): self.assertEqual(len_rate, len(rate)) def test_rate_times(self): - # check the differences between the rate.times is equal to the sampling - # period + # check if the differences between the rate.times is equal to + # sampling_period st = self.spike_train periods = [1, 0.99, 0.35, st.duration]*pq.s for period in periods: @@ -874,6 +874,7 @@ def test_rate_times(self): assert_array_almost_equal(rate_times_diff, period_times, decimal=14) + class TimeHistogramTestCase(unittest.TestCase): def setUp(self): self.spiketrain_a = neo.SpikeTrain( From fdaba6d2da08a250d0c3358a121a22312b41a3ec Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Wed, 9 Mar 2022 18:30:48 +0100 Subject: [PATCH 59/78] added include endpoint option --- elephant/statistics.py | 45 ++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 79f26b788..723706104 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -601,7 +601,7 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): @deprecated_alias(spiketrain='spiketrains') def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, - center_kernel=True): + center_kernel=True, endpoint=False): """ Estimates instantaneous firing rate by kernel convolution. @@ -621,7 +621,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', The string 'auto' or callable object of class `kernels.Kernel`. The kernel is used for convolution with the spike train and its standard deviation determines the time resolution of the instantaneous - rate estimation. Currently implemented kernel forms are rectangular, + rate estimation. Currently, implemented kernel forms are rectangular, triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. If 'auto', the optimized kernel width for the rate estimation is @@ -641,7 +641,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', `spiketrain`. Default: None t_stop : pq.Quantity, optional - End time of the interval used to compute the firing rate (included). + End time of the interval used to compute the firing rate. If None, `t_stop` is assumed equal to `t_stop` attribute of `spiketrain`. Default: None @@ -665,6 +665,13 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. Default: True + endpoint: bool, optional + If set to True, the estimation of the instantaneous firing rate will + be based on all spikes in the interval `[t_start, t_stop]`. + If False, only spikes in the interval `[t_start, n * sampling_period]` + are considered. Here `n` is an integer and defined as: + `n = int((t_stop - t_start) / sampling_period)`. + Default: True Returns ------- @@ -706,7 +713,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Notes ----- The resulting instantaneous firing rate values smaller than ``0``, which - can happen due to machine precision errors, are clipped to zero. + may happen due to machine precision errors, are clipped to zero. Examples -------- @@ -802,6 +809,9 @@ def optimal_kernel(st): if not isinstance(trim, bool): raise TypeError("'trim' must be bool") + if not isinstance(endpoint, bool): + raise TypeError("'endpoint' must be bool") + check_neo_consistency(spiketrains, object_type=neo.SpikeTrain, t_start=t_start, t_stop=t_stop) @@ -818,19 +828,21 @@ def optimal_kernel(st): if t_stop is None: t_stop = spiketrains[0].t_stop - # rescale units for consistency + # Rescale units for consistent calculation units = pq.CompoundUnit( "{}*s".format(sampling_period.rescale('s').item())) t_start = t_start.rescale(spiketrains[0].units) t_stop = t_stop.rescale(spiketrains[0].units) - # calculate parameters for np.histogram + # Calculate parameters for np.histogram n_bins = int(((t_stop - t_start) / sampling_period).simplified) + if endpoint: + n_bins += 1 hist_range_end = t_start + n_bins * \ sampling_period.rescale(spiketrains[0].units) hist_range = (t_start.item(), hist_range_end.item()) - # preallocation + # Preallocation time_vectors = np.zeros((len(spiketrains), n_bins), dtype=np.float64) for i, st in enumerate(spiketrains): time_vectors[i], _ = np.histogram(st.magnitude, bins=n_bins, @@ -858,45 +870,44 @@ def optimal_kernel(st): median = kernel.icdf(0.5).rescale(units).item() else: median = 0 - # shift kernel using the calculated median + # Shift kernel using the calculated median t_arr = np.linspace(start=-cutoff_sigma + median, stop=cutoff_sigma + median, num=2 * n_half + 1, endpoint=True) * units - + # Calculate the kernel values with t_arr kernel_arr = np.expand_dims(kernel(t_arr).rescale(pq.Hz).magnitude, axis=1) - # Parameters for scipy.signal.fftconvolve + # Define mode for scipy.signal.fftconvolve if trim: - # no median index trimming is involved fft_mode = 'valid' else: - # no median index trimming is involved fft_mode = 'same' rate = scipy.signal.fftconvolve(time_vectors, kernel_arr, mode=fft_mode) - # the convolution of non-negative vectors is non-negative + # The convolution of non-negative vectors is non-negative rate = np.clip(rate, a_min=0, a_max=None, out=rate) - # adjust t_start and t_stop + # Adjust t_start and t_stop if fft_mode == 'valid': median_id = kernel.median_index(t_arr) kernel_array_size = len(kernel_arr) t_start = t_start + median_id * units t_stop = t_stop - (kernel_array_size - median_id) * units + if endpoint: # last bin is used for calculation but no estimation is given + rate = rate[::-1] + kernel_annotation = dict(type=type(kernel).__name__, sigma=str(kernel.sigma), invert=kernel.invert) - rate = neo.AnalogSignal(signal=rate, + return neo.AnalogSignal(signal=rate, sampling_period=sampling_period, units=pq.Hz, t_start=t_start, t_stop=t_stop, kernel=kernel_annotation) - return rate - @deprecated_alias(binsize='bin_size') def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, From 3a2f6e9cc3a088c8be4ba9365168a2550bb79603 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Thu, 10 Mar 2022 14:40:31 +0100 Subject: [PATCH 60/78] This removes support of RrcordingChannelGroup in CSD methods. --- elephant/current_source_density.py | 51 ++++++++++++++++-------------- elephant/test/test_kcsd.py | 18 ++--------- 2 files changed, 31 insertions(+), 38 deletions(-) diff --git a/elephant/current_source_density.py b/elephant/current_source_density.py index 686c1fde9..6638d9e8e 100644 --- a/elephant/current_source_density.py +++ b/elephant/current_source_density.py @@ -62,7 +62,7 @@ @deprecated_alias(coords='coordinates') -def estimate_csd(lfp, coordinates=None, method=None, +def estimate_csd(lfp, coordinates='coordinates', method=None, process_estimate=True, **kwargs): """ Function call to compute the current source density (CSD) from @@ -72,12 +72,16 @@ def estimate_csd(lfp, coordinates=None, method=None, Parameters ---------- lfp : neo.AnalogSignal - positions of electrodes can be added as neo.RecordingChannel - coordinate or sent externally as a func argument (See coords) - coordinates : [Optional] corresponding spatial coordinates of the - electrodes. - Defaults to None - Otherwise looks for ChannelIndex coordinate + Positions of electrodes can be added as an array annotation + coordinates : array-like Quantity or string + Specifies the corresponding spatial coordinates of the electrodes. + Coordinates can be directly supplied by a NxM array-like Quantity + with dimension of space, where M is the number of signals in 'lfp', + and N is equal to the dimensionality of the method. + Alternatively, if coordinates is a string, the function will fetch the + coordinates, supplied in the same format, as annotation of 'lfp' by that + name. + Default: 'coordinates' method : string Pick a method corresponding to the setup, in this implementation For Laminar probe style (1D), use 'KCSD1D' or 'StandardCSD', @@ -114,17 +118,19 @@ def estimate_csd(lfp, coordinates=None, method=None, """ if not isinstance(lfp, neo.AnalogSignal): raise TypeError('Parameter `lfp` must be a neo.AnalogSignal object') - if coordinates is None: - coordinates = lfp.channel_index.coordinates - else: - scaled_coords = [] - for coord in coordinates: - try: - scaled_coords.append(coord.rescale(pq.mm)) - except AttributeError: - raise AttributeError('No units given for electrode spatial \ - coordinates') - coordinates = scaled_coords + if isinstance(coordinates, str): + coordinates = lfp.annotations[coordinates] + + # Scale all coordinates to mm as common basis + scaled_coords = [] + for coord in coordinates: + try: + scaled_coords.append(coord.rescale(pq.mm)) + except AttributeError: + raise AttributeError('No units given for electrode spatial \ + coordinates') + coordinates = scaled_coords + if method is None: raise ValueError('Must specify a method of CSD implementation') if len(coordinates) != lfp.shape[1]: @@ -249,7 +255,8 @@ def generate_lfp(csd_profile, x_positions, y_positions=None, z_positions=None, ------- LFP : neo.AnalogSignal The potentials created by the csd profile at the electrode positions. - The electrode positions are attached as RecordingChannel's coordinate. + The electrode positions are attached as an annotation named + 'coordinates'. """ def integrate_1D(x0, csd_x, csd, h): @@ -327,10 +334,8 @@ def integrate_3D(x, y, z, csd, xlin, ylin, zlin, X, Y, Z): pots /= 4 * np.pi * sigma ele_pos = np.vstack((x_positions, y_positions, z_positions)).T ele_pos = ele_pos * pq.mm - ch = neo.ChannelIndex(index=range(len(pots))) + asig = neo.AnalogSignal(np.expand_dims(pots, axis=0), sampling_rate=pq.kHz, units='mV') - ch.coordinates = ele_pos - ch.analogsignals.append(asig) - ch.create_relationship() + asig.annotate(coordinates=ele_pos) return asig diff --git a/elephant/test/test_kcsd.py b/elephant/test/test_kcsd.py index 6a8527f30..ee98b96c1 100644 --- a/elephant/test/test_kcsd.py +++ b/elephant/test/test_kcsd.py @@ -32,11 +32,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd1d_estimate(self, cv_params={}): self.test_params.update(cv_params) @@ -86,11 +82,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd2d_estimate(self, cv_params={}): self.test_params.update(cv_params) @@ -149,11 +141,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd3d_estimate(self, cv_params={}): self.test_params.update(cv_params) From aec3b386f378df6da70b0dac8c852855bb1edb38 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Thu, 10 Mar 2022 15:18:44 +0100 Subject: [PATCH 61/78] Changed requirements to Neo >=0.10.0 --- requirements/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index e89638ae3..25f8e040b 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,4 +1,4 @@ -neo>=0.9.0,<0.10.0 +neo>=0.10.0 numpy>=1.18.1 quantities>=0.12.1 scipy<1.7.0 From 9b9ab3a7088a48fb3a7943ddff13aafecf60fe0d Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Thu, 10 Mar 2022 16:54:38 +0100 Subject: [PATCH 62/78] Fix spiketrain lists in instantaneous rate. --- elephant/statistics.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 170aad6c5..1fa076f5e 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -70,6 +70,7 @@ import warnings import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq import scipy.stats @@ -769,7 +770,7 @@ def optimal_kernel(st): if kernel == 'auto': kernel = optimal_kernel(spiketrains) spiketrains = [spiketrains] - elif not isinstance(spiketrains, (list, tuple)): + elif not isinstance(spiketrains, (list, tuple, SpikeTrainList)): raise TypeError( "'spiketrains' must be a list of neo.SpikeTrain's or a single " "neo.SpikeTrain. Found: '{}'".format(type(spiketrains))) From 2904cee9e2ffb67c744a8afffa0c609b9efa93ba Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Fri, 11 Mar 2022 15:28:00 +0100 Subject: [PATCH 63/78] added notes to docstrings, reformat docstrings and code, removed endpoint option --- elephant/statistics.py | 176 ++++++++++++++++++++++++----------------- 1 file changed, 103 insertions(+), 73 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 723706104..e87700f96 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -601,7 +601,7 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): @deprecated_alias(spiketrain='spiketrains') def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, - center_kernel=True, endpoint=False): + center_kernel=True): """ Estimates instantaneous firing rate by kernel convolution. @@ -629,21 +629,25 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', this width a gaussian kernel is constructed. Automatized calculation of the kernel width is not available for other than gaussian kernel shapes. + Default: 'auto' cutoff : float, optional This factor determines the cutoff of the probability distribution of the kernel, i.e., the considered width of the kernel in terms of multiples of the standard deviation sigma. + Default: 5.0 t_start : pq.Quantity, optional Start time of the interval used to compute the firing rate. If None, `t_start` is assumed equal to `t_start` attribute of `spiketrain`. + Default: None t_stop : pq.Quantity, optional End time of the interval used to compute the firing rate. If None, `t_stop` is assumed equal to `t_stop` attribute of `spiketrain`. + Default: None trim : bool, optional Accounts for the asymmetry of a kernel. @@ -658,19 +662,14 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Transformation by a total of two times the size of the kernel, and `t_start` and `t_stop` are adjusted. True (trimming) is equivalent to 'valid' convolution mode for symmetrical kernels. + Default: False center_kernel : bool, optional If set to True, the kernel will be translated such that its median is centered on the spike, thus putting equal weight before and after the spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. - Default: True - endpoint: bool, optional - If set to True, the estimation of the instantaneous firing rate will - be based on all spikes in the interval `[t_start, t_stop]`. - If False, only spikes in the interval `[t_start, n * sampling_period]` - are considered. Here `n` is an integer and defined as: - `n = int((t_stop - t_start) / sampling_period)`. + Default: True Returns @@ -712,8 +711,30 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Notes ----- - The resulting instantaneous firing rate values smaller than ``0``, which - may happen due to machine precision errors, are clipped to zero. + * The resulting instantaneous firing rate values smaller than ``0``, which + may happen due to machine precision errors, are clipped to zero. + + * The instantaneous firing rate estimate is calculated based on half-open + intervals ``[)``, except the last one e.g. if ``t_start = 0s``, + ``t_stop = 4s`` and ``sampling_period = 1s``, the intervals are: + + ``[0, 1)`` ``[1, 2)`` ``[2, 3)`` ``[3, 4]``. + + This induces a sampling bias, which can lead to a time shift of the + estimated rate, if the `sampling_period` is chosen large relative to the + duration ``(t_stop - t_start)``. One possibility to counteract this is + to choose a smaller `sampling_period`. + + * The last interval of the given duration ``(t_stop - t_start)`` is + dropped if it is shorter than `sampling_period`, + e.g. if ``t_start = 0s``, ``t_stop = 4.5s`` and + ``sampling_period = 1s``, the intervals considered are: + + ``[0, 1)`` ``[1, 2)`` ``[2, 3)`` ``[3, 4]``, + + the last interval ``[4, 4.5]`` is excluded from all calculations. + + Examples -------- @@ -809,9 +830,6 @@ def optimal_kernel(st): if not isinstance(trim, bool): raise TypeError("'trim' must be bool") - if not isinstance(endpoint, bool): - raise TypeError("'endpoint' must be bool") - check_neo_consistency(spiketrains, object_type=neo.SpikeTrain, t_start=t_start, t_stop=t_stop) @@ -829,26 +847,28 @@ def optimal_kernel(st): t_stop = spiketrains[0].t_stop # Rescale units for consistent calculation - units = pq.CompoundUnit( - "{}*s".format(sampling_period.rescale('s').item())) t_start = t_start.rescale(spiketrains[0].units) t_stop = t_stop.rescale(spiketrains[0].units) # Calculate parameters for np.histogram n_bins = int(((t_stop - t_start) / sampling_period).simplified) - if endpoint: - n_bins += 1 hist_range_end = t_start + n_bins * \ sampling_period.rescale(spiketrains[0].units) + + if hist_range_end != t_stop: + warnings.warn(f"The last interval from {hist_range_end} to {t_stop} " + f"was dropped. Length of interval: " + f"{t_stop-hist_range_end}") + hist_range = (t_start.item(), hist_range_end.item()) # Preallocation - time_vectors = np.zeros((len(spiketrains), n_bins), dtype=np.float64) + histogram_arr = np.zeros((len(spiketrains), n_bins), dtype=np.float64) for i, st in enumerate(spiketrains): - time_vectors[i], _ = np.histogram(st.magnitude, bins=n_bins, - range=hist_range) + histogram_arr[i], _ = np.histogram(st.magnitude, bins=n_bins, + range=hist_range) - time_vectors = time_vectors.T # make it (time, units) + histogram_arr = histogram_arr.T # make it (time, units) # Kernel if cutoff < kernel.min_cutoff: @@ -856,26 +876,33 @@ def optimal_kernel(st): warnings.warn("The width of the kernel was adjusted to a minimally " "allowed width.") - # An odd number of points correctly resolves the median index and the - # fact that the peak of an instantaneous rate should be centered at t=0 - # for symmetric kernels applied on a single spike at t=0. - # See issue https://github.com/NeuralEnsemble/elephant/issues/360 - n_half = math.ceil(cutoff * ( - kernel.sigma / sampling_period).simplified.item()) - cutoff_sigma = cutoff * kernel.sigma.rescale(units).magnitude - if center_kernel: - # t_arr must be centered at the kernel median. - # Not centering on the kernel median leads to underestimating the - # instantaneous rate in cases when sampling_period >> kernel.sigma. - median = kernel.icdf(0.5).rescale(units).item() + scaling_unit = pq.CompoundUnit(f"{sampling_period.rescale('s').item()}*s") + cutoff_sigma = cutoff * kernel.sigma.rescale(scaling_unit).magnitude + if center_kernel: # t_arr is centered on the kernel median. + median = kernel.icdf(0.5).rescale(scaling_unit).item() else: median = 0 + + # An odd number of points correctly resolves the median index of the + # kernel. This avoids a timeshift in the rate estimate for symmetric + # kernels. A number x given by 'x = 2 * n + 1' with n being an integer is + # always odd. Using `math.ceil` to calculate `t_arr_kernel_half` ensures an + # integer value, hence the number of points for the kernel (num) given by + # `num=2 * t_arr_kernel_half + 1` is always odd. + # (See Issue #360, https://github.com/NeuralEnsemble/elephant/issues/360) + t_arr_kernel_half = math.ceil( + cutoff * (kernel.sigma / sampling_period).simplified.item()) + t_arr_kernel_length = 2 * t_arr_kernel_half + 1 + # Shift kernel using the calculated median - t_arr = np.linspace(start=-cutoff_sigma + median, - stop=cutoff_sigma + median, - num=2 * n_half + 1, endpoint=True) * units + t_arr_kernel = np.linspace(start=-cutoff_sigma + median, + stop=cutoff_sigma + median, + num=t_arr_kernel_length, + endpoint=True) * scaling_unit + # Calculate the kernel values with t_arr - kernel_arr = np.expand_dims(kernel(t_arr).rescale(pq.Hz).magnitude, axis=1) + kernel_arr = np.expand_dims( + kernel(t_arr_kernel).rescale(pq.Hz).magnitude, axis=1) # Define mode for scipy.signal.fftconvolve if trim: @@ -883,7 +910,7 @@ def optimal_kernel(st): else: fft_mode = 'same' - rate = scipy.signal.fftconvolve(time_vectors, + rate = scipy.signal.fftconvolve(histogram_arr, kernel_arr, mode=fft_mode) # The convolution of non-negative vectors is non-negative @@ -891,13 +918,10 @@ def optimal_kernel(st): # Adjust t_start and t_stop if fft_mode == 'valid': - median_id = kernel.median_index(t_arr) + median_id = kernel.median_index(t_arr_kernel) kernel_array_size = len(kernel_arr) - t_start = t_start + median_id * units - t_stop = t_stop - (kernel_array_size - median_id) * units - - if endpoint: # last bin is used for calculation but no estimation is given - rate = rate[::-1] + t_start = t_start + median_id * scaling_unit + t_stop = t_stop - (kernel_array_size - median_id) * scaling_unit kernel_annotation = dict(type=type(kernel).__name__, sigma=str(kernel.sigma), @@ -940,10 +964,11 @@ def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, Default: None output : {'counts', 'mean', 'rate'}, optional Normalization of the histogram. Can be one of: - * 'counts': spike counts at each bin (as integer numbers) - * 'mean': mean spike counts per spike train - * 'rate': mean spike rate per spike train. Like 'mean', but the - counts are additionally normalized by the bin width. + * 'counts': spike counts at each bin (as integer numbers). + * 'mean': mean spike counts per spike train. + * 'rate': mean spike rate per spike train. Like 'mean', but the + counts are additionally normalized by the bin width. + Default: 'counts' binary : bool, optional If True, indicates whether all `neo.SpikeTrain` objects should first @@ -1092,25 +1117,28 @@ class Complexity(object): bin_size : pq.Quantity or None, optional Width of the histogram's time bins with units of time. The user must specify the `bin_size` or the `sampling_rate`. - * If None and the `sampling_rate` is available - 1/`sampling_rate` is used. - * If both are given then `bin_size` is used. + * If None and the `sampling_rate` is available + 1/`sampling_rate` is used. + * If both are given then `bin_size` is used. + Default: None binary : bool, optional - * If True then the time histograms will be binary. - * If False the total number of synchronous spikes is counted in the - time histogram. + * If True then the time histograms will be binary. + * If False the total number of synchronous spikes is counted in the + time histogram. + Default: True spread : int, optional Number of bins in which to check for synchronous spikes. Spikes that occur separated by `spread - 1` or less empty bins are considered synchronous. - * ``spread = 0`` corresponds to a bincount accross spike trains. - * ``spread = 1`` corresponds to counting consecutive spikes. - * ``spread = 2`` corresponds to counting consecutive spikes and - spikes separated by exactly 1 empty bin. - * ``spread = n`` corresponds to counting spikes separated by exactly - or less than `n - 1` empty bins. + * ``spread = 0`` corresponds to a bincount accross spike trains. + * ``spread = 1`` corresponds to counting consecutive spikes. + * ``spread = 2`` corresponds to counting consecutive spikes and + spikes separated by exactly 1 empty bin. + * ``spread = n`` corresponds to counting spikes separated by exactly + or less than `n - 1` empty bins. + Default: 0 tolerance : float or None, optional Tolerance for rounding errors in the binning process and in the input @@ -1123,18 +1151,20 @@ class Complexity(object): epoch : neo.Epoch An epoch object containing complexity values, left edges and durations of all intervals with at least one spike. - * ``epoch.array_annotations['complexity']`` contains the - complexity values per spike. - * ``epoch.times`` contains the left edges. - * ``epoch.durations`` contains the durations. + * ``epoch.array_annotations['complexity']`` contains the + complexity values per spike. + * ``epoch.times`` contains the left edges. + * ``epoch.durations`` contains the durations. + time_histogram : neo.Analogsignal A `neo.AnalogSignal` object containing the histogram values. `neo.AnalogSignal[j]` is the histogram computed between `t_start + j * binsize` and `t_start + (j + 1) * binsize`. - * If ``binary = True`` : Number of neurons that spiked in each bin, - regardless of the number of spikes. - * If ``binary = False`` : Number of neurons and spikes per neurons - in each bin. + * If ``binary = True`` : Number of neurons that spiked in each bin, + regardless of the number of spikes. + * If ``binary = False`` : Number of neurons and spikes per neurons + in each bin. + complexity_histogram : np.ndarray The number of occurrences of events of different complexities. `complexity_hist[i]` corresponds to the number of events of @@ -1168,11 +1198,11 @@ class Complexity(object): Notes ----- - * Note that with most common parameter combinations spike times can end up - on bin edges. This makes the binning susceptible to rounding errors which - is accounted for by moving spikes which are within tolerance of the next - bin edge into the following bin. This can be adjusted using the tolerance - parameter and turned off by setting `tolerance=None`. + Note that with most common parameter combinations spike times can end up + on bin edges. This makes the binning susceptible to rounding errors which + is accounted for by moving spikes which are within tolerance of the next + bin edge into the following bin. This can be adjusted using the tolerance + parameter and turned off by setting `tolerance=None`. See also -------- From b1ec09d0c508a0c6fddac01adfc799b66e026949 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 08:38:31 +0100 Subject: [PATCH 64/78] update requirements in environment-*.yml to neo>=0.10.0 --- requirements/environment-docs.yml | 2 +- requirements/environment-tests.yml | 2 +- requirements/environment.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/requirements/environment-docs.yml b/requirements/environment-docs.yml index 68fdfe1a0..c9da5d22c 100644 --- a/requirements/environment-docs.yml +++ b/requirements/environment-docs.yml @@ -14,6 +14,6 @@ dependencies: - statsmodels - jinja2 - pip: - - neo>=0.9.0,<0.10.0 + - neo>=0.10.0 - viziphant # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml index 68fdfe1a0..c9da5d22c 100644 --- a/requirements/environment-tests.yml +++ b/requirements/environment-tests.yml @@ -14,6 +14,6 @@ dependencies: - statsmodels - jinja2 - pip: - - neo>=0.9.0,<0.10.0 + - neo>=0.10.0 - viziphant # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt diff --git a/requirements/environment.yml b/requirements/environment.yml index 68fdfe1a0..c9da5d22c 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -14,6 +14,6 @@ dependencies: - statsmodels - jinja2 - pip: - - neo>=0.9.0,<0.10.0 + - neo>=0.10.0 - viziphant # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt From 203dbc9b4e1c84a7ac3065ac72c28ec0be6d11b4 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 10:21:52 +0100 Subject: [PATCH 65/78] updated .yml files to python version 3.7 --- .github/workflows/CI.yml | 8 ++++---- .travis.yml | 5 ++--- requirements/environment-docs.yml | 2 +- requirements/environment-tests.yml | 2 +- requirements/environment.yml | 2 +- 5 files changed, 9 insertions(+), 10 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index de04a89c1..1b1cc4f8a 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -44,8 +44,8 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - # python versions for elephant: [3.6, 3.7, 3.8, 3.9] - python-version: [3.6, 3.7, 3.8, 3.9] + # python versions for elephant: [3.7, 3.8, 3.9] + python-version: [3.7, 3.8, 3.9] # OS [ubuntu-latest, macos-latest, windows-latest] os: [ubuntu-latest] @@ -214,7 +214,7 @@ jobs: strategy: matrix: # python versions for elephant: [3.6, 3.7, 3.8, 3.9] - python-version: [3.6] + python-version: [3.9] # OS [ubuntu-latest, macos-latest, windows-latest] os: [ubuntu-latest] @@ -313,4 +313,4 @@ jobs: - name: make html run: | cd doc - make html \ No newline at end of file + make html diff --git a/.travis.yml b/.travis.yml index 43be16787..14df3f7fe 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,7 @@ addons: matrix: include: - name: "conda 3.6 extras,opencl" - python: 3.6 + python: 3.7 env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin before_script: @@ -32,7 +32,7 @@ matrix: env: DISTRIB="pip" - name: "docs" - python: 3.6 + python: 3.7 env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin before_script: @@ -74,4 +74,3 @@ install: script: pytest --cov=elephant --import-mode=importlib - \ No newline at end of file diff --git a/requirements/environment-docs.yml b/requirements/environment-docs.yml index c9da5d22c..00f3e8cc4 100644 --- a/requirements/environment-docs.yml +++ b/requirements/environment-docs.yml @@ -4,7 +4,7 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 - mpi4py - numpy - scipy diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml index c9da5d22c..00f3e8cc4 100644 --- a/requirements/environment-tests.yml +++ b/requirements/environment-tests.yml @@ -4,7 +4,7 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 - mpi4py - numpy - scipy diff --git a/requirements/environment.yml b/requirements/environment.yml index c9da5d22c..00f3e8cc4 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -4,7 +4,7 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 - mpi4py - numpy - scipy From 6cead92225411c8a740499183ef05b28243b63fb Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 11:35:44 +0100 Subject: [PATCH 66/78] removed python 3.6 from docs 'install.rst', added python version requirement to `setup.py` --- doc/install.rst | 2 +- setup.py | 13 +++++++------ 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/doc/install.rst b/doc/install.rst index 541e44565..eb71cbf56 100644 --- a/doc/install.rst +++ b/doc/install.rst @@ -14,7 +14,7 @@ Below is the explanation of how to proceed with these two steps. Prerequisites ************* -Elephant requires `Python `_ 3.6, 3.7, 3.8, or 3.9. +Elephant requires `Python `_ 3.7, 3.8, or 3.9. .. tabs:: diff --git a/setup.py b/setup.py index 57ab67d43..6f85f75f2 100644 --- a/setup.py +++ b/setup.py @@ -29,12 +29,12 @@ '-Dfim_EXPORTS', '-fopenmp', '/std:c++17']) elif platform.system() == "Darwin": fim_module = Extension( - name = 'elephant.spade_src.fim', - sources = ['elephant/spade_src/src/fim.cpp'], - include_dirs = ['elephant/spade_src/include'], - language = 'c++', - libraries = ['pthread', 'omp'], - extra_compile_args = [ + name='elephant.spade_src.fim', + sources=['elephant/spade_src/src/fim.cpp'], + include_dirs=['elephant/spade_src/include'], + language='c++', + libraries=['pthread', 'omp'], + extra_compile_args=[ '-DMODULE_NAME=fim', '-DUSE_OPENMP', '-DWITH_SIG_TERM', '-Dfim_EXPORTS', '-O3', '-pedantic', '-Wextra', '-Weffc++', '-Wunused-result', '-Werror', '-Werror=return-type', @@ -67,6 +67,7 @@ long_description=long_description, license="BSD", url='http://python-elephant.org', + python_requires=">=3.7", classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Science/Research', From 0459e76b81207b1a15519b64279a2644a867a575 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 11:51:08 +0100 Subject: [PATCH 67/78] rename travis conda 3.6 extras,opencl runner --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 14df3f7fe..ddfb4bcfe 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,7 @@ addons: matrix: include: - - name: "conda 3.6 extras,opencl" + - name: "conda 3.7 extras,opencl" python: 3.7 env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin From ec9e07e7978e30b33134757cf2347f6dedc3a2c2 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 11:55:22 +0100 Subject: [PATCH 68/78] updated build_wheels workflow to exclude python 3.6 --- .github/workflows/build_wheels.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml index 46cd527d8..d9a483822 100644 --- a/.github/workflows/build_wheels.yml +++ b/.github/workflows/build_wheels.yml @@ -34,8 +34,8 @@ jobs: - name: Build wheels run: python -m cibuildwheel --output-dir wheelhouse env: - CIBW_SKIP: "cp27-* cp33-* cp34-* cp35-* pp*" - CIBW_PROJECT_REQUIRES_PYTHON: ">=3.6" + CIBW_SKIP: "cp27-* cp33-* cp34-* cp35-* cp36-* pp*" + CIBW_PROJECT_REQUIRES_PYTHON: ">=3.7" CIBW_ARCHS: "auto64" - uses: actions/upload-artifact@v2 From aef297b8a36b5312ffbfa1355ef0bb5c33b3c5db Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 15:10:40 +0100 Subject: [PATCH 69/78] removed redundant line --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index cab57f9f9..74d526c91 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -284,7 +284,6 @@ jobs: run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH - sudo apt install -y libopenmpi-dev openmpi-bin - name: Cache pip uses: actions/cache@v2 @@ -299,6 +298,7 @@ jobs: python -m pip install --upgrade pip pip install -r requirements/requirements-docs.txt pip install -r requirements/requirements-tutorials.txt + pip install . conda update conda conda env update --file requirements/environment-docs.yml --name base conda install -c conda-forge openmpi From 84b983e76a2697ae6ce39da8f0b1862e4a5d6ec9 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 15:17:13 +0100 Subject: [PATCH 70/78] changed structure of installation for docs runner --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 74d526c91..927d7805e 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -298,11 +298,11 @@ jobs: python -m pip install --upgrade pip pip install -r requirements/requirements-docs.txt pip install -r requirements/requirements-tutorials.txt - pip install . conda update conda conda env update --file requirements/environment-docs.yml --name base conda install -c conda-forge openmpi conda install -c conda-forge pandoc + pip install . # run notebooks sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py From e01586260fd692604c3456d202b725f7f87bff45 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 15:27:20 +0100 Subject: [PATCH 71/78] added extras to docs runner --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 927d7805e..a987c6cfc 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -302,7 +302,7 @@ jobs: conda env update --file requirements/environment-docs.yml --name base conda install -c conda-forge openmpi conda install -c conda-forge pandoc - pip install . + pip install -e .[extras] # run notebooks sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py From a9969350b3dbf3572355af2085464942e5842425 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 17:40:09 +0100 Subject: [PATCH 72/78] merged changes for instantaneous rate --- elephant/statistics.py | 10 +++++----- elephant/test/test_statistics.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 5642f1c82..04f312039 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -945,7 +945,10 @@ def optimal_kernel(st): sigma=str(kernel.sigma), invert=kernel.invert) - + rate = neo.AnalogSignal(signal=rate, + sampling_period=sampling_period, + units=pq.Hz, t_start=t_start, t_stop=t_stop, + kernel=kernel_annotation) if border_correction: sigma = kernel.sigma.simplified.magnitude @@ -965,10 +968,7 @@ def optimal_kernel(st): rate[:, i] *= len(spiketrain) /\ (np.mean(rate[:, i]).magnitude * duration) - return neo.AnalogSignal(signal=rate, - sampling_period=sampling_period, - units=pq.Hz, t_start=t_start, t_stop=t_stop, - kernel=kernel_annotation) + return rate @deprecated_alias(binsize='bin_size') diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index aabbcef00..48c115d21 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -882,7 +882,7 @@ def test_border_correction(self): sampling_period = 0.1 * pq.ms - trial_list = StationaryPoissonProcess( + trial_list = StatPP( rate=rate, t_start=t_start, t_stop=t_stop ).generate_n_spiketrains(n_spiketrains) From d08c7c94cf6467afe91d2e718735db22ca654657 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Mon, 14 Mar 2022 17:41:56 +0100 Subject: [PATCH 73/78] changed trigger for github actions CI --- .github/workflows/CI.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index a987c6cfc..b776e5146 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -36,6 +36,9 @@ on: #- review_request_removed #- auto_merge_enabled #- auto_merge_disabled + push: + branches: + - master # jobs define the steps that will be executed on the runner jobs: From 26ab04e9d7110b2a8e5121460e983a644b664610 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Wed, 23 Mar 2022 11:16:13 +0100 Subject: [PATCH 74/78] upload docs build html as artifact --- .github/workflows/CI.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index b776e5146..feacff229 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -1,4 +1,4 @@ -# This workflow will setup GitHub-hosted runners and install the required dependencies for elephant tests. +# This workflow will set up GitHub-hosted runners and install the required dependencies for elephant tests. # On a pull requests and on pushes to master it will run different tests for elephant. name: tests @@ -319,3 +319,9 @@ jobs: run: | cd doc make html + + - name: Upload HTML + uses: actions/upload-artifact@v3 + with: + name: docs-html + path: doc/_build/html # doc/_build/html From 5fef259357f282fa1513453c8c45ff1fb82007b1 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Wed, 23 Mar 2022 11:49:57 +0100 Subject: [PATCH 75/78] conda runner, use newest pytest version --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index feacff229..e7d1efe20 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -139,7 +139,7 @@ jobs: activate base conda install -c conda-forge openmpi pip install -r requirements/requirements-tests.txt - pip install pytest==6.2.5 # hotfix for pytest 7.0.0, remove once fixed + pip install pytest pip install pytest-cov coveralls pip install . From 0c2546cd8554e0b9010b5640d459f7829a0ec44a Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Wed, 6 Jul 2022 15:01:58 +0200 Subject: [PATCH 76/78] fixed .yml --- .github/workflows/CI.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 3cefc11b9..43a88bba3 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -327,7 +327,6 @@ jobs: os: [ubuntu-latest] steps: - - name: Get current year-month id: date run: echo "::set-output name=date::$(date +'%Y-%m')" From ba00dae25dd7d383fe0196948f752e613a615fc8 Mon Sep 17 00:00:00 2001 From: Moritz-Alexander-Kern Date: Wed, 6 Jul 2022 15:03:50 +0200 Subject: [PATCH 77/78] fixed indentation --- .github/workflows/CI.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 43a88bba3..dd1a29b71 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -372,8 +372,8 @@ jobs: cd doc make html - - name: Upload HTML - uses: actions/upload-artifact@v3 - with: - name: docs-html - path: doc/_build/html + - name: Upload HTML + uses: actions/upload-artifact@v3 + with: + name: docs-html + path: doc/_build/html From 00e99ab8365de3ab7f486b744b59cf735444fc7e Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Tue, 26 Jul 2022 14:18:29 +0200 Subject: [PATCH 78/78] Update CI.yml --- .github/workflows/CI.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index dd1a29b71..c487083ac 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -371,8 +371,9 @@ jobs: run: | cd doc make html - + - name: Upload HTML + if: ${{ github.event.label.name == 'upload html' }} uses: actions/upload-artifact@v3 with: name: docs-html