use more memoryviews

Author: jbrockmendel

pandas/_libs/algos.pyx

@@ -151,7 +151,7 @@ def is_lexsorted(list_of_arrays: list) -> bint:
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def groupsort_indexer(ndarray[int64_t] index, Py_ssize_t ngroups):
+def groupsort_indexer(int64_t[:] index, Py_ssize_t ngroups):
     """
     compute a 1-d indexer that is an ordering of the passed index,
     ordered by the groups. This is a reverse of the label
@@ -373,7 +373,7 @@ ctypedef fused algos_t:
 # TODO: unused; needed?
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cpdef map_indices(ndarray[algos_t] index):
+cpdef map_indices(algos_t[:] index):
     """
     Produce a dict mapping the values of the input array to their respective
     locations.
@@ -397,7 +397,7 @@ cpdef map_indices(ndarray[algos_t] index):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def pad(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
+def pad(algos_t[:] old, algos_t[:] new, limit=None):
     cdef:
         Py_ssize_t i, j, nleft, nright
         ndarray[int64_t, ndim=1] indexer
@@ -475,8 +475,9 @@ pad_bool = pad["uint8_t"]
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def pad_inplace(ndarray[algos_t] values,
+def pad_inplace(algos_t[:] values,
                 ndarray[uint8_t, cast=True] mask,
+                # TODO: What does the cast=True mean?  If unneeded, use bint[:]?
                 limit=None):
     cdef:
         Py_ssize_t i, N
@@ -595,7 +596,7 @@ D
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def backfill(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
+def backfill(algos_t[:] old, algos_t[:] new, limit=None):
     cdef:
         Py_ssize_t i, j, nleft, nright
         ndarray[int64_t, ndim=1] indexer
@@ -674,7 +675,7 @@ backfill_bool = backfill["uint8_t"]
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def backfill_inplace(ndarray[algos_t] values,
+def backfill_inplace(algos_t[:] values,
                      ndarray[uint8_t, cast=True] mask,
                      limit=None):
     cdef:
@@ -768,7 +769,7 @@ backfill_2d_inplace_bool = backfill_2d_inplace["uint8_t"]
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def arrmap(ndarray[algos_t] index, object func):
+def arrmap(algos_t[:] index, object func):
     cdef:
         Py_ssize_t length = index.shape[0]
         Py_ssize_t i = 0
@@ -793,7 +794,7 @@ arrmap_bool = arrmap["uint8_t"]
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def is_monotonic(ndarray[algos_t] arr, bint timelike):
+def is_monotonic(algos_t[:] arr, bint timelike):
     """
     Returns
     -------

pandas/_libs/lib.pyx

@@ -1909,7 +1909,7 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
+def maybe_convert_objects(ndarray[object, ndim=1] objects, bint try_float=0,
                           bint safe=0, bint convert_datetime=0,
                           bint convert_timedelta=0):
     """

pandas/_libs/reduction.pyx

@@ -438,6 +438,7 @@ cdef inline _extract_result(object res):
                 res = res[0]
     return res
 
+
 cdef class Slider:
     """
     Only handles contiguous data for now

pandas/_libs/sparse.pyx

@@ -315,6 +315,7 @@ cpdef get_blocks(ndarray[int32_t, ndim=1] indices):
     lens = lens[:result_indexer]
     return locs, lens
 
+
 # -----------------------------------------------------------------------------
 # BlockIndex
 
@@ -805,10 +806,11 @@ include "sparse_op_helper.pxi"
 # Indexing operations
 
 def get_reindexer(ndarray[object, ndim=1] values, dict index_map):
-    cdef object idx
-    cdef Py_ssize_t i
-    cdef Py_ssize_t new_length = len(values)
-    cdef ndarray[int32_t, ndim=1] indexer
+    cdef:
+        object idx
+        Py_ssize_t i
+        Py_ssize_t new_length = len(values)
+        ndarray[int32_t, ndim=1] indexer
 
     indexer = np.empty(new_length, dtype=np.int32)
 
@@ -861,10 +863,11 @@ def reindex_integer(ndarray[float64_t, ndim=1] values,
 # SparseArray mask create operations
 
 def make_mask_object_ndarray(ndarray[object, ndim=1] arr, object fill_value):
-    cdef object value
-    cdef Py_ssize_t i
-    cdef Py_ssize_t new_length = len(arr)
-    cdef ndarray[int8_t, ndim=1] mask
+    cdef:
+        object value
+        Py_ssize_t i
+        Py_ssize_t new_length = len(arr)
+        ndarray[int8_t, ndim=1] mask
 
     mask = np.ones(new_length, dtype=np.int8)
 

pandas/_libs/tslibs/conversion.pyx

@@ -49,10 +49,10 @@ TD_DTYPE = np.dtype('m8[ns]')
 
 UTC = pytz.UTC
 
+
 # ----------------------------------------------------------------------
 # Misc Helpers
 
-# TODO: How to declare np.datetime64 as the input type?
 cdef inline int64_t get_datetime64_nanos(object val) except? -1:
     """
     Extract the value and unit from a np.datetime64 object, then convert the

pandas/_libs/tslibs/timestamps.pyx

@@ -107,6 +107,7 @@ cdef inline _npdivmod(x1, x2):
 try:
     from numpy import divmod as npdivmod
 except ImportError:
+    # numpy < 1.13
     npdivmod = _npdivmod