django-pudding 0.1.0__py3-none-any.whl

django_pudding-0.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: django-pudding
+Version: 0.1.0
+Summary: Declarative Python framework for Django to build dashboards and internal apps fast.
+Author: Zishan Kadri
+Author-email: Zishan Kadri <zishankadri01@gmail.com>
+License-Expression: MIT
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Dist: django>=5.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

django_pudding-0.1.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+pudding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pudding/actions/__init__.py,sha256=sfLGmJPUltuj05bfWi3u9ZhWSSWerfMTSF373dtKFyU,409
+pudding/actions/base.py,sha256=jNcT5dHMf9CX4f2pxaNAsTXWZFIKZCJFFYvJQk5Idjc,3463
+pudding/actions/contracts.py,sha256=6Ez-Pep-UQpQUONE5bWfM05DiZ4K_Kf1BZf-17epM1Q,686
+pudding/actions/defaults/__init__.py,sha256=8uWeFCnvcH9D6eDv1iKbbnYr3CTaha6g2vfvmBxIp9A,83
+pudding/actions/defaults/add.py,sha256=Ldl53Cm03LhkhuGdWmpLVtGB5pIxjZghcw9ehsvA2bI,4695
+pudding/actions/defaults/delete.py,sha256=sEzvq6hIDYMrafxsoZ5bTISZQJGVY-DqYeSS-TCTDAU,2779
+pudding/actions/defaults/edit.py,sha256=qbqaP1iSsJGN42mREcfrpLNKVIK5jK4jtp--bU1_-Lg,2640
+pudding/actions/defaults/utils.py,sha256=o8KhUB2UFLkUzdsMxEbjtOt338GDANiDawk6NpvVL5s,2958
+pudding/actions/defaults/view.py,sha256=pxCp6o5N-tUfKvRT1T-clDqyDXFcN9DbWydes-hzrxU,2686
+pudding/actions/registry.py,sha256=IGhx6IAZGlu0LbePTlhF_HtO_nDQ8nU7pWwW-MLFMeA,2114
+pudding/actions/utils.py,sha256=YR3wEIl4b3t2wVtaffFgoJtbmrmCTNgHL5RSiNzRkO8,79
+pudding/apps.py,sha256=00yy-yWffkc-3Ytb9dRVwG2ReoZ6-t_pmanWFKHPlaQ,168
+pudding/domains/__init__.py,sha256=bn3AIzXmDLx-mhc551kG0eVYGsHja99xpyr0UFGByMM,152
+pudding/domains/base.py,sha256=w-sUw8whYOx6aFKSRUtM3Jfx2-ziE7Hb0IT2QJ_wyi0,2022
+pudding/domains/registry.py,sha256=vKfFNJgGVGmm0CXQ7Ow-OLvBsiJO-RzLZ7QV2dM-yg0,1743
+pudding/exceptions.py,sha256=SIWNQ3V5uBz_gqbh7fYL-xgI0KoBSaU4VdN-XY4nl6Q,325
+pudding/forms.py,sha256=UmAjuQqhAUMGTWw4nYVsEzsNaQ5yiniiaO-hbb0LotI,929
+pudding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pudding/static/pudding/css/styles.css,sha256=cbos25luLxGCJwfqXbjWqiU04wieyrRYLH72fHGOJUU,60293
+pudding/static/pudding/js/bundle.min.js,sha256=WxJEjnQZhLX-wAhZlqIxbLx7upQi5eF04HzWnlZfpzA,640704
+pudding/static/pudding/js/bundle.min.js.map,sha256=SLgK7HacKuH9LQhXBTNzE_raPZ6O70hOZ3PLHfajbBM,3487076
+pudding/templates/pudding/base.html,sha256=YgkCrglHBM1XRjWPRqNWpEdafhLzZwvl7pNOXUsXCzI,1697
+pudding/templates/pudding/components/actions/dropdown.html,sha256=XWVUZqPvsFRju16nLpBJFVD6JP_lHjj5N-QQ64w2Ro8,544
+pudding/templates/pudding/components/form.html,sha256=9A7LruNND2PnxquIPWyhxhXwMf-xv3PaRKfV-RoFdjY,1105
+pudding/templates/pudding/components/messages.html,sha256=6649SPa-O4wTdIKBpn3Vaa0vCwu2c4Ks862Z-seg-OU,2162
+pudding/templates/pudding/components/overlays/modal.html,sha256=2ooQRGc5udxxqxRDnM7ty5HiLXdaTzYm1ZRjiC8fAew,1142
+pudding/templates/pudding/components/sidebar.html,sha256=T-UGUlW2JgWEOI8SG1aWJ8zHHdujeEk0TxtNUB4Olns,542
+pudding/templates/pudding/components/table/_table_empty_state.html,sha256=b0j4hQeGUwamms1kJX7GU-koWFC24KG1r1I5sr2kCFM,1038
+pudding/templates/pudding/components/table/header_checkbox.html,sha256=zH-UAPJLHD9s-Ib7Pb27udUzZjI_D8BZjEcTCGxgBLA,1255
+pudding/templates/pudding/components/table/pagination.html,sha256=wv_McMLC2CJiRMWOzwB3sFZftjdQB8yrXuYX4_6nCxM,2473
+pudding/templates/pudding/components/table/table.html,sha256=CA6Xm_FTGiz1c8LLB_KssaT4gJomPOrTHgI-0LmWOKQ,2246
+pudding/templates/pudding/components/table/table_cell.html,sha256=4EAkA0HXoutzUyxoe0HnKX8q6JCESv9LJY0YNpS6lc0,202
+pudding/templates/pudding/components/table/table_controls.html,sha256=aR2nqDw3PxR_O1XQ8xlC_iMDfLNev2vPLXgwlVCM8Vs,4199
+pudding/templates/pudding/components/table/table_row.html,sha256=1s7NkjmzwRuXJAdh8ttRz5UXMWpDRKuynTfBss_VQ7o,2556
+pudding/templates/pudding/frames/modal_frame.html,sha256=GuW_XhKK7iK9OKeMEdLu4nweWsJqEwHKc7hxWBxyNVw,2464
+pudding/templates/pudding/frames/view_frame.html,sha256=NjSX7RMem6tAEYBUkS2RZgFRPszWzxSyBOzn4J4HrWI,1265
+pudding/templates/pudding/table.html,sha256=KVzKWnjVWc63eP9nwK1HOZ9CwJbwdPekQ6uPzc3yBZ8,381
+pudding/templates/pudding/table_columns/profile.html,sha256=iSKm2Cgk5BKW92pFWRnAMSJknFK3GbMdzQXkfNdX37Y,421
+pudding/ui/__init__.py,sha256=e4yvBvm_31KKxluynb5yYrhmvF3ovbjCnAFu8b1GbEc,998
+pudding/ui/_types.py,sha256=6Sju3bz4-RI71gqBEQLFWCbDTA3XU0to61VGqsoqVTk,252
+pudding/ui/breadcrumbs.py,sha256=MZBb0liF0vY-lVh6YylXU-SGHWKaee3qwfII4d1btOc,2581
+pudding/ui/buttons/__init__.py,sha256=qaSO0dzmk4yIuaKdaNtyNhMzj0OczPDkQLjTvZHBmFM,441
+pudding/ui/buttons/base.py,sha256=5rjASdBOsLi-4d9FJ1adGsx2Em_MllODM2RobcNZGow,4671
+pudding/ui/buttons/looks.py,sha256=1joQwgx0EG64E-uS7DTO2SWB-5vKn-WhBmc6k_Zb76Y,3598
+pudding/ui/buttons/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pudding/ui/buttons/wrappers/base.py,sha256=-k3PGO4qva7wG3FhB28aQ82BWIE8X3UeXi3Ap8dDq2o,2224
+pudding/ui/buttons/wrappers/factories.py,sha256=_uD1O3HxyYIfd0zDIjSlW239eTGQJGAwYWTywjTsR88,2753
+pudding/ui/contracts.py,sha256=gQNz0tJjvpAIiwh4Itt_-Wr_5joFBaYFao7_wyBdR8k,1223
+pudding/ui/frames/__init__.py,sha256=Bpsj_5o0PwWh7mcf-qkiPQ2t1xZiy1RHCxmHyHyO7qw,399
+pudding/ui/frames/base.py,sha256=_KonO2-nbAbBCeNm0hSzdCCbM8KmJpvLt6rBee3rIJ8,4928
+pudding/ui/frames/frame_response.py,sha256=EoG73Dx1nOr8IfPuVMiJEtPaPuaJaBHhq759jnA1ZYM,2308
+pudding/ui/frames/modal.py,sha256=fEHx0LcHbU_Z6ZiDY7nGyCuiTms9bGxpvsWuDWt7LoY,5998
+pudding/ui/hooks/__init__.py,sha256=HnhAx2DmoeiXFsdKHllVQF5lBH3na0Ia8JwgHL8lVPE,72
+pudding/ui/hooks/modal.py,sha256=ga1wnKL4dmQdKQs8-rjh_b99zEuVxAIsjIEa7XJnypY,471
+pudding/ui/sidebar/sidebar.py,sha256=eYJa-PRLNExOI38PyBBY00Mq4rvbBXJ8bbdOwoDO6fs,644
+pudding/ui/tables/__init__.py,sha256=cwcQjyrR448HL-5XNcH8e7azB_gAIegzNkECtv5_3iE,62
+pudding/ui/tables/base.py,sha256=kd4Lr7oTpJp3GABdRAjtznpNHIH_2KL-nlbAOpw0LZ4,4673
+pudding/ui/tables/columns/base.py,sha256=radRlAlR0l6QqR8pRfgKhZbcpWGVNJd4SUhuJdLTCRo,2120
+pudding/ui/tables/columns/column_formatters.py,sha256=_lQKpg_JiaqU4KYZ8chIGdDSeIgmv1zofcDUdf6xeV8,3142
+pudding/ui/tables/columns/column_renderers.py,sha256=vmsv-Z4rJiajdiu9eoJN35DxeFgVyoZt2M3wzJSmvLM,3297
+pudding/ui/tables/table_row.py,sha256=7reENpnh3utH8lWXOBc4XBxuRiriesRjpfV1kwob6jE,1662
+pudding/ui/utils.py,sha256=JOxaoKQyNGm2EMSkkCXPWiwObUNMY6PzSbPSbptN0Co,2409
+pudding/urls.py,sha256=mx8zYFZ4B52wP2d5yDMV9YXcf_6FcQao1vlF3TzGitg,209
+pudding/views.py,sha256=WPbdcx3eMMQ_BE7bFx3mp6wax-kOH61VpP82OjwAsds,1055
+django_pudding-0.1.0.dist-info/WHEEL,sha256=EmLkUISDECbcUx3FMCYOqokNOJqNp2r0d4mJzjErvvs,80
+django_pudding-0.1.0.dist-info/METADATA,sha256=VMt8qBzEphZxrUwWOtCqYki8Qpdmw3x5oYpNuqlCgoo,949
+django_pudding-0.1.0.dist-info/RECORD,,

django_pudding-0.1.0.dist-info/WHEEL

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

pudding/actions/__init__.py

@@ -0,0 +1,9 @@
+from pudding.actions.base import action_handler
+from pudding.actions.contracts import Action
+from pudding.actions.defaults.add import Add
+from pudding.actions.defaults.delete import Delete
+from pudding.actions.defaults.edit import Edit
+from pudding.actions.defaults.view import View
+from pudding.actions.utils import is_htmx
+
+__all__ = ["Action", "Add", "Delete", "Edit", "View", "action_handler", "is_htmx"]

pudding/actions/base.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from django.http import HttpRequest, HttpResponse, HttpResponseNotAllowed
+
+from pudding import ui
+from pudding.actions.contracts import ActionHook, ActionStep
+
+
+@dataclass(kw_only=True)
+class InteractiveAction(ABC):
+    """
+    Base class for actions requiring user interaction (like confirmation or forms)
+    before the backend logic runs.
+    """
+
+    slug: str
+    icon: str | None = None
+    permission: Callable[[HttpRequest], bool] | None = None
+
+    def handle(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        match request.method:
+            case "GET":
+                return self.before(request, ctx)
+            case "POST":
+                return self.execute(request, ctx)
+            case _:
+                return HttpResponseNotAllowed(["GET", "POST"])
+
+    @abstractmethod
+    def before(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse: ...
+
+    @abstractmethod
+    def execute(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse: ...
+
+
+@dataclass(kw_only=True)
+class FunctionalAction:
+    slug: str
+    trigger: ui.Trigger
+    icon: str | None = None
+    permission: Callable[[HttpRequest], bool] | None = None
+
+    execute: ActionStep | None = None
+    before: ActionStep | None = None
+
+    allowed_methods: list[str] = field(init=False, repr=False)
+
+    def __post_init__(self):
+        allowed = []
+        if self.before:
+            allowed.append("GET")
+        if self.execute:
+            allowed.append("POST")
+
+        if not allowed:
+            raise ValueError("At least one of `execute` or `before` must be provided.")
+
+        self.allowed_methods = allowed
+
+    def handle(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        if request.method == "GET" and self.before:
+            return self.before(self, request, ctx)
+
+        if request.method == "POST" and self.execute:
+            return self.execute(self, request, ctx)
+
+        return HttpResponseNotAllowed(self.allowed_methods)
+
+    def __repr__(self):
+        return (
+            f"FunctionalAction("
+            f"slug={self.slug!r}, "
+            f"execute={getattr(self.execute, '__name__', None)!r}, "
+            f"before={getattr(self.before, '__name__', None)!r})"
+        )
+
+
+def action_handler(
+    *,
+    slug: str,
+    label: str | None = None,
+    icon: str | None = None,
+    before: ActionHook | Callable | None = None,
+    permission: Callable[[HttpRequest], bool] | None = None,
+) -> Callable[[Callable], FunctionalAction]:
+    def decorator(func: Callable) -> FunctionalAction:
+        display_label = label or slug.replace("_", " ").replace("-", " ").capitalize()
+        trigger = ui.action(
+            slug,
+            label=display_label,
+            icon=icon,
+        )
+
+        before_func = None
+
+        if isinstance(before, ActionHook):
+            frame = before.frame
+            before_func = before.before
+            trigger = trigger(**frame.loading_mod)
+        elif callable(before):
+            before_func = before
+
+        action = FunctionalAction(
+            slug=slug,
+            icon=icon,
+            trigger=trigger,
+            execute=func,
+            before=before_func,
+            permission=permission,
+        )
+
+        return action
+
+    return decorator

pudding/actions/contracts.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from pudding.ui.frames.base import Frame
+
+from django.http import HttpRequest, HttpResponse
+
+
+@runtime_checkable
+class Action(Protocol):
+    slug: str
+    icon: str | None
+    permission: Callable[[HttpRequest], bool] | None
+
+    def handle(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse: ...
+
+
+type ActionStep = Callable[[Action, HttpRequest, dict[str, Any]], HttpResponse]
+
+
+@dataclass(frozen=True, slots=True)
+class ActionHook:
+    frame: Frame
+    before: ActionStep

pudding/actions/defaults/__init__.py

@@ -0,0 +1,3 @@
+from . import add, delete, edit, view
+
+__all__ = ["add", "delete", "edit", "view"]

pudding/actions/defaults/add.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from django.contrib import messages
+from django.http import HttpRequest, HttpResponse
+from django.shortcuts import render
+from django.template.loader import render_to_string
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+from pudding import actions, ui
+from pudding.actions.base import InteractiveAction
+from pudding.actions.defaults.utils import (
+    build_sidebar_from_domains,
+    get_form_class,
+)
+
+
+def get_content(self, form, request, ctx):
+    submit_btn = ui.action(
+        self.slug,
+        label=_("Save"),
+        method="post",
+        look=ui.looks.button(variant="solid"),
+    )
+
+    form_id = "modal-form"
+    validity_guard = (
+        f"const f = document.getElementById('{form_id}');"
+        " if (!f.checkValidity()) { event.preventDefault(); f.reportValidity(); }"
+    )
+    submit_btn = submit_btn(
+        attrs={
+            "form": form_id,
+            "hx-on::before-request": validity_guard,
+            "hx-encoding": "multipart/form-data",
+        }
+    )
+    form_html = render_to_string(
+        "pudding/components/form.html",
+        {"form": form, "form_id": form_id},
+        request=request,
+    )
+
+    submit_btn = submit_btn.render(ctx=ctx)
+
+    return form_html, submit_btn
+
+
+class Add(InteractiveAction):
+    def __init__(
+        self,
+        slug: str = "add",
+        icon: str | None = "plus",
+        modal_frame: ui.Frame = ui.modal_frame,
+        **kwargs,
+    ):
+        self.modal_frame = modal_frame
+        super().__init__(slug=slug, icon=icon, **kwargs)
+
+    def before(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        domain = ctx["domain"]
+        model = domain.model
+
+        pks = request.POST.getlist("pks[]") or request.GET.getlist("pks[]")
+
+        FormClass = get_form_class(model=model)
+
+        base_label = _(model._meta.verbose_name_plural).title()
+        breadcrumbs = ui.Breadcrumbs(
+            children=tuple(
+                [
+                    ui.action("view", label=base_label, icon=domain.icon),
+                    ui.BreadcrumbLabel(label=_("Add"), icon="plus"),
+                ]
+            )
+        ).render(request=request, ctx=ctx)
+
+        form_html, submit_btn = get_content(
+            self, form=FormClass(), request=request, ctx=ctx
+        )
+        header_triggers = format_html(
+            '<div hx-vals="{ids}" class="flex gap-2 items-center"> {submit}</div>',
+            ids=json.dumps({"pks[]": pks}),
+            submit=submit_btn,
+        )
+
+        if actions.is_htmx(request):
+            return ui.ship(
+                ui.view_frame.fill(form_html),
+                ui.breadcrumb_frame.fill(breadcrumbs),
+                ui.header_triggers_frame.fill(header_triggers),
+                push_action_url={"action_slug": "add", "domain_slug": domain.slug},
+            )
+
+        context = ctx | {
+            "sidebar": build_sidebar_from_domains(ctx=ctx),
+            "breadcrumbs": ui.breadcrumb_frame(default_content=breadcrumbs).render(
+                request=request
+            ),
+            "view_area": ui.view_frame(default_content=form_html).render(
+                request=request
+            ),
+            "modal_frame": self.modal_frame.render(request=request),
+            "header_actions": ui.header_triggers_frame(
+                default_content=header_triggers
+            ).render(request=request),
+        }
+        response = render(request, "pudding/table.html", context)
+        return response
+
+    def execute(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        domain = ctx["domain"]
+        model = domain.model
+
+        FormClass = get_form_class(model=model)
+
+        form = FormClass(request.POST, request.FILES)
+        if form.is_valid():
+            form.save()
+            messages.success(
+                request,
+                _("{name} created successfully!").format(
+                    name=_(model._meta.verbose_name.capitalize())
+                ),
+            )
+            response = HttpResponse(status=204)
+            response["HX-Redirect"] = reverse(
+                "pudding:run_action",
+                kwargs={
+                    "domain_slug": domain.slug,
+                    "action_slug": "view",
+                },
+            )
+            return response
+        else:
+            form_html, submit_btn = get_content(
+                self, form=form, request=request, ctx=ctx
+            )
+            return ui.ship(
+                ui.view_frame.fill(form_html), ui.header_triggers_frame.fill(submit_btn)
+            )

pudding/actions/defaults/delete.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib import messages
+from django.http import Http404, HttpRequest, HttpResponse
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django.utils.translation import ngettext
+
+from pudding import ui
+from pudding.actions.base import InteractiveAction
+from pudding.ui.frames.base import Frame
+
+
+class Delete(InteractiveAction):
+    def __init__(
+        self,
+        slug: str = "delete",
+        icon: str | None = "trash-2",
+        modal_frame: Frame = ui.modal_frame,
+        *args,
+        **kwargs,
+    ):
+        self.modal_frame = modal_frame
+        super().__init__(slug=slug, icon=icon, *args, **kwargs)
+
+    def before(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        domain = ctx["domain"]
+        model = domain.model
+
+        opts = model._meta
+        queryset = ctx["queryset"]
+        count = queryset.count()
+        if count == 0:
+            raise Http404(_("No items selected for deletion."))
+
+        if count == 1:
+            title = str(queryset.first())
+        else:
+            title = ngettext(
+                "{count} {model_name}", "{count} {model_name_plural}", count
+            ).format(
+                count=count,
+                model_name=opts.verbose_name,
+                model_name_plural=opts.verbose_name_plural,
+            )
+        return ui.ship(
+            self.modal_frame.fill(
+                ui.ActionModal(
+                    action=self,
+                    eyebrow=_("Delete"),
+                    title=title,
+                    button=lambda btn: btn(look=ui.looks.button(variant="danger")),
+                    icon_color="danger",
+                ).render(ctx=ctx)
+            )
+        )
+
+    def execute(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        model = ctx["domain"].model
+
+        opts = model._meta
+        queryset = ctx["queryset"]
+        count = queryset.count()
+        if count == 0:
+            raise Http404(_("No items selected for deletion."))
+
+        queryset.delete()
+
+        success_message = ngettext(
+            "Deleted {count} {model_name}.",
+            "Deleted {count} {model_name_plural}.",
+            count,
+        ).format(
+            count=count,
+            model_name=opts.verbose_name,
+            model_name_plural=opts.verbose_name_plural,
+        )
+
+        messages.success(request, success_message)
+        response = HttpResponse()
+        response["HX-Redirect"] = reverse(
+            "pudding:run_action",
+            kwargs={
+                "domain_slug": ctx["domain"].slug,
+                "action_slug": "view",
+                "step": "init",
+            },
+        )
+        return response

pudding/actions/defaults/edit.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib import messages
+from django.http import HttpRequest, HttpResponse
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+
+from pudding import ui
+from pudding.actions.base import InteractiveAction
+from pudding.actions.defaults.utils import get_form_class
+
+
+class Edit(InteractiveAction):
+    def __init__(
+        self,
+        slug: str = "edit",
+        icon: str | None = "pen-line",
+        fields: list[str] | None = None,
+        exclude: list[str] | None = None,
+        dock_actions: list[ui.Trigger] | None = None,
+        modal_frame: ui.Frame = ui.modal_frame,
+        **kwargs,
+    ):
+        self.fields = fields
+        self.exclude = exclude
+        self.dock_actions: list[ui.Trigger] = dock_actions or []
+        self.modal_frame = modal_frame
+
+        super().__init__(slug=slug, icon=icon, **kwargs)
+
+    def before(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        domain = ctx["domain"]
+        model = domain.model
+
+        FormClass = get_form_class(model=model)
+
+        instance = ctx["queryset"][0] if ctx["queryset"] else None
+        form = FormClass(instance=instance)
+
+        return ui.ship(
+            self.modal_frame.fill(
+                ui.ActionModal(
+                    action=self, form=form, icon=None, title=f"Edit {instance}"
+                ).render(ctx=ctx)
+            )
+        )
+
+    def execute(self, request: HttpRequest, ctx: dict[str, Any]) -> HttpResponse:
+        domain = ctx["domain"]
+        model = domain.model
+
+        FormClass = get_form_class(model=model)
+
+        instance = ctx["queryset"][0] if ctx["queryset"] else None
+        form = FormClass(request.POST, request.FILES, instance=instance)
+        if form.is_valid():
+            form.save()
+            messages.success(
+                request,
+                _("{name} edited successfully!").format(
+                    name=_(model._meta.verbose_name.capitalize())
+                ),
+            )
+            response = HttpResponse(status=204)
+            response["HX-Redirect"] = reverse(
+                "pudding:run_action",
+                kwargs={
+                    "domain_slug": domain.slug,
+                    "action_slug": "view",
+                },
+            )
+            return response
+        else:
+            return ui.ship(
+                self.modal_frame.fill(
+                    ui.ActionModal(
+                        action=self, form=form, icon=None, title=f"Edit {instance}"
+                    ).render(ctx=ctx)
+                )
+            )

pudding/actions/defaults/utils.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from django.db import models
+    from django.http import HttpRequest
+
+    from pudding.ui import Trigger
+
+from django import forms
+from django.db import models
+from django.forms import modelform_factory
+from django.utils.html import format_html_join
+
+from pudding import domains, ui
+from pudding.forms import StyledModelForm
+
+
+def formfield_for_dbfield(db_field, **kwargs):
+    """Return a form field with widgets based on the model field type"""
+    # Make a copy of kwargs because modelform_factory passes extra args
+    formfield_kwargs = kwargs.copy()
+
+    if isinstance(db_field, models.DateTimeField):
+        formfield_kwargs["widget"] = forms.DateTimeInput(
+            attrs={"type": "datetime-local"},
+            format="%Y-%m-%dT%H:%M",
+        )
+    elif isinstance(db_field, models.DateField):
+        formfield_kwargs["widget"] = forms.DateInput(
+            attrs={"type": "date"},
+            format="%Y-%m-%d",
+        )
+    elif isinstance(db_field, models.TextField):
+        formfield_kwargs["widget"] = forms.Textarea()
+
+    formfield = db_field.formfield(**formfield_kwargs)
+
+    # Ensure initial value formatting works
+    if isinstance(db_field, (models.DateTimeField, models.DateField)):
+        formfield.input_formats = [formfield.widget.format]
+
+    return db_field.formfield(**formfield_kwargs)
+
+
+def get_editable_fields(model, fields=None):
+    """Return fields suitable for ModelForm, excluding non-editable fields"""
+    all_fields = fields if fields else [f.name for f in model._meta.fields]
+    editable_fields = [f for f in all_fields if model._meta.get_field(f).editable]
+
+    return editable_fields
+
+
+def get_form_class(
+    *,
+    model: type[models.Model],
+    fields=None,
+    exclude=None,
+    form_class: type[forms.ModelForm] = StyledModelForm,
+    widgets=None,
+) -> type[forms.ModelForm]:
+    fields = get_editable_fields(model, fields)
+
+    return modelform_factory(
+        model,
+        form=form_class,
+        fields=fields,
+        exclude=exclude,
+        widgets=widgets,
+        formfield_callback=formfield_for_dbfield,
+    )
+
+
+def render_actions(
+    actions: list[Trigger], request: HttpRequest | None, ctx: dict
+) -> str:
+    actions_html = format_html_join(
+        "",
+        "{}",
+        ((action.render(request=request, ctx=ctx),) for action in actions),
+    )
+    return actions_html
+
+
+def build_sidebar_from_domains(ctx: dict[str, Any]):
+    sidebar_items = []
+    for slug, domain_class in domains.get_all().items():
+        item = ui.action(
+            "view",
+            label=slug,
+            icon=getattr(domain_class, "icon", None),
+            look=ui.looks.sidebar_item(activation_id=slug),
+        ).with_local_context(domain=domain_class)
+
+        sidebar_items.append(item)
+
+    return ui.sidebar(
+        ctx=ctx, sidebar_items=sidebar_items, active_id=ctx["domain"].slug
+    )