revert edits to be pure cut/paste

Author: jbrockmendel

pandas/_libs/internals.pyx

@@ -3,16 +3,13 @@
 cimport cython
 from cython cimport Py_ssize_t
 
-from cpython cimport PyObject, PyInt_Check
-from cpython.slice cimport PySlice_Check
+cdef extern from "Python.h":
+    Py_ssize_t PY_SSIZE_T_MAX
 
 import numpy as np
 cimport numpy as np
 from numpy cimport int64_t
 
-cdef extern from "Python.h":
-    Py_ssize_t PY_SSIZE_T_MAX
-
 cdef extern from "compat_helper.h":
     cdef int slice_get_indices(PyObject* s, Py_ssize_t length,
                                Py_ssize_t *start, Py_ssize_t *stop,
@@ -22,19 +19,18 @@ cdef extern from "compat_helper.h":
 
 cdef class BlockPlacement:
     # __slots__ = '_as_slice', '_as_array', '_len'
-    cdef:
-        slice _as_slice
-        object _as_array
-        bint _has_slice, _has_array, _is_known_slice_like
+    cdef slice _as_slice
+    cdef object _as_array
+
+    cdef bint _has_slice, _has_array, _is_known_slice_like
 
     def __init__(self, val):
-        cdef:
-            slice slc
+        cdef slice slc
 
         self._has_slice = False
         self._has_array = False
 
-        if PySlice_Check(val):
+        if isinstance(val, slice):
             slc = slice_canonize(val)
 
             if slc.start != slc.stop:
@@ -52,8 +48,7 @@ cdef class BlockPlacement:
             self._has_array = True
 
     def __str__(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is not None:
             v = self._as_slice
         else:
@@ -64,17 +59,15 @@ cdef class BlockPlacement:
     __repr__ = __str__
 
     def __len__(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is not None:
             return slice_len(s)
         else:
             return len(self._as_array)
 
     def __iter__(self):
-        cdef:
-            slice s = self._ensure_has_slice()
-            Py_ssize_t start, stop, step, _
+        cdef slice s = self._ensure_has_slice()
+        cdef Py_ssize_t start, stop, step, _
         if s is not None:
             start, stop, step, _ = slice_get_indices_ex(s)
             return iter(range(start, stop, step))
@@ -83,17 +76,15 @@ cdef class BlockPlacement:
 
     @property
     def as_slice(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is None:
             raise TypeError('Not slice-like')
         else:
             return s
 
     @property
     def indexer(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is not None:
             return s
         else:
@@ -105,8 +96,7 @@ cdef class BlockPlacement:
 
     @property
     def as_array(self):
-        cdef:
-            Py_ssize_t start, stop, end, _
+        cdef Py_ssize_t start, stop, end, _
         if not self._has_array:
             start, stop, step, _ = slice_get_indices_ex(self._as_slice)
             self._as_array = np.arange(start, stop, step,
@@ -116,19 +106,17 @@ cdef class BlockPlacement:
 
     @property
     def is_slice_like(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         return s is not None
 
     def __getitem__(self, loc):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is not None:
             val = slice_getitem(s, loc)
         else:
             val = self._as_array[loc]
 
-        if not PySlice_Check(val) and val.ndim == 0:
+        if not isinstance(val, slice) and val.ndim == 0:
             return val
 
         return BlockPlacement(val)
@@ -144,11 +132,10 @@ cdef class BlockPlacement:
                                              [o.as_array for o in others]))
 
     cdef iadd(self, other):
-        cdef:
-            slice s = self._ensure_has_slice()
-            Py_ssize_t other_int, start, stop, step, l
+        cdef slice s = self._ensure_has_slice()
+        cdef Py_ssize_t other_int, start, stop, step, l
 
-        if PyInt_Check(other) and s is not None:
+        if isinstance(other, int) and s is not None:
             other_int = <Py_ssize_t>other
 
             if other_int == 0:
@@ -182,8 +169,7 @@ cdef class BlockPlacement:
         return self
 
     cdef BlockPlacement copy(self):
-        cdef:
-            slice s = self._ensure_has_slice()
+        cdef slice s = self._ensure_has_slice()
         if s is not None:
             return BlockPlacement(s)
         else:
@@ -202,7 +188,7 @@ cdef class BlockPlacement:
         return self._as_slice
 
 
-cdef slice_canonize(slice s):
+cpdef slice_canonize(slice s):
     """
     Convert slice to canonical bounded form.
     """
@@ -248,8 +234,8 @@ cdef slice_canonize(slice s):
         return slice(start, stop, step)
 
 
-cpdef Py_ssize_t slice_len(slice slc,
-                           Py_ssize_t objlen=PY_SSIZE_T_MAX) except -1:
+cpdef Py_ssize_t slice_len(
+        slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX) except -1:
     """
     Get length of a bounded slice.
 
@@ -293,14 +279,14 @@ cpdef slice_get_indices_ex(slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX):
     return start, stop, step, length
 
 
-cdef slice_getitem(slice slc, ind):
+def slice_getitem(slice slc not None, ind):
     cdef:
         Py_ssize_t s_start, s_stop, s_step, s_len
         Py_ssize_t ind_start, ind_stop, ind_step, ind_len
 
     s_start, s_stop, s_step, s_len = slice_get_indices_ex(slc)
 
-    if PySlice_Check(ind):
+    if isinstance(ind, slice):
         ind_start, ind_stop, ind_step, ind_len = slice_get_indices_ex(ind,
                                                                       s_len)
 
@@ -402,7 +388,7 @@ def get_blkno_indexers(int64_t[:] blknos, bint group=True):
     start = 0
     cur_blkno = blknos[start]
 
-    if group is False:
+    if group == False:
         for i in range(1, n):
             if blknos[i] != cur_blkno:
                 yield cur_blkno, slice(start, i)
@@ -447,4 +433,4 @@ def get_blkno_indexers(int64_t[:] blknos, bint group=True):
                         res_view[i] = diff
                         i += 1
 
-                yield blkno, result
+                yield blkno, result

pandas/tests/internals/test_internals.py

@@ -39,8 +39,8 @@ def mgr():
 def assert_block_equal(left, right):
     tm.assert_numpy_array_equal(left.values, right.values)
     assert left.dtype == right.dtype
-    assert isinstance(left.mgr_locs, lib.BlockPlacement)
-    assert isinstance(right.mgr_locs, lib.BlockPlacement)
+    assert isinstance(left.mgr_locs, BlockPlacement)
+    assert isinstance(right.mgr_locs, BlockPlacement)
     tm.assert_numpy_array_equal(left.mgr_locs.as_array,
                                 right.mgr_locs.as_array)
 
@@ -222,7 +222,7 @@ def _check(blk):
         _check(self.bool_block)
 
     def test_mgr_locs(self):
-        assert isinstance(self.fblock.mgr_locs, lib.BlockPlacement)
+        assert isinstance(self.fblock.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(self.fblock.mgr_locs.as_array,
                                     np.array([0, 2, 4], dtype=np.int64))
 
@@ -264,14 +264,14 @@ def test_insert(self):
     def test_delete(self):
         newb = self.fblock.copy()
         newb.delete(0)
-        assert isinstance(newb.mgr_locs, lib.BlockPlacement)
+        assert isinstance(newb.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(newb.mgr_locs.as_array,
                                     np.array([2, 4], dtype=np.int64))
         assert (newb.values[0] == 1).all()
 
         newb = self.fblock.copy()
         newb.delete(1)
-        assert isinstance(newb.mgr_locs, lib.BlockPlacement)
+        assert isinstance(newb.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(newb.mgr_locs.as_array,
                                     np.array([0, 4], dtype=np.int64))
         assert (newb.values[1] == 2).all()
@@ -679,7 +679,7 @@ def test_consolidate_ordering_issues(self, mgr):
         assert cons.nblocks == 4
         cons = mgr.consolidate().get_numeric_data()
         assert cons.nblocks == 1
-        assert isinstance(cons.blocks[0].mgr_locs, lib.BlockPlacement)
+        assert isinstance(cons.blocks[0].mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(cons.blocks[0].mgr_locs.as_array,
                                     np.arange(len(cons.items), dtype=np.int64))