Merge branch 'master' into small_changes_to_intan

Author: h-mayorquin

.gitignore

@@ -58,6 +58,7 @@ cover
 .directory
 .gdb_history
 .DS_Store?
+.DS_Store
 ehthumbs.db
 Icon?
 Thumbs.db

neo/core/analogsignal.py

@@ -294,13 +294,7 @@ def __repr__(self):
         """
         Returns a string representing the :class:`AnalogSignal`.
         """
-        return "<%s(%s, [%s, %s], sampling rate: %s)>" % (
-            self.__class__.__name__,
-            super().__repr__(),
-            self.t_start,
-            self.t_stop,
-            self.sampling_rate,
-        )
+        return f"<{self.__class__.__name__}({super().__repr__()}, [{self.t_start}, {self.t_stop}], sampling rate: {self.sampling_rate})>"
 
     def __getitem__(self, i):
         """
@@ -324,7 +318,7 @@ def __getitem__(self, i):
                     raise NotImplementedError("Arrays not yet supported")  # in the general case, would need to return
                     #  IrregularlySampledSignal(Array)
                 else:
-                    raise TypeError("%s not supported" % type(j))
+                    raise TypeError(f"{type(j)} not supported")
                 if isinstance(k, (int, np.integer)):
                     obj = obj.reshape(-1, 1)
                 elif k is None:
@@ -473,7 +467,7 @@ def _check_consistency(self, other):
         if isinstance(other, AnalogSignal):
             for attr in "t_start", "sampling_rate":
                 if getattr(self, attr) != getattr(other, attr):
-                    raise ValueError("Inconsistent values of %s" % attr)  # how to handle name and annotations?
+                    raise ValueError(f"Inconsistent values of {attr}")  # how to handle name and annotations?
 
     def _repr_pretty_(self, pp, cycle):
         """

neo/core/basesignal.py

@@ -237,7 +237,7 @@ def merge(self, other):
         for attr in self._necessary_attrs:
             if "signal" != attr[0]:
                 if getattr(self, attr[0], None) != getattr(other, attr[0], None):
-                    raise MergeError("Cannot merge these two signals as the %s differ." % attr[0])
+                    raise MergeError(f"Cannot merge these two signals as the {attr[0]} differ.")
 
         if self.segment != other.segment:
             raise MergeError("Cannot merge these two signals as they belong to different segments.")

neo/core/container.py

@@ -577,6 +577,6 @@ def _repr_pretty_(self, pp, cycle):
             pp.text(f"# {container} (N={objs})")
             for i, obj in enumerate(objs):
                 pp.breakable()
-                pp.text("%s: " % i)
+                pp.text(f"{i}: ")
                 with pp.indent(3):
                     pp.pretty(obj)

neo/core/dataobject.py

@@ -400,7 +400,7 @@ def __setitem__(self, key, value):
     def update(self, *args, **kwargs):
         if args:
             if len(args) > 1:
-                raise TypeError("update expected at most 1 arguments, " "got %d" % len(args))
+                raise TypeError("update expected at most 1 arguments, " f"got {len(args)}")
             other = dict(args[0])
             for key in other:
                 self[key] = other[key]

neo/core/epoch.py

@@ -155,7 +155,7 @@ def __new__(
         # this approach is much faster than comparing the
         # reference dimensionality
         if len(dim) != 1 or list(dim.values())[0] != 1 or not isinstance(list(dim.keys())[0], pq.UnitTime):
-            ValueError("Unit %s has dimensions %s, not [time]" % (units, dim.simplified))
+            ValueError(f"Unit {units} has dimensions {dim.simplified}, not [time]")
 
         obj = pq.Quantity.__new__(cls, times, units=dim)
         obj._labels = labels
@@ -227,8 +227,7 @@ def __repr__(self):
         """
 
         objs = [
-            "%s@%s for %s" % (label, str(time), str(dur))
-            for label, time, dur in zip(self.labels, self.times, self.durations)
+            f"{label}@{str(time)} for {str(dur)}" for label, time, dur in zip(self.labels, self.times, self.durations)
         ]
         return "<Epoch: %s>" % ", ".join(objs)
 

neo/core/event.py

@@ -194,7 +194,7 @@ def __repr__(self):
         Returns a string representing the :class:`Event`.
         """
 
-        objs = ["%s@%s" % (label, str(time)) for label, time in zip(self.labels, self.times)]
+        objs = [f"{label}@{str(time)}" for label, time in zip(self.labels, self.times)]
         return "<Event: %s>" % ", ".join(objs)
 
     def _repr_pretty_(self, pp, cycle):

neo/core/imagesequence.py

@@ -227,7 +227,7 @@ def _check_consistency(self, other):
         if isinstance(other, ImageSequence):
             for attr in ("sampling_rate", "spatial_scale", "t_start"):
                 if getattr(self, attr) != getattr(other, attr):
-                    raise ValueError("Inconsistent values of %s" % attr)
+                    raise ValueError(f"Inconsistent values of {attr}")
 
     # t_start attribute is handled as a property so type checking can be done
     @property

neo/core/irregularlysampledsignal.py

@@ -272,7 +272,7 @@ def __getitem__(self, i):
                 elif isinstance(j, np.ndarray):
                     raise NotImplementedError("Arrays not yet supported")
                 else:
-                    raise TypeError("%s not supported" % type(j))
+                    raise TypeError(f"{type(j)} not supported")
                 if isinstance(k, (int, np.integer)):
                     obj = obj.reshape(-1, 1)
                 obj.array_annotations = deepcopy(self.array_annotations_at_index(k))
@@ -600,7 +600,7 @@ def concatenate(self, other, allow_overlap=False):
         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 concatenate these two signals as the %s differ." % attr[0])
+                    raise MergeError(f"Cannot concatenate these two signals as the {attr[0]} differ.")
 
         if hasattr(self, "lazy_shape"):
             if hasattr(other, "lazy_shape"):

neo/core/objectlist.py

@@ -21,7 +21,7 @@ def __init__(self, allowed_contents, parent=None):
             for item in allowed_contents:
                 assert issubclass(item, BaseNeo)
             self.allowed_contents = tuple(allowed_contents)
-        self.contents = []
+        self._items = []
         self.parent = parent
 
     def _handle_append(self, obj):
@@ -32,6 +32,10 @@ def _handle_append(self, obj):
             )
         ):
             raise TypeError(f"Object is a {type(obj)}. It should be one of {self.allowed_contents}.")
+
+        if self._contains(obj):
+            raise ValueError("Cannot add this object because it is already contained within the list")
+
         # set the child-parent relationship
         if self.parent:
             relationship_name = self.parent.__class__.__name__.lower()
@@ -42,76 +46,83 @@ def _handle_append(self, obj):
                 # use weakref here? - see https://github.com/NeuralEnsemble/python-neo/issues/684
                 setattr(obj, relationship_name, self.parent)
 
+    def _contains(self, obj):
+        if self._items is None:
+            obj_ids = []
+        else:
+            obj_ids = [id(item) for item in self._items]
+        return id(obj) in obj_ids
+
     def __str__(self):
-        return str(self.contents)
+        return str(self._items)
 
     def __repr__(self):
-        return repr(self.contents)
+        return repr(self._items)
 
     def __add__(self, objects):
         # todo: decision: return a list, or a new DataObjectList?
         if isinstance(objects, ObjectList):
-            return self.contents + objects.contents
+            return self._items + objects._items
         else:
-            return self.contents + objects
+            return self._items + objects
 
     def __radd__(self, objects):
         if isinstance(objects, ObjectList):
-            return objects.contents + self.contents
+            return objects._items + self._items
         else:
-            return objects + self.contents
+            return objects + self._items
 
     def __contains__(self, key):
-        return key in self.contents
+        return key in self._items
 
     def __iadd__(self, objects):
         for obj in objects:
             self._handle_append(obj)
-        self.contents.extend(objects)
+        self._items.extend(objects)
         return self
 
     def __iter__(self):
-        return iter(self.contents)
+        return iter(self._items)
 
     def __getitem__(self, i):
-        return self.contents[i]
+        return self._items[i]
 
     def __len__(self):
-        return len(self.contents)
+        return len(self._items)
 
     def __setitem__(self, key, value):
-        self.contents[key] = value
+        self._items[key] = value
 
     def append(self, obj):
         self._handle_append(obj)
-        self.contents.append(obj)
+        self._items.append(obj)
 
     def extend(self, objects):
         for obj in objects:
             self._handle_append(obj)
-        self.contents.extend(objects)
+        self._items.extend(objects)
 
     def clear(self):
-        self.contents = []
+        self._items = []
 
     def count(self, value):
-        return self.contents.count(value)
+        return self._items.count(value)
 
     def index(self, value, start=0, stop=sys.maxsize):
-        return self.contents.index(value, start, stop)
+        return self._items.index(value, start, stop)
 
     def insert(self, index, obj):
         self._handle_append(obj)
-        self.contents.insert(index, obj)
+        self._items.insert(index, obj)
 
     def pop(self, index=-1):
-        return self.contents.pop(index)
+        return self._items.pop(index)
 
     def remove(self, value):
-        return self.contents.remove(value)
+        return self._items.remove(value)
 
     def reverse(self):
-        raise self.contents.reverse()
+        raise self._items.reverse()
 
     def sort(self, *args, key=None, reverse=False):
-        self.contents.sort(*args, key=key, reverse=reverse)
+        self._items.sort(*args, key=key, reverse=reverse)