DF.__setitem__ creates extension column when given extension scalar

doc/source/whatsnew/v1.0.0.rst

@@ -1259,6 +1259,7 @@ ExtensionArray
 - Bug in :class:`arrays.PandasArray` when setting a scalar string (:issue:`28118`, :issue:`28150`).
 - Bug where nullable integers could not be compared to strings (:issue:`28930`)
 - Bug where :class:`DataFrame` constructor raised ``ValueError`` with list-like data and ``dtype`` specified (:issue:`30280`)
+- Bug where :class:`Series` set to scalar extension type was considered an object type rather than the extension type (:issue:`34832`)
 
 Other
 ^^^^^

pandas/core/dtypes/cast.py

@@ -1505,10 +1505,20 @@ def cast_scalar_to_array(shape, value, dtype: Optional[DtypeObj] = None) -> np.n
 
     """
     if dtype is None:
-        dtype, fill_value = infer_dtype_from_scalar(value)
+        dtype, fill_value = infer_dtype_from_scalar(value, pandas_dtype=True)
     else:
         fill_value = value
 
+    # TODO: Update this function to add support for 3rd party extension types
+    # Issue #34959
+    if is_extension_array_dtype(dtype):
+        if isinstance(shape, int):
+            shape = (shape, 1)
+        return [
+            construct_1d_arraylike_from_scalar(value, shape[0], dtype)
+            for _ in range(shape[1])
+        ]
+
     values = np.empty(shape, dtype=dtype)
     values.fill(fill_value)
 

pandas/core/frame.py

@@ -76,6 +76,7 @@
     cast_scalar_to_array,
     coerce_to_dtypes,
     find_common_type,
+    infer_dtype_from_array,
     infer_dtype_from_scalar,
     invalidate_string_dtypes,
     maybe_cast_to_datetime,
@@ -528,9 +529,15 @@ def __init__(
                 values = cast_scalar_to_array(
                     (len(index), len(columns)), data, dtype=dtype
                 )
-                mgr = init_ndarray(
-                    values, index, columns, dtype=values.dtype, copy=False
-                )
+                if isinstance(values, list):
+                    # Case 1: values is a list of extension arrays
+                    dtype, _ = infer_dtype_from_array(values[0], pandas_dtype=True)
+                    mgr = arrays_to_mgr(values, columns, index, columns, dtype=dtype)
+                else:
+                    # Case 2: values is a numpy array
+                    mgr = init_ndarray(
+                        values, index, columns, dtype=values.dtype, copy=False
+                    )
             else:
                 raise ValueError("DataFrame constructor not properly called!")
 
@@ -3731,6 +3738,11 @@ def reindexer(value):
 
             # upcast
             value = cast_scalar_to_array(len(self.index), value)
+
+            # if extension dtype, value will be a list of length 1
+            if isinstance(value, list):
+                value = value[0]
+
             value = maybe_cast_to_datetime(value, infer_dtype)
 
         # return internal types directly

pandas/tests/dtypes/cast/test_infer_dtype.py

@@ -9,6 +9,7 @@
     infer_dtype_from_scalar,
 )
 from pandas.core.dtypes.common import is_dtype_equal
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, IntervalDtype, PeriodDtype
 
 from pandas import (
     Categorical,
@@ -187,14 +188,37 @@ def test_infer_dtype_from_array(arr, expected, pandas_dtype):
         (1.1, np.float64),
         (Timestamp("2011-01-01"), "datetime64[ns]"),
         (Timestamp("2011-01-01", tz="US/Eastern"), object),
-        (Period("2011-01-01", freq="D"), object),
     ],
 )
-def test_cast_scalar_to_array(obj, dtype):
+def test_cast_scalar_to_numpy_array(obj, dtype):
     shape = (3, 2)
 
     exp = np.empty(shape, dtype=dtype)
     exp.fill(obj)
 
     arr = cast_scalar_to_array(shape, obj, dtype=dtype)
     tm.assert_numpy_array_equal(arr, exp)
+
+
+@pytest.mark.parametrize(
+    "obj,dtype",
+    [
+        (Period("2011-01-01", freq="D"), PeriodDtype("D")),
+        (Interval(left=0, right=5), IntervalDtype("int64")),
+        (
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            DatetimeTZDtype(unit="ns", tz="US/Eastern"),
+        ),
+    ],
+)
+def test_cast_scalar_to_extension_array(obj, dtype):
+    # GH: 34832
+    shape = 3
+
+    exp = dtype.construct_array_type()._from_sequence([obj] * shape)
+
+    arr = cast_scalar_to_array(shape, obj, dtype=dtype)
+    tm.assert_extension_array_equal(arr[0], exp)
+
+    arr = cast_scalar_to_array(shape, obj, dtype=None)
+    tm.assert_extension_array_equal(arr[0], exp)

pandas/tests/frame/indexing/test_setitem.py

@@ -1,7 +1,18 @@
 import numpy as np
 import pytest
 
-from pandas import Categorical, DataFrame, Index, Series, Timestamp, date_range
+from pandas.core.dtypes.dtypes import IntervalDtype, PeriodDtype
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Interval,
+    Period,
+    Series,
+    Timestamp,
+    date_range,
+)
 import pandas._testing as tm
 from pandas.core.arrays import SparseArray
 
@@ -150,3 +161,22 @@ def test_setitem_dict_preserves_dtypes(self):
                 "c": float(b),
             }
         tm.assert_frame_equal(df, expected)
+
+    def test_setitem_extension_types(self):
+        # GH: 34832
+        period_val = Period("2020-01")
+        interval_val = Interval(left=0, right=5)
+
+        expected = DataFrame(
+            {
+                "idx": [1, 2, 3],
+                "period": Series([period_val] * 3, dtype=PeriodDtype("M")),
+                "interval": Series([interval_val] * 3, dtype=IntervalDtype("int64")),
+            }
+        )
+
+        df = DataFrame({"idx": [1, 2, 3]})
+        df["period"] = period_val
+        df["interval"] = interval_val
+
+        tm.assert_frame_equal(df, expected)

pandas/tests/frame/methods/test_combine_first.py

@@ -199,12 +199,14 @@ def test_combine_first_timezone(self):
             columns=["UTCdatetime", "abc"],
             data=data1,
             index=pd.date_range("20140627", periods=1),
+            dtype="object",
         )
         data2 = pd.to_datetime("20121212 12:12").tz_localize("UTC")
         df2 = pd.DataFrame(
             columns=["UTCdatetime", "xyz"],
             data=data2,
             index=pd.date_range("20140628", periods=1),
+            dtype="object",
         )
         res = df2[["UTCdatetime"]].combine_first(df1)
         exp = pd.DataFrame(
@@ -217,10 +219,13 @@ def test_combine_first_timezone(self):
             },
             columns=["UTCdatetime", "abc"],
             index=pd.date_range("20140627", periods=2, freq="D"),
+            dtype="object",
         )
-        tm.assert_frame_equal(res, exp)
         assert res["UTCdatetime"].dtype == "datetime64[ns, UTC]"
         assert res["abc"].dtype == "datetime64[ns, UTC]"
+        # GH Issue 7509
+        res = res.astype("object")
+        tm.assert_frame_equal(res, exp)
 
         # see gh-10567
         dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="UTC")