BUG: passing a non-dict mapping to pd.concat raises a TypeError (#32953)

Author: pbourguignon

doc/source/whatsnew/v1.1.0.rst

@@ -386,8 +386,10 @@ Reshaping
 - :meth:`DataFrame.replace` and :meth:`Series.replace` will raise a ``TypeError`` if ``to_replace`` is not an expected type. Previously the ``replace`` would fail silently (:issue:`18634`)
 - Bug in :meth:`DataFrame.apply` where callback was called with :class:`Series` parameter even though ``raw=True`` requested. (:issue:`32423`)
 - Bug in :meth:`DataFrame.pivot_table` losing timezone information when creating a :class:`MultiIndex` level from a column with timezone-aware dtype (:issue:`32558`)
+- Bug in :meth:`concat` where when passing a non-dict mapping as ``objs`` would raise a ``TypeError`` (:issue:`32863`)
 - :meth:`DataFrame.agg` now provides more descriptive ``SpecificationError`` message when attempting to aggregating non-existant column (:issue:`32755`)
 
+
 Sparse
 ^^^^^^
 - Creating a :class:`SparseArray` from timezone-aware dtype will issue a warning before dropping timezone information, instead of doing so silently (:issue:`32501`)

pandas/conftest.py

@@ -311,7 +311,7 @@ def __init__(self, *args, **kwargs):
 
 
 @pytest.fixture
-def non_mapping_dict_subclass():
+def non_dict_mapping_subclass():
     """
     Fixture for a non-mapping dictionary subclass.
     """

pandas/core/reshape/concat.py

@@ -2,6 +2,7 @@
 Concat routines.
 """
 
+from collections import abc
 from typing import Iterable, List, Mapping, Union, overload
 
 import numpy as np
@@ -85,7 +86,7 @@ def concat(
     Parameters
     ----------
     objs : a sequence or mapping of Series or DataFrame objects
-        If a dict is passed, the sorted keys will be used as the `keys`
+        If a mapping is passed, the sorted keys will be used as the `keys`
         argument, unless it is passed, in which case the values will be
         selected (see below). Any None objects will be dropped silently unless
         they are all None in which case a ValueError will be raised.
@@ -315,7 +316,7 @@ def __init__(
                 "Only can inner (intersect) or outer (union) join the other axis"
             )
 
-        if isinstance(objs, dict):
+        if isinstance(objs, abc.Mapping):
             if keys is None:
                 keys = list(objs.keys())
             objs = [objs[k] for k in keys]

pandas/tests/reshape/test_concat.py

@@ -1220,13 +1220,17 @@ def test_concat_series_partial_columns_names(self):
         expected = DataFrame({0: [1, 2], 1: [1, 2], 2: [4, 5]})
         tm.assert_frame_equal(result, expected)
 
-    def test_concat_dict(self):
-        frames = {
-            "foo": DataFrame(np.random.randn(4, 3)),
-            "bar": DataFrame(np.random.randn(4, 3)),
-            "baz": DataFrame(np.random.randn(4, 3)),
-            "qux": DataFrame(np.random.randn(4, 3)),
-        }
+    @pytest.mark.parametrize("mapping", ["mapping", "dict"])
+    def test_concat_mapping(self, mapping, non_dict_mapping_subclass):
+        constructor = dict if mapping == "dict" else non_dict_mapping_subclass
+        frames = constructor(
+            {
+                "foo": DataFrame(np.random.randn(4, 3)),
+                "bar": DataFrame(np.random.randn(4, 3)),
+                "baz": DataFrame(np.random.randn(4, 3)),
+                "qux": DataFrame(np.random.randn(4, 3)),
+            }
+        )
 
         sorted_keys = list(frames.keys())
 

pandas/tests/series/test_apply.py

@@ -630,19 +630,19 @@ class DictWithoutMissing(dict):
         expected = Series([np.nan, np.nan, "three"])
         tm.assert_series_equal(result, expected)
 
-    def test_map_abc_mapping(self, non_mapping_dict_subclass):
+    def test_map_abc_mapping(self, non_dict_mapping_subclass):
         # https://github.com/pandas-dev/pandas/issues/29733
         # Check collections.abc.Mapping support as mapper for Series.map
         s = Series([1, 2, 3])
-        not_a_dictionary = non_mapping_dict_subclass({3: "three"})
+        not_a_dictionary = non_dict_mapping_subclass({3: "three"})
         result = s.map(not_a_dictionary)
         expected = Series([np.nan, np.nan, "three"])
         tm.assert_series_equal(result, expected)
 
-    def test_map_abc_mapping_with_missing(self, non_mapping_dict_subclass):
+    def test_map_abc_mapping_with_missing(self, non_dict_mapping_subclass):
         # https://github.com/pandas-dev/pandas/issues/29733
         # Check collections.abc.Mapping support as mapper for Series.map
-        class NonDictMappingWithMissing(non_mapping_dict_subclass):
+        class NonDictMappingWithMissing(non_dict_mapping_subclass):
             def __missing__(self, key):
                 return "missing"
 

pandas/tests/series/test_constructors.py

@@ -1124,9 +1124,9 @@ def test_constructor_dict_tuple_indexer(self):
         )
         tm.assert_series_equal(result, expected)
 
-    def test_constructor_mapping(self, non_mapping_dict_subclass):
+    def test_constructor_mapping(self, non_dict_mapping_subclass):
         # GH 29788
-        ndm = non_mapping_dict_subclass({3: "three"})
+        ndm = non_dict_mapping_subclass({3: "three"})
         result = Series(ndm)
         expected = Series(["three"], index=[3])