fix some bugs that were found by running iotests

Author: apdavison

neo/core/container.py

@@ -7,6 +7,7 @@
 
 from copy import deepcopy
 from neo.core.baseneo import BaseNeo, _reference_name, _container_name
+from neo.core.objectlist import ObjectList
 from neo.core.spiketrain import SpikeTrain
 from neo.core.spiketrainlist import SpikeTrainList
 
@@ -211,11 +212,14 @@ def _set_object_list(self, name, value):
         Example:
         >>> segment._set_object_list("_analogsignals", [sig1, sig2])
         """
-        assert isinstance(value, list)
-        object_list = getattr(self, name)
-        if len(object_list) > 0:
-            raise Exception("Object list not empty")
-        object_list.extend(value)
+        if isinstance(value, list):
+            object_list = getattr(self, name)
+            object_list.clear()
+            object_list.extend(value)
+        elif isinstance(value, ObjectList):  # from __iadd__
+            setattr(self, name, value)
+        else:
+            TypeError("value must be a list or an ObjectList")
 
     @property
     def _child_objects(self):
@@ -365,11 +369,7 @@ def filter(self, targdict=None, data=True, container=False, recursive=True,
             data = True
             container = True
 
-        if objects == SpikeTrain:
-            children = SpikeTrainList()
-        else:
-            children = []
-
+        children = []
         # get the objects we want
         if data:
             if recursive:
@@ -382,8 +382,12 @@ def filter(self, targdict=None, data=True, container=False, recursive=True,
             else:
                 children.extend(self.container_children)
 
-        return filterdata(children, objects=objects,
-                          targdict=targdict, **kwargs)
+        filtered = filterdata(children, objects=objects,
+                              targdict=targdict, **kwargs)
+        if objects == SpikeTrain:
+            return SpikeTrainList(items=filtered)
+        else:
+            return filtered
 
     def list_children_by_class(self, cls):
         """
@@ -406,7 +410,12 @@ def check_relationships(self, recursive=True):
         """
         parent_name = _reference_name(self.__class__.__name__)
         for child in self._single_children:
-            assert getattr(child, parent_name, None) is self
+            if hasattr(child, "proxy_for"):
+                container = getattr(self, _container_name(child.proxy_for.__name__))
+            else:
+                container = getattr(self, _container_name(child.__class__.__name__))
+            if container.parent is not None:
+                assert getattr(child, parent_name, None) is self
         if recursive:
             for child in self.container_children:
                 child.check_relationships(recursive=True)

neo/core/group.py

@@ -64,7 +64,7 @@ def __init__(self, objects=None, name=None, description=None, file_origin=None,
         # they are contained in.
         self._analogsignals = ObjectList(AnalogSignal)
         self._irregularlysampledsignals = ObjectList(IrregularlySampledSignal)
-        self._spiketrains = SpikeTrainList(parent=self)
+        self._spiketrains = SpikeTrainList()
         self._events = ObjectList(Event)
         self._epochs = ObjectList(Epoch)
         self._channelviews = ObjectList(ChannelView)

neo/core/objectlist.py

@@ -1,14 +1,16 @@
 """
-
-
+This module implements the ObjectList class, which is used to peform type checks
+and handle relationships within the Neo Block-Segment-Data hierarchy.
 """
 
+import sys
 from neo.core.baseneo import BaseNeo
 
 
 class ObjectList:
     """
-    handle relationships within Neo hierarchy
+    This class behaves like a list, but has additional functionality
+    to handle relationships within Neo hierarchy, and perform type checks.
     """
 
     def __init__(self, allowed_contents, parent=None):
@@ -33,6 +35,8 @@ def _handle_append(self, obj):
         # set the child-parent relationship
         if self.parent:
             relationship_name = self.parent.__class__.__name__.lower()
+            if relationship_name == "group":
+                raise Exception("Objects in groups should not link to the group as their parent")
             current_parent = getattr(obj, relationship_name)
             if current_parent != self.parent:
                 setattr(obj, relationship_name, self.parent)
@@ -63,6 +67,7 @@ def __iadd__(self, objects):
         for obj in objects:
             self._handle_append(obj)
         self.contents.extend(objects)
+        return self
 
     def __iter__(self):
         return iter(self.contents)
@@ -73,11 +78,8 @@ def __getitem__(self, i):
     def __len__(self):
         return len(self.contents)
 
-    def __reversed__(self):
-        raise NotImplementedError
-
-    def __setitem__(self, i):
-        raise NotImplementedError
+    def __setitem__(self, key, value):
+        self.contents[key] = value
 
     def append(self, obj):
         self._handle_append(obj)
@@ -89,28 +91,26 @@ def extend(self, objects):
         self.contents.extend(objects)
 
     def clear(self):
-        raise NotImplementedError
-
-    def copy(self):
-         raise NotImplementedError
+        self.contents = []
 
-    def count(self):
-        raise NotImplementedError
+    def count(self, value):
+        return self.contents.count(value)
 
-    def index(self):
-        raise NotImplementedError
+    def index(self, value, start=0, stop=sys.maxsize):
+        return self.contents.index(value, start, stop)
 
-    def insert(self):
-        raise NotImplementedError
+    def insert(self, index, obj):
+        self._handle_append(obj)
+        self.contents[index] = obj
 
-    def pop(self):
-        raise NotImplementedError
+    def pop(self, index=-1):
+        return self.contents.pop(index)
 
-    def remove(self):
-        raise NotImplementedError
+    def remove(self, value):
+        return self.contents.remove(value)
 
     def reverse(self):
-        raise NotImplementedError
+        raise self.contents.reverse()
 
-    def sort(self):
-        raise NotImplementedError
+    def sort(self, *args, key=None, reverse=False):
+        self.contents.sort(*args, key=key, reverse=reverse)

neo/core/spiketrainlist.py

@@ -74,6 +74,7 @@ class SpikeTrainList(ObjectList):
          <SpikeTrain(array([], dtype=float64) * ms, [0.0 ms, 100.0 ms])>]
 
     """
+    allowed_contents = (SpikeTrain,)
 
     def __init__(self, items=None, parent=None):
         """Initialize self"""
@@ -89,8 +90,14 @@ def __init__(self, items=None, parent=None):
         self._channel_id_array = None
         self._all_channel_ids = None
         self._spiketrain_metadata = {}
+        if parent is not None:
+            assert parent.__class__.__name__ == "Segment"
         self.segment = parent
 
+    @property
+    def parent(self):
+        return self.segment
+
     def __iter__(self):
         """Implement iter(self)"""
         if self._items is None:
@@ -120,6 +127,9 @@ def __str__(self):
         else:
             return str(self._items)
 
+    def __repr__(self):
+        return "<SpikeTrainList>"
+
     def __len__(self):
         """Return len(self)"""
         if self._items is None:
@@ -196,7 +206,7 @@ def __iadd__(self, other):
             return self._add_spiketrainlists(other, in_place=True)
         elif other and is_spiketrain_or_proxy(other[0]):
             for obj in other:
-                obj.segment = self.segment
+                self._handle_append(obj)
             if self._items is None:
                 self._spiketrains_from_array()
             self._items.extend(other)
@@ -228,15 +238,15 @@ def append(self, obj):
             raise ValueError("Can only append SpikeTrain objects")
         if self._items is None:
             self._spiketrains_from_array()
-        obj.segment = self.segment
+        self._handle_append(obj)
         self._items.append(obj)
 
     def extend(self, iterable):
         """L.extend(iterable) -> None -- extend list by appending elements from the iterable"""
         if self._items is None:
             self._spiketrains_from_array()
         for obj in iterable:
-            obj.segment = self.segment
+            self._handle_append(obj)
         self._items.extend(iterable)
 
     @classmethod

neo/io/neomatlabio.py

@@ -265,7 +265,7 @@ def create_struct_from_obj(self, ob):
         struct = {}
 
         # relationship
-        for childname in getattr(ob, '_single_child_containers', []):
+        for childname in getattr(ob, '_child_containers', []):
             supported_containers = [subob.__name__.lower() + 's' for subob in
                                     self.supported_objects]
             if childname in supported_containers:
@@ -356,7 +356,7 @@ def create_ob_from_struct(self, struct, classname):
 
         for attrname in struct._fieldnames:
             # check children
-            if attrname in getattr(ob, '_single_child_containers', []):
+            if attrname in getattr(ob, '_child_containers', []):
                 child_struct = getattr(struct, attrname)
                 try:
                     # try must only surround len() or other errors are captured

neo/test/coretest/test_block.py

@@ -18,6 +18,7 @@
     HAVE_IPYTHON = True
 
 from neo.core.block import Block
+from neo.core.segment import Segment
 from neo.core.container import filterdata
 from neo.core import SpikeTrain, AnalogSignal, Event
 from neo.test.tools import (assert_neo_object_is_compliant,
@@ -451,6 +452,20 @@ def test__deepcopy(self):
             for sptr in segment.spiketrains:
                 self.assertEqual(id(sptr.segment), id(segment))
 
+    def test_segment_list(self):
+        blk = Block()
+        assert len(blk.segments) == 0
+        blk.segments.append(Segment())
+        assert len(blk.segments) == 1
+        blk.segments.extend([Segment(), Segment()])
+        assert len(blk.segments) == 3
+        blk.segments = []
+        assert len(blk.segments) == 0
+        blk.segments = [Segment()]
+        assert len(blk.segments) == 1
+        blk.segments += [Segment(), Segment()]
+        assert len(blk.segments) == 3
+
 
 if __name__ == "__main__":
     unittest.main()

neo/test/iotest/test_cedio.py

@@ -1,9 +1,27 @@
 import unittest
+from platform import system
+from sys import maxsize
 
-from neo.io import CedIO
-from neo.test.iotest.common_io_test import BaseTestIO
+try:
+    if system() == 'Windows':
+        if maxsize > 2**32:
+            import sonpy.amd64.sonpy
+        else:
+            import sonpy.win32.sonpy
+    elif system() == 'Darwin':
+        import sonpy.darwin.sonpy
+    elif system() == 'Linux':
+        import sonpy.linux.sonpy
+    from neo.io import CedIO
+except ImportError:
+    HAVE_SONPY = False
+    CedIO = None
+else:
+    HAVE_SONPY = True
 
+from neo.test.iotest.common_io_test import BaseTestIO
 
+@unittest.skipUnless(HAVE_SONPY, "sonpy")
 class TestCedIO(BaseTestIO, unittest.TestCase, ):
     ioclass = CedIO
     entities_to_test = [