django-htmx-base 0.1.2__py3-none-any.whl

django_htmx_base/admin.py

@@ -0,0 +1 @@
+# Register your models here.

django_htmx_base/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class BaseConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_htmx_base"
+    label = "base"

django_htmx_base/forms.py

@@ -0,0 +1,20 @@
+# django
+from django import forms
+
+# widgets
+from django_htmx_base.widgets import WidgetStylerMixin
+
+
+class BaseForm(WidgetStylerMixin, forms.Form):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.apply_widget_styles()
+
+
+class BaseModelForm(WidgetStylerMixin, forms.ModelForm):
+    class Meta:
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.apply_widget_styles()

django_htmx_base/models.py

@@ -0,0 +1,210 @@
+# standard
+import csv
+from enum import StrEnum
+from io import StringIO
+
+# django
+from django.db import models
+
+
+class FilterInputType(StrEnum):
+    CHECKBOX = "checkbox"
+    DATE = "date"
+    DATETIME_LOCAL = "datetime-local"
+    MULTISELECT = "multiselect"
+    NUMBER = "number"
+    RADIO = "radio"
+    RANGE = "range"
+    SELECT = "select"
+    TEXT = "text"
+    TIME = "time"
+
+
+def BaseField(base_field_class, **kwargs):  # noqa: N802
+    sortable = kwargs.pop("sortable", False)
+    partial = kwargs.pop("partial", None)
+    css_class = kwargs.pop("css_class", "")
+    filtrable = kwargs.pop("filtrable", False)
+    filter_input_type = FilterInputType(
+        kwargs.pop("filter_input_type", FilterInputType.TEXT)
+    )
+
+    field = base_field_class(**kwargs)
+    field.sortable = sortable
+    field.partial = partial
+    field.css_class = css_class
+    field.filtrable = filtrable
+    field.filter_input_type = filter_input_type
+
+    return field
+
+
+class BaseModel(models.Model):
+    """
+    Abstract base for all models
+    """
+
+    # fields
+    created_at = BaseField(
+        models.DateTimeField, auto_now_add=True, editable=False, sortable=True
+    )
+    updated_at = BaseField(models.DateTimeField, auto_now=True, editable=False)
+    is_active = BaseField(
+        models.BooleanField,
+        default=True,
+        filtrable=True,
+        filter_input_type=FilterInputType.SELECT,
+    )
+
+    # view attributes
+    _display_fields = ["id", "created_at", "is_active"]
+    _downloadable = True
+
+    class Meta:
+        abstract = True
+        ordering = ("-created_at",)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(id={getattr(self, 'id', None)})"
+
+    @classmethod
+    def get_filtrable_fields(cls):
+        """
+        Returns context-ready filter metadata for each filtrable field.
+        """
+        return [
+            field
+            for field in cls.get_display_fields()
+            if getattr(field, "filtrable", False)
+        ]
+
+    @classmethod
+    def get_filters_objects(cls):
+        filters = []
+
+        for field in cls.get_filtrable_fields():
+            filter_config = {
+                "field": field.name,
+                "filter_input_type": getattr(
+                    field, "filter_input_type", FilterInputType.TEXT
+                ).value,
+            }
+
+            if hasattr(field, "choices") and field.choices:
+                filter_config["options"] = [
+                    {"value": value, "label": label}
+                    for value, label in field.choices
+                    if value not in (None, "")
+                ]
+            elif isinstance(field, models.BooleanField):
+                filter_config["options"] = [
+                    {"value": "True", "label": "True"},
+                    {"value": "False", "label": "False"},
+                ]
+
+            filters.append(filter_config)
+
+        return filters
+
+    @property
+    def filters(self):
+        return self.get_filtrable_fields()
+
+    @property
+    def filters_objects(self):
+        return self.get_filters_objects()
+
+    @classmethod
+    def sortable_fields(cls):
+        """
+        Returns a list of fields that are sortable.
+        """
+        return [
+            field.name
+            for field in cls.get_display_fields()
+            if getattr(field, "sortable", False)
+        ]
+
+    @classmethod
+    def get_display_fields(cls):
+        return [
+            field
+            for field in cls._meta.get_fields()
+            if field.name in cls._display_fields
+        ]
+
+    @property
+    def display_fields(self):
+        return self.get_display_fields()
+
+    def as_list(self):
+        """Ordered values for this instance, matching ``display_fields`` order."""
+        values = []
+        for field in self.display_fields:
+            if getattr(field, "choices", None):
+                value = getattr(self, f"get_{field.name}_display")()
+            else:
+                value = getattr(self, field.name)
+
+            values.append(value)
+
+        return values
+
+    def as_field_values_objects_list(self):
+        """Ordered cells for this instance, matching ``display_fields`` order."""
+        field_objects = []
+
+        for field in self.display_fields:
+            if getattr(field, "choices", None):
+                value = getattr(self, f"get_{field.name}_display")()
+            else:
+                value = getattr(self, field.name)
+
+            field_objects.append(
+                {
+                    "field": field.name,
+                    "value": value,
+                    "partial": getattr(field, "partial", None),
+                    "class": getattr(field, "css_class", ""),
+                }
+            )
+
+        return field_objects
+
+    @classmethod
+    def to_csv(cls, queryset):
+        output = StringIO(newline="")
+        writer = csv.writer(output)
+        writer.writerow(field.name for field in cls.get_display_fields())
+
+        for object in queryset:
+            writer.writerow(object.as_list())
+
+        return output.getvalue()
+
+    @classmethod
+    def as_field_names_objects_list(cls):
+        columns = []
+
+        for field in cls.get_display_fields():
+            column = {
+                "field": field.name,
+                "sortable": getattr(field, "sortable", False),
+                "filtrable": getattr(field, "filtrable", False),
+            }
+
+            partial = getattr(field, "partial", None)
+            if partial:
+                column["partial"] = partial
+
+            css_class = getattr(field, "css_class", None)
+            if css_class:
+                column["class"] = css_class
+
+            columns.append(column)
+
+        return columns
+
+    @classmethod
+    def is_downloadable(cls):
+        return cls._downloadable

django_htmx_base/routers.py

@@ -0,0 +1,157 @@
+from django.core.exceptions import ImproperlyConfigured
+from django.urls import path
+
+from django_htmx_base.viewsets import HtmxAction
+
+
+class Route:
+    def __init__(self, url, mapping, name, detail):
+        self.url = url
+        self.mapping = mapping
+        self.name = name
+        self.detail = detail
+
+
+class HtmxRouter:
+    """
+    Generate CRUD URL patterns for HtmxViewSet classes.
+    """
+
+    routes = [
+        Route(
+            url="",
+            mapping={"get": HtmxAction.LIST},
+            name=HtmxAction.LIST,
+            detail=False,
+        ),
+        Route(
+            url=HtmxAction.CREATE,
+            mapping={"get": HtmxAction.CREATE, "post": HtmxAction.CREATE},
+            name=HtmxAction.CREATE,
+            detail=False,
+        ),
+        Route(
+            url="{pk}",
+            mapping={"get": HtmxAction.DETAIL},
+            name=HtmxAction.DETAIL,
+            detail=True,
+        ),
+        Route(
+            url=f"{{pk}}/{HtmxAction.EDIT}",
+            mapping={
+                "get": HtmxAction.CREATE,
+                "post": HtmxAction.EDIT,
+                "put": HtmxAction.EDIT,
+                "patch": HtmxAction.EDIT,
+            },
+            name=HtmxAction.EDIT,
+            detail=True,
+        ),
+        Route(
+            url=f"{{pk}}/{HtmxAction.DELETE}",
+            mapping={
+                "get": HtmxAction.CREATE,
+                "post": HtmxAction.DESTROY,
+                "delete": HtmxAction.DESTROY,
+            },
+            name=HtmxAction.DELETE,
+            detail=True,
+        ),
+    ]
+
+    def __init__(self):
+        self.registry = []
+
+    def register(self, prefix, viewset, basename=None):
+        if basename is None:
+            basename = self.get_default_basename(viewset)
+
+        viewset.router = self
+
+        self.registry.append((prefix.strip("/"), viewset, basename))
+
+    def get_default_basename(self, viewset):
+        model = getattr(viewset, "model", None)
+        if model is not None:
+            return model._meta.model_name
+
+        queryset = getattr(viewset, "queryset", None)
+        if queryset is not None and hasattr(queryset, "model"):
+            return queryset.model._meta.model_name
+
+        raise ImproperlyConfigured(
+            "%(cls)s is missing a basename. Pass basename=... to register(), "
+            "or define %(cls)s.model or %(cls)s.queryset." % {"cls": viewset.__name__}
+        )
+
+    @property
+    def urls(self):
+        urls = []
+
+        for prefix, viewset, basename in self.registry:
+            pk = self.get_pk_path(viewset)
+
+            for route in self.get_routes(viewset):
+                mapping = self.get_method_map(viewset, route.mapping)
+                if not mapping:
+                    continue
+
+                route_url = route.url.format(pk=pk)
+                url = self.build_url(prefix, route_url)
+                view = viewset.as_view(
+                    mapping,
+                    basename=basename,
+                    route_detail=route.detail,
+                    route_action=route.name,
+                )
+                urls.append(path(url, view, name=f"{basename}-{route.name}"))
+
+        return urls
+
+    def get_routes(self, viewset):
+        return [*self.routes, *self.get_extra_routes(viewset)]
+
+    def get_extra_routes(self, viewset):
+        if not hasattr(viewset, "get_extra_actions"):
+            return []
+
+        routes = []
+
+        for extra_action in viewset.get_extra_actions():
+            url_path = getattr(extra_action, "url_path", None)
+            url = url_path or extra_action.__name__
+
+            if extra_action.detail:
+                url = "{pk}/%s" % url
+
+            routes.append(
+                Route(
+                    url=url,
+                    mapping=extra_action.mapping,
+                    name=extra_action.url_name,
+                    detail=extra_action.detail,
+                )
+            )
+
+        return routes
+
+    def get_pk_path(self, viewset):
+        pk_url_kwarg = getattr(viewset, "pk_url_kwarg", "pk")
+        return "<int:%s>" % pk_url_kwarg
+
+    def get_method_map(self, viewset, mapping):
+        return {
+            method: action
+            for method, action in mapping.items()
+            if hasattr(viewset, action)
+        }
+
+    def build_url(self, prefix, route_url):
+        if prefix and route_url:
+            url = f"{prefix}/{route_url}"
+        else:
+            url = prefix or route_url
+
+        if url:
+            return url + "/"
+        return ""

django_htmx_base/tests.py

@@ -0,0 +1 @@
+# Create your tests here.

django_htmx_base/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from . import views
+
+app_name = "base"
+
+urlpatterns = [
+    path("ping/", views.ping, name="ping"),
+]

django_htmx_base/views.py

@@ -0,0 +1,7 @@
+from django.shortcuts import render
+from django.views.decorators.http import require_POST
+
+
+@require_POST
+def ping(request):
+    return render(request, "partials/ping_result.html", {"ok": True})