arraykit 0.7.0__tar.gz → 0.7.2__tar.gz

{arraykit-0.7.0/arraykit.egg-info → arraykit-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.7.0
+Version: 0.7.2
 Summary: Array utilities for StaticFrame
 Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland

{arraykit-0.7.0 → arraykit-0.7.2}/README.rst

@@ -37,12 +37,25 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+
+0.7.2
+............
+
+Improved ``array_to_tuple_array()`` and ``array_to_tuple_iter()`` to preserve ``tuple`` in 1D arrays.
+
+
+0.7.1
+............
+
+Extended ``array_to_tuple_array()`` and ``array_to_tuple_iter()`` to support 1D arrays.
+
+
 0.7.0
 ............
 
-Added ``array2d_to_array1d()``.
+Added ``array_to_tuple_array()``.
 
-Added ``array2d_tuple_iter()``.
+Added ``array_to_tuple_iter()``.
 
 
 0.6.3

{arraykit-0.7.0 → arraykit-0.7.2/arraykit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.7.0
+Version: 0.7.2
 Summary: Array utilities for StaticFrame
 Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland

{arraykit-0.7.0 → arraykit-0.7.2}/setup.py

@@ -5,7 +5,7 @@ from setuptools import Extension  # type: ignore
 from setuptools import setup
 from pathlib import Path
 
-AK_VERSION = '0.7.0'
+AK_VERSION = '0.7.2'
 
 def get_long_description() -> str:
     return '''The ArrayKit library provides utilities for creating and transforming NumPy arrays, implementing performance-critical StaticFrame operations as Python C extensions.

{arraykit-0.7.0 → arraykit-0.7.2}/src/__init__.py

@@ -28,6 +28,6 @@ from ._arraykit import count_iteration as count_iteration
 from ._arraykit import first_true_1d as first_true_1d
 from ._arraykit import first_true_2d as first_true_2d
 from ._arraykit import slice_to_ascending_slice as slice_to_ascending_slice
-from ._arraykit import array2d_to_array1d as array2d_to_array1d
-from ._arraykit import array2d_tuple_iter as array2d_tuple_iter
+from ._arraykit import array_to_tuple_array as array_to_tuple_array
+from ._arraykit import array_to_tuple_iter as array_to_tuple_iter
 from ._arraykit import nonzero_1d as nonzero_1d

{arraykit-0.7.0 → arraykit-0.7.2}/src/__init__.pyi

@@ -161,5 +161,5 @@ def first_true_1d(__array: np.ndarray, *, forward: bool) -> int: ...
 def first_true_2d(__array: np.ndarray, *, forward: bool, axis: int) -> np.ndarray: ...
 def nonzero_1d(__array: np.ndarray, /) -> np.ndarray: ...
 def slice_to_ascending_slice(__slice: slice, __size: int) -> slice: ...
-def array2d_to_array1d(__array: np.ndarray) -> np.ndarray: ...
-def array2d_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...
+def array_to_tuple_array(__array: np.ndarray) -> np.ndarray: ...
+def array_to_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...

{arraykit-0.7.0 → arraykit-0.7.2}/src/_arraykit.c

@@ -3524,16 +3524,20 @@ array_deepcopy(PyObject *m, PyObject *args, PyObject *kwargs)
 }
 
 //------------------------------------------------------------------------------
-// Given a 2D array, return a 1D object array of tuples.
+// Given a 1D or 2D array, return a 1D object array of tuples.
 static PyObject *
-array2d_to_array1d(PyObject *Py_UNUSED(m), PyObject *a)
+array_to_tuple_array(PyObject *Py_UNUSED(m), PyObject *a)
 {
-    AK_CHECK_NUMPY_ARRAY_2D(a);
+    AK_CHECK_NUMPY_ARRAY(a);
     PyArrayObject *input_array = (PyArrayObject *)a;
+    int ndim = PyArray_NDIM(input_array);
+    if (ndim != 1 && ndim != 2) {
+        return PyErr_Format(PyExc_NotImplementedError,
+                "Expected 1D or 2D array, not %i.",
+                ndim);
+    }
 
     npy_intp num_rows = PyArray_DIM(input_array, 0);
-    npy_intp num_cols = PyArray_DIM(input_array, 1);
-
     npy_intp dims[] = {num_rows};
     // NOTE: this initializes values to NULL, not None
     PyObject* output = PyArray_SimpleNew(1, dims, NPY_OBJECT);
@@ -3545,26 +3549,64 @@ array2d_to_array1d(PyObject *Py_UNUSED(m), PyObject *a)
     PyObject** p = output_data;
     PyObject** p_end = p + num_rows;
     npy_intp i = 0;
-    npy_intp j;
     PyObject* tuple;
     PyObject* item;
 
-    while (p < p_end) {
-        tuple = PyTuple_New(num_cols);
-        if (tuple == NULL) {
-            goto error;
+    if (ndim == 2) {
+        npy_intp num_cols = PyArray_DIM(input_array, 1);
+        npy_intp j;
+        while (p < p_end) {
+            tuple = PyTuple_New(num_cols);
+            if (tuple == NULL) {
+                goto error;
+            }
+            for (j = 0; j < num_cols; ++j) {
+                // cannot assume input_array is contiguous
+                item = PyArray_ToScalar(PyArray_GETPTR2(input_array, i, j), input_array);
+                if (item == NULL) {
+                    Py_DECREF(tuple);
+                    goto error;
+                }
+                PyTuple_SET_ITEM(tuple, j, item); // steals reference to item
+            }
+            *p++ = tuple; // assign with new ref, no incr needed
+            i++;
         }
-        for (j = 0; j < num_cols; ++j) {
-            // cannot assume input_array is contiguous
-            item = PyArray_ToScalar(PyArray_GETPTR2(input_array, i, j), input_array);
+    }
+    else if (PyArray_TYPE(input_array) != NPY_OBJECT) { // ndim == 1, not object
+        while (p < p_end) {
+            tuple = PyTuple_New(1);
+            if (tuple == NULL) {
+                goto error;
+            }
+            // scalar returned in is native PyObject from object arrays
+            item = PyArray_ToScalar(PyArray_GETPTR1(input_array, i), input_array);
             if (item == NULL) {
                 Py_DECREF(tuple);
                 goto error;
             }
-            PyTuple_SET_ITEM(tuple, j, item); // steals reference to item
+            PyTuple_SET_ITEM(tuple, 0, item); // steals reference to item
+            *p++ = tuple; // assign with new ref, no incr needed
+            i++;
+        }
+    }
+    else { // ndim == 1, object
+        while (p < p_end) {
+            item = *(PyObject**)PyArray_GETPTR1(input_array, i);
+            Py_INCREF(item); // always incref
+            if (PyTuple_Check(item)) {
+                tuple = item; // do not double pack
+            }
+            else {
+                tuple = PyTuple_New(1);
+                if (tuple == NULL) {
+                    goto error;
+                }
+                PyTuple_SET_ITEM(tuple, 0, item); // steals reference to item
+            }
+            *p++ = tuple; // assign with new ref, no incr needed
+            i++;
         }
-        *p++ = tuple; // assign with new ref, no incr needed
-        i++;
     }
     PyArray_CLEARFLAGS((PyArrayObject *)output, NPY_ARRAY_WRITEABLE);
     return output;
@@ -3579,65 +3621,96 @@ error:
 }
 
 //------------------------------------------------------------------------------
-// Array2DTuple Iterator
+// ArrayToTupleIterator
 
-static PyTypeObject A2DTupleType;
+static PyTypeObject ATTType;
 
-typedef struct A2DTupleObject {
+typedef struct ATTObject {
     PyObject_HEAD
     PyArrayObject* array;
     npy_intp num_rows;
     npy_intp num_cols;
     Py_ssize_t pos; // current index state, mutated in-place
-} A2DTupleObject;
+} ATTObject;
 
 static PyObject *
-A2DTuple_new(PyArrayObject* array,
+ATT_new(PyArrayObject* array,
         npy_intp num_rows,
         npy_intp num_cols) {
-    A2DTupleObject* a2dt = PyObject_New(A2DTupleObject, &A2DTupleType);
+    ATTObject* a2dt = PyObject_New(ATTObject, &ATTType);
     if (!a2dt) {
         return NULL;
     }
     Py_INCREF((PyObject*)array);
     a2dt->array = array;
     a2dt->num_rows = num_rows;
-    a2dt->num_cols = num_cols;
+    a2dt->num_cols = num_cols; // -1 for 1D array
     a2dt->pos = 0;
     return (PyObject *)a2dt;
 }
 
 static void
-A2DTuple_dealloc(A2DTupleObject *self) {
+ATT_dealloc(ATTObject *self) {
     Py_DECREF((PyObject*)self->array);
     PyObject_Del((PyObject*)self);
 }
 
 static PyObject*
-A2DTuple_iter(A2DTupleObject *self) {
+ATT_iter(ATTObject *self) {
     Py_INCREF(self);
     return (PyObject*)self;
 }
 
 static PyObject *
-A2DTuple_iternext(A2DTupleObject *self) {
+ATT_iternext(ATTObject *self) {
     Py_ssize_t i = self->pos;
     if (i < self->num_rows) {
         npy_intp num_cols = self->num_cols;
         PyArrayObject* array = self->array;
-        PyObject* tuple = PyTuple_New(num_cols);
         PyObject* item;
-        if (tuple == NULL) {
-            return NULL;
+        PyObject* tuple;
+
+        if (num_cols > -1) { // ndim == 2
+            tuple = PyTuple_New(num_cols);
+            if (tuple == NULL) {
+                return NULL;
+            }
+            for (npy_intp j = 0; j < num_cols; ++j) {
+                // cannot assume array is contiguous
+                item = PyArray_ToScalar(PyArray_GETPTR2(array, i, j), array);
+                if (item == NULL) {
+                    Py_DECREF(tuple);
+                    return NULL;
+                }
+                PyTuple_SET_ITEM(tuple, j, item); // steals ref
+            }
         }
-        for (npy_intp j = 0; j < num_cols; ++j) {
-            // cannot assume array is contiguous
-            item = PyArray_ToScalar(PyArray_GETPTR2(array, i, j), array);
+        else if (PyArray_TYPE(array) != NPY_OBJECT) { // ndim == 1, not object
+            tuple = PyTuple_New(1);
+            if (tuple == NULL) {
+                return NULL;
+            }
+            item = PyArray_ToScalar(PyArray_GETPTR1(array, i), array);
             if (item == NULL) {
                 Py_DECREF(tuple);
                 return NULL;
             }
-            PyTuple_SET_ITEM(tuple, j, item); // steals reference to item
+            PyTuple_SET_ITEM(tuple, 0, item); // steals ref
+        }
+        else { // ndim == 1, object
+            item = *(PyObject**)PyArray_GETPTR1(array, i);
+            Py_INCREF(item); // always incref
+            if (PyTuple_Check(item)) {
+                tuple = item; // do not double pack
+            }
+            else {
+                tuple = PyTuple_New(1);
+                if (tuple == NULL) {
+                    Py_DECREF(item);
+                    return NULL;
+                }
+                PyTuple_SET_ITEM(tuple, 0, item); // steals ref
+            }
         }
         self->pos++;
         return tuple;
@@ -3646,44 +3719,52 @@ A2DTuple_iternext(A2DTupleObject *self) {
 }
 
 // static PyObject *
-// A2DTuple_reversed(A2DTupleObject *self) {
-//     return A2DTuple_new(self->bi, !self->reversed);
+// ATT_reversed(ATTObject *self) {
+//     return ATT_new(self->bi, !self->reversed);
 // }
 
 static PyObject *
-A2DTuple_length_hint(A2DTupleObject *self) {
+ATT_length_hint(ATTObject *self) {
     Py_ssize_t len = Py_MAX(0, self->num_rows - self->pos);
     return PyLong_FromSsize_t(len);
 }
 
-static PyMethodDef A2DTuple_methods[] = {
-    {"__length_hint__", (PyCFunction)A2DTuple_length_hint, METH_NOARGS, NULL},
-    // {"__reversed__", (PyCFunction)A2DTuple_reversed, METH_NOARGS, NULL},
+static PyMethodDef ATT_methods[] = {
+    {"__length_hint__", (PyCFunction)ATT_length_hint, METH_NOARGS, NULL},
+    // {"__reversed__", (PyCFunction)ATT_reversed, METH_NOARGS, NULL},
     {NULL},
 };
 
-static PyTypeObject A2DTupleType = {
+static PyTypeObject ATTType = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_basicsize = sizeof(A2DTupleObject),
-    .tp_dealloc = (destructor) A2DTuple_dealloc,
-    .tp_iter = (getiterfunc) A2DTuple_iter,
-    .tp_iternext = (iternextfunc) A2DTuple_iternext,
-    .tp_methods = A2DTuple_methods,
-    .tp_name = "arraykit.A2DTupleIterator",
+    .tp_basicsize = sizeof(ATTObject),
+    .tp_dealloc = (destructor) ATT_dealloc,
+    .tp_iter = (getiterfunc) ATT_iter,
+    .tp_iternext = (iternextfunc) ATT_iternext,
+    .tp_methods = ATT_methods,
+    .tp_name = "arraykit.ATTIterator",
 };
 
 // Given a 2D array, return an iterator of row tuples.
 static PyObject *
-array2d_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
+array_to_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
 {
-    AK_CHECK_NUMPY_ARRAY_2D(a);
-    PyArrayObject* array = (PyArrayObject *)a;
+    AK_CHECK_NUMPY_ARRAY(a);
+    PyArrayObject *array = (PyArrayObject *)a;
+    int ndim = PyArray_NDIM(array);
+    if (ndim != 1 && ndim != 2) {
+        return PyErr_Format(PyExc_NotImplementedError,
+                "Expected 1D or 2D array, not %i.",
+                ndim);
+    }
     npy_intp num_rows = PyArray_DIM(array, 0);
-    npy_intp num_cols = PyArray_DIM(array, 1);
-    return A2DTuple_new(array, num_rows, num_cols);
+    npy_intp num_cols = -1; // indicate 1d
+    if (ndim == 2) {
+        num_cols = PyArray_DIM(array, 1);
+    }
+    return ATT_new(array, num_rows, num_cols);
 }
 
-
 //------------------------------------------------------------------------------
 // type resolution
 
@@ -7431,8 +7512,8 @@ static PyMethodDef arraykit_methods[] =  {
             (PyCFunction)array_deepcopy,
             METH_VARARGS | METH_KEYWORDS,
             NULL},
-    {"array2d_to_array1d", array2d_to_array1d, METH_O, NULL},
-    {"array2d_tuple_iter", array2d_tuple_iter, METH_O, NULL},
+    {"array_to_tuple_array", array_to_tuple_array, METH_O, NULL},
+    {"array_to_tuple_iter", array_to_tuple_iter, METH_O, NULL},
     {"resolve_dtype", resolve_dtype, METH_VARARGS, NULL},
     {"resolve_dtype_iter", resolve_dtype_iter, METH_O, NULL},
     {"first_true_1d",

{arraykit-0.7.0 → arraykit-0.7.2}/test/test_util.py

@@ -22,8 +22,8 @@ from arraykit import count_iteration
 from arraykit import first_true_1d
 from arraykit import first_true_2d
 from arraykit import slice_to_ascending_slice
-from arraykit import array2d_to_array1d
-from arraykit import array2d_tuple_iter
+from arraykit import array_to_tuple_array
+from arraykit import array_to_tuple_iter
 
 from performance.reference.util import get_new_indexers_and_screen_ak as get_new_indexers_and_screen_full
 from arraykit import get_new_indexers_and_screen
@@ -286,15 +286,49 @@ class TestUnit(unittest.TestCase):
             a2 = array_deepcopy(a1, ())
 
     #---------------------------------------------------------------------------
-    def test_array2d_to_array1d_dummy(self) -> None:
+    def test_array_to_tuple_array_1d_a(self) -> None:
         a1 = np.arange(10)
-        with self.assertRaises(NotImplementedError):
-            # 1 dimensional
-            _ = array2d_to_array1d(a1)
-
-    def test_array2d_to_array1d_b(self) -> None:
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)])
+
+    def test_array_to_tuple_array_1d_b(self) -> None:
+        a1 = np.array(['aaa', 'b', 'ccc'])
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [('aaa',), ('b',), ('ccc',)])
+
+    def test_array_to_tuple_array_1d_c(self) -> None:
+        a1 = np.array([None, 'b', 30])
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [(None,), ('b',), (30,)])
+
+    def test_array_to_tuple_array_1d_d(self) -> None:
+        a1 = np.array([('a', 10), ('b', 30), ('c', 5)], dtype=object)
+        a2 = array_to_tuple_array(a1) # from 2d
+        self.assertEqual(a2.tolist(), [('a', 10), ('b', 30), ('c', 5)])
+        a3 = array_to_tuple_array(a2) # from 1d
+        self.assertEqual(a3.tolist(), [('a', 10), ('b', 30), ('c', 5)])
+
+    def test_array_to_tuple_array_1d_e(self) -> None:
+        a1 = np.array([True, False, True], dtype=object)
+        a2 = array_to_tuple_array(a1)
+        self.assertIs(a2[0][0].__class__, bool)
+        self.assertEqual(a2.tolist(), [(True,), (False,), (True,)])
+
+    def test_array_to_tuple_array_1d_f(self) -> None:
+        a1 = np.array([None, None, None], dtype=object)
+        a1[0] = 3
+        a1[1] = ('a', 30)
+        a1[2] = (None, True, 90000000)
+
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [(3,), ('a', 30), (None, True, 90000000)])
+
+        a3 = array_to_tuple_array(a2)
+        self.assertEqual(a3.tolist(), [(3,), ('a', 30), (None, True, 90000000)])
+
+    def test_array_to_tuple_array_b(self) -> None:
         a1 = np.arange(10, dtype=np.int64).reshape(5, 2)
-        result = array2d_to_array1d(a1)
+        result = array_to_tuple_array(a1)
         assert isinstance(result[0], tuple)
         assert result[0] == (0, 1)
         self.assertIs(type(result[0][0]), np.int64)
@@ -302,37 +336,37 @@ class TestUnit(unittest.TestCase):
         self.assertEqual(tuple(result), ((0, 1), (2, 3), (4, 5), (6, 7), (8, 9)))
 
 
-    def test_array2d_to_array1d_c(self) -> None:
+    def test_array_to_tuple_array_c(self) -> None:
         a1 = np.array([["a", "b"], ["ccc", "ddd"], ["ee", "ff"]])
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [('a', 'b'), ('ccc', 'ddd'), ('ee', 'ff')])
 
-    def test_array2d_to_array1d_d(self) -> None:
+    def test_array_to_tuple_array_d(self) -> None:
         a1 = np.array([[3, 5], [10, 20], [7, 2]], dtype=np.uint8)
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [(3, 5), (10, 20), (7, 2)])
         self.assertIs(type(a2[0][0]), np.uint8)
 
-    def test_array2d_to_array1d_e(self) -> None:
+    def test_array_to_tuple_array_e(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
-        result = array2d_to_array1d(a1)
+        result = array_to_tuple_array(a1)
         self.assertEqual(result.tolist(), [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
 
     #---------------------------------------------------------------------------
-    def test_array2d_tuple_iter_a(self) -> None:
+    def test_array_to_tuple_iter_a(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(len(result), 4)
         self.assertEqual(result, [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
 
-    def test_array2d_tuple_iter_b(self) -> None:
+    def test_array_to_tuple_iter_b(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(10, 2)
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(result, [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11), (12, 13), (14, 15), (16, 17), (18, 19)])
 
-    def test_array2d_tuple_iter_c(self) -> None:
+    def test_array_to_tuple_iter_c(self) -> None:
         a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         self.assertEqual(it.__length_hint__(), 3)
         self.assertEqual(next(it), ('aaa', 'bb'))
         self.assertEqual(it.__length_hint__(), 2)
@@ -343,35 +377,63 @@ class TestUnit(unittest.TestCase):
         with self.assertRaises(StopIteration):
             next(it)
 
-    def test_array2d_tuple_iter_d(self) -> None:
+    def test_array_to_tuple_iter_d(self) -> None:
         a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         # __reversed__ not implemented
         with self.assertRaises(TypeError):
             reversed(it)
 
-    def test_array2d_tuple_iter_e(self) -> None:
+    def test_array_to_tuple_iter_e(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         del a1
         self.assertEqual(list(it), [(None, 'bb'), (None, 'dd'), (3, None)])
 
-    def test_array2d_tuple_iter_f(self) -> None:
+    def test_array_to_tuple_iter_f(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it1 = array2d_tuple_iter(a1)
+        it1 = array_to_tuple_iter(a1)
         del a1
         it2 = iter(it1)
         self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
         self.assertEqual(list(it2), []) # expected behavior
 
-    def test_array2d_tuple_iter_g(self) -> None:
+    def test_array_to_tuple_iter_g(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it1 = array2d_tuple_iter(a1)
-        it2 = array2d_tuple_iter(a1)
+        it1 = array_to_tuple_iter(a1)
+        it2 = array_to_tuple_iter(a1)
         del a1
         self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
         self.assertEqual(list(it2), [(None, 'bb'), (None, 'dd'), (3, None)])
 
+    def test_array_to_tuple_iter_1d_a(self) -> None:
+        a1 = np.array(['bb', 'c', 'aaa'])
+        result = list(array_to_tuple_iter(a1))
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result, [('bb',), ('c',), ('aaa',)])
+
+    def test_array_to_tuple_iter_1d_b(self) -> None:
+        a1 = np.array([20, -1, 8])
+        result = list(array_to_tuple_iter(a1))
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result, [(20,), (-1,), (8,)])
+
+    def test_array_to_tuple_iter_1d_c(self) -> None:
+        a1 = np.array([('a', 4), ('c', -1), ('d', 8)], dtype=object)
+        a2 = list(array_to_tuple_iter(a1))
+        self.assertEqual(len(a2), 3)
+        self.assertEqual(a2, [('a', 4), ('c', -1), ('d', 8)])
+
+    def test_array_to_tuple_iter_1d_d(self) -> None:
+        a1 = np.array([None, None, None], dtype=object)
+        a1[0] = 3
+        a1[1] = ('a', 30)
+        a1[2] = (None, True, 90000000)
+
+        a2 = list(array_to_tuple_iter(a1))
+        self.assertEqual(a2, [(3,), ('a', 30), (None, True, 90000000)])
+
+
     #---------------------------------------------------------------------------
 
     def test_isna_element_a(self) -> None: