TST: more test moving from series/test_timeseries.py

Author: jreback

pandas/tests/frame/test_alter_axes.py

@@ -8,7 +8,7 @@
 
 from pandas.compat import lrange
 from pandas import (DataFrame, Series, Index, MultiIndex,
-                    RangeIndex)
+                    RangeIndex, date_range)
 import pandas as pd
 
 from pandas.util.testing import (assert_series_equal,
@@ -325,6 +325,32 @@ def test_set_columns(self):
         with assertRaisesRegexp(ValueError, 'Length mismatch'):
             self.mixed_frame.columns = cols[::2]
 
+    def test_dti_set_index_reindex(self):
+        # GH 6631
+        df = DataFrame(np.random.random(6))
+        idx1 = date_range('2011/01/01', periods=6, freq='M', tz='US/Eastern')
+        idx2 = date_range('2013', periods=6, freq='A', tz='Asia/Tokyo')
+
+        df = df.set_index(idx1)
+        tm.assert_index_equal(df.index, idx1)
+        df = df.reindex(idx2)
+        tm.assert_index_equal(df.index, idx2)
+
+        # 11314
+        # with tz
+        index = date_range(datetime(2015, 10, 1),
+                           datetime(2015, 10, 1, 23),
+                           freq='H', tz='US/Eastern')
+        df = DataFrame(np.random.randn(24, 1), columns=['a'], index=index)
+        new_index = date_range(datetime(2015, 10, 2),
+                               datetime(2015, 10, 2, 23),
+                               freq='H', tz='US/Eastern')
+
+        # TODO: unused?
+        result = df.set_index(new_index)  # noqa
+
+        self.assertEqual(new_index.freq, index.freq)
+
     # Renaming
 
     def test_rename(self):

pandas/tests/frame/test_apply.py

@@ -433,6 +433,15 @@ def test_applymap_box(self):
                             'd': ['Period', 'Period']})
         tm.assert_frame_equal(res, exp)
 
+    def test_frame_apply_dont_convert_datetime64(self):
+        from pandas.tseries.offsets import BDay
+        df = DataFrame({'x1': [datetime(1996, 1, 1)]})
+
+        df = df.applymap(lambda x: x + BDay())
+        df = df.applymap(lambda x: x + BDay())
+
+        self.assertTrue(df.x1.dtype == 'M8[ns]')
+
     # See gh-12244
     def test_apply_non_numpy_dtype(self):
         df = DataFrame({'dt': pd.date_range(

pandas/tests/frame/test_combine_concat.py

@@ -9,7 +9,7 @@
 
 import pandas as pd
 
-from pandas import DataFrame, Index, Series, Timestamp
+from pandas import DataFrame, Index, Series, Timestamp, date_range
 from pandas.compat import lrange
 
 from pandas.tests.frame.common import TestData
@@ -735,3 +735,17 @@ def test_combine_first_int(self):
         res = df1.combine_first(df2)
         tm.assert_frame_equal(res, df1)
         self.assertEqual(res['a'].dtype, 'int64')
+
+    def test_concat_datetime_datetime64_frame(self):
+        # #2624
+        rows = []
+        rows.append([datetime(2010, 1, 1), 1])
+        rows.append([datetime(2010, 1, 2), 'hi'])
+
+        df2_obj = DataFrame.from_records(rows, columns=['date', 'test'])
+
+        ind = date_range(start="2000/1/1", freq="D", periods=10)
+        df1 = DataFrame({'date': ind, 'test': lrange(10)})
+
+        # it works!
+        pd.concat([df1, df2_obj])

pandas/tests/frame/test_constructors.py

@@ -1920,6 +1920,33 @@ def test_from_index(self):
         df2 = DataFrame(Series(idx2))
         tm.assert_series_equal(df2[0], Series(idx2, name=0))
 
+    def test_frame_dict_constructor_datetime64_1680(self):
+        dr = date_range('1/1/2012', periods=10)
+        s = Series(dr, index=dr)
+
+        # it works!
+        DataFrame({'a': 'foo', 'b': s}, index=dr)
+        DataFrame({'a': 'foo', 'b': s.values}, index=dr)
+
+    def test_frame_datetime64_mixed_index_ctor_1681(self):
+        dr = date_range('2011/1/1', '2012/1/1', freq='W-FRI')
+        ts = Series(dr)
+
+        # it works!
+        d = DataFrame({'A': 'foo', 'B': ts}, index=dr)
+        self.assertTrue(d['B'].isnull().all())
+
+    def test_frame_timeseries_to_records(self):
+        index = date_range('1/1/2000', periods=10)
+        df = DataFrame(np.random.randn(10, 3), index=index,
+                       columns=['a', 'b', 'c'])
+
+        result = df.to_records()
+        result['index'].dtype == 'M8[ns]'
+
+        result = df.to_records(index=False)
+
+
 if __name__ == '__main__':
     import nose  # noqa
 

pandas/tests/frame/test_indexing.py

@@ -1945,6 +1945,21 @@ def test_reindex_methods(self):
         actual = df.reindex(target, method='nearest', tolerance=0.2)
         assert_frame_equal(expected, actual)
 
+    def test_reindex_frame_add_nat(self):
+        rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s')
+        df = DataFrame({'A': np.random.randn(len(rng)), 'B': rng})
+
+        result = df.reindex(lrange(15))
+        self.assertTrue(np.issubdtype(result['B'].dtype, np.dtype('M8[ns]')))
+
+        mask = com.isnull(result)['B']
+        self.assertTrue(mask[-5:].all())
+        self.assertFalse(mask[:-5].any())
+
+    def test_set_dataframe_column_ns_dtype(self):
+        x = DataFrame([datetime.now(), datetime.now()])
+        self.assertEqual(x[0].dtype, np.dtype('M8[ns]'))
+
     def test_non_monotonic_reindex_methods(self):
         dr = pd.date_range('2013-08-01', periods=6, freq='B')
         data = np.random.randn(6, 1)

pandas/tests/frame/test_timeseries.py

@@ -2,7 +2,7 @@
 
 from __future__ import print_function
 
-from datetime import datetime
+from datetime import datetime, time
 
 from numpy import nan
 from numpy.random import randn
@@ -20,6 +20,7 @@
                                  assertRaisesRegexp)
 
 import pandas.util.testing as tm
+from pandas.compat import product
 
 from pandas.tests.frame.common import TestData
 
@@ -418,6 +419,96 @@ def test_first_last_valid(self):
         self.assertIsNone(empty.last_valid_index())
         self.assertIsNone(empty.first_valid_index())
 
+    def test_at_time_frame(self):
+        rng = date_range('1/1/2000', '1/5/2000', freq='5min')
+        ts = DataFrame(np.random.randn(len(rng), 2), index=rng)
+        rs = ts.at_time(rng[1])
+        self.assertTrue((rs.index.hour == rng[1].hour).all())
+        self.assertTrue((rs.index.minute == rng[1].minute).all())
+        self.assertTrue((rs.index.second == rng[1].second).all())
+
+        result = ts.at_time('9:30')
+        expected = ts.at_time(time(9, 30))
+        assert_frame_equal(result, expected)
+
+        result = ts.loc[time(9, 30)]
+        expected = ts.loc[(rng.hour == 9) & (rng.minute == 30)]
+
+        assert_frame_equal(result, expected)
+
+        # midnight, everything
+        rng = date_range('1/1/2000', '1/31/2000')
+        ts = DataFrame(np.random.randn(len(rng), 3), index=rng)
+
+        result = ts.at_time(time(0, 0))
+        assert_frame_equal(result, ts)
+
+        # time doesn't exist
+        rng = date_range('1/1/2012', freq='23Min', periods=384)
+        ts = DataFrame(np.random.randn(len(rng), 2), rng)
+        rs = ts.at_time('16:00')
+        self.assertEqual(len(rs), 0)
+
+    def test_between_time_frame(self):
+        rng = date_range('1/1/2000', '1/5/2000', freq='5min')
+        ts = DataFrame(np.random.randn(len(rng), 2), index=rng)
+        stime = time(0, 0)
+        etime = time(1, 0)
+
+        close_open = product([True, False], [True, False])
+        for inc_start, inc_end in close_open:
+            filtered = ts.between_time(stime, etime, inc_start, inc_end)
+            exp_len = 13 * 4 + 1
+            if not inc_start:
+                exp_len -= 5
+            if not inc_end:
+                exp_len -= 4
+
+            self.assertEqual(len(filtered), exp_len)
+            for rs in filtered.index:
+                t = rs.time()
+                if inc_start:
+                    self.assertTrue(t >= stime)
+                else:
+                    self.assertTrue(t > stime)
+
+                if inc_end:
+                    self.assertTrue(t <= etime)
+                else:
+                    self.assertTrue(t < etime)
+
+        result = ts.between_time('00:00', '01:00')
+        expected = ts.between_time(stime, etime)
+        assert_frame_equal(result, expected)
+
+        # across midnight
+        rng = date_range('1/1/2000', '1/5/2000', freq='5min')
+        ts = DataFrame(np.random.randn(len(rng), 2), index=rng)
+        stime = time(22, 0)
+        etime = time(9, 0)
+
+        close_open = product([True, False], [True, False])
+        for inc_start, inc_end in close_open:
+            filtered = ts.between_time(stime, etime, inc_start, inc_end)
+            exp_len = (12 * 11 + 1) * 4 + 1
+            if not inc_start:
+                exp_len -= 4
+            if not inc_end:
+                exp_len -= 4
+
+            self.assertEqual(len(filtered), exp_len)
+            for rs in filtered.index:
+                t = rs.time()
+                if inc_start:
+                    self.assertTrue((t >= stime) or (t <= etime))
+                else:
+                    self.assertTrue((t > stime) or (t <= etime))
+
+                if inc_end:
+                    self.assertTrue((t <= etime) or (t >= stime))
+                else:
+                    self.assertTrue((t < etime) or (t >= stime))
+
     def test_operation_on_NaT(self):
         # Both NaT and Timestamp are in DataFrame.
         df = pd.DataFrame({'foo': [pd.NaT, pd.NaT,
@@ -457,6 +548,34 @@ def test_datetime_assignment_with_NaT_and_diff_time_units(self):
                                 'new': [1e9, None]}, dtype='datetime64[ns]')
         tm.assert_frame_equal(result, expected)
 
+    def test_frame_to_period(self):
+        K = 5
+        from pandas.tseries.period import period_range
+
+        dr = date_range('1/1/2000', '1/1/2001')
+        pr = period_range('1/1/2000', '1/1/2001')
+        df = DataFrame(randn(len(dr), K), index=dr)
+        df['mix'] = 'a'
+
+        pts = df.to_period()
+        exp = df.copy()
+        exp.index = pr
+        assert_frame_equal(pts, exp)
+
+        pts = df.to_period('M')
+        tm.assert_index_equal(pts.index, exp.index.asfreq('M'))
+
+        df = df.T
+        pts = df.to_period(axis=1)
+        exp = df.copy()
+        exp.columns = pr
+        assert_frame_equal(pts, exp)
+
+        pts = df.to_period('M', axis=1)
+        tm.assert_index_equal(pts.columns, exp.columns.asfreq('M'))
+
+        self.assertRaises(ValueError, df.to_period, axis=2)
+
 
 if __name__ == '__main__':
     import nose

pandas/tests/groupby/test_groupby.py

@@ -4167,6 +4167,14 @@ def test_groupby_groups_datetimeindex_tz(self):
         result = df.groupby(level=0).sum()
         assert_frame_equal(result, expected)
 
+    def test_frame_datetime64_handling_groupby(self):
+        # it works!
+        df = DataFrame([(3, np.datetime64('2012-07-03')),
+                        (3, np.datetime64('2012-07-04'))],
+                       columns=['a', 'date'])
+        result = df.groupby('a').first()
+        self.assertEqual(result['date'][3], Timestamp('2012-07-03'))
+
     def test_groupby_multi_timezone(self):
 
         # combining multiple / different timezones yields UTC