wbcore 1.59.9__py2.py3-none-any.whl

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/reportlab.py

@@ -0,0 +1,7 @@
+from reportlab.platypus import Paragraph as BaseParagraph
+
+
+class FormattedParagraph(BaseParagraph):
+    def __init__(self, text, *args, **kwargs):
+        text = text.replace("<br>", "<br/>")  # convert the HTML line break into a compatible XML line break tag
+        super().__init__(text, *args, **kwargs)

wbcore/utils/rrules.py

@@ -0,0 +1,82 @@
+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:
+    rule_dict = {
+        values[0].lower(): values[1]
+        for elt in rrule_str.replace("RRULE:", "").split(";")
+        if (values := elt.split("=")) and len(values) == 2
+    }
+    rule_dict["interval"] = int(rule_dict.get("interval", "1"))
+    if setpos_str := rule_dict.get("bysetpos", None):
+        rule_dict["bysetpos"] = int(setpos_str)
+    if freq := rule_dict.get("freq", None):
+        rule_dict["freq"] = getattr(rrule, freq)
+    if wkst := rule_dict.get("wkst", None):
+        rule_dict["wkst"] = getattr(rrule, wkst)
+    if byday := rule_dict.pop("byday", None):
+        rule_dict["byweekday"] = [getattr(rrule, day.strip()) for day in byday.split(",")]
+    if bymonthday := rule_dict.pop("bymonthday", None):
+        rule_dict["bymonthday"] = [int(v) for v in bymonthday.split(",")]
+    if dtstart:
+        rule_dict["dtstart"] = dtstart
+    if count:
+        rule_dict["count"] = count
+    if until:
+        rule_dict["until"] = until
+    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]
+
+
+def humanize_rrule(rrule_str: rrule) -> str:
+    """
+    Utility function to humanize a frequence based rrule.
+
+    Args:
+        rrule_str: The RRULE object
+
+    Returns:
+        A humanized version of the rrule
+    """
+    if rrule_str._freq is None:
+        raise ValueError("We do no support humanization of rrule without frequency yet")
+    text = "Every "
+    freq = rrule.FREQNAMES[rrule_str._freq]
+    if rrule_str._interval and rrule_str._interval != 1:
+        text += f"{rrule_str._interval} "
+    match freq:
+        case "MONTHLY":
+            text += "Month "
+        case "WEEKLY":
+            text += "Week "
+        case "DAILY":
+            text += "Day "
+        case "YEARLY":
+            text += "Year "
+        case "HOURLY":
+            text += "Hour "
+        case "MINUTELY":
+            text += "Minute "
+        case "SECONDLY":
+            text += "Second "
+    if rrule_str._dtstart:
+        text += f"From {rrule_str._dtstart:%Y-%m-%d} "
+
+    max_occurrence_text = []
+    if rrule_str._count and rrule_str._count != 1:
+        max_occurrence_text.append(f"Max {rrule_str._count} times")
+    if rrule_str._until:
+        max_occurrence_text.append(f"until {rrule_str._until:%Y-%m-%d}")
+    if max_occurrence_text:
+        text += f'({"/".join(max_occurrence_text)})'
+    return text

wbcore/utils/serializers.py

@@ -0,0 +1,9 @@
+from django.utils.translation import gettext_lazy as _
+
+import wbcore.serializers as wb_serializers
+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__)  # noqa: S102
+
+    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) -> float | str:
+    """
+    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 float(round(number, decimal))
+    except TypeError:
+        return ""
+
+
+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/urls.py

@@ -0,0 +1,70 @@
+import urllib.parse
+from typing import Dict, Tuple
+
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.http.request import QueryDict
+from django.utils.http import urlencode
+
+
+def clean_shareable_url(url):
+    endpoint = url.split("?widget_endpoint=")[-1]
+    parse_url = urllib.parse.urlsplit(urllib.parse.unquote(endpoint))
+    endpoint = parse_url.path
+    if params := dict(urllib.parse.parse_qsl(parse_url.query)):
+        params_repr = "&".join([f"{k}={v}" for k, v in params.items()])
+        endpoint += f"?{params_repr}"
+    return endpoint
+
+
+def get_parse_endpoint(endpoint: str) -> Tuple[str, Dict[str, str]]:
+    """
+    Takes a URL endpoint and outputs the path and the params separately.
+
+    Parameters
+    ----------
+    endpoint: The endpoint string
+
+    Returns
+    -------
+    Returns a tuple in the form of (path: str, params: dict[str, str]). Where path is the url and params are the parameters of the endpoint.
+    """
+
+    path = urllib.parse.urljoin(endpoint, urllib.parse.urlparse(endpoint).path)
+    params = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(endpoint).query))
+    return path, params
+
+
+def get_urlencode_endpoint(endpoint: str, params: Dict[str, str]) -> str:
+    """
+    Takes a URL path and params and creates an endpoint from it.
+
+    Parameters
+    ----------
+    endpoint: The URL string
+    params: The params dictonary
+
+    Returns
+    -------
+    Returns an endpoint string with the params attached.
+    """
+    if isinstance(params, QueryDict):
+        params = params.dict()
+    return f"{endpoint}?{urlencode(params)}"
+
+
+def base_domain() -> str:
+    """A utility method that assembles the current domain. Utilizes the site app from django
+
+    Returns:
+        A string containing the current domain as noted in the curret `Site` prefixed with the http scheme
+
+    """
+    scheme = "https" if settings.SECURE_SSL_REDIRECT else "http"
+    base_domain = Site.objects.get_current().domain
+    return f"{scheme}://{base_domain}"
+
+
+def new_mode(url: str) -> str:
+    operator = "&" if "?" in url else "?"
+    return url + f"{operator}new_mode=true"