Test + fixes for cells (wip)

Author: balbasty

spm/__wrapper__.py

@@ -199,15 +199,12 @@ def from_any(cls, other):
             else:
                 return Struct.from_any(other)
 
-        if isinstance(other, (tuple, set)):
+        if isinstance(other, (list, tuple, set)):
             # nested tuples are cells of cells, not cell arrays
             return Cell.from_any(other)
 
-        if isinstance(other, (list, np.ndarray, int, float, complex, bool)):
-            try:
-                return Array.from_any(other)
-            except (ValueError, TypeError):
-                return Cell.from_any(other)
+        if isinstance(other, (np.ndarray, int, float, complex, bool)):
+            return Array.from_any(other)
 
         if isinstance(other, str):
             return other
@@ -602,7 +599,8 @@ def _resize_for_index(self, index):
 
     def _finalize(self):
         """Transform all DelayedArrays into concrete arrays."""
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite', 'no_broadcast'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'],
+                   op_flags=['readwrite', 'no_broadcast'])
         with np.nditer(self, **opt) as iter:
             for elem in iter:
                 item = elem.item()
@@ -1273,7 +1271,7 @@ def _from_runtime(cls, objdict: dict) -> "Cell":
             raise TypeError('objdict is not a cell')
         size = np.array(objdict['size__'], dtype=np.uint32).ravel()
         data = np.array(objdict['data__'], dtype=object)
-        data = data.reshape(size)
+        data = data.reshape(size[::-1]).transpose()
         try:
             obj = data.view(cls)
         except Exception:
@@ -1311,7 +1309,8 @@ def from_shape(cls, shape=tuple(), **kwargs) -> "Cell":
             # Scalar cells are forbidden
             shape = [0]
         arr = np.ndarray(shape, **kwargs)
-        opt = dict(flags=['refs_ok'], op_flags=['write_only', 'no_broadcast'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'],
+                   op_flags=['writeonly', 'no_broadcast'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 elem[()] = cls._DEFAULT()
@@ -1367,13 +1366,16 @@ def from_any(cls, other, **kwargs) -> "Cell":
             def asrecursive(other):
                 if isinstance(other, np.ndarray):
                     return other
+                elif isinstance(other, (str, bytes)):
+                    return other
                 elif hasattr(other, "__iter__"):
                     other = list(map(asrecursive, other))
                     tmp = np.ndarray(len(other), dtype=object)
                     for i, x in enumerate(other):
                         tmp[i] = x
                     other = tmp
-                    return np.ndarray.view(other, cls)
+                    obj = np.ndarray.view(other, cls)
+                    return obj
                 else:
                     return other
 
@@ -1394,7 +1396,8 @@ def asrecursive(other):
         other = np.ndarray.view(other, cls)
 
         # recurse
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite', 'no_broadcast'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'],
+                   op_flags=['readwrite', 'no_broadcast'])
         with np.nditer(other, **opt) as iter:
             for elem in iter:
                 elem[()] = MatlabType.from_any(elem.item())
@@ -1412,7 +1415,8 @@ def _unroll_build(cls, arr):
         # them to lists, and recurse.
         rebuild = False
         arr = np.asarray(arr)
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite', 'no_broadcast'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'],
+                   op_flags=['readwrite', 'no_broadcast'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 item = elem.item()
@@ -1593,7 +1597,7 @@ def __getitem__(self, key):
         #   Otherwise the default value is [], as per matlab.
         isnewkey = key not in self.keys()
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 elem.item().setdefault(
@@ -1617,7 +1621,8 @@ def __setitem__(self, key, value):
             # Each element in the struct array is matched with an element
             # in the "unpack" array.
             value = value.broadcast_to_struct(self)
-            opt = dict(flags=['refs_ok', 'multi_index'], op_flags=['readonly'])
+            opt = dict(flags=['refs_ok', 'zerosize_ok', 'multi_index'],
+                       op_flags=['readonly'])
             with np.nditer(arr, **opt) as iter:
                 for elem in iter:
                     val = value[iter.multi_index]
@@ -1627,7 +1632,7 @@ def __setitem__(self, key, value):
 
         else:
             # Assign the same value to all elements in the struct array.
-            opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+            opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
             value = MatlabType.from_any(value)
             with np.nditer(arr, **opt) as iter:
                 for elem in iter:
@@ -1637,7 +1642,7 @@ def __delitem__(self, key):
         if key not in self._allkeys():
             raise KeyError(key)
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 del elem.item()[key]
@@ -1655,7 +1660,7 @@ def values(self):
 
     def setdefault(self, key, value):
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 item = elem.item()
@@ -1667,7 +1672,8 @@ def update(self, other):
         other = np.broadcast_to(other, self.shape)
 
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok', 'multi_index'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok', 'multi_index'],
+                   op_flags=['readonly'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 other_elem = other[iter.multi_index]
@@ -1844,7 +1850,7 @@ def from_shape(cls, shape=tuple(), **kwargs) -> "Struct":
         """
         kwargs["dtype"] = dict
         arr = np.ndarray(shape, **kwargs)
-        flags = dict(flags=['refs_ok'], op_flags=['readwrite'])
+        flags = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readwrite'])
         with np.nditer(arr, **flags) as iter:
             for elem in iter:
                 elem[()] = dict()
@@ -1892,7 +1898,7 @@ def from_any(cls, other, **kwargs) -> "Struct":
         # convert to array[dict]
         other = np.asarray(other, **kwargs)
         other = cls._unroll_build(other)
-        opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
         with np.nditer(other, **opt) as iter:
             if not all(isinstance(elem.item(), dict) for elem in iter):
                 raise TypeError("Not an array of dictionaries")
@@ -1902,7 +1908,7 @@ def from_any(cls, other, **kwargs) -> "Struct":
             other = _copy_if_needed(other, inp, copy)
 
         # nested from_any
-        opt = dict(flags=['refs_ok'], op_flags=['readonly'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readonly'])
         with np.nditer(other, **opt) as iter:
             for elem in iter:
                 item: dict = elem.item()
@@ -1929,7 +1935,7 @@ def _unroll_build(cls, arr):
         # them to lists, and recurse.
         rebuild = False
         arr = np.ndarray.view(arr, np.ndarray)
-        flags = dict(flags=['refs_ok'], op_flags=['readwrite'])
+        flags = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readwrite'])
         with np.nditer(arr, **flags) as iter:
             for elem in iter:
                 item = elem.item()
@@ -1962,7 +1968,7 @@ def as_dict(self) -> dict:
         if np.ndim(self) == 0:
             return np.ndarray.item(self)
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readwrite'])
         with np.nditer(arr, **opt) as iter:
             return {
                 key: Cell.from_any([
@@ -1976,7 +1982,7 @@ def _allkeys(self):
         # Keys are ordered by (1) element (2) within-element order
         mock = {}
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readwrite'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 mock.update({key: None for key in elem.item().keys()})
@@ -2065,7 +2071,7 @@ def __delattr__(self, key):
 
     def _finalize(self):
         arr = np.ndarray.view(self, np.ndarray)
-        opt = dict(flags=['refs_ok'], op_flags=['readwrite'])
+        opt = dict(flags=['refs_ok', 'zerosize_ok'], op_flags=['readwrite'])
         with np.nditer(arr, **opt) as iter:
             for elem in iter:
                 item = elem.item()

tests/test_cell.py

@@ -0,0 +1,81 @@
+import unittest
+import numpy as np
+
+from spm import Cell, Runtime
+
+
+class CellTestCase(unittest.TestCase):
+
+    def test_instantiate_empty(self):
+        c = Cell()
+        a = np.asarray([])
+        self.assertIsInstance(c, Cell)
+        self.assertListEqual(c.tolist(), a.tolist())
+
+    def test_instantiate_shape_1d(self):
+        c = Cell([3])
+        self.assertIsInstance(c, Cell)
+        self.assertEqual(c.shape, (3,))
+        self.assertTrue(all(x.shape == (0,) for x in c))
+
+    def test_instantiate_shape_2d(self):
+        c = Cell([3, 2])
+        self.assertIsInstance(c, Cell)
+        self.assertEqual(c.shape, (3, 2))
+        self.assertTrue(all(x.shape == (0,) for x in c.flat))
+
+    def test_instantiate_shape_order(self):
+        c = Cell([3, 2], order="C")
+        self.assertIsInstance(c, Cell)
+        self.assertEqual(c.shape, (3, 2))
+        self.assertEqual(c.strides, (2*8, 8))
+
+        c = Cell([3, 2], order="F")
+        self.assertIsInstance(c, Cell)
+        self.assertEqual(c.shape, (3, 2))
+        self.assertEqual(c.strides, (8, 8*3))
+
+    def test_instantiate_list(self):
+        c = Cell.from_any(['a', 'b', 'c'])
+        self.assertEqual(c.shape, (3,))
+        self.assertEqual(repr(c), "Cell(['a', 'b', 'c'])")
+        self.assertListEqual(c.tolist(), ['a', 'b', 'c'])
+
+    def test_instantiate_nested_list(self):
+        c = Cell.from_any([['a', 'b'], ['c', 'd']])
+        self.assertEqual(c.shape, (2,))
+        self.assertEqual(repr(c), "Cell([Cell(['a', 'b']), Cell(['c', 'd'])])")
+        self.assertTrue(all(isinstance(x, Cell) for x in c.tolist()))
+
+    def test_instantiate_nested_list_deepcat(self):
+        c = Cell.from_any([['a', 'b'], ['c', 'd']], deepcat=True)
+        self.assertEqual(c.shape, (2, 2))
+        self.assertEqual(repr(c), "Cell([['a', 'b'],\n      ['c', 'd']])")
+        self.assertTrue(all(isinstance(x, list) for x in c.tolist()))
+
+    def test_as_struct(self):
+        self.assertRaises(TypeError, lambda: Cell().as_struct)
+
+    def test_as_num(self):
+        self.assertRaises(TypeError, lambda: Cell().as_num)
+
+    def test_as_cell(self):
+        c = Cell()
+        self.assertTrue(c.as_cell is c)
+
+    def test_cell1d_from_matlab(self):
+        c_matlab = Runtime.call("eval", "{1, 2, 3}")
+        c_python = Cell.from_any([1, 2, 3])
+        self.assertListEqual(c_matlab.tolist(), c_python.tolist())
+
+    def test_cell2d_from_matlab(self):
+        c_matlab = Runtime.call("eval", "{1, 2, 3; 4, 5, 6}")
+        c_python = Cell.from_any([[1, 2, 3], [4, 5, 6]], deepcat=True)
+        self.assertTrue(c_matlab.tolist() == c_python.tolist())
+
+    def test_nested_cell_from_matlab(self):
+        c_matlab = Runtime.call("eval", "{{1, 2, 3}, {4, 5, 6}}")
+        c_python = Cell.from_any([[1, 2, 3], [4, 5, 6]])
+        c_matlab = [x.tolist() for x in c_matlab.tolist()]
+        c_python = [x.tolist() for x in c_python.tolist()]
+        self.assertListEqual(c_matlab, c_python)