wbcore 2.2.1__py2.py3-none-any.whl

wbcore/tests/test_something.py

@@ -0,0 +1,39 @@
+# import pytest
+# import time
+# from selenium import webdriver
+# from channels.testing import ChannelsLiveServerTestCase
+
+# from django.contrib.auth import get_user_model, authenticate
+# from .selenium.utils import menu_items_for_user
+
+# def login(url, username, password):
+#     driver = webdriver.Chrome()
+#     driver.get(f"{url}/frontend/")
+#     driver.implicitly_wait(10)
+#     driver.find_element_by_xpath("//input[contains(@class, 'form-control')]").send_keys(username)
+#     driver.find_element_by_xpath("//input[contains(@class, 'text-input')]").send_keys(password)
+#     driver.find_element_by_xpath("//button").click()
+#     time.sleep(1)
+#     return driver
+
+
+# @pytest.mark.django_db
+# class TestLive(ChannelsLiveServerTestCase):
+
+#     @pytest.mark.parametrize
+#     def test_something1(self):
+#         user = get_user_model().objects.create_superuser(
+#             username="root",
+#             email="a@a.de",
+#             password="root"
+#         )
+#         driver = login(self.live_server_url, "root", "root")
+
+#         # self.driver.find_element_by_class_name("root-menu__trigger").click()
+
+#         # menu_items = self.driver.find_elements_by_class_name("menu__menu-item")
+#         # for menu_item in menu_items:
+#         #     menu_item.click()
+#         #     time.sleep(3)
+
+#         assert False

wbcore/tests/test_utils/test_date.py

@@ -0,0 +1,49 @@
+from datetime import date
+
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.utils.date import get_date_interval_from_request, shortcut
+from wbcore.utils.date_builder import *
+
+
+class TestGetDateInterval:
+    def setup_method(self):
+        self.request_factory = APIRequestFactory()
+
+    @pytest.mark.parametrize("start_key", ["start", "start_date", "from", "date_gte"])
+    @pytest.mark.parametrize("start", [date(2010, 1, 1)])
+    @pytest.mark.parametrize("end_key", ["end", "end_date", "to", "date_lte"])
+    @pytest.mark.parametrize("end", [date(2010, 1, 1)])
+    def test_get_date_interval_from_request(self, start_key, start, end_key, end):
+        request = self.request_factory.get(
+            path="",
+            data={
+                start_key: start.strftime("%Y-%m-%d"),
+                end_key: end.strftime("%Y-%m-%d"),
+            },
+        )
+        _start, _end = get_date_interval_from_request(request)
+
+        assert _start == start
+        assert _end == end
+
+    def test_get_date_interval_from_request_none(self):
+        request = self.request_factory.get(
+            path="",
+        )
+        _start, _end = get_date_interval_from_request(request)
+
+        assert _start is None
+        assert _end is None
+
+    def test_get_date_interval_from_request_wrong_date_format(self):
+        request = self.request_factory.get(path="", data={"start": "abc", "end": "def"})
+        _start, _end = get_date_interval_from_request(request)
+
+        assert _start is None
+        assert _end is None
+
+
+class TestShortcut:
+    def test_shortcut(self):
+        assert shortcut("ABC", WeekStart - Day, Now) == {"label": "ABC", "value": f"{str(WeekStart-Day)},{str(Now)}"}

wbcore/tests/test_utils/test_date_builder.py

@@ -0,0 +1,99 @@
+import re
+from operator import add, sub
+
+import pytest
+from wbcore.utils.date_builder import *
+
+
+class TestDateBuilder:
+    @pytest.mark.parametrize(
+        "component,name",
+        [
+            (SecondStart, "second_start"),
+            (SecondEnd, "second_end"),
+            (MinuteStart, "minute_start"),
+            (MinuteEnd, "minute_end"),
+            (HourStart, "hour_start"),
+            (HourEnd, "hour_end"),
+            (WeekStart, "week_start"),
+            (WeekEnd, "week_end"),
+            (MonthStart, "month_start"),
+            (MonthEnd, "month_end"),
+            (QuarterStart, "quarter_start"),
+            (QuarterEnd, "quarter_end"),
+            (YearStart, "year_start"),
+            (YearEnd, "year_end"),
+        ],
+    )
+    def test_component_str(self, component, name):
+        assert str(component) == name
+
+    @pytest.mark.parametrize(
+        "offset, name",
+        [
+            (Second, "seconds"),
+            (Minute, "minutes"),
+            (Hour, "hours"),
+            (Day, "days"),
+            (BusinessDay, "bdays"),
+            (Week, "weeks"),
+            (Month, "months"),
+            (Quarter, "quarters"),
+            (Year, "years"),
+        ],
+    )
+    @pytest.mark.parametrize("amount", [None, 2])
+    def test_offset_str(self, offset, name, amount):
+        if amount:
+            assert str(offset(amount)) == f"{amount}{name}"
+        else:
+            assert str(offset) == f"1{name}"
+
+    @pytest.mark.parametrize(
+        "component",
+        [
+            SecondStart,
+            SecondEnd,
+            MinuteStart,
+            MinuteEnd,
+            HourStart,
+            HourEnd,
+            WeekStart,
+            WeekEnd,
+            MonthStart,
+            MonthEnd,
+            QuarterStart,
+            QuarterEnd,
+            YearStart,
+            YearEnd,
+        ],
+    )
+    @pytest.mark.parametrize("offset", [Second, Minute, Hour, Day, BusinessDay, Week, Month, Quarter, Year])
+    @pytest.mark.parametrize("op", [add, sub])
+    def test_component_with_offset(self, component, offset, op):
+        results = re.findall("([a-z_]*)([+-]{1})([0-9a-z]*)", str(op(component, offset)))
+        assert (
+            len(results[0]) == 3
+        )  # We expect three groups to be found, 1 for the component, 1 for the operator, and 1 for the offset
+
+    @pytest.mark.parametrize(
+        "component",
+        [
+            (SecondStart),
+            (SecondEnd),
+            (MinuteStart),
+            (MinuteEnd),
+            (HourStart),
+            (HourEnd),
+            (WeekStart),
+            (WeekEnd),
+            (MonthStart),
+            (MonthEnd),
+            (QuarterStart),
+            (QuarterEnd),
+            (YearStart),
+            (YearEnd),
+        ],
+    )
+    def test_repr(self, component):
+        assert str(component) == repr(component)

wbcore/tests/test_utils/test_primary.py

@@ -0,0 +1,79 @@
+import pytest
+from django.db import models
+from faker import Faker
+from wbcore.utils.models import PrimaryMixin
+
+fake = Faker()
+
+
+class TestPrimaryModel(PrimaryMixin):
+    PRIMARY_ATTR_FIELDS = ["pivot"]
+
+    pivot = models.CharField(max_length=32, blank=True, null=True)
+    field = models.CharField(max_length=32)
+
+
+@pytest.mark.django_db
+class TestPrimaryMixin:
+    @pytest.fixture()
+    def primary_instance(self):
+        return TestPrimaryModel.objects.create(primary=True, pivot="main", field=fake.word())
+
+    def test_get_related_queryset(self):
+        instance1 = TestPrimaryModel.objects.create(primary=False, pivot="main", field=fake.word())
+        instance2 = TestPrimaryModel.objects.create(primary=False, pivot="main", field=fake.word())
+        instance_other = TestPrimaryModel.objects.create(primary=False, pivot="other", field=fake.word())
+        assert set(instance1.get_related_queryset()) == {
+            instance1,
+            instance2,
+        }  # Test the queryset are all instance related to pivot "main"
+        assert set(instance2.get_related_queryset()) == {
+            instance1,
+            instance2,
+        }  # Test the queryset are all instance related to pivot "main"
+        assert set(instance_other.get_related_queryset()) == {
+            instance_other
+        }  # Test the queryset are all instance related to pivot "other"
+
+    @pytest.mark.parametrize("field", fake.word())
+    def test_saving_primary(self, field):
+        initial_instance = TestPrimaryModel.objects.create(primary=False, pivot="main", field=field)
+        assert (
+            initial_instance.primary is True
+        )  # assert that a non primary saved instance become primary in absence of already primary instance for that pivot
+        second_instance = TestPrimaryModel.objects.create(primary=True, pivot="main", field=field)
+        assert (
+            second_instance.primary is True
+        )  # assert that a primary saved instance become primary and the previous primary is unassigned
+        initial_instance.refresh_from_db()
+        assert initial_instance.primary is False
+
+        unlinked_instance = TestPrimaryModel.objects.create(primary=False, pivot=None, field=field)
+        assert unlinked_instance.primary is False  # check that primary logic doesn't apply for unlink instance
+
+    def test_simple_deletion(self, primary_instance):
+        assert primary_instance.pivot is not None
+        primary_instance.delete()
+        primary_instance.refresh_from_db()
+        assert primary_instance.pivot is None
+
+    def test_real_deletion(self, primary_instance):
+        assert primary_instance.pivot is not None
+        primary_instance.delete(no_deletion=False)
+        with pytest.raises(TestPrimaryModel.DoesNotExist):
+            primary_instance.refresh_from_db()
+
+    def test_deletion_forward_primary_to_next_related_objects(self, primary_instance):
+        second_instance = TestPrimaryModel.objects.create(
+            primary=False, pivot=primary_instance.pivot, field=fake.word()
+        )
+        assert second_instance.primary is False  # Basic check
+        assert primary_instance.primary is True  # Basic check
+        primary_instance.delete()
+
+        second_instance.refresh_from_db()
+        primary_instance.refresh_from_db()
+
+        assert primary_instance.pivot is None  # Check if deleted primary is simply unliked
+        assert primary_instance.primary is False  # and set to false
+        assert second_instance.primary is True  # Check if next non primary related objects become primary

wbcore/tests/test_utils/test_signals.py

@@ -0,0 +1,38 @@
+from unittest.mock import patch
+
+from django.dispatch import Signal
+from wbcore.utils.signals import DisconnectSignals, SignalWrapper
+
+test_signal1 = Signal()
+test_signal2 = Signal()
+
+
+def receiver_dummy1(sender, **kwargs):
+    pass
+
+
+def receiver_dummy2(sender, **kwargs):
+    pass
+
+
+def test_disconnect_signals():
+    with patch("wbcore.tests.test_utils.test_signals.receiver_dummy1") as mock_receiver_dummy1, patch(
+        "wbcore.tests.test_utils.test_signals.receiver_dummy2"
+    ) as mock_receiver_dummy2:
+        test_signal1.connect(receiver_dummy1, "suppressed_sender")
+        test_signal1.connect(receiver_dummy1, "working_sender")
+        test_signal2.connect(receiver_dummy2, "another_suppressed_sender")
+
+        with DisconnectSignals(
+            [
+                SignalWrapper(test_signal1, receiver_dummy1, "suppressed_sender"),
+                SignalWrapper(test_signal2, receiver_dummy2, "another_suppressed_sender"),
+            ]
+        ):
+            test_signal1.send(sender="suppressed_sender")
+            test_signal1.send(sender="working_sender")
+            test_signal2.send(sender="another_suppressed_sender")
+
+        assert mock_receiver_dummy1.call_count == 1
+        assert mock_receiver_dummy1.call_args.kwargs["sender"] == "working_sender"
+        assert not mock_receiver_dummy2.called

wbcore/tests/test_viewsets.py

@@ -0,0 +1,20 @@
+import pytest
+from django.db.models import F
+from django.db.models.expressions import OrderBy
+from wbcore.viewsets.mixins import map_ordering
+
+
+class TestWBCoreOrderingFilter:
+    @pytest.mark.parametrize(
+        ("input", "output"),
+        [
+            ("test_str", OrderBy(F("test_str"))),
+            ("-test_str", OrderBy(F("test_str"), descending=True)),
+            ("test_str__nulls_last", OrderBy(F("test_str"), nulls_last=True)),
+            ("-test_str__nulls_last", OrderBy(F("test_str"), nulls_last=True, descending=True)),
+            ("test_str__nulls_first", OrderBy(F("test_str"), nulls_first=True)),
+            ("-test_str__nulls_first", OrderBy(F("test_str"), nulls_first=True, descending=True)),
+        ],
+    )
+    def test_map_ordering(self, input, output):
+        assert map_ordering(input) == output

wbcore/urls.py

@@ -0,0 +1,114 @@
+from django.urls import include, path
+from wbcore.cache.views import clear_cache
+from wbcore.shares.views import ShareAPIView
+
+from .configs.views import ConfigAPIView
+from .content_type.viewsets import (
+    ContentTypeRepresentationViewSet,
+    DynamicObjectIDRepresentationViewSet,
+)
+from .crontab.viewsets import CrontabScheduleRepresentationViewSet
+from .frontend_user_configuration import FrontendUserConfigurationModelViewSet
+from .markdown.views import (
+    AssetCreateView,
+    AssetRetrieveView,
+    BlockDiag,
+    TemplateTagView,
+)
+from .menus.views import MenuAPIView
+from .metadata.configs.display.views import PresetAPIView
+from .release_notes.viewsets import ReleaseNoteReadOnlyModelViewSet
+from .reversion.viewsets.viewsets import (
+    RevisionModelViewSet,
+    RevisionRepresentationViewSet,
+    VersionModelViewSet,
+    VersionRepresentationViewSet,
+    VersionRevisionModelViewSet,
+)
+from .routers import WBCoreRouter
+from .views import Profile
+
+router = WBCoreRouter()
+router.register(
+    r"frontenduserconfiguration",
+    FrontendUserConfigurationModelViewSet,
+    basename="frontenduserconfiguration",
+)
+
+router.register(r"version", VersionModelViewSet, basename="version")
+router.register(r"revision", RevisionModelViewSet, basename="revision")
+router.register(r"revisionrepresentation", RevisionRepresentationViewSet, basename="revisionrepresentation")
+router.register(r"versionrepresentation", VersionRepresentationViewSet, basename="versionrepresentation")
+router.register(r"releasenote", ReleaseNoteReadOnlyModelViewSet, basename="releasenote")
+router.register(r"contenttyperepresentation", ContentTypeRepresentationViewSet, basename="contenttyperepresentation")
+router.register(
+    r"dynamiccontenttyperepresentation",
+    DynamicObjectIDRepresentationViewSet,
+    basename="dynamiccontenttyperepresentation",
+)
+router.register(
+    r"crontabschedulerepresentation", CrontabScheduleRepresentationViewSet, basename="crontabschedulerepresentation"
+)
+
+revision_router = WBCoreRouter()
+revision_router.register(r"version", VersionRevisionModelViewSet, basename="revision-version")
+
+
+urlpatterns = [
+    path("config/", ConfigAPIView.as_view(), name="config"),
+    path("profile/", Profile.as_view(), name="profile"),
+    path("menu/", MenuAPIView.as_view(), name="menu"),
+    path("preset/<str:display_identifier_path>/", PresetAPIView.as_view(), name="preset"),
+    path("share/", ShareAPIView.as_view(), name="share"),
+    path("markdown/blockdiag/", BlockDiag.as_view(), name="blockdiag"),
+    path("markdown/asset/", AssetCreateView.as_view(), name="markdown-asset-upload"),
+    path("markdown/asset/<uuid>/", AssetRetrieveView.as_view(), name="asset-retrieve"),
+    path("markdown/templatetag/", TemplateTagView.as_view(), name="markdown-tags"),
+    path("", include(router.urls)),
+    path("revision/<int:revision_id>/", include(revision_router.urls)),
+    path(
+        "authentication/",
+        include(("wbcore.contrib.authentication.urls", "wbcore.contrib.authentication"), namespace="authentication"),
+    ),
+    path(
+        "notifications/",
+        include(("wbcore.contrib.notifications.urls", "wbcore.contrib.notifications"), namespace="notifications"),
+    ),
+    path(
+        "io/",
+        include(("wbcore.contrib.io.urls", "wbcore.contrib.io"), namespace="io"),
+    ),
+    path(
+        "geography/",
+        include(("wbcore.contrib.geography.urls", "wbcore.contrib.geography"), namespace="geography"),
+    ),
+    path(
+        "currency/",
+        include(("wbcore.contrib.currency.urls", "wbcore.contrib.currency"), namespace="currency"),
+    ),
+    path(
+        "tags/",
+        include(("wbcore.contrib.tags.urls", "wbcore.contrib.tags"), namespace="tags"),
+    ),
+    path(
+        "documents/",
+        include(("wbcore.contrib.documents.urls", "wbcore.contrib.documents"), namespace="documents"),
+    ),
+    path(
+        "directory/",
+        include(("wbcore.contrib.directory.urls", "wbcore.contrib.directory"), namespace="directory"),
+    ),
+    path(
+        "agenda/",
+        include(("wbcore.contrib.agenda.urls", "wbcore.contrib.agenda"), namespace="agenda"),
+    ),
+    path(
+        "workflow/",
+        include(("wbcore.contrib.workflow.urls", "wbcore.contrib.workflow"), namespace="workflow"),
+    ),
+    path(
+        "guardian/",
+        include(("wbcore.contrib.guardian.urls", "wbcore.contrib.guardian"), namespace="guardian"),
+    ),
+    path("clear_cache/<str:cache_key>/", clear_cache, name="clear_cache"),
+]

wbcore/utils/__init__.py

@@ -0,0 +1,13 @@
+from functools import reduce
+
+
+def ilen(iterable):
+    return reduce(lambda sum, element: sum + 1, iterable, 0)
+
+
+def leaf_subclasses(parent_class):
+    if subclasses := parent_class.__subclasses__():
+        for sub_class in subclasses:
+            yield from leaf_subclasses(sub_class)
+    else:
+        yield parent_class

wbcore/utils/cache.py

@@ -0,0 +1,8 @@
+from functools import lru_cache
+
+from django.db.models import QuerySet
+
+
+@lru_cache
+def mapping(queryset: QuerySet, mapping_field: str = "key", id_field: str = "id", **filter_kwargs) -> dict:
+    return dict(queryset.filter(**filter_kwargs).values_list(mapping_field, id_field))

wbcore/utils/date.py

@@ -0,0 +1,220 @@
+from collections import defaultdict
+from datetime import date, datetime, time, timedelta
+
+from dateutil import rrule
+from django.utils.dateparse import parse_date
+from django.utils.timezone import localdate
+from pandas.tseries.offsets import BDay
+from wbcore.utils.date_builder import (
+    BusinessDay,
+    Hour,
+    Minute,
+    Month,
+    MonthEnd,
+    MonthStart,
+    Now,
+    Quarter,
+    QuarterEnd,
+    QuarterStart,
+    Week,
+    Year,
+    YearStart,
+)
+from wbcore.utils.date_builder.components import Component
+
+
+def get_quarter_from_date(d):
+    return ((d.month - 1) // 3) + 1
+
+
+def get_start_date_from_date(d):
+    quarter = get_quarter_from_date(d)
+    return date(d.year, quarter * 3 - 2, 1)
+
+
+def get_end_date_from_date(d):
+    quarter = get_quarter_from_date(d)
+    return date(d.year + ((quarter * 3 + 1) // 12), (quarter * 3 + 1) % 12, 1) - timedelta(days=1)
+
+
+def get_start_and_end_date_from_date(d):
+    return get_start_date_from_date(d), get_end_date_from_date(d)
+
+
+def current_quarter_date_start(field=None, request=None, view=None):
+    return get_start_date_from_date(localdate())
+
+
+def current_quarter_date_end(field=None, request=None, view=None):
+    return get_end_date_from_date(localdate())
+
+
+def current_quarter_date_interval(field, request, view):
+    return (
+        current_quarter_date_start(field, request, view),
+        current_quarter_date_end(field, request, view),
+    )
+
+
+def financial_year_to_date(field, request, view):
+    d = localdate()
+    return (date(d.year - 1, 12, 31), d)
+
+
+def current_year_date_start(field, request, view):
+    d = localdate()
+    return date(d.year, 1, 1)
+
+
+def current_year_date_end(field, request, view):
+    d = localdate()
+    return date(d.year + 1, 1, 1) - timedelta(days=1)
+
+
+def current_year_date_interval(field, request, view):
+    return (
+        current_year_date_start(field, request, view),
+        current_year_date_end(field, request, view),
+    )
+
+
+def current_month_date_start(field, request, view):
+    d = localdate()
+    return date(d.year, d.month, 1)
+
+
+def current_month_date_end(field=None, request=None, view=None):
+    d = localdate()
+    if d.month == 12:
+        return date(d.year, 12, 31)
+    return date(d.year, d.month + 1, 1) - timedelta(days=1)
+
+
+def current_month_date_interval(field, request, view):
+    return (
+        current_month_date_start(field, request, view),
+        current_month_date_end(field, request, view),
+    )
+
+
+def get_date_interval_from_request(
+    request,
+    request_type="GET",
+    exclude_weekend=False,
+    left_interval_inclusive=False,
+    right_interval_inclusive=True,
+    date_range_fieldname="date",
+):
+    """
+    Parses a request and returns the start and end date from it.
+
+    Parameters
+    ----------
+    request: The GET Request Object
+    exclude_weekend: If True, exclude weekend
+    left_interval_inclusive: If False, corresponds to left bound excluded "(" otherwise, inclusive "["
+    right_interval_inclusive: If False, corresponds to right bound excluded ")" otherwise, inclusive "]"
+
+    Returns
+    -------
+    Return a tuple in the form of (start_date, end_date). If either the start date or the end date is not present in the request None is returned in the tuple
+    """
+
+    start_identifier = ["start", "start_date", "from", "date_gte", "date__gte"]
+    end_identifier = ["end", "end_date", "to", "date_lte", "date__lte"]
+    params = request.GET if request_type == "GET" else request.POST
+    start = None
+    end = None
+    if date_range_fieldname in params:
+        if len(params.get(date_range_fieldname).split(",")) == 2:
+            start, end = map(lambda x: None if x == "" else x, params.get(date_range_fieldname).split(","))
+    if not start or not end:
+        start = next(
+            (params.get(identifier) for identifier in start_identifier if identifier in params),
+            None,
+        )
+        end = next((params.get(identifier) for identifier in end_identifier if identifier in params), None)
+    if start:
+        start = parse_date(start)
+        if start and exclude_weekend:
+            if left_interval_inclusive:
+                start = (start - timedelta(days=1) + BDay(1)).date()
+            else:
+                start = (start + timedelta(days=1) - BDay(1)).date()
+    if end:
+        end = parse_date(end)
+        if end and exclude_weekend:
+            if right_interval_inclusive:
+                end = (end + timedelta(days=1) - BDay(1)).date()
+            else:
+                end = (end - timedelta(days=1) + BDay(1)).date()
+    return start, end
+
+
+def get_number_of_hours_between_dates(
+    d1, d2, skip_weekends=True, list_public_holidays=False, hours_range=range(0, 23), granularity=12
+):
+    def convert_days_from_hours(hours, granularity, hours_per_day):
+        return int(hours / granularity) * granularity / hours_per_day
+
+    rules = rrule.rruleset()
+
+    byweekday_list = [rrule.MO, rrule.TU, rrule.WE, rrule.TH, rrule.FR]
+    if not skip_weekends:
+        byweekday_list.extend([rrule.SA, rrule.SU])
+
+    rules.rrule(
+        rrule.rrule(
+            freq=rrule.HOURLY,
+            byweekday=byweekday_list,
+            byhour=hours_range,
+            dtstart=d1,
+            until=d2,
+        )
+    )
+    if list_public_holidays:
+        for holiday in list_public_holidays:
+            s1 = datetime(holiday.year, holiday.month, holiday.day, 0, 0, 0)
+            s2 = datetime(holiday.year, holiday.month, holiday.day, 23, 59, 59)
+            rules.exrule(rrule.rrule(rrule.HOURLY, dtstart=s1, until=s2))
+    dates = defaultdict(int)
+    for r in list(rules):
+        dates[r.date()] += 1
+    return {k: convert_days_from_hours(v, granularity, len(hours_range)) for k, v in dates.items()}
+
+
+def shortcut(label: str, value_start: str | Component, value_end: str | Component) -> dict[str, str]:
+    return {"label": label, "value": f"{str(value_start)},{str(value_end)}"}
+
+
+financial_performance_shortcuts = [
+    shortcut("Last Day", Now - BusinessDay, Now),
+    shortcut("Last Week", Now - Week - BusinessDay, Now),
+    shortcut("Month to Date", MonthStart - BusinessDay, Now),
+    shortcut("Last Month", Now - Month - BusinessDay, Now),
+    shortcut("Quarter to Date", QuarterStart - BusinessDay, Now),
+    shortcut("Last Quarter", Now - Quarter - BusinessDay, Now),
+    shortcut("Year to Date", YearStart - BusinessDay, Now),
+    shortcut("Last 1 Year", Now - Year - BusinessDay, Now),
+    shortcut("Last 2 Years", Now - Year(2) - BusinessDay, Now),
+    shortcut("Last 3 Years", Now - Year(3) - BusinessDay, Now),
+    shortcut("Last 5 Years", Now - Year(5) - BusinessDay, Now),
+]
+
+current_financial_month = MonthStart - BusinessDay, MonthEnd
+current_financial_quarter = QuarterStart - BusinessDay, QuarterEnd
+
+calendar_item_shortcuts = [
+    shortcut("Last Minute", Now - Minute, Now),
+    shortcut("Last 5 Minutes", Now - Minute(5), Now),
+    shortcut("Last 10 Minutes", Now - Minute(10), Now),
+    shortcut("Last 15 Minutes", Now - Minute(15), Now),
+    shortcut("Last 30 Minutes", Now - Minute(30), Now),
+    shortcut("Last Hour", Now - Hour, Now),
+]
+
+
+def get_next_day_timedelta(now: datetime | None = None) -> int:
+    if not now:
+        now = datetime.now()
+    return (datetime.combine(now.date() + timedelta(days=1), time(0, 0, 0)) - now).seconds