Fixes made in parallel to Johan's and that might need to be reverted

Author: balbasty

spm/__wrapper__.py

@@ -1695,11 +1695,11 @@ class Cell(_ListMixin, WrappedArray):
     _DelayedType = DelayedCell
 
     @classmethod
-    def _DEFAULT(cls, n: list = ()) -> np.ndarray:
-        if len(n) == 0:
+    def _DEFAULT(cls, shape: list = ()) -> np.ndarray:
+        if len(shape) == 0:
             return Array.from_any([])
 
-        data = np.empty(n, dtype=object)
+        data = np.empty(shape, dtype=object)
         opt = dict(
             flags=['refs_ok', 'zerosize_ok'],
             op_flags=['writeonly', 'no_broadcast']
@@ -1743,24 +1743,27 @@ def _as_runtime(self) -> dict:
     def _from_runtime(cls, objdict: dict) -> "Cell":
         if objdict['type__'] != 'cell':
             raise TypeError('objdict is not a cell')
+        size = np.array(objdict['size__'], dtype=np.uint32).ravel()
+        data = np.fromiter(objdict['data__'], dtype=object)
+        data = data.reshape(size[::-1]).transpose()
         try:
-            size = np.array(objdict['size__'], dtype=np.uint32).ravel()
-            data = objdict['data__']
-            obj = Cell.from_shape([len(data)])
-            opt = dict(flags=['refs_ok', 'zerosize_ok', 'multi_index'],
-                       op_flags=['writeonly', 'no_broadcast'])
-            with np.nditer(obj, **opt) as iter:
-                for elem in iter:
-                    elem[()] = MatlabType.from_any(data[iter.multi_index[0]])
-            obj = obj.reshape(size[::-1]).transpose()
-            return obj
+            obj = data.view(cls)
         except Exception:
             raise RuntimeError(
                 f'Failed to construct Cell data:\n'
                 f'  data={data}\n'
                 f'  objdict={objdict}'
             )
 
+        # recurse
+        opt = dict(flags=['refs_ok', 'zerosize_ok'],
+                   op_flags=['readwrite', 'no_broadcast'])
+        with np.nditer(data, **opt) as iter:
+            for elem in iter:
+                elem[()] = MatlabType.from_any(elem.item())
+
+        return obj
+
     @classmethod
     def from_shape(cls, shape=tuple(), **kwargs) -> "Cell":
         """

tests/test_cell.py

@@ -6,24 +6,72 @@
 
 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_empty(self):
+        # Construct an empty cell array
         c = Cell()
-        a = np.asarray([])
+
+        # Check proper construction
         self.assertIsInstance(c, Cell)
-        self.assertListEqual(c.tolist(), a.tolist())
+        self.assertTupleEqual(c.shape, (0, 0))
+
+    # 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_empty_1d_shape_cell(self):
+    #     # Construct a 3x3 cell array ?
+    #     c = Cell(3)
 
-    def test_instantiate_shape_1d(self):
-        c = Cell([3])
+    #     # Check proper construction
+    #     self.assertIsInstance(c, Cell)
+    #     self.assertTupleEqual(c.shape, (1, 3))
+    #     self.assertTrue(all(isinstance(x, Array) for x in c.flat))
+    #     self.assertTrue(all(x.shape == (0,) for x in c.flat))
+
+    def test_instantiate_empty_1d_row_cell(self):
+        # Construct a 1x3 cell array
+        c = Cell(1, 3)
+
+        # Check proper construction
         self.assertIsInstance(c, Cell)
-        self.assertEqual(c.shape, (3,))
-        self.assertTrue(all(x.shape == (0,) for x in c))
+        self.assertTupleEqual(c.shape, (1, 3))
+        self.assertTrue(all(isinstance(x, Array) for x in c.flat))
+        self.assertTrue(all(x.shape == (0,) for x in c.flat))
 
-    def test_instantiate_shape_2d(self):
-        c = Cell([3, 2])
+    def test_instantiate_empty_1d_col_cell(self):
+        # Construct a 3x1 cell array
+        c = Cell(3, 1)
+
+        # Check proper construction
         self.assertIsInstance(c, Cell)
-        self.assertEqual(c.shape, (3, 2))
+        self.assertTupleEqual(c.shape, (3, 1))
+        self.assertTrue(all(isinstance(x, Array) for x in c.flat))
         self.assertTrue(all(x.shape == (0,) for x in c.flat))
 
+    def test_instantiate_empty_2d_cell(self):
+        # Construct a 3x2 cell array
+        c = Cell(3, 2)
+
+        # Check proper construction
+        self.assertIsInstance(c, Cell)
+        self.assertTupleEqual(c.shape, (3, 2))
+        self.assertTrue(all(isinstance(x, Array) for x in c.flat))
+        self.assertTrue(all(x.shape == (0,) for x in c.flat))
+
+    # 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)
@@ -83,17 +131,106 @@ def test_cell1d_from_matlab(self):
         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)
+    def test_instantiate_1d_row_cell_from_matlab(self):
+        # Construct a 1x3 cell array in Matlab
+        try:
+            c_matlab = Runtime.call("eval", "{1, 2, 3}")
+        except Exception:
+            self.fail('1D row cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (1, 3))
+        self.assertListEqual(c_matlab.tolist(), [[1, 2, 3]])
+
+    def test_instantiate_1d_col_cell_from_matlab(self):
+        # Construct a 3x1 cell array in Matlab
+        try:
+            c_matlab = Runtime.call("eval", "{1; 2; 3}")
+        except Exception:
+            self.fail('1D col cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (3, 1))
+        self.assertListEqual(c_matlab.tolist(), [[1], [2], [3]])
+
+    def test_instantiate_2d_cell_from_matlab(self):
+        # Construct a 2x3 cell array in Matlab
+        try:
+            c_matlab = Runtime.call("eval", "{1, 2, 3; 4, 5, 6}")
+        except Exception:
+            self.fail('2D cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (2, 3))
+        self.assertListEqual(c_matlab.tolist(), [[1, 2, 3], [4, 5, 6]])
+
+    def test_instantiate_nested_cell_from_matlab(self):
+        # Construct a nested cell array
+        try:
+            c_matlab = Runtime.call("eval", "{{1, 2, 3}, {4, 5, 6}}")
+        except Exception:
+            self.fail('Nested cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (2,))
+        self.assertTrue(all(isinstance(x, Cell) for x in c_matlab))
+        self.assertTrue(all(len(x.shape) == 1 for x in c_matlab))
+        self.assertListEqual(c_matlab[0].tolist(), [[1, 2, 3]])
+        self.assertListEqual(c_matlab[1].tolist(), [[4, 5, 6]])
+
+    def test_instantiate_empty_cell_from_matlab(self):
+        # Construct an empty cell array in Matlab
+        try:
+            c_matlab = Runtime.call("eval", "{}")
+        except Exception:
+            self.fail('Empty cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (0,))
+
+    def test_instantiate_empty_1d_row_cell_from_matlab(self):
+        # Construct a 1x3 cell array in Matlab
+        try:
+            c_matlab = Runtime.call('cell', 3, 1)
+        except Exception:
+            self.fail('1D empty row cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (3, 1))
+        self.assertTrue(all(isinstance(x, Array) for x in c_matlab))
+        self.assertTrue(all(len(x.shape) == 0 for x in c_matlab))
+
+    def test_instantiate_empty_1d_col_cell_from_matlab(self):
+        # Construct a 1x3 cell array in Matlab
+        try:
+            c_matlab = Runtime.call('cell', 1, 3)
+        except Exception:
+            self.fail('1D empty col cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (1, 3))
+        self.assertTrue(all(isinstance(x, Array) for x in c_matlab.flat))
+        self.assertTrue(all(len(x.shape) == 0 for x in c_matlab.flat))
+
+    def test_instantiate_empty_2d_cell_from_matlab(self):
+        # Construct a 3x2 cell array in Matlab
+        try:
+            c_matlab = Runtime.call('cell', 3, 2)
+        except Exception:
+            self.fail('2D empty cell from Matlab failed.')
+
+        # Check Runtime conversion
+        self.assertIsInstance(c_matlab, Cell)
+        self.assertTupleEqual(c_matlab.shape, (3, 2))
+        self.assertTrue(all(isinstance(x, Array) for x in c_matlab.flat))
+        self.assertTrue(all(len(x.shape) == 0 for x in c_matlab.flat))
 
     def test_append_1d(self):
         c = Cell.from_any([1, 2, 3], owndata=True)

tests/test_struct.py

@@ -1,7 +1,7 @@
 import unittest
 import numpy as np
 
-from spm import Struct
+from spm import Struct, Array
 
 
 class TestStruct(unittest.TestCase):
@@ -42,6 +42,34 @@ def test_as_array(self):
         a = np.asarray(self.struct, dtype=object)
         self.assertEqual(a.item(), dict(self.struct))
 
+    def test_struct_as_array_after_initialization(self):
+        self.struct.foo = "bar"
+        self.struct.bar = "baz"
+        self.struct[1].baz = 42
+
+        keys = set(('foo', 'bar', 'baz'))
+
+        # All fields exist in struct array
+        self.assertSetEqual(keys, set(self.struct.keys()))
+
+        # All fields exist in first slice
+        self.assertSetEqual(keys, set(self.struct[0].keys()))
+
+        # All fields exist in second slice
+        self.assertSetEqual(keys, set(self.struct[1].keys()))
+
+        # Specified elements are correct
+        self.assertEqual(self.struct[0].foo, "bar")
+        self.assertEqual(self.struct[0].bar, "baz")
+        self.assertEqual(self.struct[1].baz, 42)
+
+        # Unspecified elements are empty arrays
+        self.assertIsInstance(self.struct[0].baz, Array)
+        self.assertTupleEqual(self.struct[0].baz.shape, tuple())
+        self.assertIsInstance(self.struct[1].foo, Array)
+        self.assertTupleEqual(self.struct[1].foo.shape, tuple())
+        self.assertIsInstance(self.struct[1].bar, Array)
+        self.assertTupleEqual(self.struct[1].bar.shape, tuple())
 
 if __name__ == "__main__":
     unittest.main()

tests/tests_runtime.py

@@ -42,6 +42,96 @@ def test_call_matlab_noargout(self):
 
         self.assertTrue(result is None)
 
+    def test_0d_empty_cell_to_matlab(self):
+        try: 
+            from spm import Runtime, Cell
+            idt = Runtime.call('eval', '@(x) x')
+            c = Cell()
+            c2 = idt(c)
+        except Exception:
+            self.fail('OD empty cell to Matlab failed.')
+
+        self.assertIsInstance(c2, Cell)
+        self.assertEqual(c2.shape, c.shape)
+
+    def test_1d_empty_cell_to_matlab(self):
+        try: 
+            from spm import Runtime, Cell
+            idt = Runtime.call('eval', '@(x) x')
+            c = Cell(3)
+            c2 = idt(c)
+        except Exception:
+            self.fail('1D empty cell to Matlab failed.')
+        
+        self.assertIsInstance(c2, Cell)
+        self.assertEqual(c2.shape, c.shape)
+
+    def test_2d_empty_cell_to_matlab(self):
+        try: 
+            from spm import Runtime, Cell
+            idt = Runtime.call('eval', '@(x) x')
+            c = Cell(3, 2)
+            c2 = idt(c)
+        except Exception:
+            self.fail('2D empty cell to Matlab failed.')
+
+        self.assertIsInstance(c2, Cell)
+        self.assertEqual(c2.shape, c.shape)
+
+    def test_1d_cell_to_matlab(self):
+        try:
+            from spm import Runtime, Cell
+            idt = Runtime.call('eval', '@(x) x')
+            c = Cell.from_any([1, 2, 3])
+            c2 = idt(c)
+        except Exception:
+            self.fail('1D cell to Matlab failed.')
+        
+        self.assertIsInstance(c2, Cell)
+        self.assertEqual(c2.shape, c.shape)
+        self.assertTrue(c2.tolist() == c.tolist())
+
+    def test_2d_cell_to_matlab(self):
+        try:
+            from spm import Runtime, Cell
+            import numpy as np
+            idt = Runtime.call('eval', '@(x) x')
+            c = Cell.from_array(np.random.randn(2, 3))
+            c2 = idt(c)
+        except Exception:
+            self.fail('1D cell to Matlab failed.')
+        
+        self.assertIsInstance(c2, Cell)
+        self.assertEqual(c2.shape, c.shape)
+        self.assertTrue(c2.tolist() == c.tolist())
+
+    def test_empty_struct_to_matlab(self):
+        try: 
+            from spm import Runtime, Struct
+            idt = Runtime.call('eval', '@(x) x')
+            s = Struct()
+            s2 = idt(s)
+        except Exception:
+            self.fail('Empty struct to Matlab failed.')
+        
+        self.assertIsInstance(s2, Struct)
+        self.assertEqual(s2.shape, s.shape)
+
+    def test_empty_array_to_matlab(self):
+        try: 
+            from spm import Runtime, Array
+            idt = Runtime.call('eval', '@(x) x')
+            a = Array()
+            a2 = idt(a)
+        except Exception:
+            self.fail('Empty array to Matlab failed.')
+
+        self.assertIsInstance(a2, Array)
+        self.assertEqual(a2.shape, a.shape)
+
+    
+
+
 
 if __name__ == '__main__':
     unittest.main()