Ensure cubelists only contain cubes

docs/iris/src/whatsnew/contributions_2.3.0/bugfix_2018-Dec-07_only_cubes_in_cubelists.txt

@@ -0,0 +1,3 @@
+* The `append`, `extend` and `insert` methods of :class:`iris.cube.CubeList`
+now perform a check to ensure that only :class:`iris.cube.Cube` instances are
+added.

lib/iris/cube.py

@@ -1,4 +1,4 @@
-# (C) British Crown Copyright 2010 - 2018, Met Office
+# (C) British Crown Copyright 2010 - 2019, Met Office
 #
 # This file is part of Iris.
 #
@@ -196,10 +196,7 @@ def __new__(cls, list_of_cubes=None):
         """Given a :class:`list` of cubes, return a CubeList instance."""
         cube_list = list.__new__(cls, list_of_cubes)
 
-        # Check that all items in the incoming list are cubes. Note that this
-        # checking does not guarantee that a CubeList instance *always* has
-        # just cubes in its list as the append & __getitem__ methods have not
-        # been overridden.
+        # Check that all items in the incoming list are cubes.
         if not all([isinstance(cube, Cube) for cube in cube_list]):
             raise ValueError('All items in list_of_cubes must be Cube '
                              'instances.')
@@ -219,7 +216,30 @@ def __repr__(self):
         """Runs repr on every cube."""
         return '[%s]' % ',\n'.join([repr(cube) for cube in self])
 
+    def _check_iscube(self, obj):
+        """
+        Raise a warning if obj is not a cube.
+        """
+        if not isinstance(obj, Cube):
+            msg = ('Cubelist now contains object of type {}.  This may '
+                   'adversely affect subsequent operations.')
+            warnings.warn(msg.format(type(obj)))
+
+    def _check_cube_sequence(self, sequence):
+        """
+        Raise one or more warnings if sequence contains elements that are not
+        Cubes.  Skip this if the sequence is a CubeList, as we can assume it
+        was already checked.
+        """
+        if (isinstance(sequence, collections.Iterable) and
+            not isinstance(sequence, Cube) and
+            not isinstance(sequence, CubeList)):
+            for obj in sequence:
+                self._check_iscube(obj)
+
+
     # TODO #370 Which operators need overloads?
+
     def __add__(self, other):
         return CubeList(list.__add__(self, other))
 
@@ -241,6 +261,56 @@ def __getslice__(self, start, stop):
         result = CubeList(result)
         return result
 
+    def __iadd__(self, other_cubes):
+        """
+        Add a sequence of cubes to the cubelist in place.
+        """
+        self._check_cube_sequence(other_cubes)
+        super(CubeList, self).__iadd__(other_cubes)
+
+    def __setitem__(self, key, cube_or_sequence):
+        """Set self[key] to cube or sequence of cubes"""
+        if isinstance(key, int):
+            # should have single cube.
+            self._check_iscube(cube_or_sequence)
+        else:
+            # key is a slice (or exception will come from list method).
+            self._check_cube_sequence(cube_or_sequence)
+
+        super(CubeList, self).__setitem__(key, cube_or_sequence)
+
+    #  __setslice__ is only required for python2.7 compatibility.
+    def __setslice__(self, *args):
+        cubes = args[-1]
+        self._check_cube_sequence(cubes)
+        super(CubeList, self).__setslice__(*args)
+
+    def append(self, cube):
+        """
+        Append a cube.
+        """
+        self._check_iscube(cube)
+        super(CubeList, self).append(cube)
+
+    def extend(self, other_cubes):
+        """
+        Extend cubelist by appending the cubes contained in other_cubes.
+
+        Args:
+
+        * other_cubes:
+           A cubelist or other sequence of cubes.
+        """
+        self._check_cube_sequence(other_cubes)
+        super(CubeList, self).extend(other_cubes)
+
+    def insert(self, index, cube):
+        """
+        Insert a cube before index.
+        """
+        self._check_iscube(cube)
+        super(CubeList, self).insert(index, cube)
+
     def xml(self, checksum=False, order=True, byteorder=True):
         """Return a string of the XML that this list of cubes represents."""
         doc = Document()

lib/iris/tests/unit/cube/test_CubeList.py

@@ -1,4 +1,4 @@
-# (C) British Crown Copyright 2014 - 2018, Met Office
+# (C) British Crown Copyright 2014 - 2019, Met Office
 #
 # This file is part of Iris.
 #
@@ -24,6 +24,8 @@
 import iris.tests as tests
 import iris.tests.stock
 
+import copy
+
 from cf_units import Unit
 import numpy as np
 
@@ -34,6 +36,25 @@
 from iris.fileformats.pp import STASH
 from iris.tests import mock
 
+NOT_CUBE_MSG = 'Cubelist now contains object of type '
+
+
+class Test_append(tests.IrisTest):
+    def setUp(self):
+        self.cubelist = iris.cube.CubeList()
+        self.cube1 = iris.cube.Cube(1, long_name='foo')
+        self.cube2 = iris.cube.Cube(1, long_name='bar')
+
+    def test_pass(self):
+        self.cubelist.append(self.cube1)
+        self.assertEqual(self.cubelist[-1], self.cube1)
+        self.cubelist.append(self.cube2)
+        self.assertEqual(self.cubelist[-1], self.cube2)
+
+    def test_warn(self):
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist.append(None)
+
 
 class Test_concatenate_cube(tests.IrisTest):
     def setUp(self):
@@ -64,6 +85,32 @@ def test_empty(self):
             CubeList([]).concatenate_cube()
 
 
+class Test_extend(tests.IrisTest):
+    def setUp(self):
+        self.cube1 = iris.cube.Cube(1, long_name='foo')
+        self.cube2 = iris.cube.Cube(1, long_name='bar')
+        self.cubelist1 = iris.cube.CubeList([self.cube1])
+        self.cubelist2 = iris.cube.CubeList([self.cube2])
+
+    def test_pass(self):
+        cubelist = copy.copy(self.cubelist1)
+        cubelist.extend(self.cubelist2)
+        self.assertEqual(cubelist, self.cubelist1 + self.cubelist2)
+        cubelist.extend([self.cube2])
+        self.assertEqual(cubelist[-1], self.cube2)
+
+    def test_fail(self):
+        with self.assertRaisesRegexp(TypeError, 'Cube is not iterable'):
+            self.cubelist1.extend(self.cube1)
+        msg = "'NoneType' object is not iterable"
+        with self.assertRaisesRegexp(TypeError, msg):
+            self.cubelist1.extend(None)
+
+    def test_warn(self):
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist1.extend(range(3))
+
+
 class Test_extract_overlapping(tests.IrisTest):
     def setUp(self):
         shape = (6, 14, 19)
@@ -118,6 +165,48 @@ def test_different_orders(self):
         self.assertEqual(b.coord('time'), self.cube.coord('time')[2:4])
 
 
+class Test_iadd(tests.IrisTest):
+    def setUp(self):
+        self.cube1 = iris.cube.Cube(1, long_name='foo')
+        self.cube2 = iris.cube.Cube(1, long_name='bar')
+        self.cubelist1 = iris.cube.CubeList([self.cube1])
+        self.cubelist2 = iris.cube.CubeList([self.cube2])
+
+    def test_pass(self):
+        cubelist = copy.copy(self.cubelist1)
+        cubelist += self.cubelist2
+        self.assertEqual(cubelist, self.cubelist1 + self.cubelist2)
+        cubelist += [self.cube2]
+        self.assertEqual(cubelist[-1], self.cube2)
+
+    def test_fail(self):
+        msg = 'Cube is not iterable'
+        with self.assertRaisesRegexp(TypeError, msg):
+            self.cubelist1 += self.cube1
+        msg = "'float' object is not iterable"
+        with self.assertRaisesRegexp(TypeError, msg):
+            self.cubelist1 += 1.
+
+    def test_warn(self):
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist1 += range(3)
+
+
+class Test_insert(tests.IrisTest):
+    def setUp(self):
+        self.cube1 = iris.cube.Cube(1, long_name='foo')
+        self.cube2 = iris.cube.Cube(1, long_name='bar')
+        self.cubelist = iris.cube.CubeList([self.cube1] * 3)
+
+    def test_pass(self):
+        self.cubelist.insert(1, self.cube2)
+        self.assertEqual(self.cubelist[1], self.cube2)
+
+    def test_warn(self):
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist.insert(0, None)
+
+
 class Test_merge_cube(tests.IrisTest):
     def setUp(self):
         self.cube1 = Cube([1, 2, 3], "air_temperature", units="K")
@@ -241,6 +330,35 @@ def test_combination_with_extra_triple(self):
         self.assertCML(cube, checksum=False)
 
 
+class Test_setitem(tests.IrisTest):
+    def setUp(self):
+        self.cube1 = iris.cube.Cube(1, long_name='foo')
+        self.cube2 = iris.cube.Cube(1, long_name='bar')
+        self.cube3 = iris.cube.Cube(1, long_name='boo')
+        self.cubelist = iris.cube.CubeList([self.cube1] * 3)
+
+    def test_pass(self):
+        self.cubelist[1] = self.cube2
+        self.assertEqual(self.cubelist[1], self.cube2)
+        self.cubelist[:2] = (self.cube2, self.cube3)
+        self.assertEqual(
+            self.cubelist,
+            iris.cube.CubeList([self.cube2, self.cube3, self.cube1]))
+
+    def test_warn(self):
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist[0] = None
+        with self.assertWarnsRegexp(NOT_CUBE_MSG):
+            self.cubelist[0:2] = [self.cube3, None]
+
+    def test_fail(self):
+        msg = "can only assign an iterable"
+        with self.assertRaisesRegexp(TypeError, msg):
+            self.cubelist[:1] = 2.5
+        with self.assertRaisesRegexp(TypeError, msg):
+            self.cubelist[:1] = self.cube1
+
+
 class Test_xml(tests.IrisTest):
     def setUp(self):
         self.cubes = CubeList([Cube(np.arange(3)),