Provide ExtensionDtype.construct_from_string by default

pandas/core/arrays/integer.py

@@ -78,17 +78,6 @@ def construct_array_type(cls):
         """
         return IntegerArray
 
-    @classmethod
-    def construct_from_string(cls, string):
-        """
-        Construction from a string, raise a TypeError if not
-        possible
-        """
-        if string == cls.name:
-            return cls()
-        raise TypeError("Cannot construct a '{}' from "
-                        "'{}'".format(cls, string))
-
 
 def integer_array(values, dtype=None, copy=False):
     """

pandas/core/dtypes/base.py

@@ -172,17 +172,27 @@ def construct_array_type(cls):
         raise NotImplementedError
 
     @classmethod
-    def construct_from_string(cls, string):
-        """
-        Attempt to construct this type from a string.
+    def construct_from_string(cls, string: str):
+        r"""
+        Construct this type from a string.
+
+        This is useful mainly for data types that accept parameters.
+        For example, a period dtype accepts a frequency parameter that
+        can be set as ``period[H]`` (where H means hourly frequency).
+
+        By default, in the abstract class, just the name of the type is
+        expected. But subclasses can overwrite this method to accept
+        parameters.
 
         Parameters
         ----------
         string : str
+            The name of the type, for example ``category``.
 
         Returns
         -------
-        self : instance of 'cls'
+        ExtensionDtype
+            Instance of the dtype.
 
         Raises
         ------
@@ -191,21 +201,26 @@ def construct_from_string(cls, string):
 
         Examples
         --------
-        If the extension dtype can be constructed without any arguments,
-        the following may be an adequate implementation.
+        For extension dtypes with arguments the following may be an
+        adequate implementation.
 
         >>> @classmethod
-        ... def construct_from_string(cls, string)
-        ...     if string == cls.name:
-        ...         return cls()
+        ... def construct_from_string(cls, string):
+        ...     pattern = re.compile(r"^my_type\[(?P<arg_name>.+)\]$")
+        ...     match = pattern.match(string)
+        ...     if match:
+        ...         return cls(**match.groupdict())
         ...     else:
         ...         raise TypeError("Cannot construct a '{}' from "
-        ...                         "'{}'".format(cls, string))
+        ...                         "'{}'".format(cls.__name__, string))
         """
-        raise AbstractMethodError(cls)
+        if string != cls.name:
+            raise TypeError("Cannot construct a '{}' from '{}'".format(
+                cls.__name__, string))
+        return cls()
 
     @classmethod
-    def is_dtype(cls, dtype):
+    def is_dtype(cls, dtype) -> bool:
         """Check if we match 'dtype'.
 
         Parameters

pandas/core/dtypes/dtypes.py

@@ -440,19 +440,6 @@ def construct_array_type(cls):
         from pandas import Categorical
         return Categorical
 
-    @classmethod
-    def construct_from_string(cls, string):
-        """
-        attempt to construct this type from a string, raise a TypeError if
-        it's not possible """
-        try:
-            if string == 'category':
-                return cls()
-            else:
-                raise TypeError("cannot construct a CategoricalDtype")
-        except AttributeError:
-            pass
-
     @staticmethod
     def validate_ordered(ordered):
         """

pandas/tests/dtypes/test_dtypes.py

@@ -51,6 +51,36 @@ def test_pickle(self):
         assert result == self.dtype
 
 
+class TestBaseDtype:
+    def setup_method(self):
+        class DummyDtype(pd.core.dtypes.base.ExtensionDtype):
+            name = 'dummy'
+        self.dtype = DummyDtype()
+
+    def test_str(self):
+        assert str(self.dtype) == self.dtype.name
+
+    def test_eq(self):
+        assert self.dtype == 'dummy'
+        assert self.dtype != 'anonther_type'
+
+    def test_default_kind(self):
+        assert self.dtype.kind == 'O'
+
+    def test_construct_from_string(self):
+        dtype_instance = self.dtype.__class__.construct_from_string('dummy')
+        assert isinstance(dtype_instance, self.dtype.__class__)
+        with pytest.raises(TypeError, match="Cannot construct a 'DummyDtype' "
+                                            "from 'another_type'"):
+            self.dtype.__class__.construct_from_string('another_type')
+
+    def test_default_is_numeric(self):
+        assert not self.dtype._is_numeric
+
+    def test_default_is_boolean(self):
+        assert not self.dtype._is_numeric
+
+
 class TestCategoricalDtype(Base):
 
     def create(self):
@@ -82,7 +112,7 @@ def test_equality(self):
     def test_construction_from_string(self):
         result = CategoricalDtype.construct_from_string('category')
         assert is_dtype_equal(self.dtype, result)
-        msg = "cannot construct a CategoricalDtype"
+        msg = "Cannot construct a 'CategoricalDtype' from 'foo'"
         with pytest.raises(TypeError, match=msg):
             CategoricalDtype.construct_from_string('foo')