lint fix and mark extra_features_utils tests as unit tests

Author: Jaquier Aurélien Tristan

bluepyopt/ephys/objectives.py

@@ -85,7 +85,7 @@ def __str__(self):
         """String representation"""
 
         return '( %s )' % self.features[0]
-    
+
 
 class SingletonWeightObjective(EFeatureObjective):
 

bluepyopt/ephys/parameters.py

@@ -252,7 +252,7 @@ class NrnPointProcessParameter(NrnParameter, DictMixin):
 
     """Parameter of a section"""
     SERIALIZED_FIELDS = ('name', 'value', 'frozen', 'bounds', 'param_name',
-                         'value_scaler', 'locations', 'param_name', 
+                         'value_scaler', 'locations', 'param_name',
                          'param_dependancies')
 
     def __init__(

bluepyopt/ephys/parameterscalers.py

@@ -92,7 +92,7 @@ def __str__(self):
 class NrnSegmentSectionDistanceScaler(ParameterScaler, DictMixin):
 
     """Scaler based on distance from soma"""
-    SERIALIZED_FIELDS = ('name', 'comment', 'distribution', 
+    SERIALIZED_FIELDS = ('name', 'comment', 'distribution',
                          "distribution", "dist_param_names",
                          "ref_sec", "ref_location",)
 

bluepyopt/tests/test_ephys/test_extra_features_utils.py

@@ -16,13 +16,16 @@
 waveform = numpy.array([waveforms[0]])
 sampling_freq = 10000
 
+
+@pytest.mark.unit
 def test_peak_to_valley():
     """ephys.extra_features_utils: Test peak_to_valley"""
     ptv = ephys.extra_features_utils.peak_to_valley(waveform, sampling_freq)
     assert len(ptv) == 1
     assert ptv[0] == pytest.approx(0.0013)
 
 
+@pytest.mark.unit
 def test_peak_trough_ratio():
     """ephys.extra_features_utils: Test peak_trough_ratio"""
     ptratio = ephys.extra_features_utils.peak_trough_ratio(waveform)
@@ -31,6 +34,7 @@ def test_peak_trough_ratio():
     assert ptratio[0] == pytest.approx(0.53804035)
 
 
+@pytest.mark.unit
 def test_halfwidth():
     """ephys.extra_features_utils: Test halfwidth"""
     ret = ephys.extra_features_utils.halfwidth(waveform, sampling_freq, True)
@@ -41,66 +45,95 @@ def test_halfwidth():
     assert hw[0] == pytest.approx(0.0015)
 
 
+@pytest.mark.unit
 def test_repolarization_slope():
     """ephys.extra_features_utils: Test repolarization_slope"""
-    ret = ephys.extra_features_utils.repolarization_slope(waveform, sampling_freq, True)
+    ret = ephys.extra_features_utils.repolarization_slope(
+        waveform, sampling_freq, True
+    )
     assert len(ret) == 2
 
-    rslope = ephys.extra_features_utils.repolarization_slope(waveform, sampling_freq)
+    rslope = ephys.extra_features_utils.repolarization_slope(
+        waveform, sampling_freq
+    )
     assert len(rslope) == 1
     assert rslope[0] == pytest.approx(73.12572131)
 
 
+@pytest.mark.unit
 def test_recovery_slope():
     """ephys.extra_features_utils: Test recovery_slope"""
-    window=0.7
-    rslope = ephys.extra_features_utils.recovery_slope(waveform, sampling_freq, window=window)
+    window = 0.7
+    rslope = ephys.extra_features_utils.recovery_slope(
+        waveform, sampling_freq, window=window
+    )
     assert len(rslope) == 1
     assert rslope[0] == pytest.approx(-3.63355521)
 
 
+@pytest.mark.unit
 def test_peak_image():
     """ephys.extra_features_utils: Test peak_image"""
-    rel_peaks = ephys.extra_features_utils.peak_image(waveforms, sign="negative")
+    rel_peaks = ephys.extra_features_utils.peak_image(
+        waveforms, sign="negative"
+    )
     assert len(rel_peaks) == 209
     assert rel_peaks[0] == pytest.approx(0.06084468)
 
-    rel_peaks = ephys.extra_features_utils.peak_image(waveforms, sign="positive")
+    rel_peaks = ephys.extra_features_utils.peak_image(
+        waveforms, sign="positive"
+    )
     assert len(rel_peaks) == 209
     assert rel_peaks[0] == pytest.approx(0.10850117)
 
 
+@pytest.mark.unit
 def test_relative_amplitude():
     """ephys.extra_features_utils: Test relative_amplitude"""
-    rel_amp = ephys.extra_features_utils.relative_amplitude(waveforms, sign="negative")
+    rel_amp = ephys.extra_features_utils.relative_amplitude(
+        waveforms, sign="negative"
+    )
     assert len(rel_amp) == 209
     assert rel_amp[0] == pytest.approx(0.09513392)
 
-    rel_amp = ephys.extra_features_utils.relative_amplitude(waveforms, sign="positive")
+    rel_amp = ephys.extra_features_utils.relative_amplitude(
+        waveforms, sign="positive"
+    )
     assert len(rel_amp) == 209
     assert rel_amp[0] == pytest.approx(0.2135929)
 
 
+@pytest.mark.unit
 def test_peak_time_diff():
     """ephys.extra_features_utils: Test peak_time_diff"""
-    peak_t = ephys.extra_features_utils.peak_time_diff(waveforms, sampling_freq, sign="negative")
+    peak_t = ephys.extra_features_utils.peak_time_diff(
+        waveforms, sampling_freq, sign="negative"
+    )
     assert len(peak_t) == 209
     assert peak_t[0] == pytest.approx(0.0009)
 
-    peak_t = ephys.extra_features_utils.peak_time_diff(waveforms, sampling_freq, sign="positive")
+    peak_t = ephys.extra_features_utils.peak_time_diff(
+        waveforms, sampling_freq, sign="positive"
+    )
     assert len(peak_t) == 209
     assert peak_t[0] == pytest.approx(0.0007)
 
 
+@pytest.mark.unit
 def test__get_trough_and_peak_idx():
     """ephys.extra_features_utils: Test _get_trough_and_peak_idx"""
-    t_idx, p_idx = ephys.extra_features_utils._get_trough_and_peak_idx(waveform)
+    t_idx, p_idx = ephys.extra_features_utils._get_trough_and_peak_idx(
+        waveform
+    )
     assert t_idx == 102
     assert p_idx == 115
 
 
+@pytest.mark.unit
 def test_calculate_features():
     """ephys.extra_features_utils: Test calculate_features"""
-    feats = ephys.extra_features_utils.calculate_features(waveforms, sampling_freq)
+    feats = ephys.extra_features_utils.calculate_features(
+        waveforms, sampling_freq
+    )
     for feature_name in ephys.extra_features_utils.all_1D_features:
-        assert feature_name in feats
+        assert feature_name in feats

bluepyopt/tests/test_ephys/test_features.py

@@ -260,7 +260,7 @@ def test_extraFELFeature():
     name = 'test_extraFELFeature'
     stim_start = 400
     stim_end = 1750
-    fs = 10 # sampling freq (kHz)
+    fs = 10
     ms_cut = [10, 25]
 
     # load responses from file
@@ -288,11 +288,10 @@ def test_extraFELFeature():
         fs=fs,
         ms_cut=ms_cut
     )
-    
+
     ret = efeature.calculate_feature(responses, raise_warnings=True)
     assert len(ret) == 209
 
-
     # compute for 1 electrode
     efeature = efeatures.extraFELFeature(
         name=name,

bluepyopt/tests/test_ephys/test_models.py

@@ -184,7 +184,9 @@ def test_CellModel_destroy():
 def test_lfpy_create_empty_template():
     """ephys.models: Test creation of lfpy empty template"""
     template_name = 'FakeTemplate'
-    hoc_template = ephys.models.LFPyCellModel.create_empty_template(template_name)
+    hoc_template = ephys.models.LFPyCellModel.create_empty_template(
+        template_name
+    )
     sim.neuron.h(hoc_template)
     assert hasattr(sim.neuron.h, template_name)
 
@@ -225,7 +227,9 @@ def test_load_lfpy_hoc_template():
     """ephys.models: Test loading of hoc template with lfpy cell"""
 
     template_name = 'test_load_hoc'
-    hoc_string = ephys.models.LFPyCellModel.create_empty_template(template_name)
+    hoc_string = ephys.models.LFPyCellModel.create_empty_template(
+        template_name
+    )
     ephys.models.HocCellModel.load_hoc_template(sim, hoc_string)
     assert hasattr(sim.neuron.h, template_name)
 
@@ -245,12 +249,15 @@ def test_LFPyCellModel_create_hoc():
 
     morph0 = ephys.morphologies.NrnFileMorphology(
         simple_morphology_path,
-        do_replace_axon=True)
+        do_replace_axon=True
+    )
 
-    cell_model = ephys.models.LFPyCellModel('LFPyCellModel',
-                                        morph=morph0,
-                                        mechs=[],
-                                        params=[])
+    cell_model = ephys.models.LFPyCellModel(
+        'LFPyCellModel',
+        morph=morph0,
+        mechs=[],
+        params=[]
+    )
 
     hoc_string = cell_model.create_hoc({})
     assert 'begintemplate LFPyCellModel' in hoc_string

bluepyopt/tests/test_ephys/test_parameterscalers.py

@@ -38,7 +38,7 @@ def test_NrnSegmentSomaDistanceScaler_dist_params():
 
 @pytest.mark.unit
 def test_NrnSegmentSectionDistanceScaler_eval_dist_with_dict():
-    """ephys.parameterscalers: eval_dist of NrnSegmentSectionDistanceScaler with dict as values"""
+    """ephys.parameterscalers: eval_dist of NrnSegmentSectionDistanceScaler"""
 
     dist = '{param1_somatic} + (1 - (abs({distance} - 8) / 4)) * {value}'
 

bluepyopt/tests/test_ephys/test_recordings.py

@@ -100,7 +100,9 @@ def test_lfprecording_instantiate():
     test_morph = ephys.morphologies.NrnFileMorphology(simple_morphology_path)
 
     recording = ephys.recordings.LFPRecording()
-    lfpy_cell = ephys.models.LFPyCellModel(name="lfpy_cell", morph=test_morph, mechs=[])
+    lfpy_cell = ephys.models.LFPyCellModel(
+        name="lfpy_cell", morph=test_morph, mechs=[]
+    )
     neuron_sim = ephys.simulators.LFPySimulator(LFPyCellModel=lfpy_cell)
     lfpy_cell.instantiate(sim=neuron_sim)
 
@@ -111,4 +113,3 @@ def test_lfprecording_instantiate():
     assert recording.instantiated
 
     lfpy_cell.destroy(sim=neuron_sim)
-

bluepyopt/tests/test_ephys/test_simulators.py

@@ -169,7 +169,7 @@ def test_lfpyimulator_init_windows():
 
 @pytest.mark.unit
 def test__lfpysimulator_neuron_import():
-    """ephys.simulators: test if neuron import from LFPySimulator was successful"""
+    """ephys.simulators: test neuron import from LFPySimulator"""
     from bluepyopt import ephys  # NOQA
     empty_cell = ephys.models.LFPyCellModel(name="empty_cell")
     neuron_sim = ephys.simulators.LFPySimulator(LFPyCellModel=empty_cell)
@@ -178,7 +178,7 @@ def test__lfpysimulator_neuron_import():
 
 @pytest.mark.unit
 def test_lfpysim_run_cvodeactive_dt_exception():
-    """ephys.simulators: test if LFPySimulator run returns exception cvode and dt both used"""
+    """ephys.simulators: test if LFPySimulator run returns exception"""
 
     from bluepyopt import ephys  # NOQA
     TESTDATA_DIR = os.path.join(
@@ -187,13 +187,20 @@ def test_lfpysim_run_cvodeactive_dt_exception():
     simple_morphology_path = os.path.join(TESTDATA_DIR, 'simple.swc')
     test_morph = ephys.morphologies.NrnFileMorphology(simple_morphology_path)
 
-    lfpy_cell = ephys.models.LFPyCellModel(name="lfpy_cell", morph=test_morph, mechs=[])
+    lfpy_cell = ephys.models.LFPyCellModel(
+        name="lfpy_cell", morph=test_morph, mechs=[]
+    )
     neuron_sim = ephys.simulators.LFPySimulator(LFPyCellModel=lfpy_cell)
     lfpy_cell.instantiate(sim=neuron_sim)
 
-    with pytest.raises(ValueError, match=('NrnSimulator: '
-        'Impossible to combine the dt argument when '
-        'cvode_active is True in the NrnSimulator run method')):
+    with pytest.raises(
+        ValueError,
+        match=(
+            'NrnSimulator: '
+            'Impossible to combine the dt argument when '
+            'cvode_active is True in the NrnSimulator run method'
+        ),
+    ):
         neuron_sim.run(10, dt=0.1, cvode_active=True)
 
     lfpy_cell.destroy(sim=neuron_sim)
@@ -202,7 +209,7 @@ def test_lfpysim_run_cvodeactive_dt_exception():
 @pytest.mark.unit
 @mock.patch('glob.glob')
 def test_lfpysimulator_disable_banner_exception(mock_glob):
-    """ephys.simulators: test if LFPySimulator disable_banner raises exception"""
+    """ephys.simulators: test LFPySimulator disable_banner raises exception"""
     mock_glob.return_value = []
 
     import warnings

bluepyopt/tests/test_ephys/testmodels/dummycells.py

@@ -60,7 +60,6 @@ def destroy(self, sim=None):
         self.persistent = []
 
 
-
 class DummyLFPyCellModel1(ephys.models.Model):
 
     """Dummy LFPy cell model 1"""
@@ -126,4 +125,4 @@ def __init__(self):
     def destroy(self, sim=None):
         """Destroy cell from simulator"""
 
-        self.persistent = []
+        self.persistent = []