Merge pull request #1010 from JuliaSprenger/fix/warnings

fix failing tests and warnings

Author: samuelgarcia

neo/core/spiketrain.py

@@ -126,7 +126,7 @@ def normalize_times_array(times, units=None, dtype=None, copy=True):
     """
     if dtype is None:
         if not hasattr(times, 'dtype'):
-            dtype = np.float
+            dtype = float
     if units is None:
         # No keyword units, so get from `times`
         try:

neo/core/view.py

@@ -55,7 +55,7 @@ def __init__(self, obj, index, name=None, description=None, file_origin=None,
         self.index = np.array(index)
         if len(self.index.shape) != 1:
             raise ValueError("index must be a 1D array")
-        if self.index.dtype == np.bool:  # convert boolean mask to integer index
+        if self.index.dtype == bool:  # convert boolean mask to integer index
             if self.index.size != self.obj.shape[-1]:
                 raise ValueError("index size does not match number of channels in signal")
             self.index, = np.nonzero(self.index)

neo/io/asciisignalio.py

@@ -199,29 +199,29 @@ def read_segment(self, lazy=False):
             if len(sig.shape) == 1:
                 sig = sig[:, np.newaxis]
         elif self.method == 'csv':
-            with open(self.filename, 'rU') as fp:
+            with open(self.filename, newline=None) as fp:
                 tab = [l for l in csv.reader(fp, delimiter=self.delimiter)]
             tab = tab[self.skiprows:]
             sig = np.array(tab, dtype='f')
             if self.usecols is not None:
                 mask = np.array(self.usecols)
                 sig = sig[:, mask]
         elif self.method == 'homemade':
-            fid = open(self.filename, 'rU')
-            for l in range(self.skiprows):
-                fid.readline()
-            tab = []
-            for line in fid.readlines():
-                line = line.replace('\r', '')
-                line = line.replace('\n', '')
-                parts = line.split(self.delimiter)
-                while '' in parts:
-                    parts.remove('')
-                tab.append(parts)
-            sig = np.array(tab, dtype='f')
-            if self.usecols is not None:
-                mask = np.array(self.usecols)
-                sig = sig[:, mask]
+            with open(self.filename, 'r', newline=None) as fid:
+                for _ in range(self.skiprows):
+                    fid.readline()
+                tab = []
+                for line in fid.readlines():
+                    line = line.replace('\r', '')
+                    line = line.replace('\n', '')
+                    parts = line.split(self.delimiter)
+                    while '' in parts:
+                        parts.remove('')
+                    tab.append(parts)
+                sig = np.array(tab, dtype='f')
+                if self.usecols is not None:
+                    mask = np.array(self.usecols)
+                    sig = sig[:, mask]
         else:
             sig = self.method(self.filename, self.usecols)
             if not isinstance(sig, np.ndarray):

neo/io/asciispiketrainio.py

@@ -91,22 +91,21 @@ def read_segment(self,
 
         seg = Segment(file_origin=os.path.basename(self.filename))
 
-        f = open(self.filename, 'Ur')
-        for i, line in enumerate(f):
-            alldata = line[:-1].split(delimiter)
-            if alldata[-1] == '':
-                alldata = alldata[:-1]
-            if alldata[0] == '':
-                alldata = alldata[1:]
+        with open(self.filename, 'r', newline=None) as f:
+            for i, line in enumerate(f):
+                alldata = line[:-1].split(delimiter)
+                if alldata[-1] == '':
+                    alldata = alldata[:-1]
+                if alldata[0] == '':
+                    alldata = alldata[1:]
 
-            spike_times = np.array(alldata).astype('f')
-            t_stop = spike_times.max() * unit
+                spike_times = np.array(alldata).astype('f')
+                t_stop = spike_times.max() * unit
 
-            sptr = SpikeTrain(spike_times * unit, t_start=t_start, t_stop=t_stop)
+                sptr = SpikeTrain(spike_times * unit, t_start=t_start, t_stop=t_stop)
 
-            sptr.annotate(channel_index=i)
-            seg.spiketrains.append(sptr)
-        f.close()
+                sptr.annotate(channel_index=i)
+                seg.spiketrains.append(sptr)
 
         seg.create_many_to_one_relationship()
         return seg

neo/io/brainwaredamio.py

@@ -193,7 +193,7 @@ def _read_segment(self, fobject):
             name = np.fromfile(fobject, dtype=np.uint8, count=numchars)
 
             # exclude invalid characters
-            name = str(name[name >= 32].view('c').tostring())
+            name = str(name[name >= 32].view('c').tobytes())
 
             # add the name to the list of names
             paramnames.append(name)

neo/io/elphyio.py

@@ -73,7 +73,7 @@
 
 # python commons:
 from datetime import datetime
-from fractions import gcd
+from math import gcd
 from os import path
 import re
 import struct

neo/io/tiffio.py

@@ -102,14 +102,15 @@ def natural_sort(l):
         file_name_list = natural_sort(file_name_list)
         list_data_image = []
         for file_name in file_name_list:
-            list_data_image.append(
-                np.array(Image.open(self.filename + "/" + file_name), dtype=np.float32))
+            data = np.array(Image.open(self.filename + "/" + file_name)).astype(np.float32)
+            list_data_image.append(data)
         list_data_image = np.array(list_data_image)
         if len(list_data_image.shape) == 4:
             list_data_image = []
             for file_name in file_name_list:
-                list_data_image.append(
-                    np.array(Image.open(self.filename + "/" + file_name).convert('L'), dtype=np.float32))
+                image = Image.open(self.filename + "/" + file_name).convert('L')
+                data = np.array(image).astype(np.float32)
+                list_data_image.append(data)
 
         print("read block")
         image_sequence = ImageSequence(np.stack(list_data_image),

neo/rawio/bci2000rawio.py

@@ -175,7 +175,7 @@ def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_s
         # label must a dtype ='U'
         ts, dur, labels = self._event_arrays_list[event_channel_index]
         # seg_t_start = self._segment_t_start(block_index, seg_index)
-        keep = np.ones(ts.shape, dtype=np.bool)
+        keep = np.ones(ts.shape, dtype=bool)
         if t_start is not None:
             keep = np.logical_and(keep, ts >= t_start)
         if t_stop is not None:

neo/rawio/micromedrawio.py

@@ -6,8 +6,6 @@
 
 Author: Samuel Garcia
 """
-# from __future__ import unicode_literals is not compatible with numpy.dtype both py2 py3
-
 
 from .baserawio import (BaseRawIO, _signal_channel_dtype, _signal_stream_dtype,
                 _spike_channel_dtype, _event_channel_dtype)

neo/test/coretest/test_base.py

@@ -769,7 +769,7 @@ def setUp(self):
 
     def test_numpy_array_int(self):
         '''test to make sure int type numpy arrays are accepted'''
-        value = np.array([1, 2, 3, 4, 5], dtype=np.int)
+        value = np.array([1, 2, 3, 4, 5], dtype=int)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -858,13 +858,6 @@ def test_numpy_array_float(self):
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
 
-    def test_numpy_array_floating(self):
-        '''test to make sure floating type numpy arrays are accepted'''
-        value = np.array([1, 2, 3, 4, 5], dtype=np.floating)
-        self.base.annotate(data=value)
-        result = {'data': value}
-        self.assertDictEqual(result, self.base.annotations)
-
     def test_numpy_array_double(self):
         '''test to make sure double type numpy arrays are accepted'''
         value = np.array([1, 2, 3, 4, 5], dtype=np.double)
@@ -903,7 +896,7 @@ def test_numpy_array_float128(self):
 
     def test_numpy_array_complex(self):
         '''test to make sure complex type numpy arrays are accepted'''
-        value = np.array([1, 2, 3, 4, 5], dtype=np.complex)
+        value = np.array([1, 2, 3, 4, 5], complex)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -933,14 +926,14 @@ def test_numpy_scalar_complex256(self):
 
     def test_numpy_array_bool(self):
         '''test to make sure bool type numpy arrays are accepted'''
-        value = np.array([1, 2, 3, 4, 5], dtype=np.bool)
+        value = np.array([1, 2, 3, 4, 5], dtype=bool)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
 
     def test_numpy_array_str(self):
         '''test to make sure str type numpy arrays are accepted'''
-        value = np.array([1, 2, 3, 4, 5], dtype=np.str)
+        value = np.array([1, 2, 3, 4, 5], dtype=str)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -964,7 +957,7 @@ def setUp(self):
 
     def test_numpy_scalar_int(self):
         '''test to make sure int type numpy scalars are accepted'''
-        value = np.array(99, dtype=np.int)
+        value = np.array(99, dtype=int)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1053,13 +1046,6 @@ def test_numpy_scalar_float(self):
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
 
-    def test_numpy_scalar_floating(self):
-        '''test to make sure floating type numpy scalars are accepted'''
-        value = np.array(99, dtype=np.floating)
-        self.base.annotate(data=value)
-        result = {'data': value}
-        self.assertDictEqual(result, self.base.annotations)
-
     def test_numpy_scalar_double(self):
         '''test to make sure double type numpy scalars are accepted'''
         value = np.array(99, dtype=np.double)
@@ -1098,7 +1084,7 @@ def test_numpy_scalar_float128(self):
 
     def test_numpy_scalar_complex(self):
         '''test to make sure complex type numpy scalars are accepted'''
-        value = np.array(99, dtype=np.complex)
+        value = np.array(99, dtype=complex)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1127,14 +1113,14 @@ def test_numpy_scalar_complex256(self):
 
     def test_numpy_scalar_bool(self):
         '''test to make sure bool type numpy scalars are rejected'''
-        value = np.array(99, dtype=np.bool)
+        value = np.array(99, dtype=bool)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
 
     def test_numpy_array_str(self):
         '''test to make sure str type numpy scalars are accepted'''
-        value = np.array(99, dtype=np.str)
+        value = np.array(99, dtype=str)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1159,7 +1145,7 @@ def setUp(self):
 
     def test_quantities_array_int(self):
         '''test to make sure int type quantites arrays are accepted'''
-        value = pq.Quantity([1, 2, 3, 4, 5], dtype=np.int, units=pq.s)
+        value = pq.Quantity([1, 2, 3, 4, 5], dtype=int, units=pq.s)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1180,7 +1166,7 @@ def test_quantities_array_float(self):
 
     def test_quantities_array_str(self):
         '''test to make sure str type quantites arrays are accepted'''
-        value = pq.Quantity([1, 2, 3, 4, 5], dtype=np.str, units=pq.meter)
+        value = pq.Quantity([1, 2, 3, 4, 5], dtype=str, units=pq.meter)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1198,7 +1184,7 @@ def setUp(self):
 
     def test_quantities_scalar_int(self):
         '''test to make sure int type quantites scalars are accepted'''
-        value = pq.Quantity(99, dtype=np.int, units=pq.s)
+        value = pq.Quantity(99, dtype=int, units=pq.s)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)
@@ -1219,7 +1205,7 @@ def test_quantities_scalar_float(self):
 
     def test_quantities_scalar_str(self):
         '''test to make sure str type quantites scalars are accepted'''
-        value = pq.Quantity(99, dtype=np.str, units=pq.meter)
+        value = pq.Quantity(99, dtype=str, units=pq.meter)
         self.base.annotate(data=value)
         result = {'data': value}
         self.assertDictEqual(result, self.base.annotations)