BUG: allow Timestamp comparisons on the left

Now tested with Series and DataFrame

Author: cpcloud

doc/source/release.rst

@@ -487,6 +487,8 @@ Bug Fixes
   - Fix repr for DateOffset. No longer show duplicate entries in kwds.
     Removed unused offset fields. (:issue:`4638`)
   - Fixed wrong index name during read_csv if using usecols. Applies to c parser only. (:issue:`4201`)
+  - ``Timestamp`` objects can now appear in the left hand side of a comparison
+    operation with a ``Series`` or ``DataFrame`` object (:issue:`4982`).
 
 pandas 0.12.0
 -------------

pandas/tests/test_frame.py

@@ -4335,6 +4335,31 @@ def check(df,df2):
         df2 = DataFrame({'a': date_range('20010101', periods=len(df)), 'b': date_range('20100101', periods=len(df))})
         check(df,df2)
 
+    def test_timestamp_compare(self):
+        # make sure we can compare Timestamps on the right AND left hand side
+        # GH4982
+        df = DataFrame({'dates1': date_range('20010101', periods=10),
+                        'dates2': date_range('20010102', periods=10),
+                        'intcol': np.random.randint(1000000000, size=10),
+                        'floatcol': np.random.randn(10),
+                        'stringcol': list(tm.rands(10))})
+        df.loc[np.random.rand(len(df)) > 0.5, 'dates2'] = pd.NaT
+        ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq',
+               'ne': 'ne'}
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+
+            # no nats
+            expected = left_f(df, Timestamp('20010109'))
+            result = right_f(Timestamp('20010109'), df)
+            tm.assert_frame_equal(result, expected)
+
+            # nats
+            expected = left_f(df, Timestamp('nat'))
+            result = right_f(Timestamp('nat'), df)
+            tm.assert_frame_equal(result, expected)
+
     def test_modulo(self):
 
         # GH3590, modulo as ints

pandas/tests/test_series.py

@@ -2059,6 +2059,42 @@ def check_comparators(series, other):
         check_comparators(self.ts, 5)
         check_comparators(self.ts, self.ts + 1)
 
+    def test_timestamp_compare(self):
+        # make sure we can compare Timestamps on the right AND left hand side
+        # GH4982
+        df = DataFrame({'dates': date_range('20010101', periods=10)})
+        s = df.dates.copy()
+
+        s[0] = pd.Timestamp('nat')
+        s[3] = pd.Timestamp('nat')
+
+        ops = {'lt': 'gt', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'}
+
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+
+            # no nats
+            expected = left_f(df.dates, Timestamp('20010109'))
+            result = right_f(Timestamp('20010109'), df.dates)
+            tm.assert_series_equal(result, expected)
+
+            # nats
+            expected = left_f(df.dates, Timestamp('nat'))
+            result = right_f(Timestamp('nat'), df.dates)
+            tm.assert_series_equal(result, expected)
+
+            # compare to timestamp with series containing nats
+            expected = left_f(s, Timestamp('20010109'))
+            result = right_f(Timestamp('20010109'), s)
+            tm.assert_series_equal(result, expected)
+
+            # compare to nat with series containing nats
+            expected = left_f(s, Timestamp('nat'))
+            result = right_f(Timestamp('nat'), s)
+            tm.assert_series_equal(result, expected)
+
+
     def test_operators_empty_int_corner(self):
         s1 = Series([], [], dtype=np.int32)
         s2 = Series({'x': 0.})
@@ -4990,6 +5026,39 @@ def test_numpy_unique(self):
         result = np.unique(self.ts)
 
 
+def test_timestamp_compare_scalars():
+    # case where ndim == 0
+    lhs = np.datetime64(datetime(2013, 12, 6))
+    rhs = Timestamp('now')
+    nat = Timestamp('nat')
+
+    ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq',
+           'ne': 'ne'}
+
+    for left, right in ops.items():
+        left_f = getattr(operator, left)
+        right_f = getattr(operator, right)
+
+        if pd._np_version_under1p7:
+            # you have to convert to timestamp for this to work with numpy
+            # scalars
+            expected = left_f(Timestamp(lhs), rhs)
+
+            # otherwise a TypeError is thrown
+            if left not in ('eq', 'ne'):
+                with tm.assertRaises(TypeError):
+                    left_f(lhs, rhs)
+        else:
+            expected = left_f(lhs, rhs)
+
+        result = right_f(rhs, lhs)
+        tm.assert_equal(result, expected)
+
+        expected = left_f(rhs, nat)
+        result = right_f(nat, rhs)
+        tm.assert_equal(result, expected)
+
+
 class TestSeriesNonUnique(unittest.TestCase):
 
     _multiprocess_can_split_ = True

pandas/tslib.pyx

@@ -457,6 +457,7 @@ cdef class _Timestamp(datetime):
 
     def __richcmp__(_Timestamp self, object other, int op):
         cdef _Timestamp ots
+        cdef int ndim = getattr(other, 'ndim', -1)
 
         if isinstance(other, _Timestamp):
             ots = other
@@ -470,13 +471,33 @@ cdef class _Timestamp(datetime):
             except ValueError:
                 return self._compare_outside_nanorange(other, op)
         else:
-            if op == 2:
-                return False
-            elif op == 3:
-                return True
+            if ndim != -1:
+                if ndim == 0:
+                    if isinstance(other, np.datetime64):
+                        other = Timestamp(other)
+                    else:
+                        raise TypeError("Cannot compare Timestamp with type"
+                                        " %r" % type(other).__name__)
+                if op == 2: # ==
+                    return other == self
+                elif op == 3: # !=
+                    return other != self
+                elif op == 0: # <
+                    return other > self
+                elif op == 1: # <=
+                    return other >= self
+                elif op == 4: # >
+                    return other < self
+                elif op == 5: # >=
+                    return other <= self
             else:
-                raise TypeError('Cannot compare Timestamp with '
-                                '{0!r}'.format(other.__class__.__name__))
+                if op == 2:
+                    return False
+                elif op == 3:
+                    return True
+                else:
+                    raise TypeError('Cannot compare Timestamp with '
+                                    '{0!r}'.format(other.__class__.__name__))
 
         self._assert_tzawareness_compat(other)
 
@@ -589,21 +610,40 @@ cdef class _NaT(_Timestamp):
     def __richcmp__(_NaT self, object other, int op):
         # if not isinstance(other, (_NaT, _Timestamp)):
         #     raise TypeError('Cannot compare %s with NaT' % type(other))
+        cdef int ndim = getattr(other, 'ndim', -1)
 
-        if op == 2: # ==
-            return False
-        elif op == 3: # !=
-            return True
-        elif op == 0: # <
-            return False
-        elif op == 1: # <=
-            return False
-        elif op == 4: # >
-            return False
-        elif op == 5: # >=
-            return False
-
-
+        if ndim != -1:
+            if ndim == 0:
+                if isinstance(other, np.datetime64):
+                    other = Timestamp(other)
+                else:
+                    raise TypeError("Cannot compare NaT with type "
+                                    "%r" % type(other).__name__)
+            if op == 2: # ==
+                return other == self
+            elif op == 3: # !=
+                return other != self
+            elif op == 0: # <
+                return other > self
+            elif op == 1: # <=
+                return other >= self
+            elif op == 4: # >
+                return other < self
+            elif op == 5: # >=
+                return other <= self
+        else:
+            if op == 2: # ==
+                return False
+            elif op == 3: # !=
+                return True
+            elif op == 0: # <
+                return False
+            elif op == 1: # <=
+                return False
+            elif op == 4: # >
+                return False
+            elif op == 5: # >=
+                return False
 
 
 def _delta_to_nanoseconds(delta):