arraykit 1.0.9__tar.gz → 1.2.0__tar.gz

{arraykit-1.0.9 → arraykit-1.2.0}/MANIFEST.in

@@ -1,2 +1,3 @@
 include src/__init__.pyi src/py.typed
 include src/*.h
+include VERSION

{arraykit-1.0.9/arraykit.egg-info → arraykit-1.2.0}/PKG-INFO

@@ -1,17 +1,16 @@
 Metadata-Version: 2.4
 Name: arraykit
-Version: 1.0.9
+Version: 1.2.0
 Summary: Array utilities for StaticFrame
-Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland
-License: MIT
-Keywords: numpy array
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/static-frame/arraykit
+Keywords: numpy,array
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
 Classifier: Programming Language :: C
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
@@ -19,22 +18,32 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.24.3
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+
+
+
+.. image:: https://img.shields.io/pypi/pyversions/arraykit.svg
+  :target: https://pypi.org/project/arraykit
+
+.. image:: https://img.shields.io/pypi/v/arraykit.svg
+  :target: https://pypi.org/project/arraykit
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/arraykit.svg
+  :target: https://anaconda.org/conda-forge/arraykit
+
+.. image:: https://img.shields.io/github/actions/workflow/status/static-frame/arraykit/ci.yml?branch=master&label=build&logo=Github
+  :target: https://github.com/static-frame/arraykit/actions/workflows/ci.yml
+
+
+arraykit
+=============
 
 The ArrayKit library provides utilities for creating and transforming NumPy arrays, implementing performance-critical StaticFrame operations as Python C extensions.
 
@@ -55,6 +64,22 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.2.0
+............
+
+Now building wheels for Python 3.14 and 3.14t.
+
+
+1.1.0
+............
+
+Now building free-threaded compatible wheels for Python 3.13.
+
+Added ``is_objectable()`` and ``is_objectable_dt64()``.
+
+Added ``astype_array()``.
+
+
 1.0.9
 ............
 

{arraykit-1.0.9 → arraykit-1.2.0}/README.rst

@@ -35,6 +35,22 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.2.0
+............
+
+Now building wheels for Python 3.14 and 3.14t.
+
+
+1.1.0
+............
+
+Now building free-threaded compatible wheels for Python 3.13.
+
+Added ``is_objectable()`` and ``is_objectable_dt64()``.
+
+Added ``astype_array()``.
+
+
 1.0.9
 ............
 

arraykit-1.2.0/VERSION

@@ -0,0 +1,2 @@
+1.2.0
+

{arraykit-1.0.9 → arraykit-1.2.0/arraykit.egg-info}/PKG-INFO

@@ -1,17 +1,16 @@
 Metadata-Version: 2.4
 Name: arraykit
-Version: 1.0.9
+Version: 1.2.0
 Summary: Array utilities for StaticFrame
-Home-page: https://github.com/static-frame/arraykit
 Author: Christopher Ariza, Brandt Bucher, Charles Burkland
-License: MIT
-Keywords: numpy array
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/static-frame/arraykit
+Keywords: numpy,array
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
 Classifier: Programming Language :: C
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
@@ -19,22 +18,32 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.24.3
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+
+
+
+.. image:: https://img.shields.io/pypi/pyversions/arraykit.svg
+  :target: https://pypi.org/project/arraykit
+
+.. image:: https://img.shields.io/pypi/v/arraykit.svg
+  :target: https://pypi.org/project/arraykit
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/arraykit.svg
+  :target: https://anaconda.org/conda-forge/arraykit
+
+.. image:: https://img.shields.io/github/actions/workflow/status/static-frame/arraykit/ci.yml?branch=master&label=build&logo=Github
+  :target: https://github.com/static-frame/arraykit/actions/workflows/ci.yml
+
+
+arraykit
+=============
 
 The ArrayKit library provides utilities for creating and transforming NumPy arrays, implementing performance-critical StaticFrame operations as Python C extensions.
 
@@ -55,6 +64,22 @@ ArrayKit requires the following:
 What is New in ArrayKit
 -------------------------
 
+1.2.0
+............
+
+Now building wheels for Python 3.14 and 3.14t.
+
+
+1.1.0
+............
+
+Now building free-threaded compatible wheels for Python 3.13.
+
+Added ``is_objectable()`` and ``is_objectable_dt64()``.
+
+Added ``astype_array()``.
+
+
 1.0.9
 ............
 

{arraykit-1.0.9 → arraykit-1.2.0}/arraykit.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 LICENSE.txt
 MANIFEST.in
 README.rst
+VERSION
+pyproject.toml
 setup.py
 arraykit.egg-info/PKG-INFO
 arraykit.egg-info/SOURCES.txt
@@ -27,6 +29,7 @@ src/tri_map.c
 src/tri_map.h
 src/utilities.h
 test/test_array_go.py
+test/test_astype_array.py
 test/test_auto_map.py
 test/test_auto_map_property.py
 test/test_block_index.py
@@ -35,6 +38,7 @@ test/test_delimited_to_arrays_integration.py
 test/test_delimited_to_arrays_property.py
 test/test_nonzero_1d.py
 test/test_nonzero_1d_property.py
+test/test_objectable.py
 test/test_pyi.py
 test/test_split_after_count.py
 test/test_tri_map.py

arraykit-1.2.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = [
+  "setuptools>=64",
+  "wheel",
+  "numpy>=2.2"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arraykit"
+description = "Array utilities for StaticFrame"
+readme = { file = "README.rst", content-type = "text/x-rst" }
+requires-python = ">=3.10"
+
+dynamic = ["version"]
+
+authors = [
+  { name = "Christopher Ariza" },
+  { name = "Brandt Bucher" },
+  { name = "Charles Burkland" },
+]
+license = "MIT"
+keywords = ["numpy", "array"]
+dependencies = [
+  "numpy>=1.24.3",
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development",
+  "Programming Language :: C",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Operating System :: MacOS :: MacOS X",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Free Threading",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/static-frame/arraykit"
+
+[tool.setuptools]
+package-dir = { "arraykit" = "src" }
+
+[tool.setuptools.package-data]
+arraykit = ["__init__.pyi", "py.typed"]
+
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }
+

arraykit-1.2.0/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import site, os
+from pathlib import Path
+
+AK_VERSION = Path("VERSION").read_text(encoding="utf-8").strip()
+
+def get_ext_dir(*components: tp.Iterable[str]) -> tp.Sequence[str]:
+    dirs = []
+    for sp in site.getsitepackages():
+        fp = os.path.join(sp, *components)
+        if os.path.exists(fp):
+            dirs.append(fp)
+    return dirs
+
+ext_modules = [
+    Extension(
+        name="arraykit._arraykit",
+        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",
+            "src/auto_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"],
+    )
+]
+
+setup(ext_modules=ext_modules)
+

{arraykit-1.0.9 → arraykit-1.2.0}/src/__init__.py

@@ -31,7 +31,10 @@ 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-1.0.9 → arraykit-1.2.0}/src/__init__.pyi

@@ -203,6 +203,9 @@ def get_new_indexers_and_screen(indexers: np.ndarray, positions: 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-1.0.9 → arraykit-1.2.0}/src/_arraykit.c

@@ -52,6 +52,9 @@ static PyMethodDef arraykit_methods[] =  {
             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,
@@ -72,7 +75,7 @@ static struct PyModuleDef arraykit_module = {
     .m_methods = arraykit_methods,
 };
 
-PyObject *
+PyObject*
 PyInit__arraykit(void)
 {
     import_array();
@@ -95,6 +98,7 @@ PyInit__arraykit(void)
         return NULL;
     }
 
+    // store a reference to the deepcopy function
     PyObject *copy = PyImport_ImportModule("copy");
     if (copy == NULL) {
         return NULL;
@@ -105,6 +109,18 @@ PyInit__arraykit(void)
         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)) ||
@@ -128,12 +144,17 @@ PyInit__arraykit(void)
         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, "NonUniqueError", NonUniqueError) ||
+        PyModule_AddObject(m, "dt_year", (PyObject *)dt_year)
 ){
-        Py_DECREF(deepcopy);
+        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-1.0.9 → arraykit-1.2.0}/src/auto_map.c

@@ -426,8 +426,13 @@ fami_iternext(FAMIObject *self)
             else {
                 PyObject* t = PyTuple_New(2);
                 if (!t) { return NULL; }
+#if PY_VERSION_HEX >= 0x030D0000  // Python 3.13+
+                PyObject* k = PyList_GetItemRef(self->fam->keys, index);
+#else
                 PyObject* k = PyList_GET_ITEM(self->fam->keys, index);
-                Py_INCREF(k);
+                Py_XINCREF(k);
+#endif
+                if (!k) { return NULL; }
                 PyTuple_SET_ITEM(t, 0, k);
                 PyTuple_SET_ITEM(t, 1, PyLong_FromSsize_t(index));
                 return t;
@@ -438,8 +443,13 @@ fami_iternext(FAMIObject *self)
                 return PyArray_ToScalar(PyArray_GETPTR1(self->keys_array, index), self->keys_array);
             }
             else {
+#if PY_VERSION_HEX >= 0x030D0000  // Python 3.13+
+                PyObject* yield = PyList_GetItemRef(self->fam->keys, index);
+#else
                 PyObject* yield = PyList_GET_ITEM(self->fam->keys, index);
-                Py_INCREF(yield);
+                Py_XINCREF(yield);
+#endif
+                if (!yield) { return NULL; }
                 return yield;
             }
         }
@@ -1302,11 +1312,11 @@ lookup(FAMObject *self, PyObject *key) {
     return self->table[table_pos].keys_pos;
 }
 
-// Insert a key_pos, hash pair into the table. Assumes table already has appropriate size. When inserting a new itme, `hash` is -1, forcing a fresh hash to be computed here. Return 0 on success, -1 on error.
+// Insert a key_pos, hash pair into the table. Assumes table already has appropriate size. When inserting a new item, `hash` is -1, forcing a fresh hash to be computed here. Return 0 on success, -1 on error.
 static int
 insert_obj(
         FAMObject *self,
-        PyObject *key,
+        PyObject *key,  // NOTE: a borrowed reference
         Py_ssize_t keys_pos,
         Py_hash_t hash)
 {

{arraykit-1.0.9 → arraykit-1.2.0}/src/methods.c

@@ -201,6 +201,139 @@ nonzero_1d(PyObject *Py_UNUSED(m), PyObject *a) {
     return AK_nonzero_1d(array);
 }
 
+PyObject*
+is_objectable_dt64(PyObject *m, PyObject *a) {
+    AK_CHECK_NUMPY_ARRAY(a);
+    PyArrayObject* array = (PyArrayObject*)a;
+
+    // this returns a new reference
+    PyObject* dt_year = PyObject_GetAttrString(m, "dt_year");
+    int is_objectable = AK_is_objectable_dt64(array, dt_year);
+    Py_DECREF(dt_year);
+
+    switch (is_objectable) {
+        case -1:
+            return NULL;
+        case 0:
+            Py_RETURN_FALSE;
+        case 1:
+            Py_RETURN_TRUE;
+    }
+    return NULL;
+}
+
+
+PyObject*
+is_objectable(PyObject *m, PyObject *a) {
+    AK_CHECK_NUMPY_ARRAY(a);
+    PyArrayObject* array = (PyArrayObject*)a;
+
+    char kind = PyArray_DESCR(array)->kind;
+    if ((kind == 'M' || kind == 'm')) {
+        // this returns a new reference
+        PyObject* dt_year = PyObject_GetAttrString(m, "dt_year");
+        int is_objectable = AK_is_objectable_dt64(array, dt_year);
+        Py_DECREF(dt_year);
+
+        switch (is_objectable) {
+            case -1:
+                return NULL;
+            case 0:
+                Py_RETURN_FALSE;
+            case 1:
+                Py_RETURN_TRUE;
+        }
+    }
+    Py_RETURN_TRUE;
+}
+
+// Convert array to the dtype provided. NOTE: mutable arrays will be returned unless the input array is immutable and no dtype change is needed
+PyObject*
+astype_array(PyObject* m, PyObject* args) {
+
+    PyObject* a = NULL;
+    PyObject* dtype_spec = Py_None;
+
+    if (!PyArg_ParseTuple(args, "O!|O:astype_array",
+        &PyArray_Type, &a,
+        &dtype_spec)) {
+        return NULL;
+    }
+    PyArrayObject* array = (PyArrayObject*)a;
+
+    PyArray_Descr* dtype = NULL;
+    if (dtype_spec == Py_None) {
+        dtype = PyArray_DescrFromType(NPY_DEFAULT_TYPE);
+    } else {
+        if (!PyArray_DescrConverter(dtype_spec, &dtype)) {
+            return NULL;
+        }
+    }
+
+    if (PyArray_EquivTypes(PyArray_DESCR(array), dtype)) {
+        Py_DECREF(dtype);
+
+        if (PyArray_ISWRITEABLE(array)) {
+            PyObject* result = PyArray_NewCopy(array, NPY_ANYORDER);
+            if (!result) {
+                return NULL;
+            }
+            return result;
+        }
+        else { // already immutable
+            Py_INCREF(a);
+            return a;
+        }
+    }
+    // if converting to an object
+    if (dtype->type_num == NPY_OBJECT) {
+        char kind = PyArray_DESCR(array)->kind;
+        if ((kind == 'M' || kind == 'm')) {
+            PyObject* dt_year = PyObject_GetAttrString(m, "dt_year");
+            int is_objectable = AK_is_objectable_dt64(array, dt_year);
+            Py_DECREF(dt_year);
+
+            if (!is_objectable) {
+                PyObject* result = PyArray_NewLikeArray(array, NPY_ANYORDER, dtype, 0);
+                if (!result) {
+                    Py_DECREF(dtype);
+                    return NULL;
+                }
+                PyObject** data = (PyObject**)PyArray_DATA((PyArrayObject*)result);
+
+                PyArrayIterObject* it = (PyArrayIterObject*)PyArray_IterNew(a);
+                if (!it) {
+                    Py_DECREF(result);
+                    return NULL;
+                }
+
+                npy_intp i = 0;
+                while (it->index < it->size) {
+                    PyObject* item = PyArray_ToScalar(it->dataptr, array);
+                    if (!item) {
+                        Py_DECREF(result);
+                        Py_DECREF(it);
+                        return NULL;
+                    }
+                    data[i++] = item;
+                    PyArray_ITER_NEXT(it);
+                }
+                Py_DECREF(it);
+                return result;
+            }
+        }
+    }
+    // all other cases: do a standard cast conversion
+    PyObject* result = PyArray_CastToType(array, dtype, 0);
+    if (!result) {
+        Py_DECREF(dtype);
+        return NULL;
+    }
+    return result;
+}
+
+
+
 static char *first_true_1d_kwarg_names[] = {
     "array",
     "forward",

{arraykit-1.0.9 → arraykit-1.2.0}/src/methods.h

@@ -47,6 +47,15 @@ resolve_dtype_iter(PyObject *Py_UNUSED(m), PyObject *arg);
 PyObject *
 nonzero_1d(PyObject *Py_UNUSED(m), PyObject *a);
 
+PyObject *
+is_objectable_dt64(PyObject *m, PyObject *a);
+
+PyObject *
+is_objectable(PyObject *m, PyObject *a);
+
+PyObject *
+astype_array(PyObject *m, PyObject *args);
+
 PyObject *
 first_true_1d(PyObject *Py_UNUSED(m), PyObject *args, PyObject *kwargs);
 

{arraykit-1.0.9 → arraykit-1.2.0}/src/utilities.h

@@ -223,6 +223,69 @@ AK_slice_to_ascending_slice(PyObject* slice, Py_ssize_t size)
             -step);
 }
 
+
+static inline NPY_DATETIMEUNIT
+AK_dt_unit_from_array(PyArrayObject* a) {
+    // This is based on get_datetime_metadata_from_dtype in the NumPy source, but that function is private. This does not check that the dtype is of the appropriate type.
+    PyArray_Descr* dt = PyArray_DESCR(a); // borrowed ref
+    PyArray_DatetimeMetaData* dma = &(((PyArray_DatetimeDTypeMetaData *)PyDataType_C_METADATA(dt))->meta);
+    return dma->base;
+}
+
+// Given a dt64 array, determine if it can be cast to a object without data loss. Returns -1 on error. NOTE: if we use dt_year, must incref first
+static inline int
+AK_is_objectable_dt64(PyArrayObject* a, PyObject* dt_year)
+{
+    NPY_DATETIMEUNIT unit = AK_dt_unit_from_array(a);
+    switch (unit) {
+        case NPY_FR_ERROR:
+        case NPY_FR_Y:
+        case NPY_FR_M:
+        case NPY_FR_W:
+            return false;
+        case NPY_FR_D:
+        case NPY_FR_h:
+        case NPY_FR_m:
+        case NPY_FR_s:
+        case NPY_FR_ms:
+        case NPY_FR_us:
+            break;
+        case NPY_FR_ns:
+        case NPY_FR_ps:
+        case NPY_FR_fs:
+        case NPY_FR_as:
+        case NPY_FR_GENERIC:
+            return false;
+    }
+
+    Py_INCREF(dt_year);
+    PyObject* a_year = PyArray_CastToType(a, (PyArray_Descr*)dt_year, 0);
+    if (!a_year) {
+        Py_DECREF(dt_year);
+        return -1;
+    }
+
+    npy_int64* data = (npy_int64*)PyArray_DATA((PyArrayObject*)a_year);
+    npy_intp size = PyArray_SIZE((PyArrayObject*)a_year);
+
+    for (npy_intp i = 0; i < size; ++i) {
+        npy_int64 v = data[i];
+        if (v == NPY_DATETIME_NAT) {
+            continue;
+        }
+        // offset: 1-1970, 9999-1970
+        if (v < -1969 || v > 8029) {
+            Py_DECREF(a_year);
+            return 0;
+        }
+    }
+    Py_DECREF(a_year);
+    return 1;
+}
+
+
+
+
 // Given a Boolean, contiguous 1D array, return the index positions in an int64 array. Through experimentation it has been verified that doing full-size allocation of memory provides the best performance at all scales. Using NpyIter, or using, bit masks does not improve performance over pointer arithmetic. Prescanning for all empty is very effective. Note that NumPy benefits from first counting the nonzeros, then allocating only enough data for the expexted number of indices.
 static inline PyObject *
 AK_nonzero_1d(PyArrayObject* array) {
@@ -319,15 +382,6 @@ AK_nonzero_1d(PyArrayObject* array) {
     return final;
 }
 
-static inline NPY_DATETIMEUNIT
-AK_dt_unit_from_array(PyArrayObject* a) {
-    // This is based on get_datetime_metadata_from_dtype in the NumPy source, but that function is private. This does not check that the dtype is of the appropriate type.
-    PyArray_Descr* dt = PyArray_DESCR(a); // borrowed ref
-    PyArray_DatetimeMetaData* dma = &(((PyArray_DatetimeDTypeMetaData *)PyDataType_C_METADATA(dt))->meta);
-    // PyArray_DatetimeMetaData* dma = &(((PyArray_DatetimeDTypeMetaData *)PyArray_DESCR(a)->c_metadata)->meta);
-    return dma->base;
-}
-
 static inline NPY_DATETIMEUNIT
 AK_dt_unit_from_scalar(PyDatetimeScalarObject* dts) {
     // Based on convert_pyobject_to_datetime and related usage in datetime.c

arraykit-1.2.0/test/test_astype_array.py

@@ -0,0 +1,123 @@
+import unittest
+
+import numpy as np
+
+from arraykit import astype_array
+
+class TestUnit(unittest.TestCase):
+
+    def test_astype_array_a1(self) -> None:
+        a1 = np.array([10, 20, 30], dtype=np.int64)
+        a1.flags.writeable = False
+
+        a2 = astype_array(a1, np.int64)
+        self.assertEqual(id(a1), id(a2))
+
+
+    def test_astype_array_a2(self) -> None:
+        a1 = np.array([10, 20, 30], dtype=np.int64)
+        a1.flags.writeable = False
+
+        a2 = astype_array(a1, np.float64)
+        self.assertNotEqual(id(a1), id(a2))
+        self.assertEqual(a2.dtype, np.dtype(np.float64))
+
+
+    def test_astype_array_a3(self) -> None:
+        a1 = np.array([False, True, False])
+
+        a2 = astype_array(a1, np.int8)
+        self.assertEqual(a2.dtype, np.dtype(np.int8))
+        self.assertTrue(a2.flags.writeable)
+
+    def test_astype_array_b1(self) -> None:
+        a1 = np.array(['2021', '2024'], dtype=np.datetime64)
+
+        a2 = astype_array(a1, np.object_)
+        self.assertEqual(a2.dtype, np.dtype(np.object_))
+        self.assertTrue(a2.flags.writeable)
+        self.assertEqual(list(a2), [np.datetime64('2021'), np.datetime64('2024')])
+
+
+    def test_astype_array_b2(self) -> None:
+        a1 = np.array(['2021', '1642'], dtype=np.datetime64)
+
+        a2 = astype_array(a1, np.object_)
+        self.assertEqual(a2.dtype, np.dtype(np.object_))
+        self.assertTrue(a2.flags.writeable)
+        self.assertEqual(list(a2), [np.datetime64('2021'), np.datetime64('1642')])
+
+
+    def test_astype_array_b3(self) -> None:
+        a1 = np.array(['2021', '2024', '1984', '1642'], dtype=np.datetime64).reshape((2, 2))
+
+        a2 = astype_array(a1, np.object_)
+        self.assertEqual(a2.dtype, np.dtype(np.object_))
+        self.assertTrue(a2.flags.writeable)
+        self.assertEqual(
+                list(list(a) for a in a2),
+                [[np.datetime64('2021'), np.datetime64('2024')], [np.datetime64('1984'), np.datetime64('1642')]])
+
+    def test_astype_array_b4(self) -> None:
+        a1 = np.array(['2021', '2024', '1532', '1984', '1642', '899'], dtype=np.datetime64).reshape((2, 3))
+
+        a2 = astype_array(a1, np.object_)
+        self.assertEqual(a2.dtype, np.dtype(np.object_))
+        self.assertEqual(a2.shape, (2, 3))
+        self.assertTrue(a2.flags.writeable)
+        self.assertEqual(
+                list(list(a) for a in a2),
+                [[np.datetime64('2021'), np.datetime64('2024'), np.datetime64('1532')],
+                 [np.datetime64('1984'), np.datetime64('1642'), np.datetime64('899')]])
+
+    def test_astype_array_c(self) -> None:
+        with self.assertRaises(TypeError):
+            _ = astype_array([3, 4, 5], np.int64)
+
+
+    def test_astype_array_d1(self) -> None:
+        a1 = np.array([10, 20, 30], dtype=np.int64)
+        a2 = astype_array(a1)
+
+        self.assertEqual(a2.dtype, np.dtype(np.float64))
+        self.assertEqual(a2.shape, (3,))
+        self.assertTrue(a2.flags.writeable)
+
+
+    def test_astype_array_d2(self) -> None:
+        a1 = np.array([10, 20, 30], dtype=np.int64)
+        a2 = astype_array(a1, None)
+
+        self.assertEqual(a2.dtype, np.dtype(np.float64))
+        self.assertEqual(a2.shape, (3,))
+        self.assertTrue(a2.flags.writeable)
+
+
+
+    def test_astype_array_d3(self) -> None:
+        a1 = np.array([10, 20, 30], dtype=np.int64)
+        a2 = astype_array(a1, np.int64)
+
+        self.assertEqual(a2.dtype, np.dtype(np.int64))
+        self.assertEqual(a2.shape, (3,))
+        self.assertTrue(a2.flags.writeable)
+
+        self.assertNotEqual(id(a1), id(a2))
+
+    def test_astype_array_e(self) -> None:
+        a1 = np.array(['2021', '2024', '1997', '1984', '2000', '1999'], dtype='datetime64[ns]').reshape((2, 3))
+
+        a2 = astype_array(a1, np.object_)
+        self.assertEqual(a2.dtype, np.dtype(np.object_))
+        self.assertEqual(a2.shape, (2, 3))
+        self.assertTrue(a2.flags.writeable)
+        self.assertEqual(
+                list(list(a) for a in a2),
+                [[np.datetime64('2021-01-01T00:00:00.000000000'),
+                  np.datetime64('2024-01-01T00:00:00.000000000'),
+                  np.datetime64('1997-01-01T00:00:00.000000000')],
+                  [np.datetime64('1984-01-01T00:00:00.000000000'),
+                   np.datetime64('2000-01-01T00:00:00.000000000'),
+                   np.datetime64('1999-01-01T00:00:00.000000000')]]
+                 )
+

arraykit-1.2.0/test/test_objectable.py

@@ -0,0 +1,68 @@
+import unittest
+
+import numpy as np
+
+from arraykit import is_objectable_dt64
+from arraykit import is_objectable
+
+class TestUnit(unittest.TestCase):
+
+    def test_is_objectable_a1(self) -> None:
+        a1 = np.array(['2022-01-04', '1954-04-12'], dtype=np.datetime64)
+        self.assertTrue(is_objectable(a1))
+
+    def test_is_objectable_a2(self) -> None:
+        a1 = np.array(['10000-01-04', '1954-04-12'], dtype=np.datetime64)
+        self.assertFalse(is_objectable(a1))
+
+    def test_is_objectable_b(self) -> None:
+        a1 = np.array([10, 20])
+        self.assertTrue(is_objectable(a1))
+
+    def test_is_objectable_c(self) -> None:
+        a1 = np.array([True, False])
+        self.assertTrue(is_objectable(a1))
+
+    def test_is_objectable_d(self) -> None:
+        a1 = np.array(['b', 'ccc'])
+        self.assertTrue(is_objectable(a1))
+
+    def test_is_objectable_e(self) -> None:
+        a1 = np.array(['b', None, False], dtype=object)
+        self.assertTrue(is_objectable(a1))
+
+
+    #---------------------------------------------------------------------------
+
+    def test_is_objectable_dt64_a1(self) -> None:
+        a1 = np.array(['2022-01-04', '1954-04-12'], dtype=np.datetime64)
+        self.assertTrue(is_objectable_dt64(a1))
+
+    def test_is_objectable_dt64_a2(self) -> None:
+        a1 = np.array(['2022-01-04', '', '1954-04-12'], dtype=np.datetime64)
+        self.assertTrue(is_objectable_dt64(a1))
+
+    def test_is_objectable_dt64_a3(self) -> None:
+        a1 = np.array(['2022-01-04', '1954-04-12', '', ''], dtype=np.datetime64)
+        self.assertTrue(is_objectable_dt64(a1))
+
+
+    def test_is_objectable_dt64_b(self) -> None:
+        # years are nevery objectable
+        a1 = np.array(['2022', '2023'], dtype=np.datetime64)
+        self.assertFalse(is_objectable_dt64(a1))
+
+
+    def test_is_objectable_dt64_c(self) -> None:
+        a1 = np.array(['-120-01-01', '2023-04-05'], dtype='datetime64[m]')
+        self.assertFalse(is_objectable_dt64(a1))
+
+    def test_is_objectable_dt64_d(self) -> None:
+        a1 = np.array(['2024-01-01', '2023-04-05', '10000-01-01'], dtype='datetime64[s]')
+        self.assertFalse(is_objectable_dt64(a1))
+
+
+    def test_is_objectable_dt64_e(self) -> None:
+        a1 = np.array(['2024-01-01', '2023-04-05'], dtype='datetime64[ns]')
+        self.assertFalse(is_objectable_dt64(a1))
+

{arraykit-1.0.9 → arraykit-1.2.0}/test/test_pyi.py

@@ -14,6 +14,8 @@ class Interface(tp.NamedTuple):
 
     @staticmethod
     def _valid_name(name: str) -> bool:
+        if name in ('__annotate__', '__class__', '__annotate_func__'):
+            return False
         if name.startswith('__'):
             return True
         if name.startswith('_'):

{arraykit-1.0.9 → arraykit-1.2.0}/test/test_util.py

@@ -17,6 +17,7 @@ from arraykit import mloc
 from arraykit import immutable_filter
 from arraykit import array_deepcopy
 from arraykit import isna_element
+from arraykit import is_objectable_dt64
 from arraykit import dtype_from_element
 from arraykit import count_iteration
 from arraykit import first_true_1d
@@ -953,7 +954,5 @@ class TestUnit(unittest.TestCase):
             )
 
 
-
-
 if __name__ == '__main__':
     unittest.main()

arraykit-1.0.9/setup.py

@@ -1,94 +0,0 @@
-import site
-import os
-from os import path
-import typing as tp
-from setuptools import Extension  # type: ignore
-from setuptools import setup
-
-AK_VERSION = '1.0.9'
-
-ROOT_DIR_FP = path.abspath(path.dirname(__file__))
-
-def get_long_description() -> str:
-    with open(path.join(ROOT_DIR_FP, 'README.rst'), encoding='utf-8') as f:
-        msg = []
-        collect = False
-        start = -1
-        for i, line in enumerate(f):
-            if line.startswith('arraykit'):
-                start = i + 2 # skip this line and the next
-            if i == start:
-                collect = True
-            if collect:
-                msg.append(line)
-    return ''.join(msg).strip()
-
-
-# NOTE: we do this to avoid importing numpy: https://stackoverflow.com/questions/54117786/add-numpy-get-include-argument-to-setuptools-without-preinstalled-numpy
-# we used to import the following to get directories:
-# from numpy.distutils.misc_util import get_info
-# import numpy as np  # type: ignore
-# get_info('npymath')['library_dirs']
-# get_info('npymath')['libraries']
-
-def get_ext_dir(*components: tp.Iterable[str]) -> tp.Sequence[str]:
-    dirs = []
-    for sp in site.getsitepackages():
-        fp = os.path.join(sp, *components)
-        if os.path.exists(fp):
-            dirs.append(fp)
-    return dirs
-
-ak_extension = Extension(
-        name='arraykit._arraykit', # build into module
-        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',
-            'src/auto_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
-        )
-
-setup(
-    name='arraykit',
-    version=AK_VERSION,
-    description='Array utilities for StaticFrame',
-    long_description=get_long_description(),
-    long_description_content_type='text/x-rst', # use text/x-rst
-    python_requires='>=3.10',
-    install_requires=['numpy>=1.24.3'],
-    url='https://github.com/static-frame/arraykit',
-    author='Christopher Ariza, Brandt Bucher, Charles Burkland',
-    license='MIT',
-    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Intended Audience :: Developers',
-        'Topic :: Software Development',
-        "Programming Language :: C",
-        "Programming Language :: Python :: Implementation :: CPython",
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: MacOS :: MacOS X',
-        'Operating System :: Microsoft :: Windows',
-        'Operating System :: POSIX',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Programming Language :: Python :: 3.12',
-        'Programming Language :: Python :: 3.13',
-        'Typing :: Typed',
-    ],
-    keywords='numpy array',
-    packages=['arraykit'],
-    package_dir={'arraykit': 'src'},
-    package_data={'arraykit': ['__init__.pyi', 'py.typed']},
-    include_package_data=True,
-    ext_modules=[ak_extension],
-)