revert the changes of the group's behavior

Author: natmokval

pandas/core/groupby/grouper.py

@@ -675,11 +675,11 @@ def groups(self) -> dict[Hashable, Index]:
             warnings.warn(
                 "`groups` by one element list returns scalar is deprecated "
                 "and will be removed. In a future version `groups` by one element "
-                "list will return tuple.",
+                "list will return tuple. Use ``df.groupby(by='a').groups`` "
+                "instead of ``df.groupby(by=['a']).groups`` to avoid this warning",
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            cats = [(key,) for key in cats]  # type: ignore[assignment]
         return self._index.groupby(cats)
 
     @property

pandas/tests/groupby/test_groupby.py

@@ -2999,11 +2999,11 @@ def test_groupby_multi_index_codes():
 
 
 def test_groupby_keys_1length_list():
-    # GH#58858
+    # GH#59179
     msg = "`groups` by one element list returns scalar is deprecated"
 
     df = DataFrame({"x": [10, 20, 30], "y": ["a", "b", "c"]})
-    expected = {(10,): [0], (20,): [1], (30,): [2]}
+    expected = {10: [0], 20: [1], 30: [2]}
     with tm.assert_produces_warning(FutureWarning, match=msg):
         result = df.groupby(["x"]).groups
     tm.assert_dict_equal(result, expected)

pandas/tests/groupby/test_grouping.py

@@ -545,19 +545,62 @@ def test_multiindex_columns_empty_level(self):
 
         df = DataFrame([[1, "A"]], columns=midx)
 
+        msg = "`groups` by one element list returns scalar is deprecated"
         grouped = df.groupby("to filter").groups
         assert grouped["A"] == [0]
 
-        msg = "`groups` by one element list returns scalar is deprecated"
-
         with tm.assert_produces_warning(FutureWarning, match=msg):
             grouped = df.groupby([("to filter", "")]).groups
-        assert grouped[("A",)] == [0]
+        assert grouped["A"] == [0]
 
         df = DataFrame([[1, "A"], [2, "B"]], columns=midx)
 
+        expected = df.groupby("to filter").groups
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.groupby([("to filter", "")]).groups
+        assert result == expected
+
+        df = DataFrame([[1, "A"], [2, "A"]], columns=midx)
+
+        expected = df.groupby("to filter").groups
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.groupby([("to filter", "")]).groups
+        tm.assert_dict_equal(result, expected)
+
+    def test_groupby_multiindex_tuple(self):
+        # GH 17979, GH#59179
+        df = DataFrame(
+            [[1, 2, 3, 4], [3, 4, 5, 6], [1, 4, 2, 3]],
+            columns=MultiIndex.from_arrays([["a", "b", "b", "c"], [1, 1, 2, 2]]),
+        )
+
+        msg = "`groups` by one element list returns scalar is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df.groupby([("b", 1)]).groups
+        result = df.groupby(("b", 1)).groups
+        tm.assert_dict_equal(expected, result)
+
+        df2 = DataFrame(
+            df.values,
+            columns=MultiIndex.from_arrays(
+                [["a", "b", "b", "c"], ["d", "d", "e", "e"]]
+            ),
+        )
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df2.groupby([("b", "d")]).groups
+        result = df.groupby(("b", 1)).groups
+        tm.assert_dict_equal(expected, result)
+
+        df3 = DataFrame(df.values, columns=[("a", "d"), ("b", "d"), ("b", "e"), "c"])
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df3.groupby([("b", "d")]).groups
+        result = df.groupby(("b", 1)).groups
+        tm.assert_dict_equal(expected, result)
+
     def test_groupby_multiindex_partial_indexing_equivalence(self):
-        # GH 17977
+        # GH 17977, GH#59179
         df = DataFrame(
             [[1, 2, 3, 4], [3, 4, 5, 6], [1, 4, 2, 3]],
             columns=MultiIndex.from_arrays([["a", "b", "b", "c"], [1, 1, 2, 2]]),
@@ -584,7 +627,6 @@ def test_groupby_multiindex_partial_indexing_equivalence(self):
         tm.assert_frame_equal(expected_max, result_max)
 
         msg = "`groups` by one element list returns scalar is deprecated"
-
         with tm.assert_produces_warning(FutureWarning, match=msg):
             expected_groups = df.groupby([("a", 1)])[[("b", 1), ("b", 2)]].groups
             result_groups = df.groupby([("a", 1)])["b"].groups
@@ -690,16 +732,15 @@ def test_grouping_labels(self, multiindex_dataframe_random_data):
         tm.assert_almost_equal(grouped._grouper.codes[0], exp_labels)
 
     def test_list_grouper_with_nat(self):
-        # GH 14715
+        # GH 14715, GH#59179
         df = DataFrame({"date": date_range("1/1/2011", periods=365, freq="D")})
         df.iloc[-1] = pd.NaT
         grouper = Grouper(key="date", freq="YS")
         msg = "`groups` by one element list returns scalar is deprecated"
 
         # Grouper in a list grouping
         result = df.groupby([grouper])
-        expected = {(Timestamp("2011-01-01"),): list(range(364)), (pd.NaT,): [364]}
-
+        expected = {Timestamp("2011-01-01"): Index(list(range(364)))}
         with tm.assert_produces_warning(FutureWarning, match=msg):
             result = result.groups
         tm.assert_dict_equal(result, expected)
@@ -976,7 +1017,7 @@ def test_groups(self, df):
         assert groups is grouped.groups  # caching works
 
         for k, v in grouped.groups.items():
-            assert (df.loc[v]["A"] == k[0]).all()
+            assert (df.loc[v]["A"] == k).all()
 
         grouped = df.groupby(["A", "B"])
         groups = grouped.groups