BUG/TST: Fix infer_dtype for Period array-likes and general ExtensionArrays

pandas/_libs/lib.pyx

@@ -1073,6 +1073,7 @@ _TYPE_MAP = {
     "M": "datetime64",
     "timedelta64[ns]": "timedelta64",
     "m": "timedelta64",
+    "period": "period",
     "interval": "interval",
 }
 
@@ -1226,9 +1227,14 @@ cdef object _try_infer_map(object dtype):
         object val
         str attr
     for attr in ["name", "kind", "base"]:
-        val = getattr(dtype, attr)
+        val = getattr(dtype, attr, None)
         if val in _TYPE_MAP:
             return _TYPE_MAP[val]
+        # also check base name for parametrized dtypes (eg period[D])
+        if isinstance(val, str):
+            val = val.split("[")[0]
+            if val in _TYPE_MAP:
+                return _TYPE_MAP[val]
     return None
 
 
@@ -1267,6 +1273,7 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
     - time
     - period
     - mixed
+    - unknown-array
 
     Raises
     ------
@@ -1279,6 +1286,9 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
       specialized
     - 'mixed-integer-float' are floats and integers
     - 'mixed-integer' are integers mixed with non-integers
+    - 'unknown-array' is the catchall for something that *is* an array (has
+      a dtype attribute), but has a dtype unknown to pandas (e.g. external
+      extension array)
 
     Examples
     --------
@@ -1347,12 +1357,10 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
         # e.g. categoricals
         dtype = value.dtype
         if not isinstance(dtype, np.dtype):
-            value = _try_infer_map(value.dtype)
-            if value is not None:
-                return value
-
-            # its ndarray-like but we can't handle
-            raise ValueError(f"cannot infer type for {type(value)}")
+            inferred = _try_infer_map(value.dtype)
+            if inferred is not None:
+                return inferred
+            return "unknown-array"
 
         # Unwrap Series/Index
         values = np.asarray(value)

pandas/core/strings/accessor.py

@@ -208,11 +208,7 @@ def _validate(data):
         if isinstance(values.dtype, StringDtype):
             return "string"
 
-        try:
-            inferred_dtype = lib.infer_dtype(values, skipna=True)
-        except ValueError:
-            # GH#27571 mostly occurs with ExtensionArray
-            inferred_dtype = None
+        inferred_dtype = lib.infer_dtype(values, skipna=True)
 
         if inferred_dtype not in allowed_types:
             raise AttributeError("Can only use .str accessor with string values!")

pandas/tests/dtypes/test_inference.py

@@ -891,6 +891,19 @@ def test_infer_dtype_period(self):
         arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="M")])
         assert lib.infer_dtype(arr, skipna=True) == "period"
 
+    @pytest.mark.parametrize("klass", [pd.array, pd.Series, pd.Index])
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_infer_dtype_period_array(self, klass, skipna):
+        # https://github.com/pandas-dev/pandas/issues/23553
+        values = klass(
+            [
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-02", freq="D"),
+                pd.NaT,
+            ]
+        )
+        assert lib.infer_dtype(values, skipna=skipna) == "period"
+
     def test_infer_dtype_period_mixed(self):
         arr = np.array(
             [Period("2011-01", freq="M"), np.datetime64("nat")], dtype=object

pandas/tests/extension/base/dtype.py

@@ -123,3 +123,11 @@ def test_get_common_dtype(self, dtype):
         # still testing as good practice to have this working (and it is the
         # only case we can test in general)
         assert dtype._get_common_dtype([dtype]) == dtype
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_infer_dtype(self, data, data_missing, skipna):
+        # only testing that this works without raising an error
+        res = pd.api.types.infer_dtype(data, skipna=skipna)
+        assert isinstance(res, str)
+        res = pd.api.types.infer_dtype(data_missing, skipna=skipna)
+        assert isinstance(res, str)

pandas/tests/extension/decimal/test_decimal.py

@@ -116,6 +116,13 @@ class TestDtype(BaseDecimal, base.BaseDtypeTests):
     def test_hashable(self, dtype):
         pass
 
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_infer_dtype(self, data, data_missing, skipna):
+        # here overriding base test to ensure we fall back to return
+        # "unknown-array" for an EA pandas doesn't know
+        assert pd.api.types.infer_dtype(data, skipna=skipna) == "unknown-array"
+        assert pd.api.types.infer_dtype(data_missing, skipna=skipna) == "unknown-array"
+
 
 class TestInterface(BaseDecimal, base.BaseInterfaceTests):
     pass