Squashed commit of the following:

commit c23c9e2 Merge: 50e1aeb dc8d35a Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Fri Nov 30 09:10:00 2018 -0600 Merge remote-tracking branch 'upstream/master' into dtype-only commit 50e1aeb Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 13:00:35 2018 -0600 PeriodDtype needs freq commit 10d2c8a Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 10:30:29 2018 -0600 refactor construct_from_string commit c14b45f Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 10:19:29 2018 -0600 fix unpickling commit 7ab2a74 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 10:16:32 2018 -0600 Remove _coerce_to_dtype commit 6cc9ce5 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 08:54:35 2018 -0600 Fixed tz name commit e0b7b77 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 07:05:04 2018 -0600 Updates * Use pandas_dtype * removed cache_readonly commit ad2723c Merge: 9e4faf8 d9a037e Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 06:39:25 2018 -0600 Merge remote-tracking branch 'upstream/master' into dtype-only commit 9e4faf8 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Thu Nov 29 06:14:05 2018 -0600 cache readonly commit 7e6d8ea Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Wed Nov 28 21:45:21 2018 -0600 Restore construct_array_type commit 2fa4bb0 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Wed Nov 28 21:14:10 2018 -0600 unxfail test, remove caching bit commit 1ca7fa4 Author: Tom Augspurger <tom.w.augspurger@gmail.com> Date: Wed Nov 28 17:04:40 2018 -0600 REF/API: DatetimeTZDtype * Remove magic constructor from string * Remove Caching The remaining changes in the DatetimeArray PR will be to 1. Inherit from ExtensionDtype 2. Implement construct_array_type 3. Register
pandas-dev · jreback · Jan 2, 2019 · Nov 30, 2018 · Nov 30, 2018 · Nov 30, 2018
commit e9c8418ce793bf044fda1b992386f074d760c8ce
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
@@ -978,16 +978,21 @@ def validate_tz_from_dtype(dtype, tz):
     ValueError : on tzinfo mismatch
     """
     if dtype is not None:
-        try:
-            dtype = DatetimeTZDtype.construct_from_string(dtype)
-            dtz = getattr(dtype, 'tz', None)
-            if dtz is not None:
-                if tz is not None and not timezones.tz_compare(tz, dtz):
-                    raise ValueError("cannot supply both a tz and a dtype"
-                                     " with a tz")
-                tz = dtz
-        except TypeError:
-            pass
+        if isinstance(dtype, compat.string_types):
+            try:
+                dtype = DatetimeTZDtype.construct_from_string(dtype)
+            except TypeError:
+                # Things like `datetime64[ns]`, which is OK for the
+                # constructors, but also nonsense, which should be validated
+                # but not by us. We *do* allow non-existent tz errors to
+                # go through
+                pass
+        dtz = getattr(dtype, 'tz', None)
+        if dtz is not None:
+            if tz is not None and not timezones.tz_compare(tz, dtz):
+                raise ValueError("cannot supply both a tz and a dtype"
+                                 " with a tz")
+            tz = dtz
     return tz
 
 

diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
@@ -12,7 +12,7 @@
     timezones)
 import pandas.compat as compat
 from pandas.errors import PerformanceWarning
-from pandas.util._decorators import Appender, cache_readonly
+from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
     _NS_DTYPE, is_datetime64_dtype, is_datetime64tz_dtype, is_extension_type,
@@ -332,7 +332,7 @@ def _generate_range(cls, start, end, periods, freq, tz=None,
     def _box_func(self):
         return lambda x: Timestamp(x, freq=self.freq, tz=self.tz)
 
-    @cache_readonly
+    @property
     def dtype(self):
         if self.tz is None:
             return _NS_DTYPE

diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
@@ -1767,38 +1767,6 @@ def is_complex_dtype(arr_or_dtype):
     return issubclass(tipo, np.complexfloating)
 
 
-def _coerce_to_dtype(dtype):
-    """
-    Coerce a string or np.dtype to a pandas or numpy
-    dtype if possible.
-
-    If we cannot convert to a pandas dtype initially,
-    we convert to a numpy dtype.
-
-    Parameters
-    ----------
-    dtype : The dtype that we want to coerce.
-
-    Returns
-    -------
-    pd_or_np_dtype : The coerced dtype.
-    """
-
-    if is_categorical_dtype(dtype):
-        categories = getattr(dtype, 'categories', None)
-        ordered = getattr(dtype, 'ordered', False)
-        dtype = CategoricalDtype(categories=categories, ordered=ordered)
-    elif is_datetime64tz_dtype(dtype):
-        dtype = DatetimeTZDtype(dtype)
-    elif is_period_dtype(dtype):
-        dtype = PeriodDtype(dtype)
-    elif is_interval_dtype(dtype):
-        dtype = IntervalDtype(dtype)
-    else:
-        dtype = np.dtype(dtype)
-    return dtype
-
-
 def _get_dtype(arr_or_dtype):
     """
     Get the dtype instance associated with an array

diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
@@ -1,8 +1,8 @@
 """ define extension dtypes """
-
 import re
 
 import numpy as np
+import pytz
 
 from pandas._libs.interval import Interval
 from pandas._libs.tslibs import NaT, Period, Timestamp, timezones
@@ -483,67 +483,63 @@ class DatetimeTZDtype(PandasExtensionDtype):
     str = '|M8[ns]'
     num = 101
     base = np.dtype('M8[ns]')
+    na_value = NaT
     _metadata = ('unit', 'tz')
     _match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
     _cache = {}
+    # TODO: restore caching? who cares though? It seems needlessly complex.
+    # np.dtype('datetime64[ns]') isn't a singleton
 
-    def __new__(cls, unit=None, tz=None):
-        """ Create a new unit if needed, otherwise return from the cache
+    def __init__(self, unit="ns", tz=None):
+        """
+        An ExtensionDtype for timezone-aware datetime data.
 
         Parameters
         ----------
-        unit : string unit that this represents, currently must be 'ns'
-        tz : string tz that this represents
-        """
+        unit : str, default "ns"
+            The precision of the datetime data. Currently limited
+            to ``"ns"``.
+        tz : str, int, or datetime.tzinfo
+            The timezone.
 
+        Raises
+        ------
+        pytz.UnknownTimeZoneError
+            When the requested timezone cannot be found.
+
+        Examples
+        --------
+        >>> pd.core.dtypes.dtypes.DatetimeTZDtype(tz='UTC')
+        datetime64[ns, UTC]
+
+        >>> pd.core.dtypes.dtypes.DatetimeTZDtype(tz='dateutil/US/Central')
+        datetime64[ns, tzfile('/usr/share/zoneinfo/US/Central')]
+        """
         if isinstance(unit, DatetimeTZDtype):
             unit, tz = unit.unit, unit.tz
 
-        elif unit is None:
-            # we are called as an empty constructor
-            # generally for pickle compat
-            return object.__new__(cls)
+        if unit != 'ns':
+            raise ValueError("DatetimeTZDtype only supports ns units")
 
+        if tz:
+            tz = timezones.maybe_get_tz(tz)
+        elif tz is not None:
+            raise pytz.UnknownTimeZoneError(tz)
         elif tz is None:
+            raise TypeError("A 'tz' is required.")
 
-            # we were passed a string that we can construct
-            try:
-                m = cls._match.search(unit)
-                if m is not None:
-                    unit = m.groupdict()['unit']
-                    tz = timezones.maybe_get_tz(m.groupdict()['tz'])
-            except TypeError:
-                raise ValueError("could not construct DatetimeTZDtype")
-
-        elif isinstance(unit, compat.string_types):
-
-            if unit != 'ns':
-                raise ValueError("DatetimeTZDtype only supports ns units")
-
-            unit = unit
-            tz = tz
+        self._unit = unit
+        self._tz = tz
 
-        if tz is None:
-            raise ValueError("DatetimeTZDtype constructor must have a tz "
-                             "supplied")
-
-        # hash with the actual tz if we can
-        # some cannot be hashed, so stringfy
-        try:
-            key = (unit, tz)
-            hash(key)
-        except TypeError:
-            key = (unit, str(tz))
+    @property
+    def unit(self):
+        """The precision of the datetime data."""
+        return self._unit
 
-        # set/retrieve from cache
-        try:
-            return cls._cache[key]
-        except KeyError:
-            u = object.__new__(cls)
-            u.unit = unit
-            u.tz = tz
-            cls._cache[key] = u
-            return u
+    @property
+    def tz(self):
+        """The timezone."""
+        return self._tz
 
     @classmethod
     def construct_array_type(cls):
@@ -558,24 +554,43 @@ def construct_array_type(cls):
 
     @classmethod
     def construct_from_string(cls, string):
-        """ attempt to construct this type from a string, raise a TypeError if
-        it's not possible
         """
+        Construct a DatetimeTZDtype from a string.
+
+        Parameters
+        ----------
+        string : str
+            The string alias for this DatetimeTZDtype.
+            Should be formatted like ``datetime64[ns, <tz>]``,
+            where ``<tz>`` is the timezone name.
+
+        Examples
+        --------
+        >>> DatetimeTZDtype.construct_from_string('datetime64[ns, UTC]')
+        datetime64[ns, UTC]
+        """
+        msg = "Could not construct DatetimeTZDtype from {}"
         try:
-            return cls(unit=string)
-        except ValueError:
-            raise TypeError("could not construct DatetimeTZDtype")
+            match = cls._match.match(string)
+            if match:
+                d = match.groupdict()
+                return cls(unit=d['unit'], tz=d['tz'])
+        except Exception:
+            # TODO(py3): Change this pass to `raise TypeError(msg) from e`
+            pass
+        raise TypeError(msg.format(string))
 
     def __unicode__(self):
-        # format the tz
         return "datetime64[{unit}, {tz}]".format(unit=self.unit, tz=self.tz)
 
     @property
     def name(self):
+        """A string representation of the dtype."""
         return str(self)
 
     def __hash__(self):
         # make myself hashable
+        # TODO: update this.
         return hash(str(self))
 
     def __eq__(self, other):
@@ -586,6 +601,11 @@ def __eq__(self, other):
                 self.unit == other.unit and
                 str(self.tz) == str(other.tz))
 
+    def __setstate__(self, state):
+        # for pickle compat.
+        self._tz = state['tz']
+        self._unit = state['unit']
+
 
 class PeriodDtype(ExtensionDtype, PandasExtensionDtype):
     """

diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
@@ -209,7 +209,7 @@ def _isna_ndarraylike(obj):
             vec = libmissing.isnaobj(values.ravel())
             result[...] = vec.reshape(shape)
 
-    elif needs_i8_conversion(obj):
+    elif needs_i8_conversion(dtype):
         # this is the NaT pattern
         result = values.view('i8') == iNaT
     else:

diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
@@ -2669,11 +2669,10 @@ def _astype(self, dtype, **kwargs):
         these automatically copy, so copy=True has no effect
         raise on an except if raise == True
         """
+        dtype = pandas_dtype(dtype)
 
         # if we are passed a datetime64[ns, tz]
         if is_datetime64tz_dtype(dtype):
-            dtype = DatetimeTZDtype(dtype)
-
             values = self.values
             if getattr(values, 'tz', None) is None:
                 values = DatetimeIndex(values).tz_localize('UTC')

diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
@@ -43,8 +43,8 @@ def test_numpy_string_dtype(self):
         'datetime64[ns, Asia/Tokyo]',
         'datetime64[ns, UTC]'])
     def test_datetimetz_dtype(self, dtype):
-        assert com.pandas_dtype(dtype) is DatetimeTZDtype(dtype)
-        assert com.pandas_dtype(dtype) == DatetimeTZDtype(dtype)
+        assert (com.pandas_dtype(dtype) ==
+                DatetimeTZDtype.construct_from_string(dtype))
         assert com.pandas_dtype(dtype) == dtype
 
     def test_categorical_dtype(self):