wbcore 1.59.9__py2.py3-none-any.whl

wbcore/tests/test_viewsets.py

@@ -0,0 +1,21 @@
+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,117 @@
+from django.urls import include, path
+from dynamic_preferences.api.viewsets import GlobalPreferencesViewSet
+
+from wbcore.cache.views import clear_cache
+from wbcore.contrib.dynamic_preferences.viewsets import UserPreferencesViewSet
+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,
+    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"global_preferences", GlobalPreferencesViewSet, basename="global_preferences")
+router.register(r"user_preferences", UserPreferencesViewSet, basename="user_preferences")
+
+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/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,237 @@
+from collections import defaultdict
+from datetime import date, datetime, time, timedelta, timezone
+from zoneinfo import ZoneInfo, available_timezones
+
+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=None, granularity=12
+):
+    if hours_range is None:
+        hours_range = range(0, 23)
+
+    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
+
+
+def get_timezone_choices() -> list[tuple[str, str]]:
+    now_utc = datetime.now(timezone.utc)
+    tz_tuples = []  # a list of (timezone_name, timezone_name (UTC offset))
+    for tz_name in sorted(available_timezones()):
+        tz = ZoneInfo(tz_name)
+        now_in_tz = now_utc.astimezone(tz)
+        offset_str = now_in_tz.strftime("UTC%z")  # gives UTC+HHMM
+        offset_str = offset_str[:-2] + ":" + offset_str[-2:]
+        tz_tuples.append((tz_name, f"{tz_name} ({offset_str})"))
+    return tz_tuples

wbcore/utils/date_builder/__init__.py

@@ -0,0 +1,18 @@
+from .components import (
+    SecondStart,
+    SecondEnd,
+    MinuteStart,
+    MinuteEnd,
+    HourStart,
+    HourEnd,
+    WeekStart,
+    WeekEnd,
+    MonthStart,
+    MonthEnd,
+    QuarterStart,
+    QuarterEnd,
+    YearStart,
+    YearEnd,
+    Now,
+)
+from .offsets import Second, Minute, Hour, Day, BusinessDay, Week, Month, Quarter, Year

wbcore/utils/date_builder/components.py

@@ -0,0 +1,42 @@
+class Component:
+    _name: str
+
+    def __init__(self, _name: str | None = None):
+        if _name:
+            self._name = _name
+
+    def arithmetic(self, other, operator) -> "Component":
+        return Component(_name=f"{self.name}{operator}{other.name}")
+
+    def __sub__(self, other) -> "Component":
+        return self.arithmetic(other, "-")
+
+    def __add__(self, other) -> "Component":
+        return self.arithmetic(other, "+")
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+
+Now = Component("now")
+SecondStart = Component("second_start")
+SecondEnd = Component("second_end")
+MinuteStart = Component("minute_start")
+MinuteEnd = Component("minute_end")
+HourStart = Component("hour_start")
+HourEnd = Component("hour_end")
+WeekStart = Component("week_start")
+WeekEnd = Component("week_end")
+MonthStart = Component("month_start")
+MonthEnd = Component("month_end")
+QuarterStart = Component("quarter_start")
+QuarterEnd = Component("quarter_end")
+YearStart = Component("year_start")
+YearEnd = Component("year_end")

wbcore/utils/date_builder/offsets.py

@@ -0,0 +1,27 @@
+from .components import Component
+
+
+class Offset(Component):
+    name_part: str
+
+    def __init__(self, name_part: str, amount: int = 1):
+        self.name_part = name_part
+        self.amount = amount
+
+    def __call__(self, amount: int) -> "Offset":
+        return self.__class__(self.name_part, amount)
+
+    @property
+    def name(self) -> str:
+        return f"{self.amount}{self.name_part}"
+
+
+Second = Offset("seconds")
+Minute = Offset("minutes")
+Hour = Offset("hours")
+Day = Offset("days")
+BusinessDay = Offset("bdays")
+Week = Offset("weeks")
+Month = Offset("months")
+Quarter = Offset("quarters")
+Year = Offset("years")

wbcore/utils/deprecations.py

@@ -0,0 +1,11 @@
+import warnings
+
+
+def deprecate_warning(message: str):
+    warnings.simplefilter("always", DeprecationWarning)
+    warnings.warn(
+        message,
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    warnings.simplefilter("default", DeprecationWarning)

wbcore/utils/enum.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class ChoiceEnum(Enum):
+    @classmethod
+    def choices(cls):
+        return [(choice.name, choice.value) for choice in cls]
+
+    @classmethod
+    def model_choices(cls):
+        return [(choice.value, choice.value) for choice in cls]
+
+    @classmethod
+    def names(cls):
+        return [choice.name for choice in cls]
+
+    @classmethod
+    def values(cls):
+        return [choice.value for choice in cls]
+
+    @classmethod
+    def to_dict(cls):
+        return {choice.name: choice.value for choice in cls}