REF: avoid getattr pattern for join_indexer (pandas-dev#29117)

Author: jbrockmendel

pandas/_libs/join.pyx

@@ -290,14 +290,6 @@ def left_join_indexer_unique(join_t[:] left, join_t[:] right):
     return indexer
 
 
-left_join_indexer_unique_float64 = left_join_indexer_unique["float64_t"]
-left_join_indexer_unique_float32 = left_join_indexer_unique["float32_t"]
-left_join_indexer_unique_object = left_join_indexer_unique["object"]
-left_join_indexer_unique_int32 = left_join_indexer_unique["int32_t"]
-left_join_indexer_unique_int64 = left_join_indexer_unique["int64_t"]
-left_join_indexer_unique_uint64 = left_join_indexer_unique["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def left_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
@@ -401,14 +393,6 @@ def left_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-left_join_indexer_float64 = left_join_indexer["float64_t"]
-left_join_indexer_float32 = left_join_indexer["float32_t"]
-left_join_indexer_object = left_join_indexer["object"]
-left_join_indexer_int32 = left_join_indexer["int32_t"]
-left_join_indexer_int64 = left_join_indexer["int64_t"]
-left_join_indexer_uint64 = left_join_indexer["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def inner_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
@@ -502,14 +486,6 @@ def inner_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-inner_join_indexer_float64 = inner_join_indexer["float64_t"]
-inner_join_indexer_float32 = inner_join_indexer["float32_t"]
-inner_join_indexer_object = inner_join_indexer["object"]
-inner_join_indexer_int32 = inner_join_indexer["int32_t"]
-inner_join_indexer_int64 = inner_join_indexer["int64_t"]
-inner_join_indexer_uint64 = inner_join_indexer["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def outer_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
@@ -639,14 +615,6 @@ def outer_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-outer_join_indexer_float64 = outer_join_indexer["float64_t"]
-outer_join_indexer_float32 = outer_join_indexer["float32_t"]
-outer_join_indexer_object = outer_join_indexer["object"]
-outer_join_indexer_int32 = outer_join_indexer["int32_t"]
-outer_join_indexer_int64 = outer_join_indexer["int64_t"]
-outer_join_indexer_uint64 = outer_join_indexer["uint64_t"]
-
-
 # ----------------------------------------------------------------------
 # asof_join_by
 # ----------------------------------------------------------------------

pandas/core/indexes/datetimes.py

@@ -230,11 +230,11 @@ class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
     def _join_i8_wrapper(joinf, **kwargs):
         return DatetimeIndexOpsMixin._join_i8_wrapper(joinf, dtype="M8[ns]", **kwargs)
 
-    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer_int64)
-    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer_int64)
-    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer_int64)
+    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer)
+    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer)
+    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer)
     _left_indexer_unique = _join_i8_wrapper(
-        libjoin.left_join_indexer_unique_int64, with_indexers=False
+        libjoin.left_join_indexer_unique, with_indexers=False
     )
 
     _engine_type = libindex.DatetimeEngine

pandas/core/indexes/timedeltas.py

@@ -152,11 +152,11 @@ class TimedeltaIndex(
     def _join_i8_wrapper(joinf, **kwargs):
         return DatetimeIndexOpsMixin._join_i8_wrapper(joinf, dtype="m8[ns]", **kwargs)
 
-    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer_int64)
-    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer_int64)
-    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer_int64)
+    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer)
+    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer)
+    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer)
     _left_indexer_unique = _join_i8_wrapper(
-        libjoin.left_join_indexer_unique_int64, with_indexers=False
+        libjoin.left_join_indexer_unique, with_indexers=False
     )
 
     _engine_type = libindex.TimedeltaEngine

pandas/tests/test_join.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 from pandas._libs import join as _join
 
@@ -8,50 +9,46 @@
 
 
 class TestIndexer:
-    def test_outer_join_indexer(self):
-        typemap = [
-            ("int32", _join.outer_join_indexer_int32),
-            ("int64", _join.outer_join_indexer_int64),
-            ("float32", _join.outer_join_indexer_float32),
-            ("float64", _join.outer_join_indexer_float64),
-            ("object", _join.outer_join_indexer_object),
-        ]
-
-        for dtype, indexer in typemap:
-            left = np.arange(3, dtype=dtype)
-            right = np.arange(2, 5, dtype=dtype)
-            empty = np.array([], dtype=dtype)
-
-            result, lindexer, rindexer = indexer(left, right)
-            assert isinstance(result, np.ndarray)
-            assert isinstance(lindexer, np.ndarray)
-            assert isinstance(rindexer, np.ndarray)
-            tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
-            exp = np.array([0, 1, 2, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
-
-            result, lindexer, rindexer = indexer(empty, right)
-            tm.assert_numpy_array_equal(result, right)
-            exp = np.array([-1, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
-
-            result, lindexer, rindexer = indexer(left, empty)
-            tm.assert_numpy_array_equal(result, left)
-            exp = np.array([0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([-1, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
+    @pytest.mark.parametrize(
+        "dtype", ["int32", "int64", "float32", "float64", "object"]
+    )
+    def test_outer_join_indexer(self, dtype):
+        indexer = _join.outer_join_indexer
+
+        left = np.arange(3, dtype=dtype)
+        right = np.arange(2, 5, dtype=dtype)
+        empty = np.array([], dtype=dtype)
+
+        result, lindexer, rindexer = indexer(left, right)
+        assert isinstance(result, np.ndarray)
+        assert isinstance(lindexer, np.ndarray)
+        assert isinstance(rindexer, np.ndarray)
+        tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
+        exp = np.array([0, 1, 2, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(empty, right)
+        tm.assert_numpy_array_equal(result, right)
+        exp = np.array([-1, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(left, empty)
+        tm.assert_numpy_array_equal(result, left)
+        exp = np.array([0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
 
 
 def test_left_join_indexer_unique():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([2, 2, 3, 4, 4], dtype=np.int64)
 
-    result = _join.left_join_indexer_unique_int64(b, a)
+    result = _join.left_join_indexer_unique(b, a)
     expected = np.array([1, 1, 2, 3, 3], dtype=np.int64)
     tm.assert_numpy_array_equal(result, expected)
 
@@ -182,7 +179,7 @@ def test_inner_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.inner_join_indexer_int64(a, b)
+    index, ares, bres = _join.inner_join_indexer(a, b)
 
     index_exp = np.array([3, 5], dtype=np.int64)
     assert_almost_equal(index, index_exp)
@@ -195,7 +192,7 @@ def test_inner_join_indexer():
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.inner_join_indexer_int64(a, b)
+    index, ares, bres = _join.inner_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -205,7 +202,7 @@ def test_outer_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.outer_join_indexer_int64(a, b)
+    index, ares, bres = _join.outer_join_indexer(a, b)
 
     index_exp = np.array([0, 1, 2, 3, 4, 5, 7, 9], dtype=np.int64)
     assert_almost_equal(index, index_exp)
@@ -218,7 +215,7 @@ def test_outer_join_indexer():
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.outer_join_indexer_int64(a, b)
+    index, ares, bres = _join.outer_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -228,7 +225,7 @@ def test_left_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.left_join_indexer_int64(a, b)
+    index, ares, bres = _join.left_join_indexer(a, b)
 
     assert_almost_equal(index, a)
 
@@ -240,7 +237,7 @@ def test_left_join_indexer():
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.left_join_indexer_int64(a, b)
+    index, ares, bres = _join.left_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -250,7 +247,7 @@ def test_left_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.left_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.left_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
     assert_almost_equal(res, exp_res)
@@ -266,7 +263,7 @@ def test_outer_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.outer_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.outer_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
     assert_almost_equal(res, exp_res)
@@ -282,7 +279,7 @@ def test_inner_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.inner_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.inner_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5], dtype=np.int64)
     assert_almost_equal(res, exp_res)