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

@@ -174,15 +174,26 @@ def construct_array_type(cls):
     @classmethod
     def construct_from_string(cls, string):
         """
-        Attempt to construct this type from a string.
+        Construct this type from a string.
+
+        This is useful mainly for data types that accept parameters.
+        For example, datetime types can accept units (e.g. nanoseconds)
+        or timezones. In those cases, the expected type could be
+        something like ``datetime64[ns, UTC]``.
+
+        By default, in the abstract class, just the name of the type is
+        expected. But subclasses can overwrite this method to accept
+        type parameters.
 
         Parameters
         ----------
         string : str
+            The name of the type, for example ``category``.
 
         Returns
         -------
-        self : instance of 'cls'
+        ExtensionDtype
+            Instance of the dtype.
 
         Raises
         ------
@@ -191,18 +202,23 @@ 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>.+)\]$")  # noqa
+        ...     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):