dynamicforms 0.76.14__py3-none-any.whl

dynamicforms_legacy/filters.py

@@ -0,0 +1,44 @@
+import django_filters.rest_framework as filters
+
+
+class ListWithFields(list):
+    def __init__(self, fields, lst) -> None:
+        super().__init__()
+        self.fields = fields
+        self.extend(lst)
+
+
+class FilterBackend(filters.DjangoFilterBackend):
+    """
+    Our own FilterBackend that also tries to read order from the pagination class's ordering field
+    """
+
+    def get_filterset_class(self, view, queryset=None):
+        # here we look for any pagination class and its ordering attribute. if there is none, we sort by id
+        __paginator_ordering = getattr(getattr(view, "pagination_class", 0), "ordering", ["id"])
+        if isinstance(__paginator_ordering, str):
+            __paginator_ordering = [__paginator_ordering]
+
+        ordering_excluded_fields = getattr(view, "filterset_ordering_exclude", [])
+        ordering_default = getattr(view, "filterset_ordering_default", __paginator_ordering)
+
+        class MyOrderingFilter(filters.OrderingFilter):
+            def get_ordering(self, value):
+                if not value:
+                    return ListWithFields(list(self.param_map.keys()), ordering_default)
+                return ListWithFields(list(self.param_map.keys()), [self.get_ordering_value(param) for param in value])
+
+        class FilterSetApplied(filters.FilterSet):
+            ordering = MyOrderingFilter(
+                fields=[f.name for f in queryset.model._meta.fields if f.name not in ordering_excluded_fields]
+            )
+
+        return FilterSetApplied
+
+    def get_ordering(self, request, queryset, view):
+        filterset = self.get_filterset(request, queryset, view)
+        filterset.is_valid()
+        ordering_filters = {k: v for k, v in filterset.filters.items() if isinstance(v, filters.OrderingFilter)}
+        for name, value in filterset.form.cleaned_data.items():
+            if name in ordering_filters:
+                return ordering_filters[name].get_ordering(value)

dynamicforms_legacy/mixins/__init__.py

@@ -0,0 +1,16 @@
+# flake8: noqa
+
+from .action import ActionMixin
+from .allow_tags import AllowTagsMixin
+from .enable_copy import EnableCopyMixin
+from .file_field import FileFieldMixin
+from .help_text import FieldHelpTextMixin
+from .implicit_hidden import HiddenFieldMixin
+from .implicit_natural_date import DateFieldMixin, DateTimeFieldMixin, TimeFieldMixin
+from .null_choice import NullChoiceMixin
+from .null_value import NullValueMixin
+from .password_field import PasswordFieldMixin
+from .related_field_ajax import RelatedFieldAJAXMixin
+from .render import DisplayMode, RenderMixin
+from .rtf_field import RTFFieldMixin
+from .single_choice import SingleChoiceMixin

dynamicforms_legacy/mixins/action.py

@@ -0,0 +1,14 @@
+from dynamicforms_legacy.action import Actions
+
+
+class ActionMixin(object):
+    """
+    Used in fields allowing declaration of actions that happen when field values change
+    """
+
+    def __init__(self, *args, actions: Actions = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        act = actions or Actions(None)
+        act.actions.extend(getattr(self, "actions", Actions()).actions)
+        # Obtain a personalised list of actions
+        self.actions = act.get_resolved_copy(self)

dynamicforms_legacy/mixins/allow_tags.py

@@ -0,0 +1,85 @@
+# TODO: Implementation of this mixin is wrong for ChoiceField (single choice variant):
+#  The ChoiceField will return data in an array even for (Single)ChoiceField. Select2 handles this, maybe even requires
+#  this, but some other component might not
+import ast
+
+from rest_framework.fields import ChoiceField, MultipleChoiceField
+
+
+class DenormalisedArray(list):
+    def __init__(self, lst, field):
+        self.field = field
+        if lst is not None and isinstance(lst, str) and isinstance(field, MultipleChoiceField):
+            for itm in ast.literal_eval(lst):
+                self.append(itm)
+
+        elif lst is not None and isinstance(lst, list):
+            for itm in lst:
+                self.append(itm)
+
+        elif lst is not None:
+            self.append(lst)
+
+    def __str__(self):
+        choices = self.field.choices
+        ret = ""
+        count = 0
+        for item in self:
+            ret += ", " if count else ""
+            if item in choices:
+                ret += choices[item]
+            else:
+                ret += item
+            count += 1
+        return ret
+
+
+class AllowTagsMixin(object):
+    def __init__(self, *args, allow_tags=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.allow_tags = allow_tags or False
+
+    def to_internal_value(self, data):
+        """
+        Validator is taken directly from DRF and updated, to check for allow_tags.
+        Option allow_tags enables adding value that is not on the options list.
+        """
+        if not self.allow_tags:
+            data = super().to_internal_value(data)
+
+        if isinstance(self, MultipleChoiceField):
+            if isinstance(data, str) or not hasattr(data, "__iter__"):
+                self.fail("not_a_list", input_type=type(data).__name__)
+            if not self.allow_empty and len(data) == 0:
+                self.fail("empty")
+
+            return data
+
+        elif isinstance(self, ChoiceField) and not isinstance(self, MultipleChoiceField):
+            if data == "" and self.allow_blank:
+                return ""
+
+            try:
+                if not self.allow_tags:
+                    return self.choice_strings_to_values[str(data)]
+
+                return data
+            except KeyError:
+                self.fail("invalid_choice", input=data)
+
+    def to_representation(self, value, row_data=None):
+        if isinstance(self, ChoiceField) and self.allow_tags and value:
+            return DenormalisedArray(value, self)
+
+        return super().to_representation(value, row_data)
+
+    def iter_options_bound(self, value):
+        # noinspection PyUnresolvedReferences
+        if isinstance(value, list):
+            for item in value:
+                if item not in self.choices.keys():
+                    self.grouped_choices[item] = item
+        elif isinstance(value, str) and self.allow_tags and value not in self.choices.keys():
+            self.grouped_choices[value] = value
+
+        return super().iter_options_bound(value)

dynamicforms_legacy/mixins/enable_copy.py

@@ -0,0 +1,4 @@
+class EnableCopyMixin(object):
+    def __init__(self, *args, enable_copy=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.enable_copy = enable_copy or False

dynamicforms_legacy/mixins/file_field.py

@@ -0,0 +1,5 @@
+class FileFieldMixin(object):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        # noinspection PyUnresolvedReferences
+        self.style.setdefault("no_filter", True)

dynamicforms_legacy/mixins/help_text.py

@@ -0,0 +1,38 @@
+from typing import Optional, Union
+
+
+class FieldHelpTextMixin(object):
+    """
+    Redefines help_text property such that we can set help text for api docs and form help text
+    """
+
+    def __init__(
+        self, *args, help_text: Union[str, dict, None] = None, help_text_form: Optional[str] = None, **kwargs
+    ) -> None:
+        super().__init__(*args, help_text=help_text, **kwargs)
+        self.help_text = help_text
+        if help_text_form or not isinstance(help_text, dict):
+            self._help_text_form = help_text_form or self.help_text
+
+    def get_help_text(self):
+        return self._help_text
+
+    def set_help_text(self, value):
+        if isinstance(value, dict):
+            self._help_text = value.get("doc", None)
+            self._help_text_form = value.get("form", None)
+        else:
+            self._help_text = value
+            self._help_text_form = getattr(self, "_help_text_form", None) or value
+
+    def get_help_text_form(self):
+        return self._help_text_form
+
+    def set_help_text_form(self, value):
+        if isinstance(value, dict):
+            self._help_text = value.get("form", None)
+        else:
+            self._help_text_form = value
+
+    help_text = property(get_help_text, set_help_text)
+    help_text_form = property(get_help_text_form, set_help_text_form)

dynamicforms_legacy/mixins/implicit_hidden.py

@@ -0,0 +1,7 @@
+from .render import DisplayMode, RenderMixin
+
+
+class HiddenFieldMixin(RenderMixin):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("display_table", DisplayMode.SUPPRESS)
+        super().__init__(*args, **kwargs)

dynamicforms_legacy/mixins/implicit_natural_date.py

@@ -0,0 +1,86 @@
+import re
+
+from datetime import datetime
+
+from django.utils import timezone
+from django.utils.formats import localize
+from rest_framework.fields import DateField, TimeField
+
+from .render import RenderMixin
+
+
+class NaturalDateTimeMixin(object):
+    """
+    Used for rendering datetime in human natural style (e.g.: 1 hour, 10 minutes ago)
+    """
+
+    def __init__(self, *args, table_format: str = "", **kwargs) -> None:
+        """
+
+        :param args:
+        :param table_format: Format for datetime rendering in table (non editable). If format is %N:{precision},
+            datetime will render in natural style with {precision} depth
+        :param kwargs:
+        """
+        super().__init__(*args, **kwargs)
+        self.table_format = table_format
+
+    # noinspection PyUnresolvedReferences
+    def render_to_table(self, value, row_data):
+        if value is not None:
+            output_format = getattr(self, "table_format", None)
+            if output_format is not None:
+                if re.match(r"%N:\d+", output_format):
+                    imported = False
+                    try:
+                        # This library (will-natural) is used because is the only one we could find that adds text
+                        # saying when is this datetime ("ago" or "from now") and have the possibility to set max
+                        # precision
+
+                        # noinspection PyPackageRequirements
+                        from natural.date import duration
+
+                        imported = True
+                    except:
+                        print("Install library for natural presentation of date (pip install will-natural)")
+
+                    if imported:
+                        if isinstance(self, DateField):
+                            now = timezone.now().date()
+                        elif isinstance(self, TimeField):
+                            now = datetime.now()
+                            value = datetime.now().replace(
+                                hour=value.hour, minute=value.minute, second=value.second, microsecond=value.microsecond
+                            )
+                        else:
+                            now = timezone.now()
+
+                        # noinspection PyUnboundLocalVariable
+                        return duration(value, now=now, precision=int(output_format.split(":")[1]))
+                else:
+                    # Invoke DRF field's to_representation
+                    global_format = getattr(self, "format", None)
+                    setattr(self, "format", output_format)
+                    # noinspection PySuperArguments
+                    value = super(RenderMixin, self).to_representation(value)  # Skip RenderMixin
+                    setattr(self, "format", global_format)
+                    return value or ""
+
+            return localize(value)
+
+        return super().render_to_table(value, row_data)
+
+
+class TimeFieldMixin(NaturalDateTimeMixin):
+    def __init__(self, *args, table_format: str = None, **kwargs) -> None:
+        super().__init__(*args, table_format=table_format, **kwargs)
+
+
+class DateFieldMixin(NaturalDateTimeMixin):
+    def __init__(self, *args, table_format: str = None, **kwargs) -> None:
+        super().__init__(*args, table_format=table_format, **kwargs)
+
+
+class DateTimeFieldMixin(NaturalDateTimeMixin):
+    def __init__(self, *args, table_format: str = None, **kwargs) -> None:
+        super().__init__(*args, table_format=table_format, **kwargs)

dynamicforms_legacy/mixins/null_choice.py

@@ -0,0 +1,26 @@
+from rest_framework.fields import ChoiceField
+
+
+class NullChoiceMixin(object):
+    """
+    Declaring ChoiceField's null_choice_text
+      (what should be rendered for "no selection"; DRF's default is ---------)
+      We also support user declaring a choice with None value and a different text (see hidden fields example)
+    """
+
+    @property
+    def null_choice_text(self):
+        res = "--------"
+        if isinstance(self, ChoiceField) and not getattr(self, "get_queryset", None):
+            # Only do this for true ChoiceFields. RelatedFields would run a query here
+            # Possibly we will at some point have to enable this for relatedfields too
+            for opt in self.iter_options():
+                if opt.start_option_group or opt.end_option_group:
+                    pass
+                elif opt.value is None:
+                    res = opt.display_text
+        return res
+
+    def iter_options_bound(self, value):
+        # noinspection PyUnresolvedReferences
+        return super().iter_options()

dynamicforms_legacy/mixins/null_value.py

@@ -0,0 +1,15 @@
+from rest_framework.fields import IntegerField
+
+
+class NullValueMixin(object):
+    def to_internal_value(self, data):
+        if data == "" and self.allow_null:
+            self.validators = []
+            return None
+        return super().to_internal_value(data)
+
+    def to_representation(self, value, row_data=None):
+        if value is None and self.allow_null and not isinstance(self, IntegerField):
+            value = ""
+
+        return super().to_representation(value, row_data)

dynamicforms_legacy/mixins/password_field.py

@@ -0,0 +1,19 @@
+class PasswordFieldMixin(object):
+    def __init__(self, *args, password_field=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.password_field = password_field
+
+    def set_password_field(self, value):
+        self._password_field = value
+        if value:
+            self.display_table = "DisplayMode.SUPRESS"
+            self.style.update(input_type="password")
+        else:
+            try:
+                self.style["input_type"]
+                self.style.update(input_type="text")
+                self.display_table = "DisplayMode.FULL"
+            except:
+                pass
+
+    password_field = property(lambda self: self._password_field, set_password_field)

dynamicforms_legacy/mixins/related_field_ajax.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+
+class RelatedFieldAJAXMixin(object):
+    def __init__(
+        self,
+        *args,
+        url_reverse: Optional[str] = None,
+        placeholder: Optional[str] = None,
+        additional_parameters: Optional[dict] = None,
+        query_field: str = "query",
+        value_field: str = "choice_id",
+        text_field: str = "choice_text",
+        **kwargs
+    ):
+        """
+        Allows us to use AJAX to populate select2 options instead of pre-populating at render time
+
+        :param args:
+        :param url_reverse: reverse url to ViewSet providing the JSON data
+        :param placeholder: select2 placeholder to display until user selects a value
+        :param additional_parameters: additional parameters to be sent to ViewSet as part of the query
+        :param query_field: field against which user search will be performed
+        :param kwargs:
+        """
+        super().__init__(*args, **kwargs)
+        self.url_reverse = url_reverse
+        self.placeholder = placeholder
+        self.additional_parameters = additional_parameters
+        self.query_field = query_field
+        self.value_field = value_field
+        self.text_field = text_field
+
+    @property
+    def additional_parameters_urlencoded(self):
+        from django.utils.http import urlencode
+
+        return "?" + urlencode(self.additional_parameters)
+
+    # noinspection PyUnresolvedReferences
+    def iter_options_bound(self, value):
+        if self.url_reverse:
+            if value is None:
+                return [dict(value="", display_text=self.placeholder)]
+            try:
+                if hasattr(self, "child_relation"):
+                    itm = self.child_relation
+                    qry = itm.get_queryset()
+                    qry = qry.filter(pk__in=value)
+                else:
+                    itm = self
+                    qry = self.get_queryset()
+                    qry = qry.filter(pk=value)
+
+                return [dict(value=rec.id, display_text=itm.display_value(rec)) for rec in qry.all()]
+            except:
+                return []
+        return super().iter_options()

dynamicforms_legacy/mixins/render.py

@@ -0,0 +1,203 @@
+import uuid as uuid_module
+
+from enum import IntEnum
+from typing import Hashable
+
+from rest_framework.fields import Field as DrfField
+from rest_framework.relations import ManyRelatedField, PKOnlyObject, RelatedField
+from rest_framework.serializers import ListSerializer
+from rest_framework.templatetags import rest_framework as drftt
+
+from dynamicforms_legacy.settings import DYNAMICFORMS
+
+
+class DisplayMode(IntEnum):
+    SUPPRESS = 1  # Field will be entirely suppressed. it will not render (not even to JSON) and will not parse for PUT
+    HIDDEN = 5  # Field will render as <input type="hidden"> or <tr data-field_name>
+    INVISIBLE = 8  # Field will render completely, but with display: none. Equal to setting its style = {display: none}
+    FULL = 10  # Field will render completely
+
+
+class RenderMixin(object):
+    """
+    Is used in fields and serializers, so every field and serializer gets its unique id. Also to specify where and how
+    fields should render.
+
+    In form where serializer is used, id is serializers uuid. Table with list of records has id »list-serializer.uuid«,
+    in dialog id is »dialog-{serializer.uuid}« and save button's id on dialog is »save-{serializer.uuid}«
+
+    Similar for fields: All inputs in HTML get id from field.uuid. Div that contains all that belongs to the field has
+    »container-{field.uuid}« for id, label has »label-{field.uuid}« and help text (if exists) has »help-{field.uuid}«
+    for id.
+
+    Used for rendering individual field to table view
+    """
+
+    def __init__(
+        self,
+        *args,
+        uuid: uuid_module.UUID = None,
+        display: DisplayMode = None,  # None == Leave at default
+        display_table: DisplayMode = None,  # None == Leave at default
+        display_form: DisplayMode = None,  # None == Leave at default
+        table_classes: str = "",
+        **kwargs
+    ):
+        """
+
+        :param args: passed on to inherited constructors
+        :param uuid: custom specified field UUID. if not specified, it will be assigned automatically
+        :param display: see DisplayMode enum. Specifies how field will render. Leave at None for default (FULL)
+            display_form and display_table also accepted for better granularity
+        :param table_classes: css classes to add to the table column
+        :param kwargs: passed on to inherited constructors
+        """
+        super().__init__(*args, **kwargs)
+        self.uuid = uuid or uuid_module.uuid1()
+        # noinspection PyUnresolvedReferences
+        self.display_table = (
+            display_table
+            or display
+            or (DisplayMode.FULL if not getattr(self, "write_only", False) else DisplayMode.SUPPRESS)
+        )
+        self.display_form = display_form or display or DisplayMode.FULL
+        self.table_classes = table_classes
+
+    @property
+    def is_rendering_to_list(self):
+        """
+        reports whether we are currently rendering to table or to single record
+        :return:
+        """
+        try:
+            # noinspection PyUnresolvedReferences
+            base = self.parent
+            while base:
+                if isinstance(base, ListSerializer):
+                    # If fields parent's parent is the ListSerializer, we're rendering to list
+                    return True
+                base = base.parent
+        except:
+            pass
+        return False
+
+    @property
+    def is_rendering_to_html(self):
+        try:
+            # noinspection PyUnresolvedReferences
+            return self.context["format"] == "html"
+        except:
+            pass
+        return False
+
+    # noinspection PyUnresolvedReferences
+    def use_pk_only_optimization(self):
+        """
+        Overrides DRF RelatedField's method. It True is returned then value passed for serialisation will be PK value
+        only, not entire relation object. we don't want that because then we can't resolve the value into something more
+        human-readable
+        :return:
+        """
+        if self.is_rendering_to_list and self.is_rendering_to_html:
+            return False
+        return super().use_pk_only_optimization()
+
+    # noinspection PyUnresolvedReferences
+    def to_representation(self, value, row_data=None):
+        """
+        Overrides DRF Field's to_representation.
+        Note that this is also called for the entire record as well as the serializer also is a Field descendant
+        :param value: value to serialize
+        :param row_data: instance with row data
+        :return: serialized value
+        """
+        if self.is_rendering_to_list and self.is_rendering_to_html and self.display_table != DisplayMode.HIDDEN:
+            # if rentering to html table, let's try to resolve any lookups
+            # hidden fields will render to tr data-field_name attributes, so we maybe want to have ids, not text there
+            #   we have discussed alternatives but decided that right now a more complete solution is not needed
+            return self.render_to_table(value, row_data)
+
+        check_for_none = value.pk if isinstance(value, PKOnlyObject) else value
+        if check_for_none is None:
+            return None
+
+        return super().to_representation(value)
+
+    def set_display(self, value):
+        if isinstance(value, tuple):
+            self.display_form, self.display_table = value
+        else:
+            self.display_form = self.display_table = value
+
+    display = property(lambda self: self.display_form, set_display)
+
+    # noinspection PyUnusedLocal, PyUnresolvedReferences
+    def render_to_table(self, value, row_data):
+        """
+        Renders field value for table view
+
+        :param value: field value
+        :param row_data: data for entire row (for more complex renderers)
+        :return: rendered value for table view
+        """
+        get_queryset = getattr(self, "get_queryset", None)
+
+        if isinstance(self, ManyRelatedField):
+            # Hm, not sure if this is the final thing to do: an example of this field is in
+            # ALC plane editor (modes of takeoff). However, value is a queryset here. There seem to still be DB queries
+            # However, in the example I have, the problem is solved by doing prefetch_related on the m2m relation
+            cr = self.child_relation
+            return ", ".join((cr.display_value(item) for item in value))
+            # return ', '.join((cr.display_value(item) for item in cr.get_queryset().filter(pk__in=value)))
+        elif isinstance(self, RelatedField) or get_queryset:
+            return self.display_value(value)
+        else:
+            choices = getattr(self, "choices", {})
+
+        # Now that we got our choices for related & choice fields, let's first get the value as it would be by DRF
+        check_for_none = value.pk if isinstance(value, PKOnlyObject) else value
+        if check_for_none is None:
+            value = None
+        else:
+            value = super().to_representation(value)
+
+        if isinstance(value, Hashable) and value in choices:
+            # choice field: let's render display names, not values
+            value = choices[value]
+        if value is None:
+            return DYNAMICFORMS.null_text_table
+
+        return drftt.format_value(value)
+
+    def validate_empty_values(self: DrfField, data):
+        # noinspection PyUnresolvedReferences
+        res = super().validate_empty_values(data)
+
+        # This is to fix a problem with calculated fields which was only solved in DRF 3.10.
+        # Forces validation and inclusion of the field into validated data. See comment in original function.
+        if res == (True, None) and data is None and self.source == "*":
+            return False, None
+        return res
+
+    def ordering(self):
+        ordering = []
+        if hasattr(self, "context") and "view" in getattr(self, "context"):
+            ordering = getattr(self.context["view"], "ordering", None)
+
+        if getattr(self, "field_name") not in getattr(ordering, "fields", []):
+            return ""
+
+        index = -1
+        direction_asc = True
+        for idx, o in enumerate(ordering):
+            if o.startswith("-"):
+                direction_asc = False
+                o = o[1:]
+            if o == getattr(self, "field_name"):
+                index = idx
+
+        if index > -1:
+            direction_class = ("asc" if direction_asc else "desc") + " seg-%d" % (index + 1)
+        else:
+            direction_class = "unsorted"
+        return "ordering " + direction_class