Modernize the fix for pandas-dev#10043

Author: xhochy

doc/source/whatsnew/v0.24.0.txt

@@ -425,6 +425,7 @@ Other
 
 - :meth: `~pandas.io.formats.style.Styler.background_gradient` now takes a ``text_color_threshold`` parameter to automatically lighten the text color based on the luminance of the background color. This improves readability with dark background colors without the need to limit the background colormap range. (:issue:`21258`)
 - Require at least 0.28.2 version of ``cython`` to support read-only memoryviews (:issue:`21688`)
+- Utilize cython version to simplify the treatment of read-only memoryviews in take_nd (:issue:`10043`)
 -
 -
 -

pandas/_libs/algos_take_helper.pxi.in

@@ -36,87 +36,6 @@ dtypes = [
 
 def get_dispatch(dtypes):
 
-    inner_take_1d_template = """
-    cdef:
-        Py_ssize_t i, n, idx
-        %(c_type_out)s fv
-
-    n = indexer.shape[0]
-
-    fv = fill_value
-
-    %(nogil_str)s
-    %(tab)sfor i from 0 <= i < n:
-    %(tab)s    idx = indexer[i]
-    %(tab)s    if idx == -1:
-    %(tab)s        out[i] = fv
-    %(tab)s    else:
-    %(tab)s        out[i] = %(preval)svalues[idx]%(postval)s
-"""
-
-    inner_take_2d_axis0_template = """\
-    cdef:
-        Py_ssize_t i, j, k, n, idx
-        %(c_type_out)s fv
-
-    n = len(indexer)
-    k = values.shape[1]
-
-    fv = fill_value
-
-    IF %(can_copy)s:
-        cdef:
-            %(c_type_out)s *v
-            %(c_type_out)s *o
-
-        #GH3130
-        if (values.strides[1] == out.strides[1] and
-            values.strides[1] == sizeof(%(c_type_out)s) and
-            sizeof(%(c_type_out)s) * n >= 256):
-
-            for i from 0 <= i < n:
-                idx = indexer[i]
-                if idx == -1:
-                    for j from 0 <= j < k:
-                        out[i, j] = fv
-                else:
-                    v = &values[idx, 0]
-                    o = &out[i, 0]
-                    memmove(o, v, <size_t>(sizeof(%(c_type_out)s) * k))
-            return
-
-    for i from 0 <= i < n:
-        idx = indexer[i]
-        if idx == -1:
-            for j from 0 <= j < k:
-                out[i, j] = fv
-        else:
-            for j from 0 <= j < k:
-                out[i, j] = %(preval)svalues[idx, j]%(postval)s
-"""
-
-    inner_take_2d_axis1_template = """\
-    cdef:
-        Py_ssize_t i, j, k, n, idx
-        %(c_type_out)s fv
-
-    n = len(values)
-    k = len(indexer)
-
-    if n == 0 or k == 0:
-        return
-
-    fv = fill_value
-
-    for i from 0 <= i < n:
-        for j from 0 <= j < k:
-            idx = indexer[j]
-            if idx == -1:
-                out[i, j] = fv
-            else:
-                out[i, j] = %(preval)svalues[i, idx]%(postval)s
-"""
-
     for (name, dest, c_type_in, c_type_out, preval, postval,
          can_copy, nogil) in dtypes:
         if nogil:
@@ -126,108 +45,112 @@ def get_dispatch(dtypes):
             nogil_str = ''
             tab = ''
 
-        args = dict(name=name, dest=dest, c_type_in=c_type_in,
-                    c_type_out=c_type_out, preval=preval, postval=postval,
-                    can_copy=can_copy, nogil_str=nogil_str, tab=tab)
-
-        inner_take_1d = inner_take_1d_template % args
-        inner_take_2d_axis0 = inner_take_2d_axis0_template % args
-        inner_take_2d_axis1 = inner_take_2d_axis1_template % args
-
         yield (name, dest, c_type_in, c_type_out, preval, postval, can_copy,
-               inner_take_1d, inner_take_2d_axis0, inner_take_2d_axis1)
+               nogil_str, tab)
 
 }}
 
 
 {{for name, dest, c_type_in, c_type_out, preval, postval, can_copy,
-      inner_take_1d, inner_take_2d_axis0, inner_take_2d_axis1
+      nogil_str, tab
       in get_dispatch(dtypes)}}
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cdef inline take_1d_{{name}}_{{dest}}_memview({{c_type_in}}[:] values,
-                                              int64_t[:] indexer,
-                                              {{c_type_out}}[:] out,
-                                              fill_value=np.nan):
-
-
-{{inner_take_1d}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def take_1d_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=1] values,
-                              int64_t[:] indexer,
+def take_1d_{{name}}_{{dest}}({{if c_type_in != 'object'}}const{{endif}} {{c_type_in}}[:] values,
+                              const int64_t[:] indexer,
                               {{c_type_out}}[:] out,
                               fill_value=np.nan):
+    cdef:
+        Py_ssize_t i, n, idx
+        {{c_type_out}} fv
 
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_1d_{{name}}_{{dest}}_memview(values, indexer, out,
-                                          fill_value=fill_value)
-        return
-
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_1d}}
+    n = indexer.shape[0]
 
+    fv = fill_value
 
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline take_2d_axis0_{{name}}_{{dest}}_memview({{c_type_in}}[:, :] values,
-                                                    int64_t[:] indexer,
-                                                    {{c_type_out}}[:, :] out,
-                                                    fill_value=np.nan):
-{{inner_take_2d_axis0}}
+    {{nogil_str}}
+    {{tab}}for i from 0 <= i < n:
+    {{tab}}    idx = indexer[i]
+    {{tab}}    if idx == -1:
+    {{tab}}        out[i] = fv
+    {{tab}}    else:
+    {{tab}}        out[i] = {{preval}}values[idx]{{postval}}
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def take_2d_axis0_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
-                                    ndarray[int64_t] indexer,
+def take_2d_axis0_{{name}}_{{dest}}({{if c_type_in != 'object'}}const{{endif}} {{c_type_in}}[:, :] values,
+                                    const int64_t[:] indexer,
                                     {{c_type_out}}[:, :] out,
                                     fill_value=np.nan):
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_2d_axis0_{{name}}_{{dest}}_memview(values, indexer, out,
-                                                fill_value=fill_value)
-        return
+    cdef:
+        Py_ssize_t i, j, k, n, idx
+        {{c_type_out}} fv
 
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_2d_axis0}}
+    n = len(indexer)
+    k = values.shape[1]
 
+    fv = fill_value
 
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline take_2d_axis1_{{name}}_{{dest}}_memview({{c_type_in}}[:, :] values,
-                                                    int64_t[:] indexer,
-                                                    {{c_type_out}}[:, :] out,
-                                                    fill_value=np.nan):
-{{inner_take_2d_axis1}}
+    {{if can_copy}}
+    cdef:
+        {{c_type_out}} *v
+        {{c_type_out}} *o
+
+    #GH3130
+    if (values.strides[1] == out.strides[1] and
+        values.strides[1] == sizeof({{c_type_out}}) and
+        sizeof({{c_type_out}}) * n >= 256):
+
+        for i from 0 <= i < n:
+            idx = indexer[i]
+            if idx == -1:
+                for j from 0 <= j < k:
+                    out[i, j] = fv
+            else:
+                v = &values[idx, 0]
+                o = &out[i, 0]
+                memmove(o, v, <size_t>(sizeof({{c_type_out}}) * k))
+        return
+    {{endif}}
+
+    for i from 0 <= i < n:
+        idx = indexer[i]
+        if idx == -1:
+            for j from 0 <= j < k:
+                out[i, j] = fv
+        else:
+            for j from 0 <= j < k:
+                out[i, j] = {{preval}}values[idx, j]{{postval}}
 
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def take_2d_axis1_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
-                                    ndarray[int64_t] indexer,
+def take_2d_axis1_{{name}}_{{dest}}({{if c_type_in != 'object'}}const{{endif}} {{c_type_in}}[:, :] values,
+                                    const int64_t[:] indexer,
                                     {{c_type_out}}[:, :] out,
                                     fill_value=np.nan):
+    cdef:
+        Py_ssize_t i, j, k, n, idx
+        {{c_type_out}} fv
 
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_2d_axis1_{{name}}_{{dest}}_memview(values, indexer, out,
-                                                fill_value=fill_value)
+    n = len(values)
+    k = len(indexer)
+
+    if n == 0 or k == 0:
         return
 
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_2d_axis1}}
+    fv = fill_value
+
+    for i from 0 <= i < n:
+        for j from 0 <= j < k:
+            idx = indexer[j]
+            if idx == -1:
+                out[i, j] = fv
+            else:
+                out[i, j] = {{preval}}values[i, idx]{{postval}}
 
 
 @cython.wraparound(False)