arraykit 0.6.3__tar.gz → 0.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.6.3
+Version: 0.7.0
 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.0}/README.rst

@@ -37,6 +37,14 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+0.7.0
+............
+
+Added ``array2d_to_array1d()``.
+
+Added ``array2d_tuple_iter()``.
+
+
 0.6.3
 ............
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arraykit
-Version: 0.6.3
+Version: 0.7.0
 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.0}/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.0'
 
 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.0}/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 array2d_to_array1d as array2d_to_array1d
+from ._arraykit import array2d_tuple_iter as array2d_tuple_iter
 from ._arraykit import nonzero_1d as nonzero_1d

{arraykit-0.6.3 → arraykit-0.7.0}/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 array2d_to_array1d(__array: np.ndarray) -> np.ndarray: ...
+def array2d_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...

{arraykit-0.6.3 → arraykit-0.7.0}/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,167 @@ array_deepcopy(PyObject *m, PyObject *args, PyObject *kwargs)
     return AK_ArrayDeepCopy(m, (PyArrayObject*)array, memo);
 }
 
+//------------------------------------------------------------------------------
+// Given a 2D array, return a 1D object array of tuples.
+static PyObject *
+array2d_to_array1d(PyObject *Py_UNUSED(m), PyObject *a)
+{
+    AK_CHECK_NUMPY_ARRAY_2D(a);
+    PyArrayObject *input_array = (PyArrayObject *)a;
+
+    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);
+    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;
+    npy_intp j;
+    PyObject* tuple;
+    PyObject* item;
+
+    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++;
+    }
+    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;
+}
+
+//------------------------------------------------------------------------------
+// Array2DTuple Iterator
+
+static PyTypeObject A2DTupleType;
+
+typedef struct A2DTupleObject {
+    PyObject_HEAD
+    PyArrayObject* array;
+    npy_intp num_rows;
+    npy_intp num_cols;
+    Py_ssize_t pos; // current index state, mutated in-place
+} A2DTupleObject;
+
+static PyObject *
+A2DTuple_new(PyArrayObject* array,
+        npy_intp num_rows,
+        npy_intp num_cols) {
+    A2DTupleObject* a2dt = PyObject_New(A2DTupleObject, &A2DTupleType);
+    if (!a2dt) {
+        return NULL;
+    }
+    Py_INCREF((PyObject*)array);
+    a2dt->array = array;
+    a2dt->num_rows = num_rows;
+    a2dt->num_cols = num_cols;
+    a2dt->pos = 0;
+    return (PyObject *)a2dt;
+}
+
+static void
+A2DTuple_dealloc(A2DTupleObject *self) {
+    Py_DECREF((PyObject*)self->array);
+    PyObject_Del((PyObject*)self);
+}
+
+static PyObject*
+A2DTuple_iter(A2DTupleObject *self) {
+    Py_INCREF(self);
+    return (PyObject*)self;
+}
+
+static PyObject *
+A2DTuple_iternext(A2DTupleObject *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;
+        }
+        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
+        }
+        self->pos++;
+        return tuple;
+    }
+    return NULL;
+}
+
+// static PyObject *
+// A2DTuple_reversed(A2DTupleObject *self) {
+//     return A2DTuple_new(self->bi, !self->reversed);
+// }
+
+static PyObject *
+A2DTuple_length_hint(A2DTupleObject *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},
+    {NULL},
+};
+
+static PyTypeObject A2DTupleType = {
+    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",
+};
+
+// Given a 2D array, return an iterator of row tuples.
+static PyObject *
+array2d_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
+{
+    AK_CHECK_NUMPY_ARRAY_2D(a);
+    PyArrayObject* array = (PyArrayObject *)a;
+    npy_intp num_rows = PyArray_DIM(array, 0);
+    npy_intp num_cols = PyArray_DIM(array, 1);
+    return A2DTuple_new(array, num_rows, num_cols);
+}
+
+
 //------------------------------------------------------------------------------
 // type resolution
 
@@ -5944,7 +6117,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 +7431,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},
     {"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.0}/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 array2d_to_array1d
+from arraykit import array2d_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,93 @@ class TestUnit(unittest.TestCase):
         with self.assertRaises(TypeError):
             a2 = array_deepcopy(a1, ())
 
+    #---------------------------------------------------------------------------
+    def test_array2d_to_array1d_dummy(self) -> None:
+        a1 = np.arange(10)
+        with self.assertRaises(NotImplementedError):
+            # 1 dimensional
+            _ = array2d_to_array1d(a1)
+
+    def test_array2d_to_array1d_b(self) -> None:
+        a1 = np.arange(10, dtype=np.int64).reshape(5, 2)
+        result = array2d_to_array1d(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 = array2d_to_array1d(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 = array2d_to_array1d(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 = array2d_to_array1d(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(array2d_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(array2d_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 = array2d_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 = array2d_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 = array2d_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 = array2d_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 = array2d_tuple_iter(a1)
+        it2 = array2d_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_isna_element_a(self) -> None: