wbcore 1.59.9__py2.py3-none-any.whl

wbcore/serializers/fields/fields.py

@@ -0,0 +1,193 @@
+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 StringRelatedField
+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:
+                    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):
+    field_type = WBCoreType.HYPERLINK.value
+
+    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=StringRelatedField, **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__(*args, read_only=read_only, **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,104 @@
+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 row is [] or null, we default to an empty list of list
+        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, strict=False)
+        return representation

wbcore/serializers/fields/mixins.py

@@ -0,0 +1,196 @@
+import logging
+from contextlib import suppress
+from typing import Any, ClassVar, Type
+
+from django.db.models.fields import NOT_PROVIDED
+from rest_framework.fields import empty
+from rest_framework.serializers import Field
+
+logger = logging.getLogger(__name__)
+
+
+def decorator(position: str, value: str, decorator_type: str = "icon") -> dict:
+    if position not in ("left", "right"):
+        raise ValueError("Decorator Position can only be right or left")
+    if decorator_type not in ("icon", "text"):
+        raise ValueError("Decorator Type can only be icon or text")
+    return {"position": position, "value": value, "type": decorator_type}
+
+
+class WBCoreSerializerFieldMixin:
+    """
+    A mixin that takes care of adding all the necessary magic to each implementation
+    of the serializer fields
+    """
+
+    def __init__(
+        self,
+        *args,
+        decorators=None,
+        depends_on=None,
+        math=None,
+        extra=None,
+        read_only=False,
+        copyable=None,
+        related_key=None,
+        on_unsatisfied_deps="read_only",
+        clear_dependent_fields=True,
+        **kwargs,
+    ):
+        if not decorators:
+            decorators = list()
+        if not depends_on:
+            depends_on = list()
+        self.extra = extra
+        self.decorators = decorators
+        self.depends_on = depends_on
+        self.math = math
+        self.copyable = copyable
+        # To satisfy DRF assertion, we detect if the readonly given is a callable and in that case, we consider the default read only attribute to be true
+        self._callable_read_only = None
+        if callable(read_only):
+            self._callable_read_only = read_only
+            read_only = True
+        self.related_key = related_key
+        self.on_unsatisfied_deps = on_unsatisfied_deps
+        self.clear_dependent_fields = clear_dependent_fields
+        super().__init__(*args, read_only=read_only, **kwargs)
+
+    def _evaluate_read_only(self, field_name, parent):
+        if self._callable_read_only:
+            # if view is present, we use it as parameter to the callable, otherwise we assume read_only is True
+            if view := self.view:
+                self.read_only = self._callable_read_only(view)
+            else:
+                self.read_only = True
+
+        if meta := getattr(parent, "Meta", None):
+            read_only_fields = getattr(meta, "read_only_fields", [])
+            # By default, DRF do not apply extra_kwargs to declared field, this leds to confusion in our codebase so we take the conscious decision to make read_only_fields take presence over declared field attribute
+            if field_name in read_only_fields:
+                self.read_only = True
+
+    def bind(self, field_name, parent):
+        super().bind(field_name, parent)
+        # After binding to the parent happens, we evaluate the callable readonly if given
+        self._evaluate_read_only(field_name, parent)
+
+    def get_related_key(self) -> str:
+        return self.related_key or self.source
+
+    @property
+    def view(self):
+        # Helper property to return the stored instantiated view in the context
+        return self.context.get(
+            "view",
+            getattr(self.context.get("request"), "parser_context", {}).get("view"),
+        )
+
+    def set_attr(self, attr, value):
+        setattr(self, attr, value)
+        self._kwargs[attr] = value
+
+    def append_depend_on(self, depend_on):
+        existing_fields = [elem["field"] for elem in self.depends_on]
+        if depend_on["field"] not in existing_fields:
+            self.depends_on.append(depend_on)
+            self._kwargs["depends_on"] = self.depends_on
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        if meta := getattr(self.parent, "Meta", None):
+            if field_name in getattr(meta, "required_fields", []):
+                self.required = True
+
+        representation = {
+            "key": field_name,
+            "label": getattr(self, "label", None),
+            "type": getattr(self, "field_type", "undefined"),
+            "required": getattr(self, "required", True),
+            "read_only": getattr(self, "read_only", False),
+        }
+
+        default = getattr(self, "default", None)
+        if default is None or default == empty or default == NOT_PROVIDED:
+            with suppress(Exception):  # TODO Add some explicit exception handling
+                default = self.parent.Meta.model._meta._forward_fields_map[field_name].default
+
+        if default is not None and default != empty and default != NOT_PROVIDED:
+            if callable(default):
+                if getattr(default, "requires_context", False):
+                    default = default(self)
+                else:
+                    default = default()
+            if default is not None:
+                representation["default"] = self.to_representation(default)
+
+        representation["decorators"] = getattr(self, "decorators", [])
+        representation["depends_on"] = getattr(self, "depends_on", [])
+
+        for _attr in ["help_text", "extra"]:
+            attr = getattr(self, _attr, None)
+            if attr:
+                representation[_attr] = attr
+
+        if self.math:
+            representation["math"] = self.math
+        if self.copyable:
+            representation["copyable"] = self.copyable
+        if self.on_unsatisfied_deps != "read_only":
+            representation["on_unsatisfied_deps"] = self.on_unsatisfied_deps
+        if self.clear_dependent_fields is not True:
+            representation["clear_dependent_fields"] = self.clear_dependent_fields
+        return field_name, representation
+
+    def validate_empty_values(self, data):
+        if isinstance(data, str) and data == "null":
+            data = None
+        return super().validate_empty_values(data)
+
+
+class RangeMixin(WBCoreSerializerFieldMixin, Field):
+    """
+    This mixin represents a range in the form of:
+    (value1,value2)
+
+    When using this mixin, you must supply the internal_field (usually the postgres wrapper) that converts the range tuple to some datastructure.
+    """
+
+    default_error_messages = {
+        "lower_gt_upper": "The upper bound must be greater than the lower bound.",
+    }
+    internal_field: ClassVar[Type]
+
+    def _transform_range(self, lower, upper, inward: bool | None = None):
+        return lower, upper
+
+    def to_internal_value(self, data) -> Any:
+        # If formdata is used, we need to separate the string into the range
+        if isinstance(data, str) and "," in data:
+            data = data.split(",")
+        lower = upper = None
+        if isinstance(data, list):
+            if len(data) > 0 and data[0]:
+                lower = super().to_internal_value(data[0])
+            if len(data) > 1 and data[1]:
+                upper = super().to_internal_value(data[1])
+        lower, upper = self._transform_range(lower, upper, inward=True)
+        if lower and upper and lower >= upper:
+            self.fail("lower_gt_upper")
+        return self.internal_field(lower, upper)
+
+    def to_representation(self, instance):
+        if hasattr(instance, "lower"):
+            lower = instance.lower
+        else:
+            lower = instance[0]
+
+        if hasattr(instance, "upper"):
+            upper = instance.upper
+        else:
+            upper = instance[1]
+        lower, upper = self._transform_range(lower, upper, inward=False)
+        with suppress(Exception):
+            lower = super().to_representation(lower)
+        with suppress(Exception):
+            upper = super().to_representation(upper)
+        return lower, upper

wbcore/serializers/fields/number.py

@@ -0,0 +1,94 @@
+from psycopg.types.range import NumericRange
+from rest_framework import serializers
+
+from .mixins import RangeMixin, WBCoreSerializerFieldMixin, decorator
+from .types import DisplayMode, WBCoreType
+
+percent_decorator = decorator(position="right", value="%", decorator_type="text")
+
+
+class NumberFieldMixin:
+    def __init__(
+        self,
+        *args,
+        percent=False,
+        display_mode=DisplayMode.DECIMAL,
+        precision=2,
+        signed: bool = True,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.percent = percent
+        self.disable_formatting = getattr(self, "disable_formatting", kwargs.pop("disable_formatting", False))
+        self.display_mode = display_mode
+        self.precision = kwargs.get("decimal_places", precision)
+        self.max_digits = kwargs.get("max_digits", 34)
+        self.signed = signed
+
+    def set_precision(self, precision):
+        self.precision = precision
+        self._kwargs["precision"] = self.precision
+
+    def set_percent(self, percent):
+        self.percent = percent
+        self._kwargs["percent"] = self.percent
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["display_mode"] = self.display_mode.value
+        representation["precision"] = self.precision
+        representation["max_digits"] = self.max_digits
+        representation["disable_formatting"] = self.disable_formatting
+        representation["signed"] = self.signed
+
+        if self.percent:  # TODO: Discuss with Christoph if this is necessary like this
+            representation["type"] = WBCoreType.PERCENT.value
+            representation["precision"] = self.precision - 2
+        return key, representation
+
+
+class IntegerField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.IntegerField):
+    field_type = WBCoreType.NUMBER.value
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.precision = 0
+
+
+class YearField(IntegerField):
+    disable_formatting = True
+
+
+class DecimalField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
+    field_type = WBCoreType.NUMBER.value
+
+    # TODO: If this is used, then the validation for max_digits and decimal_fields is not done
+    # def validate_precision(self, value):
+    #     return value
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        field_name, representation = super().get_representation(request, field_name)
+
+        if meta := getattr(self.parent, "Meta", None):
+            odp = getattr(meta, "override_decimal_places", None)
+            percent_fields = getattr(meta, "percent_fields", [])
+            if odp is not None and field_name not in percent_fields:
+                representation["precision"] = odp
+
+        return field_name, representation
+
+
+class FloatField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.FloatField):
+    field_type = WBCoreType.NUMBER.value
+
+
+class DecimalRangeField(RangeMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
+    field_type = WBCoreType.NUMBERRANGE.value
+    internal_field = NumericRange
+
+    def __init__(self, max_digits=None, decimal_places=None, **kwargs):
+        if not max_digits:
+            max_digits = 3
+        if not decimal_places:
+            decimal_places = 2
+        super().__init__(max_digits, decimal_places, **kwargs)