wbcore 2.2.1__py2.py3-none-any.whl

wbcore/utils/models.py

@@ -0,0 +1,275 @@
+from contextlib import suppress
+
+from django.core.exceptions import FieldDoesNotExist, FieldError
+from django.db import models
+from django.db.models.signals import post_delete, pre_delete
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from ordered_model.models import OrderedModelManager
+from rest_framework.fields import get_attribute
+from wbcore.contrib.color.enums import WBColor
+from wbcore.contrib.color.fields import ColorField
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.icons.models import IconField
+from wbcore.utils.enum import ChoiceEnum
+
+
+def get_and_update_or_create(model, filter_params, defaults):
+    """get or create with default values applied to existing instances
+
+    {model}.objects.get_or_create(*{filter_params}, defaults={defaults})
+
+    Arguments:
+        model {django.db.models.Model} -- The model the queryset gets applied to
+        filter_params {dict} -- The parameters that the queryset gets filter against
+        defaults {dict} -- The default values that will be applied to the instance (create, update)
+
+    Returns:
+        django.db.models.Model -- The created/updated instance of the model
+    """
+
+    instance, created = model.objects.get_or_create(**filter_params, defaults=defaults)
+    if not created:
+        model.objects.filter(id=instance.id).update(**defaults)
+        instance = model.objects.get(id=instance.id)
+        instance.save()
+    return instance
+
+
+class NoGroupBySubquery(models.Subquery):
+    """Same as the default django subquery, however does not perform a group by"""
+
+    def get_group_by_cols(self):
+        return []
+
+
+class NoGroupByExpressionWrapper(models.ExpressionWrapper):
+    def get_group_by_cols(self):
+        return []
+
+
+class ComplexToStringMixin(models.Model):
+    """Mixin that allows to store a complex to string method in the database"""
+
+    COMPUTED_STR_RECOMPUTE_PERIODICALLY: bool = True
+    COMPUTED_STR_RECOMPUTE_ON_SAVE: bool = True
+    COMPUTED_STR_MAX_LENGTH: int = 512
+
+    class Meta:
+        abstract = True
+
+    computed_str = models.CharField(max_length=COMPUTED_STR_MAX_LENGTH, null=True, blank=True, verbose_name=_("Name"))
+
+    def compute_str(self):
+        raise NotImplementedError
+
+    def __str__(self):
+        if self.computed_str:
+            return self.computed_str
+        return ""
+
+    def save(self, *args, **kwargs):
+        if self.COMPUTED_STR_RECOMPUTE_ON_SAVE or not self.id:
+            self.computed_str = self.compute_str()
+
+        if (
+            self.computed_str and len(self.computed_str) > self.COMPUTED_STR_MAX_LENGTH
+        ):  # ensure computed str does not exceed the provided max length
+            self.computed_str = (
+                self.computed_str[: self.COMPUTED_STR_MAX_LENGTH - 3] + "..."
+            )  # we materialize the fact that we pruned the computed str with ...
+
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{computed_str}}"
+
+
+class LabelKeyMixin:
+    @classmethod
+    def get_label_key(cls):
+        if hasattr(cls, "LABEL_KEY"):
+            return cls.LABEL_KEY
+        raise AssertionError(
+            f"You need to implement the get_label_key method in the class {cls} or remove the LabelKeyMixin from {cls}."
+        )
+
+
+class Status(ChoiceEnum):
+    PENDING = _("Pending")
+    DENIED = _("Denied")
+    APPROVED = _("Approved")
+
+    @classmethod
+    def get_color_map(cls):
+        colors = [WBColor.YELLOW_LIGHT.value, WBColor.RED_LIGHT.value, WBColor.GREEN_LIGHT.value]
+        return [choice for choice in zip(cls, colors)]
+
+
+class PrimaryMixin(models.Model):
+    """
+    Ensures that there is only one entry with primary=True
+    for models with a foreign key field to a different model and a primary field.
+    """
+
+    PRIMARY_ATTR_FIELDS: list = []  # define the list of fields that needs to introduce uniqueness
+    primary = models.BooleanField(default=False, verbose_name="Primary")
+
+    @property
+    def can_update_primary_field(self) -> bool:
+        """
+        Check if any of the primary fields have non-None values for updating.
+
+        This property evaluates whether any of the primary fields defined in
+        `PRIMARY_ATTR_FIELDS` have non-None values in the current instance.
+        It is useful to determine if the primary fields can be updated.
+
+        Returns:
+            bool: True if any primary field has a non-None value, False otherwise.
+        """
+        return any([get_attribute(self, field.split(".")) is not None for field in self.PRIMARY_ATTR_FIELDS])
+
+    def get_related_queryset(self):
+        """
+        Retrieve a queryset of related objects based on primary attributes.
+
+        This method generates a queryset for related objects of the same model
+        by filtering on primary attributes. Primary attributes are defined in
+        the class attribute `PRIMARY_ATTR_FIELDS`.
+
+        Returns:
+            QuerySet: A Django QuerySet containing related objects.
+
+        """
+        return self._meta.model.objects.filter(
+            **{field.replace(".", "__"): get_attribute(self, field.split(".")) for field in self.PRIMARY_ATTR_FIELDS}
+        )
+
+    def save(self, *args, **kwargs):
+        if self.can_update_primary_field:
+            related_qs = self.get_related_queryset()
+            if self.primary:
+                related_qs = related_qs.exclude(id=self.id)  # if self id is None, it will not exclude anything
+                related_qs.update(primary=False)
+            elif not related_qs.filter(primary=True).exists():
+                self.primary = True
+        super().save(*args, **kwargs)
+
+    def delete(self, no_deletion=True, **kwargs):
+        if self.primary and (qs := self.get_related_queryset().exclude(id=self.id)).exists():
+            next_primary = qs.first()
+            next_primary.primary = True
+            next_primary.save()
+            self.primary = False
+            self.save()
+        if no_deletion:
+            for field_name in self.PRIMARY_ATTR_FIELDS:
+                with suppress(FieldError, FieldDoesNotExist):
+                    if self._meta.get_field(field_name).null:  # ensure the field is nullable
+                        setattr(
+                            self, field_name, None
+                        )  # We don't delete the object, we just un-assign the entry to "hide" it
+            self.save()
+        else:
+            super().delete(**kwargs)
+
+    class Meta:
+        abstract = True
+
+
+class DefaultMixin(models.Model):
+    """
+    Ensures that there is only one instance with default=True.
+    """
+
+    default = models.BooleanField(
+        verbose_name=_("Default"),
+        default=False,
+    )
+
+    def save(self, *args, **kwargs):
+        if hasattr(self, "default"):
+            if self.default:
+                self._meta.model.objects.all().update(default=False)
+            elif self._meta.model.objects.all().count() == 0:
+                self.default = True
+        return super().save(*args, **kwargs)
+
+    class Meta:
+        abstract = True
+
+
+class ActiveObjectManager(OrderedModelManager):
+    def get_queryset(self):
+        try:
+            return super().get_queryset().filter(is_active=True)
+        except FieldError:
+            return super().get_queryset()
+
+
+class DeleteToDisableMixin(models.Model):
+    AUTOMATICALLY_CLEAN_SOFT_DELETED_OBJECTS = False
+
+    is_active = models.BooleanField(default=True)
+    deletion_datetime = models.DateTimeField(blank=True, null=True)
+
+    objects = ActiveObjectManager()
+    all_objects = models.Manager()
+
+    def delete(self, using=None, no_deletion=True, **kwargs):
+        if no_deletion:
+            pre_delete.send(
+                sender=self.__class__,
+                instance=self,
+            )
+            self.is_active = False
+            self.deletion_datetime = timezone.now()
+            self.save()
+            post_delete.send(sender=self.__class__, instance=self, using=using)
+        else:
+            super().delete(using=using, **kwargs)
+
+    class Meta:
+        abstract = True
+
+
+def get_object(model_class: models.Model, object_id: int):
+    if issubclass(model_class, DeleteToDisableMixin):
+        objects = model_class.all_objects
+    else:
+        objects = model_class.objects
+    return objects.get(id=object_id)
+
+
+class CalendarItemTypeMixin(models.Model):
+    color = ColorField(
+        verbose_name=_("Color"),
+        default="#000000",
+        unique=False,
+        blank=False,
+        null=False,
+    )
+
+    icon = IconField(
+        max_length=128,
+        unique=False,
+        verbose_name=_("Icon"),
+        blank=False,
+        null=False,
+        default=WBIcon.EVENT.value,
+    )
+
+    class Meta:
+        abstract = True
+
+
+class ResolvableModelMixin(models.Model):
+    class Meta:
+        abstract = True
+
+    resolved = models.BooleanField(default=False, verbose_name="Resolved")
+
+    def delete(self, *args, **kwargs):
+        assert not self.resolved, "Resolved Entities cannot be deleted."
+        super().delete(*args, **kwargs)

wbcore/utils/numbers.py

@@ -0,0 +1,69 @@
+powers = [10**x for x in (3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 100)]
+
+human_powers = (
+    ("Thousand", "Thousand"),
+    ("Million", "Million"),
+    ("Billion", "Billion"),
+    ("Trillion", "Trillion"),
+    ("Quadrillion", "Quadrillion"),
+    ("Quintillion", "Quintillion"),
+    ("Sextillion", "Sextillion"),
+    ("Septillion", "Septillion"),
+    ("Octillion", "Octillion"),
+    ("Nonillion", "Nonillion"),
+    ("Decillion", "Decillion"),
+    ("Googol", "Googol"),
+)
+
+
+def intword(value, format=".1f"):
+    """Converts a large integer to a friendly text representation.
+    Works best for numbers over 1 million. For example, 1_000_000 becomes "1.0 million",
+    1200000 becomes "1.2 million" and "1_200_000_000" becomes "1.2 billion". Supports up
+    to decillion (33 digits) and googol (100 digits).
+    Examples:
+        ```pycon
+        >>> intword("100")
+        '100'
+        >>> intword("12400")
+        '12.4 thousand'
+        >>> intword("1000000")
+        '1.0 million'
+        >>> intword(1_200_000_000)
+        '1.2 billion'
+        >>> intword(8100000000000000000000000000000000)
+        '8.1 decillion'
+        >>> intword(None) is None
+        True
+        >>> intword("1234000", "%0.3f")
+        '1.234 million'
+        ```
+    Args:
+        value (int, float, str): Integer to convert.
+        format (str): To change the number of decimal or general format of the number
+            portion.
+    Returns:
+        str: Friendly text representation as a string, unless the value passed could not
+        be coaxed into an `int`.
+    """
+    try:
+        value = int(value)
+    except (TypeError, ValueError):
+        return value
+
+    output_format = format
+    format = "%" + format
+
+    if value < powers[0]:
+        return str(value)
+    for ordinal, power in enumerate(powers[1:], 1):
+        if value < power:
+            chopped = value / float(powers[ordinal - 1])
+            if float(format % chopped) == float(10**3):
+                chopped = value / float(powers[ordinal])
+                singular, plural = human_powers[ordinal]
+                return f"{chopped:{output_format}} {singular}"
+            else:
+                singular, plural = human_powers[ordinal - 1]
+                return f"{chopped:{output_format}} {singular}"
+    return str(value)

wbcore/utils/prettytable.py

@@ -0,0 +1,35 @@
+from decimal import Decimal
+
+from prettytable import PrettyTable
+
+
+def prettytable_from_querydict(values, float_format=False):
+    ptable = PrettyTable()
+    keys = [key for key in values[0].keys()]
+
+    ptable.field_names = list(keys)
+
+    if float_format:
+        for _values in values:
+            formatted_values = list()
+            for v in _values.values():
+                if type(v) in [float, int, Decimal]:
+                    v = f"{v:,.2f}"
+                formatted_values.append(v)
+            ptable.add_row(formatted_values)
+    else:
+        for _values in values:
+            ptable.add_row(_values.values())
+
+    print(ptable)  # noqa: T201
+
+
+def prettytable_from_list(headers, values):
+    ptable = PrettyTable()
+
+    ptable.field_names = list(headers)
+
+    for _values in values:
+        ptable.add_row(_values.values())
+
+    print(ptable)  # noqa: T201

wbcore/utils/print.py

@@ -0,0 +1,29 @@
+import json
+
+from pygments import highlight
+from pygments.formatters import TerminalFormatter
+from pygments.lexers import JsonLexer
+
+
+class PrintColor:
+    PURPLE = "\033[95m"
+    CYAN = "\033[96m"
+    DARKCYAN = "\033[36m"
+    BLUE = "\033[94m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    END = "\033[0m"
+
+
+def print_bold(text, color=None):
+    if color:
+        print(f"{PrintColor.BOLD}{color}{text}{PrintColor.END}")  # noqa: T201
+    else:
+        print(f"{PrintColor.BOLD}{text}{PrintColor.END}")  # noqa: T201
+
+
+def print_dict(dictionary):
+    print(highlight(json.dumps(dictionary, indent=4), JsonLexer(), TerminalFormatter()))  # noqa: T201

wbcore/utils/renderers.py

@@ -0,0 +1,13 @@
+from rest_framework.renderers import BrowsableAPIRenderer
+
+
+class BrowsableAPIRendererWithoutForms(BrowsableAPIRenderer):
+    """Renders the browsable api, but excludes the forms."""
+
+    def get_rendered_html_form(self, data, view, method, request):
+        """Why render _any_ forms at all. This method should return
+        rendered HTML, so let's simply return an empty string.
+        """
+        if method in ("DELETE", "OPTIONS"):
+            return True  # Don't actually need to return a form
+        return ""

wbcore/utils/rrules.py

@@ -0,0 +1,37 @@
+import calendar as calendar_reference
+from datetime import date
+
+from dateutil import rrule
+
+
+def convert_rrulestr_to_dict(
+    rrule_str: str, dtstart: date | None = None, count: int | None = None, until: date | None = None
+) -> dict:
+    kwargs = {
+        values[0]: values[1]
+        for elt in rrule_str.replace("RRULE:", "").split(";")
+        if (values := elt.split("=")) and len(values) == 2
+    }
+    rule_dict = {}
+    if freq := kwargs.get("FREQ"):
+        rule_dict = {
+            "freq": getattr(rrule, freq),
+            "interval": int(kwargs.get("INTERVAL", "1")),
+        }
+        if dtstart:
+            rule_dict["dtstart"] = dtstart
+        if count:
+            rule_dict["count"] = count
+        if until:
+            rule_dict["until"] = until
+        if wkst := kwargs.get("WKST"):
+            rule_dict["wkst"] = getattr(rrule, wkst)
+        if byday := kwargs.get("BYDAY"):
+            rule_dict["byweekday"] = [getattr(rrule, day.strip()) for day in byday.split(",")]
+    return rule_dict
+
+
+def convert_weekday_rrule_to_day_name(wkday: rrule.weekday) -> str:
+    week_dict = {_day: _day.weekday for _day in rrule.weekdays}
+    if idx := week_dict.get(wkday):
+        return calendar_reference.day_name[idx]

wbcore/utils/serializers.py

@@ -0,0 +1,8 @@
+import wbcore.serializers as wb_serializers
+from django.utils.translation import gettext_lazy as _
+from wbcore.utils.date import current_quarter_date_end, current_quarter_date_start
+
+
+class StartEndDateSerializer(wb_serializers.Serializer):
+    start = wb_serializers.DateField(label=_("Start"), default=current_quarter_date_start)
+    end = wb_serializers.DateField(label=_("End"), default=current_quarter_date_end)

wbcore/utils/settings.py

@@ -0,0 +1,5 @@
+def historical_models(historical_app_models):
+    models = list()
+    for app in historical_app_models:
+        models.extend(list(map(lambda model: f"{app[0]}.{model}", app[1])))
+    return models

wbcore/utils/signals.py

@@ -0,0 +1,36 @@
+from typing import Callable
+
+from django.db.models.signals import ModelSignal
+
+
+class SignalWrapper:
+    """A convenience class that encapsulates a signal in order to
+    be used in the DisconnectedSignals context manager
+    """
+
+    def __init__(self, signal: ModelSignal, receiver: Callable, sender, dispatch_uid: str | None = None):
+        self.signal = signal
+        self.receiver = receiver
+        self.sender = sender
+        self.dispatch_uid = dispatch_uid
+
+    def connect(self):
+        self.signal.connect(receiver=self.receiver, sender=self.sender, weak=False, dispatch_uid=self.dispatch_uid)
+
+    def disconnect(self):
+        self.signal.disconnect(receiver=self.receiver, sender=self.sender, dispatch_uid=self.dispatch_uid)
+
+
+class DisconnectSignals:
+    """A Context-Manager to temporarily disable a set of signals"""
+
+    def __init__(self, signals: list[SignalWrapper]):
+        self.signals = signals
+
+    def __enter__(self):
+        for signal in self.signals:
+            signal.disconnect()
+
+    def __exit__(self, type, value, traceback):
+        for signal in self.signals:
+            signal.connect()

wbcore/utils/string_loader.py

@@ -0,0 +1,42 @@
+import importlib.abc
+import importlib.machinery
+import sys
+from types import ModuleType
+
+
+class StringSourceLoader(importlib.abc.SourceLoader):
+    MOD_NAME = "__string_mod"
+
+    def __init__(self, data):
+        self.data = data.encode()
+
+    def get_data(self, path):
+        return self.data
+
+    def get_filename(self, fullname):
+        return "<string>"
+
+    def create_module(self, spec):
+        return ModuleType(spec.name)
+
+    def exec_module(self, module):
+        code = self.source_to_code(self.data, self.get_filename(module.__name__))
+        exec(code, module.__dict__)
+
+    def get_spec(self):
+        return importlib.machinery.ModuleSpec(self.MOD_NAME, self, origin=self.get_filename(self.MOD_NAME))
+
+    def register_module(self):
+        sys.modules[self.MOD_NAME] = importlib._bootstrap._load(self.get_spec())
+
+    def import_module(self):
+        return importlib.import_module(self.MOD_NAME)
+
+    def load_module(self):
+        self.register_module()
+        return self.import_module()
+
+    def cleanup(self):
+        del sys.modules[self.MOD_NAME]
+        if self.MOD_NAME in globals():
+            del globals()[self.MOD_NAME]

wbcore/utils/strings.py

@@ -0,0 +1,77 @@
+import json
+from functools import reduce
+
+
+def enumerated_string_join(array):
+    """Generates a human readable string out of a list"""
+
+    if len(array) > 0:
+        casted_array = [str(i) for i in array]
+        return (
+            " and ".join([", ".join(casted_array[:-1]), casted_array[-1]])
+            if len(casted_array) > 1
+            else casted_array[0]
+        )
+    return ""
+
+
+def format_number(number, decimal: int = 2, **kwargs):
+    """
+    utility function used to serialize an aggregate to a json compatible value
+    Args:
+        number: Number to serialize
+        **kwargs: backward compatibility keyword argument
+
+    Returns:
+
+    """
+    try:
+        return round(number, decimal)
+    except TypeError:
+        return None
+
+
+class ReferenceIDMixin:
+    @property
+    def reference_id(self):
+        return f"{self.id:06}"
+
+
+def convert_str_to_boolean(fake_bool: str | bool) -> bool:
+    """
+    Converts any bool or str to a boolean - can throw JSONDecodeError
+    """
+    return json.loads(str(fake_bool).lower())
+
+
+def snake_case_to_human(s: str) -> str:
+    words = s.split("_")
+    human_readable = " ".join(word.capitalize() for word in words)
+    return human_readable
+
+
+def camel_to_snake_case(s: str) -> str:
+    """
+    Convert a string as CamelCase to snake_case
+    """
+    return reduce(lambda x, y: x + ("_" if y.isupper() else "") + y, s).lower()
+
+
+def get_aggregate_symbol(aggregate: str) -> str:
+    match aggregate.lower():
+        case "avg":
+            return "μ"
+        case "count":
+            return "#"
+        case "max":
+            return "⋁"
+        case "min":
+            return "⋀"
+        case "stddev":
+            return "σ"
+        case "sum":
+            return "Σ"
+        case "variance":
+            return "σ2"
+        case _:
+            return aggregate

wbcore/utils/task.py

@@ -0,0 +1,6 @@
+from celery import shared_task
+
+
+@shared_task
+def save_as_task(obj):
+    obj.save()