def test_to_period_tz_explicit_pytz(self): tm._skip_if_no_pytz() import pytz from dateutil.tz import tzlocal xp = date_range('1/1/2000', '4/1/2000').to_period() ts = date_range('1/1/2000', '4/1/2000', tz=pytz.timezone('US/Eastern')) result = ts.to_period()[0] expected = ts[0].to_period() self.assertTrue(result == expected) tm.assert_index_equal(ts.to_period(), xp) ts = date_range('1/1/2000', '4/1/2000', tz=pytz.utc) result = ts.to_period()[0] expected = ts[0].to_period() self.assertTrue(result == expected) tm.assert_index_equal(ts.to_period(), xp) ts = date_range('1/1/2000', '4/1/2000', tz=tzlocal()) result = ts.to_period()[0] expected = ts[0].to_period() self.assertTrue(result == expected) tm.assert_index_equal(ts.to_period(), xp)
def test_timestamp_tz_arg(self): tm._skip_if_no_pytz() import pytz for case in ['Europe/Brussels', 'Asia/Tokyo', 'US/Pacific']: p = Period('1/1/2005', freq='M').to_timestamp(tz=case) exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case) exp_zone = pytz.timezone(case).normalize(p) assert p == exp assert p.tz == exp_zone.tzinfo assert p.tz == exp.tz p = Period('1/1/2005', freq='3H').to_timestamp(tz=case) exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case) exp_zone = pytz.timezone(case).normalize(p) assert p == exp assert p.tz == exp_zone.tzinfo assert p.tz == exp.tz p = Period('1/1/2005', freq='A').to_timestamp(freq='A', tz=case) exp = Timestamp('31/12/2005', tz='UTC').tz_convert(case) exp_zone = pytz.timezone(case).normalize(p) assert p == exp assert p.tz == exp_zone.tzinfo assert p.tz == exp.tz p = Period('1/1/2005', freq='A').to_timestamp(freq='3H', tz=case) exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case) exp_zone = pytz.timezone(case).normalize(p) assert p == exp assert p.tz == exp_zone.tzinfo assert p.tz == exp.tz
def test_take_dont_lose_meta(self): tm._skip_if_no_pytz() rng = date_range("1/1/2000", periods=20, tz=self.tzstr("US/Eastern")) result = rng.take(lrange(5)) self.assertEqual(result.tz, rng.tz) self.assertEqual(result.freq, rng.freq)
def test_range_tz_dst_straddle_pytz(self): tm._skip_if_no_pytz() from pytz import timezone tz = timezone('US/Eastern') dates = [(tz.localize(datetime(2014, 3, 6)), tz.localize(datetime(2014, 3, 12))), (tz.localize(datetime(2013, 11, 1)), tz.localize(datetime(2013, 11, 6)))] for (start, end) in dates: dr = date_range(start, end, freq='D') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True) dr = date_range(start, end, freq='D', tz='US/Eastern') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True) dr = date_range(start.replace(tzinfo=None), end.replace(tzinfo=None), freq='D', tz='US/Eastern') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True)
def test_repr(self): tm._skip_if_no_pytz() tm._skip_if_no_dateutil() dates = ['2014-03-07', '2014-01-01 09:00', '2014-01-01 00:00:00.000000001'] # dateutil zone change (only matters for repr) import dateutil if dateutil.__version__ >= LooseVersion('2.3'): timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern', 'dateutil/US/Pacific'] else: timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern', 'dateutil/America/Los_Angeles'] freqs = ['D', 'M', 'S', 'N'] for date in dates: for tz in timezones: for freq in freqs: # avoid to match with timezone name freq_repr = "'{0}'".format(freq) if tz.startswith('dateutil'): tz_repr = tz.replace('dateutil', '') else: tz_repr = tz date_only = Timestamp(date) self.assertIn(date, repr(date_only)) self.assertNotIn(tz_repr, repr(date_only)) self.assertNotIn(freq_repr, repr(date_only)) self.assertEqual(date_only, eval(repr(date_only))) date_tz = Timestamp(date, tz=tz) self.assertIn(date, repr(date_tz)) self.assertIn(tz_repr, repr(date_tz)) self.assertNotIn(freq_repr, repr(date_tz)) self.assertEqual(date_tz, eval(repr(date_tz))) date_freq = Timestamp(date, offset=freq) self.assertIn(date, repr(date_freq)) self.assertNotIn(tz_repr, repr(date_freq)) self.assertIn(freq_repr, repr(date_freq)) self.assertEqual(date_freq, eval(repr(date_freq))) date_tz_freq = Timestamp(date, tz=tz, offset=freq) self.assertIn(date, repr(date_tz_freq)) self.assertIn(tz_repr, repr(date_tz_freq)) self.assertIn(freq_repr, repr(date_tz_freq)) self.assertEqual(date_tz_freq, eval(repr(date_tz_freq))) # this can cause the tz field to be populated, but it's redundant to information in the datestring tm._skip_if_no_pytz() import pytz date_with_utc_offset = Timestamp('2014-03-13 00:00:00-0400', tz=None) self.assertIn('2014-03-13 00:00:00-0400', repr(date_with_utc_offset)) self.assertNotIn('tzoffset', repr(date_with_utc_offset)) self.assertIn('pytz.FixedOffset(-240)', repr(date_with_utc_offset)) expr = repr(date_with_utc_offset).replace("'pytz.FixedOffset(-240)'", 'pytz.FixedOffset(-240)') self.assertEqual(date_with_utc_offset, eval(expr))
def test_take_dont_lose_meta(self): tm._skip_if_no_pytz() rng = date_range('1/1/2000', periods=20, tz=self.tzstr('US/Eastern')) result = rng.take(lrange(5)) self.assertEqual(result.tz, rng.tz) self.assertEqual(result.freq, rng.freq)
def test_constructor(self): base_str = '2014-07-01 09:00' base_dt = datetime.datetime(2014, 7, 1, 9) base_expected = 1404205200000000000 # confirm base representation is correct import calendar self.assertEqual( calendar.timegm(base_dt.timetuple()) * 1000000000, base_expected) tests = [ (base_str, base_dt, base_expected), ('2014-07-01 10:00', datetime.datetime(2014, 7, 1, 10), base_expected + 3600 * 1000000000), ('2014-07-01 09:00:00.000008000', datetime.datetime(2014, 7, 1, 9, 0, 0, 8), base_expected + 8000), ('2014-07-01 09:00:00.000000005', Timestamp('2014-07-01 09:00:00.000000005'), base_expected + 5) ] tm._skip_if_no_pytz() tm._skip_if_no_dateutil() import pytz import dateutil timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9), ('US/Eastern', -4), ('dateutil/US/Pacific', -7), (pytz.FixedOffset(-180), -3), (dateutil.tz.tzoffset(None, 18000), 5)] for date_str, date, expected in tests: for result in [Timestamp(date_str), Timestamp(date)]: # only with timestring self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # re-creation shouldn't affect to internal value result = Timestamp(result) self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # with timezone for tz, offset in timezones: for result in [ Timestamp(date_str, tz=tz), Timestamp(date, tz=tz) ]: expected_tz = expected - offset * 3600 * 1000000000 self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should preserve tz result = Timestamp(result) self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should convert to UTC result = Timestamp(result, tz='UTC') expected_utc = expected - offset * 3600 * 1000000000 self.assertEqual(result.value, expected_utc) self.assertEqual(tslib.pydt_to_i8(result), expected_utc)
def test_to_period_tz_pytz(self): tm._skip_if_no_pytz() from dateutil.tz import tzlocal from pytz import utc as UTC xp = date_range('1/1/2000', '4/1/2000').to_period() ts = date_range('1/1/2000', '4/1/2000', tz='US/Eastern') result = ts.to_period()[0] expected = ts[0].to_period() self.assertEqual(result, expected) tm.assert_index_equal(ts.to_period(), xp) ts = date_range('1/1/2000', '4/1/2000', tz=UTC) result = ts.to_period()[0] expected = ts[0].to_period() self.assertEqual(result, expected) tm.assert_index_equal(ts.to_period(), xp) ts = date_range('1/1/2000', '4/1/2000', tz=tzlocal()) result = ts.to_period()[0] expected = ts[0].to_period() self.assertEqual(result, expected) tm.assert_index_equal(ts.to_period(), xp)
def test_getitem_setitem_datetime_tz_pytz(self): tm._skip_if_no_pytz() from pytz import timezone as tz from pandas import date_range 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) # also test Timestamp tz handling, GH #2789 result = ts.copy() result["1990-01-01 09:00:00+00:00"] = 0 result["1990-01-01 09:00:00+00:00"] = ts[4] assert_series_equal(result, ts) result = ts.copy() result["1990-01-01 03:00:00-06:00"] = 0 result["1990-01-01 03:00:00-06:00"] = ts[4] assert_series_equal(result, ts) # repeat with datetimes result = ts.copy() result[datetime(1990, 1, 1, 9, tzinfo=tz('UTC'))] = 0 result[datetime(1990, 1, 1, 9, tzinfo=tz('UTC'))] = ts[4] assert_series_equal(result, ts) result = ts.copy() # comparison dates with datetime MUST be localized! date = tz('US/Central').localize(datetime(1990, 1, 1, 3)) result[date] = 0 result[date] = ts[4] assert_series_equal(result, ts)
def test_range_tz_dst_straddle_pytz(self): tm._skip_if_no_pytz() from pytz import timezone tz = timezone('US/Eastern') dates = [(tz.localize(datetime(2014, 3, 6)), tz.localize(datetime(2014, 3, 12))), (tz.localize(datetime(2013, 11, 1)), tz.localize(datetime(2013, 11, 6)))] for (start, end) in dates: dr = date_range(start, end, freq='D') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True) dr = date_range(start, end, freq='D', tz='US/Eastern') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True) dr = date_range(start.replace(tzinfo=None), end.replace( tzinfo=None), freq='D', tz='US/Eastern') self.assertEqual(dr[0], start) self.assertEqual(dr[-1], end) self.assertEqual(np.all(dr.hour == 0), True)
def test_append_concat_tz_explicit_pytz(self): # GH 2938 tm._skip_if_no_pytz() from pytz import timezone as timezone rng = date_range('5/8/2012 1:45', periods=10, freq='5T', tz=timezone('US/Eastern')) rng2 = date_range('5/8/2012 2:35', periods=10, freq='5T', tz=timezone('US/Eastern')) rng3 = date_range('5/8/2012 1:45', periods=20, freq='5T', tz=timezone('US/Eastern')) ts = Series(np.random.randn(len(rng)), rng) df = DataFrame(np.random.randn(len(rng), 4), index=rng) ts2 = Series(np.random.randn(len(rng2)), rng2) df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2) result = ts.append(ts2) result_df = df.append(df2) tm.assert_index_equal(result.index, rng3) tm.assert_index_equal(result_df.index, rng3) appended = rng.append(rng2) tm.assert_index_equal(appended, rng3)
def test_constructor(self): base_str = '2014-07-01 09:00' base_dt = datetime.datetime(2014, 7, 1, 9) base_expected = 1404205200000000000 # confirm base representation is correct import calendar self.assertEqual(calendar.timegm(base_dt.timetuple()) * 1000000000, base_expected) tests = [(base_str, base_dt, base_expected), ('2014-07-01 10:00', datetime.datetime(2014, 7, 1, 10), base_expected + 3600 * 1000000000), ('2014-07-01 09:00:00.000008000', datetime.datetime(2014, 7, 1, 9, 0, 0, 8), base_expected + 8000), ('2014-07-01 09:00:00.000000005', Timestamp('2014-07-01 09:00:00.000000005'), base_expected + 5)] tm._skip_if_no_pytz() tm._skip_if_no_dateutil() import pytz import dateutil timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9), ('US/Eastern', -4), ('dateutil/US/Pacific', -7), (pytz.FixedOffset(-180), -3), (dateutil.tz.tzoffset(None, 18000), 5)] for date_str, date, expected in tests: for result in [Timestamp(date_str), Timestamp(date)]: # only with timestring self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # re-creation shouldn't affect to internal value result = Timestamp(result) self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # with timezone for tz, offset in timezones: for result in [Timestamp(date_str, tz=tz), Timestamp(date, tz=tz)]: expected_tz = expected - offset * 3600 * 1000000000 self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should preserve tz result = Timestamp(result) self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should convert to UTC result = Timestamp(result, tz='UTC') expected_utc = expected - offset * 3600 * 1000000000 self.assertEqual(result.value, expected_utc) self.assertEqual(tslib.pydt_to_i8(result), expected_utc)
def test_repr(self): dates = [ '2014-03-07', '2014-01-01 09:00', '2014-01-01 00:00:00.000000001' ] timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern', 'dateutil/US/Pacific'] if _np_version_under1p7: freqs = ['D', 'M', 'S'] else: freqs = ['D', 'M', 'S', 'N'] for date in dates: for tz in timezones: for freq in freqs: # avoid to match with timezone name freq_repr = "'{0}'".format(freq) if tz.startswith('dateutil'): tz_repr = tz.replace('dateutil', '') else: tz_repr = tz date_only = Timestamp(date) self.assertIn(date, repr(date_only)) self.assertNotIn(tz_repr, repr(date_only)) self.assertNotIn(freq_repr, repr(date_only)) self.assertEqual(date_only, eval(repr(date_only))) date_tz = Timestamp(date, tz=tz) self.assertIn(date, repr(date_tz)) self.assertIn(tz_repr, repr(date_tz)) self.assertNotIn(freq_repr, repr(date_tz)) self.assertEqual(date_tz, eval(repr(date_tz))) date_freq = Timestamp(date, offset=freq) self.assertIn(date, repr(date_freq)) self.assertNotIn(tz_repr, repr(date_freq)) self.assertIn(freq_repr, repr(date_freq)) self.assertEqual(date_freq, eval(repr(date_freq))) date_tz_freq = Timestamp(date, tz=tz, offset=freq) self.assertIn(date, repr(date_tz_freq)) self.assertIn(tz_repr, repr(date_tz_freq)) self.assertIn(freq_repr, repr(date_tz_freq)) self.assertEqual(date_tz_freq, eval(repr(date_tz_freq))) # this can cause the tz field to be populated, but it's redundant to information in the datestring tm._skip_if_no_pytz() import pytz date_with_utc_offset = Timestamp('2014-03-13 00:00:00-0400', tz=None) self.assertIn('2014-03-13 00:00:00-0400', repr(date_with_utc_offset)) self.assertNotIn('tzoffset', repr(date_with_utc_offset)) self.assertIn('pytz.FixedOffset(-240)', repr(date_with_utc_offset)) expr = repr(date_with_utc_offset).replace("'pytz.FixedOffset(-240)'", 'pytz.FixedOffset(-240)') self.assertEqual(date_with_utc_offset, eval(expr))
def test_timezone_info(self): # GH 11682 # Timezone info lost when broadcasting scalar datetime to DataFrame tm._skip_if_no_pytz() import pytz df = pd.DataFrame({'a': [1], 'b': [datetime.now(pytz.utc)]}) self.assertEqual(df['b'][0].tzinfo, pytz.utc) df = pd.DataFrame({'a': [1, 2, 3]}) df['b'] = datetime.now(pytz.utc) self.assertEqual(df['b'][0].tzinfo, pytz.utc)
def test_timezone_info(self): # GH 11682 # Timezone info lost when broadcasting scalar datetime to DataFrame tm._skip_if_no_pytz() import pytz df = pd.DataFrame({'a': [1], 'b': [datetime.now(pytz.utc)]}) assert df['b'][0].tzinfo == pytz.utc df = pd.DataFrame({'a': [1, 2, 3]}) df['b'] = datetime.now(pytz.utc) assert df['b'][0].tzinfo == pytz.utc
def test_constructor_datetime64_tzformat(self): # GH 6572 tm._skip_if_no_pytz() import pytz # ISO 8601 format results in pytz.FixedOffset for freq in ['AS', 'W-SUN']: idx = date_range('2013-01-01T00:00:00-05:00', '2016-01-01T23:59:59-05:00', freq=freq) expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz=pytz.FixedOffset(-300)) tm.assert_index_equal(idx, expected) # Unable to use `US/Eastern` because of DST expected_i8 = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz='America/Lima') tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8) idx = date_range('2013-01-01T00:00:00+09:00', '2016-01-01T23:59:59+09:00', freq=freq) expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz=pytz.FixedOffset(540)) tm.assert_index_equal(idx, expected) expected_i8 = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz='Asia/Tokyo') tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8) tm._skip_if_no_dateutil() # Non ISO 8601 format results in dateutil.tz.tzoffset for freq in ['AS', 'W-SUN']: idx = date_range('2013/1/1 0:00:00-5:00', '2016/1/1 23:59:59-5:00', freq=freq) expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz=pytz.FixedOffset(-300)) tm.assert_index_equal(idx, expected) # Unable to use `US/Eastern` because of DST expected_i8 = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz='America/Lima') tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8) idx = date_range('2013/1/1 0:00:00+9:00', '2016/1/1 23:59:59+09:00', freq=freq) expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz=pytz.FixedOffset(540)) tm.assert_index_equal(idx, expected) expected_i8 = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59', freq=freq, tz='Asia/Tokyo') tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
def test_repr(self): dates = ["2014-03-07", "2014-01-01 09:00", "2014-01-01 00:00:00.000000001"] timezones = ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/US/Pacific"] freqs = ["D", "M", "S", "N"] for date in dates: for tz in timezones: for freq in freqs: # avoid to match with timezone name freq_repr = "'{0}'".format(freq) if tz.startswith("dateutil"): tz_repr = tz.replace("dateutil", "") else: tz_repr = tz date_only = Timestamp(date) self.assertIn(date, repr(date_only)) self.assertNotIn(tz_repr, repr(date_only)) self.assertNotIn(freq_repr, repr(date_only)) self.assertEqual(date_only, eval(repr(date_only))) date_tz = Timestamp(date, tz=tz) self.assertIn(date, repr(date_tz)) self.assertIn(tz_repr, repr(date_tz)) self.assertNotIn(freq_repr, repr(date_tz)) self.assertEqual(date_tz, eval(repr(date_tz))) date_freq = Timestamp(date, offset=freq) self.assertIn(date, repr(date_freq)) self.assertNotIn(tz_repr, repr(date_freq)) self.assertIn(freq_repr, repr(date_freq)) self.assertEqual(date_freq, eval(repr(date_freq))) date_tz_freq = Timestamp(date, tz=tz, offset=freq) self.assertIn(date, repr(date_tz_freq)) self.assertIn(tz_repr, repr(date_tz_freq)) self.assertIn(freq_repr, repr(date_tz_freq)) self.assertEqual(date_tz_freq, eval(repr(date_tz_freq))) # this can cause the tz field to be populated, but it's redundant to information in the datestring tm._skip_if_no_pytz() import pytz date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400", tz=None) self.assertIn("2014-03-13 00:00:00-0400", repr(date_with_utc_offset)) self.assertNotIn("tzoffset", repr(date_with_utc_offset)) self.assertIn("pytz.FixedOffset(-240)", repr(date_with_utc_offset)) expr = repr(date_with_utc_offset).replace("'pytz.FixedOffset(-240)'", "pytz.FixedOffset(-240)") self.assertEqual(date_with_utc_offset, eval(expr))
def test_month_range_union_tz_pytz(self): tm._skip_if_no_pytz() from pytz import timezone tz = timezone('US/Eastern') early_start = datetime(2011, 1, 1) early_end = datetime(2011, 3, 1) late_start = datetime(2011, 3, 1) late_end = datetime(2011, 5, 1) early_dr = date_range(start=early_start, end=early_end, tz=tz, freq=datetools.monthEnd) late_dr = date_range(start=late_start, end=late_end, tz=tz, freq=datetools.monthEnd) early_dr.union(late_dr)
def test_to_datetime_tz_pytz(self): # xref 8260 tm._skip_if_no_pytz() import pytz us_eastern = pytz.timezone('US/Eastern') arr = np.array([us_eastern.localize(datetime(year=2000, month=1, day=1, hour=3, minute=0)), us_eastern.localize(datetime(year=2000, month=6, day=1, hour=3, minute=0))], dtype=object) result = pd.to_datetime(arr, utc=True) expected = DatetimeIndex(['2000-01-01 08:00:00+00:00', '2000-06-01 07:00:00+00:00'], dtype='datetime64[ns, UTC]', freq=None) tm.assert_index_equal(result, expected)
def test_index_convert_to_datetime_array(self): tm._skip_if_no_pytz() def _check_rng(rng): converted = rng.to_pydatetime() assert isinstance(converted, np.ndarray) for x, stamp in zip(converted, rng): assert isinstance(x, datetime) self.assertEqual(x, stamp.to_pydatetime()) self.assertEqual(x.tzinfo, stamp.tzinfo) rng = date_range('20090415', '20090519') rng_eastern = date_range('20090415', '20090519', tz='US/Eastern') rng_utc = date_range('20090415', '20090519', tz='utc') _check_rng(rng) _check_rng(rng_eastern) _check_rng(rng_utc)
def test_index_convert_to_datetime_array_explicit_pytz(self): tm._skip_if_no_pytz() import pytz def _check_rng(rng): converted = rng.to_pydatetime() tm.assertIsInstance(converted, np.ndarray) for x, stamp in zip(converted, rng): tm.assertIsInstance(x, datetime) self.assertEqual(x, stamp.to_pydatetime()) self.assertEqual(x.tzinfo, stamp.tzinfo) rng = date_range('20090415', '20090519') rng_eastern = date_range('20090415', '20090519', tz=pytz.timezone('US/Eastern')) rng_utc = date_range('20090415', '20090519', tz=pytz.utc) _check_rng(rng) _check_rng(rng_eastern) _check_rng(rng_utc)
def test_range_tz_pytz(self): # GH 2906 tm._skip_if_no_pytz() from pytz import timezone as tz start = datetime(2011, 1, 1, tzinfo=tz('US/Eastern')) end = datetime(2011, 1, 3, tzinfo=tz('US/Eastern')) dr = date_range(start=start, periods=3) self.assertEqual(dr.tz, tz('US/Eastern')) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end) dr = date_range(end=end, periods=3) self.assertEqual(dr.tz, tz('US/Eastern')) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end) dr = date_range(start=start, end=end) self.assertEqual(dr.tz, tz('US/Eastern')) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end)
def test_append_concat_tz(self): # GH 2938 tm._skip_if_no_pytz() rng = date_range('5/8/2012 1:45', periods=10, freq='5T', tz='US/Eastern') rng2 = date_range('5/8/2012 2:35', periods=10, freq='5T', tz='US/Eastern') rng3 = date_range('5/8/2012 1:45', periods=20, freq='5T', tz='US/Eastern') ts = Series(np.random.randn(len(rng)), rng) df = DataFrame(np.random.randn(len(rng), 4), index=rng) ts2 = Series(np.random.randn(len(rng2)), rng2) df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2) result = ts.append(ts2) result_df = df.append(df2) tm.assert_index_equal(result.index, rng3) tm.assert_index_equal(result_df.index, rng3) appended = rng.append(rng2) tm.assert_index_equal(appended, rng3)
def test_range_tz_pytz(self): # GH 2906 tm._skip_if_no_pytz() from pytz import timezone tz = timezone('US/Eastern') start = tz.localize(datetime(2011, 1, 1)) end = tz.localize(datetime(2011, 1, 3)) dr = date_range(start=start, periods=3) self.assertEqual(dr.tz.zone, tz.zone) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end) dr = date_range(end=end, periods=3) self.assertEqual(dr.tz.zone, tz.zone) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end) dr = date_range(start=start, end=end) self.assertEqual(dr.tz.zone, tz.zone) self.assertEqual(dr[0], start) self.assertEqual(dr[2], end)
def test_range_tz_pytz(self): # GH 2906 tm._skip_if_no_pytz() from pytz import timezone tz = timezone('US/Eastern') start = tz.localize(datetime(2011, 1, 1)) end = tz.localize(datetime(2011, 1, 3)) dr = date_range(start=start, periods=3) assert dr.tz.zone == tz.zone assert dr[0] == start assert dr[2] == end dr = date_range(end=end, periods=3) assert dr.tz.zone == tz.zone assert dr[0] == start assert dr[2] == end dr = date_range(start=start, end=end) assert dr.tz.zone == tz.zone assert dr[0] == start assert dr[2] == end
def setUp(self): tm._skip_if_no_pytz()
def test_summary_pytz(self): tm._skip_if_no_pytz() import pytz cdate_range('1/1/2005', '1/1/2009', tz=pytz.utc).summary()
def test_constructor_with_stringoffset(self): # GH 7833 base_str = '2014-07-01 11:00:00+02:00' base_dt = datetime.datetime(2014, 7, 1, 9) base_expected = 1404205200000000000 # confirm base representation is correct import calendar self.assertEqual( calendar.timegm(base_dt.timetuple()) * 1000000000, base_expected) tests = [(base_str, base_expected), ('2014-07-01 12:00:00+02:00', base_expected + 3600 * 1000000000), ('2014-07-01 11:00:00.000008000+02:00', base_expected + 8000), ('2014-07-01 11:00:00.000000005+02:00', base_expected + 5)] tm._skip_if_no_pytz() tm._skip_if_no_dateutil() import pytz import dateutil timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9), ('US/Eastern', -4), ('dateutil/US/Pacific', -7), (pytz.FixedOffset(-180), -3), (dateutil.tz.tzoffset(None, 18000), 5)] for date_str, expected in tests: for result in [Timestamp(date_str)]: # only with timestring self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # re-creation shouldn't affect to internal value result = Timestamp(result) self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # with timezone for tz, offset in timezones: result = Timestamp(date_str, tz=tz) expected_tz = expected self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should preserve tz result = Timestamp(result) self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should convert to UTC result = Timestamp(result, tz='UTC') expected_utc = expected self.assertEqual(result.value, expected_utc) self.assertEqual(tslib.pydt_to_i8(result), expected_utc) # This should be 2013-11-01 05:00 in UTC # converted to Chicago tz result = Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago') self.assertEqual(result.value, Timestamp('2013-11-01 05:00').value) expected = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')" # noqa self.assertEqual(repr(result), expected) self.assertEqual(result, eval(repr(result))) # This should be 2013-11-01 05:00 in UTC # converted to Tokyo tz (+09:00) result = Timestamp('2013-11-01 00:00:00-0500', tz='Asia/Tokyo') self.assertEqual(result.value, Timestamp('2013-11-01 05:00').value) expected = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')" self.assertEqual(repr(result), expected) self.assertEqual(result, eval(repr(result))) # GH11708 # This should be 2015-11-18 10:00 in UTC # converted to Asia/Katmandu result = Timestamp("2015-11-18 15:45:00+05:45", tz="Asia/Katmandu") self.assertEqual(result.value, Timestamp("2015-11-18 10:00").value) expected = "Timestamp('2015-11-18 15:45:00+0545', tz='Asia/Katmandu')" self.assertEqual(repr(result), expected) self.assertEqual(result, eval(repr(result))) # This should be 2015-11-18 10:00 in UTC # converted to Asia/Kolkata result = Timestamp("2015-11-18 15:30:00+05:30", tz="Asia/Kolkata") self.assertEqual(result.value, Timestamp("2015-11-18 10:00").value) expected = "Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')" self.assertEqual(repr(result), expected) self.assertEqual(result, eval(repr(result)))
def test_insert(self): idx = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-02'], name='idx') result = idx.insert(2, datetime(2000, 1, 5)) exp = DatetimeIndex( ['2000-01-04', '2000-01-01', '2000-01-05', '2000-01-02'], name='idx') tm.assert_index_equal(result, exp) # insertion of non-datetime should coerce to object index result = idx.insert(1, 'inserted') expected = Index([ datetime(2000, 1, 4), 'inserted', datetime(2000, 1, 1), datetime(2000, 1, 2) ], name='idx') assert not isinstance(result, DatetimeIndex) tm.assert_index_equal(result, expected) assert result.name == expected.name idx = date_range('1/1/2000', periods=3, freq='M', name='idx') # preserve freq expected_0 = DatetimeIndex( ['1999-12-31', '2000-01-31', '2000-02-29', '2000-03-31'], name='idx', freq='M') expected_3 = DatetimeIndex( ['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-30'], name='idx', freq='M') # reset freq to None expected_1_nofreq = DatetimeIndex( ['2000-01-31', '2000-01-31', '2000-02-29', '2000-03-31'], name='idx', freq=None) expected_3_nofreq = DatetimeIndex( ['2000-01-31', '2000-02-29', '2000-03-31', '2000-01-02'], name='idx', freq=None) cases = [(0, datetime(1999, 12, 31), expected_0), (-3, datetime(1999, 12, 31), expected_0), (3, datetime(2000, 4, 30), expected_3), (1, datetime(2000, 1, 31), expected_1_nofreq), (3, datetime(2000, 1, 2), expected_3_nofreq)] for n, d, expected in cases: result = idx.insert(n, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq == expected.freq # reset freq to None result = idx.insert(3, datetime(2000, 1, 2)) expected = DatetimeIndex( ['2000-01-31', '2000-02-29', '2000-03-31', '2000-01-02'], name='idx', freq=None) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq is None # GH 7299 tm._skip_if_no_pytz() import pytz idx = date_range('1/1/2000', periods=3, freq='D', tz='Asia/Tokyo', name='idx') with pytest.raises(ValueError): idx.insert(3, pd.Timestamp('2000-01-04')) with pytest.raises(ValueError): idx.insert(3, datetime(2000, 1, 4)) with pytest.raises(ValueError): idx.insert(3, pd.Timestamp('2000-01-04', tz='US/Eastern')) with pytest.raises(ValueError): idx.insert( 3, datetime(2000, 1, 4, tzinfo=pytz.timezone('US/Eastern'))) for tz in ['US/Pacific', 'Asia/Singapore']: idx = date_range('1/1/2000 09:00', periods=6, freq='H', tz=tz, name='idx') # preserve freq expected = date_range('1/1/2000 09:00', periods=7, freq='H', tz=tz, name='idx') for d in [ pd.Timestamp('2000-01-01 15:00', tz=tz), pytz.timezone(tz).localize(datetime(2000, 1, 1, 15)) ]: result = idx.insert(6, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq == expected.freq assert result.tz == expected.tz expected = DatetimeIndex([ '2000-01-01 09:00', '2000-01-01 10:00', '2000-01-01 11:00', '2000-01-01 12:00', '2000-01-01 13:00', '2000-01-01 14:00', '2000-01-01 10:00' ], name='idx', tz=tz, freq=None) # reset freq to None for d in [ pd.Timestamp('2000-01-01 10:00', tz=tz), pytz.timezone(tz).localize(datetime(2000, 1, 1, 10)) ]: result = idx.insert(6, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.tz == expected.tz assert result.freq is None
def test_constructor_with_stringoffset(self): # GH 7833 base_str = '2014-07-01 11:00:00+02:00' base_dt = datetime.datetime(2014, 7, 1, 9) base_expected = 1404205200000000000 # confirm base representation is correct import calendar self.assertEqual(calendar.timegm(base_dt.timetuple()) * 1000000000, base_expected) tests = [(base_str, base_expected), ('2014-07-01 12:00:00+02:00', base_expected + 3600 * 1000000000), ('2014-07-01 11:00:00.000008000+02:00', base_expected + 8000), ('2014-07-01 11:00:00.000000005+02:00', base_expected + 5)] tm._skip_if_no_pytz() tm._skip_if_no_dateutil() import pytz import dateutil timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9), ('US/Eastern', -4), ('dateutil/US/Pacific', -7), (pytz.FixedOffset(-180), -3), (dateutil.tz.tzoffset(None, 18000), 5)] for date_str, expected in tests: for result in [Timestamp(date_str)]: # only with timestring self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # re-creation shouldn't affect to internal value result = Timestamp(result) self.assertEqual(result.value, expected) self.assertEqual(tslib.pydt_to_i8(result), expected) # with timezone for tz, offset in timezones: result = Timestamp(date_str, tz=tz) expected_tz = expected self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should preserve tz result = Timestamp(result) self.assertEqual(result.value, expected_tz) self.assertEqual(tslib.pydt_to_i8(result), expected_tz) # should convert to UTC result = Timestamp(result, tz='UTC') expected_utc = expected self.assertEqual(result.value, expected_utc) self.assertEqual(tslib.pydt_to_i8(result), expected_utc) # This should be 2013-11-01 05:00 in UTC -> converted to Chicago tz result = Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago') self.assertEqual(result.value, Timestamp('2013-11-01 05:00').value) expected_repr = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')" self.assertEqual(repr(result), expected_repr) self.assertEqual(result, eval(repr(result))) # This should be 2013-11-01 05:00 in UTC -> converted to Tokyo tz (+09:00) result = Timestamp('2013-11-01 00:00:00-0500', tz='Asia/Tokyo') self.assertEqual(result.value, Timestamp('2013-11-01 05:00').value) expected_repr = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')" self.assertEqual(repr(result), expected_repr) self.assertEqual(result, eval(repr(result)))
def test_insert(self): idx = DatetimeIndex( ['2000-01-04', '2000-01-01', '2000-01-02'], name='idx') result = idx.insert(2, datetime(2000, 1, 5)) exp = DatetimeIndex(['2000-01-04', '2000-01-01', '2000-01-05', '2000-01-02'], name='idx') tm.assert_index_equal(result, exp) # insertion of non-datetime should coerce to object index result = idx.insert(1, 'inserted') expected = Index([datetime(2000, 1, 4), 'inserted', datetime(2000, 1, 1), datetime(2000, 1, 2)], name='idx') assert not isinstance(result, DatetimeIndex) tm.assert_index_equal(result, expected) assert result.name == expected.name idx = date_range('1/1/2000', periods=3, freq='M', name='idx') # preserve freq expected_0 = DatetimeIndex(['1999-12-31', '2000-01-31', '2000-02-29', '2000-03-31'], name='idx', freq='M') expected_3 = DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-30'], name='idx', freq='M') # reset freq to None expected_1_nofreq = DatetimeIndex(['2000-01-31', '2000-01-31', '2000-02-29', '2000-03-31'], name='idx', freq=None) expected_3_nofreq = DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-01-02'], name='idx', freq=None) cases = [(0, datetime(1999, 12, 31), expected_0), (-3, datetime(1999, 12, 31), expected_0), (3, datetime(2000, 4, 30), expected_3), (1, datetime(2000, 1, 31), expected_1_nofreq), (3, datetime(2000, 1, 2), expected_3_nofreq)] for n, d, expected in cases: result = idx.insert(n, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq == expected.freq # reset freq to None result = idx.insert(3, datetime(2000, 1, 2)) expected = DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-01-02'], name='idx', freq=None) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq is None # GH 7299 tm._skip_if_no_pytz() import pytz idx = date_range('1/1/2000', periods=3, freq='D', tz='Asia/Tokyo', name='idx') with pytest.raises(ValueError): idx.insert(3, pd.Timestamp('2000-01-04')) with pytest.raises(ValueError): idx.insert(3, datetime(2000, 1, 4)) with pytest.raises(ValueError): idx.insert(3, pd.Timestamp('2000-01-04', tz='US/Eastern')) with pytest.raises(ValueError): idx.insert(3, datetime(2000, 1, 4, tzinfo=pytz.timezone('US/Eastern'))) for tz in ['US/Pacific', 'Asia/Singapore']: idx = date_range('1/1/2000 09:00', periods=6, freq='H', tz=tz, name='idx') # preserve freq expected = date_range('1/1/2000 09:00', periods=7, freq='H', tz=tz, name='idx') for d in [pd.Timestamp('2000-01-01 15:00', tz=tz), pytz.timezone(tz).localize(datetime(2000, 1, 1, 15))]: result = idx.insert(6, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.freq == expected.freq assert result.tz == expected.tz expected = DatetimeIndex(['2000-01-01 09:00', '2000-01-01 10:00', '2000-01-01 11:00', '2000-01-01 12:00', '2000-01-01 13:00', '2000-01-01 14:00', '2000-01-01 10:00'], name='idx', tz=tz, freq=None) # reset freq to None for d in [pd.Timestamp('2000-01-01 10:00', tz=tz), pytz.timezone(tz).localize(datetime(2000, 1, 1, 10))]: result = idx.insert(6, d) tm.assert_index_equal(result, expected) assert result.name == expected.name assert result.tz == expected.tz assert result.freq is None