arraykit 0.7.2__tar.gz → 0.8.1__tar.gz

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

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

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

@@ -38,6 +38,18 @@ What is New in ArrayKit
 -------------------------
 
 
+0.8.1
+............
+
+Updated build ``include_dirs`` configuration.
+
+
+0.8.0
+............
+
+Now building with NumPy 2.0.
+
+
 0.7.2
 ............
 

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

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

{arraykit-0.7.2 → arraykit-0.8.1}/arraykit.egg-info/SOURCES.txt

@@ -10,7 +10,13 @@ arraykit.egg-info/top_level.txt
 src/__init__.py
 src/__init__.pyi
 src/_arraykit.c
+src/array_go.c
+src/array_to_tuple.c
+src/block_index.c
+src/delimited_to_arrays.c
+src/methods.c
 src/py.typed
+src/tri_map.c
 test/test_array_go.py
 test/test_block_index.py
 test/test_delimited_to_arrays.py

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

@@ -5,7 +5,7 @@ from setuptools import Extension  # type: ignore
 from setuptools import setup
 from pathlib import Path
 
-AK_VERSION = '0.7.2'
+AK_VERSION = '0.8.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.
@@ -32,9 +32,17 @@ def get_ext_dir(*components: tp.Iterable[str]) -> tp.Sequence[str]:
 
 ak_extension = Extension(
         name='arraykit._arraykit', # build into module
-        sources=['src/_arraykit.c'],
-        include_dirs=get_ext_dir('numpy', 'core', 'include'),
-        library_dirs=get_ext_dir('numpy', 'core', 'lib'),
+        sources=[
+            'src/_arraykit.c',
+            'src/array_go.c',
+            'src/array_to_tuple.c',
+            'src/block_index.c',
+            'src/delimited_to_arrays.c',
+            'src/methods.c',
+            'src/tri_map.c',
+        ],
+        include_dirs=get_ext_dir('numpy', '_core', 'include') + ['src'],
+        library_dirs=get_ext_dir('numpy', '_core', 'lib'),
         define_macros=[("AK_VERSION", AK_VERSION)],
         libraries=['npymath'], # not including mlib at this time
         )

arraykit-0.8.1/src/_arraykit.c

@@ -0,0 +1,122 @@
+# 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"
+
+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},
+    {"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;
+    }
+
+    PyObject *copy = PyImport_ImportModule("copy");
+    if (copy == NULL) {
+        return NULL;
+    }
+    PyObject *deepcopy = PyObject_GetAttrString(copy, "deepcopy");
+    Py_DECREF(copy);
+    if (deepcopy == NULL) {
+        return NULL;
+    }
+
+    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) ||
+        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)
+    ){
+        Py_DECREF(deepcopy);
+        Py_XDECREF(m);
+        return NULL;
+    }
+    return m;
+}
+

arraykit-0.8.1/src/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,
+};