def test_to_period_tz_dateutil(self): tm._skip_if_no_dateutil() import dateutil 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='dateutil/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=dateutil.tz.tzutc()) 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_iteration_preserves_tz(self): tm._skip_if_no_dateutil() # GH 8890 import dateutil index = date_range("2012-01-01", periods=3, freq='H', tz='US/Eastern') for i, ts in enumerate(index): result = ts expected = index[i] self.assertEqual(result, expected) index = date_range("2012-01-01", periods=3, freq='H', tz=dateutil.tz.tzoffset(None, -28800)) for i, ts in enumerate(index): result = ts expected = index[i] self.assertEqual(result._repr_base, expected._repr_base) self.assertEqual(result, expected) # 9100 index = pd.DatetimeIndex(['2014-12-01 03:32:39.987000-08:00', '2014-12-01 04:12:34.987000-08:00']) for i, ts in enumerate(index): result = ts expected = index[i] self.assertEqual(result._repr_base, expected._repr_base) self.assertEqual(result, expected)
def test_append_concat_tz_dateutil(self): # GH 2938 tm._skip_if_no_dateutil() rng = date_range('5/8/2012 1:45', periods=10, freq='5T', tz='dateutil/US/Eastern') rng2 = date_range('5/8/2012 2:35', periods=10, freq='5T', tz='dateutil/US/Eastern') rng3 = date_range('5/8/2012 1:45', periods=20, freq='5T', tz='dateutil/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_getitem_setitem_datetime_tz_dateutil(self): tm._skip_if_no_dateutil() from dateutil.tz import tzutc from pandas.tslib import _dateutil_gettz as gettz tz = lambda x: tzutc() if x == 'UTC' else gettz( x) # handle special case for utc in dateutil 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() result[datetime(1990, 1, 1, 3, tzinfo=tz('US/Central'))] = 0 result[datetime(1990, 1, 1, 3, tzinfo=tz('US/Central'))] = ts[4] assert_series_equal(result, ts)
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_iteration_preserves_tz(self): tm._skip_if_no_dateutil() # GH 8890 import dateutil index = date_range("2012-01-01", periods=3, freq='H', tz='US/Eastern') for i, ts in enumerate(index): result = ts expected = index[i] assert result == expected index = date_range("2012-01-01", periods=3, freq='H', tz=dateutil.tz.tzoffset(None, -28800)) for i, ts in enumerate(index): result = ts expected = index[i] assert result._repr_base == expected._repr_base assert result == expected # 9100 index = pd.DatetimeIndex(['2014-12-01 03:32:39.987000-08:00', '2014-12-01 04:12:34.987000-08:00']) for i, ts in enumerate(index): result = ts expected = index[i] assert result._repr_base == expected._repr_base assert result == expected
def test_parsers_dayfirst_yearfirst(self): # str : dayfirst, yearfirst, expected cases = {'10-11-12': [(False, False, datetime.datetime(2012, 10, 11)), (True, False, datetime.datetime(2012, 11, 10)), (False, True, datetime.datetime(2010, 11, 12)), (True, True, datetime.datetime(2010, 11, 12))], '20/12/21': [(False, False, datetime.datetime(2021, 12, 20)), (True, False, datetime.datetime(2021, 12, 20)), (False, True, datetime.datetime(2020, 12, 21)), (True, True, datetime.datetime(2020, 12, 21))]} tm._skip_if_no_dateutil() from dateutil.parser import parse for date_str, values in compat.iteritems(cases): for dayfirst, yearfirst ,expected in values: result1, _, _ = tools.parse_time_string(date_str, dayfirst=dayfirst, yearfirst=yearfirst) result2 = to_datetime(date_str, dayfirst=dayfirst, yearfirst=yearfirst) result3 = DatetimeIndex([date_str], dayfirst=dayfirst, yearfirst=yearfirst)[0] # Timestamp doesn't support dayfirst and yearfirst self.assertEqual(result1, expected) self.assertEqual(result2, expected) self.assertEqual(result3, expected) # compare with dateutil result dateutil_result = parse(date_str, dayfirst=dayfirst, yearfirst=yearfirst) self.assertEqual(dateutil_result, expected)
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_concat_tz_series_tzlocal(self): # GH 13583 tm._skip_if_no_dateutil() import dateutil x = [pd.Timestamp('2011-01-01', tz=dateutil.tz.tzlocal()), pd.Timestamp('2011-02-01', tz=dateutil.tz.tzlocal())] y = [pd.Timestamp('2012-01-01', tz=dateutil.tz.tzlocal()), pd.Timestamp('2012-02-01', tz=dateutil.tz.tzlocal())] result = concat([pd.Series(x), pd.Series(y)], ignore_index=True) tm.assert_series_equal(result, pd.Series(x + y)) self.assertEqual(result.dtype, 'datetime64[ns, tzlocal()]')
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_month_range_union_tz_dateutil(self): tm._skip_if_windows_python_3() tm._skip_if_no_dateutil() from pandas.tslib import _dateutil_gettz as 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_month_range_union_tz_dateutil(self): _skip_if_windows_python_3() tm._skip_if_no_dateutil() from dateutil.tz import gettz as 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_month_range_union_tz_dateutil(self): tm._skip_if_windows_python_3() tm._skip_if_no_dateutil() from pandas._libs.tslib import _dateutil_gettz as 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=MonthEnd()) late_dr = date_range(start=late_start, end=late_end, tz=tz, freq=MonthEnd()) early_dr.union(late_dr)
def test_index_convert_to_datetime_array_dateutil(self): tm._skip_if_no_dateutil() import dateutil 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='dateutil/US/Eastern') rng_utc = date_range('20090415', '20090519', tz=dateutil.tz.tzutc()) _check_rng(rng) _check_rng(rng_eastern) _check_rng(rng_utc)
def test_index_convert_to_datetime_array_dateutil(self): tm._skip_if_no_dateutil() import dateutil 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='dateutil/US/Eastern') rng_utc = date_range('20090415', '20090519', tz=dateutil.tz.tzutc()) _check_rng(rng) _check_rng(rng_eastern) _check_rng(rng_utc)
def test_parsers_dayfirst_yearfirst(self): # str : dayfirst, yearfirst, expected cases = { '10-11-12': [(False, False, datetime.datetime(2012, 10, 11)), (True, False, datetime.datetime(2012, 11, 10)), (False, True, datetime.datetime(2010, 11, 12)), (True, True, datetime.datetime(2010, 11, 12))], '20/12/21': [(False, False, datetime.datetime(2021, 12, 20)), (True, False, datetime.datetime(2021, 12, 20)), (False, True, datetime.datetime(2020, 12, 21)), (True, True, datetime.datetime(2020, 12, 21))] } tm._skip_if_no_dateutil() from dateutil.parser import parse for date_str, values in compat.iteritems(cases): for dayfirst, yearfirst, expected in values: result1, _, _ = tools.parse_time_string(date_str, dayfirst=dayfirst, yearfirst=yearfirst) result2 = to_datetime(date_str, dayfirst=dayfirst, yearfirst=yearfirst) result3 = DatetimeIndex([date_str], dayfirst=dayfirst, yearfirst=yearfirst)[0] # Timestamp doesn't support dayfirst and yearfirst self.assertEqual(result1, expected) self.assertEqual(result2, expected) self.assertEqual(result3, expected) # compare with dateutil result dateutil_result = parse(date_str, dayfirst=dayfirst, yearfirst=yearfirst) self.assertEqual(dateutil_result, expected)
def test_parsers_timestring(self): tm._skip_if_no_dateutil() from dateutil.parser import parse # must be the same as dateutil result cases = {'10:15': (parse('10:15'), datetime.datetime(1, 1, 1, 10, 15)), '9:05': (parse('9:05'), datetime.datetime(1, 1, 1, 9, 5)) } for date_str, (exp_now, exp_def) in compat.iteritems(cases): result1, _, _ = tools.parse_time_string(date_str) result2 = to_datetime(date_str) result3 = to_datetime([date_str]) result4 = Timestamp(date_str) result5 = DatetimeIndex([date_str])[0] # parse time string return time string based on default date # others are not, and can't be changed because it is used in # time series plot self.assertEqual(result1, exp_def) self.assertEqual(result2, exp_now) self.assertEqual(result3, exp_now) self.assertEqual(result4, exp_now) self.assertEqual(result5, exp_now)
def test_parsers_timestring(self): tm._skip_if_no_dateutil() from dateutil.parser import parse # must be the same as dateutil result cases = {'10:15': (parse('10:15'), datetime.datetime(1, 1, 1, 10, 15)), '9:05': (parse('9:05'), datetime.datetime(1, 1, 1, 9, 5))} for date_str, (exp_now, exp_def) in compat.iteritems(cases): result1, _, _ = tools.parse_time_string(date_str) result2 = to_datetime(date_str) result3 = to_datetime([date_str]) result4 = Timestamp(date_str) result5 = DatetimeIndex([date_str])[0] # parse time string return time string based on default date # others are not, and can't be changed because it is used in # time series plot self.assertEqual(result1, exp_def) self.assertEqual(result2, exp_now) self.assertEqual(result3, exp_now) self.assertEqual(result4, exp_now) self.assertEqual(result5, exp_now)
def test_range_tz_dateutil(self): # GH 2906 tm._skip_if_no_dateutil() # Use maybe_get_tz to fix filename in tz under dateutil. from pandas.tslib import maybe_get_tz tz = lambda x: maybe_get_tz('dateutil/' + x) 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.assert_(dr.tz == tz('US/Eastern')) self.assert_(dr[0] == start) self.assert_(dr[2] == end) dr = date_range(end=end, periods=3) self.assert_(dr.tz == tz('US/Eastern')) self.assert_(dr[0] == start) self.assert_(dr[2] == end) dr = date_range(start=start, end=end) self.assert_(dr.tz == tz('US/Eastern')) self.assert_(dr[0] == start) self.assert_(dr[2] == end)
def test_range_tz_dateutil(self): # GH 2906 tm._skip_if_no_dateutil() # Use maybe_get_tz to fix filename in tz under dateutil. from pandas.tslib import maybe_get_tz tz = lambda x: maybe_get_tz('dateutil/' + x) 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.assertTrue(dr.tz == tz('US/Eastern')) self.assertTrue(dr[0] == start) self.assertTrue(dr[2] == end) dr = date_range(end=end, periods=3) self.assertTrue(dr.tz == tz('US/Eastern')) self.assertTrue(dr[0] == start) self.assertTrue(dr[2] == end) dr = date_range(start=start, end=end) self.assertTrue(dr.tz == tz('US/Eastern')) self.assertTrue(dr[0] == start) self.assertTrue(dr[2] == end)
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_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") and dateutil.__version__ <= LooseVersion("2.4.0"): 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_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_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') and dateutil.__version__ <= LooseVersion('2.4.0'): 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 # noqa 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 setUp(self): tm._skip_if_no_dateutil()
def test_summary_dateutil(self): tm._skip_if_no_dateutil() import dateutil cdate_range('1/1/2005', '1/1/2009', tz=dateutil.tz.tzutc()).summary()
def test_parsers_dayfirst_yearfirst(self): tm._skip_if_no_dateutil() # OK # 2.5.1 10-11-12 [dayfirst=0, yearfirst=0] -> 2012-10-11 00:00:00 # 2.5.2 10-11-12 [dayfirst=0, yearfirst=1] -> 2012-10-11 00:00:00 # 2.5.3 10-11-12 [dayfirst=0, yearfirst=0] -> 2012-10-11 00:00:00 # OK # 2.5.1 10-11-12 [dayfirst=0, yearfirst=1] -> 2010-11-12 00:00:00 # 2.5.2 10-11-12 [dayfirst=0, yearfirst=1] -> 2010-11-12 00:00:00 # 2.5.3 10-11-12 [dayfirst=0, yearfirst=1] -> 2010-11-12 00:00:00 # bug fix in 2.5.2 # 2.5.1 10-11-12 [dayfirst=1, yearfirst=1] -> 2010-11-12 00:00:00 # 2.5.2 10-11-12 [dayfirst=1, yearfirst=1] -> 2010-12-11 00:00:00 # 2.5.3 10-11-12 [dayfirst=1, yearfirst=1] -> 2010-12-11 00:00:00 # OK # 2.5.1 10-11-12 [dayfirst=1, yearfirst=0] -> 2012-11-10 00:00:00 # 2.5.2 10-11-12 [dayfirst=1, yearfirst=0] -> 2012-11-10 00:00:00 # 2.5.3 10-11-12 [dayfirst=1, yearfirst=0] -> 2012-11-10 00:00:00 # OK # 2.5.1 20/12/21 [dayfirst=0, yearfirst=0] -> 2021-12-20 00:00:00 # 2.5.2 20/12/21 [dayfirst=0, yearfirst=0] -> 2021-12-20 00:00:00 # 2.5.3 20/12/21 [dayfirst=0, yearfirst=0] -> 2021-12-20 00:00:00 # OK # 2.5.1 20/12/21 [dayfirst=0, yearfirst=1] -> 2020-12-21 00:00:00 # 2.5.2 20/12/21 [dayfirst=0, yearfirst=1] -> 2020-12-21 00:00:00 # 2.5.3 20/12/21 [dayfirst=0, yearfirst=1] -> 2020-12-21 00:00:00 # revert of bug in 2.5.2 # 2.5.1 20/12/21 [dayfirst=1, yearfirst=1] -> 2020-12-21 00:00:00 # 2.5.2 20/12/21 [dayfirst=1, yearfirst=1] -> month must be in 1..12 # 2.5.3 20/12/21 [dayfirst=1, yearfirst=1] -> 2020-12-21 00:00:00 # OK # 2.5.1 20/12/21 [dayfirst=1, yearfirst=0] -> 2021-12-20 00:00:00 # 2.5.2 20/12/21 [dayfirst=1, yearfirst=0] -> 2021-12-20 00:00:00 # 2.5.3 20/12/21 [dayfirst=1, yearfirst=0] -> 2021-12-20 00:00:00 import dateutil is_lt_253 = dateutil.__version__ < LooseVersion('2.5.3') # str : dayfirst, yearfirst, expected cases = {'10-11-12': [(False, False, datetime.datetime(2012, 10, 11)), (True, False, datetime.datetime(2012, 11, 10)), (False, True, datetime.datetime(2010, 11, 12)), (True, True, datetime.datetime(2010, 12, 11))], '20/12/21': [(False, False, datetime.datetime(2021, 12, 20)), (True, False, datetime.datetime(2021, 12, 20)), (False, True, datetime.datetime(2020, 12, 21)), (True, True, datetime.datetime(2020, 12, 21))]} from dateutil.parser import parse for date_str, values in compat.iteritems(cases): for dayfirst, yearfirst, expected in values: # odd comparisons across version # let's just skip if dayfirst and yearfirst and is_lt_253: continue # compare with dateutil result dateutil_result = parse(date_str, dayfirst=dayfirst, yearfirst=yearfirst) self.assertEqual(dateutil_result, expected) result1, _, _ = tools.parse_time_string(date_str, dayfirst=dayfirst, yearfirst=yearfirst) # we don't support dayfirst/yearfirst here: if not dayfirst and not yearfirst: result2 = Timestamp(date_str) self.assertEqual(result2, expected) result3 = to_datetime(date_str, dayfirst=dayfirst, yearfirst=yearfirst) result4 = DatetimeIndex([date_str], dayfirst=dayfirst, yearfirst=yearfirst)[0] self.assertEqual(result1, expected) self.assertEqual(result3, expected) self.assertEqual(result4, expected)