dynamicforms 0.76.14__py3-none-any.whl

dynamicforms/mixins/conditional_visibility.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Callable, Iterable, NamedTuple, Union
+
+
+class ConditionalVisibilityMixin(object):
+    def __init__(self, *args, conditional_visibility: Statement = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.conditional_visibility = conditional_visibility
+
+    def as_component_def(self) -> dict:
+        try:
+            res = super().as_component_def()  # noqa
+        except AttributeError:
+            res = dict()
+        res.update(dict(conditional_visibility=self.conditional_visibility.to_value()))
+        return res
+
+
+class Operators(IntEnum):
+    # Logic Operators
+    NOT = 0
+    OR = 1
+    AND = 2
+    XOR = 3
+    NAND = 4
+    NOR = 5
+
+    # Comparators
+    EQUALS = -1
+    NOT_EQUALS = -2
+    GT = -3
+    LT = -4
+    GE = -5
+    LE = -6
+    IN = -7
+    NOT_IN = -8
+    INCLUDES = -9
+    NOT_INCLUDES = -10
+
+
+LogicOperators = {
+    Operators.OR,
+    Operators.AND,
+    Operators.XOR,
+    Operators.NAND,
+    Operators.NOR,
+}
+
+Comparators = {
+    Operators.EQUALS,
+    Operators.NOT_EQUALS,
+    Operators.GT,
+    Operators.LT,
+    Operators.GE,
+    Operators.LE,
+    Operators.IN,
+    Operators.NOT_IN,
+    Operators.INCLUDES,
+    Operators.NOT_INCLUDES,
+}
+
+
+# Types
+FieldType = str
+
+
+class StatementType(NamedTuple):
+    statement_a: Union[FieldType, StatementType]
+    operator: Operators
+    statement_b: Union[any, StatementType]
+
+
+class Field(object):
+    """
+    Abstraction of field name. Object is used to make statements inline with comparison operators such as
+    equals,
+
+    Arguments:
+    :field_name: Name of a field to use comparison function on
+    """
+
+    def __init__(self, field_name: str):
+        self.field_name = field_name
+
+    def to_value(self) -> FieldType:
+        return self.field_name
+
+    def __eq__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.EQUALS, other)
+
+    def __gt__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.GT, other)
+
+    def __ge__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.GE, other)
+
+    def __le__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.LE, other)
+
+    def __lt__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.LT, other)
+
+    def __ne__(self, other: any) -> Statement:
+        return Statement(self.field_name, Operators.NOT_EQUALS, other)
+
+    def is_in(self, other: Union[Iterable, Callable]) -> Statement:
+        return Statement(self.field_name, Operators.IN, other)
+
+    def not_in(self, other: Union[Iterable, Callable]) -> Statement:
+        return Statement(self.field_name, Operators.NOT_IN, other)
+
+    def includes(self, other: Union[Iterable, Callable]) -> Statement:
+        return Statement(self.field_name, Operators.INCLUDES, other)
+
+    def not_includes(self, other: Union[Iterable, Callable]) -> Statement:
+        return Statement(self.field_name, Operators.NOT_INCLUDES, other)
+
+
+class Statement:
+    """
+    Statement represents a single statement in boolean algebra. Since boolean algebra statements are recursive,
+    one statement can be composed of multiple statements, statement can be of 2 different types. One is a comparison
+    on field value and the other is a composition of comparisons.
+
+    Names of init params can be decieving so please read the following documentation
+
+    Arguments:
+    :statement_a: Is either a nested statement [Statement] or a name of the field [str]
+    :operator: Type of common boolean algebra operators [LogicOperators] or comparison operator [Comparator]
+    :statement_b: Is either a nested statement [Statement] or a value to compare a field with [any]
+    """
+
+    def __init__(
+        self,
+        statement_a: Union[str, Statement, Callable],
+        operator: Operators,
+        statement_b: Union[any, Statement, Callable],
+    ):
+        self.statement_a = statement_a
+        self.operator = operator
+        self.statement_b = statement_b
+
+        self.validation()
+
+    def validation(self) -> None:
+        if self.operator in [Operators.IN, Operators.NOT_IN]:
+            if not isinstance(self.statement_b, Iterable) and not callable(self.statement_b):
+                raise ValueError(f"Operator IN expects an iterable value, got {self.statement_b}")
+
+        if self.operator == Operators.NOT:
+            # Not is a special case, since it only takes 1 argument
+            if self.statement_b is not None:
+                raise ValueError("Operator NOT expects only first statement, got also second statement")
+
+        if self.operator in LogicOperators:
+            if not (isinstance(self.statement_a, Statement) and isinstance(self.statement_b, Statement)):
+                raise ValueError(
+                    f"Logic operators expect Statement type variables,"
+                    f"got {type(self.statement_a)}, {type(self.statement_b)}"
+                )
+        else:
+            # We are using comparator
+            if isinstance(self.statement_a, Statement) and isinstance(self.statement_b, Statement):
+                raise ValueError("Comparators expect non Statement type variables")
+            if not isinstance(self.statement_a, str):
+                raise ValueError(f"Comparators expects first value to be string type, got {type(self.statement_a)}")
+
+    def __or__(self, other: Statement) -> Statement:
+        return Statement(self, Operators.OR, other)
+
+    def __and__(self, other: Statement):
+        return Statement(self, Operators.AND, other)
+
+    def __xor__(self, other: Statement):
+        return Statement(self, Operators.XOR, other)
+
+    def __neg__(self):
+        return Statement(self, Operators.NOT, None)
+
+    def to_value(self) -> StatementType:
+        statement_a = self.statement_a() if callable(self.statement_a) else self.statement_a
+        statement_b = self.statement_b() if callable(self.statement_b) else self.statement_b
+
+        if isinstance(statement_a, Statement) and isinstance(statement_b, Statement):
+            return StatementType(statement_a.to_value(), self.operator, statement_b.to_value())
+        return StatementType(statement_a, self.operator, statement_b)
+
+
+# Aliases for developer friendly experience
+F = Field
+S = Statement

dynamicforms/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/mixins/field_render.py

@@ -0,0 +1,209 @@
+import typing
+import uuid as uuid_module
+
+from enum import IntEnum
+from typing import Dict, Optional
+
+from rest_framework.fields import Field as DrfField
+from rest_framework.relations import PKOnlyObject
+
+if typing.TYPE_CHECKING:
+    from dynamicforms.mixins import DFField
+
+
+class DisplayMode(IntEnum):
+    """
+    The ways a field might be rendered (or not).
+
+    NOTE: This class has a copy in Vue component "df-table", so if you change here, the change needs to be
+          implemented there as well
+    """
+
+    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 FieldAlignment(IntEnum):
+    """
+    How field's contents should be aligned in their respective containers (table cell / input)
+
+    NOTE: This class has a copy in Vue component "df-table", so if you change here, the change needs to be
+          implemented there as well
+    """
+
+    LEFT = -1
+    CENTER = 0
+    RIGHT = 1
+    DECIMAL = 2  # Aligned on the decimal separator
+
+
+class FieldRenderMixin(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 = "",
+        alignment: FieldAlignment = FieldAlignment.LEFT,
+        render_params: Optional[Dict] = None,
+        **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 alignment: How field's contents should be aligned in their respective containers (table cell / input)
+        :param render_params: what widget to use for render and its parameters. Whatever you want that affects rendering
+        :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
+        self.alignment = alignment
+
+        # render_params need not only include form renderer and table formatting function. add anything you need!
+        render_params = render_params or {}
+        render_params.setdefault("form_component_name", "DInput")
+        render_params.setdefault("table", "df-tablecell-plaintext")
+        render_params.setdefault("input_type", "text")
+        render_params.setdefault("field_class", "form-control")
+        render_params.setdefault("container_class", "form-group")
+        self.render_params = render_params
+
+    # noinspection PyUnresolvedReferences,PyMethodMayBeStatic
+    def use_pk_only_optimization(self):
+        """
+        Overrides DRF RelatedField's method. If 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:
+        """
+        return False
+
+    # 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
+        """
+        check_for_none = value.pk if isinstance(value, PKOnlyObject) else value
+        if check_for_none is None:
+            value = None
+
+        if value is None:
+            # TODO: DRF excepts if value is None. However, if me have a field that redeclares its
+            #  to_representation, it now won't be called :(
+            return None
+        else:
+            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. override for your field
+
+        :param value: field value
+        :param row_data: data for entire row (for more complex renderers)
+        :return: rendered value for table view
+        """
+        return 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
+
+    def as_component_def(self: "DFField") -> dict:
+        try:
+            res = super().as_component_def()  # noqa
+        except AttributeError:
+            res = dict()
+        res.update(
+            dict(
+                uuid=str(self.uuid),
+                name=str(self.field_name),
+                label=str(self.label),
+                read_only=self.read_only,
+                table_classes=self.table_classes,
+                ordering=self.ordering(),
+                alignment=self.alignment.name.lower(),
+                visibility=dict(table=self.display_table.value, form=self.display_form.value),
+                render_params=self.render_params,
+                help_text=res.get("help_text", ""),
+                allow_null=self.allow_null,
+            )
+        )
+        if "base_template" in self.style and self.style["base_template"] == "textarea.html":
+            res["render_params"]["form"] = "TextArea"
+        if hasattr(self, "max_length"):
+            res["render_params"]["max_length"] = self.max_length
+        if hasattr(self, "min_length"):
+            res["render_params"]["min_length"] = self.min_length
+        return res

dynamicforms/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/mixins/help_text.py

@@ -0,0 +1,46 @@
+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)
+
+    def as_component_def(self) -> dict:
+        try:
+            res = super().as_component_def()  # noqa
+        except AttributeError:
+            res = dict()
+        res.update(dict(help_text=self.help_text))
+        return res

dynamicforms/mixins/implicit_hidden.py

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

dynamicforms/mixins/implicit_natural_date.py

@@ -0,0 +1,88 @@
+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 .field_render import FieldRenderMixin
+
+
+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 None:
+            return super().render_to_table(value, row_data)
+
+        if hasattr(self, "enforce_timezone"):
+            value = self.enforce_timezone(value)
+
+        if (output_format := getattr(self, "table_format", None)) 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(FieldRenderMixin, self).to_representation(value)  # Skip RenderMixin
+                setattr(self, "format", global_format)
+                return value or ""
+
+        return localize(value)
+
+
+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/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/mixins/password_field.py

@@ -0,0 +1,23 @@
+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):
+        from dynamicforms.mixins import DisplayMode
+
+        self._password_field = value
+        if value:
+            self.display_table = DisplayMode.SUPPRESS
+            self.style.update(input_type="password")
+            self.render_params["form_component_name"] = "DPassword"
+            self.render_params["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)