fix #883: fixed Array.values(), zip_array_values and zip_array_items when axes=()

Author: gdementen

doc/source/changes/version_0_33.rst.inc

@@ -61,4 +61,4 @@ Miscellaneous improvements
 Fixes
 ^^^^^
 
-* fixed something (closes :issue:`1`).
+* fixed Array.values(), zip_array_values and zip_array_items when axes=() (closes :issue:`883`).

larray/core/array.py

@@ -3548,6 +3548,9 @@ def values(self, axes=None, ascending=True):
             combined = np.ravel(self.data)
             # combined[::-1] *is* indexable
             return combined if ascending else combined[::-1]
+        elif not axes:
+            # empty axes list
+            return [self]
 
         if not isinstance(axes, (tuple, list, AxisCollection)):
             axes = (axes,)
@@ -9722,9 +9725,11 @@ def zip_array_values(values, axes=None, ascending=True):
 
     Parameters
     ----------
+    values : sequence of (scalar or Array)
+        Values to iterate on. Scalars are repeated as many times as necessary.
     axes : int, str or Axis or tuple of them, optional
-        Axis or axes along which to iterate and in which order. Defaults to None (union of all axes present in
-        all arrays, in the order they are found).
+        Axis or axes along which to iterate and in which order. All those axes must be compatible (if present) between
+        the different values. Defaults to None (union of all axes present in all arrays, in the order they are found).
     ascending : bool, optional
         Whether or not to iterate the axes in ascending order (from start to end). Defaults to True.
 
@@ -9758,6 +9763,10 @@ def zip_array_values(values, axes=None, ascending=True):
         2   3
     c  c1  c2
         2   3
+
+    When the axis to iterate on (`c` in this case) is not present in one of the arrays (arr1), that array is repeated
+    for each label of that axis:
+
     >>> for a1, a2 in zip_array_values((arr1, arr2), arr2.c):
     ...     print("==")
     ...     print(a1)
@@ -9774,8 +9783,11 @@ def zip_array_values(values, axes=None, ascending=True):
      a1   2   3
     a  a0  a1
         1   3
+
+    When no `axes` are given, it iterates on the union of all compatible axes (a, b, and c in this case):
+
     >>> for a1, a2 in zip_array_values((arr1, arr2)):
-    ...     print("arr1: {}, arr2: {}".format(a1, a2))
+    ...     print(f"arr1: {a1}, arr2: {a2}")
     arr1: 0, arr2: 0
     arr1: 0, arr2: 1
     arr1: 1, arr2: 0
@@ -9794,21 +9806,26 @@ def values_with_expand(value, axes, readonly=True, ascending=True):
             size = axes.size if axes.ndim else 0
             return Repeater(value, size)
 
-    all_axes = AxisCollection.union(*[get_axes(v) for v in values])
+    values_axes = [get_axes(v) for v in values]
+
     if axes is None:
-        axes = all_axes
+        all_iter_axes = values_axes
     else:
         if not isinstance(axes, (tuple, list, AxisCollection)):
             axes = (axes,)
-        # transform string axes definitions to objects
+
+        # transform string axes _definitions_ to objects
         axes = [Axis(axis) if isinstance(axis, str) and '=' in axis else axis
                 for axis in axes]
-        # transform string axes references to objects
-        axes = AxisCollection([axis if isinstance(axis, Axis) else all_axes[axis]
-                               for axis in axes])
+
+        # get iter axes for all values and transform string axes _references_ to objects
+        all_iter_axes = [AxisCollection([value_axes[axis] for axis in axes if axis in value_axes])
+                         for value_axes in values_axes]
+
+    common_iter_axes = AxisCollection.union(*all_iter_axes)
 
     # sequence of tuples (of scalar or arrays)
-    return SequenceZip([values_with_expand(v, axes, ascending=ascending) for v in values])
+    return SequenceZip([values_with_expand(v, common_iter_axes, ascending=ascending) for v in values])
 
 
 def zip_array_items(values, axes=None, ascending=True):

larray/tests/test_array.py

@@ -17,7 +17,8 @@
 from larray import (Array, LArray, Axis, AxisCollection, LGroup, IGroup,
                     union, zeros, zeros_like, ndtest, empty, ones, eye, diag, stack,
                     clip, exp, where, X, mean, isnan, round, read_hdf, read_csv, read_eurostat, read_excel,
-                    from_lists, from_string, open_excel, from_frame, sequence, nan)
+                    from_lists, from_string, open_excel, from_frame, sequence, nan,
+                    zip_array_values, zip_array_items)
 from larray.inout.pandas import from_series
 from larray.core.axis import _to_ticks, _to_key
 from larray.util.misc import LHDFStore
@@ -329,6 +330,10 @@ def test_values():
     assert_larray_equal(values[0], arr['b1'])
     assert_larray_equal(values[-1], arr['b0'])
 
+    values = arr.values(())
+    res = list(values)
+    assert_larray_equal(res[0], arr)
+
 
 def test_items():
     arr = ndtest((2, 2))
@@ -5210,6 +5215,40 @@ def test_eq():
     assert_array_equal(ao.eq(ao['c0'], nans_equal=True), a == a['c0'])
 
 
+def test_zip_array_values():
+    arr1 = ndtest((2, 3))
+    # b axis intentionally not the same on both arrays
+    arr2 = ndtest((2, 2, 2))
+
+    # 1) no axes => return input arrays themselves
+    res = list(zip_array_values((arr1, arr2), ()))
+    assert len(res) == 1 and len(res[0]) == 2
+    r0_arr1, r0_arr2 = res[0]
+    assert_larray_equal(r0_arr1, arr1)
+    assert_larray_equal(r0_arr2, arr2)
+
+    # 2) iterate on an axis not present on one of the arrays => the other array is repeated
+    res = list(zip_array_values((arr1, arr2), arr2.c))
+    assert len(res) == 2 and all(len(r) == 2 for r in res)
+    r0_arr1, r0_arr2 = res[0]
+    r1_arr1, r1_arr2 = res[1]
+    assert_larray_equal(r0_arr1, arr1)
+    assert_larray_equal(r0_arr2, arr2['c0'])
+    assert_larray_equal(r1_arr1, arr1)
+    assert_larray_equal(r1_arr2, arr2['c1'])
+
+
+def test_zip_array_items():
+    arr1 = ndtest('a=a0,a1;b=b0,b1')
+    arr2 = ndtest('a=a0,a1;c=c0,c1')
+    res = list(zip_array_items((arr1, arr2), axes=()))
+    assert len(res) == 1 and len(res[0]) == 2 and len(res[0][1]) == 2
+    r0_k, (r0_arr1, r0_arr2) = res[0]
+    assert r0_k == ()
+    assert_larray_equal(r0_arr1, arr1)
+    assert_larray_equal(r0_arr2, arr2)
+
+
 if __name__ == "__main__":
     # import doctest
     # import unittest