TST: Timestamp and Timeseries tests reorg (gh14854)

pandas/sparse/tests/test_series.py

@@ -19,6 +19,9 @@
 from pandas._sparse import BlockIndex, IntIndex
 from pandas.sparse.api import SparseSeries
 from pandas.tests.series.test_misc_api import SharedWithSparse
+from pandas.util.testing import assert_series_equal
+
+from pandas.tests.series.common import TestData
 
 
 def _test_data1():
@@ -1368,6 +1371,50 @@ def test_numpy_func_call(self):
                 getattr(np, func)(getattr(self, series))
 
 
+class TestSeriesMissingData(TestData, tm.TestCase):
+
+    _multiprocess_can_split_ = True
+
+    def test_sparse_series_fillna_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.randn(10), index=index)
+
+        ss = s[:2].reindex(index).to_sparse()
+        result = ss.fillna(method='pad', limit=5)
+        expected = ss.fillna(method='pad', limit=5)
+        expected = expected.to_dense()
+        expected[-3:] = np.nan
+        expected = expected.to_sparse()
+        assert_series_equal(result, expected)
+
+        ss = s[-2:].reindex(index).to_sparse()
+        result = ss.fillna(method='backfill', limit=5)
+        expected = ss.fillna(method='backfill')
+        expected = expected.to_dense()
+        expected[:3] = np.nan
+        expected = expected.to_sparse()
+        assert_series_equal(result, expected)
+
+    def test_sparse_series_pad_backfill_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.randn(10), index=index)
+        s = s.to_sparse()
+
+        result = s[:2].reindex(index, method='pad', limit=5)
+        expected = s[:2].reindex(index).fillna(method='pad')
+        expected = expected.to_dense()
+        expected[-3:] = np.nan
+        expected = expected.to_sparse()
+        assert_series_equal(result, expected)
+
+        result = s[-2:].reindex(index, method='backfill', limit=5)
+        expected = s[-2:].reindex(index).fillna(method='backfill')
+        expected = expected.to_dense()
+        expected[:3] = np.nan
+        expected = expected.to_sparse()
+        assert_series_equal(result, expected)
+
+
 if __name__ == '__main__':
     import nose
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],

pandas/tests/indexes/datetimes/test_construction.py

@@ -4,7 +4,8 @@
 import pandas as pd
 import pandas.util.testing as tm
 from pandas.tslib import OutOfBoundsDatetime
-from pandas import (DatetimeIndex, Index, Timestamp, datetime, date_range)
+from pandas import (DatetimeIndex, Index, Timestamp, datetime, date_range,
+                    to_datetime)
 
 
 class TestDatetimeIndex(tm.TestCase):
@@ -423,3 +424,69 @@ def test_000constructor_resolution(self):
         idx = DatetimeIndex([t1])
 
         self.assertEqual(idx.nanosecond[0], t1.nanosecond)
+
+
+class TestTimeSeries(tm.TestCase):
+    _multiprocess_can_split_ = True
+
+    def test_dti_constructor_preserve_dti_freq(self):
+        rng = date_range('1/1/2000', '1/2/2000', freq='5min')
+
+        rng2 = DatetimeIndex(rng)
+        self.assertEqual(rng.freq, rng2.freq)
+
+    def test_dti_constructor_years_only(self):
+        # GH 6961
+        for tz in [None, 'UTC', 'Asia/Tokyo', 'dateutil/US/Pacific']:
+            rng1 = date_range('2014', '2015', freq='M', tz=tz)
+            expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)
+
+            rng2 = date_range('2014', '2015', freq='MS', tz=tz)
+            expected2 = date_range('2014-01-01', '2015-01-01', freq='MS',
+                                   tz=tz)
+
+            rng3 = date_range('2014', '2020', freq='A', tz=tz)
+            expected3 = date_range('2014-12-31', '2019-12-31', freq='A', tz=tz)
+
+            rng4 = date_range('2014', '2020', freq='AS', tz=tz)
+            expected4 = date_range('2014-01-01', '2020-01-01', freq='AS',
+                                   tz=tz)
+
+            for rng, expected in [(rng1, expected1), (rng2, expected2),
+                                  (rng3, expected3), (rng4, expected4)]:
+                tm.assert_index_equal(rng, expected)
+
+    def test_dti_constructor_small_int(self):
+        # GH 13721
+        exp = DatetimeIndex(['1970-01-01 00:00:00.00000000',
+                             '1970-01-01 00:00:00.00000001',
+                             '1970-01-01 00:00:00.00000002'])
+
+        for dtype in [np.int64, np.int32, np.int16, np.int8]:
+            arr = np.array([0, 10, 20], dtype=dtype)
+            tm.assert_index_equal(DatetimeIndex(arr), exp)
+
+    def test_dti_constructor_numpy_timeunits(self):
+        # GH 9114
+        base = pd.to_datetime(['2000-01-01T00:00', '2000-01-02T00:00', 'NaT'])
+
+        for dtype in ['datetime64[h]', 'datetime64[m]', 'datetime64[s]',
+                      'datetime64[ms]', 'datetime64[us]', 'datetime64[ns]']:
+            values = base.values.astype(dtype)
+
+            tm.assert_index_equal(DatetimeIndex(values), base)
+            tm.assert_index_equal(to_datetime(values), base)
+
+    def test_constructor_int64_nocopy(self):
+        # #1624
+        arr = np.arange(1000, dtype=np.int64)
+        index = DatetimeIndex(arr)
+
+        arr[50:100] = -1
+        self.assertTrue((index.asi8[50:100] == -1).all())
+
+        arr = np.arange(1000, dtype=np.int64)
+        index = DatetimeIndex(arr, copy=True)
+
+        arr[50:100] = -1
+        self.assertTrue((index.asi8[50:100] != -1).all())

pandas/tests/indexes/datetimes/test_date_range.py

@@ -0,0 +1,112 @@
+from datetime import datetime, timedelta, time
+
+import pandas as pd
+import pandas.util.testing as tm
+from pandas import date_range, offsets, DatetimeIndex, Timestamp
+
+from pandas.tests.series.common import TestData
+
+
+class TestTimeSeries(TestData, tm.TestCase):
+    _multiprocess_can_split_ = True
+
+    def test_date_range_gen_error(self):
+        rng = date_range('1/1/2000 00:00', '1/1/2000 00:18', freq='5min')
+        self.assertEqual(len(rng), 4)
+
+    def test_date_range_negative_freq(self):
+        # GH 11018
+        rng = date_range('2011-12-31', freq='-2A', periods=3)
+        exp = pd.DatetimeIndex(['2011-12-31', '2009-12-31',
+                                '2007-12-31'], freq='-2A')
+        tm.assert_index_equal(rng, exp)
+        self.assertEqual(rng.freq, '-2A')
+
+        rng = date_range('2011-01-31', freq='-2M', periods=3)
+        exp = pd.DatetimeIndex(['2011-01-31', '2010-11-30',
+                                '2010-09-30'], freq='-2M')
+        tm.assert_index_equal(rng, exp)
+        self.assertEqual(rng.freq, '-2M')
+
+    def test_date_range_bms_bug(self):
+        # #1645
+        rng = date_range('1/1/2000', periods=10, freq='BMS')
+
+        ex_first = Timestamp('2000-01-03')
+        self.assertEqual(rng[0], ex_first)
+
+    def test_date_range_normalize(self):
+        snap = datetime.today()
+        n = 50
+
+        rng = date_range(snap, periods=n, normalize=False, freq='2D')
+
+        offset = timedelta(2)
+        values = DatetimeIndex([snap + i * offset for i in range(n)])
+
+        tm.assert_index_equal(rng, values)
+
+        rng = date_range('1/1/2000 08:15', periods=n, normalize=False,
+                         freq='B')
+        the_time = time(8, 15)
+        for val in rng:
+            self.assertEqual(val.time(), the_time)
+
+    def test_date_range_fy5252(self):
+        dr = date_range(start="2013-01-01", periods=2, freq=offsets.FY5253(
+            startingMonth=1, weekday=3, variation="nearest"))
+        self.assertEqual(dr[0], Timestamp('2013-01-31'))
+        self.assertEqual(dr[1], Timestamp('2014-01-30'))
+
+    def test_date_range_ambiguous_arguments(self):
+        # #2538
+        start = datetime(2011, 1, 1, 5, 3, 40)
+        end = datetime(2011, 1, 1, 8, 9, 40)
+
+        self.assertRaises(ValueError, date_range, start, end, freq='s',
+                          periods=10)
+
+    def test_date_range_businesshour(self):
+        idx = DatetimeIndex(['2014-07-04 09:00', '2014-07-04 10:00',
+                             '2014-07-04 11:00',
+                             '2014-07-04 12:00', '2014-07-04 13:00',
+                             '2014-07-04 14:00',
+                             '2014-07-04 15:00', '2014-07-04 16:00'],
+                            freq='BH')
+        rng = date_range('2014-07-04 09:00', '2014-07-04 16:00', freq='BH')
+        tm.assert_index_equal(idx, rng)
+
+        idx = DatetimeIndex(
+            ['2014-07-04 16:00', '2014-07-07 09:00'], freq='BH')
+        rng = date_range('2014-07-04 16:00', '2014-07-07 09:00', freq='BH')
+        tm.assert_index_equal(idx, rng)
+
+        idx = DatetimeIndex(['2014-07-04 09:00', '2014-07-04 10:00',
+                             '2014-07-04 11:00',
+                             '2014-07-04 12:00', '2014-07-04 13:00',
+                             '2014-07-04 14:00',
+                             '2014-07-04 15:00', '2014-07-04 16:00',
+                             '2014-07-07 09:00', '2014-07-07 10:00',
+                             '2014-07-07 11:00',
+                             '2014-07-07 12:00', '2014-07-07 13:00',
+                             '2014-07-07 14:00',
+                             '2014-07-07 15:00', '2014-07-07 16:00',
+                             '2014-07-08 09:00', '2014-07-08 10:00',
+                             '2014-07-08 11:00',
+                             '2014-07-08 12:00', '2014-07-08 13:00',
+                             '2014-07-08 14:00',
+                             '2014-07-08 15:00', '2014-07-08 16:00'],
+                            freq='BH')
+        rng = date_range('2014-07-04 09:00', '2014-07-08 16:00', freq='BH')
+        tm.assert_index_equal(idx, rng)
+
+    def test_range_misspecified(self):
+        # GH #1095
+
+        self.assertRaises(ValueError, date_range, '1/1/2000')
+        self.assertRaises(ValueError, date_range, end='1/1/2000')
+        self.assertRaises(ValueError, date_range, periods=10)
+
+        self.assertRaises(ValueError, date_range, '1/1/2000', freq='H')
+        self.assertRaises(ValueError, date_range, end='1/1/2000', freq='H')
+        self.assertRaises(ValueError, date_range, periods=10, freq='H')

pandas/tests/indexes/datetimes/test_datetime.py

@@ -457,74 +457,6 @@ def test_sort_values(self):
         self.assert_numpy_array_equal(dexer,
                                       np.array([0, 2, 1], dtype=np.intp))
 
-    def test_round(self):
-
-        # round
-        dt = Timestamp('20130101 09:10:11')
-        result = dt.round('D')
-        expected = Timestamp('20130101')
-        self.assertEqual(result, expected)
-
-        dt = Timestamp('20130101 19:10:11')
-        result = dt.round('D')
-        expected = Timestamp('20130102')
-        self.assertEqual(result, expected)
-
-        dt = Timestamp('20130201 12:00:00')
-        result = dt.round('D')
-        expected = Timestamp('20130202')
-        self.assertEqual(result, expected)
-
-        dt = Timestamp('20130104 12:00:00')
-        result = dt.round('D')
-        expected = Timestamp('20130105')
-        self.assertEqual(result, expected)
-
-        dt = Timestamp('20130104 12:32:00')
-        result = dt.round('30Min')
-        expected = Timestamp('20130104 12:30:00')
-        self.assertEqual(result, expected)
-
-        dti = date_range('20130101 09:10:11', periods=5)
-        result = dti.round('D')
-        expected = date_range('20130101', periods=5)
-        tm.assert_index_equal(result, expected)
-
-        # floor
-        dt = Timestamp('20130101 09:10:11')
-        result = dt.floor('D')
-        expected = Timestamp('20130101')
-        self.assertEqual(result, expected)
-
-        # ceil
-        dt = Timestamp('20130101 09:10:11')
-        result = dt.ceil('D')
-        expected = Timestamp('20130102')
-        self.assertEqual(result, expected)
-
-        # round with tz
-        dt = Timestamp('20130101 09:10:11', tz='US/Eastern')
-        result = dt.round('D')
-        expected = Timestamp('20130101', tz='US/Eastern')
-        self.assertEqual(result, expected)
-
-        dt = Timestamp('20130101 09:10:11', tz='US/Eastern')
-        result = dt.round('s')
-        self.assertEqual(result, dt)
-
-        dti = date_range('20130101 09:10:11',
-                         periods=5).tz_localize('UTC').tz_convert('US/Eastern')
-        result = dti.round('D')
-        expected = date_range('20130101', periods=5).tz_localize('US/Eastern')
-        tm.assert_index_equal(result, expected)
-
-        result = dti.round('s')
-        tm.assert_index_equal(result, dti)
-
-        # invalid
-        for freq in ['Y', 'M', 'foobar']:
-            self.assertRaises(ValueError, lambda: dti.round(freq))
-
     def test_take(self):
         dates = [datetime(2010, 1, 1, 14), datetime(2010, 1, 1, 15),
                  datetime(2010, 1, 1, 17), datetime(2010, 1, 1, 21)]