try to fix failing tests

Author: reidy-p

pandas/_libs/tslibs/period.pyx

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # cython: profile=False
-import pandas as pd
 from datetime import datetime, date, timedelta
 
 from cpython cimport (
@@ -35,6 +34,7 @@ cdef extern from "../src/datetime/np_datetime.h":
 cimport util
 from util cimport is_period_object, is_string_object, INT32_MIN
 
+from pandas._libs.tslib import Timedelta
 from timestamps import Timestamp
 from timezones cimport is_utc, is_tzlocal, get_dst_info
 from timedeltas cimport delta_to_nanoseconds
@@ -1224,7 +1224,7 @@ cdef class _Period(object):
 
         end = how == 'E'
         if end:
-            return (self + 1).to_timestamp(how='start') - pd.Timedelta(1, 'ns')
+            return (self + 1).to_timestamp(how='start') - Timedelta(1, 'ns')
 
         if freq is None:
             base, mult = get_freq_code(self.freq)

pandas/core/indexes/datetimes.py

@@ -50,7 +50,7 @@
 import pandas.core.tools.datetimes as tools
 
 from pandas._libs import (lib, index as libindex, tslib as libts,
-                          join as libjoin, Timestamp)
+                          join as libjoin, Timestamp, Timedelta)
 from pandas._libs.tslibs import (timezones, conversion, fields, parsing,
                                  ccalendar)
 

pandas/core/indexes/period.py

@@ -2,7 +2,6 @@
 from datetime import datetime
 import numpy as np
 import warnings
-import pandas as pd
 
 from pandas.core import common as com
 from pandas.core.dtypes.common import (
@@ -504,7 +503,12 @@ def to_timestamp(self, freq=None, how='start'):
 
         end = how == 'E'
         if end:
-            return (self + 1).to_timestamp(how='start') - pd.Timedelta(1, 'ns')
+            if freq == 'B':
+                adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
+                return self.to_timestamp(how='start') + adjust
+            else:
+                adjust = Timedelta(1, 'ns')
+                return (self + 1).to_timestamp(how='start') - adjust
 
         if freq is None:
             base, mult = _gfc(self.freq)
@@ -515,7 +519,19 @@ def to_timestamp(self, freq=None, how='start'):
         base, mult = _gfc(freq)
         new_data = self.asfreq(freq, how)
 
-        new_data = period.periodarr_to_dt64arr(new_data._values, base)
+        end = how == 'E'
+        if end:
+            indexer = np.where(new_data.notnull())
+            # move forward one period
+            new_data._values[indexer] += 1
+            ndarray_vals = new_data._ndarray_values
+            new_data = period.periodarr_to_dt64arr(ndarray_vals, base)
+            # subtract one nanosecond
+            new_data[indexer] -= 1
+        else:
+            ndarray_vals = new_data._ndarray_values
+            new_data = period.periodarr_to_dt64arr(ndarray_vals, base)
+
         return DatetimeIndex(new_data, freq='infer', name=self.name)
 
     @property

pandas/tests/frame/test_period.py

@@ -5,7 +5,7 @@
 import pandas as pd
 import pandas.util.testing as tm
 from pandas import (PeriodIndex, period_range, DataFrame, date_range,
-                    Index, to_datetime, DatetimeIndex)
+                    Index, to_datetime, DatetimeIndex, Timedelta)
 
 
 def _permute(obj):
@@ -51,6 +51,7 @@ def test_frame_to_time_stamp(self):
         df['mix'] = 'a'
 
         exp_index = date_range('1/1/2001', end='12/31/2009', freq='A-DEC')
+        exp_index = exp_index + Timedelta(1, 'D') - Timedelta(1, 'ns')
         result = df.to_timestamp('D', 'end')
         tm.assert_index_equal(result.index, exp_index)
         tm.assert_numpy_array_equal(result.values, df.values)
@@ -66,22 +67,26 @@ def _get_with_delta(delta, freq='A-DEC'):
         delta = timedelta(hours=23)
         result = df.to_timestamp('H', 'end')
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 'h') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         delta = timedelta(hours=23, minutes=59)
         result = df.to_timestamp('T', 'end')
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 'm') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         result = df.to_timestamp('S', 'end')
         delta = timedelta(hours=23, minutes=59, seconds=59)
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 's') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         # columns
         df = df.T
 
         exp_index = date_range('1/1/2001', end='12/31/2009', freq='A-DEC')
+        exp_index = exp_index + Timedelta(1, 'D') - Timedelta(1, 'ns')
         result = df.to_timestamp('D', 'end', axis=1)
         tm.assert_index_equal(result.columns, exp_index)
         tm.assert_numpy_array_equal(result.values, df.values)
@@ -93,16 +98,19 @@ def _get_with_delta(delta, freq='A-DEC'):
         delta = timedelta(hours=23)
         result = df.to_timestamp('H', 'end', axis=1)
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 'h') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.columns, exp_index)
 
         delta = timedelta(hours=23, minutes=59)
         result = df.to_timestamp('T', 'end', axis=1)
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 'm') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.columns, exp_index)
 
         result = df.to_timestamp('S', 'end', axis=1)
         delta = timedelta(hours=23, minutes=59, seconds=59)
         exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, 's') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.columns, exp_index)
 
         # invalid axis

pandas/tests/indexes/period/test_period.py

@@ -366,6 +366,17 @@ def test_periods_number_check(self):
         with pytest.raises(ValueError):
             period_range('2011-1-1', '2012-1-1', 'B')
 
+    def test_start_time(self):
+        index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
+        expected_index = date_range('2016-01-01', end='2016-05-31', freq='MS')
+        tm.assert_index_equal(index.start_time, expected_index)
+
+    def test_end_time(self):
+        index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
+        expected_index = date_range('2016-01-01', end='2016-05-31', freq='M')
+        expected_index = expected_index.shift(1, freq='D').shift(-1, freq='ns')
+        tm.assert_index_equal(index.end_time, expected_index)
+
     def test_index_duplicate_periods(self):
         # monotonic
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq='A-JUN')

pandas/tests/indexes/period/test_scalar_compat.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Tests for PeriodIndex behaving like a vectorized Period scalar"""
 
-from pandas import PeriodIndex, date_range
+from pandas import PeriodIndex, date_range, Timedelta
 import pandas.util.testing as tm
 
 
@@ -14,4 +14,5 @@ def test_start_time(self):
     def test_end_time(self):
         index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
         expected_index = date_range('2016-01-01', end='2016-05-31', freq='M')
+        expected_index += Timedelta(1, 'D') - Timedelta(1, 'ns')
         tm.assert_index_equal(index.end_time, expected_index)

pandas/tests/indexes/period/test_tools.py

@@ -3,6 +3,7 @@
 import pytest
 
 import pandas as pd
+from pandas import Timedelta
 import pandas.util.testing as tm
 import pandas.core.indexes.period as period
 from pandas.compat import lrange
@@ -60,7 +61,7 @@ def test_to_timestamp(self):
 
         exp_index = date_range('1/1/2001', end='12/31/2009', freq='A-DEC')
         result = series.to_timestamp(how='end')
-        exp_index = exp_index + pd.Timedelta(1, 'D') - pd.Timedelta(1, 'ns')
+        exp_index = exp_index + Timedelta(1, 'D') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
         assert result.name == 'foo'
 
@@ -75,19 +76,19 @@ def _get_with_delta(delta, freq='A-DEC'):
         delta = timedelta(hours=23)
         result = series.to_timestamp('H', 'end')
         exp_index = _get_with_delta(delta)
-        exp_index = exp_index + pd.Timedelta(1, 'h') - pd.Timedelta(1, 'ns')
+        exp_index = exp_index + Timedelta(1, 'h') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         delta = timedelta(hours=23, minutes=59)
         result = series.to_timestamp('T', 'end')
         exp_index = _get_with_delta(delta)
-        exp_index = exp_index + pd.Timedelta(1, 'm') - pd.Timedelta(1, 'ns')
+        exp_index = exp_index + Timedelta(1, 'm') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         result = series.to_timestamp('S', 'end')
         delta = timedelta(hours=23, minutes=59, seconds=59)
         exp_index = _get_with_delta(delta)
-        exp_index = exp_index + pd.Timedelta(1, 's') - pd.Timedelta(1, 'ns')
+        exp_index = exp_index + Timedelta(1, 's') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
 
         index = PeriodIndex(freq='H', start='1/1/2001', end='1/2/2001')
@@ -96,7 +97,7 @@ def _get_with_delta(delta, freq='A-DEC'):
         exp_index = date_range('1/1/2001 00:59:59', end='1/2/2001 00:59:59',
                                freq='H')
         result = series.to_timestamp(how='end')
-        exp_index = exp_index + pd.Timedelta(1, 's') - pd.Timedelta(1, 'ns')
+        exp_index = exp_index + Timedelta(1, 's') - Timedelta(1, 'ns')
         tm.assert_index_equal(result.index, exp_index)
         assert result.name == 'foo'
 
@@ -289,6 +290,7 @@ def test_to_timestamp_pi_mult(self):
         result = idx.to_timestamp(how='E')
         expected = DatetimeIndex(['2011-02-28', 'NaT', '2011-03-31'],
                                  name='idx')
+        expected = expected + Timedelta(1, 'D') - Timedelta(1, 'ns')
         tm.assert_index_equal(result, expected)
 
     def test_to_timestamp_pi_combined(self):
@@ -303,11 +305,13 @@ def test_to_timestamp_pi_combined(self):
         expected = DatetimeIndex(['2011-01-02 00:59:59',
                                   '2011-01-03 01:59:59'],
                                  name='idx')
+        expected = expected + Timedelta(1, 's') - Timedelta(1, 'ns')
         tm.assert_index_equal(result, expected)
 
         result = idx.to_timestamp(how='E', freq='H')
         expected = DatetimeIndex(['2011-01-02 00:00', '2011-01-03 01:00'],
                                  name='idx')
+        expected = expected + Timedelta(1, 'h') - Timedelta(1, 'ns')
         tm.assert_index_equal(result, expected)
 
     def test_period_astype_to_timestamp(self):
@@ -317,6 +321,7 @@ def test_period_astype_to_timestamp(self):
         tm.assert_index_equal(pi.astype('datetime64[ns]'), exp)
 
         exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'])
+        exp = exp + Timedelta(1, 'D') - Timedelta(1, 'ns')
         tm.assert_index_equal(pi.astype('datetime64[ns]', how='end'), exp)
 
         exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
@@ -326,6 +331,7 @@ def test_period_astype_to_timestamp(self):
 
         exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'],
                                tz='US/Eastern')
+        exp = exp + Timedelta(1, 'D') - Timedelta(1, 'ns')
         res = pi.astype('datetime64[ns, US/Eastern]', how='end')
         tm.assert_index_equal(res, exp)
 

pandas/tests/scalar/period/test_period.py

@@ -5,6 +5,7 @@
 from datetime import datetime, date, timedelta
 
 import pandas as pd
+from pandas import Timedelta
 import pandas.util.testing as tm
 import pandas.core.indexes.period as period
 from pandas.compat import text_type, iteritems
@@ -274,12 +275,14 @@ def test_timestamp_tz_arg_dateutil_from_string(self):
 
     def test_timestamp_mult(self):
         p = pd.Period('2011-01', freq='M')
-        assert p.to_timestamp(how='S') == pd.Timestamp('2011-01-01')
-        assert p.to_timestamp(how='E') == pd.Timestamp('2011-01-31')
+        assert p.to_timestamp(how='S') == Timestamp('2011-01-01')
+        expected = Timestamp('2011-02-01') - Timedelta(1, 'ns')
+        assert p.to_timestamp(how='E') == expected
 
         p = pd.Period('2011-01', freq='3M')
-        assert p.to_timestamp(how='S') == pd.Timestamp('2011-01-01')
-        assert p.to_timestamp(how='E') == pd.Timestamp('2011-03-31')
+        assert p.to_timestamp(how='S') == Timestamp('2011-01-01')
+        expected = Timestamp('2011-04-01') - Timedelta(1, 'ns')
+        assert p.to_timestamp(how='E') == expected
 
     def test_construction(self):
         i1 = Period('1/1/2005', freq='M')
@@ -611,19 +614,19 @@ def _ex(p):
         p = Period('1985', freq='A')
 
         result = p.to_timestamp('H', how='end')
-        expected = datetime(1985, 12, 31, 23)
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, 'ns')
         assert result == expected
         result = p.to_timestamp('3H', how='end')
         assert result == expected
 
         result = p.to_timestamp('T', how='end')
-        expected = datetime(1985, 12, 31, 23, 59)
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, 'ns')
         assert result == expected
         result = p.to_timestamp('2T', how='end')
         assert result == expected
 
         result = p.to_timestamp(how='end')
-        expected = datetime(1985, 12, 31)
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, 'ns')
         assert result == expected
 
         expected = datetime(1985, 1, 1)

pandas/tests/series/test_period.py

@@ -6,6 +6,7 @@
 from pandas import Series, period_range, DataFrame, Period
 import pytest
 
+
 def _permute(obj):
     return obj.take(np.random.permutation(len(obj)))
 

pandas/tests/test_resample.py

@@ -21,7 +21,7 @@
 import pandas as pd
 
 from pandas import (Series, DataFrame, Panel, Index, isna,
-                    notna, Timestamp)
+                    notna, Timestamp, Timedelta)
 
 from pandas.compat import range, lrange, zip, OrderedDict
 from pandas.errors import UnsupportedFunctionCall
@@ -1702,12 +1702,14 @@ def test_resample_anchored_intraday(self):
         result = df.resample('M').mean()
         expected = df.resample(
             'M', kind='period').mean().to_timestamp(how='end')
+        expected.index += Timedelta(1, 'ns') - Timedelta(1, 'D')
         tm.assert_frame_equal(result, expected)
 
         result = df.resample('M', closed='left').mean()
         exp = df.tshift(1, freq='D').resample('M', kind='period').mean()
         exp = exp.to_timestamp(how='end')
 
+        exp.index = exp.index + Timedelta(1, 'ns') - Timedelta(1, 'D')
         tm.assert_frame_equal(result, exp)
 
         rng = date_range('1/1/2012', '4/1/2012', freq='100min')
@@ -1716,12 +1718,14 @@ def test_resample_anchored_intraday(self):
         result = df.resample('Q').mean()
         expected = df.resample(
             'Q', kind='period').mean().to_timestamp(how='end')
+        expected.index += Timedelta(1, 'ns') - Timedelta(1, 'D')
         tm.assert_frame_equal(result, expected)
 
         result = df.resample('Q', closed='left').mean()
         expected = df.tshift(1, freq='D').resample('Q', kind='period',
                                                    closed='left').mean()
         expected = expected.to_timestamp(how='end')
+        expected.index += Timedelta(1, 'ns') - Timedelta(1, 'D')
         tm.assert_frame_equal(result, expected)
 
         ts = _simple_ts('2012-04-29 23:00', '2012-04-30 5:00', freq='h')
@@ -2473,7 +2477,7 @@ def test_resample_to_timestamps(self):
         ts = _simple_pts('1/1/1990', '12/31/1995', freq='M')
 
         result = ts.resample('A-DEC', kind='timestamp').mean()
-        expected = ts.to_timestamp(how='end').resample('A-DEC').mean()
+        expected = ts.to_timestamp(how='start').resample('A-DEC').mean()
         assert_series_equal(result, expected)
 
     def test_resample_to_quarterly(self):

pandas/tseries/offsets.py

@@ -1321,7 +1321,7 @@ def _end_apply_index(self, dtindex):
             roll = self.n
 
         base = (base_period + roll).to_timestamp(how='end')
-        return base + off
+        return base + off + Timedelta(1, 'ns') - Timedelta(1, 'D')
 
     def onOffset(self, dt):
         if self.normalize and not _is_normalized(dt):