kennethreitz/maya
1
0
Fork 0
mirror of https://github.com/kennethreitz/maya.git synced 2026-06-05 06:46:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup Python project

Browse Source
This commit is contained in:
Timo Furrer
2019-08-24 22:53:43 +02:00
parent 260f0d54eb
commit a4432eef31
37 changed files with 812 additions and 646 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/conftest.py
+17 -16
View File
@@ -2,22 +2,23 @@ from freezegun import freeze_time
import pytest
@pytest.fixture(params=[
("2018-03-25T00:00:00", 2),
("2018-03-25T01:00:00", 2),
("2018-03-25T02:00:00", 2),
("2018-03-25T02:30:00", 2),
("2018-03-25T03:00:00", 2),
("2018-03-25T04:00:00", 2),
("2018-10-28T00:00:00", 2),
("2018-10-28T01:00:00", 2),
("2018-10-28T02:00:00", 2),
("2018-10-28T02:30:00", 2),
("2018-10-28T03:00:00", 2),
("2018-10-28T04:00:00", 2),
], ids=lambda x: x[0] + "_off_" + str(x[1]))
@pytest.fixture(
params=[
("2018-03-25T00:00:00", 2),
("2018-03-25T01:00:00", 2),
("2018-03-25T02:00:00", 2),
("2018-03-25T02:30:00", 2),
("2018-03-25T03:00:00", 2),
("2018-03-25T04:00:00", 2),
("2018-10-28T00:00:00", 2),
("2018-10-28T01:00:00", 2),
("2018-10-28T02:00:00", 2),
("2018-10-28T02:30:00", 2),
("2018-10-28T03:00:00", 2),
("2018-10-28T04:00:00", 2),
],
ids=lambda x: x[0] + "_off_" + str(x[1]),
)
def frozen_now(request):
now_string, tz_offset = request.param
with freeze_time(now_string, tz_offset=tz_offset):
tests/test_maya.py
+85 -109
View File
@@ -10,10 +10,9 @@ import maya
from maya.core import _seconds_or_timedelta # import private function
@pytest.mark.parametrize("string,expected", [
('February 21, 1994',
'Mon, 21 Feb 1994 00:00:00 GMT'),
])
@pytest.mark.parametrize(
"string,expected", [("February 21, 1994", "Mon, 21 Feb 1994 00:00:00 GMT")]
)
def test_rfc2822(string, expected):
r = maya.parse(string).rfc2822()
d = maya.MayaDT.from_rfc2822(r)
@@ -21,10 +20,9 @@ def test_rfc2822(string, expected):
assert r == d.rfc2822()
@pytest.mark.parametrize("string,expected", [
('February 21, 1994',
'1994-02-21T00:00:00Z'),
])
@pytest.mark.parametrize(
"string,expected", [("February 21, 1994", "1994-02-21T00:00:00Z")]
)
def test_iso8601(string, expected):
r = maya.parse(string).iso8601()
d = maya.MayaDT.from_iso8601(r)
@@ -32,28 +30,18 @@ def test_iso8601(string, expected):
assert r == d.iso8601()
@pytest.mark.parametrize("string,expected", [
('20161001T1430.4+05:30',
'2016-10-01T09:00:00.400000Z'),
('2016T14',
'2016-01-01T14:00:00Z'),
('2016-10T14',
'2016-10-01T14:00:00Z'),
('2012W05',
'2012-01-30T00:00:00Z'),
('2012W055',
'2012-02-03T00:00:00Z'),
('2012007',
'2012-01-07T00:00:00Z'),
('2016-W07T09',
'2016-02-15T09:00:00Z'),
])
@pytest.mark.parametrize(
"string,expected",
[
("20161001T1430.4+05:30", "2016-10-01T09:00:00.400000Z"),
("2016T14", "2016-01-01T14:00:00Z"),
("2016-10T14", "2016-10-01T14:00:00Z"),
("2012W05", "2012-01-30T00:00:00Z"),
("2012W055", "2012-02-03T00:00:00Z"),
("2012007", "2012-01-07T00:00:00Z"),
("2016-W07T09", "2016-02-15T09:00:00Z"),
],
)
def test_parse_iso8601(string, expected):
d = maya.MayaDT.from_iso8601(string)
assert expected == d.iso8601()
@@ -69,9 +57,7 @@ def test_struct():
assert m.datetime() == dt
ts = time.localtime(now)
m = maya.MayaDT.from_struct(ts)
dt = Datetime.fromtimestamp(
time.mktime(ts) - maya.core.utc_offset(ts), pytz.UTC
)
dt = Datetime.fromtimestamp(time.mktime(ts) - maya.core.utc_offset(ts), pytz.UTC)
assert m._epoch is not None
assert m.datetime() == dt
@@ -80,29 +66,29 @@ def test_issue_104():
e = 1507756331
t = Datetime.utcfromtimestamp(e)
t = maya.MayaDT.from_datetime(t)
assert str(t) == 'Wed, 11 Oct 2017 21:12:11 GMT'
assert str(t) == "Wed, 11 Oct 2017 21:12:11 GMT"
t = time.gmtime(e)
t = maya.MayaDT.from_struct(t)
assert str(t) == 'Wed, 11 Oct 2017 21:12:11 GMT'
assert str(t) == "Wed, 11 Oct 2017 21:12:11 GMT"
def test_human_when():
r1 = maya.when('yesterday')
r2 = maya.when('today')
r1 = maya.when("yesterday")
r2 = maya.when("today")
assert (r2.day - r1.day) in (1, -30, -29, -28, -27)
def test_machine_parse():
r1 = maya.parse('August 14, 2015')
r1 = maya.parse("August 14, 2015")
assert r1.day == 14
r2 = maya.parse('August 15, 2015')
r2 = maya.parse("August 15, 2015")
assert r2.day == 15
@pytest.mark.usefixtures("frozen_now")
def test_dt_tz_translation():
d1 = maya.now().datetime()
d2 = maya.now().datetime(to_timezone='EST')
d2 = maya.now().datetime(to_timezone="EST")
assert (d1.hour - d2.hour) % 24 == 5
@@ -110,14 +96,14 @@ def test_dt_tz_translation():
def test_dt_tz_naive():
d1 = maya.now().datetime(naive=True)
assert d1.tzinfo is None
d2 = maya.now().datetime(to_timezone='EST', naive=True)
d2 = maya.now().datetime(to_timezone="EST", naive=True)
assert d2.tzinfo is None
assert (d1.hour - d2.hour) % 24 == 5
def test_random_date():
# Test properties for maya.when()
d1 = maya.when('11-17-11 08:09:10')
d1 = maya.when("11-17-11 08:09:10")
assert d1.year == 2011
assert d1.month == 11
assert d1.day == 17
@@ -128,7 +114,7 @@ def test_random_date():
assert d1.second == 10
assert d1.microsecond == 0
# Test properties for maya.parse()
d2 = maya.parse('February 29, 1992 13:12:34')
d2 = maya.parse("February 29, 1992 13:12:34")
assert d2.year == 1992
assert d2.month == 2
assert d2.day == 29
@@ -141,60 +127,58 @@ def test_random_date():
def test_print_date(capsys):
d = maya.when('11-17-11')
d = maya.when("11-17-11")
print(d)
out, err = capsys.readouterr()
assert out == 'Thu, 17 Nov 2011 00:00:00 GMT\n'
assert repr(d) == '<MayaDT epoch=1321488000.0>'
assert out == "Thu, 17 Nov 2011 00:00:00 GMT\n"
assert repr(d) == "<MayaDT epoch=1321488000.0>"
def test_invalid_date():
with pytest.raises(ValueError):
maya.when('another day')
maya.when("another day")
def test_slang_date():
d = maya.when('tomorrow')
assert d.slang_date() == 'tomorrow'
d = maya.when("tomorrow")
assert d.slang_date() == "tomorrow"
def test_slang_date_locale():
d = maya.when('tomorrow')
assert d.slang_date(locale='fr') == 'demain'
d = maya.when("tomorrow")
assert d.slang_date(locale="fr") == "demain"
def test_slang_time():
d = maya.when('1 hour ago')
assert d.slang_time() == '1 hour ago'
d = maya.when("1 hour ago")
assert d.slang_time() == "1 hour ago"
def test_slang_time_locale():
d = maya.when('1 hour ago')
assert d.slang_time(locale='de') == 'vor 1 Stunde'
d = maya.when("1 hour ago")
assert d.slang_time(locale="de") == "vor 1 Stunde"
@pytest.mark.parametrize("string,kwds,expected", [
('February 21, 1994', {},
'1994-02-21 00:00:00+00:00'),
('01/05/2016', {},
'2016-01-05 00:00:00+00:00'),
('01/05/2016', dict(day_first=True),
'2016-05-01 00:00:00+00:00'),
('2016/05/01', dict(year_first=True, day_first=False),
'2016-05-01 00:00:00+00:00'),
('2016/01/05', dict(year_first=True, day_first=True),
'2016-05-01 00:00:00+00:00'),
('01/05/2016', dict(timezone='UTC'),
'2016-01-05 00:00:00+00:00'),
('01/05/2016', dict(timezone='US/Central'),
'2016-01-05 06:00:00+00:00'),
])
@pytest.mark.parametrize(
"string,kwds,expected",
[
("February 21, 1994", {}, "1994-02-21 00:00:00+00:00"),
("01/05/2016", {}, "2016-01-05 00:00:00+00:00"),
("01/05/2016", dict(day_first=True), "2016-05-01 00:00:00+00:00"),
(
"2016/05/01",
dict(year_first=True, day_first=False),
"2016-05-01 00:00:00+00:00",
),
(
"2016/01/05",
dict(year_first=True, day_first=True),
"2016-05-01 00:00:00+00:00",
),
("01/05/2016", dict(timezone="UTC"), "2016-01-05 00:00:00+00:00"),
("01/05/2016", dict(timezone="US/Central"), "2016-01-05 06:00:00+00:00"),
],
)
def test_parse(string, kwds, expected):
d = maya.parse(string, **kwds)
assert format(d) == expected
@@ -204,9 +188,7 @@ def test_parse(string, kwds, expected):
def test_when_past():
two_days_away = maya.now().add(days=2)
past_date = maya.when(
two_days_away.slang_date(),
prefer_dates_from='past')
past_date = maya.when(two_days_away.slang_date(), prefer_dates_from="past")
assert past_date < maya.now()
@@ -215,9 +197,7 @@ def test_when_past():
def test_when_future():
two_days_away = maya.now().add(days=2)
future_date = maya.when(
two_days_away.slang_date(),
prefer_dates_from='future')
future_date = maya.when(two_days_away.slang_date(), prefer_dates_from="future")
assert future_date > maya.now()
@@ -227,8 +207,8 @@ def test_when_past_day_name():
two_days_away = maya.now().add(days=2)
past_date = maya.when(
calendar.day_name[two_days_away.weekday],
prefer_dates_from='past')
calendar.day_name[two_days_away.weekday], prefer_dates_from="past"
)
assert past_date < maya.now()
@@ -238,36 +218,36 @@ def test_when_future_day_name():
two_days_away = maya.now().add(days=2)
future_date = maya.when(
calendar.day_name[two_days_away.weekday],
prefer_dates_from='future')
calendar.day_name[two_days_away.weekday], prefer_dates_from="future"
)
assert future_date > maya.now()
def test_datetime_to_timezone():
dt = maya.when('2016-01-01').datetime(to_timezone='US/Eastern')
assert dt.tzinfo.zone == 'US/Eastern'
dt = maya.when("2016-01-01").datetime(to_timezone="US/Eastern")
assert dt.tzinfo.zone == "US/Eastern"
def test_rfc3339_epoch():
mdt = maya.when('2016-01-01')
mdt = maya.when("2016-01-01")
out = mdt.rfc3339()
mdt2 = maya.MayaDT.from_rfc3339(out)
assert mdt.epoch == mdt2.epoch
def test_rfc3339_format():
rfc3339 = maya.MayaDT.rfc3339(maya.when('2016-01-01T12:03:03Z'))
rfc3339 = maya.MayaDT.rfc3339(maya.when("2016-01-01T12:03:03Z"))
# it's important that the string has got a "max 1-digit millis" fragment
# as per https://tools.ietf.org/html/rfc3339#section-5.6
assert rfc3339 == '2016-01-01T12:03:03.0Z'
assert rfc3339 == "2016-01-01T12:03:03.0Z"
@pytest.mark.usefixtures("frozen_now")
def test_comparison_operations():
now = maya.now()
now_copy = copy.deepcopy(now)
tomorrow = maya.when('tomorrow')
tomorrow = maya.when("tomorrow")
assert (now == now_copy) is True
assert (now == tomorrow) is False
assert (now != now_copy) is False
@@ -302,7 +282,7 @@ def test_seconds_or_timedelta():
assert _seconds_or_timedelta(timedelta(0, 1234)) == timedelta(0, 1234)
# test for invalid value
with pytest.raises(TypeError):
_seconds_or_timedelta('invalid interval')
_seconds_or_timedelta("invalid interval")
@pytest.mark.usefixtures("frozen_now")
@@ -342,49 +322,45 @@ def test_mayaDT_sub():
def test_core_local_timezone(monkeypatch):
@property
def mock_local_tz(self):
class StaticTzInfo(object):
zone = 'local'
zone = "local"
def __repr__(self):
return "<StaticTzInfo 'local'>"
return StaticTzInfo()
monkeypatch.setattr(maya.MayaDT, '_local_tz', mock_local_tz)
monkeypatch.setattr(maya.MayaDT, "_local_tz", mock_local_tz)
mdt = maya.MayaDT(0)
assert mdt.local_timezone == 'UTC'
assert mdt.local_timezone == "UTC"
def test_getting_datetime_for_local_timezone(monkeypatch):
@property
def mock_local_tz(self):
class StaticTzInfo(object):
zone = 'Europe/Zurich'
zone = "Europe/Zurich"
def __repr__(self):
return "<StaticTzInfo 'Europe/Zurich'>"
return StaticTzInfo()
monkeypatch.setattr(maya.MayaDT, '_local_tz', mock_local_tz)
monkeypatch.setattr(maya.MayaDT, "_local_tz", mock_local_tz)
d = maya.parse('1994-02-21T12:00:00+05:30')
d = maya.parse("1994-02-21T12:00:00+05:30")
dt = pytz.timezone('Europe/Zurich').localize(
Datetime(1994, 2, 21, 7, 30))
dt = pytz.timezone("Europe/Zurich").localize(Datetime(1994, 2, 21, 7, 30))
assert d.local_datetime() == dt
@pytest.mark.parametrize("when_str,snap_str,expected_when", [
('Mon, 21 Feb 1994 21:21:42 GMT', '@d',
'Mon, 21 Feb 1994 00:00:00 GMT'),
])
@pytest.mark.parametrize(
"when_str,snap_str,expected_when",
[("Mon, 21 Feb 1994 21:21:42 GMT", "@d", "Mon, 21 Feb 1994 00:00:00 GMT")],
)
def test_snaptime(when_str, snap_str, expected_when):
# given
dt = maya.when(when_str)
tests/test_maya_interval.py
+100 -168
View File
@@ -7,9 +7,9 @@ import pytz
import maya
from maya.compat import cmp
Los_Angeles = pytz.timezone('America/Los_Angeles')
New_York = pytz.timezone('America/New_York')
Melbourne = pytz.timezone('Australia/Melbourne')
Los_Angeles = pytz.timezone("America/Los_Angeles")
New_York = pytz.timezone("America/New_York")
Melbourne = pytz.timezone("Australia/Melbourne")
def test_interval_requires_2_of_start_end_duration():
@@ -59,7 +59,7 @@ def test_interval_init_end_duration():
@pytest.mark.parametrize(
'start_doy1,end_doy1,start_doy2,end_doy2,intersection_doys',
"start_doy1,end_doy1,start_doy2,end_doy2,intersection_doys",
(
(0, 2, 1, 3, (1, 2)),
(0, 2, 3, 4, None),
@@ -74,40 +74,35 @@ def test_interval_init_end_duration():
(1, 3, 2, 2, (2, 2)),
),
ids=(
'overlapping',
'non-overlapping',
'adjacent',
'equal',
'instant overlapping start only',
'instant equal',
'instant disjoint',
'instant overlapping',
'instant overlapping start only (left)',
'instant disjoint (left)',
'instant overlapping (left)',
"overlapping",
"non-overlapping",
"adjacent",
"equal",
"instant overlapping start only",
"instant equal",
"instant disjoint",
"instant overlapping",
"instant overlapping start only (left)",
"instant disjoint (left)",
"instant overlapping (left)",
),
)
def test_interval_intersection(
start_doy1, end_doy1, start_doy2, end_doy2, intersection_doys
):
base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
interval1 = maya.MayaInterval(
base.add(days=start_doy1), base.add(days=end_doy1)
)
interval2 = maya.MayaInterval(
base.add(days=start_doy2), base.add(days=end_doy2)
)
interval1 = maya.MayaInterval(base.add(days=start_doy1), base.add(days=end_doy1))
interval2 = maya.MayaInterval(base.add(days=start_doy2), base.add(days=end_doy2))
if intersection_doys:
start_doy_intersection, end_doy_intersection = intersection_doys
assert interval1 & interval2 == maya.MayaInterval(
base.add(days=start_doy_intersection),
base.add(days=end_doy_intersection),
base.add(days=start_doy_intersection), base.add(days=end_doy_intersection)
)
else:
assert (interval1 & interval2) is None
# check invalid argument
with pytest.raises(TypeError):
interval1 & 'invalid type'
interval1 & "invalid type"
def test_interval_intersects():
@@ -119,7 +114,7 @@ def test_interval_intersects():
)
# check invalid argument
with pytest.raises(TypeError):
interval.intersects('invalid type')
interval.intersects("invalid type")
def test_and_operator():
@@ -127,13 +122,13 @@ def test_and_operator():
interval1 = maya.MayaInterval(base, base.add(days=2))
interval2 = maya.MayaInterval(base.add(days=1), base.add(days=3))
assert (
interval1 & interval2 ==
interval2 & interval1 ==
interval1.intersection(interval2)
interval1 & interval2
== interval2 & interval1 # noqa
== interval1.intersection(interval2) # noqa
)
# check invalid argument
with pytest.raises(TypeError):
interval1.intersection('invalid type')
interval1.intersection("invalid type")
def test_interval_eq_operator():
@@ -144,9 +139,9 @@ def test_interval_eq_operator():
assert interval != maya.MayaInterval(start=start, end=end.add(days=1))
# check invalid argument
with pytest.raises(TypeError):
interval == 'invalid type'
interval == "invalid type"
with pytest.raises(TypeError):
interval != 'invalid type'
interval != "invalid type"
def test_interval_timedelta():
@@ -164,7 +159,7 @@ def test_interval_duration():
@pytest.mark.parametrize(
'start_doy1,end_doy1,start_doy2,end_doy2,expected',
"start_doy1,end_doy1,start_doy2,end_doy2,expected",
(
(0, 2, 1, 3, False),
(0, 2, 3, 4, False),
@@ -172,27 +167,21 @@ def test_interval_duration():
(0, 1, 0, 1, True),
(0, 3, 1, 2, True),
),
ids=('overlapping', 'non-overlapping', 'adjacent', 'equal', 'subset'),
ids=("overlapping", "non-overlapping", "adjacent", "equal", "subset"),
)
def test_interval_contains(
start_doy1, end_doy1, start_doy2, end_doy2, expected
):
def test_interval_contains(start_doy1, end_doy1, start_doy2, end_doy2, expected):
base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
interval1 = maya.MayaInterval(
base.add(days=start_doy1), base.add(days=end_doy1)
)
interval2 = maya.MayaInterval(
base.add(days=start_doy2), base.add(days=end_doy2)
)
interval1 = maya.MayaInterval(base.add(days=start_doy1), base.add(days=end_doy1))
interval2 = maya.MayaInterval(base.add(days=start_doy2), base.add(days=end_doy2))
assert interval1.contains(interval2) is expected
assert (interval2 in interval1) is expected
# check invalid argument
with pytest.raises(TypeError):
interval1.contains('invalid type')
interval1.contains("invalid type")
@pytest.mark.parametrize(
'start_doy,end_doy,dt_doy,expected',
"start_doy,end_doy,dt_doy,expected",
(
(2, 4, 1, False),
(2, 4, 2, True),
@@ -200,7 +189,7 @@ def test_interval_contains(
(2, 4, 4, False),
(2, 4, 5, False),
),
ids=('before-start', 'on-start', 'during', 'on-end', 'after-end'),
ids=("before-start", "on-start", "during", "on-end", "after-end"),
)
def test_interval_in_operator_maya_dt(start_doy, end_doy, dt_doy, expected):
base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
@@ -211,7 +200,7 @@ def test_interval_in_operator_maya_dt(start_doy, end_doy, dt_doy, expected):
assert (dt in interval) is expected
# check invalid argument
with pytest.raises(TypeError):
'invalid type' in interval
"invalid type" in interval
def test_interval_hash():
@@ -219,9 +208,7 @@ def test_interval_hash():
end = start.add(hours=1)
interval = maya.MayaInterval(start=start, end=end)
assert hash(interval) == hash(maya.MayaInterval(start=start, end=end))
assert hash(interval) != hash(
maya.MayaInterval(start=start, end=end.add(days=1))
)
assert hash(interval) != hash(maya.MayaInterval(start=start, end=end.add(days=1)))
def test_interval_iter():
@@ -231,47 +218,34 @@ def test_interval_iter():
@pytest.mark.parametrize(
'start1,end1,start2,end2,expected',
"start1,end1,start2,end2,expected",
[(1, 2, 1, 2, 0), (1, 3, 2, 4, -1), (2, 4, 1, 3, 1), (1, 2, 1, 3, -1)],
ids=(
'equal',
'less-than',
'greater-than',
'use-end-time-if-start-time-identical',
),
ids=("equal", "less-than", "greater-than", "use-end-time-if-start-time-identical"),
)
def test_interval_cmp(start1, end1, start2, end2, expected):
base = maya.now()
interval1 = maya.MayaInterval(
start=base.add(days=start1), end=base.add(days=end1)
)
interval2 = maya.MayaInterval(
start=base.add(days=start2), end=base.add(days=end2)
)
interval1 = maya.MayaInterval(start=base.add(days=start1), end=base.add(days=end1))
interval2 = maya.MayaInterval(start=base.add(days=start2), end=base.add(days=end2))
assert cmp(interval1, interval2) == expected
# check invalid argument
with pytest.raises(TypeError):
cmp(interval1, 'invalid type')
cmp(interval1, "invalid type")
@pytest.mark.parametrize(
'start1,end1,start2,end2,expected',
"start1,end1,start2,end2,expected",
[
(1, 2, 2, 3, [(1, 3)]),
(1, 3, 2, 4, [(1, 4)]),
(1, 2, 3, 4, [(1, 2), (3, 4)]),
(1, 5, 2, 3, [(1, 5)]),
],
ids=('adjacent', 'overlapping', 'non-overlapping', 'contains'),
ids=("adjacent", "overlapping", "non-overlapping", "contains"),
)
def test_interval_combine(start1, end1, start2, end2, expected):
base = maya.now()
interval1 = maya.MayaInterval(
start=base.add(days=start1), end=base.add(days=end1)
)
interval2 = maya.MayaInterval(
start=base.add(days=start2), end=base.add(days=end2)
)
interval1 = maya.MayaInterval(start=base.add(days=start1), end=base.add(days=end1))
interval2 = maya.MayaInterval(start=base.add(days=start2), end=base.add(days=end2))
expected_intervals = [
maya.MayaInterval(start=base.add(days=start), end=base.add(days=end))
for start, end in expected
@@ -280,11 +254,11 @@ def test_interval_combine(start1, end1, start2, end2, expected):
assert interval2.combine(interval1) == expected_intervals
# check invalid argument
with pytest.raises(TypeError):
interval2.combine('invalid type')
interval2.combine("invalid type")
@pytest.mark.parametrize(
'start1,end1,start2,end2,expected',
"start1,end1,start2,end2,expected",
[
(1, 2, 3, 4, [(1, 2)]),
(1, 2, 2, 4, [(1, 2)]),
@@ -296,24 +270,20 @@ def test_interval_combine(start1, end1, start2, end2, expected):
(1, 4, 3, 4, [(1, 3)]),
],
ids=(
'non-overlapping',
'adjacent',
'contains',
'splits',
'overlaps-left',
'overlaps-right',
'overlaps-left-identical-start',
'overlaps-right-identical-end',
"non-overlapping",
"adjacent",
"contains",
"splits",
"overlaps-left",
"overlaps-right",
"overlaps-left-identical-start",
"overlaps-right-identical-end",
),
)
def test_interval_subtract(start1, end1, start2, end2, expected):
base = maya.now()
interval1 = maya.MayaInterval(
start=base.add(days=start1), end=base.add(days=end1)
)
interval2 = maya.MayaInterval(
start=base.add(days=start2), end=base.add(days=end2)
)
interval1 = maya.MayaInterval(start=base.add(days=start1), end=base.add(days=end1))
interval2 = maya.MayaInterval(start=base.add(days=start2), end=base.add(days=end2))
expected_intervals = [
maya.MayaInterval(start=base.add(days=start), end=base.add(days=end))
for start, end in expected
@@ -321,35 +291,26 @@ def test_interval_subtract(start1, end1, start2, end2, expected):
assert interval1.subtract(interval2) == expected_intervals
# check invalid argument
with pytest.raises(TypeError):
interval1.subtract('invalid type')
interval1.subtract("invalid type")
@pytest.mark.parametrize(
'start1,end1,start2,end2,expected',
[
(1, 2, 2, 3, True),
(2, 3, 1, 2, True),
(1, 3, 2, 3, False),
(2, 3, 4, 5, False),
],
ids=('adjacent-right', 'adjacent-left', 'overlapping', 'non-overlapping'),
"start1,end1,start2,end2,expected",
[(1, 2, 2, 3, True), (2, 3, 1, 2, True), (1, 3, 2, 3, False), (2, 3, 4, 5, False)],
ids=("adjacent-right", "adjacent-left", "overlapping", "non-overlapping"),
)
def test_interval_is_adjacent(start1, end1, start2, end2, expected):
base = maya.now()
interval1 = maya.MayaInterval(
start=base.add(days=start1), end=base.add(days=end1)
)
interval2 = maya.MayaInterval(
start=base.add(days=start2), end=base.add(days=end2)
)
interval1 = maya.MayaInterval(start=base.add(days=start1), end=base.add(days=end1))
interval2 = maya.MayaInterval(start=base.add(days=start2), end=base.add(days=end2))
assert interval1.is_adjacent(interval2) == expected
# check invalid argument
with pytest.raises(TypeError):
interval1.is_adjacent('invalid type')
interval1.is_adjacent("invalid type")
@pytest.mark.parametrize(
'start,end,delta,include_remainder,expected',
"start,end,delta,include_remainder,expected",
[
(0, 10, 5, False, [(0, 5), (5, 10)]),
(0, 10, 5, True, [(0, 5), (5, 10)]),
@@ -359,19 +320,17 @@ def test_interval_is_adjacent(start1, end1, start2, end2, expected):
(0, 2, 5, True, [(0, 2)]),
],
ids=(
'even-split',
'even-split-include-partial',
'uneven-split-do-not-include-partial',
'uneven-split-include-partial',
'delta-larger-than-timepsan-do-not-include-partial',
'delta-larger-than-timepsan-include-partial',
"even-split",
"even-split-include-partial",
"uneven-split-do-not-include-partial",
"uneven-split-include-partial",
"delta-larger-than-timepsan-do-not-include-partial",
"delta-larger-than-timepsan-include-partial",
),
)
def test_interval_split(start, end, delta, include_remainder, expected):
base = maya.now()
interval = maya.MayaInterval(
start=base.add(days=start), end=base.add(days=end)
)
interval = maya.MayaInterval(start=base.add(days=start), end=base.add(days=end))
delta = timedelta(days=delta)
expected_intervals = [
maya.MayaInterval(start=base.add(days=s), end=base.add(days=e))
@@ -393,30 +352,30 @@ def test_interval_split_non_positive_delta():
@pytest.mark.parametrize(
'start,end,minutes,timezone,snap_out,expected_start,expected_end',
"start,end,minutes,timezone,snap_out,expected_start,expected_end",
[
((5, 12), (8, 48), 30, None, False, (5, 30), (8, 30)),
((5, 12), (8, 48), 30, None, True, (5, 0), (9, 0)),
((5, 15), (9, 0), 15, None, False, (5, 15), (9, 0)),
((5, 15), (9, 0), 15, None, True, (5, 15), (9, 0)),
((6, 50), (9, 15), 60, 'America/New_York', False, (7, 0), (9, 0)),
((6, 50), (9, 15), 60, 'America/New_York', True, (6, 0), (10, 0)),
((6, 50), (9, 15), 60, "America/New_York", False, (7, 0), (9, 0)),
((6, 50), (9, 15), 60, "America/New_York", True, (6, 0), (10, 0)),
((6, 20), (6, 50), 60, None, False, (6, 0), (6, 0)),
((6, 20), (6, 50), 60, None, True, (6, 0), (7, 0)),
((6, 20), (6, 50), 60, 'America/Chicago', False, (6, 0), (6, 0)),
((6, 20), (6, 50), 60, 'America/Chicago', True, (6, 0), (7, 0)),
((6, 20), (6, 50), 60, "America/Chicago", False, (6, 0), (6, 0)),
((6, 20), (6, 50), 60, "America/Chicago", True, (6, 0), (7, 0)),
],
ids=(
'normal',
'normal-snap_out',
'already-quantized',
'already-quantized-snap_out',
'with-timezone',
'with-timezone-snap_out',
'too-small',
'too-small-snap_out',
'too-small-with-timezone',
'too-small-with-timezone-snap_out',
"normal",
"normal-snap_out",
"already-quantized",
"already-quantized-snap_out",
"with-timezone",
"with-timezone-snap_out",
"too-small",
"too-small-snap_out",
"too-small-with-timezone",
"too-small-with-timezone-snap_out",
),
)
def test_quantize(
@@ -427,7 +386,7 @@ def test_quantize(
start=base.add(hours=start[0], minutes=start[1]),
end=base.add(hours=end[0], minutes=end[1]),
)
kwargs = {'timezone': timezone} if timezone is not None else {}
kwargs = {"timezone": timezone} if timezone is not None else {}
quantized_interval = interval.quantize(
timedelta(minutes=minutes), snap_out=snap_out, **kwargs
)
@@ -464,11 +423,9 @@ def test_interval_flatten_non_overlapping():
def test_interval_flatten_adjacent():
step = 2
max_hour = 20
base = maya.when('jan/1/2011')
base = maya.when("jan/1/2011")
intervals = [
maya.MayaInterval(
start=base.add(hours=hour), duration=timedelta(hours=step)
)
maya.MayaInterval(start=base.add(hours=hour), duration=timedelta(hours=step))
for hour in range(0, max_hour, step)
]
random.shuffle(intervals)
@@ -483,16 +440,13 @@ def test_interval_flatten_intersecting():
base = maya.now()
intervals = [
maya.MayaInterval(
start=base.add(hours=hour),
duration=timedelta(hours=step, minutes=30),
start=base.add(hours=hour), duration=timedelta(hours=step, minutes=30)
)
for hour in range(0, max_hour, step)
]
random.shuffle(intervals)
assert maya.MayaInterval.flatten(intervals) == [
maya.MayaInterval(
start=base, duration=timedelta(hours=max_hour, minutes=30)
)
maya.MayaInterval(start=base, duration=timedelta(hours=max_hour, minutes=30))
]
@@ -536,9 +490,9 @@ def test_interval_from_datetime():
def test_interval_iso8601():
start = maya.when('11-17-11 08:09:10')
start = maya.when("11-17-11 08:09:10")
interval = maya.MayaInterval(start=start, duration=1)
assert interval.iso8601() == '2011-11-17T08:09:10Z/2011-11-17T08:09:11Z'
assert interval.iso8601() == "2011-11-17T08:09:10Z/2011-11-17T08:09:11Z"
def test_interval_from_iso8601():
@@ -553,18 +507,14 @@ def test_interval_from_iso8601():
def test_interval_from_iso8601_duration():
interval = maya.MayaInterval.from_iso8601(
"2018-03-18T14:27:18Z/P13DT13H48M9S"
)
interval = maya.MayaInterval.from_iso8601("2018-03-18T14:27:18Z/P13DT13H48M9S")
s = maya.when("2018-03-18T14:27:18Z")
e = maya.when("2018-04-01T04:15:27Z")
assert interval.start == s
assert interval.end == e
interval = maya.MayaInterval.from_iso8601(
"2018-03-05T14:27:18Z/P2W"
)
interval = maya.MayaInterval.from_iso8601("2018-03-05T14:27:18Z/P2W")
s = maya.when("2018-03-05T14:27:18Z")
e = maya.when("2018-03-19T14:27:18Z")
@@ -576,26 +526,11 @@ def test_interval_from_iso8601_duration():
"start_string,end_string,interval,expected_count",
[
("2019-01-03 11:40:00Z", "2019-01-03 11:40:20Z", 2, 10),
(
"2019-01-03 11:40:00Z",
"2019-01-03 11:40:30Z",
timedelta(seconds=2),
15,
),
("2019-01-03 11:40:00Z", "2019-01-03 11:40:30Z", timedelta(seconds=2), 15),
("2019-01-03 11:40:00Z", "2019-01-03 11:45:00Z", 2 * 60, 3),
(
"2019-01-03 11:40:00Z",
"2019-01-03 11:51:00Z",
timedelta(minutes=1),
11,
),
("2019-01-03 11:40:00Z", "2019-01-03 11:51:00Z", timedelta(minutes=1), 11),
("2019-01-03 11:40:00Z", "2019-01-03 21:40:00Z", 3 * 60 * 60, 4),
(
"2019-01-03 11:40:00Z",
"2019-01-03 13:41:00Z",
timedelta(hours=1),
3,
),
("2019-01-03 11:40:00Z", "2019-01-03 13:41:00Z", timedelta(hours=1), 3),
("2019-01-03 11:40:00Z", "2019-01-09 11:40:00Z", 3 * 60 * 60 * 24, 2),
("2019-01-03 11:40:00Z", "2019-01-05 12:00:00Z", timedelta(days=2), 2),
],
@@ -623,7 +558,4 @@ def test_issue_168_regression():
# Since the bug causes the generator to never end, first sanity
# check that two results are not the same.
assert next(gen) != next(gen)
assert (
len(list(maya.intervals(start=start, end=end, interval=60 * 60 * 24)))
== 7
)
assert len(list(maya.intervals(start=start, end=end, interval=60 * 60 * 24))) == 7