diff --git a/pystreamapi/conditions/date.py b/pystreamapi/conditions/date.py index b5e519e..2960793 100644 --- a/pystreamapi/conditions/date.py +++ b/pystreamapi/conditions/date.py @@ -1,7 +1,9 @@ -from datetime import datetime as __datetime, timedelta as __timedelta, timezone as __timezone +from datetime import datetime as __datetime, timedelta as __timedelta, timezone as __timezone, \ + date as __date +from typing import Union -def before(d: __datetime): +def before(d: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is before a given datetime. :param d: The datetime to check against. @@ -10,7 +12,7 @@ def before(d: __datetime): return lambda y: y < d -def after(d: __datetime): +def after(d: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is after a given datetime. :param d: The datetime to check against. @@ -19,7 +21,7 @@ def after(d: __datetime): return lambda y: y > d -def before_or_equal(d: __datetime): +def before_or_equal(d: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is before or equal to a given datetime. :param d: The datetime to check against. @@ -28,7 +30,7 @@ def before_or_equal(d: __datetime): return lambda y: y <= d -def after_or_equal(d: __datetime): +def after_or_equal(d: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is after or equal to a given datetime. :param d: The datetime to check against. @@ -37,7 +39,7 @@ def after_or_equal(d: __datetime): return lambda y: y >= d -def between_or_equal(d: __datetime, y: __datetime): +def between_or_equal(d: Union[__datetime, __date], y: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is between or equal to two given datetimes. :param d: The datetime to check against. @@ -47,7 +49,7 @@ def between_or_equal(d: __datetime, y: __datetime): return lambda z: d <= z <= y -def not_between_or_equal(d: __datetime, y: __datetime): +def not_between_or_equal(d: Union[__datetime, __date], y: Union[__datetime, __date]): """ Returns a condition that checks if a datetime is not between or equal to two given datetimes. :param d: The datetime to check against. @@ -62,7 +64,8 @@ def today(): The condition that checks if a datetime is today. :return: A condition that checks if a datetime is today. """ - return lambda d: __datetime.now().date() == d.date() + return lambda d: __datetime.now().date() == d.date() if isinstance(d, __datetime) else \ + __datetime.now().date() == d def today_utc(): @@ -71,7 +74,8 @@ def today_utc(): in your Stream). :return: A condition that checks if a datetime is today. """ - return lambda d: __datetime.now(__timezone.utc).date() == d.astimezone(__timezone.utc).date() + return lambda d: __datetime.now(__timezone.utc).date() == d.astimezone(__timezone.utc).date() \ + if isinstance(d, __datetime) else __datetime.now(__timezone.utc).date() == d def yesterday(): @@ -79,7 +83,8 @@ def yesterday(): The condition that checks if a datetime is yesterday. :return: A condition that checks if a datetime is yesterday. """ - return lambda d: __datetime.now().date() - __timedelta(days=1) == d.date() + return lambda d: __datetime.now().date() - __timedelta(days=1) == d.date() if \ + isinstance(d, __datetime) else __datetime.now().date() - __timedelta(days=1) == d def yesterday_utc(): @@ -89,7 +94,8 @@ def yesterday_utc(): :return: A condition that checks if a datetime is yesterday. """ return lambda d: __datetime.now(__timezone.utc).date() - __timedelta(days=1) == d.astimezone( - __timezone.utc).date() + __timezone.utc).date() if isinstance(d, __datetime) \ + else __datetime.now(__timezone.utc).date() - __timedelta(days=1) == d def tomorrow(): @@ -97,7 +103,8 @@ def tomorrow(): A condition that checks if a datetime is tomorrow. :return: A condition that checks if a datetime is tomorrow. """ - return lambda d: __datetime.now().date() + __timedelta(days=1) == d.date() + return lambda d: __datetime.now().date() + __timedelta(days=1) == d.date() if \ + isinstance(d, __datetime) else __datetime.now().date() + __timedelta(days=1) == d def tomorrow_utc(): @@ -107,7 +114,8 @@ def tomorrow_utc(): :return: A condition that checks if a datetime is tomorrow. """ return lambda d: __datetime.now(__timezone.utc).date() + __timedelta(days=1) == d.astimezone( - __timezone.utc).date() + __timezone.utc).date() if isinstance(d, __datetime) \ + else __datetime.now(__timezone.utc).date() + __timedelta(days=1) == d def this_week(): @@ -115,7 +123,9 @@ def this_week(): A condition that checks if a datetime is this week. :return: A condition that checks if a datetime is this week. """ - return lambda d: __datetime.now().date().isocalendar()[1] == d.date().isocalendar()[1] + return lambda d: __datetime.now().date().isocalendar()[1] == d.date().isocalendar()[1] \ + if isinstance(d, __datetime) \ + else __datetime.now().date().isocalendar()[1] == d.isocalendar()[1] def this_week_utc(): @@ -125,7 +135,8 @@ def this_week_utc(): :return: A condition that checks if a datetime is this week. """ return lambda d: __datetime.now(__timezone.utc).date().isocalendar()[1] == \ - d.astimezone(__timezone.utc).date().isocalendar()[1] + d.astimezone(__timezone.utc).date().isocalendar()[1] if isinstance(d, __datetime) else \ + __datetime.now(__timezone.utc).date().isocalendar()[1] == d.isocalendar()[1] def last_week(): @@ -133,7 +144,9 @@ def last_week(): A condition that checks if a datetime is last week. :return: A condition that checks if a datetime is last week. """ - return lambda d: __datetime.now().date().isocalendar()[1] - 1 == d.date().isocalendar()[1] + return lambda d: __datetime.now().date().isocalendar()[1] - 1 == d.date().isocalendar()[1] if \ + isinstance(d, __datetime) \ + else __datetime.now().date().isocalendar()[1] - 1 == d.isocalendar()[1] def last_week_utc(): @@ -143,7 +156,8 @@ def last_week_utc(): :return: A condition that checks if a datetime is last week. """ return lambda d: __datetime.now(__timezone.utc).date().isocalendar()[1] - 1 == \ - d.astimezone(__timezone.utc).date().isocalendar()[1] + d.astimezone(__timezone.utc).date().isocalendar()[1] if isinstance(d, __datetime) else \ + __datetime.now(__timezone.utc).date().isocalendar()[1] - 1 == d.isocalendar()[1] def next_week(): @@ -151,7 +165,9 @@ def next_week(): A condition that checks if a datetime is next week. :return: A condition that checks if a datetime is next week. """ - return lambda d: __datetime.now().date().isocalendar()[1] + 1 == d.date().isocalendar()[1] + return lambda d: __datetime.now().date().isocalendar()[1] + 1 == d.date().isocalendar()[1] if \ + isinstance(d, __datetime) \ + else __datetime.now().date().isocalendar()[1] + 1 == d.isocalendar()[1] def next_week_utc(): @@ -161,7 +177,8 @@ def next_week_utc(): :return: A condition that checks if a datetime is next week. """ return lambda d: __datetime.now(__timezone.utc).date().isocalendar()[1] + 1 == \ - d.astimezone(__timezone.utc).date().isocalendar()[1] + d.astimezone(__timezone.utc).date().isocalendar()[1] if isinstance(d, __datetime) else \ + __datetime.now(__timezone.utc).date().isocalendar()[1] + 1 == d.isocalendar()[1] def this_month(): @@ -223,7 +240,8 @@ def __check_is_month(d: __datetime, offset: int = 0, tz: __timezone = None): :param offset: The offset to check against. :param tz: The timezone to check against. """ - return __datetime.now(tz).date().month + offset == d.astimezone(tz).date().month + return __datetime.now(tz).date().month + offset == d.astimezone(tz).date().month if \ + isinstance(d, __datetime) else __datetime.now(tz).date().month + offset == d.month def this_year(): @@ -283,4 +301,5 @@ def __check_is_year(d: __datetime, offset: int = 0, tz: __timezone = None): :param d: The datetime to check against. :param offset: The offset to check against. """ - return __datetime.now(tz).date().year + offset == d.astimezone(tz).date().year + return __datetime.now(tz).date().year + offset == d.astimezone(tz).date().year if \ + isinstance(d, __datetime) else __datetime.now(tz).date().year + offset == d.year diff --git a/tests/date_test.py b/tests/date_test.py new file mode 100644 index 0000000..3b0bcab --- /dev/null +++ b/tests/date_test.py @@ -0,0 +1,27 @@ +# pylint: disable=too-many-instance-attributes + +from datetime import datetime, timedelta, timezone +from unittest import TestCase + + +class DateTest(TestCase): + + def setUp(self): + self.now = datetime.now() + self.yesterday = self.now - timedelta(days=1) + self.tomorrow = self.now + timedelta(days=1) + self.last_week = self.now - timedelta(weeks=1) + self.next_week = self.now + timedelta(weeks=1) + self.last_month = (self.now.replace(day=1) - timedelta(days=1)) + self.next_month = (self.now.replace(day=25) + timedelta(days=15)) + self.last_year = self.now.replace(year=self.now.year - 1) + self.next_year = self.now.replace(year=self.now.year + 1) + self.now_utc = datetime.now(timezone.utc) + self.yesterday_utc = self.now_utc - timedelta(days=1) + self.tomorrow_utc = self.now_utc + timedelta(days=1) + self.last_week_utc = self.now_utc - timedelta(weeks=1) + self.next_week_utc = self.now_utc + timedelta(weeks=1) + self.last_month_utc = (self.now_utc.replace(day=1) - timedelta(days=1)) + self.next_month_utc = (self.now_utc.replace(day=25) + timedelta(days=15)) + self.last_year_utc = self.now_utc.replace(year=self.now_utc.year - 1) + self.next_year_utc = self.now_utc.replace(year=self.now_utc.year + 1) diff --git a/tests/test_date_conditions.py b/tests/test_date_conditions.py index 151af74..6167b94 100644 --- a/tests/test_date_conditions.py +++ b/tests/test_date_conditions.py @@ -1,33 +1,11 @@ -# pylint: disable=wildcard-import,too-many-instance-attributes - -from datetime import datetime, timedelta, timezone -from unittest import TestCase +# pylint: disable=wildcard-import,too-many-instance-attributes,unused-wildcard-import +from date_test import DateTest from pystreamapi.conditions import equal_to, not_equal_to, between, not_between from pystreamapi.conditions.date import * -class TestDateConditions(TestCase): - - def setUp(self): - self.now = datetime.now() - self.yesterday = self.now - timedelta(days=1) - self.tomorrow = self.now + timedelta(days=1) - self.last_week = self.now - timedelta(weeks=1) - self.next_week = self.now + timedelta(weeks=1) - self.last_month = (self.now.replace(day=1) - timedelta(days=1)) - self.next_month = (self.now.replace(day=25) + timedelta(days=15)) - self.last_year = self.now.replace(year=self.now.year - 1) - self.next_year = self.now.replace(year=self.now.year + 1) - self.now_utc = datetime.now(timezone.utc) - self.yesterday_utc = self.now_utc - timedelta(days=1) - self.tomorrow_utc = self.now_utc + timedelta(days=1) - self.last_week_utc = self.now_utc - timedelta(weeks=1) - self.next_week_utc = self.now_utc + timedelta(weeks=1) - self.last_month_utc = (self.now_utc.replace(day=1) - timedelta(days=1)) - self.next_month_utc = (self.now_utc.replace(day=25) + timedelta(days=15)) - self.last_year_utc = self.now_utc.replace(year=self.now_utc.year - 1) - self.next_year_utc = self.now_utc.replace(year=self.now_utc.year + 1) +class TestDateConditions(DateTest): def test_before(self): self.assertTrue(before(self.tomorrow)(self.now)) diff --git a/tests/test_date_conditions_type_date.py b/tests/test_date_conditions_type_date.py new file mode 100644 index 0000000..e6b9901 --- /dev/null +++ b/tests/test_date_conditions_type_date.py @@ -0,0 +1,180 @@ +# pylint: disable=wildcard-import,too-many-instance-attributes,unused-wildcard-import + +from date_test import DateTest +from pystreamapi.conditions import equal_to, not_equal_to, between, not_between +from pystreamapi.conditions.date import * + + +class TestDateConditionsUsingTypeDate(DateTest): + + def test_before(self): + self.assertTrue(before(self.tomorrow.date())(self.now.date())) + self.assertFalse(before(self.yesterday.date())(self.now.date())) + self.assertFalse(before(self.now.date())(self.now.date())) + + def test_after(self): + self.assertTrue(after(self.yesterday.date())(self.now.date())) + self.assertFalse(after(self.tomorrow.date())(self.now.date())) + self.assertFalse(after(self.now.date())(self.now.date())) + + def test_before_or_equal(self): + self.assertTrue(before_or_equal(self.tomorrow.date())(self.now.date())) + self.assertFalse(before_or_equal(self.yesterday.date())(self.now.date())) + self.assertTrue(before_or_equal(self.now.date())(self.now.date())) + + def test_after_or_equal(self): + self.assertTrue(after_or_equal(self.yesterday.date())(self.now.date())) + self.assertFalse(after_or_equal(self.tomorrow.date())(self.now.date())) + self.assertTrue(after_or_equal(self.now.date())(self.now.date())) + + def test_equal_to(self): + self.assertTrue(equal_to(self.now.date())(self.now.date())) + self.assertFalse(equal_to(self.now.date())(self.yesterday.date())) + + def test_not_equal_to(self): + self.assertTrue(not_equal_to(self.now.date())(self.yesterday.date())) + self.assertFalse(not_equal_to(self.now.date())(self.now.date())) + + def test_between(self): + between_func = between(self.yesterday.date(), self.tomorrow.date()) + self.assertTrue(between_func(self.now.date())) + self.assertFalse(between_func(self.last_week.date())) + self.assertFalse(between_func(self.next_week.date())) + + def test_not_between(self): + not_between_func = not_between(self.yesterday.date(), self.tomorrow.date()) + self.assertFalse(not_between_func(self.now.date())) + self.assertTrue(not_between_func(self.last_week.date())) + self.assertTrue(not_between_func(self.next_week.date())) + + def test_between_or_equal(self): + between_or_equal_func = between_or_equal(self.now.date(), self.tomorrow.date()) + self.assertTrue(between_or_equal_func(self.now.date())) + self.assertTrue(between_or_equal_func(self.tomorrow.date())) + self.assertFalse(between_or_equal_func(self.yesterday.date())) + + def test_not_between_or_equal(self): + not_between_or_equal_func = not_between_or_equal(self.now.date(), self.tomorrow.date()) + self.assertFalse(not_between_or_equal_func(self.now.date())) + self.assertFalse(not_between_or_equal_func(self.tomorrow.date())) + self.assertTrue(not_between_or_equal_func(self.yesterday.date())) + + def test_today(self): + self.assertTrue(today()(self.now.date())) + self.assertFalse(today()(self.yesterday.date())) + self.assertFalse(today()(self.tomorrow.date())) + + def test_today_utc(self): + self.assertTrue(today_utc()(self.now_utc.date())) + self.assertFalse(today_utc()(self.yesterday_utc.date())) + self.assertFalse(today_utc()(self.tomorrow_utc.date())) + + def test_yesterday(self): + self.assertTrue(yesterday()(self.yesterday.date())) + self.assertFalse(yesterday()(self.now.date())) + self.assertFalse(yesterday()(self.tomorrow.date())) + + def test_yesterday_utc(self): + self.assertTrue(yesterday_utc()(self.yesterday_utc.date())) + self.assertFalse(yesterday_utc()(self.now_utc.date())) + self.assertFalse(yesterday_utc()(self.tomorrow_utc.date())) + + def test_tomorrow(self): + self.assertTrue(tomorrow()(self.tomorrow.date())) + self.assertFalse(tomorrow()(self.now.date())) + self.assertFalse(tomorrow()(self.yesterday.date())) + + def test_tomorrow_utc(self): + self.assertTrue(tomorrow_utc()(self.tomorrow_utc.date())) + self.assertFalse(tomorrow_utc()(self.now_utc.date())) + self.assertFalse(tomorrow_utc()(self.yesterday_utc.date())) + + def test_this_week(self): + self.assertTrue(this_week()(self.now.date())) + self.assertFalse(this_week()(self.last_week.date())) + self.assertFalse(this_week()(self.next_week.date())) + + def test_this_week_utc(self): + self.assertTrue(this_week_utc()(self.now_utc.date())) + self.assertFalse(this_week_utc()(self.last_week_utc.date())) + self.assertFalse(this_week_utc()(self.next_week_utc.date())) + + def test_last_week(self): + self.assertTrue(last_week()(self.last_week.date())) + self.assertFalse(last_week()(self.now.date())) + self.assertFalse(last_week()(self.next_week.date())) + + def test_last_week_utc(self): + self.assertTrue(last_week_utc()(self.last_week_utc.date())) + self.assertFalse(last_week_utc()(self.now_utc.date())) + self.assertFalse(last_week_utc()(self.next_week_utc.date())) + + def test_next_week(self): + self.assertTrue(next_week()(self.next_week.date())) + self.assertFalse(next_week()(self.now.date())) + self.assertFalse(next_week()(self.last_week.date())) + + def test_next_week_utc(self): + self.assertTrue(next_week_utc()(self.next_week_utc.date())) + self.assertFalse(next_week_utc()(self.now_utc.date())) + self.assertFalse(next_week_utc()(self.last_week_utc.date())) + + def test_this_month(self): + self.assertTrue(this_month()(self.now.date())) + self.assertFalse(this_month()(self.last_month.date())) + self.assertFalse(this_month()(self.next_month.date())) + + def test_this_month_utc(self): + self.assertTrue(this_month_utc()(self.now_utc.date())) + self.assertFalse(this_month_utc()(self.last_month_utc.date())) + self.assertFalse(this_month_utc()(self.next_month_utc.date())) + + def test_last_month(self): + self.assertTrue(last_month()(self.last_month.date())) + self.assertFalse(last_month()(self.now.date())) + self.assertFalse(last_month()(self.next_month.date())) + + def test_last_month_utc(self): + self.assertTrue(last_month_utc()(self.last_month_utc.date())) + self.assertFalse(last_month_utc()(self.now_utc.date())) + self.assertFalse(last_month_utc()(self.next_month_utc.date())) + + def test_next_month(self): + self.assertTrue(next_month()(self.next_month.date())) + self.assertFalse(next_month()(self.now.date())) + self.assertFalse(next_month()(self.last_month.date())) + + def test_next_month_utc(self): + self.assertTrue(next_month_utc()(self.next_month_utc.date())) + self.assertFalse(next_month_utc()(self.now_utc.date())) + self.assertFalse(next_month_utc()(self.last_month_utc.date())) + + def test_this_year(self): + self.assertTrue(this_year()(self.now.date())) + self.assertFalse(this_year()(self.last_year.date())) + self.assertFalse(this_year()(self.next_year.date())) + + def test_this_year_utc(self): + self.assertTrue(this_year_utc()(self.now_utc.date())) + self.assertFalse(this_year_utc()(self.last_year_utc.date())) + self.assertFalse(this_year_utc()(self.next_year_utc.date())) + + def test_last_year(self): + self.assertTrue(last_year()(self.last_year.date())) + self.assertFalse(last_year()(self.now.date())) + self.assertFalse(last_year()(self.next_year.date())) + + def test_last_year_utc(self): + self.assertTrue(last_year_utc()(self.last_year_utc.date())) + self.assertFalse(last_year_utc()(self.now_utc.date())) + self.assertFalse(last_year_utc()(self.next_year_utc.date())) + + def test_next_year(self): + self.assertTrue(next_year()(self.next_year.date())) + self.assertFalse(next_year()(self.now.date())) + self.assertFalse(next_year()(self.last_year.date())) + + def test_next_year_utc(self): + self.assertTrue(next_year_utc()(self.next_year_utc.date())) + self.assertFalse(next_year_utc()(self.now_utc.date())) + self.assertFalse(next_year_utc()(self.last_year_utc.date()))