arraykit 1.7.0__tar.gz → 1.9.0__tar.gz

{arraykit-1.7.0/arraykit.egg-info → arraykit-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraykit
-Version: 1.7.0
+Version: 1.9.0
 Summary: Array utilities for StaticFrame
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland
 License: MIT
@@ -64,6 +64,18 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.9.0
+............
+
+Added ``FrozenAutoMap.get_all_fill()`` and ``TriMap.register_many_from_one()``.
+
+
+1.8.0
+............
+
+Added ``fill_directional()``.
+
+
 1.7.0
 ............
 

{arraykit-1.7.0 → arraykit-1.9.0}/README.rst

@@ -35,6 +35,18 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.9.0
+............
+
+Added ``FrozenAutoMap.get_all_fill()`` and ``TriMap.register_many_from_one()``.
+
+
+1.8.0
+............
+
+Added ``fill_directional()``.
+
+
 1.7.0
 ............
 

arraykit-1.9.0/VERSION

@@ -0,0 +1,2 @@
+1.9.0
+

{arraykit-1.7.0 → arraykit-1.9.0/arraykit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraykit
-Version: 1.7.0
+Version: 1.9.0
 Summary: Array utilities for StaticFrame
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland
 License: MIT
@@ -64,6 +64,18 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.9.0
+............
+
+Added ``FrozenAutoMap.get_all_fill()`` and ``TriMap.register_many_from_one()``.
+
+
+1.8.0
+............
+
+Added ``fill_directional()``.
+
+
 1.7.0
 ............
 

{arraykit-1.7.0 → arraykit-1.9.0}/arraykit.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ test/test_delimited_to_arrays.py
 test/test_delimited_to_arrays_integration.py
 test/test_delimited_to_arrays_property.py
 test/test_factorize.py
+test/test_fill_directional.py
 test/test_group_ordering.py
 test/test_nonzero_1d.py
 test/test_nonzero_1d_property.py

{arraykit-1.7.0 → arraykit-1.9.0}/src/__init__.py

@@ -27,6 +27,7 @@ from ._arraykit import get_new_indexers_and_screen as get_new_indexers_and_scree
 from ._arraykit import write_array_to_file as write_array_to_file
 from ._arraykit import factorize as factorize
 from ._arraykit import group_ordering as group_ordering
+from ._arraykit import fill_directional as fill_directional
 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

{arraykit-1.7.0 → arraykit-1.9.0}/src/__init__.pyi

@@ -53,6 +53,7 @@ class TriMap:
     def __init__(self, /, src_len: int, dst_len: int) -> None: ...
     def __repr__(self) -> str: ...
     def register_one(self, /, src_from: int, dst_from: int) -> None: ...
+    def register_many_from_one(self, __dst_pos: np.ndarray) -> None: ...
     def register_unmatched_dst(self) -> None: ...
     def register_many(self, /, src_from: int, dst_from: np.ndarray) -> None: ...
     def finalize(self) -> None: ...
@@ -142,6 +143,7 @@ class FrozenAutoMap:
     def items(self) -> tp.Iterator[tuple[_TLabel, int]]: ...
     def values(self) -> tp.Iterator[int]: ...
     def get_all(self, __key: list[_TLabel] | np.ndarray) -> np.ndarray: ...
+    def get_all_fill(self, __key: list[_TLabel] | np.ndarray) -> np.ndarray: ...
     def get_any(self, __key: list[_TLabel] | np.ndarray) -> list[int]: ...
     def __iter__(self) -> tp.Iterator[_TLabel]: ...
     def __getitem__(self, __key: tp.Any) -> int: ...
@@ -230,6 +232,14 @@ def factorize(
 def group_ordering(
     codes: np.ndarray, *, size: tp.Optional[int] = ...
 ) -> tp.Tuple[np.ndarray, np.ndarray]: ...
+def fill_directional(
+    array: np.ndarray,
+    target: np.ndarray,
+    *,
+    forward: bool = ...,
+    axis: int = ...,
+    limit: int = ...,
+) -> np.ndarray: ...
 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: ...

{arraykit-1.7.0 → arraykit-1.9.0}/src/_arraykit.c

@@ -78,6 +78,10 @@ static PyMethodDef arraykit_methods[] =  {
             (PyCFunction)group_ordering,
             METH_VARARGS | METH_KEYWORDS,
             NULL},
+    {"fill_directional",
+            (PyCFunction)fill_directional,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
     {NULL},
 };
 

{arraykit-1.7.0 → arraykit-1.9.0}/src/auto_map.c

@@ -1919,6 +1919,209 @@ fam_get_all(FAMObject *self, PyObject *key) {
 # undef GET_ALL_FLEXIBLE
 
 
+// Fill variants of the GET_ALL_* macros: on a miss, write -1 into the output slot and
+// continue (instead of raising KeyError). Depend on self, key_size, key_array, i, b, array.
+# define GET_ALL_FILL_SCALARS(npy_type_src, npy_type_dst, kat, lookup_func, hash_func, post_deref) \
+{                                                                      \
+    npy_type_dst v;                                                    \
+    Py_ssize_t table_pos;                                             \
+    for (; i < key_size; i++) {                                        \
+        v = post_deref(*(npy_type_src*)PyArray_GETPTR1(key_array, i)); \
+        table_pos = lookup_func(self, v, hash_func(v), kat);           \
+        if (table_pos < 0 || (self->table[table_pos].hash == -1)) {    \
+            if (PyErr_Occurred()) {                                    \
+                Py_DECREF(array);                                      \
+                return NULL;                                           \
+            }                                                          \
+            b[i] = -1;                                                 \
+            continue;                                                  \
+        }                                                              \
+        b[i] = (npy_int64)self->table[table_pos].keys_pos;             \
+    }                                                                  \
+}                                                                      \
+
+# define GET_ALL_FILL_DT64(npy_type_src, npy_type_dst, kat, lookup_func, hash_func) \
+{                                                                      \
+    npy_type_dst v;                                                    \
+    Py_ssize_t table_pos;                                             \
+    for (; i < key_size; i++) {                                        \
+        v = *(npy_type_src*)PyArray_GETPTR1(key_array, i);             \
+        table_pos = lookup_func(self, v, hash_func(v), kat);           \
+        if (table_pos < 0 || (self->table[table_pos].hash == -1)) {    \
+            if (PyErr_Occurred()) {                                    \
+                Py_DECREF(array);                                      \
+                return NULL;                                           \
+            }                                                          \
+            b[i] = -1;                                                 \
+            continue;                                                  \
+        }                                                              \
+        b[i] = (npy_int64)self->table[table_pos].keys_pos;             \
+    }                                                                  \
+}                                                                      \
+
+# define GET_ALL_FILL_FLEXIBLE(char_type, get_end_func, lookup_func, hash_func) \
+{                                                                             \
+    char_type* v;                                                             \
+    Py_ssize_t dt_size = PyArray_ITEMSIZE(key_array) / sizeof(char_type);     \
+    Py_ssize_t k_size;                                                        \
+    Py_ssize_t table_pos;                                                     \
+    for (; i < key_size; i++) {                                               \
+        v = (char_type*)PyArray_GETPTR1(key_array, i);                        \
+        k_size = get_end_func(v, dt_size) - v;                                \
+        table_pos = lookup_func(self, v, k_size, hash_func(v, k_size));       \
+        if (table_pos < 0 || (self->table[table_pos].hash == -1)) {           \
+            if (PyErr_Occurred()) {                                           \
+                Py_DECREF(array);                                             \
+                return NULL;                                                  \
+            }                                                                 \
+            b[i] = -1;                                                        \
+            continue;                                                         \
+        }                                                                     \
+        b[i] = (npy_int64)self->table[table_pos].keys_pos;                    \
+    }                                                                         \
+}                                                                             \
+
+// Given a list or array of keys, return an input-aligned int64 array of looked-up
+// positions, with -1 for any key not found (never raises KeyError). This is the
+// "vectorized get with default -1" needed by left/outer joins. Immutable output.
+static PyObject *
+fam_get_all_fill(FAMObject *self, PyObject *key) {
+    Py_ssize_t key_size = 0;
+    Py_ssize_t keys_pos = -1;
+    PyObject* k = NULL;
+    PyObject *array = NULL;
+    Py_ssize_t i = 0;
+
+    int key_is_list;
+    if (PyList_CheckExact(key)) {
+        key_is_list = 1;
+        key_size = PyList_GET_SIZE(key);
+    }
+    else if (PyArray_Check(key)) {
+        key_is_list = 0;
+        key_size = PyArray_SIZE((PyArrayObject *)key);
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "Must provide a list or array.");
+        return NULL;
+    }
+
+    npy_intp dims[] = {key_size};
+    array = PyArray_EMPTY(1, dims, NPY_INT64, 0);
+    if (array == NULL) {
+        return NULL;
+    }
+    npy_int64* b = (npy_int64*)PyArray_DATA((PyArrayObject*)array);
+
+    if (key_is_list) {
+        for (; i < key_size; i++) {
+            k = PyList_GET_ITEM(key, i); // borrow
+            keys_pos = lookup(self, k);
+            if (keys_pos < 0) {
+                if (PyErr_Occurred()) {
+                    Py_DECREF(array);
+                    return NULL;
+                }
+                b[i] = -1;
+                continue;
+            }
+            b[i] = (npy_int64)keys_pos;
+        }
+    }
+    else { // key is an array
+        PyArrayObject* key_array = (PyArrayObject *)key;
+        int key_array_t = PyArray_TYPE(key_array);
+        int use_typed = kat_is_kind(self->keys_array_type, PyArray_DESCR(key_array)->kind);
+        if (use_typed && key_array_t == NPY_DATETIME) {
+            NPY_DATETIMEUNIT key_unit = AK_dt_unit_from_array(key_array);
+            if (!kat_is_datetime_unit(self->keys_array_type, key_unit)) {
+                // mismatched units: use the coercing scalar path (below) rather than
+                // raising, so equal instants still resolve (and true misses give -1)
+                use_typed = 0;
+            }
+        }
+        if (use_typed) {
+            switch (key_array_t) {
+                case NPY_INT64:
+                    GET_ALL_FILL_SCALARS(npy_int64, npy_int64, KAT_INT64, lookup_hash_int, int_to_hash,);
+                    break;
+                case NPY_INT32:
+                    GET_ALL_FILL_SCALARS(npy_int32, npy_int64, KAT_INT32, lookup_hash_int, int_to_hash,);
+                    break;
+                case NPY_INT16:
+                    GET_ALL_FILL_SCALARS(npy_int16, npy_int64, KAT_INT16, lookup_hash_int, int_to_hash,);
+                    break;
+                case NPY_INT8:
+                    GET_ALL_FILL_SCALARS(npy_int8, npy_int64, KAT_INT8, lookup_hash_int, int_to_hash,);
+                    break;
+                case NPY_UINT64:
+                    GET_ALL_FILL_SCALARS(npy_uint64, npy_uint64, KAT_UINT64, lookup_hash_uint, uint_to_hash,);
+                    break;
+                case NPY_UINT32:
+                    GET_ALL_FILL_SCALARS(npy_uint32, npy_uint64, KAT_UINT32, lookup_hash_uint, uint_to_hash,);
+                    break;
+                case NPY_UINT16:
+                    GET_ALL_FILL_SCALARS(npy_uint16, npy_uint64, KAT_UINT16, lookup_hash_uint, uint_to_hash,);
+                    break;
+                case NPY_UINT8:
+                    GET_ALL_FILL_SCALARS(npy_uint8, npy_uint64, KAT_UINT8, lookup_hash_uint, uint_to_hash,);
+                    break;
+                case NPY_FLOAT64:
+                    GET_ALL_FILL_SCALARS(npy_double, npy_double, KAT_FLOAT64, lookup_hash_double, double_to_hash,);
+                    break;
+                case NPY_FLOAT32:
+                    GET_ALL_FILL_SCALARS(npy_float, npy_double, KAT_FLOAT32, lookup_hash_double, double_to_hash,);
+                    break;
+                case NPY_FLOAT16:
+                    GET_ALL_FILL_SCALARS(npy_half, npy_double, KAT_FLOAT16, lookup_hash_double, double_to_hash, npy_half_to_double);
+                    break;
+                case NPY_UNICODE:
+                    GET_ALL_FILL_FLEXIBLE(Py_UCS4, ucs4_get_end_p, lookup_hash_unicode, unicode_to_hash);
+                    break;
+                case NPY_STRING:
+                    GET_ALL_FILL_FLEXIBLE(char, char_get_end_p, lookup_hash_string, string_to_hash);
+                    break;
+                case NPY_DATETIME:
+                    GET_ALL_FILL_DT64(npy_int64, npy_int64, KAT_INT64, lookup_hash_int, int_to_hash);
+                    break;
+                default:
+                    use_typed = 0; // unhandled kind: fall to the scalar path below
+                    break;
+            }
+        }
+        if (!use_typed) {
+            for (; i < key_size; i++) {
+                k = PyArray_ToScalar(PyArray_GETPTR1(key_array, i), key_array);
+                if (k == NULL) {
+                    Py_DECREF(array);
+                    return NULL;
+                }
+                keys_pos = lookup(self, k);
+                if (keys_pos < 0) {
+                    if (PyErr_Occurred()) {
+                        Py_DECREF(k);
+                        Py_DECREF(array);
+                        return NULL;
+                    }
+                    Py_DECREF(k);
+                    b[i] = -1;
+                    continue;
+                }
+                Py_DECREF(k);
+                b[i] = (npy_int64)keys_pos;
+            }
+        }
+    }
+
+    PyArray_CLEARFLAGS((PyArrayObject *)array, NPY_ARRAY_WRITEABLE);
+    return array;
+}
+
+# undef GET_ALL_FILL_SCALARS
+# undef GET_ALL_FILL_DT64
+# undef GET_ALL_FILL_FLEXIBLE
+
+
 static inline int
 append_ssize_t(
     PyObject* list,
@@ -2974,6 +3177,7 @@ static PyMethodDef fam_methods[] = {
     {"keys", (PyCFunction) fam_keys, METH_NOARGS, NULL},
     {"values", (PyCFunction) fam_values, METH_NOARGS, NULL},
     {"get_all", (PyCFunction) fam_get_all, METH_O, NULL},
+    {"get_all_fill", (PyCFunction) fam_get_all_fill, METH_O, NULL},
     {"get_any", (PyCFunction) fam_get_any, METH_O, NULL},
     {NULL},
 };

{arraykit-1.7.0 → arraykit-1.9.0}/src/methods.c

@@ -1128,6 +1128,163 @@ fail:
     return NULL;
 }
 
+// Fill one strided lane in place: walk positions in the fill direction, carrying
+// the most recent non-target value into each target position (subject to `limit`
+// consecutive fills per run). `elem_base`/`elem_stride` address elements in bytes;
+// `target_base`/`target_stride` address the aligned Boolean target lane. Object arrays
+// duplicate the carried PyObject* with balanced refcounts; all other dtypes memcpy
+// the itemsize bytes. Leading targets (no prior source) are left unchanged.
+static inline void
+AK_fill_lane(
+        char *elem_base,
+        npy_intp elem_stride,
+        const npy_bool *target_base,
+        npy_intp target_stride,
+        npy_intp length,
+        npy_intp itemsize,
+        int is_object,
+        int forward,
+        npy_intp limit)
+{
+    char *last_valid = NULL;
+    npy_intp count = 0;
+    for (npy_intp k = 0; k < length; k++) {
+        npy_intp pos = forward ? k : (length - 1 - k);
+        char *elem = elem_base + pos * elem_stride;
+        if (target_base[pos * target_stride]) {
+            if (last_valid != NULL && (limit == 0 || count < limit)) {
+                if (is_object) {
+                    PyObject **dst = (PyObject**)elem;
+                    PyObject **src = (PyObject**)last_valid;
+                    Py_INCREF(*src);
+                    Py_XDECREF(*dst);
+                    *dst = *src;
+                }
+                else {
+                    memcpy(elem, last_valid, (size_t)itemsize);
+                }
+                count++;
+            }
+            // else: leading target (no source yet) or limit reached; leave as-is
+        }
+        else {
+            last_valid = elem;
+            count = 0;
+        }
+    }
+}
+
+static char *fill_directional_kwarg_names[] = {
+    "array",
+    "target",
+    "forward",
+    "axis",
+    "limit",
+    NULL
+};
+
+// Directional (forward or backward) fill of `array` along `axis`, replacing each
+// position flagged True in the Boolean `target` mask with the last (forward) or
+// next (backward) non-target value. A single O(n) pass per lane; `limit` caps the
+// number of consecutive fills per run (0 == unlimited). The target mask is supplied
+// by the caller (e.g. isna/isfalsy), keeping this dtype- and predicate-agnostic.
+// Returns a new, immutable, C-contiguous array.
+PyObject *
+fill_directional(PyObject *Py_UNUSED(m), PyObject *args, PyObject *kwargs)
+{
+    PyArrayObject *array = NULL;
+    PyArrayObject *target = NULL;
+    int forward = 1;
+    int axis = 0;
+    Py_ssize_t limit = 0;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+            "O!O!|$pin:fill_directional",
+            fill_directional_kwarg_names,
+            &PyArray_Type, &array,
+            &PyArray_Type, &target,
+            &forward,
+            &axis,
+            &limit
+            )) {
+        return NULL;
+    }
+
+    int ndim = PyArray_NDIM(array);
+    if (ndim != 1 && ndim != 2) {
+        PyErr_SetString(PyExc_ValueError, "array must be 1- or 2-dimensional");
+        return NULL;
+    }
+    if (PyArray_TYPE(target) != NPY_BOOL) {
+        PyErr_SetString(PyExc_ValueError, "target must be a Boolean array");
+        return NULL;
+    }
+    if (PyArray_NDIM(target) != ndim) {
+        PyErr_SetString(PyExc_ValueError,
+                "target must match the dimensionality of array");
+        return NULL;
+    }
+    for (int i = 0; i < ndim; i++) {
+        if (PyArray_DIM(target, i) != PyArray_DIM(array, i)) {
+            PyErr_SetString(PyExc_ValueError,
+                    "target must match the shape of array");
+            return NULL;
+        }
+    }
+    if (!PyArray_IS_C_CONTIGUOUS(target)) {
+        PyErr_SetString(PyExc_ValueError, "target must be C-contiguous");
+        return NULL;
+    }
+    if (ndim == 2 && axis != 0 && axis != 1) {
+        PyErr_SetString(PyExc_ValueError, "axis must be 0 or 1");
+        return NULL;
+    }
+    if (limit < 0) {
+        PyErr_SetString(PyExc_ValueError, "limit must be non-negative");
+        return NULL;
+    }
+
+    // A C-order copy is the result: non-target positions are already correct, and
+    // its layout aligns element-for-element with the C-contiguous target mask.
+    PyObject *out = PyArray_NewCopy(array, NPY_CORDER);
+    if (!out) {
+        return NULL;
+    }
+
+    int is_object = PyArray_TYPE(array) == NPY_OBJECT;
+    npy_intp itemsize = PyArray_ITEMSIZE((PyArrayObject*)out);
+
+    char *out_data = (char*)PyArray_DATA((PyArrayObject*)out);
+    const npy_bool *target_data = (const npy_bool*)PyArray_DATA(target);
+
+    if (ndim == 1) {
+        npy_intp n = PyArray_DIM((PyArrayObject*)out, 0);
+        AK_fill_lane(out_data, itemsize, target_data, 1, n,
+                itemsize, is_object, forward, limit);
+    }
+    else {
+        npy_intp rows = PyArray_DIM((PyArrayObject*)out, 0);
+        npy_intp cols = PyArray_DIM((PyArrayObject*)out, 1);
+        if (axis == 0) {
+            // fill down each column: elements stride by a full row (cols * itemsize)
+            for (npy_intp c = 0; c < cols; c++) {
+                AK_fill_lane(out_data + c * itemsize, cols * itemsize,
+                        target_data + c, cols, rows, itemsize, is_object, forward, limit);
+            }
+        }
+        else {
+            // fill across each row: elements are contiguous
+            for (npy_intp r = 0; r < rows; r++) {
+                AK_fill_lane(out_data + r * cols * itemsize, itemsize,
+                        target_data + r * cols, 1, cols, itemsize, is_object, forward, limit);
+            }
+        }
+    }
+
+    PyArray_CLEARFLAGS((PyArrayObject*)out, NPY_ARRAY_WRITEABLE);
+    return out;
+}
+
 PyObject *
 dtype_from_element(PyObject *Py_UNUSED(m), PyObject *arg)
 {

{arraykit-1.7.0 → arraykit-1.9.0}/src/methods.h

@@ -72,6 +72,9 @@ first_true_2d(PyObject *Py_UNUSED(m), PyObject *args, PyObject *kwargs);
 PyObject *
 group_ordering(PyObject *Py_UNUSED(m), PyObject *args, PyObject *kwargs);
 
+PyObject *
+fill_directional(PyObject *Py_UNUSED(m), PyObject *args, PyObject *kwargs);
+
 PyObject *
 dtype_from_element(PyObject *Py_UNUSED(m), PyObject *arg);
 

{arraykit-1.7.0 → arraykit-1.9.0}/src/tri_map.c

@@ -269,6 +269,47 @@ TriMap_register_one(TriMapObject *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
+// Bulk one-to-one registration: given an int64 array `dst_pos` of length `src_len`,
+// register src position i to dst position dst_pos[i] (or -1 for an unmatched src) in a
+// single C loop -- equivalent to calling register_one(i, dst_pos[i]) for each i, but
+// without per-element Python overhead. Used by the hash-join fast path.
+PyObject *
+TriMap_register_many_from_one(TriMapObject *self, PyObject *arg) {
+    if (self->finalized) {
+        PyErr_SetString(PyExc_RuntimeError, "Cannot register post finalization");
+        return NULL;
+    }
+    if (!PyArray_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "Must provide an array");
+        return NULL;
+    }
+    PyArrayObject* a = (PyArrayObject*)arg;
+    if (PyArray_TYPE(a) != NPY_INT64) {
+        PyErr_SetString(PyExc_ValueError, "Array must be of type int64");
+        return NULL;
+    }
+    if (PyArray_NDIM(a) != 1) {
+        PyErr_SetString(PyExc_ValueError, "Array must be 1-dimensional");
+        return NULL;
+    }
+    if (!PyArray_IS_C_CONTIGUOUS(a)) {
+        PyErr_SetString(PyExc_ValueError, "Array must be contiguous");
+        return NULL;
+    }
+    npy_intp n = PyArray_SIZE(a);
+    if (n != self->src_len) {
+        PyErr_SetString(PyExc_ValueError, "Array length must equal src_len");
+        return NULL;
+    }
+    const npy_int64* d = (npy_int64*)PyArray_DATA(a);
+    for (npy_intp i = 0; i < n; i++) {
+        if (AK_TM_register_one(self, (Py_ssize_t)i, (Py_ssize_t)d[i])) {
+            return NULL;
+        }
+    }
+    Py_RETURN_NONE;
+}
+
 PyObject *
 TriMap_register_unmatched_dst(TriMapObject *self) {
     if (self->finalized) {
@@ -1358,6 +1399,7 @@ TriMap_map_dst_fill(TriMapObject *self, PyObject *args) {
 
 static PyMethodDef TriMap_methods[] = {
     {"register_one", (PyCFunction)TriMap_register_one, METH_VARARGS, NULL},
+    {"register_many_from_one", (PyCFunction)TriMap_register_many_from_one, METH_O, NULL},
     {"register_unmatched_dst", (PyCFunction)TriMap_register_unmatched_dst, METH_NOARGS, NULL},
     {"register_many", (PyCFunction)TriMap_register_many, METH_VARARGS, NULL},
     {"finalize", (PyCFunction)TriMap_finalize, METH_NOARGS, NULL},

{arraykit-1.7.0 → arraykit-1.9.0}/test/test_auto_map.py

@@ -916,6 +916,109 @@ def test_fam_array_get_all_m3():
     assert post2.tolist() == [2, 1]
 
 
+# -------------------------------------------------------------------------------
+# get_all_fill: input-aligned lookup, -1 for misses (never raises KeyError)
+
+
+def test_fam_array_get_all_fill_int_a():
+    a1 = np.array((10, 20, 30, 40), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    # all present -> identical to get_all
+    keys = np.array([30, 10, 40], dtype=np.int64)
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [2, 0, 3]
+    assert fam.get_all_fill(keys).tolist() == fam.get_all(keys).tolist()
+
+
+def test_fam_array_get_all_fill_int_missing():
+    a1 = np.array((10, 20, 30, 40), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([30, 99, 10, 77], dtype=np.int64)
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [2, -1, 0, -1]
+
+
+def test_fam_array_get_all_fill_immutable_and_dtype():
+    a1 = np.array((10, 20, 30), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([10], dtype=np.int64)
+    keys.flags.writeable = False
+    post = fam.get_all_fill(keys)
+    assert not post.flags.writeable
+    assert post.dtype == np.dtype(np.int64)
+
+
+def test_fam_array_get_all_fill_empty():
+    a1 = np.array((10, 20), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([], dtype=np.int64)
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == []
+
+
+def test_fam_array_get_all_fill_all_missing():
+    a1 = np.array((10, 20), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([1, 2, 3], dtype=np.int64)
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [-1, -1, -1]
+
+
+def test_fam_array_get_all_fill_kind_mismatch():
+    # int map queried with a float array -> scalar fallback, -1 for misses
+    a1 = np.array((10, 20, 30), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([10.0, 15.0, 30.0], dtype=np.float64)
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [0, -1, 2]
+
+
+def test_fam_array_get_all_fill_unicode():
+    a1 = np.array(['a', 'bb', 'c'])
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array(['c', 'zz', 'a'])
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [2, -1, 0]
+
+
+def test_fam_array_get_all_fill_bytes():
+    a1 = np.array([b'a', b'bb', b'c'], dtype='S2')
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array([b'c', b'zz', b'a'], dtype='S2')
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [2, -1, 0]
+
+
+def test_fam_array_get_all_fill_datetime():
+    a1 = np.array(['2020-01', '2021-06', '2022-03'], dtype='datetime64[M]')
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    keys = np.array(['2022-03', '1999-12', '2020-01'], dtype='datetime64[M]')
+    keys.flags.writeable = False
+    assert fam.get_all_fill(keys).tolist() == [2, -1, 0]
+
+
+def test_fam_array_get_all_fill_object_list():
+    fam = FrozenAutoMap([('x',), ('y',)])
+    assert fam.get_all_fill([('y',), ('z',), ('x',)]).tolist() == [1, -1, 0]
+
+
+def test_fam_array_get_all_fill_bad_type():
+    a1 = np.array((10, 20), dtype=np.int64)
+    a1.flags.writeable = False
+    fam = FrozenAutoMap(a1)
+    with pytest.raises(TypeError):
+        fam.get_all_fill('a')
+
+
 # -------------------------------------------------------------------------------
 
 

arraykit-1.9.0/test/test_fill_directional.py

@@ -0,0 +1,229 @@
+import sys
+import unittest
+
+import numpy as np
+from arraykit import fill_directional
+
+
+def reference(array, target, *, forward=True, axis=0, limit=0):
+    """Pure-Python reference: carry the last (forward) or next (backward) non-target
+    value across target runs, capped at `limit` consecutive fills."""
+    out = array.copy()
+
+    def fill_lane(vals, tgt):
+        last = None
+        count = 0
+        order = range(len(vals)) if forward else range(len(vals) - 1, -1, -1)
+        for i in order:
+            if tgt[i]:
+                if last is not None and (limit == 0 or count < limit):
+                    vals[i] = last
+                    count += 1
+            else:
+                last = vals[i]
+                count = 0
+
+    if array.ndim == 1:
+        fill_lane(out, target)
+    elif axis == 0:
+        for c in range(out.shape[1]):
+            col = out[:, c].copy()
+            fill_lane(col, target[:, c])
+            out[:, c] = col
+    else:
+        for r in range(out.shape[0]):
+            row = out[r, :].copy()
+            fill_lane(row, target[r, :])
+            out[r, :] = row
+    return out
+
+
+class TestUnit(unittest.TestCase):
+    # ------------------------------------------------------------------
+    # basic 1D behavior
+
+    def test_forward_1d(self) -> None:
+        a = np.array([1.0, np.nan, np.nan, 4.0, np.nan])
+        t = np.isnan(a)
+        post = fill_directional(a, t)
+        self.assertEqual(post.tolist(), [1.0, 1.0, 1.0, 4.0, 4.0])
+
+    def test_backward_1d(self) -> None:
+        a = np.array([1.0, np.nan, np.nan, 4.0, np.nan])
+        t = np.isnan(a)
+        post = fill_directional(a, t, forward=False)
+        # trailing target has no source and stays NaN
+        self.assertTrue(
+            np.array_equal(post, [1.0, 4.0, 4.0, 4.0, np.nan], equal_nan=True)
+        )
+
+    def test_leading_target_unchanged(self) -> None:
+        a = np.array([np.nan, np.nan, 3.0, np.nan])
+        post = fill_directional(a, np.isnan(a))
+        self.assertTrue(
+            np.array_equal(post, [np.nan, np.nan, 3.0, 3.0], equal_nan=True)
+        )
+
+    def test_all_target(self) -> None:
+        a = np.array([np.nan, np.nan, np.nan])
+        post = fill_directional(a, np.isnan(a))
+        self.assertTrue(np.array_equal(post, a, equal_nan=True))
+
+    def test_no_target(self) -> None:
+        a = np.arange(5.0)
+        post = fill_directional(a, np.zeros(5, dtype=bool))
+        self.assertEqual(post.tolist(), a.tolist())
+
+    def test_empty(self) -> None:
+        a = np.array([], dtype=float)
+        post = fill_directional(a, np.array([], dtype=bool))
+        self.assertEqual(len(post), 0)
+
+    # ------------------------------------------------------------------
+    # limit
+
+    def test_limit_forward(self) -> None:
+        a = np.array([1.0, np.nan, np.nan, np.nan, 5.0])
+        post = fill_directional(a, np.isnan(a), limit=1)
+        self.assertTrue(
+            np.array_equal(post, [1.0, 1.0, np.nan, np.nan, 5.0], equal_nan=True)
+        )
+
+    def test_limit_resets_per_run(self) -> None:
+        a = np.array([1.0, np.nan, 3.0, np.nan, np.nan, 6.0])
+        post = fill_directional(a, np.isnan(a), limit=1)
+        self.assertTrue(
+            np.array_equal(post, [1.0, 1.0, 3.0, 3.0, np.nan, 6.0], equal_nan=True)
+        )
+
+    # ------------------------------------------------------------------
+    # dtypes
+
+    def test_int(self) -> None:
+        a = np.array([5, 0, 0, 8, 0])
+        t = np.array([False, True, True, False, True])
+        self.assertEqual(fill_directional(a, t).tolist(), [5, 5, 5, 8, 8])
+
+    def test_object(self) -> None:
+        a = np.array([None, 'a', None, 'b', None, None], dtype=object)
+        t = np.array([v is None for v in a])
+        post = fill_directional(a, t)
+        self.assertEqual(post.tolist(), [None, 'a', 'a', 'b', 'b', 'b'])
+
+    def test_object_no_refcount_leak(self) -> None:
+        marker = object()
+        a = np.array([marker, None, None, marker, None], dtype=object)
+        t = np.array([False, True, True, False, True])
+        base = sys.getrefcount(marker)
+        for _ in range(2000):
+            post = fill_directional(a, t)
+            del post
+        self.assertEqual(sys.getrefcount(marker), base)
+
+    def test_datetime(self) -> None:
+        a = np.array(['2020-01-01', 'NaT', '2020-01-03'], dtype='datetime64[D]')
+        t = np.isnat(a)
+        post = fill_directional(a, t)
+        self.assertEqual(
+            post.tolist(),
+            np.array(
+                ['2020-01-01', '2020-01-01', '2020-01-03'], dtype='datetime64[D]'
+            ).tolist(),
+        )
+
+    # ------------------------------------------------------------------
+    # 2D
+
+    def test_2d_axis0(self) -> None:
+        a = np.array([[1.0, np.nan], [np.nan, 5.0], [3.0, np.nan]])
+        post = fill_directional(a, np.isnan(a), axis=0)
+        self.assertTrue(
+            np.array_equal(post, [[1.0, np.nan], [1.0, 5.0], [3.0, 5.0]], equal_nan=True)
+        )
+
+    def test_2d_axis1(self) -> None:
+        a = np.array([[1.0, np.nan, 3.0], [np.nan, np.nan, 6.0]])
+        post = fill_directional(a, np.isnan(a), axis=1)
+        self.assertTrue(
+            np.array_equal(
+                post, [[1.0, 1.0, 3.0], [np.nan, np.nan, 6.0]], equal_nan=True
+            )
+        )
+
+    # ------------------------------------------------------------------
+    # immutability
+
+    def test_immutable(self) -> None:
+        a = np.array([1.0, np.nan, 3.0])
+        post = fill_directional(a, np.isnan(a))
+        self.assertFalse(post.flags.writeable)
+
+    # ------------------------------------------------------------------
+    # differential vs reference across a matrix of parameters
+
+    def test_matches_reference(self) -> None:
+        rng = np.random.default_rng(42)
+        arrays_1d = (
+            np.round(rng.random(300), 2),
+            np.where(rng.random(300) < 0.5, np.nan, rng.random(300)),
+            rng.integers(0, 4, 300),
+        )
+        for a in arrays_1d:
+            t = np.isnan(a) if a.dtype.kind == 'f' else (a % 3 == 0)
+            for forward in (True, False):
+                for limit in (0, 1, 3):
+                    post = fill_directional(a, t, forward=forward, limit=limit)
+                    exp = reference(a, t, forward=forward, limit=limit)
+                    self.assertTrue(
+                        np.array_equal(post, exp, equal_nan=(a.dtype.kind == 'f'))
+                    )
+        for shape in ((8, 5), (5, 8), (1, 6), (6, 1), (10, 10)):
+            a = np.where(rng.random(shape) < 0.35, np.nan, rng.random(shape))
+            t = np.isnan(a)
+            for axis in (0, 1):
+                for forward in (True, False):
+                    for limit in (0, 2):
+                        post = fill_directional(
+                            a, t, forward=forward, axis=axis, limit=limit
+                        )
+                        exp = reference(
+                            a, t, forward=forward, axis=axis, limit=limit
+                        )
+                        self.assertTrue(np.array_equal(post, exp, equal_nan=True))
+
+    # ------------------------------------------------------------------
+    # errors
+
+    def test_error_target_not_bool(self) -> None:
+        a = np.arange(3.0)
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros(3, dtype=int))
+
+    def test_error_shape_mismatch(self) -> None:
+        a = np.arange(3.0)
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros(4, dtype=bool))
+
+    def test_error_ndim_mismatch(self) -> None:
+        a = np.arange(6.0).reshape(2, 3)
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros(6, dtype=bool))
+
+    def test_error_bad_axis(self) -> None:
+        a = np.arange(6.0).reshape(2, 3)
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros((2, 3), dtype=bool), axis=2)
+
+    def test_error_negative_limit(self) -> None:
+        a = np.arange(3.0)
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros(3, dtype=bool), limit=-1)
+
+    def test_error_3d(self) -> None:
+        a = np.zeros((2, 2, 2))
+        with self.assertRaises(ValueError):
+            fill_directional(a, np.zeros((2, 2, 2), dtype=bool))
+
+
+if __name__ == '__main__':
+    unittest.main()

{arraykit-1.7.0 → arraykit-1.9.0}/test/test_tri_map.py

@@ -1439,3 +1439,72 @@ class TestUnit(unittest.TestCase):
                 np.datetime64('2005-11'),
             ],
         )
+
+    # ------------------------------------------------------------------
+    # register_many_from_one (bulk one-to-one)
+
+    def test_tri_map_register_many_from_one_a(self) -> None:
+        tm = TriMap(3, 4)
+        tm.register_many_from_one(np.array([2, 0, 3], dtype=np.int64))
+        tm.finalize()
+        self.assertFalse(tm.is_many())
+        src = np.array([10, 20, 30])
+        dst = np.array([100, 200, 300, 400])
+        self.assertEqual(tm.map_src_no_fill(src).tolist(), [10, 20, 30])
+        self.assertEqual(tm.map_dst_no_fill(dst).tolist(), [300, 100, 400])
+
+    def test_tri_map_register_many_from_one_unmatched(self) -> None:
+        # -1 marks an unmatched src -> a src-only row (dst side gets a fill there)
+        tm = TriMap(3, 4)
+        tm.register_many_from_one(np.array([2, -1, 0], dtype=np.int64))
+        tm.finalize()
+        self.assertTrue(tm.src_no_fill())  # every output row has a src value
+        self.assertFalse(tm.dst_no_fill())  # row 1 has no dst -> needs fill
+        dst = np.array([100, 200, 300, 400])
+        self.assertEqual(tm.map_dst_fill(dst, -9, np.dtype(np.int64)).tolist(), [300, -9, 100])
+
+    def test_tri_map_register_many_from_one_is_many(self) -> None:
+        # two src rows matching the same dst -> is_many
+        tm = TriMap(3, 3)
+        tm.register_many_from_one(np.array([0, 0, 1], dtype=np.int64))
+        tm.finalize()
+        self.assertTrue(tm.is_many())
+
+    def test_tri_map_register_many_from_one_equivalence(self) -> None:
+        rng = np.random.RandomState(0)
+        for _ in range(50):
+            src_len = int(rng.randint(1, 12))
+            dst_len = int(rng.randint(1, 10))
+            dst_pos = rng.randint(-1, dst_len, size=src_len).astype(np.int64)
+            tb = TriMap(src_len, dst_len)
+            tb.register_many_from_one(dst_pos)
+            tb.finalize()
+            tl = TriMap(src_len, dst_len)
+            for i in range(src_len):
+                tl.register_one(i, int(dst_pos[i]))
+            tl.finalize()
+            src = np.arange(100, 100 + src_len)
+            dst = np.arange(200, 200 + dst_len)
+            self.assertEqual(tb.is_many(), tl.is_many())
+            self.assertEqual(
+                tb.map_src_no_fill(src).tolist(), tl.map_src_no_fill(src).tolist()
+            )
+            self.assertEqual(
+                tb.map_dst_fill(dst, -1, np.dtype(np.int64)).tolist(),
+                tl.map_dst_fill(dst, -1, np.dtype(np.int64)).tolist(),
+            )
+
+    def test_tri_map_register_many_from_one_errors(self) -> None:
+        with self.assertRaises(ValueError):  # wrong length
+            TriMap(3, 3).register_many_from_one(np.array([0, 1], dtype=np.int64))
+        with self.assertRaises(ValueError):  # wrong dtype
+            TriMap(3, 3).register_many_from_one(np.array([0, 1, 2], dtype=np.int32))
+        with self.assertRaises(ValueError):  # out of bounds dst
+            TriMap(3, 3).register_many_from_one(np.array([0, 1, 9], dtype=np.int64))
+        with self.assertRaises(TypeError):  # not an array
+            TriMap(3, 3).register_many_from_one([0, 1, 2])
+        tm = TriMap(2, 2)
+        tm.register_many_from_one(np.array([0, 1], dtype=np.int64))
+        tm.finalize()
+        with self.assertRaises(RuntimeError):  # post-finalize
+            tm.register_many_from_one(np.array([0, 1], dtype=np.int64))

arraykit-1.7.0/VERSION

@@ -1,2 +0,0 @@
-1.7.0
-