django-admin-radio-select 0.1.0__tar.gz

django_admin_radio_select-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodolfo Becerra
+
+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.

django_admin_radio_select-0.1.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: django-admin-radio-select
+Version: 0.1.0
+Summary: Synchronize BooleanFields across Django Admin inline rows as mutually exclusive radio button groups.
+Author-email: Rodolfo Becerra <rodolvbg@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rodolvbg/django-admin-radio-select
+Project-URL: Repository, https://github.com/rodolvbg/django-admin-radio-select
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Dynamic: license-file
+
+# django-admin-radio-select
+
+[![Python tests](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/pytest.yml/badge.svg)](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/pytest.yml)
+[![JavaScript tests](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/js-tests.yml/badge.svg)](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/js-tests.yml)
+[![Current version on PyPI](https://img.shields.io/pypi/v/django-admin-radio-select.svg)](https://pypi.org/project/django-admin-radio-select/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-admin-radio-select)](https://pypi.org/project/django-admin-radio-select/)
+[![PyPI - Django Version](https://img.shields.io/pypi/djversions/django-admin-radio-select)](https://pypi.org/project/django-admin-radio-select/)
+[![Downloads](https://static.pepy.tech/personalized-badge/django-admin-radio-select?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month)](https://pepy.tech/project/django-admin-radio-select)
+
+Synchronize BooleanFields across Django Admin inline rows as mutually exclusive radio button groups.
+
+## Problem
+
+An inline `BooleanField` column renders as independent checkboxes:
+
+```text
+Image A    [ ]
+Image B    [x]
+Image C    [ ]
+```
+
+Nothing stops you from checking more than one — but often only one row should ever be true (the primary image, the default address, the featured item). This package renders that column as radio buttons instead:
+
+```text
+Image A    ( )
+Image B    (•)
+Image C    ( )
+```
+
+Selecting one clears the others, enforced with a small vanilla JS module. Every row still POSTs under its own normal Django-generated field name (e.g. `images-0-is_primary`, `images-1-is_primary`) — nothing here relies on giving different forms the same HTML `name`. A formset-level check on the server also rejects a handcrafted POST that tries to set more than one row true, so the guarantee doesn't depend on JavaScript running at all.
+
+Inline formset, before and after clicking a different row's radio — note `is_primary` switches from "Snowy Peak" to "Frozen Lake" while the independent `is_featured` column ("Cabin") is untouched:
+
+![Inline radio-select columns](docs/screenshots/inline-radio-select.png)
+![Inline radio-select columns after clicking a different row](docs/screenshots/inline-radio-select-after-click.png)
+
+Same behavior on a `ModelAdmin` changelist, via `list_editable` (see below):
+
+![Changelist radio-select column](docs/screenshots/changelist-radio-select.png)
+
+## Install
+
+```bash
+uv add django-admin-radio-select
+# or
+pip install django-admin-radio-select
+```
+
+Add it to `INSTALLED_APPS` — it's a real Django app (with its own `AppConfig`), which is what makes `django.contrib.staticfiles` pick up its JS:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_admin_radio_select",
+]
+```
+
+## Usage
+
+```python
+from django.contrib import admin
+from django_admin_radio_select import ExclusiveRadioFieldsMixin
+
+from .models import Album, Image
+
+
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary",)
+
+
+@admin.register(Album)
+class AlbumAdmin(admin.ModelAdmin):
+    inlines = [ImageInline]
+```
+
+Works the same way with `StackedInline`:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.StackedInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary",)
+```
+
+Multiple fields are independent groups:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary", "is_featured")
+```
+
+Compute the field list per request (and, for an inline or a change form, per object) instead of (or in addition to) the class attribute:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+
+    def get_radio_select_exclusive_fields(self, request, obj=None):
+        return ("is_primary",) if request.user.is_superuser else ()
+```
+
+Whatever `get_radio_select_exclusive_fields` returns — the default above, or an override like the one above it — always gets filtered against `get_readonly_fields(request, obj)` before being used: a readonly field isn't rendered as an editable widget at all, so there's nothing to turn into a radio button. This matters for a field that's only conditionally readonly (permissions, object state, ...): without it, a field in `radio_select_exclusive_fields` that becomes readonly for some request would no longer be on the form at all and raise `ImproperlyConfigured`, for a state the admin class itself put it in. This filtering happens in a separate `_get_effective_radio_select_exclusive_fields(request, obj)` method precisely so overriding `get_radio_select_exclusive_fields` doesn't also have to reimplement it.
+
+Each configured name must be a `BooleanField` present on the **form** — anything else raises `ImproperlyConfigured` when the admin builds the formset (a `python manage.py check`-time-ish failure, not a silent no-op). "Present on the form" is deliberate: the field only has to exist there, not on the model. A field declared only on a custom `ModelForm`/`InlineModelAdmin.form` (not a real model field at all) works exactly the same as any other configured field, and so does a form field that overrides the model's own type for that name (e.g. the model has a `CharField` but the form redeclares it as a `BooleanField`) — this package never inspects the model, only `form.base_fields`.
+
+### `ModelAdmin` changelist (`list_editable`)
+
+The same mixin also works directly on a `ModelAdmin`, for a `BooleanField` column made editable in the changelist via `list_editable`. The field still has to be in `list_display` too — that's a normal Django `list_editable` requirement, unrelated to this package:
+
+```python
+@admin.register(Album)
+class AlbumAdmin(ExclusiveRadioFieldsMixin, admin.ModelAdmin):
+    list_display = ("title", "is_featured")
+    list_editable = ("is_featured",)
+    radio_select_exclusive_fields = ("is_featured",)
+```
+
+Now only one `Album` row in the whole changelist can have `is_featured` checked at a time — same client-side sync, same per-row Django field names (`form-0-is_featured`, `form-1-is_featured`, ...), same server-side exclusivity check on save.
+
+## Supported versions
+
+Python 3.10–3.13, Django 4.2–5.2. Works on `TabularInline`, `StackedInline`, and `ModelAdmin` (via `list_editable`).
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, running the example project, and the test/lint/type-check commands.

django_admin_radio_select-0.1.0/README.md

@@ -0,0 +1,127 @@
+# django-admin-radio-select
+
+[![Python tests](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/pytest.yml/badge.svg)](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/pytest.yml)
+[![JavaScript tests](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/js-tests.yml/badge.svg)](https://github.com/rodolvbg/django-admin-radio-select/actions/workflows/js-tests.yml)
+[![Current version on PyPI](https://img.shields.io/pypi/v/django-admin-radio-select.svg)](https://pypi.org/project/django-admin-radio-select/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-admin-radio-select)](https://pypi.org/project/django-admin-radio-select/)
+[![PyPI - Django Version](https://img.shields.io/pypi/djversions/django-admin-radio-select)](https://pypi.org/project/django-admin-radio-select/)
+[![Downloads](https://static.pepy.tech/personalized-badge/django-admin-radio-select?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month)](https://pepy.tech/project/django-admin-radio-select)
+
+Synchronize BooleanFields across Django Admin inline rows as mutually exclusive radio button groups.
+
+## Problem
+
+An inline `BooleanField` column renders as independent checkboxes:
+
+```text
+Image A    [ ]
+Image B    [x]
+Image C    [ ]
+```
+
+Nothing stops you from checking more than one — but often only one row should ever be true (the primary image, the default address, the featured item). This package renders that column as radio buttons instead:
+
+```text
+Image A    ( )
+Image B    (•)
+Image C    ( )
+```
+
+Selecting one clears the others, enforced with a small vanilla JS module. Every row still POSTs under its own normal Django-generated field name (e.g. `images-0-is_primary`, `images-1-is_primary`) — nothing here relies on giving different forms the same HTML `name`. A formset-level check on the server also rejects a handcrafted POST that tries to set more than one row true, so the guarantee doesn't depend on JavaScript running at all.
+
+Inline formset, before and after clicking a different row's radio — note `is_primary` switches from "Snowy Peak" to "Frozen Lake" while the independent `is_featured` column ("Cabin") is untouched:
+
+![Inline radio-select columns](docs/screenshots/inline-radio-select.png)
+![Inline radio-select columns after clicking a different row](docs/screenshots/inline-radio-select-after-click.png)
+
+Same behavior on a `ModelAdmin` changelist, via `list_editable` (see below):
+
+![Changelist radio-select column](docs/screenshots/changelist-radio-select.png)
+
+## Install
+
+```bash
+uv add django-admin-radio-select
+# or
+pip install django-admin-radio-select
+```
+
+Add it to `INSTALLED_APPS` — it's a real Django app (with its own `AppConfig`), which is what makes `django.contrib.staticfiles` pick up its JS:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_admin_radio_select",
+]
+```
+
+## Usage
+
+```python
+from django.contrib import admin
+from django_admin_radio_select import ExclusiveRadioFieldsMixin
+
+from .models import Album, Image
+
+
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary",)
+
+
+@admin.register(Album)
+class AlbumAdmin(admin.ModelAdmin):
+    inlines = [ImageInline]
+```
+
+Works the same way with `StackedInline`:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.StackedInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary",)
+```
+
+Multiple fields are independent groups:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+    radio_select_exclusive_fields = ("is_primary", "is_featured")
+```
+
+Compute the field list per request (and, for an inline or a change form, per object) instead of (or in addition to) the class attribute:
+
+```python
+class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline):
+    model = Image
+
+    def get_radio_select_exclusive_fields(self, request, obj=None):
+        return ("is_primary",) if request.user.is_superuser else ()
+```
+
+Whatever `get_radio_select_exclusive_fields` returns — the default above, or an override like the one above it — always gets filtered against `get_readonly_fields(request, obj)` before being used: a readonly field isn't rendered as an editable widget at all, so there's nothing to turn into a radio button. This matters for a field that's only conditionally readonly (permissions, object state, ...): without it, a field in `radio_select_exclusive_fields` that becomes readonly for some request would no longer be on the form at all and raise `ImproperlyConfigured`, for a state the admin class itself put it in. This filtering happens in a separate `_get_effective_radio_select_exclusive_fields(request, obj)` method precisely so overriding `get_radio_select_exclusive_fields` doesn't also have to reimplement it.
+
+Each configured name must be a `BooleanField` present on the **form** — anything else raises `ImproperlyConfigured` when the admin builds the formset (a `python manage.py check`-time-ish failure, not a silent no-op). "Present on the form" is deliberate: the field only has to exist there, not on the model. A field declared only on a custom `ModelForm`/`InlineModelAdmin.form` (not a real model field at all) works exactly the same as any other configured field, and so does a form field that overrides the model's own type for that name (e.g. the model has a `CharField` but the form redeclares it as a `BooleanField`) — this package never inspects the model, only `form.base_fields`.
+
+### `ModelAdmin` changelist (`list_editable`)
+
+The same mixin also works directly on a `ModelAdmin`, for a `BooleanField` column made editable in the changelist via `list_editable`. The field still has to be in `list_display` too — that's a normal Django `list_editable` requirement, unrelated to this package:
+
+```python
+@admin.register(Album)
+class AlbumAdmin(ExclusiveRadioFieldsMixin, admin.ModelAdmin):
+    list_display = ("title", "is_featured")
+    list_editable = ("is_featured",)
+    radio_select_exclusive_fields = ("is_featured",)
+```
+
+Now only one `Album` row in the whole changelist can have `is_featured` checked at a time — same client-side sync, same per-row Django field names (`form-0-is_featured`, `form-1-is_featured`, ...), same server-side exclusivity check on save.
+
+## Supported versions
+
+Python 3.10–3.13, Django 4.2–5.2. Works on `TabularInline`, `StackedInline`, and `ModelAdmin` (via `list_editable`).
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, running the example project, and the test/lint/type-check commands.

django_admin_radio_select-0.1.0/pyproject.toml

@@ -0,0 +1,80 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools>=68" ]
+
+[project]
+name = "django-admin-radio-select"
+version = "0.1.0"
+description = "Synchronize BooleanFields across Django Admin inline rows as mutually exclusive radio button groups."
+readme = "README.md"
+license = "MIT"
+license-files = [ "LICENSE" ]
+authors = [ { name = "Rodolfo Becerra", email = "rodolvbg@gmail.com" } ]
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Web Environment",
+  "Framework :: Django",
+  "Framework :: Django :: 4.2",
+  "Framework :: Django :: 5.0",
+  "Framework :: Django :: 5.1",
+  "Framework :: Django :: 5.2",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+dependencies = [ "django>=4.2" ]
+urls.Homepage = "https://github.com/rodolvbg/django-admin-radio-select"
+urls.Repository = "https://github.com/rodolvbg/django-admin-radio-select"
+
+[dependency-groups]
+dev = [
+  "coverage[toml]>=7.4",
+  "django-stubs[compatible-mypy]>=5",
+  "mypy>=1.10",
+  "pre-commit>=4",
+  "pytest>=8",
+  "pytest-cov>=5",
+  "pytest-django>=4.8",
+  "pytest-playwright>=0.5",
+  "ruff>=0.6",
+]
+
+[tool.setuptools]
+packages.find.where = [ "src" ]
+packages.find.include = [ "django_admin_radio_select*" ]
+package-data.django_admin_radio_select = [ "py.typed", "static/django_admin_radio_select/*.js" ]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+extend-exclude = [ "**/migrations/*.py" ]
+lint.select = [ "B", "DJ", "E", "F", "I", "UP" ]
+
+[tool.mypy]
+mypy_path = "src:example"
+python_version = "3.10"
+warn_redundant_casts = true
+warn_unused_ignores = true
+plugins = [ "mypy_django_plugin.main" ]
+
+[tool.django-stubs]
+django_settings_module = "example.settings"
+
+[tool.pytest]
+ini_options.testpaths = [ "tests" ]
+ini_options.pythonpath = [ "src", "example" ]
+ini_options.addopts = "--no-migrations --cov=django_admin_radio_select --cov-report=term-missing"
+ini_options.DJANGO_SETTINGS_MODULE = "example.settings"
+
+[tool.coverage]
+run.branch = true
+run.source = [ "django_admin_radio_select" ]
+report.show_missing = true
+report.skip_covered = true

django_admin_radio_select-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_admin_radio_select-0.1.0/src/django_admin_radio_select/__init__.py

@@ -0,0 +1,5 @@
+from .mixins import ExclusiveRadioFieldsMixin
+
+__all__ = ["ExclusiveRadioFieldsMixin"]
+
+__version__ = "0.1.0"

django_admin_radio_select-0.1.0/src/django_admin_radio_select/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DjangoAdminRadioSelectConfig(AppConfig):
+    name = "django_admin_radio_select"
+    verbose_name = "Django Admin Radio Select"

django_admin_radio_select-0.1.0/src/django_admin_radio_select/formsets.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, TypeVar
+
+from django import forms
+
+if TYPE_CHECKING:
+    from django.forms.models import BaseModelFormSet
+
+_FormSetT = TypeVar("_FormSetT", bound="BaseModelFormSet")
+
+
+def make_radio_select_exclusive_formset(
+    formset_class: type[_FormSetT], field_names: Sequence[str]
+) -> type[_FormSetT]:
+    """Return a subclass of ``formset_class`` whose ``clean()`` rejects
+    more than one non-deleted form having any of ``field_names`` set to
+    ``True``.
+
+    Works the same for an inline's formset and for a ``ModelAdmin``
+    changelist's ``list_editable`` formset — both are ``BaseModelFormSet``
+    subclasses. This is the server-side backstop for the client-side
+    radio behavior: JS keeps at most one row checked interactively, but a
+    handcrafted POST could still submit several. The check runs *after*
+    ``formset_class``'s own ``clean()`` (via ``super()``), so whatever
+    validation a user-supplied ``InlineModelAdmin.formset`` (or
+    ``ModelAdmin.get_changelist_formset``) already does keeps running
+    unchanged; this only adds to it.
+    """
+
+    class RadioSelectExclusiveFormSet(formset_class):  # type: ignore[misc,valid-type]
+        def clean(self) -> None:
+            super().clean()
+            if any(self.errors):
+                return
+
+            for field_name in field_names:
+                selected = [
+                    form
+                    for form in self.forms
+                    if not self._should_delete_form(form) and form.cleaned_data.get(field_name)
+                ]
+                if len(selected) > 1:
+                    raise forms.ValidationError(
+                        "Only one row may have '%(field)s' selected.",
+                        code="radio-select-exclusive",
+                        params={"field": field_name},
+                    )
+
+    RadioSelectExclusiveFormSet.__name__ = formset_class.__name__
+    RadioSelectExclusiveFormSet.__qualname__ = formset_class.__qualname__
+    return RadioSelectExclusiveFormSet

django_admin_radio_select-0.1.0/src/django_admin_radio_select/mixins.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from django import forms
+from django.contrib.admin.options import BaseModelAdmin
+from django.core.exceptions import ImproperlyConfigured
+
+from .formsets import make_radio_select_exclusive_formset
+from .widgets import RadioCheckboxInput
+
+if TYPE_CHECKING:
+    from django.db.models import Model
+    from django.forms.models import BaseInlineFormSet, BaseModelFormSet
+    from django.http import HttpRequest
+
+_FormSetT = TypeVar("_FormSetT", bound="BaseModelFormSet")
+
+
+class ExclusiveRadioFieldsMixin(BaseModelAdmin):
+    """Mixin for ``ModelAdmin``, ``TabularInline``, or ``StackedInline``
+    that renders the ``BooleanField``\\ s named in
+    ``radio_select_exclusive_fields`` as radio buttons, synchronized
+    client-side so selecting one clears the others in the same column —
+    while every row keeps its own Django-generated field name, so the
+    formset POST is completely unaffected.
+
+    - On an inline, this applies to every row of that inline's formset.
+    - On a ``ModelAdmin``, it applies to the changelist's
+      ``list_editable`` formset — the field must be in both
+      ``list_display`` and ``list_editable`` for Django to render it as
+      an editable column at all; ``radio_select_exclusive_fields`` only
+      controls how that column renders and is validated, same as inline.
+
+    Meant to sit before ``admin.ModelAdmin``/``admin.TabularInline``/
+    ``admin.StackedInline`` in a subclass's bases, e.g.
+    ``class ImageInline(ExclusiveRadioFieldsMixin, admin.TabularInline)``.
+    Inheriting from ``BaseModelAdmin`` — the common base of both
+    ``ModelAdmin`` and ``InlineModelAdmin`` — rather than staying a bare
+    mixin gives ``self``/``super()`` their real types for free; the
+    ``# type: ignore[misc]`` on each ``super()`` call below is only
+    because ``BaseModelAdmin`` itself doesn't declare ``get_formset``/
+    ``get_changelist_formset`` (only the concrete ``InlineModelAdmin``/
+    ``ModelAdmin`` a using class also inherits from do), so a type
+    checker can't confirm they'll exist until the two are combined.
+
+    See ``RadioCheckboxInput.media`` for how the JS gets loaded — not
+    from a ``media`` property here, since ``ModelAdmin.media`` /
+    ``InlineModelAdmin.media`` are computed the same way no matter which
+    view is asking, so a property here couldn't tell a changelist render
+    apart from a change-form render.
+    """
+
+    radio_select_exclusive_fields: Sequence[str] = ()
+
+    def get_radio_select_exclusive_fields(
+        self, request: HttpRequest, obj: Model | None = None
+    ) -> Sequence[str]:
+        return tuple(self.radio_select_exclusive_fields)
+
+    def _get_effective_radio_select_exclusive_fields(
+        self, request: HttpRequest, obj: Model | None = None
+    ) -> Sequence[str]:
+        # A readonly field is never part of form.base_fields as an
+        # editable widget (Django renders it as plain text instead), so
+        # radioizing it would either be a no-op or, if it's also missing
+        # from the form for that reason, raise ImproperlyConfigured for
+        # something the caller didn't really misconfigure — e.g. a field
+        # only made readonly for some requests via get_readonly_fields.
+        # Kept separate from get_radio_select_exclusive_fields() so this
+        # filtering applies whether or not that method is overridden.
+        readonly_fields = set(self.get_readonly_fields(request, obj))
+        return tuple(
+            field_name
+            for field_name in self.get_radio_select_exclusive_fields(request, obj)
+            if field_name not in readonly_fields
+        )
+
+    def get_formset(
+        self, request: HttpRequest, obj: Model | None = None, **kwargs: Any
+    ) -> type[BaseInlineFormSet]:
+        formset_class = super().get_formset(request, obj, **kwargs)  # type: ignore[misc]
+        field_names = self._get_effective_radio_select_exclusive_fields(request, obj)
+        return self._wrap_formset(formset_class, field_names)
+
+    def get_changelist_formset(self, request: HttpRequest, **kwargs: Any) -> type[BaseModelFormSet]:
+        formset_class = super().get_changelist_formset(request, **kwargs)  # type: ignore[misc]
+        field_names = self._get_effective_radio_select_exclusive_fields(request)
+        return self._wrap_formset(formset_class, field_names)
+
+    @staticmethod
+    def _wrap_formset(
+        formset_class: type[_FormSetT], field_names: Sequence[str]
+    ) -> type[_FormSetT]:
+        if not field_names:
+            return formset_class
+
+        prefix = formset_class.get_default_prefix()
+        ExclusiveRadioFieldsMixin._radioize_form_fields(formset_class.form, field_names, prefix)
+        return make_radio_select_exclusive_formset(formset_class, field_names)
+
+    @staticmethod
+    def _radioize_form_fields(
+        form_class: type[forms.ModelForm], field_names: Sequence[str], prefix: str
+    ) -> None:
+        for field_name in field_names:
+            field = form_class.base_fields.get(field_name)
+            if not isinstance(field, forms.BooleanField):
+                raise ImproperlyConfigured(
+                    f"{form_class.__name__}: radio_select_exclusive_fields references "
+                    f"'{field_name}', which must be a BooleanField on the form "
+                    f"(got {field.__class__.__name__ if field else 'nothing'})."
+                )
+            field.widget = RadioCheckboxInput(
+                group=f"{prefix}::{field_name}", field_name=field_name
+            )
+            # A "must be checked" BooleanField can't represent the "this
+            # row isn't the selected one" (False) state, which is a
+            # completely valid, expected state for every row but one.
+            field.required = False

django_admin_radio_select-0.1.0/src/django_admin_radio_select/static/django_admin_radio_select/radio-select.js

@@ -0,0 +1,35 @@
+(() => {
+    var SELECTOR = 'input[type="radio"].radio-select-exclusive';
+
+    function escapeAttrValue(value) {
+        if (window.CSS && typeof CSS.escape === "function") {
+            return CSS.escape(value);
+        }
+        return String(value).replace(/["\\]/g, "\\$&");
+    }
+
+    function uncheckOthersInGroup(radio) {
+        var group = radio.dataset.radioSelectGroup;
+        var selector =
+            SELECTOR +
+            '[data-radio-select-group="' +
+            escapeAttrValue(group) +
+            '"]';
+        document.querySelectorAll(selector).forEach((other) => {
+            if (other !== radio) {
+                other.checked = false;
+            }
+        });
+    }
+
+    // A single delegated listener on `document` covers inline rows added
+    // later too (Django admin's "Add another"), since `change` bubbles
+    // from any input inserted into the page — no MutationObserver or
+    // dependency on Django's internal jQuery formset events needed.
+    document.addEventListener("change", (event) => {
+        var radio = event.target;
+        if (radio.matches?.(SELECTOR) && radio.checked) {
+            uncheckOthersInGroup(radio);
+        }
+    });
+})();

django_admin_radio_select-0.1.0/src/django_admin_radio_select/widgets.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.forms.widgets import CheckboxInput
+
+
+class RadioCheckboxInput(CheckboxInput):
+    """A :class:`~django.forms.CheckboxInput` rendered with
+    ``type="radio"`` instead of ``type="checkbox"``.
+
+    ``CheckboxInput`` already POSTs exactly the way a radio-per-row needs
+    to: present in the data means checked, absent means unchecked/False.
+    Only ``input_type`` changes here, which is all Django's widget
+    templates key off of for the rendered ``type`` attribute — so a
+    ``BooleanField`` using this widget round-trips through a normal
+    Django form/formset completely unchanged; only the rendered control
+    (and therefore its default browser styling and grouping semantics)
+    is different.
+
+    ``media`` lives here rather than on the admin mixin on purpose: a
+    widget only exists once a field is actually radioized, and only ever
+    gets *rendered* as part of the specific form/formset that uses it —
+    Django aggregates a rendered page's media from exactly the
+    forms/widgets it renders. So this script only ever loads on a
+    changelist that actually has a ``list_editable`` radio column, or a
+    change view that actually has a radioized inline — never anywhere
+    else — with no extra request- or view-awareness needed here. An
+    admin-level ``media`` property couldn't do this: Django computes
+    ``ModelAdmin.media``/``InlineModelAdmin.media`` the same way
+    regardless of which view asked for it, so it can't tell "changelist"
+    from "change form" apart.
+    """
+
+    class Media:
+        js = ("django_admin_radio_select/radio-select.js",)
+
+    input_type = "radio"
+
+    def __init__(self, group: str, field_name: str, attrs: dict[str, Any] | None = None) -> None:
+        attrs = dict(attrs or {})
+        attrs["class"] = f"{attrs.get('class', '')} radio-select-exclusive".strip()
+        attrs["data-radio-select-group"] = group
+        attrs["data-radio-select-field"] = field_name
+        super().__init__(attrs=attrs)