String.astype() uses _from_sequence_of_strings

Author: siboehm

pandas/core/arrays/categorical.py

@@ -478,6 +478,12 @@ def _constructor(self) -> Type[Categorical]:
     def _from_sequence(cls, scalars, *, dtype: Optional[Dtype] = None, copy=False):
         return Categorical(scalars, dtype=dtype, copy=copy)
 
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings, *, dtype: Optional[Dtype] = None, copy=False
+    ):
+        return cls._from_sequence(scalars=strings, dtype=dtype, copy=copy)
+
     def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
         """
         Coerce this type to another dtype

pandas/core/arrays/datetimes.py

@@ -38,6 +38,7 @@
     to_offset,
     tzconversion,
 )
+from pandas._typing import Dtype
 from pandas.errors import PerformanceWarning
 
 from pandas.core.dtypes.cast import astype_dt64_to_dt64tz
@@ -65,6 +66,7 @@
 from pandas.core.dtypes.missing import isna
 
 from pandas.core.algorithms import checked_add_with_arr
+from pandas.core.api import NA
 from pandas.core.arrays import (
     ExtensionArray,
     datetimelike as dtl,
@@ -334,6 +336,13 @@ def _simple_new(
     def _from_sequence(cls, scalars, *, dtype=None, copy: bool = False):
         return cls._from_sequence_not_strict(scalars, dtype=dtype, copy=copy)
 
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings, *, dtype: Optional[Dtype] = None, copy=False
+    ):
+        scalars = [NaT if s is NA else s for s in strings]
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
+
     @classmethod
     def _from_sequence_not_strict(
         cls,

pandas/core/arrays/period.py

@@ -73,6 +73,7 @@
 )
 
 import pandas.core.algorithms as algos
+from pandas.core.api import NA
 from pandas.core.arrays import datetimelike as dtl
 import pandas.core.common as com
 
@@ -252,7 +253,8 @@ def _from_sequence(
     def _from_sequence_of_strings(
         cls, strings, *, dtype: Optional[Dtype] = None, copy=False
     ) -> PeriodArray:
-        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+        scalars = [NaT if s is NA else s for s in strings]
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
 
     @classmethod
     def _from_datetime64(cls, data, freq, tz=None) -> PeriodArray:

pandas/core/arrays/string_.py

@@ -26,23 +26,29 @@
 from pandas.core.dtypes.common import (
     is_array_like,
     is_bool_dtype,
+    is_datetime64_any_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
     is_integer_dtype,
     is_object_dtype,
     is_string_dtype,
+    is_timedelta64_dtype,
     pandas_dtype,
 )
 
 from pandas.core import ops
 from pandas.core.array_algos import masked_reductions
-from pandas.core.arrays import (
+from pandas.core.arrays import PandasArray
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.floating import (
     FloatingArray,
+    FloatingDtype,
+)
+from pandas.core.arrays.integer import (
     IntegerArray,
-    PandasArray,
+    _IntegerDtype,
 )
-from pandas.core.arrays.floating import FloatingDtype
-from pandas.core.arrays.integer import _IntegerDtype
+from pandas.core.arrays.timedeltas import TimedeltaArray
 from pandas.core.construction import extract_array
 from pandas.core.indexers import check_array_indexer
 from pandas.core.missing import isna
@@ -329,7 +335,13 @@ def astype(self, dtype, copy=True):
             return FloatingArray(values, mask, copy=False)
         elif is_extension_array_dtype(dtype):
             cls = dtype.construct_array_type()
-            return cls._from_sequence(self, dtype=dtype, copy=copy)
+            return cls._from_sequence_of_strings(self, dtype=dtype, copy=copy)
+        elif is_datetime64_any_dtype(dtype):
+            return DatetimeArray._from_sequence_of_strings(self, dtype=dtype, copy=copy)
+        elif is_timedelta64_dtype(dtype):
+            return TimedeltaArray._from_sequence_of_strings(
+                self, dtype=dtype, copy=copy
+            )
         elif np.issubdtype(dtype, np.floating):
             arr = self._ndarray.copy()
             mask = self.isna()

pandas/core/arrays/timedeltas.py

@@ -35,7 +35,10 @@
     ints_to_pytimedelta,
     parse_timedelta_unit,
 )
-from pandas._typing import NpDtype
+from pandas._typing import (
+    Dtype,
+    NpDtype,
+)
 from pandas.compat.numpy import function as nv
 
 from pandas.core.dtypes.cast import astype_td64_unit_conversion
@@ -60,6 +63,7 @@
 
 from pandas.core import nanops
 from pandas.core.algorithms import checked_add_with_arr
+from pandas.core.api import NA
 from pandas.core.arrays import (
     ExtensionArray,
     IntegerArray,
@@ -254,6 +258,13 @@ def _from_sequence(
 
         return cls._simple_new(data, freq=freq)
 
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings, *, dtype: Optional[Dtype] = None, copy=False
+    ):
+        scalars = [NaT if s is NA else s for s in strings]
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
+
     @classmethod
     def _from_sequence_not_strict(
         cls,

pandas/tests/series/methods/test_astype.py

@@ -354,6 +354,8 @@ class TestAstypeString:
     @pytest.mark.parametrize(
         "data, dtype",
         [
+            ([True, False, NA], "boolean"),
+            # GH-40351
             (["A", NA], "category"),
             (["2020-10-10", "2020-10-10"], "datetime64[ns]"),
             (["2020-10-10", "2020-10-10", NaT], "datetime64[ns]"),
@@ -365,19 +367,10 @@ class TestAstypeString:
             (["1/1/2021", "2/1/2021"], "period[M]"),
             (["1/1/2021", "2/1/2021", NaT], "period[M]"),
             (["1 Day", "59 Days", NaT], "timedelta64[ns]"),
-            # currently no way to parse BooleanArray, IntervalArray from a
-            # list of strings
+            # currently no way to parse IntervalArray from strings
         ],
     )
     def test_astype_string_to_extension_dtype_roundtrip(self, data, dtype, request):
-        if dtype in ("timedelta64[ns]"):
-            mark = pytest.mark.xfail(reason="TODO fix is_extension_array_dtype GH40478")
-            request.node.add_marker(mark)
-        if NaT in data and dtype in ("period[M]", "datetime64[ns]"):
-            mark = pytest.mark.xfail(
-                reason="TODO StringArray.astype() None to dtype.na_value conversion"
-            )
-            request.node.add_marker(mark)
         # GH-40351
         s = Series(data, dtype=dtype)
         tm.assert_series_equal(s, s.astype("string").astype(dtype))
@@ -503,18 +496,6 @@ def test_astype_categories_raises(self):
         with pytest.raises(TypeError, match="got an unexpected"):
             s.astype("category", categories=["a", "b"], ordered=True)
 
-    def test_astype_str_to_extension_dtype(self):
-        # GH-40351
-        s = Series(["A", np.NaN], dtype="string")
-        result = s.astype("category")
-        expected = Series(["A", np.NaN], dtype="category")
-        tm.assert_series_equal(result, expected)
-
-        s = Series(["1/1/2021", "2/1/2021"], dtype="string")
-        result = s.astype("period[M]")
-        expected = Series(["1/1/2021", "2/1/2021"], dtype="period[M]")
-        tm.assert_series_equal(result, expected)
-
     @pytest.mark.parametrize("items", [["a", "b", "c", "a"], [1, 2, 3, 1]])
     def test_astype_from_categorical(self, items):
         ser = Series(items)