Cleanup

Removed some accumulated cruft

pandas/core/arrays/datetimelike.py

@@ -645,6 +645,7 @@ def _from_factorized(cls, values, original):
     # pandas currently assumes they're there.
 
     def value_counts(self, dropna=False):
+        # n.b. moved from PeriodArray.value_counts
         from pandas import Series, Index
 
         if dropna:
@@ -684,6 +685,7 @@ def repeat(self, repeats, *args, **kwargs):
         --------
         numpy.ndarray.repeat
         """
+        # n.b. moved from PeriodArray.repeat
         nv.validate_repeat(args, kwargs)
         values = self._data.repeat(repeats)
         return type(self)(values, dtype=self.dtype)
@@ -823,6 +825,7 @@ def _validate_frequency(cls, index, freq, **kwargs):
 
     # monotonicity/uniqueness properties are called via frequencies.infer_freq,
     #  see GH#23789
+    # n.b. moved from TimedeltaArray
 
     @property
     def _is_monotonic_increasing(self):

pandas/core/arrays/datetimes.py

@@ -150,6 +150,8 @@ def wrapper(self, other):
                 if (is_datetime64_dtype(other) and
                         not is_datetime64_ns_dtype(other) or
                         not hasattr(other, 'asi8')):
+                    # e.g. other.dtype == 'datetime64[s]'
+                    # or an object-dtype ndarray
                     other = type(self)._from_sequence(other)
 
                 result = meth(self, other)
@@ -171,23 +173,25 @@ def wrapper(self, other):
     return compat.set_function_name(wrapper, opname, cls)
 
 
-def validate_values_freq(values, freq):
-    # type: (Union[DatetimeArrayMixin, TimedeltaArrayMixin], Freq) -> Freq
-    if freq:
-        freq = to_offset(freq)
-        if values.freq != freq:
-            raise ValueError("'freq' does not match.")
-    return values.freq
-
-
 class DatetimeArrayMixin(dtl.DatetimeLikeArrayMixin,
                          dtl.TimelikeOps,
                          dtl.DatelikeOps):
     """
-    Assumes that subclass __new__/__init__ defines:
-        tz
-        _freq
-        _data
+    Pandas ExtensionArray for tz-naive or tz-aware datetime data.
+
+    Parameters
+    ----------
+    values : Series, Index, DatetimeArray, ndarray
+        The datetime data.
+
+        For DatetimeArray `values` (or a Series or Index boxing one),
+        `dtype` and `freq` will be extracted from `values`, with
+        precedence given to
+
+    dtype : numpy.dtype or DatetimeTZDtype
+        Note that the only NumPy dtype allowed is 'datetime64[ns]'.
+    freq : str or Offset, optional
+    copy : bool, default False
     """
     _typ = "datetimearray"
     _scalar_type = Timestamp
@@ -231,8 +235,16 @@ def __init__(self, values, dtype=_NS_DTYPE, freq=None, copy=False):
 
         if isinstance(values, type(self)):
             # validation
-            if getattr(dtype, 'tz', None) and values.tz is None:
+            dtz = getattr(dtype, 'tz', None)
+            if dtz and values.tz is None:
                 dtype = DatetimeTZDtype(tz=dtype.tz)
+            elif dtz and values.tz:
+                if not timezones.tz_compare(dtz, values.tz):
+                    # todo standard error message.
+                    msg = (
+                        "Timezones do not match. {} != {}."
+                    )
+                    raise ValueError(msg.format(dtz, values.tz))
             elif values.tz:
                 dtype = values.dtype
             # freq = validate_values_freq(values, freq)
@@ -478,6 +490,8 @@ def _resolution(self):
 
     def __array__(self, dtype=None):
         # TODO: Check PeriodArray.__array__ and push to parent
+        # This may need to wait for the deprecation of np.array
+        # on datetimetz data.
         if is_object_dtype(dtype):
             return np.array(list(self), dtype=object)
         elif is_int64_dtype(dtype):
@@ -508,10 +522,6 @@ def __iter__(self):
             for v in converted:
                 yield v
 
-    def copy(self, deep=False):
-        values = self.asi8.copy()
-        return type(self)(values, dtype=self.dtype, freq=self.freq)
-
     # ----------------------------------------------------------------
     # ExtensionArray Interface
 
@@ -1586,6 +1596,7 @@ def sequence_to_dt64ns(data, dtype=None, copy=False,
     ------
     TypeError : PeriodDType data is passed
     """
+
     inferred_freq = None
 
     if not hasattr(data, "dtype"):
@@ -1603,16 +1614,15 @@ def sequence_to_dt64ns(data, dtype=None, copy=False,
         inferred_freq = data.freq
 
     # if dtype has an embedded tz, capture it
-    # breakpoint()
     tz = validate_tz_from_dtype(dtype, tz)
 
     if isinstance(data, (ABCSeries, ABCIndexClass)):
         data = data._data
 
     if isinstance(data, DatetimeArrayMixin):
+        # TODO: verify this changes. This was done in haste.
         if inferred_freq and data.freq:
             assert inferred_freq == data.freq
-        inferred_freq = inferred_freq or data.freq
 
         if tz and data.tz:
             if not timezones.tz_compare(tz, data.tz):

pandas/core/arrays/timedeltas.py

@@ -168,8 +168,6 @@ def _from_sequence(cls, data, dtype=_TD_DTYPE, copy=False,
         freq, freq_infer = dtl.maybe_infer_freq(freq)
 
         data, inferred_freq = sequence_to_td64ns(data, copy=copy, unit=unit)
-        # TODO: maybe inside an ``if inferred_freq is not None:
-
         freq, freq_infer = dtl.validate_inferred_freq(freq, inferred_freq,
                                                       freq_infer)
 

pandas/core/dtypes/missing.py

@@ -210,9 +210,8 @@ def _isna_ndarraylike(obj):
             result[...] = vec.reshape(shape)
 
     elif needs_i8_conversion(dtype):
-        values = values.astype("i8", copy=False)
         # this is the NaT pattern
-        result = values == iNaT
+        result = values.view('i8') == iNaT
     else:
         result = np.isnan(values)
 

pandas/core/frame.py

@@ -5172,8 +5172,6 @@ def extract_values(arr):
                 arr = arr._values
 
             if needs_i8_conversion(arr):
-                # Need an ndarray & EA compat way of doing
-                # this if we want to remove this if.
                 if is_extension_array_dtype(arr.dtype):
                     arr = arr.asi8
                 else:

pandas/core/indexes/datetimelike.py

@@ -109,14 +109,12 @@ def _join_i8_wrapper(joinf, dtype, with_indexers=True):
 
         @staticmethod
         def wrapper(left, right):
-            if isinstance(left, (np.ndarray, ABCIndex, ABCSeries)):
+            if isinstance(left, (np.ndarray, ABCIndex, ABCSeries,
+                                 DatetimeLikeArrayMixin)):
                 left = left.view('i8')
-            elif isinstance(left, DatetimeLikeArrayMixin):
-                left = left.asi8
-            if isinstance(right, (np.ndarray, ABCIndex, ABCSeries)):
+            if isinstance(right, (np.ndarray, ABCIndex, ABCSeries,
+                                  DatetimeLikeArrayMixin)):
                 right = right.view('i8')
-            elif isinstance(right, DatetimeLikeArrayMixin):
-                right = right.asi8
             results = joinf(left, right)
             if with_indexers:
                 join_index, left_indexer, right_indexer = results

pandas/core/reshape/merge.py

@@ -1455,8 +1455,8 @@ def flip(xs):
 
         # initial type conversion as needed
         if needs_i8_conversion(left_values):
-            left_values = left_values.astype('i8', copy=False)
-            right_values = right_values.astype('i8', copy=False)
+            left_values = left_values.view("i8")
+            right_values = right_values.view("i8")
             if tolerance is not None:
                 tolerance = tolerance.value
 

pandas/core/reshape/tile.py

@@ -393,7 +393,7 @@ def _coerce_to_type(x):
 
     if dtype is not None:
         # GH 19768: force NaT to NaN during integer conversion
-        x = np.where(x.notna(), x.astype(np.int64, copy=False), np.nan)
+        x = np.where(x.notna(), x.view(np.int64), np.nan)
 
     return x, dtype
 

pandas/core/series.py

@@ -1544,9 +1544,6 @@ def unique(self):
         ...                          ordered=True)).unique()
         [b, a, c]
         Categories (3, object): [a < b < c]
-
-        >>> pd.Series(pd.date_range('2000', periods=4, tz='US/Central'))
-        # TODO: repr
         """
         result = super(Series, self).unique()
         return result

pandas/io/formats/printing.py

@@ -290,11 +290,6 @@ def format_object_summary(obj, formatter, is_justify=True, name=None,
         Whether subsequent lines should be be indented to
         align with the name.
 
-        Pass ``False`` to indicate that subsequent lines should
-        not be indented to align with the name.
-    trailing_comma : bool, default True
-        Whether to include a comma after the closing ']'
-
     Returns
     -------
     summary string

pandas/tests/arrays/test_datetimelike.py

@@ -297,7 +297,6 @@ def test_concat_same_type_different_freq(self):
         tm.assert_datetime_array_equal(result, expected)
 
 
-@pytest.mark.skip(reason="TODO")
 class TestTimedeltaArray(SharedTests):
     index_cls = pd.TimedeltaIndex
     array_cls = TimedeltaArray

pandas/tests/arrays/test_datetimes.py

@@ -5,12 +5,24 @@
 import operator
 
 import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
 from pandas.core.arrays import DatetimeArrayMixin as DatetimeArray
 import pandas.util.testing as tm
 
 
+class TestDatetimeArrayConstructor(object):
+    def test_mismatched_timezone_raises(self):
+        a = DatetimeArray(np.array(['2000-01-01T06:00:00'], dtype='M8[ns]'),
+                          dtype=DatetimeTZDtype(tz='US/Central'))
+        dtype = DatetimeTZDtype(tz='US/Eastern')
+        with pytest.raises(ValueError, match='Timezones'):
+            DatetimeArray(a, dtype=dtype)
+
+
 class TestDatetimeArrayComparisons(object):
     # TODO: merge this into tests/arithmetic/test_datetime64 once it is
     #  sufficiently robust

pandas/tests/extension/arrow/bool.py

@@ -77,6 +77,7 @@ def __len__(self):
         return len(self._data)
 
     def astype(self, dtype, copy=True):
+        # needed to fix this astype for the Series constructor.
         if isinstance(dtype, type(self.dtype)) and dtype == self.dtype:
             if copy:
                 return self.copy()

pandas/tests/extension/json/array.py

@@ -157,6 +157,8 @@ def astype(self, dtype, copy=True):
         # NumPy has issues when all the dicts are the same length.
         # np.array([UserDict(...), UserDict(...)]) fails,
         # but np.array([{...}, {...}]) works, so cast.
+
+        # needed to add this check for the Series constructor
         if isinstance(dtype, type(self.dtype)) and dtype == self.dtype:
             if copy:
                 return self.copy()

pandas/tests/frame/test_analytics.py

@@ -1613,9 +1613,6 @@ def test_isin_multiIndex(self):
 
     def test_isin_empty_datetimelike(self):
         # GH 15473
-        # This fails since empty.reindex(...) will produce floats.
-        # I wonder if `reindex_like` could / should pass through dtype
-        # info?
         df1_ts = DataFrame({'date':
                             pd.to_datetime(['2014-01-01', '2014-01-02'])})
         df1_td = DataFrame({'date':

pandas/tests/indexes/datetimes/test_astype.py

@@ -119,10 +119,9 @@ def test_astype_datetime64(self):
         tm.assert_index_equal(result, idx)
         assert result is not idx
 
-        # TODO: determine if this is part of the API and we want to maintain
-        # result = idx.astype('datetime64[ns]', copy=False)
-        # tm.assert_index_equal(result, idx)
-        # assert result is idx
+        result = idx.astype('datetime64[ns]', copy=False)
+        tm.assert_index_equal(result, idx)
+        assert result is idx
 
         idx_tz = DatetimeIndex(['2016-05-16', 'NaT', NaT, np.NaN], tz='EST')
         result = idx_tz.astype('datetime64[ns]')

pandas/tests/indexes/datetimes/test_construction.py

@@ -507,7 +507,6 @@ def test_disallow_setting_tz(self):
     @pytest.mark.parametrize('tz', [
         None, 'America/Los_Angeles', pytz.timezone('America/Los_Angeles'),
         Timestamp('2000', tz='America/Los_Angeles').tz])
-    @pytest.mark.xfail(reason="TODO-constructor", strict=False)
     def test_constructor_start_end_with_tz(self, tz):
         # GH 18595
         start = Timestamp('2013-01-01 06:00:00', tz='America/Los_Angeles')
@@ -521,7 +520,6 @@ def test_constructor_start_end_with_tz(self, tz):
         assert pytz.timezone('America/Los_Angeles') is result.tz
 
     @pytest.mark.parametrize('tz', ['US/Pacific', 'US/Eastern', 'Asia/Tokyo'])
-    @pytest.mark.xfail(reason="TODO-constructor", strict=False)
     def test_constructor_with_non_normalized_pytz(self, tz):
         # GH 18595
         non_norm_tz = Timestamp('2010', tz=tz).tz

pandas/tests/indexes/timedeltas/test_construction.py

@@ -28,7 +28,6 @@ def test_int64_nocopy(self):
         tdi = TimedeltaIndex(arr, copy=False)
         assert tdi._data._data.base is arr
 
-    # @pytest.mark.skip(reason="hangs?")
     def test_infer_from_tdi(self):
         # GH#23539
         # fast-path for inferring a frequency if the passed data already

pandas/tests/indexing/test_coercion.py

@@ -31,7 +31,7 @@ def has_test(combo):
     for combo in combos:
         if not has_test(combo):
             msg = 'test method is not defined: {0}, {1}'
-            raise AssertionError(msg.format(cls.__name__, combo))
+            raise AssertionError(msg.format(type(cls), combo))
 
     yield
 

pandas/tests/plotting/test_boxplot_method.py

@@ -93,6 +93,7 @@ def test_boxplot_return_type_none(self):
     def test_boxplot_return_type_legacy(self):
         # API change in https://github.com/pandas-dev/pandas/pull/7096
         import matplotlib as mpl  # noqa
+
         df = DataFrame(np.random.randn(6, 4),
                        index=list(string.ascii_letters[:6]),
                        columns=['one', 'two', 'three', 'four'])

pandas/tests/series/test_combine_concat.py

@@ -199,9 +199,8 @@ def get_result_type(dtype, dtype2):
                 assert result.kind == expected
 
     @pytest.mark.xfail(resson="TODO-where-internals", strict=False)
-    # Something strange with internals shapes.
-    # After reindexing in combine_first, our tz-block mananger is
-    # (maybe?) in a bad state.
+    # https://github.com/pandas-dev/pandas/issues/24147
+    # After reindexing an EA-backed Series, our internal shape is wonky.
     def test_combine_first_dt_tz_values(self, tz_naive_fixture):
         ser1 = pd.Series(pd.DatetimeIndex(['20150101', '20150102', '20150103'],
                                           tz=tz_naive_fixture),