PERF/REF: require BlockPlacement in Block.__init__

pandas/core/internals/api.py

@@ -13,7 +13,10 @@
 from pandas._libs.internals import BlockPlacement
 from pandas._typing import Dtype
 
-from pandas.core.dtypes.common import is_datetime64tz_dtype
+from pandas.core.dtypes.common import (
+    is_datetime64tz_dtype,
+    pandas_dtype,
+)
 
 from pandas.core.arrays import DatetimeArray
 from pandas.core.internals.blocks import (
@@ -40,11 +43,10 @@ def make_block(
     - Block.make_block_same_class
     - Block.__init__
     """
-    # error: Argument 2 to "extract_pandas_array" has incompatible type
-    # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
-    # Type[complex], Type[bool], Type[object], None]"; expected "Union[dtype[Any],
-    # ExtensionDtype, None]"
-    values, dtype = extract_pandas_array(values, dtype, ndim)  # type: ignore[arg-type]
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+
+    values, dtype = extract_pandas_array(values, dtype, ndim)
 
     if klass is None:
         dtype = dtype or values.dtype

pandas/core/internals/blocks.py

@@ -153,7 +153,7 @@ def _simple_new(
         obj._mgr_locs = placement
         return obj
 
-    def __init__(self, values, placement, ndim: int):
+    def __init__(self, values, placement: BlockPlacement, ndim: int):
         """
         Parameters
         ----------
@@ -163,8 +163,10 @@ def __init__(self, values, placement, ndim: int):
         ndim : int
             1 for SingleBlockManager/Series, 2 for BlockManager/DataFrame
         """
+        assert isinstance(ndim, int)
+        assert isinstance(placement, BlockPlacement)
         self.ndim = ndim
-        self.mgr_locs = placement
+        self._mgr_locs = placement
         self.values = values
 
     @property
@@ -243,14 +245,12 @@ def fill_value(self):
         return np.nan
 
     @property
-    def mgr_locs(self):
+    def mgr_locs(self) -> BlockPlacement:
         return self._mgr_locs
 
     @mgr_locs.setter
-    def mgr_locs(self, new_mgr_locs):
-        if not isinstance(new_mgr_locs, libinternals.BlockPlacement):
-            new_mgr_locs = libinternals.BlockPlacement(new_mgr_locs)
-
+    def mgr_locs(self, new_mgr_locs: BlockPlacement):
+        assert isinstance(new_mgr_locs, BlockPlacement)
         self._mgr_locs = new_mgr_locs
 
     @final
@@ -269,7 +269,9 @@ def make_block(self, values, placement=None) -> Block:
         return new_block(values, placement=placement, ndim=self.ndim)
 
     @final
-    def make_block_same_class(self, values, placement=None) -> Block:
+    def make_block_same_class(
+        self, values, placement: Optional[BlockPlacement] = None
+    ) -> Block:
         """ Wrap given values in a block of same type as self. """
         if placement is None:
             placement = self.mgr_locs
@@ -1228,7 +1230,11 @@ def func(yvalues: np.ndarray) -> np.ndarray:
         return self._maybe_downcast(blocks, downcast)
 
     def take_nd(
-        self, indexer, axis: int, new_mgr_locs=None, fill_value=lib.no_default
+        self,
+        indexer,
+        axis: int,
+        new_mgr_locs: Optional[BlockPlacement] = None,
+        fill_value=lib.no_default,
     ) -> Block:
         """
         Take values according to indexer and return them as a block.bb
@@ -1576,7 +1582,11 @@ def to_native_types(self, na_rep="nan", quoting=None, **kwargs):
         return self.make_block(new_values)
 
     def take_nd(
-        self, indexer, axis: int = 0, new_mgr_locs=None, fill_value=lib.no_default
+        self,
+        indexer,
+        axis: int = 0,
+        new_mgr_locs: Optional[BlockPlacement] = None,
+        fill_value=lib.no_default,
     ) -> Block:
         """
         Take values according to indexer and return them as a block.
@@ -1743,7 +1753,7 @@ def _unstack(self, unstacker, fill_value, new_placement):
         blocks = [
             self.make_block_same_class(
                 self.values.take(indices, allow_fill=True, fill_value=fill_value),
-                [place],
+                BlockPlacement(place),
             )
             for indices, place in zip(new_values.T, new_placement)
         ]
@@ -2287,8 +2297,8 @@ def check_ndim(values, placement: BlockPlacement, ndim: int):
 
 
 def extract_pandas_array(
-    values: ArrayLike, dtype: Optional[DtypeObj], ndim: int
-) -> Tuple[ArrayLike, Optional[DtypeObj]]:
+    values: Union[np.ndarray, ExtensionArray], dtype: Optional[DtypeObj], ndim: int
+) -> Tuple[Union[np.ndarray, ExtensionArray], Optional[DtypeObj]]:
     """
     Ensure that we don't allow PandasArray / PandasDtype in internals.
     """

pandas/core/internals/managers.py

@@ -23,6 +23,7 @@
     internals as libinternals,
     lib,
 )
+from pandas._libs.internals import BlockPlacement
 from pandas._typing import (
     ArrayLike,
     Dtype,
@@ -238,7 +239,8 @@ def make_empty(self: T, axes=None) -> T:
             assert isinstance(self, SingleBlockManager)  # for mypy
             blk = self.blocks[0]
             arr = blk.values[:0]
-            nb = blk.make_block_same_class(arr, placement=slice(0, 0))
+            bp = BlockPlacement(slice(0, 0))
+            nb = blk.make_block_same_class(arr, placement=bp)
             blocks = [nb]
         else:
             blocks = []
@@ -784,7 +786,7 @@ def _combine(
         new_blocks: List[Block] = []
         for b in blocks:
             b = b.copy(deep=copy)
-            b.mgr_locs = inv_indexer[b.mgr_locs.indexer]
+            b.mgr_locs = BlockPlacement(inv_indexer[b.mgr_locs.indexer])
             new_blocks.append(b)
 
         axes = list(self.axes)
@@ -1052,8 +1054,9 @@ def iget(self, i: int) -> SingleBlockManager:
         values = block.iget(self.blklocs[i])
 
         # shortcut for select a single-dim from a 2-dim BM
+        bp = BlockPlacement(slice(0, len(values)))
         values = maybe_coerce_values(values)
-        nb = type(block)(values, placement=slice(0, len(values)), ndim=1)
+        nb = type(block)(values, placement=bp, ndim=1)
         return SingleBlockManager(nb, self.axes[1])
 
     def iget_values(self, i: int) -> ArrayLike:
@@ -1265,7 +1268,7 @@ def insert(
             else:
                 new_mgr_locs = blk.mgr_locs.as_array.copy()
                 new_mgr_locs[new_mgr_locs >= loc] += 1
-                blk.mgr_locs = new_mgr_locs
+                blk.mgr_locs = BlockPlacement(new_mgr_locs)
 
         # Accessing public blklocs ensures the public versions are initialized
         if loc == self.blklocs.shape[0]:
@@ -1393,7 +1396,8 @@ def _slice_take_blocks_ax0(
                 if sllen == 0:
                     return []
                 # TODO: tests all have isinstance(slobj, slice), other possibilities?
-                return [blk.getitem_block(slobj, new_mgr_locs=slice(0, sllen))]
+                bp = BlockPlacement(slice(0, sllen))
+                return [blk.getitem_block(slobj, new_mgr_locs=bp)]
             elif not allow_fill or self.ndim == 1:
                 if allow_fill and fill_value is None:
                     fill_value = blk.fill_value
@@ -1402,18 +1406,21 @@ def _slice_take_blocks_ax0(
                     # GH#33597 slice instead of take, so we get
                     #  views instead of copies
                     blocks = [
-                        blk.getitem_block(slice(ml, ml + 1), new_mgr_locs=i)
+                        blk.getitem_block(
+                            slice(ml, ml + 1), new_mgr_locs=BlockPlacement(i)
+                        )
                         for i, ml in enumerate(slobj)
                     ]
                     # We have
                     #  all(np.shares_memory(nb.values, blk.values) for nb in blocks)
                     return blocks
                 else:
+                    bp = BlockPlacement(slice(0, sllen))
                     return [
                         blk.take_nd(
                             slobj,
                             axis=0,
-                            new_mgr_locs=slice(0, sllen),
+                            new_mgr_locs=bp,
                             fill_value=fill_value,
                         )
                     ]
@@ -1450,7 +1457,7 @@ def _slice_take_blocks_ax0(
                     # item.
                     for mgr_loc in mgr_locs:
                         newblk = blk.copy(deep=False)
-                        newblk.mgr_locs = slice(mgr_loc, mgr_loc + 1)
+                        newblk.mgr_locs = BlockPlacement(slice(mgr_loc, mgr_loc + 1))
                         blocks.append(newblk)
 
                 else:
@@ -1647,12 +1654,15 @@ def getitem_mgr(self, indexer) -> SingleBlockManager:
         # similar to get_slice, but not restricted to slice indexer
         blk = self._block
         array = blk._slice(indexer)
-        if array.ndim > blk.values.ndim:
+        if array.ndim > 1:
             # This will be caught by Series._get_values
             raise ValueError("dimension-expanding indexing not allowed")
 
-        block = blk.make_block_same_class(array, placement=slice(0, len(array)))
-        return type(self)(block, self.index[indexer])
+        bp = BlockPlacement(slice(0, len(array)))
+        block = blk.make_block_same_class(array, placement=bp)
+
+        new_idx = self.index[indexer]
+        return type(self)(block, new_idx)
 
     def get_slice(self, slobj: slice, axis: int = 0) -> SingleBlockManager:
         assert isinstance(slobj, slice), type(slobj)
@@ -1664,7 +1674,8 @@ def get_slice(self, slobj: slice, axis: int = 0) -> SingleBlockManager:
         if array.ndim > blk.values.ndim:
             # This will be caught by Series._get_values
             raise ValueError("dimension-expanding indexing not allowed")
-        block = blk.make_block_same_class(array, placement=slice(0, len(array)))
+        bp = BlockPlacement(slice(0, len(array)))
+        block = blk.make_block_same_class(array, placement=bp)
         new_index = self.index._getitem_slice(slobj)
         return type(self)(block, new_index)
 
@@ -1728,7 +1739,7 @@ def set_values(self, values: ArrayLike):
         valid for the current Block/SingleBlockManager (length, dtype, etc).
         """
         self.blocks[0].values = values
-        self.blocks[0]._mgr_locs = libinternals.BlockPlacement(slice(len(values)))
+        self.blocks[0]._mgr_locs = BlockPlacement(slice(len(values)))
 
 
 # --------------------------------------------------------------------
@@ -1995,7 +2006,8 @@ def _merge_blocks(
         new_values = new_values[argsort]
         new_mgr_locs = new_mgr_locs[argsort]
 
-        return [new_block(new_values, placement=new_mgr_locs, ndim=2)]
+        bp = BlockPlacement(new_mgr_locs)
+        return [new_block(new_values, placement=bp, ndim=2)]
 
     # can't consolidate --> no merge
     return blocks

pandas/core/internals/ops.py

@@ -87,7 +87,7 @@ def _reset_block_mgr_locs(nbs: List[Block], locs):
     Reset mgr_locs to correspond to our original DataFrame.
     """
     for nb in nbs:
-        nblocs = locs.as_array[nb.mgr_locs.indexer]
+        nblocs = locs[nb.mgr_locs.indexer]
         nb.mgr_locs = nblocs
         # Assertions are disabled for performance, but should hold:
         #  assert len(nblocs) == nb.shape[0], (len(nblocs), nb.shape)

pandas/tests/extension/test_external_block.py

@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs.internals import BlockPlacement
+
 import pandas as pd
 from pandas.core.internals import BlockManager
 from pandas.core.internals.blocks import ExtensionBlock
@@ -17,7 +19,8 @@ def df():
     df1 = pd.DataFrame({"a": [1, 2, 3]})
     blocks = df1._mgr.blocks
     values = np.arange(3, dtype="int64")
-    custom_block = CustomBlock(values, placement=slice(1, 2), ndim=2)
+    bp = BlockPlacement(slice(1, 2))
+    custom_block = CustomBlock(values, placement=bp, ndim=2)
     blocks = blocks + (custom_block,)
     block_manager = BlockManager(blocks, [pd.Index(["a", "b"]), df1.index])
     return pd.DataFrame(block_manager)

pandas/tests/internals/test_internals.py

@@ -327,8 +327,8 @@ def test_duplicate_ref_loc_failure(self):
 
         axes, blocks = tmp_mgr.axes, tmp_mgr.blocks
 
-        blocks[0].mgr_locs = np.array([0])
-        blocks[1].mgr_locs = np.array([0])
+        blocks[0].mgr_locs = BlockPlacement(np.array([0]))
+        blocks[1].mgr_locs = BlockPlacement(np.array([0]))
 
         # test trying to create block manager with overlapping ref locs
 
@@ -338,8 +338,8 @@ def test_duplicate_ref_loc_failure(self):
             mgr = BlockManager(blocks, axes)
             mgr._rebuild_blknos_and_blklocs()
 
-        blocks[0].mgr_locs = np.array([0])
-        blocks[1].mgr_locs = np.array([1])
+        blocks[0].mgr_locs = BlockPlacement(np.array([0]))
+        blocks[1].mgr_locs = BlockPlacement(np.array([1]))
         mgr = BlockManager(blocks, axes)
         mgr.iget(1)