django-unfold 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

unfold/contrib/forms/widgets.py

@@ -1,7 +1,10 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from django.forms import Widget
-from unfold.widgets import PROSE_CLASSES
+from django.core.validators import EMPTY_VALUES
+from django.forms import MultiWidget, Widget
+from django.http import QueryDict
+from django.utils.datastructures import MultiValueDict
+from unfold.widgets import PROSE_CLASSES, UnfoldAdminTextInputWidget
 
 WYSIWYG_CLASSES = [
     *PROSE_CLASSES,
@@ -22,6 +25,58 @@ WYSIWYG_CLASSES = [
 ]
 
 
+class ArrayWidget(MultiWidget):
+    template_name = "unfold/forms/array.html"
+    widget_class = UnfoldAdminTextInputWidget
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        widgets = [self.widget_class]
+        super().__init__(widgets)
+
+    def get_context(self, name: str, value: str, attrs: Dict) -> Dict:
+        self._resolve_widgets(value)
+        context = super().get_context(name, value, attrs)
+        template_widget = UnfoldAdminTextInputWidget()
+        template_widget.name = name
+
+        context.update({"template": template_widget})
+        return context
+
+    def value_from_datadict(
+        self, data: QueryDict, files: MultiValueDict, name: str
+    ) -> List:
+        values = []
+
+        for item in data.getlist(name):
+            if item not in EMPTY_VALUES:
+                values.append(item)
+
+        return values
+
+    def value_omitted_from_data(
+        self, data: QueryDict, files: MultiValueDict, name: str
+    ) -> List:
+        return data.getlist(name) not in [[""], *EMPTY_VALUES]
+
+    def decompress(self, value: Union[str, List]) -> List:
+        if isinstance(value, List):
+            return value.split(",")
+
+        return []
+
+    def _resolve_widgets(self, value: Optional[Union[List, str]]) -> None:
+        if value is None:
+            value = []
+
+        elif isinstance(value, List):
+            self.widgets = [self.widget_class for item in value]
+        else:
+            self.widgets = [self.widget_class for item in value.split(",")]
+
+        self.widgets_names = ["" for i in range(len(self.widgets))]
+        self.widgets = [w() if isinstance(w, type) else w for w in self.widgets]
+
+
 class WysiwygWidget(Widget):
     template_name = "unfold/forms/wysiwyg.html"
 

unfold/contrib/import_export/forms.py

@@ -1,8 +1,13 @@
+from django.forms.fields import BooleanField
 from import_export.forms import ExportForm as BaseExportForm
 from import_export.forms import ImportForm as BaseImportForm
+from import_export.forms import (
+    SelectableFieldsExportForm as BaseSelectableFieldsExportForm,
+)
 from unfold.widgets import (
     SELECT_CLASSES,
     UnfoldAdminFileFieldWidget,
+    UnfoldBooleanWidget,
 )
 
 
@@ -18,4 +23,16 @@ class ImportForm(BaseImportForm):
 class ExportForm(BaseExportForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.fields["resource"].widget.attrs["class"] = " ".join(SELECT_CLASSES)
         self.fields["format"].widget.attrs["class"] = " ".join(SELECT_CLASSES)
+
+
+class SelectableFieldsExportForm(BaseSelectableFieldsExportForm):
+    def __init__(self, formats, resources, **kwargs):
+        super().__init__(formats, resources, **kwargs)
+        self.fields["resource"].widget.attrs["class"] = " ".join(SELECT_CLASSES)
+        self.fields["format"].widget.attrs["class"] = " ".join(SELECT_CLASSES)
+
+        for _key, field in self.fields.items():
+            if isinstance(field, BooleanField):
+                field.widget = UnfoldBooleanWidget()

unfold/contrib/import_export/templates/admin/import_export/change_form.html

@@ -0,0 +1,10 @@
+{% extends 'admin/change_form.html' %}
+{% load i18n %}
+
+{% block actions %}
+    {{ block.super }}
+
+    {% if show_change_form_export %}
+        <input type="submit" value="{% translate 'Export' %}" name="_export-item" class="bg-white text-gray-500 border cursor-pointer flex font-medium items-center px-3 py-2 mr-3 rounded-md shadow-sm text-sm dark:bg-gray-900 dark:border dark:border-gray-700 dark:text-gray-400">
+    {% endif %}
+{% endblock %}

unfold/contrib/import_export/templates/admin/import_export/export.html

@@ -33,11 +33,46 @@
 {% endblock %}
 
 {% block content %}
-    <form action="" method="POST">
+    <form action="{{ export_url }}" method="POST">
         {% csrf_token %}
 
-        <fieldset class="border border-gray-200 mb-8 rounded-md pt-3 px-3 shadow-sm dark:border-gray-800">
-            {% include "unfold/helpers/field.html" with field=form.format %}
+        {% if form.initial.export_items %}
+            <p class="bg-blue-50 mb-4 text-blue-500 px-3 py-3 rounded-md text-sm dark:bg-blue-500/20 dark:border-blue-500/10">
+                {% blocktranslate count len=form.initial.export_items|length %}
+                    Export {{ len }} selected item.
+                {% plural %}
+                    Export {{ len }} selected items.
+                {% endblocktranslate %}
+            </p>
+        {% endif %}
+
+        {% if not form.is_selectable_fields_form %}
+            {% include "admin/import_export/resource_fields_list.html" with import_or_export="export" %}
+        {% endif %}
+
+        {{ form.non_field_errors }}
+
+        <fieldset class="border border-gray-200 mb-4 rounded-md pt-3 px-3 shadow-sm dark:border-gray-800">
+            {% for field in form.visible_fields %}
+                <div {% if field.field.is_selectable_field %}class="selectable-field-export-row" resource-index="{{ field.field.resource_index }}"{% else %}class="form-row aligned"{% endif %}>
+                    {% if field.field.initial_field %}
+                        <p class="block font-medium mb-2 text-gray-900 text-sm dark:text-gray-200">
+                            {% trans "This exporter will export the following fields" %}
+                        </p>
+                    {% endif %}
+
+                    {% if field.field.widget.attrs.readonly %}
+                        {% include "unfold/helpers/field_readonly.html" with title=field.label value=field.field.value %}
+                        {{ field.as_hidden }}
+                    {% else %}
+                        {% include "unfold/helpers/field.html" with field=field %}
+                    {% endif %}
+                </div>
+            {% endfor %}
+
+            {% for field in form.hidden_fields %}
+                {{ field }}
+            {% endfor %}
         </fieldset>
 
         <button type="submit" class="bg-primary-600 border border-transparent font-medium px-3 py-2 rounded-md text-sm text-white">

unfold/contrib/import_export/templates/admin/import_export/import_form.html

@@ -7,20 +7,16 @@
         {% include "admin/import_export/resource_fields_list.html" with import_or_export="import" %}
 
         <fieldset class="border border-gray-200 mb-8 rounded-md pt-3 px-3 shadow-sm dark:border-gray-800">
-            {% if form.resource.field.widget.attrs.readonly %}
-                {% include "unfold/helpers/field_readonly.html" with title=form.resource.field.label value=form.resource.field.value %}
-                {{ form.resource.as_hidden }}
-            {% else %}
-                {% include "unfold/helpers/field.html" with field=form.resource %}
-            {% endif %}
-
-
-            {% include "unfold/helpers/field.html" with field=form.import_file %}
-
-            {% include "unfold/helpers/field.html" with field=form.format %}
+            {% for field in form %}
+                {% if field.field.widget.attrs.readonly %}
+                    {% include "unfold/helpers/field_readonly.html" with title=field.label value=field.field.value %}
+                    {{ field.as_hidden }}
+                {% else %}
+                    {% include "unfold/helpers/field.html" with field=field %}
+                {% endif %}
+            {% endfor %}
         </fieldset>
 
-
         <button type="submit" class="bg-primary-600 border border-transparent font-medium px-3 py-2 rounded-md text-sm text-white">
             {% translate 'Submit' %}
         </button>

unfold/contrib/import_export/templates/admin/import_export/resource_fields_list.html

@@ -1,7 +1,7 @@
 {% load i18n %}
 
 {% block fields_help %}
-    <div class="bg-blue-50 mb-8 text-blue-500 px-3 py-3 rounded-md text-sm dark:bg-blue-500/20 dark:border-blue-500/10">
+    <div class="bg-blue-50 mb-4 text-blue-500 px-3 py-3 rounded-md text-sm dark:bg-blue-500/20 dark:border-blue-500/10">
         {% if import_or_export == "export" %}
             {% trans "This exporter will export the following fields: " %}
         {% elif import_or_export == "import" %}

unfold/contrib/inlines/admin.py

@@ -0,0 +1,141 @@
+from functools import partial
+from typing import Any, Optional
+
+from django import forms
+from django.contrib.admin.utils import NestedObjects, flatten_fieldsets
+from django.core.exceptions import ValidationError
+from django.db import router
+from django.db.models import Model
+from django.forms.formsets import DELETION_FIELD_NAME
+from django.forms.models import modelform_defines_fields
+from django.http import HttpRequest
+from django.utils.text import get_text_list
+from django.utils.translation import gettext_lazy as _
+from unfold.admin import StackedInline, TabularInline
+
+from .checks import NonrelatedModelAdminChecks
+from .forms import NonrelatedInlineModelFormSet, nonrelated_inline_formset_factory
+
+
+class NonrelatedInlineMixin:
+    checks_class = NonrelatedModelAdminChecks
+    formset = NonrelatedInlineModelFormSet
+
+    def get_formset(
+        self, request: HttpRequest, obj: Optional[Model] = None, **kwargs: Any
+    ):
+        defaults = self._get_formset_defaults(request, obj, **kwargs)
+
+        defaults["queryset"] = (
+            self.get_form_queryset(obj) if obj else self.model.objects.none()
+        )
+
+        return nonrelated_inline_formset_factory(
+            self.model, save_new_instance=self.save_new_instance, **defaults
+        )
+
+    def _get_formset_defaults(
+        self, request: HttpRequest, obj: Optional[Model] = None, **kwargs: Any
+    ):
+        """Return a BaseInlineFormSet class for use in admin add/change views."""
+        if "fields" in kwargs:
+            fields = kwargs.pop("fields")
+        else:
+            fields = flatten_fieldsets(self.get_fieldsets(request, obj))
+        excluded = self.get_exclude(request, obj)
+        exclude = [] if excluded is None else list(excluded)
+        exclude.extend(self.get_readonly_fields(request, obj))
+        if excluded is None and hasattr(self.form, "_meta") and self.form._meta.exclude:
+            # Take the custom ModelForm's Meta.exclude into account only if the
+            # InlineModelAdmin doesn't define its own.
+            exclude.extend(self.form._meta.exclude)
+        # If exclude is an empty list we use None, since that's the actual
+        # default.
+        exclude = exclude or None
+        can_delete = self.can_delete and self.has_delete_permission(request, obj)
+        defaults = {
+            "form": self.form,
+            "formset": self.formset,
+            # "fk_name": self.fk_name,
+            "fields": fields,
+            "exclude": exclude,
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
+            "extra": self.get_extra(request, obj, **kwargs),
+            "min_num": self.get_min_num(request, obj, **kwargs),
+            "max_num": self.get_max_num(request, obj, **kwargs),
+            "can_delete": can_delete,
+            **kwargs,
+        }
+
+        base_model_form = defaults["form"]
+        can_change = self.has_change_permission(request, obj) if request else True
+        can_add = self.has_add_permission(request, obj) if request else True
+
+        class DeleteProtectedModelForm(base_model_form):
+            def hand_clean_DELETE(self):
+                """
+                We don't validate the 'DELETE' field itself because on
+                templates it's not rendered using the field information, but
+                just using a generic "deletion_field" of the InlineModelAdmin.
+                """
+                if self.cleaned_data.get(DELETION_FIELD_NAME, False):
+                    using = router.db_for_write(self._meta.model)
+                    collector = NestedObjects(using=using)
+                    if self.instance._state.adding:
+                        return
+                    collector.collect([self.instance])
+                    if collector.protected:
+                        objs = []
+                        for p in collector.protected:
+                            objs.append(
+                                # Translators: Model verbose name and instance representation,
+                                # suitable to be an item in a list.
+                                _("%(class_name)s %(instance)s")
+                                % {
+                                    "class_name": p._meta.verbose_name,
+                                    "instance": p,
+                                }
+                            )
+                        params = {
+                            "class_name": self._meta.model._meta.verbose_name,
+                            "instance": self.instance,
+                            "related_objects": get_text_list(objs, _("and")),
+                        }
+                        msg = _(
+                            "Deleting %(class_name)s %(instance)s would require "
+                            "deleting the following protected related objects: "
+                            "%(related_objects)s"
+                        )
+                        raise ValidationError(
+                            msg, code="deleting_protected", params=params
+                        )
+
+            def is_valid(self):
+                result = super().is_valid()
+                self.hand_clean_DELETE()
+                return result
+
+            def has_changed(self):
+                # Protect against unauthorized edits.
+                if not can_change and not self.instance._state.adding:
+                    return False
+                if not can_add and self.instance._state.adding:
+                    return False
+                return super().has_changed()
+
+        defaults["form"] = DeleteProtectedModelForm
+
+        if defaults["fields"] is None and not modelform_defines_fields(
+            defaults["form"]
+        ):
+            defaults["fields"] = forms.ALL_FIELDS
+
+        return defaults
+
+
+class NonrelatedStackedInline(NonrelatedInlineMixin, StackedInline):
+    pass
+
+
+class NonrelatedTabularInline(NonrelatedInlineMixin, TabularInline):
+    pass

unfold/contrib/inlines/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DefaultAppConfig(AppConfig):
+    name = "unfold.contrib.inlines"
+    label = "unfold_inlines"

unfold/contrib/inlines/checks.py

@@ -0,0 +1,18 @@
+from typing import List
+
+from django.contrib.admin.checks import InlineModelAdminChecks
+from django.contrib.admin.options import InlineModelAdmin
+from django.core.checks import CheckMessage
+from django.db.models import Model
+
+
+class NonrelatedModelAdminChecks(InlineModelAdminChecks):
+    def _check_exclude_of_parent_model(
+        self, obj: InlineModelAdmin, parent_model: Model
+    ) -> List[CheckMessage]:
+        return []
+
+    def _check_relation(
+        self, obj: InlineModelAdmin, parent_model: Model
+    ) -> List[CheckMessage]:
+        return []

unfold/contrib/inlines/forms.py

@@ -0,0 +1,43 @@
+from typing import Any, Callable, Optional
+
+from django.db.models import Model, QuerySet
+from django.forms import BaseModelFormSet, ModelForm, modelformset_factory
+
+
+class NonrelatedInlineModelFormSet(BaseModelFormSet):
+    def __init__(
+        self,
+        instance: Optional[Model] = None,
+        save_as_new: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        self.instance = instance
+        self.queryset = self.provided_queryset
+
+        super().__init__(**kwargs)
+
+    @classmethod
+    def get_default_prefix(cls: BaseModelFormSet) -> str:
+        return f"{cls.model._meta.app_label}-{cls.model._meta.model_name}"
+
+    def save_new(self, form: ModelForm, commit: bool = True):
+        obj = super().save_new(form, commit=False)
+        self.save_new_instance(self.instance, obj)
+
+        if commit:
+            obj.save()
+
+        return obj
+
+
+def nonrelated_inline_formset_factory(
+    model: Model,
+    queryset: Optional[QuerySet] = None,
+    formset: BaseModelFormSet = NonrelatedInlineModelFormSet,
+    save_new_instance: Optional[Callable] = None,
+    **kwargs: Any,
+) -> BaseModelFormSet:
+    inline_formset = modelformset_factory(model, formset=formset, **kwargs)
+    inline_formset.provided_queryset = queryset
+    inline_formset.save_new_instance = save_new_instance
+    return inline_formset

unfold/decorators.py

@@ -58,6 +58,7 @@ def display(
     function: Optional[Callable[[Model], Any]] = None,
     *,
     boolean: Optional[bool] = None,
+    image: Optional[bool] = None,
     ordering: Optional[Union[str, Combinable, BaseExpression]] = None,
     description: Optional[str] = None,
     empty_value: Optional[str] = None,
@@ -72,6 +73,8 @@ def display(
             )
         if boolean is not None:
             func.boolean = boolean
+        if image is not None:
+            func.image = image
         if ordering is not None:
             func.admin_order_field = ordering
         if description is not None:

unfold/fields.py

@@ -0,0 +1,200 @@
+from django.contrib.admin import helpers
+from django.contrib.admin.utils import lookup_field, quote
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import models
+from django.db.models import (
+    ForeignObjectRel,
+    ImageField,
+    JSONField,
+    ManyToManyRel,
+    OneToOneField,
+)
+from django.forms.utils import flatatt
+from django.template.defaultfilters import linebreaksbr
+from django.urls import NoReverseMatch, reverse
+from django.utils.html import conditional_escape, format_html
+from django.utils.module_loading import import_string
+from django.utils.safestring import SafeText, mark_safe
+from django.utils.text import capfirst
+
+from .settings import get_config
+from .utils import display_for_field
+from .widgets import CHECKBOX_LABEL_CLASSES, LABEL_CLASSES
+
+
+class UnfoldAdminReadonlyField(helpers.AdminReadonlyField):
+    def label_tag(self) -> SafeText:
+        from .admin import ModelAdmin, ModelAdminMixin
+
+        if not isinstance(self.model_admin, ModelAdmin) and not isinstance(
+            self.model_admin, ModelAdminMixin
+        ):
+            return super().label_tag()
+
+        attrs = {
+            "class": " ".join(LABEL_CLASSES + ["mb-2"]),
+        }
+
+        label = self.field["label"]
+
+        return format_html(
+            "<label{}>{}{}</label>",
+            flatatt(attrs),
+            capfirst(label),
+            self.form.label_suffix,
+        )
+
+    def is_json(self) -> bool:
+        field, obj, model_admin = (
+            self.field["field"],
+            self.form.instance,
+            self.model_admin,
+        )
+
+        try:
+            f, attr, value = lookup_field(field, obj, model_admin)
+        except (AttributeError, ValueError, ObjectDoesNotExist):
+            return False
+
+        return isinstance(f, JSONField)
+
+    def is_image(self) -> bool:
+        field, obj, model_admin = (
+            self.field["field"],
+            self.form.instance,
+            self.model_admin,
+        )
+
+        try:
+            f, attr, value = lookup_field(field, obj, model_admin)
+        except (AttributeError, ValueError, ObjectDoesNotExist):
+            return False
+
+        if hasattr(attr, "image"):
+            return attr.image
+        elif (
+            isinstance(attr, property)
+            and hasattr(attr, "fget")
+            and hasattr(attr.fget, "image")
+        ):
+            return attr.fget.image
+
+        return isinstance(f, ImageField)
+
+    def contents(self) -> str:
+        contents = self._get_contents()
+        contents = self._preprocess_field(contents)
+        return contents
+
+    def get_admin_url(self, remote_field, remote_obj):
+        url_name = f"admin:{remote_field.model._meta.app_label}_{remote_field.model._meta.model_name}_change"
+        try:
+            url = reverse(
+                url_name,
+                args=[quote(remote_obj.pk)],
+                current_app=self.model_admin.admin_site.name,
+            )
+            return format_html(
+                '<a href="{}" class="text-primary-600 underline whitespace-nowrap">{}</a>',
+                url,
+                remote_obj,
+            )
+        except NoReverseMatch:
+            return str(remote_obj)
+
+    def _get_contents(self) -> str:
+        from django.contrib.admin.templatetags.admin_list import _boolean_icon
+
+        field, obj, model_admin = (
+            self.field["field"],
+            self.form.instance,
+            self.model_admin,
+        )
+        try:
+            f, attr, value = lookup_field(field, obj, model_admin)
+        except (AttributeError, ValueError, ObjectDoesNotExist):
+            result_repr = self.empty_value_display
+        else:
+            if field in self.form.fields:
+                widget = self.form[field].field.widget
+                # This isn't elegant but suffices for contrib.auth's
+                # ReadOnlyPasswordHashWidget.
+                if getattr(widget, "read_only", False):
+                    return widget.render(field, value)
+
+            if f is None:
+                if getattr(attr, "boolean", False):
+                    result_repr = _boolean_icon(value)
+                else:
+                    if hasattr(value, "__html__"):
+                        result_repr = value
+                    else:
+                        result_repr = linebreaksbr(value)
+            else:
+                if isinstance(f.remote_field, ManyToManyRel) and value is not None:
+                    result_repr = ", ".join(map(str, value.all()))
+                elif (
+                    isinstance(f.remote_field, (ForeignObjectRel, OneToOneField))
+                    and value is not None
+                ):
+                    result_repr = self.get_admin_url(f.remote_field, value)
+                elif isinstance(f, models.URLField):
+                    return format_html(
+                        '<a href="{}" class="text-primary-600 underline whitespace-nowrap">{}</a>',
+                        value,
+                        value,
+                    )
+                else:
+                    result_repr = display_for_field(value, f, self.empty_value_display)
+                    return conditional_escape(result_repr)
+                result_repr = linebreaksbr(result_repr)
+        return conditional_escape(result_repr)
+
+    def _preprocess_field(self, contents: str) -> str:
+        if (
+            hasattr(self.model_admin, "readonly_preprocess_fields")
+            and self.field["field"] in self.model_admin.readonly_preprocess_fields
+        ):
+            func = self.model_admin.readonly_preprocess_fields[self.field["field"]]
+            if isinstance(func, str):
+                contents = import_string(func)(contents)
+            elif callable(func):
+                contents = func(contents)
+
+        return contents
+
+
+class UnfoldAdminField(helpers.AdminField):
+    def label_tag(self) -> SafeText:
+        classes = []
+        if not self.field.field.widget.__class__.__name__.startswith(
+            "Unfold"
+        ) and not self.field.field.widget.template_name.startswith("unfold"):
+            return super().label_tag()
+
+        # TODO load config from current AdminSite (override Fieldline.__iter__ method)
+        for lang, flag in get_config()["EXTENSIONS"]["modeltranslation"][
+            "flags"
+        ].items():
+            if f"[{lang}]" in self.field.label:
+                self.field.label = self.field.label.replace(f"[{lang}]", flag)
+                break
+
+        contents = conditional_escape(self.field.label)
+
+        if self.is_checkbox:
+            classes.append(" ".join(CHECKBOX_LABEL_CLASSES))
+        else:
+            classes.append(" ".join(LABEL_CLASSES))
+
+        if self.field.field.required:
+            classes.append("required")
+
+        attrs = {"class": " ".join(classes)} if classes else {}
+        required = mark_safe(' <span class="text-red-600">*</span>')
+
+        return self.field.label_tag(
+            contents=mark_safe(contents),
+            attrs=attrs,
+            label_suffix=required if self.field.field.required else "",
+        )

unfold/forms.py

@@ -10,6 +10,7 @@ from django.contrib.admin.forms import (
 from django.contrib.auth.forms import (
     AdminPasswordChangeForm as BaseAdminPasswordChangeForm,
 )
+from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
 from django.contrib.auth.forms import UserChangeForm as BaseUserChangeForm
 from django.contrib.auth.forms import UserCreationForm as BaseUserCreationForm
 from django.http import HttpRequest
@@ -19,6 +20,10 @@ from django.utils.translation import gettext_lazy as _
 from .widgets import BASE_INPUT_CLASSES, INPUT_CLASSES, SELECT_CLASSES
 
 
+class UnfoldReadOnlyPasswordHashWidget(ReadOnlyPasswordHashWidget):
+    pass
+
+
 class ActionForm(forms.Form):
     action = forms.ChoiceField(
         label="",
@@ -72,6 +77,7 @@ class UserChangeForm(BaseUserChangeForm):
         **kwargs,
     ) -> None:
         super().__init__(request, *args, **kwargs)
+        self.fields["password"].widget = UnfoldReadOnlyPasswordHashWidget()
 
         self.fields["password"].help_text = _(
             "Raw passwords are not stored, so there is no way to see this "