Finish up

Author: phofl

pandas/core/frame.py

@@ -339,8 +339,7 @@
     * inner: use intersection of keys from both frames, similar to a SQL inner
       join; preserve the order of the left keys.
     * left_semi: Filter for rows in the left that have a match on the right;
-      preserve the order of the left keys. Doesn't support `left_index`, `right_index`,
-      `indicator` or `validate`.
+      preserve the order of the left keys.
 
       .. versionadded:: 3.0
     * cross: creates the cartesian product from both frames, preserves the order

pandas/core/reshape/merge.py

@@ -1054,6 +1054,7 @@ def _validate_how(
             "right",
             "inner",
             "outer",
+            "left_semi",
             "left_anti",
             "right_anti",
             "cross",
@@ -1403,7 +1404,11 @@ def _get_join_info(
         left_ax = self.left.index
         right_ax = self.right.index
 
-        if self.left_index and self.right_index and self.how != "asof":
+        if (
+            self.left_index
+            and self.right_index
+            and self.how not in ("asof", "left_semi")
+        ):
             join_index, left_indexer, right_indexer = left_ax.join(
                 right_ax, how=self.how, return_indexers=True, sort=self.sort
             )
@@ -1647,15 +1652,7 @@ def _get_merge_keys(
                     k = cast(Hashable, k)
                     left_keys.append(left._get_label_or_level_values(k))
                     join_names.append(k)
-            if isinstance(self.right.index, MultiIndex):
-                right_keys = [
-                    lev._values.take(lev_codes)
-                    for lev, lev_codes in zip(
-                        self.right.index.levels, self.right.index.codes
-                    )
-                ]
-            else:
-                right_keys = [self.right.index._values]
+            right_keys = self._unpack_index_as_join_key(self.right.index)
         elif _any(self.right_on):
             for k in self.right_on:
                 k = extract_array(k, extract_numpy=True)
@@ -1669,18 +1666,23 @@ def _get_merge_keys(
                     k = cast(Hashable, k)
                     right_keys.append(right._get_label_or_level_values(k))
                     join_names.append(k)
-            if isinstance(self.left.index, MultiIndex):
-                left_keys = [
-                    lev._values.take(lev_codes)
-                    for lev, lev_codes in zip(
-                        self.left.index.levels, self.left.index.codes
-                    )
-                ]
-            else:
-                left_keys = [self.left.index._values]
+            left_keys = self._unpack_index_as_join_key(self.left.index)
+        elif self.how == "left_semi":
+            left_keys = self._unpack_index_as_join_key(self.left.index)
+            right_keys = self._unpack_index_as_join_key(self.right.index)
 
         return left_keys, right_keys, join_names, left_drop, right_drop
 
+    def _unpack_index_as_join_key(self, index: Index) -> list[ArrayLike]:
+        if isinstance(index, MultiIndex):
+            keys = [
+                lev._values.take(lev_codes)
+                for lev, lev_codes in zip(index.levels, index.codes)
+            ]
+        else:
+            keys = [index._values]
+        return keys
+
     @final
     def _maybe_coerce_merge_keys(self) -> None:
         # we have valid merges but we may have to further
@@ -2241,15 +2243,8 @@ def _convert_to_multiindex(index: Index) -> MultiIndex:
 
 class _SemiMergeOperation(_MergeOperation):
     def __init__(self, *args, **kwargs):
-        if kwargs.get("validate", None):
-            raise NotImplementedError("validate is not supported for semi-join.")
-
         super().__init__(*args, **kwargs)
-        if self.left_index or self.right_index:
-            raise NotImplementedError(
-                "left_index or right_index are not supported for semi-join."
-            )
-        elif self.indicator:
+        if self.indicator:
             raise NotImplementedError("indicator is not supported for semi-join.")
         elif self.sort:
             raise NotImplementedError(
@@ -2273,7 +2268,7 @@ def _reindex_and_concat(
         left_indexer: npt.NDArray[np.intp] | None,
         right_indexer: npt.NDArray[np.intp] | None,
     ) -> DataFrame:
-        left = self.left[:]
+        left = self.left
 
         if left_indexer is not None and not is_range_indexer(left_indexer, len(left)):
             lmgr = left._mgr.take(left_indexer, axis=1, verify=False)
@@ -2956,7 +2951,7 @@ def _factorize_keys(
         lk_data, rk_data = lk, rk  # type: ignore[assignment]
         lk_mask, rk_mask = None, None
 
-    hash_join_available = how == "inner" and not sort
+    hash_join_available = how == "inner" and not sort and lk.dtype.kind in "iufbO"
     if hash_join_available:
         rlab = rizer.factorize(rk_data, mask=rk_mask)
         if rizer.get_count() == len(rlab):

pandas/tests/reshape/merge/test_semi.py

@@ -10,13 +10,21 @@
     "vals_left, vals_right, dtype",
     [
         ([1, 2, 3], [1, 2], "int64"),
+        ([1.5, 2.5, 3.5], [1.5, 2.5], "float64"),
+        ([True, True, False], [True, True], "bool"),
         (["a", "b", "c"], ["a", "b"], "object"),
         pytest.param(
             ["a", "b", "c"],
             ["a", "b"],
             "string[pyarrow]",
             marks=td.skip_if_no("pyarrow"),
         ),
+        pytest.param(
+            ["a", "b", "c"],
+            ["a", "b"],
+            "str",
+            marks=td.skip_if_no("pyarrow"),
+        ),
     ],
 )
 def test_left_semi(vals_left, vals_right, dtype):
@@ -28,6 +36,21 @@ def test_left_semi(vals_left, vals_right, dtype):
     result = left.merge(right, how="left_semi")
     tm.assert_frame_equal(result, expected)
 
+    result = left.set_index("a").merge(
+        right.set_index("a"), how="left_semi", left_index=True, right_index=True
+    )
+    tm.assert_frame_equal(result, expected.set_index("a"))
+
+    result = left.set_index("a").merge(
+        right, how="left_semi", left_index=True, right_on="a"
+    )
+    tm.assert_frame_equal(result, expected.set_index("a"))
+
+    result = left.merge(
+        right.set_index("a"), how="left_semi", right_index=True, left_on="a"
+    )
+    tm.assert_frame_equal(result, expected)
+
     right = pd.DataFrame({"d": vals_right, "c": 1})
     result = left.merge(right, how="left_semi", left_on="a", right_on="d")
     tm.assert_frame_equal(result, expected)
@@ -40,17 +63,6 @@ def test_left_semi(vals_left, vals_right, dtype):
 def test_left_semi_invalid():
     left = pd.DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]})
     right = pd.DataFrame({"a": [1, 2], "c": 1})
-
-    msg = "left_index or right_index are not supported for semi-join."
-    with pytest.raises(NotImplementedError, match=msg):
-        left.merge(right, how="left_semi", left_index=True, right_on="a")
-    with pytest.raises(NotImplementedError, match=msg):
-        left.merge(right, how="left_semi", right_index=True, left_on="a")
-
-    msg = "validate is not supported for semi-join."
-    with pytest.raises(NotImplementedError, match=msg):
-        left.merge(right, how="left_semi", validate="one_to_one")
-
     msg = "indicator is not supported for semi-join."
     with pytest.raises(NotImplementedError, match=msg):
         left.merge(right, how="left_semi", indicator=True)