Merge branch 'master' into perf-never-take

pandas/_libs/internals.pyi

@@ -51,6 +51,7 @@ class BlockPlacement:
     def __len__(self) -> int: ...
     def delete(self, loc) -> BlockPlacement: ...
     def append(self, others: list[BlockPlacement]) -> BlockPlacement: ...
+    def tile_for_unstack(self, factor: int) -> np.ndarray: ...
     def to_slices(self) -> list[BlockPlacement]: ...
 
 class SharedBlock:

pandas/_libs/internals.pyx

@@ -210,6 +210,60 @@ cdef class BlockPlacement:
 
         return self._as_slice
 
+    cpdef BlockPlacement increment_above(self, Py_ssize_t loc):
+        """
+        Increment any entries of 'loc' or above by one.
+        """
+        cdef:
+            slice nv, s = self._ensure_has_slice()
+            Py_ssize_t other_int, start, stop, step, l
+            ndarray newarr
+
+        if s is not None:
+            # see if we are either all-above or all-below, each of which
+            #  have fastpaths available.
+
+            start, stop, step, l = slice_get_indices_ex(s)
+
+            if start < loc and stop <= loc:
+                # We are entirely below, nothing to increment
+                return self
+
+            if start >= loc and stop >= loc:
+                # We are entirely above, we can efficiently increment out slice
+                nv = slice(start + 1, stop + 1, step)
+                return BlockPlacement(nv)
+
+        if loc == 0:
+            # fastpath where we know everything is >= 0
+            newarr = self.as_array + 1
+            return BlockPlacement(newarr)
+
+        newarr = self.as_array.copy()
+        newarr[newarr >= loc] += 1
+        return BlockPlacement(newarr)
+
+    def tile_for_unstack(self, factor: int) -> np.ndarray:
+        """
+        Find the new mgr_locs for the un-stacked version of a Block.
+        """
+        cdef:
+            slice slc = self._ensure_has_slice()
+            slice new_slice
+            ndarray new_placement
+
+        if slc is not None and slc.step == 1:
+            new_slc = slice(slc.start * factor, slc.stop * factor, 1)
+            new_placement = np.arange(new_slc.start, new_slc.stop, dtype=np.intp)
+        else:
+            # Note: test_pivot_table_empty_aggfunc gets here with `slc is not None`
+            mapped = [
+                np.arange(x * factor, (x + 1) * factor, dtype=np.intp)
+                for x in self
+            ]
+            new_placement = np.concatenate(mapped)
+        return new_placement
+
     def to_slices(self):
         """
         Decompose a BlockPlacement into a list of BlockPlacements, each of