splitting test_timeseries.py further

Author: TrigonaMinima

pandas/tests/indexes/datetimes/test_construction.py

@@ -476,3 +476,17 @@ def test_dti_constructor_numpy_timeunits(self):
 
             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,113 @@
+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_misc.py

@@ -1,10 +1,12 @@
 import numpy as np
 
+import pandas as pd
 import pandas.lib as lib
 import pandas.util.testing as tm
-from pandas import Float64Index, date_range, Timestamp
 from pandas import (Index, DatetimeIndex, datetime, offsets, to_datetime,
-                    Series, DataFrame)
+                    Series, DataFrame, Float64Index, date_range, Timestamp)
+
+from pandas.util.testing import assert_series_equal
 
 
 class TestDateTimeIndexToJulianDate(tm.TestCase):
@@ -130,40 +132,6 @@ def test_range_edges(self):
                              '1970-01-03', '1970-01-04'])
         tm.assert_index_equal(idx, exp)
 
-    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_datetimeindex_integers_shift(self):
         rng = date_range('1/1/2000', periods=20)
 
@@ -185,6 +153,110 @@ def test_datetimeindex_repr_short(self):
         dr = date_range(start='1/1/2012', periods=3)
         repr(dr)
 
+    def test_getitem_setitem_datetimeindex(self):
+        N = 50
+        # testing with timezone, GH #2785
+        rng = date_range('1/1/1990', periods=N, freq='H', tz='US/Eastern')
+        ts = Series(np.random.randn(N), index=rng)
+
+        result = ts["1990-01-01 04:00:00"]
+        expected = ts[4]
+        self.assertEqual(result, expected)
+
+        result = ts.copy()
+        result["1990-01-01 04:00:00"] = 0
+        result["1990-01-01 04:00:00"] = ts[4]
+        assert_series_equal(result, ts)
+
+        result = ts["1990-01-01 04:00:00":"1990-01-01 07:00:00"]
+        expected = ts[4:8]
+        assert_series_equal(result, expected)
+
+        result = ts.copy()
+        result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = 0
+        result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = ts[4:8]
+        assert_series_equal(result, ts)
+
+        lb = "1990-01-01 04:00:00"
+        rb = "1990-01-01 07:00:00"
+        result = ts[(ts.index >= lb) & (ts.index <= rb)]
+        expected = ts[4:8]
+        assert_series_equal(result, expected)
+
+        # repeat all the above with naive datetimes
+        result = ts[datetime(1990, 1, 1, 4)]
+        expected = ts[4]
+        self.assertEqual(result, expected)
+
+        result = ts.copy()
+        result[datetime(1990, 1, 1, 4)] = 0
+        result[datetime(1990, 1, 1, 4)] = ts[4]
+        assert_series_equal(result, ts)
+
+        result = ts[datetime(1990, 1, 1, 4):datetime(1990, 1, 1, 7)]
+        expected = ts[4:8]
+        assert_series_equal(result, expected)
+
+        result = ts.copy()
+        result[datetime(1990, 1, 1, 4):datetime(1990, 1, 1, 7)] = 0
+        result[datetime(1990, 1, 1, 4):datetime(1990, 1, 1, 7)] = ts[4:8]
+        assert_series_equal(result, ts)
+
+        lb = datetime(1990, 1, 1, 4)
+        rb = datetime(1990, 1, 1, 7)
+        result = ts[(ts.index >= lb) & (ts.index <= rb)]
+        expected = ts[4:8]
+        assert_series_equal(result, expected)
+
+        result = ts[ts.index[4]]
+        expected = ts[4]
+        self.assertEqual(result, expected)
+
+        result = ts[ts.index[4:8]]
+        expected = ts[4:8]
+        assert_series_equal(result, expected)
+
+        result = ts.copy()
+        result[ts.index[4:8]] = 0
+        result[4:8] = ts[4:8]
+        assert_series_equal(result, ts)
+
+        # also test partial date slicing
+        result = ts["1990-01-02"]
+        expected = ts[24:48]
+        assert_series_equal(result, expected)
+
+        result = ts.copy()
+        result["1990-01-02"] = 0
+        result["1990-01-02"] = ts[24:48]
+        assert_series_equal(result, ts)
+
+    def test_normalize(self):
+        rng = date_range('1/1/2000 9:30', periods=10, freq='D')
+
+        result = rng.normalize()
+        expected = date_range('1/1/2000', periods=10, freq='D')
+        tm.assert_index_equal(result, expected)
+
+        rng_ns = pd.DatetimeIndex(np.array([1380585623454345752,
+                                            1380585612343234312]).astype(
+                                                "datetime64[ns]"))
+        rng_ns_normalized = rng_ns.normalize()
+        expected = pd.DatetimeIndex(np.array([1380585600000000000,
+                                              1380585600000000000]).astype(
+                                                  "datetime64[ns]"))
+        tm.assert_index_equal(rng_ns_normalized, expected)
+
+        self.assertTrue(result.is_normalized)
+        self.assertFalse(rng.is_normalized)
+
+    def test_series_ctor_plus_datetimeindex(self):
+        rng = date_range('20090415', '20090519', freq='B')
+        data = dict((k, 1) for k in rng)
+
+        result = Series(data, index=rng)
+        self.assertIs(result.index, rng)
+
 
 class TestDatetime64(tm.TestCase):
 

pandas/tests/scalar/test_timestamp.py

@@ -12,7 +12,7 @@
 import pandas._period as period
 from pandas.tseries import offsets, frequencies
 from pandas.tslib import get_timezone, iNaT
-from pandas.compat import long
+from pandas.compat import lrange, long
 from pandas.util.testing import assert_series_equal
 from pandas.compat.numpy import np_datetime64_compat
 from pandas import (Timestamp, date_range, Period, Timedelta, tslib, compat,
@@ -1488,3 +1488,91 @@ def test_timestamp_equality(self):
         assert_series_equal(result, Series([True, False]))
         result = s == s[1]
         assert_series_equal(result, Series([False, False]))
+
+    def test_series_box_timestamp(self):
+        rng = date_range('20090415', '20090519', freq='B')
+        s = Series(rng)
+
+        tm.assertIsInstance(s[5], Timestamp)
+
+        rng = date_range('20090415', '20090519', freq='B')
+        s = Series(rng, index=rng)
+        tm.assertIsInstance(s[5], Timestamp)
+
+        tm.assertIsInstance(s.iat[5], Timestamp)
+
+    def test_frame_setitem_timestamp(self):
+        # 2155
+        columns = DatetimeIndex(start='1/1/2012', end='2/1/2012',
+                                freq=offsets.BDay())
+        index = lrange(10)
+        data = DataFrame(columns=columns, index=index)
+        t = datetime(2012, 11, 1)
+        ts = Timestamp(t)
+        data[ts] = np.nan  # works
+
+    def test_to_html_timestamp(self):
+        rng = date_range('2000-01-01', periods=10)
+        df = DataFrame(np.random.randn(10, 4), index=rng)
+
+        result = df.to_html()
+        self.assertIn('2000-01-01', result)
+
+    def test_series_map_box_timestamps(self):
+        # #2689, #2627
+        s = Series(date_range('1/1/2000', periods=10))
+
+        def f(x):
+            return (x.hour, x.day, x.month)
+
+        # it works!
+        s.map(f)
+        s.apply(f)
+        DataFrame(s).applymap(f)
+
+    def test_dti_slicing(self):
+        dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M')
+        dti2 = dti[[1, 3, 5]]
+
+        v1 = dti2[0]
+        v2 = dti2[1]
+        v3 = dti2[2]
+
+        self.assertEqual(v1, Timestamp('2/28/2005'))
+        self.assertEqual(v2, Timestamp('4/30/2005'))
+        self.assertEqual(v3, Timestamp('6/30/2005'))
+
+        # don't carry freq through irregular slicing
+        self.assertIsNone(dti2.freq)
+
+    def test_woy_boundary(self):
+        # make sure weeks at year boundaries are correct
+        d = datetime(2013, 12, 31)
+        result = Timestamp(d).week
+        expected = 1  # ISO standard
+        self.assertEqual(result, expected)
+
+        d = datetime(2008, 12, 28)
+        result = Timestamp(d).week
+        expected = 52  # ISO standard
+        self.assertEqual(result, expected)
+
+        d = datetime(2009, 12, 31)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        self.assertEqual(result, expected)
+
+        d = datetime(2010, 1, 1)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        self.assertEqual(result, expected)
+
+        d = datetime(2010, 1, 3)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        self.assertEqual(result, expected)
+
+        result = np.array([Timestamp(datetime(*args)).week
+                           for args in [(2000, 1, 1), (2000, 1, 2), (
+                               2005, 1, 1), (2005, 1, 2)]])
+        self.assertTrue((result == [52, 52, 53, 53]).all())