flake E275

Author: k1o0

brainbox/behavior/training.py

@@ -227,7 +227,7 @@ def get_training_status(trials, task_protocol, ephys_sess_dates, n_delay):
          info.rt) = compute_bias_info(trials, trials_all)
         # We are still on training rig and so all sessions should be biased
         if len(ephys_sess_dates) == 0:
-            assert(np.all(np.array(task_protocol) == 'biased'))
+            assert np.all(np.array(task_protocol) == 'biased')
             if criterion_ephys(info.psych_20, info.psych_80, info.n_trials, info.perf_easy,
                                info.rt):
                 status = 'ready4ephysrig'

brainbox/plot_base.py

@@ -109,7 +109,7 @@ def _set_lim(self, axis, lim=None):
         :return:
         """
         if lim is not None:
-            assert(len(lim) == 2)
+            assert len(lim) == 2
         else:
             lim = (np.nanmin(self.data[axis]), np.nanmax(self.data[axis]))
         return lim
@@ -175,7 +175,7 @@ def set_scale(self, scale=None):
         """
         # For pyqtgraph implementation
         if scale is not None:
-            assert(len(scale) == 2)
+            assert len(scale) == 2
         self.scale = self._set_default(scale, (self._get_scale('x'), self._get_scale('y')))
 
     def _get_scale(self, axis):
@@ -203,7 +203,7 @@ def set_offset(self, offset=None):
         """
         # For pyqtgraph implementation
         if offset is not None:
-            assert(len(offset) == 2)
+            assert len(offset) == 2
         self.offset = self._set_default(offset, (self._get_offset('x'), self._get_offset('y')))
 
     def _get_offset(self, axis):
@@ -229,9 +229,9 @@ def __init__(self, img, x, y, cmap=None):
         """
 
         # Make sure we have inputs as lists, can get input from arrange_channels2banks
-        assert(type(img) == list)
-        assert(type(x) == list)
-        assert(type(y) == list)
+        assert type(img) == list
+        assert type(x) == list
+        assert type(y) == list
 
         data = Bunch({'x': x, 'y': y, 'c': img})
         super().__init__('probe', data)
@@ -257,7 +257,7 @@ def _get_scale(self, idx, axis):
 
     def _set_lim_list(self, axis, idx, lim=None):
         if lim is not None:
-            assert(len(lim) == 2)
+            assert len(lim) == 2
         else:
             lim = (np.nanmin(self.data[axis][idx]), np.nanmax(self.data[axis][idx]))
         return lim

brainbox/quality/lfp_qc.py

@@ -107,7 +107,7 @@ def _plot_rmsmap(outpath, typ, savefig=True):
     else:
         outpath = Path(sys.argv[1])  # grab from command line input
         fbin = glob.glob(os.path.join(outpath, '*.lf.bin'))
-        assert(len(fbin) > 0)
+        assert len(fbin) > 0
         print('fbin: %s' % fbin)
         # make sure you send a path for the time being and not a string
         ephysqc.extract_rmsmap(Path(fbin[0]))

brainbox/task/trials.py

@@ -173,7 +173,7 @@ def get_event_aligned_raster(times, events, tbin=0.02, values=None, epoch=[-0.4,
     if np.sum(out_intervals) > 0:
         event_raster = np.r_[event_raster, np.full((np.sum(out_intervals),
                                                     event_raster.shape[1]), np.nan)]
-        assert(event_raster.shape[0] == intervals.shape[0])
+        assert event_raster.shape[0] == intervals.shape[0]
 
     # Reindex if we have removed any nan values
     all_event_raster = np.full((events.shape[0], event_raster.shape[1]), np.nan)

brainbox/tests/test_behavior.py

@@ -181,7 +181,7 @@ def test_trained_1b(self):
         assert (np.all(np.array(task_protocol) == 'training'))
         status, info = train.get_training_status(trials, task_protocol, ephys_sess_dates=[],
                                                  n_delay=0)
-        assert(status == 'trained 1b')
+        self.assertEqual(status, 'trained 1b')
 
     def test_training_to_bias(self):
         trials, task_protocol = self._get_trials(

brainbox/tests/test_metrics.py

@@ -80,7 +80,7 @@ def test_drift_estimate():
     t, a, c = multiple_spike_trains(firing_rates=frs, rec_len_secs=200)
     # test negative times, no drift
     drift, ts = electrode_drift.estimate_drift(t - 2, a, cells_depth[c])
-    assert(np.all(np.abs(drift) < 0.01))
+    assert np.all(np.abs(drift) < 0.01)
     # test drift recovery - sinusoid 40 um peak amplitude
     dcor = np.sin(2 * np.pi * t / np.max(t) * 2) * 50
     drift, ts = electrode_drift.estimate_drift(t, a, cells_depth[c] + dcor, display=False)

brainbox/tests/test_passive.py

@@ -27,20 +27,24 @@ def test_rf_map(self):
 
         rf_map_times, rf_map_pos, rf_stim_frames = passive.get_on_off_times_and_positions(rf_map)
 
-        assert(all(rf_map_times == test_times))
-        assert(rf_map_pos.shape == (15 * 15, 2))
-        assert(len(rf_stim_frames['on']) == 15 * 15)
-        assert(len(rf_stim_frames['off']) == 15 * 15)
+        self.assertTrue(np.all(rf_map_times == test_times))
+        self.assertEqual(rf_map_pos.shape, (15 * 15, 2))
+        self.assertEqual(len(rf_stim_frames['on']), 15 * 15)
+        self.assertEqual(len(rf_stim_frames['off']), 15 * 15)
 
         # Off is for the 0 ones
-        assert(all(rf_stim_frames['off'][ismember2d(rf_map_pos, np.array([[8, 8]]))[0]][0][0]
-                   == [10, 50]))
-        assert(rf_stim_frames['off'][ismember2d(rf_map_pos, np.array([[4, 9]]))[0]][0][0] == 40)
-        assert(rf_stim_frames['off'][ismember2d(rf_map_pos, np.array([[11, 4]]))[0]][0][0] == 42)
+        idx = ismember2d(rf_map_pos, np.array([[8, 8]]))[0]
+        self.assertTrue(np.all(rf_stim_frames['off'][idx][0][0] == [10, 50]))
+        idx = ismember2d(rf_map_pos, np.array([[4, 9]]))[0]
+        self.assertEqual(rf_stim_frames['off'][idx][0][0], 40)
+        idx = ismember2d(rf_map_pos, np.array([[11, 4]]))[0]
+        self.assertEqual(rf_stim_frames['off'][idx][0][0], 42)
 
         # On is for the 255 ones
-        assert(rf_stim_frames['on'][ismember2d(rf_map_pos, np.array([[10, 13]]))[0]][0][0] == 25)
-        assert(rf_stim_frames['on'][ismember2d(rf_map_pos, np.array([[6, 10]]))[0]][0][0] == 42)
+        idx = ismember2d(rf_map_pos, np.array([[10, 13]]))[0]
+        self.assertEqual(rf_stim_frames['on'][idx][0][0], 25)
+        idx = ismember2d(rf_map_pos, np.array([[6, 10]]))[0]
+        self.assertEqual(rf_stim_frames['on'][idx][0][0], 42)
 
         # Next test that the firing rate function works
         # Basically just make one square responsive
@@ -51,19 +55,19 @@ def test_rf_map(self):
                                                            rf_stim_frames, spike_times,
                                                            spike_depths, x_lim=[0, 60])
         non_zero = np.where(rf_map_avg['on'] != 0)
-        assert(np.argmin(np.abs(depths - 500)) == non_zero[0][0])
-        assert(all(non_zero[1] == 10))
-        assert (all(non_zero[2] == 13))
+        self.assertEqual(np.argmin(np.abs(depths - 500)), non_zero[0][0])
+        self.assertTrue(np.all(non_zero[1] == 10))
+        self.assertTrue(np.all(non_zero[2] == 13))
 
-        assert(np.all(rf_map_avg['off'] == 0))
+        self.assertTrue(np.all(rf_map_avg['off'] == 0))
 
         rf_svd = passive.get_svd_map(rf_map_avg)
         # Make sure that the one responsive element is non-zero
-        assert(rf_svd['on'][non_zero[0][0]][non_zero[1][0], non_zero[2][0]] != 0)
+        self.assertTrue(rf_svd['on'][non_zero[0][0]][non_zero[1][0], non_zero[2][0]] != 0)
         # But that all the rest are zero
         rf_svd['on'][non_zero[0][0]][non_zero[1][0], non_zero[2][0]] = 0
-        assert(np.all(np.isclose(np.vstack(rf_svd['on']), 0)))
-        assert(np.all(np.vstack(rf_svd['off']) == 0))
+        self.assertTrue(np.all(np.isclose(np.vstack(rf_svd['on']), 0)))
+        self.assertTrue(np.all(np.vstack(rf_svd['off']) == 0))
 
     def test_stim_aligned(self):
 
@@ -78,8 +82,8 @@ def test_stim_aligned(self):
         stim_activity = passive.get_stim_aligned_activity(aud_stim, spike_times, spike_depths,
                                                           z_score_flag=False, x_lim=[0, 40])
 
-        assert(list(stim_activity.keys()) == ['valveOn'])
+        self.assertCountEqual(stim_activity.keys(), ['valveOn'])
         # The first may be a bit different due to overlap with noise floor
-        assert(all(stim_activity['valveOn'][0][1:] == 5))
+        self.assertTrue(np.all(stim_activity['valveOn'][0][1:] == 5))
         # make sure the rest of the depths are all zero
-        assert(np.all(stim_activity['valveOn'][1:] == 0))
+        self.assertTrue(np.all(stim_activity['valveOn'][1:] == 0))