BUG: use EA.astype in ExtensionBlock.to_native_types

pandas/core/internals/blocks.py

@@ -2281,6 +2281,7 @@ class DatetimeTZBlock(ExtensionBlock, DatetimeBlock):
     is_extension = True
 
     _can_hold_element = DatetimeBlock._can_hold_element
+    to_native_types = DatetimeBlock.to_native_types
     fill_value = np.datetime64("NaT", "ns")
 
     @property
@@ -2354,22 +2355,6 @@ def to_dense(self):
         # expects that behavior.
         return np.asarray(self.values, dtype=_NS_DTYPE)
 
-    def to_native_types(
-        self, slicer=None, na_rep=None, date_format=None, quoting=None, **kwargs
-    ):
-        """
-        We need to pick DatetimeBlock's version, but the inheritance structure
-        would use ExtensionBlock's verison
-        """
-        return DatetimeBlock.to_native_types(
-            self,
-            slicer=slicer,
-            na_rep=na_rep,
-            date_format=date_format,
-            quoting=quoting,
-            **kwargs
-        )
-
     def _slice(self, slicer):
         """ return a slice of my values """
         if isinstance(slicer, tuple):

pandas/tests/extension/list/__init__.py

@@ -0,0 +1,3 @@
+from .array import ListArray, ListDtype, make_data
+
+__all__ = ["ListArray", "ListDtype", "make_data"]

pandas/tests/extension/list/array.py

@@ -0,0 +1,131 @@
+"""Test extension array for storing nested data in a pandas container.
+
+The ListArray stores an ndarray of lists.
+"""
+import numbers
+import random
+import string
+
+import numpy as np
+
+from pandas.core.dtypes.base import ExtensionDtype
+
+import pandas as pd
+from pandas.core.arrays import ExtensionArray
+
+
+class ListDtype(ExtensionDtype):
+    type = list
+    name = "list"
+    na_value = np.nan
+
+    @classmethod
+    def construct_array_type(cls):
+        """Return the array type associated with this dtype
+
+        Returns
+        -------
+        type
+        """
+        return ListArray
+
+    @classmethod
+    def construct_from_string(cls, string):
+        if string == cls.name:
+            return cls()
+        else:
+            raise TypeError("Cannot construct a '{}' from '{}'".format(cls, string))
+
+
+class ListArray(ExtensionArray):
+    dtype = ListDtype()
+    __array_priority__ = 1000
+
+    def __init__(self, values, dtype=None, copy=False):
+        if not isinstance(values, np.ndarray):
+            raise TypeError("Need to pass a numpy array as values")
+        for val in values:
+            if not isinstance(val, self.dtype.type) and not pd.isna(val):
+                raise TypeError("All values must be of type " + str(self.dtype.type))
+        self.data = values
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        data = np.empty(len(scalars), dtype=object)
+        data[:] = scalars
+        return cls(data)
+
+    def __getitem__(self, item):
+        if isinstance(item, numbers.Integral):
+            return self.data[item]
+        else:
+            # slice, list-like, mask
+            return type(self)(self.data[item])
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def isna(self):
+        return np.array(
+            [not isinstance(x, list) and np.isnan(x) for x in self.data], dtype=bool
+        )
+
+    def take(self, indexer, allow_fill=False, fill_value=None):
+        # re-implement here, since NumPy has trouble setting
+        # sized objects like UserDicts into scalar slots of
+        # an ndarary.
+        indexer = np.asarray(indexer)
+        msg = (
+            "Index is out of bounds or cannot do a "
+            "non-empty take from an empty array."
+        )
+
+        if allow_fill:
+            if fill_value is None:
+                fill_value = self.dtype.na_value
+            # bounds check
+            if (indexer < -1).any():
+                raise ValueError
+            try:
+                output = [
+                    self.data[loc] if loc != -1 else fill_value for loc in indexer
+                ]
+            except IndexError:
+                raise IndexError(msg)
+        else:
+            try:
+                output = [self.data[loc] for loc in indexer]
+            except IndexError:
+                raise IndexError(msg)
+
+        return self._from_sequence(output)
+
+    def copy(self):
+        return type(self)(self.data[:])
+
+    def astype(self, dtype, copy=True):
+        if isinstance(dtype, type(self.dtype)) and dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        elif pd.api.types.is_string_dtype(dtype) and not pd.api.types.is_object_dtype(
+            dtype
+        ):
+            # numpy has problems with astype(str) for nested elements
+            return np.array([str(x) for x in self.data], dtype=dtype)
+        return np.array(self.data, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat):
+        data = np.concatenate([x.data for x in to_concat])
+        return cls(data)
+
+
+def make_data():
+    # TODO: Use a regular dict. See _NDFrameIndexer._setitem_with_indexer
+    data = np.empty(100, dtype=object)
+    data[:] = [
+        [random.choice(string.ascii_letters) for _ in range(random.randint(0, 10))]
+        for _ in range(100)
+    ]
+    return data

pandas/tests/extension/list/test_list.py

@@ -0,0 +1,30 @@
+import pytest
+
+import pandas as pd
+
+from .array import ListArray, ListDtype, make_data
+
+
+@pytest.fixture
+def dtype():
+    return ListDtype()
+
+
+@pytest.fixture
+def data():
+    """Length-100 ListArray for semantics test."""
+    data = make_data()
+
+    while len(data[0]) == len(data[1]):
+        data = make_data()
+
+    return ListArray(data)
+
+
+def test_to_csv(data):
+    # https://github.com/pandas-dev/pandas/issues/28840
+    # array with list-likes fail when doing astype(str) on the numpy array
+    # which was done in to_native_types
+    s = pd.Series(data)
+    res = s.to_csv()
+    assert str(data[0]) in res