arraykit 0.6.3__tar.gz → 0.7.1__tar.gz

{arraykit-0.6.3/arraykit.egg-info → arraykit-0.7.1}/PKG-INFO

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

{arraykit-0.6.3 → arraykit-0.7.1}/README.rst

@@ -37,6 +37,21 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+
+0.7.1
+............
+
+Extended ``array_to_tuple_array()`` and ``array_to_tuple_iter()`` to support 1D arrays.
+
+
+0.7.0
+............
+
+Added ``array_to_tuple_array()``.
+
+Added ``array_to_tuple_iter()``.
+
+
 0.6.3
 ............
 

{arraykit-0.6.3 → arraykit-0.7.1/arraykit.egg-info}/PKG-INFO

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

{arraykit-0.6.3 → arraykit-0.7.1}/setup.py

@@ -5,7 +5,7 @@ from setuptools import Extension  # type: ignore
 from setuptools import setup
 from pathlib import Path
 
-AK_VERSION = '0.6.3'
+AK_VERSION = '0.7.1'
 
 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.6.3 → arraykit-0.7.1}/src/__init__.py

@@ -28,4 +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 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.6.3 → arraykit-0.7.1}/src/__init__.pyi

@@ -161,3 +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 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.6.3 → arraykit-0.7.1}/src/_arraykit.c

@@ -37,6 +37,18 @@ const static size_t UCS4_SIZE = sizeof(Py_UCS4);
         }                                                 \
     } while (0)
 
+// Given a PyObject, raise if not an array or is not two dimensional.
+# define AK_CHECK_NUMPY_ARRAY_2D(O)                       \
+    do {                                                  \
+        AK_CHECK_NUMPY_ARRAY(O)                           \
+        int ndim = PyArray_NDIM((PyArrayObject *)O);      \
+        if (ndim != 2) {                                  \
+            return PyErr_Format(PyExc_NotImplementedError,\
+                    "Expected a 2D array, not %i.",       \
+                    ndim);                                \
+        }                                                 \
+    } while (0)
+
 // Placeholder of not implemented pathways / debugging.
 # define AK_NOT_IMPLEMENTED(msg)                        \
     do {                                                \
@@ -3511,6 +3523,215 @@ array_deepcopy(PyObject *m, PyObject *args, PyObject *kwargs)
     return AK_ArrayDeepCopy(m, (PyArrayObject*)array, memo);
 }
 
+//------------------------------------------------------------------------------
+// Given a 1D or 2D array, return a 1D object array of tuples.
+static PyObject *
+array_to_tuple_array(PyObject *Py_UNUSED(m), PyObject *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 dims[] = {num_rows};
+    // NOTE: this initializes values to NULL, not None
+    PyObject* output = PyArray_SimpleNew(1, dims, NPY_OBJECT);
+    if (output == NULL) {
+        return NULL;
+    }
+
+    PyObject** output_data = (PyObject**)PyArray_DATA((PyArrayObject*)output);
+    PyObject** p = output_data;
+    PyObject** p_end = p + num_rows;
+    npy_intp i = 0;
+    PyObject* tuple;
+    PyObject* item;
+
+    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++;
+        }
+    }
+    else { // ndim == 1
+        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, 0, item); // steals reference to item
+            *p++ = tuple; // assign with new ref, no incr needed
+            i++;
+        }
+    }
+    PyArray_CLEARFLAGS((PyArrayObject *)output, NPY_ARRAY_WRITEABLE);
+    return output;
+error:
+    p = output_data;
+    p_end = p + num_rows;
+    while (p < p_end) { // decref all tuples within array
+        Py_XDECREF(*p++); // xdec as might be NULL
+    }
+    Py_DECREF(output);
+    return NULL;
+}
+
+//------------------------------------------------------------------------------
+// ArrayToTupleIterator
+
+static PyTypeObject ATTType;
+
+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
+} ATTObject;
+
+static PyObject *
+ATT_new(PyArrayObject* array,
+        npy_intp num_rows,
+        npy_intp num_cols) {
+    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; // -1 for 1D array
+    a2dt->pos = 0;
+    return (PyObject *)a2dt;
+}
+
+static void
+ATT_dealloc(ATTObject *self) {
+    Py_DECREF((PyObject*)self->array);
+    PyObject_Del((PyObject*)self);
+}
+
+static PyObject*
+ATT_iter(ATTObject *self) {
+    Py_INCREF(self);
+    return (PyObject*)self;
+}
+
+static PyObject *
+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* item;
+        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 reference to item
+            }
+        }
+        else { // ndim == 1
+            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, 0, item); // steals reference to item
+        }
+        self->pos++;
+        return tuple;
+    }
+    return NULL;
+}
+
+// static PyObject *
+// ATT_reversed(ATTObject *self) {
+//     return ATT_new(self->bi, !self->reversed);
+// }
+
+static PyObject *
+ATT_length_hint(ATTObject *self) {
+    Py_ssize_t len = Py_MAX(0, self->num_rows - self->pos);
+    return PyLong_FromSsize_t(len);
+}
+
+static PyMethodDef ATT_methods[] = {
+    {"__length_hint__", (PyCFunction)ATT_length_hint, METH_NOARGS, NULL},
+    // {"__reversed__", (PyCFunction)ATT_reversed, METH_NOARGS, NULL},
+    {NULL},
+};
+
+static PyTypeObject ATTType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .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 *
+array_to_tuple_iter(PyObject *Py_UNUSED(m), PyObject *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 = -1; // indicate 1d
+    if (ndim == 2) {
+        num_cols = PyArray_DIM(array, 1);
+    }
+    return ATT_new(array, num_rows, num_cols);
+}
+
 //------------------------------------------------------------------------------
 // type resolution
 
@@ -5944,7 +6165,6 @@ TriMap_dealloc(TriMapObject *self) {
     if (self->many_from != NULL) {
         // decref all arrays before freeing
         for (Py_ssize_t i = 0; i < self->many_count; i++) {
-            // NOTE: using dot to get to pointer?
             Py_DECREF((PyObject*)self->many_from[i].dst);
         }
         PyMem_Free(self->many_from);
@@ -7259,6 +7479,8 @@ static PyMethodDef arraykit_methods[] =  {
             (PyCFunction)array_deepcopy,
             METH_VARARGS | METH_KEYWORDS,
             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.6.3 → arraykit-0.7.1}/test/test_util.py

@@ -22,6 +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 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
@@ -283,6 +285,131 @@ class TestUnit(unittest.TestCase):
         with self.assertRaises(TypeError):
             a2 = array_deepcopy(a1, ())
 
+    #---------------------------------------------------------------------------
+    def test_array2d_to_array1d_1d_a(self) -> None:
+        a1 = np.arange(10)
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)])
+
+    def test_array2d_to_array1d_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_array2d_to_array1d_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_array2d_to_array1d_1d_d(self) -> None:
+        a1 = np.array([('a', 10), ('b', 30), ('c', 5)], dtype=object)
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [('a', 10), ('b', 30), ('c', 5)])
+
+    def test_array2d_to_array1d_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_array2d_to_array1d_b(self) -> None:
+        a1 = np.arange(10, dtype=np.int64).reshape(5, 2)
+        result = array_to_tuple_array(a1)
+        assert isinstance(result[0], tuple)
+        assert result[0] == (0, 1)
+        self.assertIs(type(result[0][0]), np.int64)
+        self.assertFalse(result.flags.writeable)
+        self.assertEqual(tuple(result), ((0, 1), (2, 3), (4, 5), (6, 7), (8, 9)))
+
+
+    def test_array2d_to_array1d_c(self) -> None:
+        a1 = np.array([["a", "b"], ["ccc", "ddd"], ["ee", "ff"]])
+        a2 = array_to_tuple_array(a1)
+        self.assertEqual(a2.tolist(), [('a', 'b'), ('ccc', 'ddd'), ('ee', 'ff')])
+
+    def test_array2d_to_array1d_d(self) -> None:
+        a1 = np.array([[3, 5], [10, 20], [7, 2]], dtype=np.uint8)
+        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:
+        a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
+        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:
+        a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
+        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:
+        a1 = np.arange(20, dtype=np.int64).reshape(10, 2)
+        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:
+        a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
+        it = array_to_tuple_iter(a1)
+        self.assertEqual(it.__length_hint__(), 3)
+        self.assertEqual(next(it), ('aaa', 'bb'))
+        self.assertEqual(it.__length_hint__(), 2)
+        self.assertEqual(next(it), ('c', 'dd'))
+        self.assertEqual(it.__length_hint__(), 1)
+        self.assertEqual(next(it), ('ee', 'fffff'))
+        self.assertEqual(it.__length_hint__(), 0)
+        with self.assertRaises(StopIteration):
+            next(it)
+
+    def test_array2d_tuple_iter_d(self) -> None:
+        a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
+        it = array_to_tuple_iter(a1)
+        # __reversed__ not implemented
+        with self.assertRaises(TypeError):
+            reversed(it)
+
+    def test_array2d_tuple_iter_e(self) -> None:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        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:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        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:
+        a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
+        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_array2d_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_array2d_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_array2d_tuple_iter_1d_c(self) -> None:
+        a1 = np.array([('a', 4), ('c', -1), ('d', 8)], dtype=object)
+        result = list(array_to_tuple_iter(a1))
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result, [('a', 4), ('c', -1), ('d', 8)])
+
     #---------------------------------------------------------------------------
 
     def test_isna_element_a(self) -> None: