Merge branch 'master' of github.com:pydata/pandas

Author: jreback

doc/source/categorical.rst

@@ -356,9 +356,9 @@ Comparisons
 Comparing categorical data with other objects is possible in three cases:
 
  * comparing equality (``==`` and ``!=``) to a list-like object (list, Series, array,
-   ...) of the same length as the categorical data or
+   ...) of the same length as the categorical data.
  * all comparisons (``==``, ``!=``, ``>``, ``>=``, ``<``, and ``<=``) of categorical data to
-   another categorical Series, when ``ordered==True`` and the `categories` are the same or
+   another categorical Series, when ``ordered==True`` and the `categories` are the same.
  * all comparisons of a categorical data to a scalar.
 
 All other comparisons, especially "non-equality" comparisons of two categoricals with different
@@ -392,7 +392,8 @@ Equality comparisons work with any list-like object of same length and scalars:
 
 .. ipython:: python
 
-    cat == cat_base2
+    cat == cat_base
+    cat == np.array([1,2,3])
     cat == 2
 
 This doesn't work because the categories are not the same:

doc/source/whatsnew/v0.15.2.txt

@@ -91,6 +91,9 @@ API changes
      data.y
      data['y'].values
 
+- Timestamp('now') is now equivalent to Timestamp.now() in that it returns the local time rather than UTC. Also, Timestamp('today') is now
+  equivalent to Timestamp.today() and both have tz as a possible argument. (:issue:`9000`)
+
 .. _whatsnew_0152.enhancements:
 
 Enhancements

pandas/tseries/tests/test_tslib.py

@@ -301,6 +301,36 @@ def test_barely_oob_dts(self):
     def test_utc_z_designator(self):
         self.assertEqual(get_timezone(Timestamp('2014-11-02 01:00Z').tzinfo), 'UTC')
 
+    def test_now(self):
+        # #9000
+        ts_from_string = Timestamp('now')
+        ts_from_method = Timestamp.now()
+        ts_datetime = datetime.datetime.now()
+        
+        ts_from_string_tz = Timestamp('now', tz='US/Eastern')
+        ts_from_method_tz = Timestamp.now(tz='US/Eastern')
+        
+        # Check that the delta between the times is less than 1s (arbitrarily small)
+        delta = Timedelta(seconds=1)
+        self.assertTrue((ts_from_method - ts_from_string) < delta)
+        self.assertTrue((ts_from_method_tz - ts_from_string_tz) < delta)
+        self.assertTrue((ts_from_string_tz.tz_localize(None) - ts_from_string) < delta)
+
+    def test_today(self):
+
+        ts_from_string = Timestamp('today')
+        ts_from_method = Timestamp.today()
+        ts_datetime = datetime.datetime.today()
+        
+        ts_from_string_tz = Timestamp('today', tz='US/Eastern')
+        ts_from_method_tz = Timestamp.today(tz='US/Eastern')
+        
+        # Check that the delta between the times is less than 1s (arbitrarily small)
+        delta = Timedelta(seconds=1)
+        self.assertTrue((ts_from_method - ts_from_string) < delta)
+        self.assertTrue((ts_datetime - ts_from_method) < delta)
+        self.assertTrue((ts_datetime - ts_from_method) < delta)
+        self.assertTrue((ts_from_string_tz.tz_localize(None) - ts_from_string) < delta)
 
 class TestDatetimeParsingWrappers(tm.TestCase):
     def test_does_not_convert_mixed_integer(self):

pandas/tslib.pyx

@@ -176,9 +176,9 @@ def ints_to_pytimedelta(ndarray[int64_t] arr, box=False):
             result[i] = NaT
         else:
             if box:
-               result[i] = Timedelta(value)
+                result[i] = Timedelta(value)
             else:
-               result[i] = timedelta(microseconds=int(value)/1000)
+                result[i] = timedelta(microseconds=int(value)/1000)
 
     return result
 
@@ -219,15 +219,32 @@ class Timestamp(_Timestamp):
 
     @classmethod
     def now(cls, tz=None):
-        """ compat now with datetime """
+        """ 
+        Return the current time in the local timezone.  Equivalent
+        to datetime.now([tz])
+        
+        Parameters
+        ----------
+        tz : string / timezone object, default None
+            Timezone to localize to
+        """
         if isinstance(tz, basestring):
             tz = maybe_get_tz(tz)
         return cls(datetime.now(tz))
 
     @classmethod
-    def today(cls):
-        """ compat today with datetime """
-        return cls(datetime.today())
+    def today(cls, tz=None):
+        """
+        Return the current time in the local timezone.  This differs
+        from datetime.today() in that it can be localized to a
+        passed timezone.
+        
+        Parameters
+        ----------
+        tz : string / timezone object, default None
+            Timezone to localize to
+        """
+        return cls.now(tz)
 
     @classmethod
     def utcnow(cls):
@@ -1024,6 +1041,14 @@ cdef convert_to_tsobject(object ts, object tz, object unit):
     if util.is_string_object(ts):
         if ts in _nat_strings:
             ts = NaT
+        elif ts == 'now': 
+            # Issue 9000, we short-circuit rather than going 
+            # into np_datetime_strings which returns utc
+            ts = Timestamp.now(tz)
+        elif ts == 'today': 
+            # Issue 9000, we short-circuit rather than going 
+            # into np_datetime_strings which returns a normalized datetime
+            ts = Timestamp.today(tz)
         else:
             try:
                 _string_to_dts(ts, &obj.dts, &out_local, &out_tzoffset)