Added test to check metadata handling for pandas.merge.

Author: aijams

pandas/core/generic.py

@@ -6096,7 +6096,10 @@ def __finalize__(self, other, method: str | None = None, **kwargs) -> Self:
         Parameters
         ----------
         other : the object from which to get the attributes that we are going
-            to propagate
+            to propagate. If ``other`` has an ``input_objs`` attribute, then this attribute
+            must contain an iterable of objects, each with an ``attrs`` attribute, in which
+            case, each such ``attrs`` instance must be a dictionary that is equal to all of
+            the others.
         method : str, optional
             A passed method name providing context on where ``__finalize__``
             was called.

pandas/core/reshape/merge.py

@@ -1151,7 +1151,8 @@ def get_result(self) -> DataFrame:
         self._maybe_restore_index_levels(result)
 
         return result.__finalize__(
-            self.left, method="merge"
+            types.SimpleNamespace(input_objs=[self.left, self.right]),
+            method="merge"
         )
 
     @final

pandas/tests/generic/test_finalize.py

@@ -148,7 +148,6 @@
         operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
     ),
     (pd.DataFrame, frame_data, operator.methodcaller("map", lambda x: x)),
-    (pd.DataFrame, frame_data, operator.methodcaller("merge", pd.DataFrame({"A": [1]}))),
     (pd.DataFrame, frame_data, operator.methodcaller("round", 2)),
     (pd.DataFrame, frame_data, operator.methodcaller("corr")),
     pytest.param(
@@ -736,24 +735,68 @@ def test_merge_asof_sets_duplication_allowance_flag(allow_duplication_on_left, a
     expected_duplication_allowance = allow_duplication_on_left and allow_duplication_on_right
     assert result.flags.allows_duplicate_labels == expected_duplication_allowance
 
-def test_merge_collects_metadata_from_only_its_left_input():
+def test_merge_propagates_metadata_from_equal_input_metadata():
     """
-    Check that pandas.merge sets the metadata of its result to a copy of the metadata from its
-    left input.
+    Check that pandas.merge sets the metadata of its result to a deep copy of the metadata from
+    its left input, if the metadata from both inputs are equal.
     """
     # Arrange
-    left = pd.DataFrame({"test": [1]})
     metadata = {"a": 2}
+    left = pd.DataFrame({"test": [1]})
     left.attrs = metadata
+    right = pd.DataFrame({"test": [1]})
+    right.attrs = metadata.copy()
 
+    # Act
+    result = left.merge(right, how="inner", on="test")
+
+    # Assert
+    assert result.attrs == metadata
+    left.attrs = {"b": 3}
+    assert result.attrs == metadata
+
+def test_merge_does_not_propagate_metadata_from_unequal_input_metadata():
+    """
+    Check that the metadata for the result of pandas.merge is empty if the metadata
+    for both inputs to pandas.merge are not equal.
+    """
+    # Arrange
+    left = pd.DataFrame({"test": [1]})
+    left.attrs = {"a": 2}
     right = pd.DataFrame({"test": [1]})
     right.attrs = {"b": 3}
 
     # Act
     result = left.merge(right, how="inner", on="test")
 
     # Assert
-    assert result.attrs == metadata
-    # Check that the metadata from the left argument is copied, rather than shared.
-    left.attrs = {"c": 4}
-    assert result.attrs == metadata
+    assert result.attrs == {}
+
+no_metadata = pd.DataFrame({"test": [1]})
+
+metadata = {"a": 2}
+has_metadata = pd.DataFrame({"test": [1]})
+has_metadata.attrs = metadata
+
+@pytest.mark.parametrize(["left", "right", "expected"],
+                         [(no_metadata, has_metadata, metadata),
+                          (has_metadata, no_metadata, metadata),
+                          (no_metadata, no_metadata, {})])
+def test_merge_propagates_metadata_if_one_input_has_no_metadata(left: pd.DataFrame, right: pd.DataFrame, expected: dict):
+    """
+    Check that if the metadata for one input to pandas.merge is empty, the result
+    of merge has the same metadata as the other input.
+
+    (empty)         (A)      (A)         (empty)    (empty)       (empty)
+       |             |        |             |          |             |
+        --> merge <--          --> merge <--            --> merge <--
+              |                      |                        |
+             (A)                    (A)                    (empty)
+    """
+    # Arrange
+
+    # Act
+    result = left.merge(right, how="inner", on="test")
+
+    # Assert
+    assert result.attrs == expected

pandas/tests/generic/test_frame.py

@@ -1,5 +1,6 @@
 from copy import deepcopy
 from operator import methodcaller
+from typing import Literal
 
 import numpy as np
 import pytest
@@ -77,7 +78,7 @@ def test_metadata_propagation_indiv(self, monkeypatch):
         # merging with override
         # GH 6923
 
-        def finalize(self, other, method=None, **kwargs):
+        def finalize(self: DataFrame, other: DataFrame, method: Literal["merge", "concat"] | None = None, **kwargs):
             for name in self._metadata:
                 if method == "merge":
                     left, right = other.input_objs