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

Author: lodagro

doc/source/gotchas.rst

@@ -217,3 +217,27 @@ passed in the index, thus finding the integers ``0`` and ``1``. While it would
 be possible to insert some logic to check whether a passed sequence is all
 contained in the index, that logic would exact a very high cost in large data
 sets.
+
+Timestamp limitations
+---------------------
+
+Minimum and maximum timestamps
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since pandas represents timestamps in nanosecond resolution, the timespan that
+can be represented using a 64-bit integer is limited to approximately 584 years:
+
+.. ipython:: python
+
+   begin = Timestamp(-9223285636854775809L)
+   begin
+   end = Timestamp(np.iinfo(np.int64).max)
+   end
+
+If you need to represent time series data outside the nanosecond timespan, use
+PeriodIndex:
+
+.. ipython:: python
+
+   span = period_range('1215-01-01', '1381-01-01', freq='D')
+   span

pandas/src/datetime.pyx

@@ -65,6 +65,7 @@ def ints_to_pydatetime(ndarray[int64_t] arr, tz=None):
     return result
 
 
+
 # Python front end to C extension type _Timestamp
 # This serves as the box for datetime64
 class Timestamp(_Timestamp):
@@ -101,10 +102,27 @@ class Timestamp(_Timestamp):
         return ts_base
 
     def __repr__(self):
-        result = self.strftime('<Timestamp: %Y-%m-%d %H:%M:%S%z')
-        if self.tzinfo:
-            result += self.strftime(' %%Z, tz=%s' % self.tzinfo.zone)
-        return result + '>'
+        result = '%d-%.2d-%.2d %.2d:%.2d:%.2d' % (self.year, self.month,
+                                                  self.day, self.hour,
+                                                  self.minute, self.second)
+
+        if self.nanosecond != 0:
+            nanos = self.nanosecond + 1000 * self.microsecond
+            result += '.%.9d' % nanos
+        elif self.microsecond != 0:
+            result += '.%.6d' % self.microsecond
+
+        try:
+            result += self.strftime('%z')
+            if self.tzinfo:
+                result += self.strftime(' %%Z, tz=%s' % self.tzinfo.zone)
+        except ValueError:
+            year2000 = self.replace(year=2000)
+            result += year2000.strftime('%z')
+            if self.tzinfo:
+                result += year2000.strftime(' %%Z, tz=%s' % self.tzinfo.zone)
+
+        return '<Timestamp: %s>' % result
 
     @property
     def tz(self):
@@ -507,13 +525,17 @@ cpdef convert_to_tsobject(object ts, object tz=None):
             obj.tzinfo = ts.tzinfo
             if obj.tzinfo is not None:
                 obj.value -= _delta_to_nanoseconds(obj.tzinfo._utcoffset)
+        _check_dts_bounds(obj.value, &obj.dts)
         return obj
     elif PyDate_Check(ts):
         obj.value  = _date_to_datetime64(ts, &obj.dts)
     else:
         raise ValueError("Could not construct Timestamp from argument %s" %
                          type(ts))
 
+    if obj.value != NPY_NAT:
+        _check_dts_bounds(obj.value, &obj.dts)
+
     if tz is not None:
         if tz is pytz.utc:
             obj.tzinfo = tz
@@ -530,6 +552,20 @@ cpdef convert_to_tsobject(object ts, object tz=None):
 
     return obj
 
+cdef int64_t _NS_LOWER_BOUND = -9223285636854775809LL
+cdef int64_t _NS_UPPER_BOUND = -9223372036854775807LL
+
+cdef inline _check_dts_bounds(int64_t value, pandas_datetimestruct *dts):
+    cdef pandas_datetimestruct dts2
+    if dts.year <= 1677 or dts.year >= 2262:
+        pandas_datetime_to_datetimestruct(value, PANDAS_FR_ns, &dts2)
+        if dts2.year != dts.year:
+            fmt = '%d-%.2d-%.2d %.2d:%.2d:%.2d' % (dts.year, dts.month,
+                                                   dts.day, dts.hour,
+                                                   dts.min, dts.sec)
+
+            raise ValueError('Out of bounds nanosecond timestamp: %s' % fmt)
+
 # elif isinstance(ts, _Timestamp):
 #     tmp = ts
 #     obj.value = (<_Timestamp> ts).value
@@ -613,8 +649,10 @@ def array_to_datetime(ndarray[object] values, raise_=False, dayfirst=False):
                 iresult[i] = iNaT
             elif PyDateTime_Check(val):
                 iresult[i] = _pydatetime_to_dts(val, &dts)
+                _check_dts_bounds(iresult[i], &dts)
             elif PyDate_Check(val):
                 iresult[i] = _date_to_datetime64(val, &dts)
+                _check_dts_bounds(iresult[i], &dts)
             elif util.is_datetime64_object(val):
                 iresult[i] = _get_datetime64_nanos(val)
             elif util.is_integer_object(val):
@@ -627,6 +665,9 @@ def array_to_datetime(ndarray[object] values, raise_=False, dayfirst=False):
                     result[i] = parse(val, dayfirst=dayfirst)
                 except Exception:
                     raise TypeError
+                pandas_datetime_to_datetimestruct(iresult[i], PANDAS_FR_ns,
+                                                  &dts)
+                _check_dts_bounds(iresult[i], &dts)
         return result
     except TypeError:
         oresult = np.empty(n, dtype=object)

pandas/tools/plotting.py

@@ -10,7 +10,7 @@
 from pandas.core.series import Series
 from pandas.tseries.index import DatetimeIndex
 from pandas.tseries.period import PeriodIndex
-from pandas.tseries.frequencies import get_period_alias
+from pandas.tseries.frequencies import get_period_alias, get_base_alias
 from pandas.tseries.offsets import DateOffset
 import pandas.tseries.tools as datetools
 
@@ -590,14 +590,19 @@ def __init__(self, data, **kwargs):
     def has_ts_index(self):
         from pandas.core.frame import DataFrame
         if isinstance(self.data, (Series, DataFrame)):
-            if isinstance(self.data.index, (DatetimeIndex, PeriodIndex)):
-                has_freq = (hasattr(self.data.index, 'freq') and
-                            self.data.index.freq is not None)
-                has_inferred = (hasattr(self.data.index, 'inferred_freq') and
-                                self.data.index.inferred_freq is not None)
-                return has_freq or has_inferred
+            freq = (getattr(self.data.index, 'freq', None)
+                    or getattr(self.data.index, 'inferred_freq', None))
+            return (freq is not None) and  self._has_dynamic_index_freq(freq)
         return False
 
+    def _has_dynamic_index_freq(self, freq):
+        if isinstance(freq, DateOffset):
+            freq = freq.rule_code
+        else:
+            freq = get_base_alias(freq)
+        freq = get_period_alias(freq)
+        return freq is not None
+
     def _make_plot(self):
         # this is slightly deceptive
         if self.use_index and self.has_ts_index:

pandas/tseries/frequencies.py

@@ -246,7 +246,16 @@ def _get_freq_str(base, mult=1):
     'BA' : 'A',
     'AS' : 'A',
     'BAS' : 'A',
-    'MS' : 'M'
+    'MS' : 'M',
+    'D' : 'D',
+    'B' : 'B',
+    'T' : 'T',
+    'S' : 'S',
+    'H' : 'H',
+    'Q' : 'Q',
+    'A' : 'A',
+    'W' : 'W',
+    'M' : 'M'
 }
 
 need_suffix = ['QS', 'BQ', 'BQS', 'AS', 'BA', 'BAS']
@@ -257,9 +266,20 @@ def _get_freq_str(base, mult=1):
         _offset_to_period_map['%s-%s' % (prefix, m)] = \
             _offset_to_period_map[prefix]
 
+months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP',
+          'OCT', 'NOV', 'DEC']
+for prefix in ['A', 'Q']:
+    for m in months:
+        alias = '%s-%s' % (prefix, m)
+        _offset_to_period_map[alias] = alias
+
+_days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
+for d in _days:
+    _offset_to_period_map['W-%s' % d] = 'W-%s' % d
+
 def get_period_alias(offset_str):
     """ alias to closest period strings BQ->Q etc"""
-    return _offset_to_period_map.get(offset_str, offset_str)
+    return _offset_to_period_map.get(offset_str, None)
 
 _rule_aliases = {
     # Legacy rules that will continue to map to their original values

pandas/tseries/plotting.py

@@ -136,7 +136,6 @@ def _get_default_annual_spacing(nyears):
         (min_spacing, maj_spacing) = (factor * 20, factor * 100)
     return (min_spacing, maj_spacing)
 
-
 def period_break(dates, period):
     """
     Returns the indices where the given period changes.

pandas/tseries/tests/test_plotting.py

@@ -68,6 +68,14 @@ def test_tsplot(self):
         ax = ts.plot(style='k')
         self.assert_((0., 0., 0.) == ax.get_lines()[0].get_color())
 
+    @slow
+    def test_high_freq(self):
+        freaks = ['ms', 'us']
+        for freq in freaks:
+            rng = date_range('1/1/2012', periods=100000, freq=freq)
+            ser = Series(np.random.randn(len(rng)), rng)
+            _check_plot_works(ser.plot)
+
     def test_get_datevalue(self):
         from pandas.tseries.plotting import get_datevalue
         self.assert_(get_datevalue(None, 'D') is None)
@@ -268,6 +276,7 @@ def test_finder_monthly(self):
     @slow
     def test_finder_annual(self):
         import matplotlib.pyplot as plt
+        plt.close('all')
         xp = [1987, 1988, 1990, 1990, 1995, 2020, 2070, 2170]
         for i, nyears in enumerate([5, 10, 19, 49, 99, 199, 599, 1001]):
             rng = period_range('1987', periods=nyears, freq='A')

pandas/tseries/tests/test_timeseries.py

@@ -898,6 +898,24 @@ def test_timestamp_fields(self):
         self.assertEqual(idx.freq, Timestamp(idx[0], idx.freq).freq)
         self.assertEqual(idx.freqstr, Timestamp(idx[0], idx.freq).freqstr)
 
+    def test_timestamp_date_out_of_range(self):
+        self.assertRaises(ValueError, Timestamp, '1676-01-01')
+        self.assertRaises(ValueError, Timestamp, '2263-01-01')
+
+        # 1475
+        self.assertRaises(ValueError, DatetimeIndex, ['1400-01-01'])
+        self.assertRaises(ValueError, DatetimeIndex, [datetime(1400, 1, 1)])
+
+    def test_timestamp_repr(self):
+        # pre-1900
+        stamp = Timestamp('1850-01-01', tz='US/Eastern')
+        repr(stamp)
+
+        iso8601 = '1850-01-01 01:23:45.012345'
+        stamp = Timestamp(iso8601, tz='US/Eastern')
+        result = repr(stamp)
+        self.assert_(iso8601 in result)
+
     def test_datetimeindex_integers_shift(self):
         rng = date_range('1/1/2000', periods=20)
 
@@ -918,7 +936,6 @@ def test_astype_object(self):
 
         self.assert_(np.array_equal(casted, exp_values))
 
-
     def test_catch_infinite_loop(self):
         offset = datetools.DateOffset(minute=5)
         # blow up, don't loop forever