wbcore 2.2.1__py2.py3-none-any.whl

wbcore/serializers/fields/datetime.py

@@ -0,0 +1,143 @@
+from datetime import timedelta
+
+import pytz
+from psycopg.types.range import DateRange, TimestamptzRange
+from rest_framework import serializers
+from timezone_field.choices import standard, with_gmt_offset
+from timezone_field.rest_framework import TimeZoneSerializerField
+
+from .mixins import RangeMixin, WBCoreSerializerFieldMixin
+from .number import NumberFieldMixin
+from .types import WBCoreType
+
+
+class DateTimeField(WBCoreSerializerFieldMixin, serializers.DateTimeField):
+    field_type = WBCoreType.DATETIME.value
+
+
+class DateField(WBCoreSerializerFieldMixin, serializers.DateField):
+    field_type = WBCoreType.DATE.value
+
+
+class TimeField(WBCoreSerializerFieldMixin, serializers.TimeField):
+    field_type = WBCoreType.TIME.value
+
+
+class ShortcutMixin(WBCoreSerializerFieldMixin):
+    def __init__(self, shortcuts: list | None = None, *args, **kwargs):
+        self.shortcuts = shortcuts
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        if self.shortcuts is not None:
+            representation["shortcuts"] = self.shortcuts
+        return key, representation
+
+
+class DateRangeField(RangeMixin, ShortcutMixin, serializers.DateField):
+    field_type = WBCoreType.DATE.value
+    internal_field = DateRange
+
+    def __init__(self, *args, outward_bounds_transform="[)", inward_bounds_transform="[)", **kwargs):
+        self.outward_bounds_transform = outward_bounds_transform  # Allow to specify another bound representation than the default and used for db (]. If specified, will switch the range around to and from the serializer
+        self.inward_bounds_transform = inward_bounds_transform
+        if self.outward_bounds_transform not in ["[]", "[)", "()", "(]"]:
+            raise ValueError(f"Outward bound transform {self.outward_bounds_transform} is not a valid choice")
+        if self.inward_bounds_transform not in ["[]", "[)", "()", "(]"]:
+            raise ValueError(f"Inward bound transform {self.inward_bounds_transform} is not a valid choice")
+
+        super().__init__(*args, **kwargs)
+
+    def _transform_range(self, lower, upper, inward=False):
+        """
+        Private utility function that shift the range by one operator
+        Args:
+            lower: Lower bound
+            upper: Upper bound
+            inverse: If True, the transform is back to its original bound transform
+
+        Returns:
+            The shifted bound
+        """
+        bound_transform = self.inward_bounds_transform if inward else self.outward_bounds_transform
+        if lower and bound_transform[0] == "(":
+            lower = lower + timedelta(days=1) if inward else lower - timedelta(days=1)
+        if upper and bound_transform[1] == "]":
+            upper = upper + timedelta(days=1) if inward else upper - timedelta(days=1)
+        return lower, upper
+
+
+class DateTimeRangeField(RangeMixin, ShortcutMixin, serializers.DateTimeField):
+    field_type = WBCoreType.DATETIME.value
+    internal_field = TimestamptzRange
+
+    def __init__(self, *args, lower_time_choices=None, upper_time_choices=None, **kwargs):
+        self.lower_time_choices = lower_time_choices
+        if (
+            self.lower_time_choices
+            and not isinstance(self.lower_time_choices, list)
+            and not callable(self.lower_time_choices)
+        ):
+            raise ValueError("lower_time_choices can only be a static list or a callable.")
+        self.upper_time_choices = upper_time_choices
+        if (
+            self.upper_time_choices
+            and not isinstance(self.upper_time_choices, list)
+            and not callable(self.upper_time_choices)
+        ):
+            raise ValueError("upper_time_choices can only be a static list or a callable.")
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        if self.lower_time_choices is not None:
+            if callable(self.lower_time_choices):
+                representation["lower_time_choices"] = self.lower_time_choices(self, request)
+            else:
+                representation["lower_time_choices"] = self.lower_time_choices
+
+        if self.upper_time_choices is not None:
+            if callable(self.upper_time_choices):
+                representation["upper_time_choices"] = self.upper_time_choices(self, request)
+            else:
+                representation["upper_time_choices"] = self.upper_time_choices
+        if timezone := getattr(self, "timezone", None):
+            representation["timezone"] = str(timezone)
+        return key, representation
+
+
+class DurationField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DurationField):
+    field_type = WBCoreType.DURATION.value
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.precision = 0
+
+
+class TimeZoneField(WBCoreSerializerFieldMixin, TimeZoneSerializerField):
+    field_type = WBCoreType.SELECT.value
+
+    def __init__(self, choices=None, choices_display=None, *args, **kwargs):
+        if choices:
+            values, displays = zip(*choices)
+        else:
+            values = pytz.common_timezones
+            displays = None
+
+        if choices_display == "WITH_GMT_OFFSET":
+            choices = with_gmt_offset(values, use_pytz=self.use_pytz)
+        elif choices_display == "STANDARD":
+            choices = standard(values)
+        elif choices_display is None:
+            choices = zip(values, displays) if displays else standard(values)
+        else:
+            raise ValueError(f"Unrecognized value for kwarg 'choices_display' of '{choices_display}'")
+
+        self.choices = choices
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["choices"] = [{"value": k, "label": v} for k, v in self.choices]
+        return key, representation

wbcore/serializers/fields/fields.py

@@ -0,0 +1,190 @@
+import logging
+from inspect import getmembers
+
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from wbcore.metadata.utils import prefix_key
+from wbcore.signals import (
+    add_additional_resource,
+    add_dynamic_button,
+    add_instance_additional_resource,
+)
+from wbcore.utils.importlib import parse_signal_received_for_module
+
+from .mixins import WBCoreSerializerFieldMixin
+from .text import TextField
+from .types import WBCoreType
+
+logger = logging.getLogger(__name__)
+
+
+def register_resource():
+    def decorator(func):
+        func._is_additional_resource = True
+        return func
+
+    return decorator
+
+
+def register_only_instance_resource():
+    def decorator(func):
+        func._is_instance_additional_resource = True
+        return func
+
+    return decorator
+
+
+def _is_additional_resource(attr):
+    return hasattr(attr, "_is_additional_resource")
+
+
+def _is_instance_additional_resource(attr):
+    return hasattr(attr, "_is_instance_additional_resource")
+
+
+def register_dynamic_button():
+    def decorator(func):
+        func._is_dynamic_button = True
+        return func
+
+    return decorator
+
+
+def register_only_instance_dynamic_button():
+    def decorator(func):
+        func._is_instance_dynamic_button = True
+        return func
+
+    return decorator
+
+
+def _is_dynamic_button(attr):
+    return hasattr(attr, "_is_dynamic_button")
+
+
+def _is_instance_dynamic_button(attr):
+    return hasattr(attr, "_is_instance_dynamic_button")
+
+
+class DynamicButtonField(WBCoreSerializerFieldMixin, serializers.ReadOnlyField):
+    field_type = "_dynamic_buttons"
+
+    def get_attribute(self, instance):
+        return instance
+
+    def to_representation(self, value):
+        buttons = list()
+        if request := self.parent.context.get("request"):
+            for _, button_func in getmembers(self.parent.__class__, _is_dynamic_button):
+                btns = button_func(self.parent, instance=value, request=request, user=request.user)
+                buttons.extend([btn.serialize(request) for btn in btns])
+            dynamic_buttons = parse_signal_received_for_module(
+                add_dynamic_button.send(
+                    sender=self.parent.__class__,
+                    serializer=self.parent,
+                    instance=value,
+                    request=request,
+                    user=request.user,
+                    view=self.parent.context.get("view", None),
+                )
+            )
+            for prefix, btns in dynamic_buttons:
+                for btn in btns:
+                    setattr(btn, "prefix_key", prefix)
+                    buttons.append(btn.serialize(request))
+            if (view := self.parent.context.get("view", None)) and not (getattr(view, "action", "list") == "list"):
+                for _, button_func in getmembers(self.parent.__class__, _is_instance_dynamic_button):
+                    btns = button_func(self.parent, instance=value, request=request, user=request.user)
+                    buttons.extend([btn.serialize(request) for btn in btns])
+
+        return buttons
+
+
+class AdditionalResourcesField(WBCoreSerializerFieldMixin, serializers.ReadOnlyField):
+    field_type = "_additional_resources"
+
+    def get_attribute(self, instance):
+        return instance
+
+    @property
+    def serializer_class_for_remote_additional_resources(self):
+        return getattr(self.parent, "SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES", self.parent.__class__)
+
+    def to_representation(self, value):
+        resources = dict()
+        if (request := self.parent.context.get("request")) and (view := self.parent.context.get("view", None)):
+            for _, function in getmembers(self.parent.__class__, _is_additional_resource):
+                _d = function(self.parent, instance=value, request=request, user=request.user)
+                resources.update(_d)
+
+            is_list = getattr(view, "action", "list") == "list"
+            remote_resources = parse_signal_received_for_module(
+                add_additional_resource.send(
+                    sender=self.serializer_class_for_remote_additional_resources,
+                    serializer=self.parent,
+                    instance=value,
+                    request=request,
+                    user=request.user,
+                    view=view,
+                    is_list=is_list,
+                )
+            )
+            for prefix, response in remote_resources:
+                for key, remote_resource in response.items():
+                    resources[prefix_key(key, prefix)] = remote_resource
+            if not is_list:
+                for _, function in getmembers(self.parent.__class__, _is_instance_additional_resource):
+                    _d = function(self.parent, instance=value, request=request, user=request.user, view=view)
+                    resources.update(_d)
+                remote_resources = parse_signal_received_for_module(
+                    add_instance_additional_resource.send(
+                        sender=self.serializer_class_for_remote_additional_resources,
+                        serializer=self.parent,
+                        instance=value,
+                        request=request,
+                        user=request.user,
+                        view=view,
+                        is_list=False,
+                    )
+                )
+                for prefix, response in remote_resources:
+                    for key, remote_resource in response.items():
+                        resources[prefix_key(key, prefix)] = remote_resource
+        return resources
+
+
+class HyperlinkField(WBCoreSerializerFieldMixin, serializers.ReadOnlyField):
+    def __init__(self, *args, **kwargs):
+        self.reverse_name = kwargs.pop("reverse_name")
+        self.id_field_name = kwargs.pop("id_field_name", "id")
+        super().__init__(*args, **kwargs)
+
+    def get_attribute(self, obj):
+        request = self.context.get("request", None)
+        if obj:
+            obj_id = getattr(obj, self.id_field_name, obj.pk)
+            if request:
+                return reverse(self.reverse_name, args=[obj_id], request=request)
+            return reverse(self.reverse_name, args=[obj_id])
+
+
+class ReadOnlyField(WBCoreSerializerFieldMixin, serializers.ReadOnlyField):
+    field_type = WBCoreType.TEXT.value
+
+
+class SlugRelatedField(WBCoreSerializerFieldMixin, serializers.SlugRelatedField):
+    field_type = WBCoreType.TEXT.value
+
+
+class SerializerMethodField(WBCoreSerializerFieldMixin, serializers.SerializerMethodField):
+    def __init__(self, method_name=None, field_class=TextField, **kwargs):
+        self.field_class = field_class
+        self.initkwargs = kwargs
+        super().__init__(method_name, **kwargs)
+
+    def get_representation(self, request, field_name):
+        field_name, rep = super().get_representation(request, field_name)
+        field_name, field_rep = self.field_class(**self.initkwargs).get_representation(request, field_name)
+
+        rep.update(field_rep)
+        return field_name, rep

wbcore/serializers/fields/file.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class ImageField(WBCoreSerializerFieldMixin, serializers.ImageField):
+    field_type = WBCoreType.IMAGE.value
+
+
+class UnsafeImageField(WBCoreSerializerFieldMixin, serializers.FileField):
+    field_type = WBCoreType.IMAGE.value
+
+
+class ImageURLField(WBCoreSerializerFieldMixin, serializers.URLField):
+    field_type = WBCoreType.IMAGE.value
+
+
+class FileField(WBCoreSerializerFieldMixin, serializers.FileField):
+    field_type = WBCoreType.FILE.value

wbcore/serializers/fields/fsm.py

@@ -0,0 +1,20 @@
+from wbcore.serializers.fields.text import CharField
+
+
+# TODO: Color for each state
+class FSMStatusField(CharField):
+    field_type = "status"
+
+    def __init__(self, *args, **kwargs):
+        self.choices = kwargs.pop("choices")
+        read_only = kwargs.pop("read_only", True)
+        super().__init__(read_only=read_only, *args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["choices"] = list()
+
+        for choice in self.choices:
+            representation["choices"].append({"value": choice[0], "label": choice[1]})
+
+        return key, representation

wbcore/serializers/fields/json.py

@@ -0,0 +1,56 @@
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import ReturnContentType, WBCoreType
+
+
+class AbstractJSONField(serializers.JSONField):
+    def __init__(self, serializer_class=None, flatten_field_names=None, *args, **kwargs):
+        self.serializer_class = serializer_class
+        if isinstance(flatten_field_names, list):
+            self.flatten_field_names = flatten_field_names
+        super().__init__(*args, **kwargs)
+
+
+class JSONField(WBCoreSerializerFieldMixin, AbstractJSONField):
+    field_type = WBCoreType.JSON.value
+
+
+class JSONTableField(WBCoreSerializerFieldMixin, AbstractJSONField):
+    field_type = WBCoreType.JSONTABLE.value
+
+
+class JSONTextEditorField(WBCoreSerializerFieldMixin, serializers.JSONField):
+    field_type = WBCoreType.TEXTEDITOR.value
+    texteditor_content_type = ReturnContentType.JSON.value
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["content_type"] = self.texteditor_content_type
+        return key, representation
+
+
+class TemplatedJSONTextEditor(WBCoreSerializerFieldMixin, serializers.JSONField):
+    field_type = WBCoreType.TEMPLATED_TEXTEDITOR.value
+
+    def __init__(self, templates, default_editor_config=None, *args, **kwargs):
+        self.templates = templates
+        self.default_editor_config = default_editor_config
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+
+        if callable(self.templates):
+            representation["template_url"] = self.templates(request)
+        else:
+            representation["template_url"] = reverse(self.templates, request=request)
+
+        if self.default_editor_config:
+            if callable(self.default_editor_config):
+                representation["default_editor_config"] = self.default_editor_config(request)
+            else:
+                representation["default_editor_config"] = self.default_editor_config
+
+        return key, representation

wbcore/serializers/fields/list.py

@@ -0,0 +1,105 @@
+import enum
+
+from rest_framework import serializers
+from rest_framework.fields import empty
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class ListFieldMixin:
+    def get_attribute(self, instance):
+        # Can't have any relationships if not created
+        try:
+            return super().get_attribute(instance)
+
+        except (AttributeError, KeyError):
+            return []
+
+    def run_validation(self, data=empty):
+        # If the data is send through form data, we need to convert the data into a proper list of ids
+        if data not in [None, empty] and len(data) == 1 and isinstance(data[0], str) and "," in data[0]:
+            data = data[0].split(",")
+
+        # If the data is a list of an empty string we need to convert it (FORM DATA)
+        if data not in [None, empty] and len(data) == 1 and isinstance(data[0], str) and data[0] == "":
+            data = []
+
+        # If the data is a list and contains the string null, then we need to convert it (FORM DATA)
+        if data == ["null"]:
+            data = []
+
+        # If the data is None and null is an allowed value, data needs to be set to an empty list
+        if data is None and self.allow_null:
+            data = []
+        return super().run_validation(data)
+
+
+class ListField(ListFieldMixin, WBCoreSerializerFieldMixin, serializers.ListField):
+    field_type = WBCoreType.LIST.value
+
+
+class SparklineField(WBCoreSerializerFieldMixin, serializers.ListField):
+
+    """Readonly field to create a sparline representation from an annotated aggregated array
+
+    Important: This is potentially very slow, use accordingly
+
+    Example:
+        View:
+            def get_queryset(self):
+                return super().get_queryset().annotate(
+                    prices_date=ArrayAgg("prices__date", filter=Q(prices__date__gt="2023-03-01")),
+                    prices_price=ArrayAgg("prices__net_value", filter=Q(prices__date__gt="2023-03-01"))
+                )
+
+        Serializer:
+            prices_sparkline = wb_serializers.SparklineField(x_data_label="prices_date", y_data_label="prices_price")
+    """
+
+    field_type = WBCoreType.SPARKLINE.value
+
+    class Type(enum.Enum):
+        LINE = "line"
+        BAR = "bar"
+        COLUMN = "column"
+        AREA = "area"
+
+    def __init__(
+        self, *args, x_data_label=None, y_data_label=None, sparkline_type=Type.LINE, sparkline_option=None, **kwargs
+    ):
+        """
+        Args:
+            *args: based serializer positional argument
+            x_data_label: The field name as find in the serialized object representative the easting data
+            y_data_label: The field name as find in the serialized object representive the northing data
+            sparkline_type: Either one of LINE, BAR, COLUMN or AREA
+            sparkline_option: a json serializable dictionary representing additional option as allowed by ag-grid.
+            **kwargs:based serializer keyword argument
+        """
+        self.x_data_label = x_data_label
+        self.y_data_label = y_data_label
+        self.sparkline_type = sparkline_type
+        kwargs.pop("read_only", None)
+        if not sparkline_option:
+            sparkline_option = {}
+        self.sparkline_option = sparkline_option
+        super().__init__(*args, read_only=True, **kwargs)
+
+    def get_attribute(self, obj):
+        # We pass the object instance onto `to_representation`,
+        # not just the field attribute.
+        return obj
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["read_only"] = True
+        representation["sparkline_type"] = self.sparkline_type.value
+        representation["sparkline_option"] = self.sparkline_option
+        return key, representation
+
+    def to_representation(self, obj):
+        representation = {}
+        if (x_data := getattr(obj, self.x_data_label, None)) and (y_data := getattr(obj, self.y_data_label, None)):
+            representation = zip(x_data, y_data)
+        return representation