renamed functions

Author: flexatone

README.rst

@@ -40,9 +40,9 @@ What is New in ArrayKit
 0.7.0
 ............
 
-Added ``array2d_to_array1d()``.
+Added ``array_to_tuple_array()``.
 
-Added ``array2d_tuple_iter()``.
+Added ``array_to_tuple_iter()``.
 
 
 0.6.3

doc/articles/array2d_to_1d.py

@@ -3,7 +3,7 @@
 import timeit
 import typing as tp
 
-from arraykit import array2d_to_array1d
+from arraykit import array_to_tuple_array
 import arraykit as ak
 
 import matplotlib.pyplot as plt
@@ -21,11 +21,11 @@ def __init__(self, array: np.ndarray):
 
 #-------------------------------------------------------------------------------
 class AKArray2D1D(ArrayProcessor):
-    NAME = 'ak.array2d_to_array1d()'
+    NAME = 'ak.array_to_tuple_array()'
     SORT = 0
 
     def __call__(self):
-        _ = array2d_to_array1d(self.array)
+        _ = array_to_tuple_array(self.array)
 
 class PyArray2D1D(ArrayProcessor):
     NAME = 'Python construction'
@@ -102,10 +102,10 @@ def plot_performance(frame):
     fig.set_size_inches(8, 4) # width, height
     fig.legend(post, names_display, loc='center right', fontsize=6)
     # horizontal, vertical
-    fig.text(.05, .96, f'array2d_to_array1d() Performance: {NUMBER} Iterations', fontsize=10)
+    fig.text(.05, .96, f'array_to_tuple_array() Performance: {NUMBER} Iterations', fontsize=10)
     fig.text(.05, .90, get_versions(), fontsize=6)
 
-    fp = '/tmp/array2d_to_array1d.png'
+    fp = '/tmp/array_to_tuple_array.png'
     plt.subplots_adjust(
             left=0.05,
             bottom=0.05,

doc/articles/array2d_tuple_iter.py

@@ -3,7 +3,7 @@
 import timeit
 import typing as tp
 
-from arraykit import array2d_tuple_iter
+from arraykit import array_to_tuple_iter
 import arraykit as ak
 
 import matplotlib.pyplot as plt
@@ -21,18 +21,18 @@ def __init__(self, array: np.ndarray):
 
 #-------------------------------------------------------------------------------
 class AKArray2DTupleList(ArrayProcessor):
-    NAME = 'list(ak.array2d_tuple_iter(a2d))'
+    NAME = 'list(ak.array_to_tuple_iter(a2d))'
     SORT = 0
 
     def __call__(self):
-        _ = list(array2d_tuple_iter(self.array))
+        _ = list(array_to_tuple_iter(self.array))
 
 class AKArray2DTupleNext(ArrayProcessor):
-    NAME = 'next(ak.array2d_tuple_iter(a2d))'
+    NAME = 'next(ak.array_to_tuple_iter(a2d))'
     SORT = 1
 
     def __call__(self):
-        it = array2d_tuple_iter(self.array)
+        it = array_to_tuple_iter(self.array)
         while True:
             try:
                 _ = next(it)
@@ -128,10 +128,10 @@ def plot_performance(frame):
     fig.set_size_inches(8, 4) # width, height
     fig.legend(post, names_display, loc='center right', fontsize=6)
     # horizontal, vertical
-    fig.text(.05, .96, f'array2d_tuple_iter() Performance: {NUMBER} Iterations', fontsize=10)
+    fig.text(.05, .96, f'array_to_tuple_iter() Performance: {NUMBER} Iterations', fontsize=10)
     fig.text(.05, .90, get_versions(), fontsize=6)
 
-    fp = '/tmp/array2d_tuple_iter.png'
+    fp = '/tmp/array_to_tuple_iter.png'
     plt.subplots_adjust(
             left=0.05,
             bottom=0.05,

src/__init__.py

@@ -28,6 +28,6 @@
 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 array2d_to_array1d as array2d_to_array1d
-from ._arraykit import array2d_tuple_iter as array2d_tuple_iter
+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

src/__init__.pyi

@@ -161,5 +161,5 @@ 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 slice_to_ascending_slice(__slice: slice, __size: int) -> slice: ...
-def array2d_to_array1d(__array: np.ndarray) -> np.ndarray: ...
-def array2d_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...
+def array_to_tuple_array(__array: np.ndarray) -> np.ndarray: ...
+def array_to_tuple_iter(__array: np.ndarray) -> tp.Iterator[tp.Tuple[tp.Any, ...]]: ...

src/_arraykit.c

@@ -3524,9 +3524,9 @@ array_deepcopy(PyObject *m, PyObject *args, PyObject *kwargs)
 }
 
 //------------------------------------------------------------------------------
-// Given a 2D array, return a 1D object array of tuples.
+// Given a 1D or 2D array, return a 1D object array of tuples.
 static PyObject *
-array2d_to_array1d(PyObject *Py_UNUSED(m), PyObject *a)
+array_to_tuple_array(PyObject *Py_UNUSED(m), PyObject *a)
 {
     AK_CHECK_NUMPY_ARRAY(a);
     PyArrayObject *input_array = (PyArrayObject *)a;
@@ -3714,7 +3714,7 @@ static PyTypeObject A2DTupleType = {
 
 // Given a 2D array, return an iterator of row tuples.
 static PyObject *
-array2d_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
+array_to_tuple_iter(PyObject *Py_UNUSED(m), PyObject *a)
 {
     AK_CHECK_NUMPY_ARRAY(a);
     PyArrayObject *array = (PyArrayObject *)a;
@@ -7480,8 +7480,8 @@ static PyMethodDef arraykit_methods[] =  {
             (PyCFunction)array_deepcopy,
             METH_VARARGS | METH_KEYWORDS,
             NULL},
-    {"array2d_to_array1d", array2d_to_array1d, METH_O, NULL},
-    {"array2d_tuple_iter", array2d_tuple_iter, METH_O, 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",

test/test_util.py

@@ -22,8 +22,8 @@
 from arraykit import first_true_1d
 from arraykit import first_true_2d
 from arraykit import slice_to_ascending_slice
-from arraykit import array2d_to_array1d
-from arraykit import array2d_tuple_iter
+from arraykit import array_to_tuple_array
+from arraykit import array_to_tuple_iter
 
 from performance.reference.util import get_new_indexers_and_screen_ak as get_new_indexers_and_screen_full
 from arraykit import get_new_indexers_and_screen
@@ -288,33 +288,33 @@ def test_array_deepcopy_h(self) -> None:
     #---------------------------------------------------------------------------
     def test_array2d_to_array1d_1d_a(self) -> None:
         a1 = np.arange(10)
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)])
 
     def test_array2d_to_array1d_1d_b(self) -> None:
         a1 = np.array(['aaa', 'b', 'ccc'])
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [('aaa',), ('b',), ('ccc',)])
 
     def test_array2d_to_array1d_1d_c(self) -> None:
         a1 = np.array([None, 'b', 30])
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [(None,), ('b',), (30,)])
 
     def test_array2d_to_array1d_1d_d(self) -> None:
         a1 = np.array([('a', 10), ('b', 30), ('c', 5)], dtype=object)
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [('a', 10), ('b', 30), ('c', 5)])
 
     def test_array2d_to_array1d_1d_e(self) -> None:
         a1 = np.array([True, False, True], dtype=object)
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertIs(a2[0][0].__class__, bool)
         self.assertEqual(a2.tolist(), [(True,), (False,), (True,)])
 
     def test_array2d_to_array1d_b(self) -> None:
         a1 = np.arange(10, dtype=np.int64).reshape(5, 2)
-        result = array2d_to_array1d(a1)
+        result = array_to_tuple_array(a1)
         assert isinstance(result[0], tuple)
         assert result[0] == (0, 1)
         self.assertIs(type(result[0][0]), np.int64)
@@ -324,35 +324,35 @@ def test_array2d_to_array1d_b(self) -> None:
 
     def test_array2d_to_array1d_c(self) -> None:
         a1 = np.array([["a", "b"], ["ccc", "ddd"], ["ee", "ff"]])
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [('a', 'b'), ('ccc', 'ddd'), ('ee', 'ff')])
 
     def test_array2d_to_array1d_d(self) -> None:
         a1 = np.array([[3, 5], [10, 20], [7, 2]], dtype=np.uint8)
-        a2 = array2d_to_array1d(a1)
+        a2 = array_to_tuple_array(a1)
         self.assertEqual(a2.tolist(), [(3, 5), (10, 20), (7, 2)])
         self.assertIs(type(a2[0][0]), np.uint8)
 
     def test_array2d_to_array1d_e(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
-        result = array2d_to_array1d(a1)
+        result = array_to_tuple_array(a1)
         self.assertEqual(result.tolist(), [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
 
     #---------------------------------------------------------------------------
     def test_array2d_tuple_iter_a(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(4, 5)
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(len(result), 4)
         self.assertEqual(result, [(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17, 18, 19)])
 
     def test_array2d_tuple_iter_b(self) -> None:
         a1 = np.arange(20, dtype=np.int64).reshape(10, 2)
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(result, [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11), (12, 13), (14, 15), (16, 17), (18, 19)])
 
     def test_array2d_tuple_iter_c(self) -> None:
         a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         self.assertEqual(it.__length_hint__(), 3)
         self.assertEqual(next(it), ('aaa', 'bb'))
         self.assertEqual(it.__length_hint__(), 2)
@@ -365,48 +365,48 @@ def test_array2d_tuple_iter_c(self) -> None:
 
     def test_array2d_tuple_iter_d(self) -> None:
         a1 = np.array([['aaa', 'bb'], ['c', 'dd'], ['ee', 'fffff']])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         # __reversed__ not implemented
         with self.assertRaises(TypeError):
             reversed(it)
 
     def test_array2d_tuple_iter_e(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it = array2d_tuple_iter(a1)
+        it = array_to_tuple_iter(a1)
         del a1
         self.assertEqual(list(it), [(None, 'bb'), (None, 'dd'), (3, None)])
 
     def test_array2d_tuple_iter_f(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it1 = array2d_tuple_iter(a1)
+        it1 = array_to_tuple_iter(a1)
         del a1
         it2 = iter(it1)
         self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
         self.assertEqual(list(it2), []) # expected behavior
 
     def test_array2d_tuple_iter_g(self) -> None:
         a1 = np.array([[None, 'bb'], [None, 'dd'], [3, None]])
-        it1 = array2d_tuple_iter(a1)
-        it2 = array2d_tuple_iter(a1)
+        it1 = array_to_tuple_iter(a1)
+        it2 = array_to_tuple_iter(a1)
         del a1
         self.assertEqual(list(it1), [(None, 'bb'), (None, 'dd'), (3, None)])
         self.assertEqual(list(it2), [(None, 'bb'), (None, 'dd'), (3, None)])
 
     def test_array2d_tuple_iter_1d_a(self) -> None:
         a1 = np.array(['bb', 'c', 'aaa'])
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(len(result), 3)
         self.assertEqual(result, [('bb',), ('c',), ('aaa',)])
 
     def test_array2d_tuple_iter_1d_b(self) -> None:
         a1 = np.array([20, -1, 8])
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(len(result), 3)
         self.assertEqual(result, [(20,), (-1,), (8,)])
 
     def test_array2d_tuple_iter_1d_c(self) -> None:
         a1 = np.array([('a', 4), ('c', -1), ('d', 8)], dtype=object)
-        result = list(array2d_tuple_iter(a1))
+        result = list(array_to_tuple_iter(a1))
         self.assertEqual(len(result), 3)
         self.assertEqual(result, [('a', 4), ('c', -1), ('d', 8)])