REF/TST: Fix remaining DatetimeArray with DateOffset arithmetic ops

pandas/_libs/tslibs/timestamps.pyx

@@ -377,13 +377,15 @@ cdef class _Timestamp(datetime):
             neg_other = -other
             return self + neg_other
 
+        typ = getattr(other, '_typ', None)
+
         # a Timestamp-DatetimeIndex -> yields a negative TimedeltaIndex
-        elif getattr(other, '_typ', None) == 'datetimeindex':
+        if typ in ('datetimeindex', 'datetimearray'):
             # timezone comparison is performed in DatetimeIndex._sub_datelike
             return -other.__sub__(self)
 
         # a Timestamp-TimedeltaIndex -> yields a negative TimedeltaIndex
-        elif getattr(other, '_typ', None) == 'timedeltaindex':
+        elif typ in ('timedeltaindex', 'timedeltaarray'):
             return (-other).__add__(self)
 
         elif other is NaT:

pandas/core/arrays/timedeltas.py

@@ -7,7 +7,7 @@
 
 import numpy as np
 
-from pandas._libs import tslibs
+from pandas._libs import algos, tslibs
 from pandas._libs.tslibs import NaT, Timedelta, Timestamp, iNaT
 from pandas._libs.tslibs.fields import get_timedelta_field
 from pandas._libs.tslibs.timedeltas import (
@@ -24,7 +24,7 @@
 from pandas.core.dtypes.missing import isna
 
 from pandas.core import ops
-from pandas.core.algorithms import checked_add_with_arr
+from pandas.core.algorithms import checked_add_with_arr, unique1d
 import pandas.core.common as com
 
 from pandas.tseries.frequencies import to_offset
@@ -162,15 +162,29 @@ def _simple_new(cls, values, freq=None, dtype=_TD_DTYPE):
         result._freq = freq
         return result
 
-    def __new__(cls, values, freq=None, dtype=_TD_DTYPE):
+    def __new__(cls, values, freq=None, dtype=_TD_DTYPE, copy=False):
 
         freq, freq_infer = dtl.maybe_infer_freq(freq)
 
-        values = np.array(values, copy=False)
-        if values.dtype == np.object_:
-            values = array_to_timedelta64(values)
+        values, inferred_freq = sequence_to_td64ns(
+            values, copy=copy, unit=None)
+        if inferred_freq is not None:
+            if freq is not None and freq != inferred_freq:
+                raise ValueError('Inferred frequency {inferred} from passed '
+                                 'values does not conform to passed frequency '
+                                 '{passed}'
+                                 .format(inferred=inferred_freq,
+                                         passed=freq.freqstr))
+            elif freq is None:
+                freq = inferred_freq
+                freq_infer = False
 
         result = cls._simple_new(values, freq=freq)
+        # check that we are matching freqs
+        if inferred_freq is None and len(result) > 0:
+            if freq is not None and not freq_infer:
+                cls._validate_frequency(result, freq)
+
         if freq_infer:
             result.freq = to_offset(result.inferred_freq)
 
@@ -227,6 +241,22 @@ def _validate_fill_value(self, fill_value):
                              "Got '{got}'.".format(got=fill_value))
         return fill_value
 
+    # is_monotonic_increasing, is_monotonic_decreasing, and is_unique
+    #  are needed by `frequencies.infer_freq`, which is called when accessing
+    #  the `inferred_freq` property inside the TimedeltaArray constructor
+
+    @property  # NB: override with cache_readonly in immutable subclasses
+    def is_monotonic_increasing(self):
+        return algos.is_monotonic(self.asi8, timelike=True)[0]
+
+    @property  # NB: override with cache_readonly in immutable subclasses
+    def is_monotonic_decreasing(self):
+        return algos.is_monotonic(self.asi8, timelike=True)[1]
+
+    @property  # NB: override with cache_readonly in immutable subclasses
+    def is_unique(self):
+        return len(unique1d(self.asi8)) == len(self)
+
     # ----------------------------------------------------------------
     # Arithmetic Methods
 
@@ -281,7 +311,7 @@ def _add_datetimelike_scalar(self, other):
         result = checked_add_with_arr(i8, other.value,
                                       arr_mask=self._isnan)
         result = self._maybe_mask_results(result)
-        return DatetimeArrayMixin(result, tz=other.tz)
+        return DatetimeArrayMixin(result, tz=other.tz, freq=self.freq)
 
     def _addsub_offset_array(self, other, op):
         # Add or subtract Array-like of DateOffset objects

pandas/core/indexes/timedeltas.py

@@ -227,6 +227,12 @@ def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
     # -------------------------------------------------------------------
     # Wrapping TimedeltaArray
 
+    # override non-caching implementations from TimedeltaArray with
+    #  _engine-based implementations that take advantage of Index immutability
+    is_monotonic_increasing = Index.is_monotonic_increasing
+    is_monotonic_decreasing = Index.is_monotonic_decreasing
+    is_unique = Index.is_unique
+
     __mul__ = Index.__mul__
     __rmul__ = Index.__rmul__
     __truediv__ = Index.__truediv__