django-smartbase-admin 2.3.2__tar.gz → 2.3.4__tar.gz

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-smartbase-admin
-Version: 2.3.2
+Version: 2.3.4
 Summary: 
 Home-page: https://smartbase-sk.github.io/django-smartbase-admin-docs/
 License: MIT
@@ -24,7 +24,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: mcp
-Requires-Dist: django (>=4.2,<7.0)
+Requires-Dist: django (>=4.2,<6.1)
 Requires-Dist: django-ckeditor (>=6.7.1,<7.0.0)
 Requires-Dist: django-filer (>=3.1.1,<4.0.0)
 Requires-Dist: django-htmx (>=1.17.3,<2.0.0)

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-smartbase-admin"
-version = "2.3.2"
+version = "2.3.4"
 description = ""
 authors = ["SmartBase <info@smartbase.sk>"]
 readme = "README.md"
@@ -32,7 +32,10 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-django = ">= 4.2, < 7.0"
+# Capped below 6.1: it drops the private django.utils.cache.cc_delim_re that every
+# djangorestframework release up to 3.17.2 imports (so the mcp extra cannot even be installed) and
+# the takes_context argument of the private template parse_bits() used by InclusionSBAdminNode.
+django = ">= 4.2, < 6.1"
 django-ckeditor = "^6.7.1"
 django-nested-admin = "^4.1.1"
 xlsxwriter = "^3.2.0"

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/actions/admin_action_list.py

@@ -936,7 +936,11 @@ class SBAdminListAction(SBAdminAction):
         queryset = self.search_in_queryset(queryset)
         request = self.threadsafe_request
         for plugin in request.request_data.configuration.plugins:
-            queryset = plugin.modify_count_queryset(self, request=request, qs=queryset)
+            queryset = plugin.modify_aggregate_queryset(
+                self,
+                request=request,
+                qs=queryset,
+            )
 
         # GROUP BY: no group_by → a single constant group, so the scalar
         # case falls out of the same path.

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/engine/actions.py

@@ -1,7 +1,7 @@
 import json
 
 from django import forms
-from django.core.exceptions import ImproperlyConfigured
+from django.core.exceptions import ImproperlyConfigured, ValidationError
 from django.utils.translation import gettext_lazy as _
 
 

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/engine/admin_base_view.py

@@ -656,6 +656,8 @@ class SBAdminBaseQuerysetMixin(object):
 
 class SBAdminBaseListView(SBAdminBaseView):
     sbadmin_list_view_config = None
+    show_views = True
+    views_bar_template_name = "sb_admin/config/view.html"
     mcp_description = None
     sbadmin_list_display = None
     sbadmin_list_display_data = None
@@ -1244,8 +1246,25 @@ class SBAdminBaseListView(SBAdminBaseView):
                 config_id=config_id,
             )
 
-        redirect_to = self.get_redirect_url_from_request(request, updated_configuration)
+        return self.get_config_response(request, updated_configuration)
 
+    def get_views_bar_context(self, request) -> dict[str, Any]:
+        """Context for rendering the views bar on its own (see get_config_response)."""
+        return {
+            "view_id": self.get_id(),
+            **self.get_config_data(request),
+            "content_context": {
+                "config_url": self.get_config_url(request),
+                "const": {
+                    "CONFIG_NAME": CONFIG_NAME,
+                    "URL_PARAMS_NAME": URL_PARAMS_NAME,
+                },
+            },
+        }
+
+    def get_config_response(self, request, updated_configuration=None):
+        """What a save/delete of a view answers with — a page (re)load by default."""
+        redirect_to = self.get_redirect_url_from_request(request, updated_configuration)
         response = redirect(redirect_to)
         if is_htmx_request(request.request_data.request_meta):
             response = HttpResponse()
@@ -1354,9 +1373,14 @@ class SBAdminBaseListView(SBAdminBaseView):
     def get_sbadmin_list_view_config(self, request) -> list:
         return self.sbadmin_list_view_config or []
 
+    def get_show_views(self, request) -> bool:
+        return self.show_views
+
     def get_base_config(self, request) -> list[dict[str, Any]]:
         sbadmin_list_config = self.get_sbadmin_list_view_config(request)
-        list_view_config = [self.get_all_config(request), *sbadmin_list_config]
+        all_config = self.get_all_config(request)
+        # get_all_config may be None where resetting to "everything" is not offered as a button.
+        list_view_config = [*([all_config] if all_config else []), *sbadmin_list_config]
         views = []
         for defined_view in list_view_config:
             url_params = SBAdminViewService.process_url_params(
@@ -1381,7 +1405,10 @@ class SBAdminBaseListView(SBAdminBaseView):
             view["detail_url"] = self.get_config_url(request, view["id"])
         config_views = self.get_base_config(request)
         config_views.extend(current_views)
-        return {"current_views": config_views}
+        return {
+            "current_views": config_views,
+            "show_views": self.get_show_views(request),
+        }
 
     def get_ajax_url(self, request=None) -> str:
         object_id = getattr(getattr(request, "request_data", None), "object_id", None)

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/engine/dashboard.py

@@ -7,7 +7,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.db.models import Q, QuerySet
 from django.db.models.functions import TruncDay, TruncMonth, TruncWeek, TruncYear
-from django.http import JsonResponse
+from django.http import HttpResponse, JsonResponse
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
@@ -755,6 +755,8 @@ class SBAdminDashboardListWidget(SBAdminBaseListView, SBAdminDashboardWidget):
     media = forms.Media(js=("sb_admin/dist/table.js",))
     cache_enabled = False
     sbadmin_table_history_enabled = False
+    show_views = False
+    views_bar_template_name = "sb_admin/config/view_embedded.html"
 
     def __init__(
         self,
@@ -822,6 +824,22 @@ class SBAdminDashboardListWidget(SBAdminBaseListView, SBAdminDashboardWidget):
         context["list_base_template"] = "sb_admin/blank_base.html"
         return context
 
+    def get_config_response(self, request, updated_configuration=None):
+        # A widget cannot navigate the page it is embedded in, so a saved/deleted view answers with
+        # the re-rendered bar; viewsModule swaps it in and re-marks the active button.
+        return HttpResponse(
+            render_to_string(
+                self.views_bar_template_name,
+                self.get_views_bar_context(request),
+                request=request,
+            )
+        )
+
+    def get_all_config(self, request) -> None:
+        # No "All" button in a widget bar: it lists the presets declared in
+        # sbadmin_list_view_config, and clearing the filter chips already brings everything back.
+        return None
+
     def get_filters_template_name(self, request) -> str:
         return "sb_admin/dashboard/includes/list_widget_filters.html"
 

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/mcp/actions.py

@@ -22,6 +22,7 @@ from urllib.parse import unquote
 
 from django.contrib import messages as django_messages
 from django.core.exceptions import PermissionDenied
+from django.db import models
 from django.forms.forms import BaseForm
 from django.forms.formsets import BaseFormSet
 from django.http import Http404, QueryDict
@@ -29,7 +30,7 @@ from django.http.response import HttpResponseRedirectBase
 from django.utils.safestring import mark_safe
 from mcp.types import BlobResourceContents, EmbeddedResource
 
-from django_smartbase_admin.engine.const import Action, BASE_PARAMS_NAME
+from django_smartbase_admin.engine.const import Action
 from django_smartbase_admin.engine.modal_view import (
     ActionModalView,
     RowActionModalView,
@@ -62,6 +63,15 @@ logger = logging.getLogger(__name__)
 MAX_INLINE_DOWNLOAD_BYTES = 5 * 1024 * 1024
 
 
+class ActionInvoker(models.TextChoices):
+    ROW = "invoke_row_action"
+    DETAIL = "invoke_detail_action"
+    INLINE = "invoke_inline_action"
+    LIST = "invoke_list_action"
+    SELECTION = "invoke_selection_action"
+    MCP = "invoke_action"
+
+
 @cache
 def get_declared_mcp_actions(view_class: type) -> tuple[tuple[str, dict], ...]:
     """Return class methods explicitly exposed with ``mcp_components``.
@@ -269,23 +279,33 @@ def action_entries_for(action) -> list[dict]:
 # name, e.g. ``row_actions`` → ``invoke_row_action``) so individual
 # action entries don't need to repeat ``invoke_with`` ~30 times per
 # response.
-_INVOKE_TOOL_BY_GETTER = {
-    "get_sbadmin_row_actions_processed": "invoke_row_action",
-    "get_sbadmin_detail_actions_processed": "invoke_detail_action",
-    "get_sbadmin_inline_list_actions_processed": "invoke_inline_action",
-    "get_sbadmin_list_actions_processed": "invoke_list_action",
-    "get_sbadmin_list_selection_actions_processed": "invoke_selection_action",
+_INVOKE_TOOL_BY_GETTER: dict[str, ActionInvoker] = {
+    "get_sbadmin_row_actions_processed": ActionInvoker.ROW,
+    "get_sbadmin_detail_actions_processed": ActionInvoker.DETAIL,
+    "get_sbadmin_fieldsets_actions_processed": ActionInvoker.DETAIL,
+    "get_sbadmin_inline_list_actions_processed": ActionInvoker.INLINE,
+    "get_sbadmin_list_actions_processed": ActionInvoker.LIST,
+    "get_sbadmin_list_selection_actions_processed": ActionInvoker.SELECTION,
+}
+
+_ACTION_GETTERS_BY_INVOKER: dict[ActionInvoker, tuple[str, ...]] = {
+    invoker: tuple(
+        getter
+        for getter, mapped_invoker in _INVOKE_TOOL_BY_GETTER.items()
+        if mapped_invoker == invoker
+    )
+    for invoker in dict.fromkeys(_INVOKE_TOOL_BY_GETTER.values())
 }
 
 # Top-level legend: action-list field name → MCP tool to invoke entries
 # in that list. ``fieldset_actions`` are merged into ``detail_actions``.
-ACTION_INVOKERS: dict[str, str] = {
-    "row_actions": "invoke_row_action",
-    "detail_actions": "invoke_detail_action",
-    "list_actions": "invoke_list_action",
-    "selection_actions": "invoke_selection_action",
-    "inline_actions": "invoke_inline_action",
-    "mcp_actions": "invoke_action",
+ACTION_INVOKERS: dict[str, ActionInvoker] = {
+    "row_actions": ActionInvoker.ROW,
+    "detail_actions": ActionInvoker.DETAIL,
+    "list_actions": ActionInvoker.LIST,
+    "selection_actions": ActionInvoker.SELECTION,
+    "inline_actions": ActionInvoker.INLINE,
+    "mcp_actions": ActionInvoker.MCP,
 }
 
 
@@ -316,8 +336,8 @@ def collect_action_entries(
     # Strip it from entries whose invoke tool would ignore it so the
     # agent doesn't see a value it can't use.
     surface_modifier = invoke_with in {
-        "invoke_list_action",
-        "invoke_selection_action",
+        ActionInvoker.LIST,
+        ActionInvoker.SELECTION,
     }
     entries: list[dict] = []
     for action in actions:
@@ -336,6 +356,82 @@ def collect_action_entries(
     return entries
 
 
+def validate_ui_action_invoker(
+    source,
+    request,
+    *,
+    action_id: str,
+    expected_invoker: ActionInvoker,
+    object_id: str | None = None,
+) -> None:
+    """Validate that a UI action is published for ``expected_invoker``.
+
+    Processed action getters are the source of truth, matching discovery and
+    its permission filtering. An explicitly MCP-exposed method is a separate
+    family invoked through ``invoke_action``; a bare ``@sbadmin_action`` method
+    belongs to no MCP family unless an action list publishes it.
+    """
+    if expected_invoker not in _ACTION_GETTERS_BY_INVOKER:
+        raise ValueError(f"Unknown MCP action invoker {expected_invoker!r}.")
+
+    entries_by_invoker: dict[ActionInvoker, list[dict]] = {}
+
+    def entries_for(invoker: ActionInvoker) -> list[dict]:
+        if invoker in entries_by_invoker:
+            return entries_by_invoker[invoker]
+
+        entries: list[dict] = []
+        for getter_name in _ACTION_GETTERS_BY_INVOKER[invoker]:
+            if not hasattr(source, getter_name):
+                continue
+            getter_kwargs = {}
+            if getter_name in {
+                "get_sbadmin_detail_actions_processed",
+                "get_sbadmin_fieldsets_actions_processed",
+            }:
+                getter_kwargs["object_id"] = object_id
+            entries.extend(
+                collect_action_entries(
+                    source,
+                    getter_name,
+                    request,
+                    **getter_kwargs,
+                )
+            )
+        entries_by_invoker[invoker] = entries
+        return entries
+
+    if any(
+        entry.get("action_id") == action_id for entry in entries_for(expected_invoker)
+    ):
+        return
+
+    actual_invokers = [
+        invoker
+        for invoker in _ACTION_GETTERS_BY_INVOKER
+        if invoker != expected_invoker
+        and any(entry.get("action_id") == action_id for entry in entries_for(invoker))
+    ]
+    if any(
+        entry.get("action_id") == action_id
+        for entry in collect_mcp_method_action_entries(source, request)
+    ):
+        actual_invokers.append(ActionInvoker.MCP)
+
+    view_id = source.get_id()
+    if actual_invokers:
+        allowed = ", ".join(actual_invokers)
+        raise LookupError(
+            f"Action {action_id!r} on view {view_id!r} cannot be invoked with "
+            f"{expected_invoker}; use {allowed}."
+        )
+    raise LookupError(
+        f"Action {action_id!r} is not available through {expected_invoker} "
+        f"on view {view_id!r}. Copy action_id from the matching action list "
+        "in list_admins() or fetch_detail()."
+    )
+
+
 def resolve_action_modifier(admin, request, getter_name, action_id):
     """Derive the modifier for ``action_id`` from its registered action.
 
@@ -782,14 +878,6 @@ class SBAdminMCPActionInvokeService:
             modifier=modifier or "template",
             component_values=component_values,
             confirmed=confirmed,
-            base_params={
-                admin.get_id(): {
-                    "selectionData": {
-                        "table_selected_rows": [str(i) for i in object_ids],
-                        "table_deselected_rows": [],
-                    }
-                }
-            },
         )
 
     @classmethod
@@ -799,8 +887,6 @@ class SBAdminMCPActionInvokeService:
         request,
         action_id: str,
         component_values: dict | None = None,
-        filter_data: dict | None = None,
-        full_text_search: str | None = None,
         confirmed: bool = False,
         modifier: str | None = None,
     ) -> dict:
@@ -816,12 +902,6 @@ class SBAdminMCPActionInvokeService:
             modifier = resolve_action_modifier(
                 admin, request, "get_sbadmin_list_actions_processed", action_id
             )
-        base_params = None
-        if filter_data or full_text_search:
-            filter_payload = dict(filter_data or {})
-            if full_text_search:
-                filter_payload["sbadmin_full_text_search"] = full_text_search
-            base_params = {admin.get_id(): {"filterData": filter_payload}}
         return cls._invoke(
             admin,
             request,
@@ -829,7 +909,6 @@ class SBAdminMCPActionInvokeService:
             modifier=modifier or "template",
             component_values=component_values,
             confirmed=confirmed,
-            base_params=base_params,
         )
 
     # -- shared dispatch -----------------------------------------------------
@@ -844,7 +923,6 @@ class SBAdminMCPActionInvokeService:
         modifier: str | None,
         component_values: dict | None,
         object_id: str | None = None,
-        base_params: dict | None = None,
         confirmed: bool = False,
     ) -> dict:
         modal = cls._lookup_modal_action(
@@ -882,13 +960,8 @@ class SBAdminMCPActionInvokeService:
             if confirmed:
                 post_qd[ActionModalView.CONFIRMATION_POST_KEY] = "1"
 
-        get_payload = None
-        if base_params is not None:
-            get_payload = {BASE_PARAMS_NAME: json.dumps(base_params)}
-
         set_request_payload(
             request,
-            get=get_payload,
             post=post_qd,
             method="POST",
         )

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/mcp/bridge.py

@@ -1,11 +1,12 @@
-"""DRF/MCP request <-> SBAdmin pipeline bridging."""
+"""MCP transport <-> SBAdmin pipeline bridging."""
 
 from __future__ import annotations
 
 import numbers
 
-from django.http import QueryDict
+from django.http import HttpRequest, QueryDict
 from django.utils.datastructures import MultiValueDict
+from rest_framework.request import Request as DRFRequest
 
 from django_smartbase_admin.engine.const import (
     COLUMNS_DATA_COLUMNS_NAME,
@@ -20,7 +21,26 @@ from django_smartbase_admin.services.thread_local import SBAdminThreadLocalServi
 from django_smartbase_admin.services.xlsx_export import strip_html_cell_value
 
 
-def ensure_sbadmin_request_data(request) -> None:
+def unwrap_drf_request(request) -> HttpRequest | None:
+    """Normalize the transport request to SBAdmin's Django request contract."""
+    if request is None:
+        return None
+    if isinstance(request, DRFRequest):
+        django_request = request._request
+        django_request.user = request.user
+
+        # The MCP server may attach these directly to the DRF wrapper instead
+        # of its underlying Django request.
+        for attribute in ("session", "request_data", "LANGUAGE_CODE", "_messages"):
+            if attribute in request.__dict__:
+                setattr(django_request, attribute, request.__dict__[attribute])
+        return django_request
+    if not isinstance(request, HttpRequest):
+        raise TypeError("SBAdmin MCP tools require a Django HttpRequest.")
+    return request
+
+
+def ensure_sbadmin_request_data(request: HttpRequest) -> None:
     """Attach ``request.request_data`` lazily so SBAdmin internals work.
 
     No-op if already set (test fixtures, pre-bridged requests). MCP
@@ -141,39 +161,30 @@ def build_columns_data(admin, request, fields: list[str], field_map=None) -> dic
 
 
 def set_request_post(
-    request, post_qd: QueryDict, files: MultiValueDict | None = None
+    request: HttpRequest,
+    post_qd: QueryDict,
+    files: MultiValueDict | None = None,
 ) -> None:
-    """Force ``request.POST`` / ``request.FILES`` on a DRF ``Request``.
-
-    DRF re-exposes ``POST`` / ``FILES`` as read-only properties backed
-    by parser-cache attrs (``_data`` / ``_files``), so pre-populating
-    the cache is the only way to make ``request.POST`` read our
-    ``QueryDict`` — assigning to ``request.POST`` raises
-    ``AttributeError: property has no setter``. ``method`` and ``GET``
-    on the DRF wrapper aren't class-level descriptors, so plain
-    ``request.method = ...`` / ``request.GET = ...`` work via the
-    instance ``__dict__``.
-
-    ``Request.POST`` also gates on ``is_form_media_type(content_type)``
-    and returns an empty ``QueryDict`` otherwise; we set
-    ``CONTENT_TYPE`` on the underlying request so the cache is read.
-    """
+    """Replace the synthetic Django request's form payload."""
+    if not isinstance(request, HttpRequest):
+        raise TypeError("SBAdmin request payload requires a Django HttpRequest.")
     if files is None:
         files = MultiValueDict()
-    request._data = post_qd
-    request._full_data = post_qd
+    request.POST = post_qd
     request._files = files
-    request._request.META["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+    request.META["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
 
 
-def set_request_payload(request, *, get=None, post=None, method=None) -> None:
+def set_request_payload(
+    request: HttpRequest, *, get=None, post=None, method=None
+) -> None:
     """Mirror tool-supplied params onto both ``request_data`` and ``request``.
 
     SBAdmin actions read from ``request.request_data.request_get`` /
     ``.request_post`` / ``.request_method`` — the canonical pipeline
-    channel. We also mirror onto the DRF wrapper so ``has_*_permission``,
-    middleware, and Django admin code that touch ``request.GET`` /
-    ``POST`` / ``method`` see the same values.
+    channel. We also mirror onto the Django request so permissions,
+    middleware, and admin code that touch ``request.GET`` / ``POST`` /
+    ``method`` see the same values.
     """
     rd = request.request_data
 

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/mcp/form_encoding.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 from copy import copy
 
+from django.core.exceptions import ValidationError
 from django.forms.formsets import BaseFormSet
 from django.forms.forms import BaseForm
 from django.forms.models import BaseModelFormSet
@@ -167,9 +168,17 @@ def write_widget_input(qd: QueryDict, key: str, widget, value) -> None:
 
 
 def validation_error_entries(errors) -> list[dict]:
-    """Serialize Django ``ValidationError`` objects with stable codes."""
+    """Serialize Django or plain error lists with stable codes."""
+    as_data = getattr(errors, "as_data", None)
+    if callable(as_data):
+        errors = as_data()
+    elif isinstance(errors, (str, ValidationError)):
+        errors = [errors]
+
     entries = []
     for error in errors:
+        if not isinstance(error, ValidationError):
+            error = ValidationError(error)
         code = str(error.code) if error.code is not None else None
         entries.extend(
             {"code": code, "message": str(message)} for message in error.messages
@@ -211,7 +220,7 @@ def formset_errors_dict(formset: BaseFormSet) -> dict:
         rows.append(row)
     return {
         "type": "formset",
-        "non_form": validation_error_entries(formset.non_form_errors().as_data()),
+        "non_form": validation_error_entries(formset.non_form_errors()),
         "rows": rows,
     }
 

{django_smartbase_admin-2.3.2 → django_smartbase_admin-2.3.4}/src/django_smartbase_admin/mcp/instructions.py

@@ -13,6 +13,10 @@ allowed to.
 What you can do:
 * Discover the available admin views and, per view, their columns, filters,
   detail fields, inlines, filter presets, and actions (``list_admins``).
+  Scope it: start with ``list_admins(detail="index")`` for the list of
+  ``view_id``s, then ``list_admins(view_id="...")`` for that one view in full.
+  Reading every view in full can exceed your result budget, and post-filtering
+  an oversized payload silently drops keys you need — ``mcp_actions`` first.
 * Browse: filter (text, choice, boolean, number range, date range,
   related-record), full-text search, sort, and paginate (``list_rows``).
 * Apply a named or saved filter preset and replay it (``fetch_filter_preset``).
@@ -30,14 +34,17 @@ What you can do:
 * Run actions on a row, a detail page, the whole list, a selection, or an
   inline row (``invoke_*_action``); inspect a modal action's form first with
   ``fetch_action_form``. Object-only fieldset actions are discovered from
-  ``fetch_detail.detail_actions``. Submit forms and formsets through
-  ``component_values`` using the names returned under ``components``.
+  ``fetch_detail.detail_actions``, and actions with no UI button from
+  ``mcp_actions`` (on ``fetch_detail`` or ``list_admins``) — those are run with
+  ``invoke_action``. Submit forms and formsets through ``component_values``
+  using the names returned under ``components``.
 * Export a list or selection to a file.
 
 Safety: deletes and impactful actions return ``needs_confirmation`` with a
 preview first; re-call with ``confirmed=True`` to commit.
 
-Workflow: ``list_admins`` (discover ``view_id``, columns, filters, inlines) →
+Workflow: ``list_admins(detail="index")`` (find the ``view_id``) →
+``list_admins(view_id=...)`` (its columns, filters, inlines, actions) →
 ``list_rows`` / ``fetch_detail`` / ``fetch_add_form`` → ``autocomplete`` for
 labels → ``create_object`` or ``update_detail``.