arraykit 1.2.0__cp314-cp314t-win32.whl

arraykit/__init__.py

@@ -0,0 +1,40 @@
+# pylint: disable=W0611
+# pylint: disable=E0401
+# pylint: disable=C0414
+
+from ._arraykit import __version__
+from ._arraykit import TriMap as TriMap
+from ._arraykit import ArrayGO as ArrayGO
+from ._arraykit import BlockIndex as BlockIndex
+from ._arraykit import ErrorInitTypeBlocks as ErrorInitTypeBlocks
+
+from ._arraykit import immutable_filter as immutable_filter
+from ._arraykit import mloc as mloc
+from ._arraykit import name_filter as name_filter
+from ._arraykit import shape_filter as shape_filter
+from ._arraykit import column_2d_filter as column_2d_filter
+from ._arraykit import column_1d_filter as column_1d_filter
+from ._arraykit import row_1d_filter as row_1d_filter
+from ._arraykit import array_deepcopy as array_deepcopy
+from ._arraykit import resolve_dtype as resolve_dtype
+from ._arraykit import resolve_dtype_iter as resolve_dtype_iter
+from ._arraykit import isna_element as isna_element
+from ._arraykit import dtype_from_element as dtype_from_element
+from ._arraykit import delimited_to_arrays as delimited_to_arrays
+from ._arraykit import iterable_str_to_array_1d as iterable_str_to_array_1d
+from ._arraykit import split_after_count as split_after_count
+from ._arraykit import get_new_indexers_and_screen as get_new_indexers_and_screen
+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
+from ._arraykit import is_objectable_dt64 as is_objectable_dt64
+from ._arraykit import is_objectable as is_objectable
+from ._arraykit import astype_array as astype_array
+from ._arraykit import AutoMap as AutoMap
+from ._arraykit import FrozenAutoMap as FrozenAutoMap
+from ._arraykit import NonUniqueError as NonUniqueError
+

arraykit/__init__.pyi

@@ -0,0 +1,211 @@
+import typing as tp
+import datetime
+
+import numpy as np  # type: ignore
+
+_T = tp.TypeVar('_T')
+
+__version__: str
+
+_TLabel = tp.Union[
+        tp.Hashable,
+        int,
+        bool,
+        np.bool_,
+        np.integer,
+        float,
+        complex,
+        np.inexact,
+        str,
+        bytes,
+        None,
+        np.datetime64,
+        np.timedelta64,
+        datetime.date,
+        datetime.datetime,
+        tp.Tuple['_TLabel', ...],
+]
+
+class ErrorInitTypeBlocks(RuntimeError):
+    def __init__(self, *args: tp.Any, **kwargs: tp.Any) -> None: ...
+    def with_traceback(self, tb: Exception) -> Exception: ...
+    def __setstate__(self) -> None: ...
+
+
+class NonUniqueError(RuntimeError):
+    def __init__(self, *args: tp.Any, **kwargs: tp.Any) -> None: ...
+    def with_traceback(self, tb: Exception) -> Exception: ...
+    def __setstate__(self) -> None: ...
+
+class ArrayGO:
+    values: np.ndarray
+    def __init__(
+        self, iterable: tp.Iterable[object], *, own_iterable: bool = ...
+    ) -> None: ...
+    def __iter__(self) -> tp.Iterator[tp.Any]: ...
+    def __getitem__(self, __key: object) -> tp.Any: ...
+    def __len__(self) -> int: ...
+    def __getnewargs__(self) -> tp.Tuple[np.ndarray]: ...
+    def append(self, __value: object) -> None: ...
+    def copy(self: _T) -> _T: ...
+    def extend(self, __values: tp.Iterable[object]) -> None: ...
+
+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_unmatched_dst(self) -> None: ...
+    def register_many(self, /, src_from: int, dst_from: np.ndarray) -> None: ...
+    def finalize(self) -> None: ...
+    def is_many(self) -> bool: ...
+    def src_no_fill(self) -> bool: ...
+    def dst_no_fill(self) -> bool: ...
+    def map_src_no_fill(self, /, array_from: np.ndarray) -> np.ndarray: ...
+    def map_dst_no_fill(self, /, array_from: np.ndarray) -> np.ndarray: ...
+    def map_src_fill(self, /,
+            array_from: np.ndarray,
+            fill_value: tp.Any,
+            fill_value_dtype: np.dtype
+            ) -> np.ndarray: ...
+    def map_dst_fill(self, /,
+            array_from: np.ndarray,
+            fill_value: tp.Any,
+            fill_value_dtype: np.dtype
+            ) -> np.ndarray: ...
+    def map_merge(self, /,
+            array_from_src: np.ndarray,
+            array_from_dst: np.ndarray,
+            ) -> np.ndarray: ...
+
+class BlockIndex:
+    shape: tp.Tuple[int, int]
+    dtype: np.dtype
+    rows: int
+    columns: int
+
+    def __init__(
+            block_count: int = 0,
+            row_count: int = -1,
+            bir_count: int = 0,
+            bir_capacity: int = 8,
+            bir_bytes: bytes = b'',
+            dtype: np.dtype = None,
+            ) -> None: ...
+    def register(self, __value: np.ndarray) -> bool: ...
+    def to_list(self,) -> tp.List[tp.Tuple[int, int]]: ...
+    def to_bytes(self,) -> bytes: ...
+    def copy(self,) -> 'BlockIndex': ...
+    def __len__(self,) -> int: ...
+    def __iter__(self,) -> tp.Iterator[tp.Tuple[int, int]]: ...
+    def __reversed__(self,) -> tp.Iterator[tp.Tuple[int, int]]: ...
+    def __getitem__(self, __key: int) -> tp.Tuple[int, int]: ...
+    def __getstate__(self,) -> tp.Tuple[int, int, int, int, bytes]: ...
+    def __setstate__(self, state: tp.Tuple[int, int, int, int, bytes]) -> None: ...
+    def get_block(self, __key: int) -> int: ...
+    def get_column(self, __key: int) -> int: ...
+    def iter_select(self,
+            __key: tp.Union[slice, np.ndarray, tp.List[int]],
+            ) -> tp.Iterator[tp.Tuple[int, int]]: ...
+    def iter_contiguous(self,
+            __key: tp.Union[slice, np.ndarray, tp.List[int]],
+            *,
+            ascending: bool = False,
+            reduce: bool = False,
+            ) -> tp.Iterator[tp.Tuple[int, tp.Union[slice, int]]]: ...
+    def iter_block(self) -> tp.Iterator[tp.Tuple[int, slice]]: ...
+
+
+class FrozenAutoMap:
+    def __init__(self, labels: tp.Iterable[_TLabel] | np.ndarray = (), /,) -> None: ...
+    def get(self, __key: _TLabel, /,) -> int: ...
+    def keys(self) -> tp.Iterator[_TLabel]: ...
+    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_any(self, __key: list[_TLabel] | np.ndarray) -> list[int]: ...
+
+    def __iter__(self) -> tp.Iterator[_TLabel]: ...
+    def __getitem__(self, __key: tp.Any) -> int: ...
+    def __contains__(self, __key: tp.Any) -> bool: ...
+    def __getnewargs__(self) -> tp.Any: ...
+    def __reversed__(self) -> tp.Any: ...
+    def __sizeof__(self) -> int: ...
+    def __getstate__(self) -> tp.Any: ...
+    def __setstate__(self, __state: tp.Any) -> None: ...
+    def __len__(self) -> int: ...
+
+    def __or__(self) -> tp.Any: ...
+    def __ror__(self) -> tp.Any: ...
+
+
+class AutoMap(FrozenAutoMap):
+    def __init__(self, labels: tp.Iterable[_TLabel] | np.ndarray = (), /,) -> None: ...
+    def __ior__(self) -> tp.Any: ...
+    def add(self, __key: _TLabel) -> None: ...
+    def update(self, __keys: tp.Iterable[_TLabel] | np.ndarray) -> None: ...
+
+
+
+
+def iterable_str_to_array_1d(
+        iterable: tp.Iterable[str],
+        *,
+        dtype: tp.Optional[tp.Any] = None,
+        thousandschar: str = ',',
+        decimalchar: str = '.',
+        ) -> np.ndarray: ...
+
+def delimited_to_arrays(
+        file_like: tp.Iterable[str],
+        *,
+        axis: int = 0,
+        dtypes: tp.Optional[tp.Callable[[int], tp.Any]] = None,
+        line_select: tp.Optional[tp.Callable[[int], bool]] = None,
+        delimiter: str = ',',
+        doublequote: bool = True,
+        escapechar: tp.Optional[str] = '',
+        quotechar: tp.Optional[str] = '"',
+        quoting: int = 0,
+        skipinitialspace: bool = False,
+        strict: bool = False,
+        thousandschar: str = ',',
+        decimalchar: str = '.',
+        ) -> tp.List[np.array]: ...
+
+def split_after_count(
+        string: str,
+        *,
+        delimiter: str = ',',
+        count: int = 0,
+        doublequote: bool = True,
+        escapechar: tp.Optional[str] = '',
+        quotechar: tp.Optional[str] = '"',
+        quoting: int = 0,
+        strict: bool = False,
+        ) -> tp.Tuple[str, str]: ...
+
+def count_iteration(__iterable: tp.Iterable) -> int: ...
+
+def immutable_filter(__array: np.ndarray) -> np.ndarray: ...
+def mloc(__array: np.ndarray) -> int: ...
+def name_filter(__name: _TLabel) -> _TLabel: ...
+def shape_filter(__array: np.ndarray) -> np.ndarray: ...
+def column_2d_filter(__array: np.ndarray) -> np.ndarray: ...
+def column_1d_filter(__array: np.ndarray) -> np.ndarray: ...
+def row_1d_filter(__array: np.ndarray) -> np.ndarray: ...
+def array_deepcopy(__array: np.ndarray, memo: tp.Optional[tp.Dict[int, tp.Any]]) -> np.ndarray: ...
+def resolve_dtype(__d1: np.dtype, __d2: np.dtype) -> np.dtype: ...
+def resolve_dtype_iter(__dtypes: tp.Iterable[np.dtype]) -> np.dtype: ...
+def isna_element(__value: tp.Any, include_none: bool = True) -> bool: ...
+def dtype_from_element(__value: tp.Optional[_TLabel]) -> np.dtype: ...
+def get_new_indexers_and_screen(indexers: np.ndarray, positions: np.ndarray) -> tp.Tuple[np.ndarray, 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: ...
+def is_objectable_dt64(__array: np.ndarray, /) -> bool: ...
+def is_objectable(__array: np.ndarray, /) -> bool: ...
+def astype_array(__array: np.ndarray, __dtype: np.dtype | None, /) -> 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/_arraykit.c

@@ -0,0 +1,160 @@
+# include "Python.h"
+
+# define PY_ARRAY_UNIQUE_SYMBOL AK_ARRAY_API
+# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+
+# include "numpy/arrayobject.h"
+
+# include "array_go.h"
+# include "array_to_tuple.h"
+# include "block_index.h"
+# include "delimited_to_arrays.h"
+# include "methods.h"
+# include "tri_map.h"
+# include "auto_map.h"
+
+static PyMethodDef arraykit_methods[] =  {
+    {"immutable_filter", immutable_filter, METH_O, NULL},
+    {"mloc", mloc, METH_O, NULL},
+    {"name_filter", name_filter, METH_O, NULL},
+    {"shape_filter", shape_filter, METH_O, NULL},
+    {"column_2d_filter", column_2d_filter, METH_O, NULL},
+    {"column_1d_filter", column_1d_filter, METH_O, NULL},
+    {"row_1d_filter", row_1d_filter, METH_O, NULL},
+    {"slice_to_ascending_slice", slice_to_ascending_slice, METH_VARARGS, NULL},
+    {"array_deepcopy",
+            (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",
+            (PyCFunction)first_true_1d,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"first_true_2d",
+            (PyCFunction)first_true_2d,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"delimited_to_arrays",
+            (PyCFunction)delimited_to_arrays,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"iterable_str_to_array_1d",
+            (PyCFunction)iterable_str_to_array_1d,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"split_after_count",
+            (PyCFunction)split_after_count,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"count_iteration", count_iteration, METH_O, NULL},
+    {"nonzero_1d", nonzero_1d, METH_O, NULL},
+    {"is_objectable_dt64", is_objectable_dt64, METH_O, NULL},
+    {"is_objectable", is_objectable, METH_O, NULL},
+    {"astype_array", astype_array, METH_VARARGS, NULL},
+    {"isna_element",
+            (PyCFunction)isna_element,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {"dtype_from_element", dtype_from_element, METH_O, NULL},
+    {"get_new_indexers_and_screen",
+            (PyCFunction)get_new_indexers_and_screen,
+            METH_VARARGS | METH_KEYWORDS,
+            NULL},
+    {NULL},
+};
+
+static struct PyModuleDef arraykit_module = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "_arraykit",
+    .m_doc = NULL,
+    .m_size = -1,
+    .m_methods = arraykit_methods,
+};
+
+PyObject*
+PyInit__arraykit(void)
+{
+    import_array();
+
+    ErrorInitTypeBlocks = PyErr_NewExceptionWithDoc(
+            "arraykit.ErrorInitTypeBlocks",
+            "RuntimeError error in block initialization.",
+            PyExc_RuntimeError,
+            NULL);
+    if (ErrorInitTypeBlocks == NULL) {
+        return NULL;
+    }
+
+    NonUniqueError = PyErr_NewExceptionWithDoc(
+            "arraykit.NonUniqueError",
+            "ValueError for non-unique values.",
+            PyExc_ValueError,
+            NULL);
+    if (NonUniqueError == NULL) {
+        return NULL;
+    }
+
+    // store a reference to the deepcopy function
+    PyObject *copy = PyImport_ImportModule("copy");
+    if (copy == NULL) {
+        return NULL;
+    }
+    PyObject *deepcopy = PyObject_GetAttrString(copy, "deepcopy");
+    Py_DECREF(copy);
+    if (deepcopy == NULL) {
+        return NULL;
+    }
+
+    // store a year dtype object
+    PyObject* dt_year_str = PyUnicode_FromString("datetime64[Y]");
+    if (!dt_year_str) return NULL;
+
+    PyArray_Descr* dt_year = NULL;
+    if (!PyArray_DescrConverter2(dt_year_str, &dt_year)) {
+        Py_DECREF(dt_year_str);
+        return NULL;
+    }
+    Py_DECREF(dt_year_str);
+
+
+    PyObject *m = PyModule_Create(&arraykit_module);
+    if (!m ||
+        PyModule_AddStringConstant(m, "__version__", Py_STRINGIFY(AK_VERSION)) ||
+        PyType_Ready(&BlockIndexType) ||
+        PyType_Ready(&BIIterType) ||
+        PyType_Ready(&BIIterSeqType) ||
+        PyType_Ready(&BIIterSliceType) ||
+        PyType_Ready(&BIIterBoolType) ||
+        PyType_Ready(&BIIterContiguousType) ||
+        PyType_Ready(&BIIterBlockType) ||
+        PyType_Ready(&TriMapType) ||
+        PyType_Ready(&ArrayGOType) ||
+        PyType_Ready(&AMType) ||
+        PyType_Ready(&FAMIType) ||
+        PyType_Ready(&FAMVType) ||
+        PyType_Ready(&FAMType) ||
+        PyModule_AddObject(m, "BlockIndex", (PyObject *) &BlockIndexType) ||
+        PyModule_AddObject(m, "TriMap", (PyObject *) &TriMapType) ||
+        PyModule_AddObject(m, "ArrayGO", (PyObject *) &ArrayGOType) ||
+        PyModule_AddObject(m, "deepcopy", deepcopy) ||
+        PyModule_AddObject(m, "ErrorInitTypeBlocks", ErrorInitTypeBlocks) ||
+        PyModule_AddObject(m, "AutoMap", (PyObject *)&AMType) ||
+        PyModule_AddObject(m, "FrozenAutoMap", (PyObject *)&FAMType) ||
+        PyModule_AddObject(m, "NonUniqueError", NonUniqueError) ||
+        PyModule_AddObject(m, "dt_year", (PyObject *)dt_year)
+){
+        Py_XDECREF(deepcopy);
+        Py_XDECREF(dt_year);
+        Py_XDECREF(m);
+        return NULL;
+    }
+#ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+    return m;
+}
+

arraykit/array_go.c

@@ -0,0 +1,264 @@
+# include "Python.h"
+
+# define NO_IMPORT_ARRAY
+# define PY_ARRAY_UNIQUE_SYMBOL AK_ARRAY_API
+# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+
+# include "numpy/arrayobject.h"
+
+# include "array_go.h"
+# include "utilities.h"
+
+typedef struct ArrayGOObject {
+    PyObject_HEAD
+    PyObject *array;
+    PyObject *list;
+} ArrayGOObject;
+
+PyDoc_STRVAR(
+    ArrayGO_doc,
+    "\n"
+    "A grow only, one-dimensional, object type array, "
+    "specifically for usage in IndexHierarchy IndexLevel objects.\n"
+    "\n"
+    "Args:\n"
+    "    own_iterable: flag iterable as ownable by this instance.\n"
+);
+
+PyDoc_STRVAR(
+    ArrayGO_copy_doc,
+    "Return a new ArrayGO with an immutable array from this ArrayGO\n"
+);
+
+PyDoc_STRVAR(ArrayGO_values_doc, "Return the immutable labels array\n");
+
+//------------------------------------------------------------------------------
+// ArrayGO utility functions
+
+static inline int
+update_array_cache(ArrayGOObject *self)
+{
+    if (self->list) {
+        if (self->array) {
+            PyObject *container = PyTuple_Pack(2, self->array, self->list);
+            if (!container) {
+                return -1;
+            }
+            Py_SETREF(self->array, PyArray_Concatenate(container, 0));
+            Py_DECREF(container);
+        }
+        else {
+            self->array = PyArray_FROM_OT(self->list, NPY_OBJECT);
+        }
+        PyArray_CLEARFLAGS((PyArrayObject *)self->array, NPY_ARRAY_WRITEABLE);
+        Py_CLEAR(self->list);
+    }
+    return 0;
+}
+
+//------------------------------------------------------------------------------
+// ArrayGO Methods:
+static char * argnames[] = {"iterable", "own_iterable", NULL};
+
+PyObject *
+ArrayGO_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
+{
+    PyObject *iterable;
+    int own_iterable = 0;
+    int parsed = PyArg_ParseTupleAndKeywords(
+        args, kwargs, "O|$p:ArrayGO", argnames, &iterable, &own_iterable
+    );
+    if (!parsed) {
+        return NULL;
+    }
+    ArrayGOObject *self = (ArrayGOObject *)cls->tp_alloc(cls, 0);
+    if (!self) {
+        return NULL;
+    }
+
+    if (PyArray_Check(iterable)) {
+        if (!PyDataType_ISOBJECT(PyArray_DESCR((PyArrayObject *)iterable))) {
+            PyErr_SetString(PyExc_NotImplementedError,
+                            "only object arrays are supported");
+            Py_DECREF(self);
+            return NULL;
+        }
+        if (own_iterable) {
+            // ArrayGO(np.array(...), own_iterable=True)
+            PyArray_CLEARFLAGS((PyArrayObject *)iterable, NPY_ARRAY_WRITEABLE);
+            self->array = iterable;
+            Py_INCREF(iterable);
+            return (PyObject *)self;
+        }
+        // ArrayGO(np.array(...))
+        self->array = (PyObject *)AK_immutable_filter((PyArrayObject *)iterable);
+        if (!self->array) {
+            Py_CLEAR(self);
+        }
+        return (PyObject *)self;
+    }
+    if (PyList_CheckExact(iterable) && own_iterable) {
+        // ArrayGO([...], own_iterable=True)
+        self->list = iterable;
+        Py_INCREF(iterable);
+        return (PyObject *)self;
+    }
+    // ArrayGO([...])
+    self->list = PySequence_List(iterable);
+    if (!self->list) {
+        Py_CLEAR(self);
+    }
+    return (PyObject *)self;
+}
+
+PyObject *
+ArrayGO_append(ArrayGOObject *self, PyObject *value)
+{
+    if (!self->list) {
+        self->list = PyList_New(1);
+        if (!self->list) {
+            return NULL;
+        }
+        Py_INCREF(value);
+        PyList_SET_ITEM(self->list, 0, value);
+    }
+    else if (PyList_Append(self->list, value)) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+PyObject *
+ArrayGO_extend(ArrayGOObject *self, PyObject *values)
+{
+    if (!self->list) {
+        self->list = PySequence_List(values);
+        if (!self->list) {
+            return NULL;
+        }
+        Py_RETURN_NONE;
+    }
+    Py_ssize_t len = PyList_Size(self->list);
+    if (len < 0 || PyList_SetSlice(self->list, len, len, values)) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+PyObject *
+ArrayGO_getnewargs(ArrayGOObject *self, PyObject *Py_UNUSED(unused))
+{
+    if (self->list && update_array_cache(self)) {
+        return NULL;
+    }
+    return PyTuple_Pack(1, self->array);
+}
+
+PyObject *
+ArrayGO_copy(ArrayGOObject *self, PyObject *Py_UNUSED(unused))
+{
+    ArrayGOObject *copy = PyObject_GC_New(ArrayGOObject, &ArrayGOType);
+    copy->array = self->array;
+    copy->list = self->list ? PySequence_List(self->list) : NULL;
+    Py_XINCREF(copy->array);
+    return (PyObject *)copy;
+}
+
+PyObject *
+ArrayGO_iter(ArrayGOObject *self)
+{
+    if (self->list && update_array_cache(self)) {
+        return NULL;
+    }
+    return PyObject_GetIter(self->array);
+}
+
+PyObject *
+ArrayGO_mp_subscript(ArrayGOObject *self, PyObject *key)
+{
+    if (self->list && update_array_cache(self)) {
+        return NULL;
+    }
+    return PyObject_GetItem(self->array, key);
+}
+
+Py_ssize_t
+ArrayGO_mp_length(ArrayGOObject *self)
+{
+    return ((self->array ? PyArray_SIZE((PyArrayObject *)self->array) : 0)
+            + (self->list ? PyList_Size(self->list) : 0));
+}
+
+PyObject *
+ArrayGO_values_getter(ArrayGOObject *self, void* Py_UNUSED(closure))
+{
+    if (self->list && update_array_cache(self)) {
+        return NULL;
+    }
+    Py_INCREF(self->array);
+    return self->array;
+}
+
+int
+ArrayGO_traverse(ArrayGOObject *self, visitproc visit, void *arg)
+{
+    Py_VISIT(self->array);
+    Py_VISIT(self->list);
+    return 0;
+}
+
+int
+ArrayGO_clear(ArrayGOObject *self)
+{
+    Py_CLEAR(self->array);
+    Py_CLEAR(self->list);
+    return 0;
+}
+
+void
+ArrayGO_dealloc(ArrayGOObject *self)
+{
+    Py_XDECREF(self->array);
+    Py_XDECREF(self->list);
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+// ArrayGo method bundles
+
+static struct PyGetSetDef ArrayGO_getset[] = {
+    {"values", (getter)ArrayGO_values_getter, NULL, ArrayGO_values_doc, NULL},
+    {NULL},
+};
+
+static PyMethodDef ArrayGO_methods[] = {
+    {"append", (PyCFunction)ArrayGO_append, METH_O, NULL},
+    {"copy", (PyCFunction)ArrayGO_copy, METH_NOARGS, ArrayGO_copy_doc},
+    {"extend", (PyCFunction)ArrayGO_extend, METH_O, NULL},
+    {"__getnewargs__", (PyCFunction)ArrayGO_getnewargs, METH_NOARGS, NULL},
+    {NULL},
+};
+
+static PyMappingMethods ArrayGO_as_mapping = {
+    .mp_length = (lenfunc)ArrayGO_mp_length,
+    .mp_subscript = (binaryfunc) ArrayGO_mp_subscript,
+};
+
+//------------------------------------------------------------------------------
+// ArrayGo PyTypeObject
+// https://docs.python.org/3/c-api/typeobj.html
+
+PyTypeObject ArrayGOType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_as_mapping = &ArrayGO_as_mapping,
+    .tp_basicsize = sizeof(ArrayGOObject),
+    .tp_clear = (inquiry)ArrayGO_clear,
+    .tp_dealloc = (destructor)ArrayGO_dealloc,
+    .tp_doc = ArrayGO_doc,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    .tp_getset = ArrayGO_getset,
+    .tp_iter = (getiterfunc)ArrayGO_iter,
+    .tp_methods = ArrayGO_methods,
+    .tp_name = "arraykit.ArrayGO",
+    .tp_new = ArrayGO_new,
+    .tp_traverse = (traverseproc)ArrayGO_traverse,
+};

arraykit/array_go.h

@@ -0,0 +1,8 @@
+# ifndef ARRAYKIT_SRC_ARRAY_GO_H_
+# define ARRAYKIT_SRC_ARRAY_GO_H_
+
+# include "Python.h"
+
+extern PyTypeObject ArrayGOType;
+
+# endif /* ARRAYKIT_SRC_ARRAY_GO_H_ */