give all the string API functions NpyString names

Author: ngoldbaum

stringdtype/stringdtype/src/casts.c

@@ -88,11 +88,11 @@ string_to_string(PyArrayMethod_Context *context, char *const data[],
         const npy_packed_static_string *s = (npy_packed_static_string *)in;
         npy_packed_static_string *os = (npy_packed_static_string *)out;
         if (in != out) {
-            if (in_hasnull && !out_hasnull && npy_string_isnull(s)) {
+            if (in_hasnull && !out_hasnull && NpyString_isnull(s)) {
                 // lossy but this is an unsafe cast so this is OK
-                npy_string_free(os, odescr->allocator);
-                if (npy_string_newsize(in_na_name->buf, in_na_name->size, os,
-                                       odescr->allocator) < 0) {
+                NpyString_free(os, odescr->allocator);
+                if (NpyString_newsize(in_na_name->buf, in_na_name->size, os,
+                                      odescr->allocator) < 0) {
                     gil_error(PyExc_MemoryError,
                               "Failed to allocate string in string to string "
                               "cast.");
@@ -243,18 +243,18 @@ unicode_to_string(PyArrayMethod_Context *context, char *const data[],
             goto fail;
         }
         npy_packed_static_string *out_pss = (npy_packed_static_string *)out;
-        if (npy_string_free(out_pss, allocator) < 0) {
+        if (NpyString_free(out_pss, allocator) < 0) {
             gil_error(PyExc_MemoryError,
                       "Failed to deallocate string in unicode to string cast");
             goto fail;
         }
-        if (npy_string_newemptysize(out_num_bytes, out_pss, allocator) < 0) {
+        if (NpyString_newemptysize(out_num_bytes, out_pss, allocator) < 0) {
             gil_error(PyExc_MemoryError,
                       "Failed to allocate string in unicode to string cast");
             goto fail;
         }
         npy_static_string out_ss = {0, NULL};
-        int is_null = npy_string_load(allocator, out_pss, &out_ss);
+        int is_null = NpyString_load(allocator, out_pss, &out_ss);
         if (is_null == -1) {
             gil_error(PyExc_MemoryError,
                       "Failed to load string in unicode to string cast");
@@ -397,7 +397,7 @@ string_to_unicode(PyArrayMethod_Context *context, char *const data[],
         npy_static_string name = {0, NULL};
         unsigned char *this_string = NULL;
         size_t n_bytes;
-        int is_null = npy_string_load(allocator, ps, &s);
+        int is_null = NpyString_load(allocator, ps, &s);
         if (is_null == -1) {
             gil_error(PyExc_MemoryError,
                       "Failed to load string in unicode to string cast");
@@ -506,7 +506,7 @@ string_to_bool(PyArrayMethod_Context *context, char *const data[],
     while (N--) {
         const npy_packed_static_string *ps = (npy_packed_static_string *)in;
         npy_static_string s = {0, NULL};
-        int is_null = npy_string_load(allocator, ps, &s);
+        int is_null = NpyString_load(allocator, ps, &s);
         if (is_null == -1) {
             gil_error(PyExc_MemoryError,
                       "Failed to load string in unicode to string cast");
@@ -570,7 +570,7 @@ bool_to_string(PyArrayMethod_Context *context, char *const data[],
 
     while (N--) {
         npy_packed_static_string *out_pss = (npy_packed_static_string *)out;
-        if (npy_string_free(out_pss, allocator) < 0) {
+        if (NpyString_free(out_pss, allocator) < 0) {
             gil_error(PyExc_MemoryError,
                       "Failed to deallocate string in bool to string cast");
             goto fail;
@@ -590,7 +590,7 @@ bool_to_string(PyArrayMethod_Context *context, char *const data[],
                       "invalid value encountered in bool to string cast");
             goto fail;
         }
-        if (npy_string_newsize(ret_val, size, out_pss, allocator) < 0) {
+        if (NpyString_newsize(ret_val, size, out_pss, allocator) < 0) {
             // execution should never get here because this will be a small
             // string on all platforms
             gil_error(PyExc_MemoryError,
@@ -628,7 +628,7 @@ string_to_pylong(char *in, int hasnull,
 {
     const npy_packed_static_string *ps = (npy_packed_static_string *)in;
     npy_static_string s = {0, NULL};
-    int isnull = npy_string_load(allocator, ps, &s);
+    int isnull = NpyString_load(allocator, ps, &s);
     if (isnull == -1) {
         PyErr_SetString(PyExc_MemoryError,
                         "Failed to load string converting string to int");
@@ -709,13 +709,13 @@ pyobj_to_string(PyObject *obj, char *out, npy_string_allocator *allocator)
         return -1;
     }
     npy_packed_static_string *out_ss = (npy_packed_static_string *)out;
-    if (npy_string_free(out_ss, allocator) < 0) {
+    if (NpyString_free(out_ss, allocator) < 0) {
         gil_error(PyExc_MemoryError,
                   "Failed to deallocate string when converting from python "
                   "string");
         return -1;
     }
-    if (npy_string_newsize(cstr_val, length, out_ss, allocator) < 0) {
+    if (NpyString_newsize(cstr_val, length, out_ss, allocator) < 0) {
         PyErr_SetString(PyExc_MemoryError,
                         "Failed to allocate numpy string when converting from "
                         "python string.");
@@ -925,7 +925,7 @@ string_to_pyfloat(char *in, int hasnull,
 {
     const npy_packed_static_string *ps = (npy_packed_static_string *)in;
     npy_static_string s = {0, NULL};
-    int isnull = npy_string_load(allocator, ps, &s);
+    int isnull = NpyString_load(allocator, ps, &s);
     if (isnull == -1) {
         PyErr_SetString(
                 PyExc_MemoryError,
@@ -1186,7 +1186,7 @@ string_to_datetime(PyArrayMethod_Context *context, char *const data[],
     while (N--) {
         const npy_packed_static_string *ps = (npy_packed_static_string *)in;
         npy_static_string s = {0, NULL};
-        int is_null = npy_string_load(allocator, ps, &s);
+        int is_null = NpyString_load(allocator, ps, &s);
         if (is_null == -1) {
             // do we hold the gil in this cast? error handling below seems to
             // think we do
@@ -1260,7 +1260,7 @@ datetime_to_string(PyArrayMethod_Context *context, char *const data[],
 
     while (N--) {
         npy_packed_static_string *out_pss = (npy_packed_static_string *)out;
-        if (npy_string_free(out_pss, allocator) < 0) {
+        if (NpyString_free(out_pss, allocator) < 0) {
             gil_error(
                     PyExc_MemoryError,
                     "Failed to deallocate string in datetime to string cast");
@@ -1284,8 +1284,8 @@ datetime_to_string(PyArrayMethod_Context *context, char *const data[],
                 goto fail;
             }
 
-            if (npy_string_newsize(datetime_buf, strlen(datetime_buf), out_pss,
-                                   allocator) < 0) {
+            if (NpyString_newsize(datetime_buf, strlen(datetime_buf), out_pss,
+                                  allocator) < 0) {
                 PyErr_SetString(PyExc_MemoryError,
                                 "Failed to allocate string when converting "
                                 "from a datetime.");

stringdtype/stringdtype/src/dtype.c

@@ -23,8 +23,8 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
         return NULL;
     }
 
-    allocator = npy_string_new_allocator(PyMem_RawMalloc, PyMem_RawFree,
-                                         PyMem_RawRealloc);
+    allocator = NpyString_new_allocator(PyMem_RawMalloc, PyMem_RawFree,
+                                        PyMem_RawRealloc);
 
     if (allocator == NULL) {
         PyErr_SetString(PyExc_MemoryError,
@@ -49,8 +49,8 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
             has_string_na = 1;
             Py_ssize_t size = 0;
             const char *buf = PyUnicode_AsUTF8AndSize(na_object, &size);
-            if (npy_string_newsize(buf, (size_t)size, &packed_default_string,
-                                   allocator) < 0) {
+            if (NpyString_newsize(buf, (size_t)size, &packed_default_string,
+                                  allocator) < 0) {
                 PyErr_SetString(PyExc_MemoryError,
                                 "Failed to allocate string while creating "
                                 "StringDType instance.");
@@ -86,8 +86,8 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
             Py_DECREF(na_pystr);
             goto fail;
         }
-        if (npy_string_newsize(utf8_ptr, (size_t)size, &packed_na_name,
-                               allocator) < 0) {
+        if (NpyString_newsize(utf8_ptr, (size_t)size, &packed_na_name,
+                              allocator) < 0) {
             PyErr_SetString(PyExc_MemoryError,
                             "Failed to allocate string while creating "
                             "StringDType instance.");
@@ -109,8 +109,8 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
     snew->array_owned = 0;
 
     npy_static_string default_string = {0, NULL};
-    if (npy_string_load(allocator, &snew->packed_default_string,
-                        &default_string) == -1) {
+    if (NpyString_load(allocator, &snew->packed_default_string,
+                       &default_string) == -1) {
         PyErr_SetString(PyExc_MemoryError,
                         "Failed to load packed string while "
                         "creating StringDType instance.");
@@ -119,7 +119,7 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
     }
 
     npy_static_string na_name = {0, NULL};
-    if (npy_string_load(allocator, &snew->packed_na_name, &na_name) == -1) {
+    if (NpyString_load(allocator, &snew->packed_na_name, &na_name) == -1) {
         PyErr_SetString(PyExc_MemoryError,
                         "Failed to load packed string while "
                         "creating StringDType instance.");
@@ -150,9 +150,9 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
     // this only makes sense if the allocator isn't attached to new yet
     Py_DECREF(new);
     if (allocator != NULL) {
-        npy_string_free(&packed_na_name, allocator);
-        npy_string_free(&packed_default_string, allocator);
-        npy_string_free_allocator(allocator);
+        NpyString_free(&packed_na_name, allocator);
+        NpyString_free(&packed_default_string, allocator);
+        NpyString_free_allocator(allocator);
     }
     if (allocator_lock != NULL) {
         PyThread_free_lock(allocator_lock);
@@ -291,7 +291,7 @@ stringdtype_setitem(StringDTypeObject *descr, PyObject *obj, char **dataptr)
 
     // free if dataptr holds preexisting string data,
     // npy_string_free does a NULL check and checks for small strings
-    if (npy_string_free(sdata, descr->allocator) < 0) {
+    if (NpyString_free(sdata, descr->allocator) < 0) {
         PyErr_SetString(PyExc_MemoryError,
                         "String deallocation failed in StringDType setitem");
         goto fail;
@@ -319,7 +319,7 @@ stringdtype_setitem(StringDTypeObject *descr, PyObject *obj, char **dataptr)
             goto fail;
         }
 
-        if (npy_string_newsize(val, length, sdata, descr->allocator) < 0) {
+        if (NpyString_newsize(val, length, sdata, descr->allocator) < 0) {
             PyErr_SetString(PyExc_MemoryError,
                             "Failed to allocate string during StringDType "
                             "setitem");
@@ -347,7 +347,7 @@ stringdtype_getitem(StringDTypeObject *descr, char **dataptr)
     npy_static_string sdata = {0, NULL};
     int hasnull = descr->na_object != NULL;
     NPY_STRING_ACQUIRE_ALLOCATOR(descr);
-    int is_null = npy_string_load(descr->allocator, psdata, &sdata);
+    int is_null = NpyString_load(descr->allocator, psdata, &sdata);
 
     if (is_null < 0) {
         PyErr_SetString(PyExc_MemoryError,
@@ -399,7 +399,7 @@ stringdtype_getitem(StringDTypeObject *descr, char **dataptr)
 npy_bool
 nonzero(void *data, void *NPY_UNUSED(arr))
 {
-    return npy_string_size((npy_packed_static_string *)data) != 0;
+    return NpyString_size((npy_packed_static_string *)data) != 0;
 }
 
 // Implementation of PyArray_CompareFunc.
@@ -429,10 +429,10 @@ _compare(void *a, void *b, StringDTypeObject *descr_a,
     npy_static_string *default_string = &descr_a->default_string;
     const npy_packed_static_string *ps_a = (npy_packed_static_string *)a;
     npy_static_string s_a = {0, NULL};
-    int a_is_null = npy_string_load(allocator_a, ps_a, &s_a);
+    int a_is_null = NpyString_load(allocator_a, ps_a, &s_a);
     const npy_packed_static_string *ps_b = (npy_packed_static_string *)b;
     npy_static_string s_b = {0, NULL};
-    int b_is_null = npy_string_load(allocator_b, ps_b, &s_b);
+    int b_is_null = NpyString_load(allocator_b, ps_b, &s_b);
     if (NPY_UNLIKELY(a_is_null == -1 || b_is_null == -1)) {
         char *msg = "Failed to load string in string comparison";
         if (hasnull && !(has_string_na && has_nan_na)) {
@@ -476,7 +476,7 @@ _compare(void *a, void *b, StringDTypeObject *descr_a,
             }
         }
     }
-    return npy_string_cmp(&s_a, &s_b);
+    return NpyString_cmp(&s_a, &s_b);
 }
 
 // PyArray_ArgFunc
@@ -526,7 +526,7 @@ stringdtype_clear_loop(void *NPY_UNUSED(traverse_context),
     while (size--) {
         npy_packed_static_string *sdata = (npy_packed_static_string *)data;
         if (data != NULL) {
-            if (npy_string_free(sdata, sdescr->allocator) < 0) {
+            if (NpyString_free(sdata, sdescr->allocator) < 0) {
                 gil_error(PyExc_MemoryError,
                           "String deallocation failed in clear loop");
                 goto fail;
@@ -703,9 +703,9 @@ stringdtype_dealloc(StringDTypeObject *self)
     if (self->allocator != NULL) {
         // can we assume the destructor for an instance will only get called
         // inside of one C thread?
-        npy_string_free(&self->packed_default_string, self->allocator);
-        npy_string_free(&self->packed_na_name, self->allocator);
-        npy_string_free_allocator(self->allocator);
+        NpyString_free(&self->packed_default_string, self->allocator);
+        NpyString_free(&self->packed_na_name, self->allocator);
+        NpyString_free_allocator(self->allocator);
         PyThread_free_lock(self->allocator_lock);
     }
     PyArrayDescr_Type.tp_dealloc((PyObject *)self);
@@ -958,14 +958,14 @@ free_and_copy(npy_string_allocator *in_allocator,
               const npy_packed_static_string *in,
               npy_packed_static_string *out, const char *location)
 {
-    if (npy_string_free(out, out_allocator) < 0) {
+    if (NpyString_free(out, out_allocator) < 0) {
         char message[200];
         snprintf(message, sizeof(message), "Failed to deallocate string in %s",
                  location);
         gil_error(PyExc_MemoryError, message);
         return -1;
     }
-    if (npy_string_dup(in, out, in_allocator, out_allocator) < 0) {
+    if (NpyString_dup(in, out, in_allocator, out_allocator) < 0) {
         char message[200];
         snprintf(message, sizeof(message), "Failed to allocate string in %s",
                  location);

stringdtype/stringdtype/src/main.c

@@ -58,7 +58,7 @@ _memory_usage(PyObject *NPY_UNUSED(self), PyObject *obj)
         npy_intp count = *innersizeptr;
 
         while (count--) {
-            size_t size = npy_string_size(((npy_packed_static_string *)in));
+            size_t size = NpyString_size(((npy_packed_static_string *)in));
             // FIXME: add a way for a string to report its heap size usage
             if (size > (sizeof(npy_static_string) - 1)) {
                 memory_usage += size;