fix for pandas-dev#60695 fix Series constructor dropping key levels when keys have varying entry counts

Author: mansoor17syed

pandas/core/indexes/multi.py

@@ -7,6 +7,7 @@
     Hashable,
     Iterable,
     Sequence,
+    List,
 )
 from functools import wraps
 from sys import getsizeof
@@ -15,6 +16,7 @@
     Any,
     Literal,
     cast,
+    ArrayLike,
 )
 import warnings
 
@@ -526,37 +528,52 @@ def from_tuples(
     ) -> MultiIndex:
         """
         Convert list of tuples to MultiIndex.
+
+        Parameters
+        ----------
+        tuples : list / sequence of tuple-likes
+            Each tuple is the index of one row/column.
+        sortorder : int or None
+            Level of sortedness (must be lexicographically sorted by that level).
+        names : list / sequence of str, optional
+            Names for the levels in the index.
+
+        Returns
+        -------
+        MultiIndex
         """
         if not is_list_like(tuples):
             raise TypeError("Input must be a list / sequence of tuple-likes.")
-        
+
         if is_iterator(tuples):
             tuples = list(tuples)
-        
-        # Cast to proper tuple type
+
         tuples = cast(Collection[tuple[Hashable, ...]], tuples)
-        
+
         if len(tuples) == 0:
             if names is None:
                 raise TypeError("Cannot infer number of levels from empty list")
-            arrays = [[]] * len(names)
-        elif isinstance(tuples, (np.ndarray, Index)):
+            names_seq = cast(Sequence[Hashable], names)
+            arrays: List[ArrayLike] = [[]] * len(names_seq)
+            return cls.from_arrays(arrays, sortorder=sortorder, names=names)
+
+        if isinstance(tuples, (np.ndarray, Index)):
             if isinstance(tuples, Index):
                 tuples = np.asarray(tuples._values)
             arrays = list(lib.tuples_to_object_array(tuples).T)
-        elif isinstance(tuples, list):
-            # Find the maximum length of tuples
-            max_length = max((len(t) for t in tuples), default=0)
-            
-            # Pad shorter tuples with np.nan
-            padded_tuples = [
-                t + (np.nan,) * (max_length - len(t)) for t in tuples
-            ]
-            arrays = list(lib.to_object_array_tuples(padded_tuples).T)
-        else:
-            from itertools import zip_longest
-            arrays = list(zip_longest(*tuples, fillvalue=np.nan))
+            return cls.from_arrays(arrays, sortorder=sortorder, names=names)
+
+        # Convert to list and process
+        tuples_list = list(tuples)
+        max_length = max(len(t) if isinstance(t, tuple) else 1 for t in tuples_list)
+        
+        result_tuples = []
+        for t in tuples_list:
+            if not isinstance(t, tuple):
+                t = (t,)
+            result_tuples.append(t + (np.nan,) * (max_length - len(t)))
 
+        arrays = list(lib.to_object_array_tuples(result_tuples).T)
         return cls.from_arrays(arrays, sortorder=sortorder, names=names)
 
     @classmethod

pandas/tests/indexes/multi/test_constructors.py

@@ -865,43 +865,59 @@ def test_from_tuples_different_lengths_gh60695():
     
     GH#60695
     """
-    # Test case 1: Original issue example with string values
+    # Test case 1: Basic string tuples
     tuples = [("l1",), ("l1", "l2")]
-    result = pd.MultiIndex.from_tuples(tuples)
-    expected = pd.MultiIndex.from_tuples([("l1", np.nan), ("l1", "l2")])
-    tm.assert_index_equal(result, expected, exact=True)
+    result = MultiIndex.from_tuples(tuples)
+    expected = MultiIndex.from_tuples([("l1", np.nan), ("l1", "l2")])
+    tm.assert_index_equal(result, expected)
 
-    # Test case 2: Series construction with tuple keys
+    # Test case 2: Series with tuple keys
     s = pd.Series({("l1",): "v1", ("l1", "l2"): "v2"})
     expected = pd.Series(
         ["v1", "v2"],
-        index=pd.MultiIndex.from_tuples([("l1", np.nan), ("l1", "l2")])
+        index=MultiIndex.from_tuples([("l1", np.nan), ("l1", "l2")])
     )
-    tm.assert_series_equal(s, expected, check_index_type=True)
+    tm.assert_series_equal(s, expected)
 
-    # Test case 3: Handle numeric values
+    # Test case 3: Numeric tuples
     tuples = [(1,), (1, 2)]
-    result = pd.MultiIndex.from_tuples(tuples)
-    expected = pd.MultiIndex.from_tuples([(1, np.nan), (1, 2)])
-    tm.assert_index_equal(result, expected, exact=True)
+    result = MultiIndex.from_tuples(tuples)
+    expected = MultiIndex.from_tuples([(1, np.nan), (1, 2)])
+    tm.assert_index_equal(result, expected)
 
-    # Test case 4: Mixed types (strings and integers)
+    # Test case 4: Mixed types
     tuples = [(1, "a"), (1,), (2, "b", "c")]
-    result = pd.MultiIndex.from_tuples(tuples)
-    expected = pd.MultiIndex.from_tuples([
+    result = MultiIndex.from_tuples(tuples)
+    expected = MultiIndex.from_tuples([
         (1, "a", np.nan),
         (1, np.nan, np.nan),
         (2, "b", "c")
     ])
-    tm.assert_index_equal(result, expected, exact=True)
+    tm.assert_index_equal(result, expected)
 
-    # Test case 5: Empty tuples
-    tuples = []
+    # Test case 5: Empty input with names
+    empty_idx = MultiIndex.from_tuples([], names=["a", "b"])
+    assert empty_idx.names == ["a", "b"]
+    assert len(empty_idx) == 0
+
+    # Test case 6: Empty input without names
     with pytest.raises(TypeError, match="Cannot infer number of levels"):
-        pd.MultiIndex.from_tuples(tuples)
+        MultiIndex.from_tuples([])
 
-    # Test case 6: Single level consistency
-    tuples = [("a",)]
-    result = pd.MultiIndex.from_tuples(tuples)
-    expected = pd.MultiIndex.from_tuples([("a",)])
-    tm.assert_index_equal(result, expected, exact=True)
+    # Test case 7: None values
+    tuples = [(1, None), (1, 2)]
+    result = MultiIndex.from_tuples(tuples)
+    expected = MultiIndex.from_tuples([(1, np.nan), (1, 2)])
+    tm.assert_index_equal(result, expected)
+
+    # Test case 8: DataFrame with tuple index
+    df = pd.DataFrame(
+        {"col": ["v1", "v2"]},
+        index=MultiIndex.from_tuples([("l1",), ("l1", "l2")])
+    )
+    expected_index = MultiIndex.from_tuples([("l1", np.nan), ("l1", "l2")])
+    expected_df = pd.DataFrame(
+        {"col": ["v1", "v2"]},
+        index=expected_index
+    )
+    tm.assert_frame_equal(df, expected_df)