Rename 'patch' to 'concatenate'

Author: JuliaSprenger

neo/core/analogsignal.py

@@ -660,7 +660,7 @@ def rectify(self, **kwargs):
 
         return rectified_signal
 
-    def patch(self, other, overwrite=True, padding=False):
+    def concatenate(self, other, overwrite=True, padding=False):
         '''
         Patch another signal to this one.
 
@@ -670,7 +670,7 @@ def patch(self, other, overwrite=True, padding=False):
         have to overlap by one sample in time, i.e.
         self.t_stop == other.t_start
         Note: Only common array annotations common to
-        both signals are attached to the patched signal.
+        both signals are attached to the concatenated signal.
 
         If the attributes of the two signal are not
         compatible, an Exception is raised.
@@ -727,16 +727,16 @@ def patch(self, other, overwrite=True, padding=False):
                 if getattr(self, attr[0], None) != getattr(other, attr[0], None):
                     # if attr[0] in ['t_start','t_stop']:
                     #     continue
-                    raise MergeError("Cannot patch these two signals as the %s differ." % attr[0])
+                    raise MergeError("Cannot concatenate these two signals as the %s differ." % attr[0])
 
         if hasattr(self, "lazy_shape"):
             if hasattr(other, "lazy_shape"):
                 if self.lazy_shape[-1] != other.lazy_shape[-1]:
-                    raise MergeError("Cannot patch signals as they contain"
+                    raise MergeError("Cannot concatenate signals as they contain"
                                      " different numbers of traces.")
                 merged_lazy_shape = (self.lazy_shape[0] + other.lazy_shape[0], self.lazy_shape[-1])
             else:
-                raise MergeError("Cannot patch a lazy object with a real object.")
+                raise MergeError("Cannot concatenate a lazy object with a real object.")
 
         #  in case of non-overlapping signals consider padding
         if signal2.t_start > signal1.t_stop + signal1.sampling_period:
@@ -764,7 +764,7 @@ def patch(self, other, overwrite=True, padding=False):
         #  in case of overlapping signals slice according to overwrite parameter
         elif signal2.t_start < signal1.t_stop + signal1.sampling_period:
             n_samples = int(((signal1.t_stop - signal2.t_start)*signal1.sampling_rate).simplified)
-            logger.warning('Overwriting {} samples while patching signals.'.format(n_samples))
+            logger.warning('Overwriting {} samples while concatenating signals.'.format(n_samples))
             if not overwrite:  # removing samples second signal
                 slice_t_start = signal1.t_stop + signal1.sampling_period
                 signal2 = signal2.time_slice(slice_t_start, None)
@@ -773,7 +773,7 @@ def patch(self, other, overwrite=True, padding=False):
                 signal1 = signal1.time_slice(None, slice_t_stop)
         else:
             assert signal2.t_start == signal1.t_stop + signal1.sampling_period, \
-                "Cannot patch signals with non-overlapping times"
+                "Cannot concatenate signals with non-overlapping times"
 
         stack = np.vstack((signal1.magnitude, signal2.magnitude))
 

neo/core/basesignal.py

@@ -293,15 +293,15 @@ def time_slice(self, t_start, t_stop):
         NotImplementedError('Needs to be implemented for subclasses.')
 
 
-    def patch(self, other):
+    def concatenate(self, other):
         '''
         Patch another signal to this one.
 
         The signal objects are concatenated vertically
         (row-wise, :func:`np.vstack`). Patching can be
         used to combine signals across segments.
         Note: Only array annotations common to
-        both signals are attached to the patched signal.
+        both signals are attached to the concatenated signal.
 
         If the attributes of the two signal are not
         compatible, an Exception is raised.

neo/core/irregularlysampledsignal.py

@@ -515,15 +515,15 @@ def merge(self, other):
 
         return signal
 
-    def patch(self, other):
+    def concatenate(self, other):
         '''
         Patch another signal to this one.
 
         The signal objects are concatenated vertically
         (row-wise, :func:`np.vstack`). Patching can be
         used to combine signals across segments.
         Note: Only array annotations common to
-        both signals are attached to the patched signal.
+        both signals are attached to the concatenated signal.
 
         If the attributes of the two signal are not
         compatible, an Exception is raised.
@@ -550,16 +550,16 @@ def patch(self, other):
         for attr in self._necessary_attrs:
             if not (attr[0] in ['signal', 'times', 't_start', 't_stop', 'times']):
                 if getattr(self, attr[0], None) != getattr(other, attr[0], None):
-                    raise MergeError("Cannot patch these two signals as the %s differ." % attr[0])
+                    raise MergeError("Cannot concatenate these two signals as the %s differ." % attr[0])
 
         if hasattr(self, "lazy_shape"):
             if hasattr(other, "lazy_shape"):
                 if self.lazy_shape[-1] != other.lazy_shape[-1]:
-                    raise MergeError("Cannot patch signals as they contain"
+                    raise MergeError("Cannot concatenate signals as they contain"
                                      " different numbers of traces.")
                 merged_lazy_shape = (self.lazy_shape[0] + other.lazy_shape[0], self.lazy_shape[-1])
             else:
-                raise MergeError("Cannot patch a lazy object with a real object.")
+                raise MergeError("Cannot concatenate a lazy object with a real object.")
         if other.units != self.units:
             other = other.rescale(self.units)
 

neo/test/coretest/test_analogsignal.py

@@ -1563,104 +1563,104 @@ def test__merge(self):
         assert_arrays_equal(mergeddata23, targdata23)
         assert_arrays_equal(mergeddata24, targdata24)
 
-    def test_patch_simple(self):
+    def test_concatenate_simple(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + signal1.sampling_period)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         assert_array_equal(np.arange(7).reshape((-1, 1)), result.magnitude)
         for attr in signal1._necessary_attrs:
             self.assertEqual(getattr(signal1, attr[0], None), getattr(result, attr[0], None))
 
-    def test_patch_inverse_signals(self):
+    def test_concatenate_inverse_signals(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + signal1.sampling_period)
 
-        result = signal2.patch(signal1)
+        result = signal2.concatenate(signal1)
         assert_array_equal(np.arange(7).reshape((-1, 1)), result.magnitude)
         for attr in signal1._necessary_attrs:
             self.assertEqual(getattr(signal1, attr[0], None), getattr(result, attr[0], None))
 
-    def test_patch_no_overlap(self):
+    def test_concatenate_no_overlap(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=10*pq.s + signal1.sampling_period)
 
         with self.assertRaises(MergeError):
-            signal1.patch(signal2)
+            signal1.concatenate(signal2)
 
-    def test_patch_multi_trace(self):
+    def test_concatenate_multi_trace(self):
         data1 = np.arange(4).reshape(2,2)
         data2 = np.arange(4,8).reshape(2,2)
         signal1 = AnalogSignal(data1*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal(data2*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + signal1.sampling_period)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         data_expected = np.array([[0,1],[2,3],[4,5],[6,7]])
         assert_array_equal(data_expected, result.magnitude)
         for attr in signal1._necessary_attrs:
             self.assertEqual(getattr(signal1, attr[0], None), getattr(result, attr[0], None))
 
-    def test_patch_overwrite_true(self):
+    def test_concatenate_overwrite_true(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop)
 
-        result = signal1.patch(signal2, overwrite=True)
+        result = signal1.concatenate(signal2, overwrite=True)
         assert_array_equal(np.array([0,1,2,4,5,6]).reshape((-1, 1)), result.magnitude)
 
-    def test_patch_overwrite_false(self):
+    def test_concatenate_overwrite_false(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop)
 
-        result = signal1.patch(signal2, overwrite=False)
+        result = signal1.concatenate(signal2, overwrite=False)
         assert_array_equal(np.array([0,1,2,3,5,6]).reshape((-1, 1)), result.magnitude)
 
-    def test_patch_padding_False(self):
+    def test_concatenate_padding_False(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=10*pq.s)
 
         with self.assertRaises(MergeError):
-            result = signal1.patch(signal2, overwrite=False, padding=False)
+            result = signal1.concatenate(signal2, overwrite=False, padding=False)
 
-    def test_patch_padding_True(self):
+    def test_concatenate_padding_True(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + 3 * signal1.sampling_period)
 
-        result = signal1.patch(signal2, overwrite=False, padding=True)
+        result = signal1.concatenate(signal2, overwrite=False, padding=True)
         assert_array_equal(np.array([0,1,2,3,np.NaN,np.NaN,np.NaN,4,5,6]).reshape((-1, 1)),
                            result.magnitude)
 
-    def test_patch_padding_quantity(self):
+    def test_concatenate_padding_quantity(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + 3 * signal1.sampling_period)
 
-        result = signal1.patch(signal2, overwrite=False, padding=-1*pq.mV)
+        result = signal1.concatenate(signal2, overwrite=False, padding=-1 * pq.mV)
         assert_array_equal(np.array([0,1,2,3,-1e-3,-1e-3,-1e-3,4,5,6]).reshape((-1, 1)),
                            result.magnitude)
 
-    def test_patch_padding_invalid(self):
+    def test_concatenate_padding_invalid(self):
         signal1 = AnalogSignal([0,1,2,3]*pq.V, sampling_rate=1*pq.Hz)
         signal2 = AnalogSignal([4,5,6]*pq.V, sampling_rate=1*pq.Hz,
                                t_start=signal1.t_stop + 3 * signal1.sampling_period)
 
         with self.assertRaises(ValueError):
-            result = signal1.patch(signal2, overwrite=False, padding=1)
+            result = signal1.concatenate(signal2, overwrite=False, padding=1)
         with self.assertRaises(ValueError):
-            result = signal1.patch(signal2, overwrite=False, padding=[1])
+            result = signal1.concatenate(signal2, overwrite=False, padding=[1])
         with self.assertRaises(ValueError):
-            result = signal1.patch(signal2, overwrite=False, padding='a')
+            result = signal1.concatenate(signal2, overwrite=False, padding='a')
         with self.assertRaises(ValueError):
-            result = signal1.patch(signal2, overwrite=False, padding=np.array([1,2,3]))
+            result = signal1.concatenate(signal2, overwrite=False, padding=np.array([1, 2, 3]))
 
-    def test_patch_array_annotations(self):
+    def test_concatenate_array_annotations(self):
         array_anno1 = {'first': ['a','b']}
         array_anno2 = {'first': ['a','b'],
                        'second': ['c','d']}
@@ -1672,13 +1672,13 @@ def test_patch_array_annotations(self):
                                t_start=signal1.t_stop + signal1.sampling_period,
                                array_annotations=array_anno2)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         assert_array_equal(array_anno1.keys(), result.array_annotations.keys())
 
         for k in array_anno1.keys():
             assert_array_equal(np.asarray(array_anno1[k]), result.array_annotations[k])
 
-    def test_patch_complex(self):
+    def test_concatenate_complex(self):
         signal1 = self.signal1
         assert_neo_object_is_compliant(self.signal1)
 
@@ -1687,13 +1687,13 @@ def test_patch_complex(self):
                                array_annotations=self.arr_ann1,
                                t_start=signal1.t_stop + signal1.sampling_period)
 
-        patched12 = self.signal1.patch(signal2)
+        concatenated12 = self.signal1.concatenate(signal2)
 
         for attr in signal1._necessary_attrs:
-            self.assertEqual(getattr(signal1, attr[0], None), getattr(patched12, attr[0], None))
+            self.assertEqual(getattr(signal1, attr[0], None), getattr(concatenated12, attr[0], None))
 
         assert_array_equal(np.vstack((signal1.magnitude, signal2.magnitude)),
-                           patched12.magnitude)
+                           concatenated12.magnitude)
 
 class TestAnalogSignalFunctions(unittest.TestCase):
     def test__pickle_1d(self):

neo/test/coretest/test_irregularysampledsignal.py

@@ -946,39 +946,39 @@ def test__merge(self):
         self.assertRaises(MergeError, signal1.merge, signal3)
 
 
-    def test_patch_simple(self):
+    def test_concatenate_simple(self):
         signal1 = IrregularlySampledSignal(signal=[0,1,2,3]*pq.s, times=[1,10,11,20]*pq.s)
         signal2 = IrregularlySampledSignal(signal=[4,5,6]*pq.s, times=[15,16,21]*pq.s)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         assert_array_equal(np.array([0,1,2,4,5,3,6]).reshape((-1, 1)), result.magnitude)
         assert_array_equal(np.array([1,10,11,15,16,20,21]), result.times)
         for attr in signal1._necessary_attrs:
             if attr[0] == 'times':
                 continue
             self.assertEqual(getattr(signal1, attr[0], None), getattr(result, attr[0], None))
 
-    def test_patch_no_overlap(self):
+    def test_concatenate_no_overlap(self):
         signal1 = IrregularlySampledSignal(signal=[0,1,2,3]*pq.s, times=range(4)*pq.s)
         signal2 = IrregularlySampledSignal(signal=[4,5,6]*pq.s, times=range(4,7)*pq.s)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         assert_array_equal(np.arange(7).reshape((-1, 1)), result.magnitude)
         assert_array_equal(np.arange(7), result.times)
 
-    def test_patch_multi_trace(self):
+    def test_concatenate_multi_trace(self):
         data1 = np.arange(4).reshape(2,2)
         data2 = np.arange(4,8).reshape(2,2)
         n1 = len(data1)
         n2 = len(data2)
         signal1 = IrregularlySampledSignal(signal=data1*pq.s, times=range(n1)*pq.s)
         signal2 = IrregularlySampledSignal(signal=data2*pq.s, times=range(n1, n1+n2)*pq.s)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         data_expected = np.array([[0,1],[2,3],[4,5],[6,7]])
         assert_array_equal(data_expected, result.magnitude)
 
-    def test_patch_array_annotations(self):
+    def test_concatenate_array_annotations(self):
         array_anno1 = {'first': ['a','b']}
         array_anno2 = {'first': ['a','b'],
                        'second': ['c','d']}
@@ -991,7 +991,7 @@ def test_patch_array_annotations(self):
         signal2 = IrregularlySampledSignal(signal=data2*pq.s, times=range(n1, n1+n2)*pq.s,
                                            array_annotations=array_anno2)
 
-        result = signal1.patch(signal2)
+        result = signal1.concatenate(signal2)
         assert_array_equal(array_anno1.keys(), result.array_annotations.keys())
 
         for k in array_anno1.keys():