delete old tests, pq copy removal

Author: zm711

neo/core/spiketrain.py

@@ -225,7 +225,7 @@ def normalize_times_array(times, units=None, dtype=None, copy=None):
     # reference dimensionality
     if len(dim) != 1 or list(dim.values())[0] != 1 or not isinstance(list(dim.keys())[0], pq.UnitTime):
         ValueError(f"Units have dimensions {dim.simplified}, not [time]")
-    return pq.Quantity(times, units=units, dtype=dtype, copy=copy), dim
+    return pq.Quantity(times, units=units, dtype=dtype,), dim
 
 
 class SpikeTrain(DataObject):

neo/io/neurosharectypesio.py

@@ -224,10 +224,10 @@ def read_segment(self, import_neuroshare_segment=True, lazy=False):
                     total_read += pdwContCount.value
 
                 try:
-                    signal = pq.Quantity(pData, units=pAnalogInfo.szUnits.decode(), copy=False)
+                    signal = pq.Quantity(pData, units=pAnalogInfo.szUnits.decode())
                     unit_annotation = None
                 except LookupError:
-                    signal = pq.Quantity(pData, units="dimensionless", copy=False)
+                    signal = pq.Quantity(pData, units="dimensionless")
                     unit_annotation = pAnalogInfo.szUnits.decode()
 
                 # t_start
@@ -292,9 +292,9 @@ def read_segment(self, import_neuroshare_segment=True, lazy=False):
                     waveforms[dwIndex, :, :] = pData[: nsample * nsource].reshape(nsample, nsource).transpose()
 
                 sptr = SpikeTrain(
-                    times=pq.Quantity(times, units="s", copy=False),
+                    times=pq.Quantity(times, units="s",
                     t_stop=times.max(),
-                    waveforms=pq.Quantity(waveforms, units=str(pdwSegmentInfo.szUnits), copy=False),
+                    waveforms=pq.Quantity(waveforms, units=str(pdwSegmentInfo.szUnits)),
                     left_sweep=nsample / 2.0 / float(pdwSegmentInfo.dSampleRate) * pq.s,
                     sampling_rate=float(pdwSegmentInfo.dSampleRate) * pq.Hz,
                     name=str(entityInfo.szEntityLabel),

neo/test/coretest/test_analogsignal.py

@@ -131,31 +131,6 @@ def test__create_inconsistent_sampling_rate_and_period_ValueError(self):
         data = np.arange(10.0) * pq.mV
         self.assertRaises(ValueError, AnalogSignal, data, sampling_rate=1 * pq.kHz, sampling_period=5 * pq.s)
 
-    # to be removed after testing in CI
-    #def test__create_with_copy_true_should_return_copy(self):
-    #    data = np.arange(10.0) * pq.mV
-    #   rate = 5000 * pq.Hz
-    #    signal = AnalogSignal(data, copy=True, sampling_rate=rate)
-    #    data[3] = 99 * pq.mV
-    #    assert_neo_object_is_compliant(signal)
-    #    self.assertNotEqual(signal[3, 0], 99 * pq.mV)
-
-    #def test__create_with_copy_false_should_return_view(self):
-    #   data = np.arange(10.0) * pq.mV
-    #    rate = 5000 * pq.Hz
-    #    signal = AnalogSignal(data, copy=False, sampling_rate=rate)
-    #    data[3] = 99 * pq.mV
-    #    assert_neo_object_is_compliant(signal)
-    #    self.assertEqual(signal[3, 0], 99 * pq.mV)
-
-    #def test__create2D_with_copy_false_should_return_view(self):
-    #    data = np.arange(10.0) * pq.mV
-    #    data = data.reshape((5, 2))
-    #    rate = 5000 * pq.Hz
-    #    signal = AnalogSignal(data, copy=False, sampling_rate=rate)
-    #    data[3, 0] = 99 * pq.mV
-    #    assert_neo_object_is_compliant(signal)
-    #    self.assertEqual(signal[3, 0], 99 * pq.mV)
 
     def test__create_with_additional_argument(self):
         signal = AnalogSignal(

neo/test/coretest/test_spiketrain.py

@@ -1542,33 +1542,6 @@ def test__dtype_change(self):
         data = np.array([3, 4, 5])
         self.assertRaises(ValueError, SpikeTrain, data, units="sec", t_stop=101, dtype=np.float64)
 
-    # need to remove for numpy 2.0 and quantities
-    #def test_change_with_copy_true_and_data_not_quantity(self):
-        # Changing spike train does not change data
-        # Data source is array
-        # Array and quantity are tested separately because copy default
-        # is different for these two.
-    #   data = [3, 4, 5]
-    #    train = SpikeTrain(data, units="sec", copy=True, t_stop=123.4)
-    #   train[0] = 99 * pq.s
-    #    assert_neo_object_is_compliant(train)
-    #    self.assertEqual(train[0], 99 * pq.s)
-    #    self.assertEqual(data[0], 3)
-
-    #def test_changing_slice_changes_original_spiketrain(self):
-        # If we slice a spiketrain and then change the slice, the
-        # original spiketrain should change.
-        # Whether the original data source changes is dependent on the
-        # copy parameter.
-        # This is compatible with both np and quantity default behavior.
-    #   data = [3, 4, 5] * pq.s
-    #    train = SpikeTrain(data, copy=True, t_stop=99.9)
-    #    result = train[1:3]
-    #    result[0] = 99 * pq.s
-    #    assert_neo_object_is_compliant(train)
-    #    self.assertEqual(train[1], 99 * pq.s)
-    #   self.assertEqual(result[0], 99 * pq.s)
-    #    self.assertEqual(data[1], 4 * pq.s)
 
     def test_changing_slice_changes_original_spiketrain(self):
         # If we slice a spiketrain and then change the slice, the
@@ -1875,137 +1848,7 @@ def test__pretty(self):
 
 
 class TestMiscellaneous(unittest.TestCase):
-    # we can't do any of this construction since we lose copy = True
-    """
-    def test__different_dtype_for_t_start_and_array(self):
-        data = np.array([0, 9.9999999], dtype=np.float64) * pq.s
-        data16 = data.astype(np.float16)
-        data32 = data.astype(np.float32)
-        data64 = data.astype(np.float64)
-        t_start = data[0]
-        t_stop = data[1]
-        t_start16 = data[0].astype(dtype=np.float16)
-        t_stop16 = data[1].astype(dtype=np.float16)
-        t_start32 = data[0].astype(dtype=np.float32)
-        t_stop32 = data[1].astype(dtype=np.float32)
-        t_start64 = data[0].astype(dtype=np.float64)
-        t_stop64 = data[1].astype(dtype=np.float64)
-        t_start_custom = 0.0
-        t_stop_custom = 10.0
-        t_start_custom16 = np.array(t_start_custom, dtype=np.float16)
-        t_stop_custom16 = np.array(t_stop_custom, dtype=np.float16)
-        t_start_custom32 = np.array(t_start_custom, dtype=np.float32)
-        t_stop_custom32 = np.array(t_stop_custom, dtype=np.float32)
-        t_start_custom64 = np.array(t_start_custom, dtype=np.float64)
-        t_stop_custom64 = np.array(t_stop_custom, dtype=np.float64)
-
-        # This is OK.
-        train = SpikeTrain(data64, copy=True, t_start=t_start, t_stop=t_stop)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data16, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start16, t_stop=t_stop16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start16, t_stop=t_stop16, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start16, t_stop=t_stop16, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start16, t_stop=t_stop16, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start32, t_stop=t_stop32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start32, t_stop=t_stop32, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start32, t_stop=t_stop32, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start32, t_stop=t_stop32, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start64, t_stop=t_stop64, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start64, t_stop=t_stop64, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom, t_stop=t_stop_custom)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start_custom, t_stop=t_stop_custom, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom16, t_stop=t_stop_custom16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom16, t_stop=t_stop_custom16, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom16, t_stop=t_stop_custom16, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom16, t_stop=t_stop_custom16, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom32, t_stop=t_stop_custom32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom32, t_stop=t_stop_custom32, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom32, t_stop=t_stop_custom32, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom32, t_stop=t_stop_custom32, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom64, t_stop=t_stop_custom64)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom64, t_stop=t_stop_custom64, dtype=np.float16)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom64, t_stop=t_stop_custom64, dtype=np.float32)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start_custom64, t_stop=t_stop_custom64, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        # This use to bug - see ticket #38
-        train = SpikeTrain(data16, copy=True, t_start=t_start, t_stop=t_stop)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data16, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start, t_stop=t_stop)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start, t_stop=t_stop, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-
-        train = SpikeTrain(data32, copy=True, t_start=t_start64, t_stop=t_stop64)
-        assert_neo_object_is_compliant(train)
-        train = SpikeTrain(data32, copy=True, t_start=t_start64, t_stop=t_stop64, dtype=np.float64)
-        assert_neo_object_is_compliant(train)
-"""
+    
     def test_as_array(self):
         data = np.arange(10.0)
         st = SpikeTrain(data, t_stop=10.0, units="ms")