django-dynamic-admin-forms 3.2.10__py3-none-any.whl

django_dynamic_admin_forms/__init__.py

@@ -0,0 +1,3 @@
+"""Add simple dynamic interaction to the otherwise static django admin."""
+
+__version__ = "3.2.10"

django_dynamic_admin_forms/admin.py

@@ -0,0 +1,76 @@
+import json
+from itertools import filterfalse
+
+from django.apps import apps
+from django.contrib import admin
+from django.core.exceptions import FieldDoesNotExist, PermissionDenied
+from django.http import HttpResponse
+
+
+class DynamicModelAdminMixin:
+    dynamic_fields = ()
+    dynamic_select_fields = None
+    dynamic_input_fields = None
+
+    def get_form(self, request, obj=None, change=False, **kwargs):
+        form = super().get_form(request, obj, **{"change": change, **kwargs})
+        self.dynamic_select_fields = list(filter(self._is_related_field, self.dynamic_fields))
+        self.dynamic_input_fields = list(filterfalse(self._is_related_field, self.dynamic_fields))
+        return form
+
+    def _is_related_field(self, field_name):
+        try:
+            return self.opts.get_field(field_name).is_relation
+        except FieldDoesNotExist:
+            return False
+
+    @staticmethod
+    def render_field(request) -> HttpResponse:
+        app_label = request.GET.get("app_label")
+        model_name = request.GET.get("model_name")
+        field_names = request.GET.getlist("field_names")
+
+        if not (app_label and model_name and field_names):
+            return HttpResponse("Invalid arguments", status=400)
+
+        model = apps.get_model(app_label, model_name)
+
+        # instantiate model_admin form from request data and get field
+        model_admin = admin.site._registry[model]
+
+        # check permissions
+        if not model_admin.has_module_permission(request):
+            raise PermissionDenied
+
+        model_form = model_admin.get_form(request)
+        bound_form = model_form(request.POST)
+
+        snippets = []
+        for field_name in field_names:
+            bound_field = bound_form[field_name]
+
+            # save custom queryset in field
+            hidden = False
+            method_name = f"get_dynamic_{field_name}_field"
+            if hasattr(model_admin, method_name):
+                method = getattr(model_admin, method_name)
+                bound_form.full_clean()
+                queryset, value, hidden = method(bound_form.cleaned_data)
+
+                bound_field.field.queryset = queryset
+                bound_field.form.data = bound_field.form.data.copy()
+                bound_field.form.data[field_name] = value
+
+            skip_update = field_name in request.FILES and not hidden
+            html = bound_field.as_widget()
+
+            snippets.append(
+                {
+                    "field_name": field_name,
+                    "html": html,
+                    "hidden": hidden,
+                    "skipUpdate": skip_update,
+                }
+            )
+
+        return HttpResponse(json.dumps(snippets), status=200)

django_dynamic_admin_forms/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class DynamicSelectConfig(AppConfig):
+    name = "django_dynamic_admin_forms"

django_dynamic_admin_forms/static/js/dynamic_admin.js

@@ -0,0 +1,72 @@
+var DynamicAdmin = {
+  //# sourceURL="dynamic_admin.js"
+  handleResponse: function (target, data) {
+    var $ = django.jQuery;
+
+    // set hidden class in parent form-row (or form-group if using jazzmin)
+    if (data.hidden) {
+      $(target.closest(".form-row,.form-group")).addClass("hidden");
+    } else {
+      $(target.closest(".form-row,.form-group")).removeClass("hidden");
+    }
+
+    // file fields will have this skipUpdate flag set
+    // TODO It might be easier to just look at the type attribute of the input element...
+    if (data.skipUpdate) {
+      return;
+    }
+
+    // Update the options for the select widget (either select2 instance or normal select element)
+    if ($(target).find("select").hasClass("select2-hidden-accessible")) {
+      var select2Widget = $(target).find("select");
+      var currentVal = select2Widget.val();
+      var options = $($.parseHTML(data.html)).find("option");
+      select2Widget.find("option").remove();
+      select2Widget.append(options);
+      select2Widget.val(currentVal);
+    } else {
+      target.outerHTML = data.html;
+    }
+  },
+
+  dynamicWidgets: function (
+    app_label,
+    model_name,
+    select_field_names,
+    input_field_names
+  ) {
+    var $ = django.jQuery;
+    var that = this;
+
+    var $form = $("#" + model_name + "_form");
+
+    $form.on("change", function () {
+      var field_names = [...select_field_names, ...input_field_names];
+      var params = new URLSearchParams([
+        ["app_label", app_label],
+        ["model_name", model_name],
+        ...field_names.map((name) => ["field_names", name]),
+      ]);
+      var url = `/dynamic-admin-form/?${params}`;
+      $.post({
+        url,
+        data: new FormData(this),
+        contentType: false,
+        processData: false,
+        success: function (data) {
+          snippets = JSON.parse(data);
+          snippets.forEach(({ field_name, ...data }) => {
+            if (select_field_names.indexOf(field_name) >= 0) {
+              var target = $(
+                ".field-" + field_name + " .related-widget-wrapper"
+              )[0];
+            } else {
+              var target = $("#id_" + field_name)[0];
+            }
+            that.handleResponse(target, data);
+          });
+        },
+      });
+    });
+  },
+};

django_dynamic_admin_forms/templates/admin/change_form.html

@@ -0,0 +1,37 @@
+{% extends "admin/change_form.html" %}
+{% load static %}
+
+{% block admin_change_form_document_ready %}
+  {{ block.super }}
+  <script type="text/javascript" src="{% static 'js/dynamic_admin.js' %}"></script>
+
+  {{ adminform.model_admin.dynamic_select_fields|json_script:"dynamic_select_fields" }}
+  {{ adminform.model_admin.dynamic_input_fields|json_script:"dynamic_input_fields" }}
+
+  <script type="text/javascript">
+    var dynamic_select_fields = JSON.parse(document.getElementById('dynamic_select_fields').textContent);
+    var dynamic_input_fields = JSON.parse(document.getElementById('dynamic_input_fields').textContent);
+    DynamicAdmin.dynamicWidgets("{{ opts.app_label }}", "{{ opts.model_name }}", dynamic_select_fields, dynamic_input_fields);
+  </script>
+{% endblock admin_change_form_document_ready %}
+
+{# Jazzmin-Support: the extrajs block is added in the jazzmin admin templates and won't do any harm for normal django admin #}
+{% block extrajs %}
+  {{ block.super }}
+  <script>
+    // Find all select2 instances in the current change form and trigger the change event manually
+    // whenever the select2 instance changes it's value.
+    $(function() {
+      $('.select2-hidden-accessible').each(function (i, select) {
+        var $select = $(select);
+        $select.on('change', function(event) {
+          var form = $(event.target).closest('form')[0];
+          // for some reason, jQuery's .trigger() method doesn't seem to work here, so we trigger a change event manually
+          if (form) {
+            form.dispatchEvent(new Event("change"));
+          }
+        })
+      })
+    });
+  </script>
+{% endblock extrajs %}

django_dynamic_admin_forms/urls.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from django.urls import path
+
+from django_dynamic_admin_forms.admin import DynamicModelAdminMixin
+
+urlpatterns = [
+    path("", admin.site.admin_view(DynamicModelAdminMixin.render_field)),
+]

django_dynamic_admin_forms-3.2.10.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: django-dynamic-admin-forms
+Version: 3.2.10
+Summary: Add simple dynamic interaction to the otherwise static django admin.
+Project-URL: Homepage, https://github.com/ambient-innovation/django-dynamic-admin/
+Project-URL: Documentation, https://django-dynamic-admin-forms.readthedocs.io/en/latest/index.html
+Project-URL: Maintained by, https://ambient.digital/
+Project-URL: Bugtracker, https://github.com/ambient-innovation/django-dynamic-admin/issues
+Project-URL: Changelog, https://django-dynamic-admin-forms.readthedocs.io/en/latest/features/changelog.html
+Author-email: Ambient Digital <hello@ambient.digital>, Fabian Binz <fabian.binz@ambient.digital>
+License: MIT License
+        
+        Copyright (c) 2022 Ambient Innovation: GmbH
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Description-Content-Type: text/markdown
+
+[![PyPI release](https://img.shields.io/pypi/v/django-dynamic-admin-forms.svg)](https://pypi.org/project/django-dynamic-admin-forms/)
+[![Downloads](https://static.pepy.tech/badge/django-dynamic-admin-forms)](https://pepy.tech/project/django-dynamic-admin-forms)
+[![Coverage](https://img.shields.io/badge/Coverage-100.0%25-success)](https://github.com/ambient-innovation/django-dynamic-admin/actions?workflow=CI)
+[![Linting](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Coding Style](https://img.shields.io/badge/code%20style-Ruff-000000.svg)](https://github.com/astral-sh/ruff)
+[![Documentation Status](https://readthedocs.org/projects/django-dynamic-admin-forms/badge/?version=latest)](https://django-dynamic-admin-forms.readthedocs.io/en/latest/?badge=latest)
+
+Add simple interactions to the otherwise static django admin.
+
+[PyPI](https://pypi.org/project/django-dynamic-admin-forms/) | [GitHub](https://github.com/ambient-innovation/django-dynamic-admin) | [Full documentation](https://django-dynamic-admin-forms.readthedocs.io/en/latest/index.html)
+
+Creator & Maintainer: [Ambient Digital](https://ambient.digital/)
+
+# django-dynamic-admin-forms
+
+Add simple interactions to the otherwise static django admin.
+
+[![demo.gif](https://i.postimg.cc/YCf7LV2m/demo.gif)](https://postimg.cc/Yv9ZJdWp)
+
+## Installation
+
+- Install the package via pip:
+
+    ```pip install django-dynamic-admin-forms```
+
+    or via pipenv:
+
+    ```pipenv install django-dynamic-admin-forms```
+- Add the module to `INSTALLED_APPS`:
+    ```python
+    INSTALLED_APPS = (
+        "django_dynamic_admin_forms",
+        "django.contrib.admin",
+    )
+    ```
+    Ensure that the `dynamic_admin_forms` comes before the
+    default `django.contrib.admin` in the list of installed apps,
+    because otherwise the templates, which are overwritten by `dynamic_admin_forms`
+    won't be found.
+- Ensure that the `dynamic_admin_forms` templates are found via using `APP_DIRS` setting:
+  ```python
+  TEMPLATES = [
+      {
+          "BACKEND": "django.template.backends.django.DjangoTemplates",
+          "APP_DIRS": True,
+      },
+  ]
+  ```
+- Run `python manage.py collectstatic` to include this apps Javascript code in your `settings.STATIC_ROOT` directory
+
+## Usage
+- Add the `django_dynamic_admin_forms.DynamicModelAdminMixin` to your admin classes
+- Add the `django_dynamic_admin_forms.urls` to your urls
+  ```python
+  from django.contrib import admin
+  from django.urls import path, include
+
+  urlpatterns = [
+      path("admin/", admin.site.urls),
+      path("dynamic-admin-form/", include("django_dynamic_admin_forms.urls")),
+  ]
+  ```
+- In addition to the standard `fields` declaration, specify a list of `dynamic_fields`
+- For each dynamic field, add a method `get_dynamic_{field_name}_field` to the admin
+  - Input: `data: Dict[str, Any]` - the cleaned form data
+  - Output:
+    - `queryset: Optional[Queryset]` - The values to select from
+    - `value: Any` - The value, the field should have (must be compatible to the field type)
+    - `hidden: Bool` - True, if field should be hidden
+
+- A rather non-sensical example:
+  ```python
+  from django.contrib import admin
+
+  from .models import MyModel
+  from django_dynamic_admin_forms.admin import DynamicModelAdminMixin
+
+
+  @admin.register(MyModel)
+  class MyModelAdmin(DynamicModelAdminMixin, admin.ModelAdmin):
+      fields = ("name", "city")
+      dynamic_fields = ("city",)
+
+      def get_dynamic_city_field(self, data):
+          # automatically choose first city that matches first letter of name
+          name = data.get("name")
+          if not name:
+              queryset = City.objects.all()
+              value = data.get("city")
+          else:
+              queryset = City.objects.filter(name__startswith=name[0])
+              value = queryset.first()
+          hidden = not queryset.exists()
+          return queryset, value, hidden
+  ```
+
+## How it works
+Whenever a dynamic form changes, an event handler makes a request to a special endpoint, which returns new HTML to swap
+into  the existing form. This new HTML is directly generated by `django.contrib.admin`, so we only have to set the
+outerHTML of the correct HTML elements to update the form.
+
+## Limitations
+- does not work in conjunction with inlines
+- does not validate that the selected value is really part of the original queryset
+  - if anybody can modify your DOM, they could potentially inject invalid values
+  - you have to write `Model.clean()` methods to guard against that
+- only tested with Django 3.2
+
+## Development
+
+For local development, create a virtual environment
+in the `testproj` folder:
+```shell
+$ cd testproj
+$ python3 -m venv .venv
+$ source .venv/bin/activate
+$ cd ..
+$ flit install --symlink
+```
+Now the package should be available in your virtual environment
+and any changes should be directly visible.
+
+Alternatively, copy the directory `dynamic_admin_forms`
+into any normal django project, so that the python interpreter
+finds the local version instead of the installed (old) version.
+
+## Running E2E tests
+
+To run end-to-end tests locally:
+```shell
+$ cd testproj
+$ python manage.py runserver 0.0.0.0:8000 &  # start server
+$ python manage.py loaddata fixtures/fixtures-dev.json
+$ cd ../e2e
+$ yarn install  # or npm install (only needed first time)
+$ yarn cypress  # or npm run cypress
+```
+
+## Installation
+
+- Install the package via pip:
+
+   `pip install django-dynamic-admin-forms`
+
+   or via pipenv:
+
+   `pipenv install django-dynamic-admin-forms`
+
+- Add the module to `INSTALLED_APPS`:
+    ```python
+    INSTALLED_APPS = (
+        "django_dynamic_admin_forms",
+        "django.contrib.admin",
+    )
+    ```
+    Ensure that the `dynamic_admin_forms` comes before the
+    default `django.contrib.admin` in the list of installed apps,
+    because otherwise the templates, which are overwritten by `dynamic_admin_forms`
+    won't be found.
+
+- Ensure that the `dynamic_admin_forms` templates are found via using `APP_DIRS` setting:
+  ```python
+  TEMPLATES = [
+      {
+          "BACKEND": "django.template.backends.django.DjangoTemplates",
+          "APP_DIRS": True,
+      },
+  ]
+  ```
+
+- Run `python manage.py collectstatic` to include this apps Javascript code in your `settings.STATIC_ROOT` directory
+
+### Publish to ReadTheDocs.io
+
+- Fetch the latest changes in GitHub mirror and push them
+- Trigger new build at ReadTheDocs.io (follow instructions in admin panel at RTD) if the GitHub webhook is not yet set
+  up.
+
+### Preparation and building
+
+This package uses [uv](https://github.com/astral-sh/uv) for dependency management and building.
+
+- Update documentation about new/changed functionality
+
+- Update the `CHANGES.md`
+
+- Increment version in main `__init__.py`
+
+- Create pull request / merge to "main"
+
+- This project uses uv to publish to PyPI. This will create distribution files in the `dist/` directory.
+
+  ```bash
+  uv build
+  ```
+
+### Publishing to PyPI
+
+To publish to the production PyPI:
+
+```bash
+uv publish
+```
+
+To publish to TestPyPI first (recommended for testing):
+
+```bash
+uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+You can then test the installation from TestPyPI:
+
+```bash
+uv pip install --index-url https://test.pypi.org/simple/ ambient-package-update
+```
+
+### Maintenance
+
+Please note that this package supports the [ambient-package-update](https://pypi.org/project/ambient-package-update/).
+So you don't have to worry about the maintenance of this package. This updater is rendering all important
+configuration and setup files. It works similar to well-known updaters like `pyupgrade` or `django-upgrade`.
+
+To run an update, refer to the [documentation page](https://pypi.org/project/ambient-package-update/)
+of the "ambient-package-update".

django_dynamic_admin_forms-3.2.10.dist-info/RECORD

@@ -0,0 +1,10 @@
+django_dynamic_admin_forms/__init__.py,sha256=ktLW1f20qQrB8XgbeYT607gD8qFXqO1aO7VyvrzEr_A,102
+django_dynamic_admin_forms/admin.py,sha256=1wER87eAw6byNpKCjmXRY0iyDCXndCiqWuNziwrsLXI,2770
+django_dynamic_admin_forms/apps.py,sha256=PRyfkFEI8Vc1RK8tMO4-RUvkO3lxEYKSGPlDNUUXBUo,114
+django_dynamic_admin_forms/urls.py,sha256=SSdld9CyKpUAP9vTi_yS9y8sSh-S1YAnhPqn4ebXFas,232
+django_dynamic_admin_forms/static/js/dynamic_admin.js,sha256=8TqoxGna-pw_SEIsBQ87gwCKe0Vo5X_SfA58NiOBhyo,2258
+django_dynamic_admin_forms/templates/admin/change_form.html,sha256=itcHMYmSZswZeDHDj5fNfPHQquPouQkptjy8VO-TI7k,1680
+django_dynamic_admin_forms-3.2.10.dist-info/METADATA,sha256=fOroOFLVgiGdYv4e-vHvuvmxdSv2IsvZaLC1_f0dadM,10674
+django_dynamic_admin_forms-3.2.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_dynamic_admin_forms-3.2.10.dist-info/licenses/LICENSE.md,sha256=llryfe8olgEjTmcDQJzppeGeEWRJLS8Xf_2I_gEKYQ4,1102
+django_dynamic_admin_forms-3.2.10.dist-info/RECORD,,

django_dynamic_admin_forms-3.2.10.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_dynamic_admin_forms-3.2.10.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ambient Innovation: GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.