django-unfold 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

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/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 "

unfold/static/unfold/css/simplebar.css

@@ -0,0 +1,230 @@
+[data-simplebar] {
+    position: relative;
+    flex-direction: column;
+    flex-wrap: wrap;
+    justify-content: flex-start;
+    align-content: flex-start;
+    align-items: flex-start;
+  }
+
+  .simplebar-wrapper {
+    overflow: hidden;
+    width: inherit;
+    height: inherit;
+    max-width: inherit;
+    max-height: inherit;
+  }
+
+  .simplebar-mask {
+    direction: inherit;
+    position: absolute;
+    overflow: hidden;
+    padding: 0;
+    margin: 0;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    width: auto !important;
+    height: auto !important;
+    z-index: 0;
+  }
+
+  .simplebar-offset {
+    direction: inherit !important;
+    box-sizing: inherit !important;
+    resize: none !important;
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    padding: 0;
+    margin: 0;
+    -webkit-overflow-scrolling: touch;
+  }
+
+  .simplebar-content-wrapper {
+    direction: inherit;
+    box-sizing: border-box !important;
+    position: relative;
+    display: block;
+    height: 100%; /* Required for horizontal native scrollbar to not appear if parent is taller than natural height */
+    width: auto;
+    max-width: 100%; /* Not required for horizontal scroll to trigger */
+    max-height: 100%; /* Needed for vertical scroll to trigger */
+    overflow: auto;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+  }
+
+  .simplebar-content-wrapper::-webkit-scrollbar,
+  .simplebar-hide-scrollbar::-webkit-scrollbar {
+    display: none;
+    width: 0;
+    height: 0;
+  }
+
+  .simplebar-content:before,
+  .simplebar-content:after {
+    content: ' ';
+    display: table;
+  }
+
+  .simplebar-placeholder {
+    max-height: 100%;
+    max-width: 100%;
+    width: 100%;
+    pointer-events: none;
+  }
+
+  .simplebar-height-auto-observer-wrapper {
+    box-sizing: inherit !important;
+    height: 100%;
+    width: 100%;
+    max-width: 1px;
+    position: relative;
+    float: left;
+    max-height: 1px;
+    overflow: hidden;
+    z-index: -1;
+    padding: 0;
+    margin: 0;
+    pointer-events: none;
+    flex-grow: inherit;
+    flex-shrink: 0;
+    flex-basis: 0;
+  }
+
+  .simplebar-height-auto-observer {
+    box-sizing: inherit;
+    display: block;
+    opacity: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+    height: 1000%;
+    width: 1000%;
+    min-height: 1px;
+    min-width: 1px;
+    overflow: hidden;
+    pointer-events: none;
+    z-index: -1;
+  }
+
+  .simplebar-track {
+    z-index: 1;
+    position: absolute;
+    right: 0;
+    bottom: 0;
+    pointer-events: none;
+    overflow: hidden;
+  }
+
+  [data-simplebar].simplebar-dragging {
+    pointer-events: none;
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+  }
+
+  [data-simplebar].simplebar-dragging .simplebar-content {
+    pointer-events: none;
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+  }
+
+  [data-simplebar].simplebar-dragging .simplebar-track {
+    pointer-events: all;
+  }
+
+  .simplebar-scrollbar {
+    position: absolute;
+    left: 0;
+    right: 0;
+    min-height: 10px;
+  }
+
+  .simplebar-scrollbar:before {
+    position: absolute;
+    content: '';
+    background: black;
+    border-radius: 7px;
+    left: 2px;
+    right: 2px;
+    opacity: 0;
+    transition: opacity 0.2s 0.5s linear;
+  }
+
+  .simplebar-scrollbar.simplebar-visible:before {
+    opacity: 0.5;
+    transition-delay: 0s;
+    transition-duration: 0s;
+  }
+
+  .simplebar-track.simplebar-vertical {
+    top: 0;
+    width: 11px;
+  }
+
+  .simplebar-scrollbar:before {
+    top: 2px;
+    bottom: 2px;
+    left: 2px;
+    right: 2px;
+  }
+
+  .simplebar-track.simplebar-horizontal {
+    left: 0;
+    height: 11px;
+  }
+
+  .simplebar-track.simplebar-horizontal .simplebar-scrollbar {
+    right: auto;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    min-height: 0;
+    min-width: 10px;
+    width: auto;
+  }
+
+  /* Rtl support */
+  [data-simplebar-direction='rtl'] .simplebar-track.simplebar-vertical {
+    right: auto;
+    left: 0;
+  }
+
+  .simplebar-dummy-scrollbar-size {
+    direction: rtl;
+    position: fixed;
+    opacity: 0;
+    visibility: hidden;
+    height: 500px;
+    width: 500px;
+    overflow-y: hidden;
+    overflow-x: scroll;
+    -ms-overflow-style: scrollbar !important;
+  }
+
+  .simplebar-dummy-scrollbar-size > div {
+    width: 200%;
+    height: 200%;
+    margin: 10px 0;
+  }
+
+  .simplebar-hide-scrollbar {
+    position: fixed;
+    left: 0;
+    visibility: hidden;
+    overflow-y: scroll;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+  }