def test_retain_tz(tmpdir, create, todos):
create("ar.ics", "SUMMARY:blah.ar\nDUE;VALUE=DATE-TIME;TZID=HST:20160102T000000\n")
create("de.ics", "SUMMARY:blah.de\nDUE;VALUE=DATE-TIME;TZID=CET:20160102T000000\n")
todos = list(todos())
assert len(todos) == 2
assert todos[0].due == datetime(2016, 1, 2, 0, 0, tzinfo=tzoffset(None, -36000))
assert todos[1].due == datetime(2016, 1, 2, 0, 0, tzinfo=tzoffset(None, 3600))
def test_strictdatetime(self):
class MySchema(EmbeddedSchema):
a = fields.StrictDateTimeField()
b = fields.StrictDateTimeField(load_as_tz_aware=False)
c = fields.StrictDateTimeField(load_as_tz_aware=True)
# Test _deserialize
s = MySchema(strict=True)
for date in (
datetime(2016, 8, 6),
datetime(2016, 8, 6, tzinfo=tzutc()),
"2016-08-06T00:00:00Z",
"2016-08-06T00:00:00",
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == datetime(2016, 8, 6)
assert data['b'] == datetime(2016, 8, 6)
assert data['c'] == datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
"2016-08-06T00:00:00+02:00",
datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == datetime(2016, 8, 5, 22, 0)
assert data['b'] == datetime(2016, 8, 5, 22, 0)
assert data['c'] == datetime(2016,
8,
6,
tzinfo=tzoffset(None, 7200))
with pytest.raises(ValidationError):
s.load({'a': "dummy"})
# Test _deserialize_from_mongo
MyDataProxy = data_proxy_factory('My', MySchema())
d = MyDataProxy()
for date in (
datetime(2016, 8, 6),
datetime(2016, 8, 6, tzinfo=tzutc()),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == datetime(2016, 8, 6)
assert d.get('b') == datetime(2016, 8, 6)
assert d.get('c') == datetime(2016, 8, 6, tzinfo=tzutc())
for date in (datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)), ):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == datetime(2016, 8, 5, 22, 0)
assert d.get('b') == datetime(2016, 8, 5, 22, 0)
assert d.get('c') == datetime(2016,
8,
6,
tzinfo=tzoffset(None, 7200))
def test_parsing_different_timezone_offsets(self):
# GH 17697
data = ["2015-11-18 15:30:00+05:30", "2015-11-18 15:30:00+06:30"]
data = np.array(data, dtype=object)
result, result_tz = tslib.array_to_datetime(data)
expected = np.array([datetime(2015, 11, 18, 15, 30,
tzinfo=tzoffset(None, 19800)),
datetime(2015, 11, 18, 15, 30,
tzinfo=tzoffset(None, 23400))],
dtype=object)
tm.assert_numpy_array_equal(result, expected)
assert result_tz is None
def test_parsing_different_timezone_offsets(self):
# GH 17697
data = ["2015-11-18 15:30:00+05:30", "2015-11-18 15:30:00+06:30"]
data = np.array(data, dtype=object)
result, result_tz = tslib.array_to_datetime(data)
expected = np.array([
datetime(2015, 11, 18, 15, 30, tzinfo=tzoffset(None, 19800)),
datetime(2015, 11, 18, 15, 30, tzinfo=tzoffset(None, 23400))
],
dtype=object)
tm.assert_numpy_array_equal(result, expected)
assert result_tz is None
def test_strictdatetime(self):
class MySchema(EmbeddedSchema):
a = fields.StrictDateTimeField()
b = fields.StrictDateTimeField(load_as_tz_aware=False)
c = fields.StrictDateTimeField(load_as_tz_aware=True)
# Test _deserialize
s = MySchema(strict=True)
for date in (
datetime(2016, 8, 6),
datetime(2016, 8, 6, tzinfo=tzutc()),
"2016-08-06T00:00:00Z",
"2016-08-06T00:00:00",
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == datetime(2016, 8, 6)
assert data['b'] == datetime(2016, 8, 6)
assert data['c'] == datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
"2016-08-06T00:00:00+02:00",
datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == datetime(2016, 8, 5, 22, 0)
assert data['b'] == datetime(2016, 8, 5, 22, 0)
assert data['c'] == datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200))
with pytest.raises(ValidationError):
s.load({'a': "dummy"})
# Test _deserialize_from_mongo
MyDataProxy = data_proxy_factory('My', MySchema())
d = MyDataProxy()
for date in (
datetime(2016, 8, 6),
datetime(2016, 8, 6, tzinfo=tzutc()),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == datetime(2016, 8, 6)
assert d.get('b') == datetime(2016, 8, 6)
assert d.get('c') == datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == datetime(2016, 8, 5, 22, 0)
assert d.get('b') == datetime(2016, 8, 5, 22, 0)
assert d.get('c') == datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200))
def test_illegal_start_suppression(create, default_database, todos):
create(
'test.ics', 'SUMMARY:Start doing stuff\n'
'DUE;VALUE=DATE-TIME;TZID=CET:20170331T120000\n'
'DTSTART;VALUE=DATE-TIME;TZID=CET:20170331T140000\n')
todo = next(todos())
assert todo.start is None
assert todo.due == datetime(2017, 3, 31, 12, tzinfo=tzoffset(None, 7200))
def test_transform_datetime() -> None:
now = datetime(2020, 1, 2, 3, 4, 5)
fmt = "2020-01-02T03:04:05+00:00"
assert transform_datetime(now) == fmt
assert transform_datetime(now.replace(tzinfo=tz.tzutc())) == fmt
offset = timedelta(hours=8)
assert (transform_datetime(
now.replace(tzinfo=tz.tzoffset("PST", offset)) + offset) == fmt)
def test_retain_tz(tmpdir, create, default_database):
create(
'ar.ics',
'SUMMARY:blah.ar\n'
'DUE;VALUE=DATE-TIME;TZID=HST:20160102T000000\n'
)
create(
'de.ics',
'SUMMARY:blah.de\n'
'DUE;VALUE=DATE-TIME;TZID=CET:20160102T000000\n'
)
db = Database([tmpdir.join('default')], tmpdir.join('cache.sqlite'))
todos = list(db.todos())
assert len(todos) == 2
assert todos[0].due == datetime(
2016, 1, 2, 0, 0, tzinfo=tzoffset(None, -36000)
)
assert todos[1].due == datetime(
2016, 1, 2, 0, 0, tzinfo=tzoffset(None, 3600)
)
def _mkoffset(hmtuple, fmt):
h, m = hmtuple
m_td = (-1 if h < 0 else 1) * m
tzo = tz.tzoffset(None, timedelta(hours=h, minutes=m_td))
return tzo, fmt.format(h, m)
###
# Acceptance of bytes
@pytest.mark.parametrize('isostr,dt', [
(b'2014', datetime(2014, 1, 1)),
(b'20140204', datetime(2014, 2, 4)),
(b'2014-02-04', datetime(2014, 2, 4)),
(b'2014-02-04T12', datetime(2014, 2, 4, 12)),
(b'2014-02-04T12:30', datetime(2014, 2, 4, 12, 30)),
(b'2014-02-04T12:30:15', datetime(2014, 2, 4, 12, 30, 15)),
(b'2014-02-04T12:30:15.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
(b'20140204T123015.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
(b'2014-02-04T12:30:15.224Z', datetime(2014, 2, 4, 12, 30, 15, 224000,
tz.tzutc())),
(b'2014-02-04T12:30:15.224+05:00',
datetime(2014, 2, 4, 12, 30, 15, 224000,
tzinfo=tz.tzoffset(None, timedelta(hours=5))))])
def test_bytes(isostr, dt):
assert isoparse(isostr) == dt
###
# Invalid ISO strings
@pytest.mark.parametrize('isostr,exception', [
('201', ValueError), # ISO string too short
('2012-0425', ValueError), # Inconsistent date separators
('201204-25', ValueError), # Inconsistent date separators
('20120425T0120:00', ValueError), # Inconsistent time separators
('20120425T012500-334', ValueError), # Wrong microsecond separator
('2001-1', ValueError), # YYYY-M not valid
('2012-04-9', ValueError), # YYYY-MM-D not valid
('201204', ValueError), # YYYYMM not valid
def _mkoffset(hmtuple, fmt):
h, m = hmtuple
m_td = (-1 if h < 0 else 1) * m
tzo = tz.tzoffset(None, timedelta(hours=h, minutes=m_td))
return tzo, fmt.format(h, m)
###
# Acceptance of bytes
@pytest.mark.parametrize('isostr,dt', [
(b'2014', datetime(2014, 1, 1)),
(b'20140204', datetime(2014, 2, 4)),
(b'2014-02-04', datetime(2014, 2, 4)),
(b'2014-02-04T12', datetime(2014, 2, 4, 12)),
(b'2014-02-04T12:30', datetime(2014, 2, 4, 12, 30)),
(b'2014-02-04T12:30:15', datetime(2014, 2, 4, 12, 30, 15)),
(b'2014-02-04T12:30:15.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
(b'20140204T123015.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
(b'2014-02-04T12:30:15.224Z', datetime(2014, 2, 4, 12, 30, 15, 224000,
tz.tzutc())),
(b'2014-02-04T12:30:15.224+05:00',
datetime(2014, 2, 4, 12, 30, 15, 224000,
tzinfo=tz.tzoffset(None, timedelta(hours=5))))])
def test_bytes(isostr, dt):
assert isoparse(isostr) == dt
###
# Invalid ISO strings
@pytest.mark.parametrize('isostr,exception', [
('201', ValueError), # ISO string too short
('2012-0425', ValueError), # Inconsistent date separators
('201204-25', ValueError), # Inconsistent date separators
('20120425T0120:00', ValueError), # Inconsistent time separators
('20120425T012500-334', ValueError), # Wrong microsecond separator
('2001-1', ValueError), # YYYY-M not valid
('2012-04-9', ValueError), # YYYY-MM-D not valid
('201204', ValueError), # YYYYMM not valid
from datetime import datetime, timedelta
import cabin.utils.time as time_utils
from dateutil import tz
from dateutil.tz.tz import tzoffset
NZDT = tzoffset("NZDT", timedelta(hours=13).seconds)
def test_timestamp_nzdt():
dt = datetime(2009, 2, 14, 12, 31, 30, tzinfo=NZDT)
assert time_utils.timestamp(dt) == 1234567890
def test_timestamp_utc():
dt = datetime(2009, 2, 13, 23, 31, 31, 11000, tzinfo=tz.UTC)
assert time_utils.timestamp(dt) == 1234567891
def test_start_of_day_nzdt():
dt = datetime(2009, 2, 13, 1, 1, 1, 11000, tzinfo=NZDT)
assert time_utils.start_of_day(dt) == datetime(2009, 2, 13, tzinfo=NZDT)
def test_start_of_day_no_tz():
dt = datetime(2009, 2, 13, 1, 1, 31, 11000)
assert time_utils.start_of_day(dt) == datetime(2009, 2, 13)
def test_to_utc_and_back():
dt_local = datetime(2009, 2, 14, 12, 31, 30, tzinfo=NZDT)
def test_parse(self):
time_zone = pytz.utc
now = datetime.datetime.now(time_zone)
with freeze_time(now):
self.assertEqual(now, dateparser.parse('now', time_zone))
self.assertEqual(now, dateparser.parse('NOW', time_zone))
self.assertEqual(now, dateparser.parse('Now', time_zone))
self.assertEqual(now, dateparser.parse('today', time_zone))
self.assertEqual(now, dateparser.parse('TODAY', time_zone))
self.assertEqual(now, dateparser.parse('Today', time_zone))
self.assertEqual(now - datetime.timedelta(1),
dateparser.parse('yesterday', time_zone))
self.assertEqual(now - datetime.timedelta(1),
dateparser.parse('YESTERDAY', time_zone))
self.assertEqual(now - datetime.timedelta(1),
dateparser.parse('Yesterday', time_zone))
self.assertEqual(now - datetime.timedelta(seconds=1),
dateparser.parse('1 sec ago', time_zone))
self.assertEqual(now - datetime.timedelta(seconds=1),
dateparser.parse('1 second ago', time_zone))
self.assertEqual(now - datetime.timedelta(seconds=2),
dateparser.parse('2 seconds ago', time_zone))
self.assertEqual(now - datetime.timedelta(minutes=1),
dateparser.parse('1 min ago', time_zone))
self.assertEqual(now - datetime.timedelta(minutes=1),
dateparser.parse('1 minute ago', time_zone))
self.assertEqual(now - datetime.timedelta(minutes=2),
dateparser.parse('2 minutes ago', time_zone))
self.assertEqual(now - datetime.timedelta(hours=1),
dateparser.parse('1 hour ago', time_zone))
self.assertEqual(now - datetime.timedelta(hours=2),
dateparser.parse('2 hours ago', time_zone))
self.assertEqual(now - datetime.timedelta(days=1),
dateparser.parse('1 day ago', time_zone))
self.assertEqual(now - datetime.timedelta(days=2),
dateparser.parse('2 days ago', time_zone))
self.assertEqual(now - datetime.timedelta(weeks=1),
dateparser.parse('1 week ago', time_zone))
self.assertEqual(now - datetime.timedelta(weeks=2),
dateparser.parse('2 weeks ago', time_zone))
self.assertEqual(now - datetime.timedelta(weeks=3),
dateparser.parse('3 WEEKS AGO', time_zone))
self.assertEqual(datetime.datetime(2017, 10, 5, tzinfo=time_zone),
dateparser.parse('2017-10-05', time_zone))
self.assertEqual(
datetime.datetime(2017, 10, 5, 16, 36, tzinfo=time_zone),
dateparser.parse('2017-10-05 16:36', time_zone))
self.assertEqual(
datetime.datetime(2017, 10, 6, 16, 37, 59, tzinfo=tzlocal()),
dateparser.parse('Fri Oct 6 16:37:59 CDT 2017', time_zone))
self.assertEqual(
datetime.datetime(2003,
9,
25,
10,
49,
41,
tzinfo=tz.tzoffset(
None, datetime.timedelta(hours=-3))),
dateparser.parse('Thu, 25 Sep 2003 10:49:41 -0300', time_zone))
self.assertIsNone(
dateparser.parse('1 day ago 1 hour ago', time_zone))
self.assertIsNone(dateparser.parse('1 day', time_zone))
self.assertIsNone(dateparser.parse('day ago', time_zone))
self.assertIsNone(dateparser.parse('day', time_zone))
self.assertIsNone(dateparser.parse('ago', time_zone))
self.assertIsNone(dateparser.parse('foo', time_zone))
self.assertIsNone(dateparser.parse('', time_zone))
def test_strictdatetime(self):
class MySchema(EmbeddedSchema):
a = fields.StrictDateTimeField()
b = fields.StrictDateTimeField(load_as_tz_aware=False)
c = fields.StrictDateTimeField(load_as_tz_aware=True)
# Test _deserialize
s = MySchema(strict=True)
for date in (
dt.datetime(2016, 8, 6),
dt.datetime(2016, 8, 6, tzinfo=tzutc()),
"2016-08-06T00:00:00Z",
"2016-08-06T00:00:00",
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == dt.datetime(2016, 8, 6)
assert data['b'] == dt.datetime(2016, 8, 6)
assert data['c'] == dt.datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
"2016-08-06T00:00:00+02:00",
dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == dt.datetime(2016, 8, 5, 22, 0)
assert data['b'] == dt.datetime(2016, 8, 5, 22, 0)
assert data['c'] == dt.datetime(2016,
8,
6,
tzinfo=tzoffset(None, 7200))
with pytest.raises(ValidationError):
s.load({'a': "dummy"})
# Test _deserialize_from_mongo
MyDataProxy = data_proxy_factory('My', MySchema())
d = MyDataProxy()
for date in (
dt.datetime(2016, 8, 6),
dt.datetime(2016, 8, 6, tzinfo=tzutc()),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == dt.datetime(2016, 8, 6)
assert d.get('b') == dt.datetime(2016, 8, 6)
assert d.get('c') == dt.datetime(2016, 8, 6, tzinfo=tzutc())
for date in (dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)), ):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == dt.datetime(2016, 8, 5, 22, 0)
assert d.get('b') == dt.datetime(2016, 8, 5, 22, 0)
assert d.get('c') == dt.datetime(2016,
8,
6,
tzinfo=tzoffset(None, 7200))
# Test StrictDateTimeField rounds to milliseconds
s = MySchema()
data, _ = s.load({'a': dt.datetime(2016, 8, 6, 12, 30, 30, 123456)})
assert data['a'].microsecond == 123000
data, _ = s.load({'a': dt.datetime(2016, 8, 6, 12, 59, 59, 999876)})
assert data['a'].hour == 13
assert data['a'].minute == 0
assert data['a'].second == 0
assert data['a'].microsecond == 0
def test_strictdatetime(self):
class MySchema(EmbeddedSchema):
a = fields.StrictDateTimeField()
b = fields.StrictDateTimeField(load_as_tz_aware=False)
c = fields.StrictDateTimeField(load_as_tz_aware=True)
# Test _deserialize
s = MySchema(strict=True)
for date in (
dt.datetime(2016, 8, 6),
dt.datetime(2016, 8, 6, tzinfo=tzutc()),
"2016-08-06T00:00:00Z",
"2016-08-06T00:00:00",
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == dt.datetime(2016, 8, 6)
assert data['b'] == dt.datetime(2016, 8, 6)
assert data['c'] == dt.datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
"2016-08-06T00:00:00+02:00",
dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
data, _ = s.load({'a': date, 'b': date, 'c': date})
assert data['a'] == dt.datetime(2016, 8, 5, 22, 0)
assert data['b'] == dt.datetime(2016, 8, 5, 22, 0)
assert data['c'] == dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200))
with pytest.raises(ValidationError):
s.load({'a': "dummy"})
# Test _deserialize_from_mongo
MyDataProxy = data_proxy_factory('My', MySchema())
d = MyDataProxy()
for date in (
dt.datetime(2016, 8, 6),
dt.datetime(2016, 8, 6, tzinfo=tzutc()),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == dt.datetime(2016, 8, 6)
assert d.get('b') == dt.datetime(2016, 8, 6)
assert d.get('c') == dt.datetime(2016, 8, 6, tzinfo=tzutc())
for date in (
dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200)),
):
d.from_mongo({'a': date, 'b': date, 'c': date})
assert d.get('a') == dt.datetime(2016, 8, 5, 22, 0)
assert d.get('b') == dt.datetime(2016, 8, 5, 22, 0)
assert d.get('c') == dt.datetime(2016, 8, 6, tzinfo=tzoffset(None, 7200))
# Test StrictDateTimeField rounds to milliseconds
s = MySchema()
data, _ = s.load({'a': dt.datetime(2016, 8, 6, 12, 30, 30, 123456)})
assert data['a'].microsecond == 123000
data, _ = s.load({'a': dt.datetime(2016, 8, 6, 12, 59, 59, 999876)})
assert data['a'].hour == 13
assert data['a'].minute == 0
assert data['a'].second == 0
assert data['a'].microsecond == 0
