django-handyhelpers 0.3.20__py3-none-any.whl → 0.3.36__py3-none-any.whl

{django_handyhelpers-0.3.20.dist-info → django_handyhelpers-0.3.36.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

handyhelpers/__init__.py

@@ -6,9 +6,9 @@ A collection of handy utilities to support django operations.
 :license: GPL-3.0. See LICENSE for more details
 """
 
-__title__ = 'django-handyhelpers'
-__version__ = '0.3.20'
-__author__ = 'David Slusser'
-__email__ = 'dbslusser@gmail.com'
-__license__ = 'GPL-3.0'
-__copyright__ = 'Copyright 2018 David Slusser'
+__title__ = "django-handyhelpers"
+__version__ = "0.3.36"
+__author__ = "David Slusser"
+__email__ = "dbslusser@gmail.com"
+__license__ = "GPL-3.0"
+__copyright__ = "Copyright 2018 David Slusser"

handyhelpers/forms.py

@@ -1,6 +1,6 @@
 from django import forms
 
-from .mixins.form_mixins import SetRequiredMixin
+from .mixins.form_mixins import SetRequiredMixin, HtmxFormMixin
 
 
 class SetRequiredModelForm(SetRequiredMixin, forms.ModelForm):
@@ -35,3 +35,11 @@ class TimestampFilter(forms.Form):
                                       required=False, label='Updated After')
     updated_at__lte = forms.DateField(widget=forms.DateInput(attrs={'class': 'form-control', 'type': 'date'}),
                                       required=False, label='Updated Before')
+
+
+class HtmxModelForm(HtmxFormMixin, forms.ModelForm):
+    """ ModelForm class with the HtmxFormMixin included """
+
+
+class HtmxForm(HtmxFormMixin, forms.Form):
+    """ Form class with the HtmxFormMixin included """

handyhelpers/mixins/form_mixins.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.template.loader import get_template
 
 
 class SetRequiredMixin:
@@ -29,3 +30,63 @@ class SetRequiredMixin:
         if getattr(self.Meta, 'required', None):
             for field in self.Meta.required:
                 self.fields[field].required = True
+
+
+class HtmxFormMixin:
+    """ mixin class for rendering a Bootstrap 5 form intended to be used with a HTMX view.
+    Usage Example:
+    
+    from handyhelpers.forms import HtmxModelForm
+    
+    class ContactRequestForm(HtmxModelForm):
+        hx_post = "/contact_request"
+        hx_target = "contact-request-form"
+        success_message = "Contact request received; we'll be in touch soon!"
+        
+        class Meta:
+            model = ContactRequest
+            fields = ["name", "email", "phone_number", "message"]
+
+            labels = {
+                "name": "Full Name",
+                "email": "Email Address",
+                "phone_number": "Phone Number",
+                "message": "Your Message",
+            }   
+    """
+    hx_post = None
+    hx_target = None
+    hx_trigger = "submit"
+    hx_swap = "innerHTML"
+    success_message = None
+    use_alert_for_success_message = False
+    template_name = "handyhelpers/htmx/bs5/form/inline_form.htm"
+    template_disabled_name = "handyhelpers/htmx/bs5/form/inline_form_disabled.htm"
+    align = "start" # can be 'start', 'end', 'center'
+    disable_on_success = True
+
+    def as_bs5(self):      
+        template = get_template(self.template_name)
+        context = {
+            "hx_post": self.hx_post,
+            "hx_trigger": self.hx_trigger,
+            "hx_target": self.hx_target,
+            "hx_swap": self.hx_swap,
+        }
+        context["form"] = self
+        rendered_html = template.render(context)
+        return rendered_html
+    
+    def as_bs5_disabled(self):      
+        template = get_template(self.template_disabled_name)
+        context = {
+            "hx_post": self.hx_post,
+            "hx_trigger": self.hx_trigger,
+            "hx_target": self.hx_target,
+            "hx_swap": self.hx_swap,
+            "disable": True,
+        }
+        context["form"] = self
+        rendered_html = template.render(context)
+        return rendered_html
+    

handyhelpers/mixins/model_mixins.py

@@ -0,0 +1,21 @@
+
+
+class NonEmptyStringMixin:
+    """Mixin for adding non-empty validation to CharFields with blank=False"""
+    def get_non_blank_char_fields(self):
+        # Retrieve all fields of the model
+        fields = self._meta.get_fields()
+        
+        # Filter the fields based on type and blank attribute
+        return [ i for i in self._meta.get_fields() if isinstance(i, models.CharField) and not i.blank]
+       
+    def clean(self):
+        non_blank_char_fields = self.get_non_blank_char_fields()
+        for field in non_blank_char_fields:
+            if not getattr(self, field.name):
+                raise ValidationError(f"The {field.name} field cannot be empty.")
+        super().clean()
+
+    def save(self, *args, **kwargs):
+        self.clean()
+        super().save(*args, **kwargs)

handyhelpers/mixins/serializer_mixins.py

@@ -0,0 +1,35 @@
+from django.conf import settings
+
+
+class FlexFieldsMixin:
+    """A serializer mixin that allow filtering or omitting fields by query parameters"""
+
+    query_params: dict = {}
+
+    def __init__(self, *args, **kwargs) -> None:
+        request = kwargs.get("context", {}).get("request", None)
+
+        if request:
+            self.query_params = request.query_params
+        super().__init__(*args, **kwargs)
+
+    def get_fields(self):
+        fields = super().get_fields()
+        if self.query_params:
+            fields_param: str = getattr(settings, "HH_FIELDS_PARAM", "fields")
+            omit_param: str = getattr(settings, "HH_OMIT_PARAM", "omit")
+            requested_fields = self.query_params.get(fields_param, None)
+            omitted_fields = self.query_params.get(omit_param, None)
+            if requested_fields:
+                return {
+                    key: value
+                    for key, value in fields.items()
+                    if key in requested_fields.split(",")
+                }
+            elif omitted_fields:
+                return {
+                    key: value
+                    for key, value in fields.items()
+                    if key not in omitted_fields.split(",")
+                }
+        return fields

handyhelpers/mixins/view_mixins.py

@@ -60,9 +60,9 @@ class FilterByQueryParamsMixin:
                 if val is not None:
                     if val == 'None':
                         val = None
-                    elif val in 'TruetrueTRUE':
+                    elif val in ['True','true','TRUE']:
                         val = True
-                    elif val in 'FalsefalseFALSE':
+                    elif val in ['False','false','FALSE']:
                         val = False
                     filter_dict[arg] = val
             if force_distinct:
@@ -155,5 +155,8 @@ class HtmxViewMixin:
             True if request is htmx, otherwise False
         """
         if self.request.headers.get("Hx-Request", None):
+            self.request.is_htmx = True
             return True
+        self.request.is_htmx = False
         return False
+

handyhelpers/serializers.py

@@ -1,14 +1,16 @@
 from rest_framework import serializers
+from handyhelpers.mixins.serializer_mixins import FlexFieldsMixin
 
 
 class FkReadWriteField(serializers.RelatedField):
-    """ A generic serializer field that provides the string representation of a ForeignKey object, as provided
+    """A generic serializer field that provides the string representation of a ForeignKey object, as provided
     by the __str__ model method, for a read operation, and performs a lookup using the provided lookup_field for
     write operations.
 
     Example usage:
         my_fk_field = FkReadWriteField(required=False, queryset=MyModel.objects.all(), lookup_field='fk_field_name')
     """
+
     def __init__(self, **kwargs):
         self.model = kwargs["queryset"].model
         self.lookup_field = kwargs.pop("lookup_field", None)
@@ -24,6 +26,24 @@ class FkReadWriteField(serializers.RelatedField):
         try:
             return self.model.objects.get(**{self.lookup_field: data})
         except self.model.DoesNotExist:
-            raise serializers.ValidationError(f"{self.model._meta.model_name} with {self.lookup_field} '{data}' not found")
+            raise serializers.ValidationError(
+                f"{self.model._meta.model_name} with {self.lookup_field} '{data}' not found"
+            )
         except self.model.MultipleObjectsReturned:
-            raise serializers.ValidationError(f"multiple objects returned; lookup_field must be unique")
+            raise serializers.ValidationError(
+                f"multiple objects returned; lookup_field must be unique"
+            )
+
+
+class NoModelFlexSerializer(FlexFieldsMixin, serializers.Serializer):
+    """A serializer that provides dynamical filtering of fields in the return data.
+
+    Example usage:
+        class ExampleViewSet(viewsets.ViewSet):
+            def list(self, request):
+                data = {}
+                serializer = NoModelSerializer(data, context={"request": request})
+                return Response(serializer.data)
+    """
+
+    pass

handyhelpers/static/handyhelpers/css/table_sortable.css

@@ -0,0 +1,17 @@
+th.sortable {
+    cursor: pointer;
+    position: relative;
+}
+th.sortable .fa {
+    margin-left: 5px;
+    color: var(--bs-secondary);
+}
+th.sortable .fa.sort-active {
+    color: var(--bs-primary);
+}
+th.sortable .fa-sortable {
+    visibility: hidden;
+}
+th.sortable:hover .fa-sortable {
+    visibility: visible;
+}

handyhelpers/static/handyhelpers/js/sidebar.js

@@ -3,10 +3,14 @@ sidebarToggle.addEventListener("click",function(){
     document.querySelector("#sidebar").classList.toggle("collapsed");
 });
 
-document.querySelector(".theme-toggle").addEventListener("click",() => {
-    toggleLocalStorage();
-    toggleRootClass();
-});
+const themeToggle = document.querySelector(".theme-toggle");
+
+if (themeToggle) {
+    themeToggle.addEventListener("click", () => {
+        toggleLocalStorage();
+        toggleRootClass();
+    });
+}
 
 function toggleRootClass(){
     const current = document.documentElement.getAttribute('data-bs-theme');

handyhelpers/static/handyhelpers/js/table_sortable.js

@@ -0,0 +1,119 @@
+function readTable(table) {
+    var sortableTableWrapper = document.querySelector('.sortable-table-wrapper');
+    // Get the value of the data-pagination-size attribute
+    var paginationSize = sortableTableWrapper.getAttribute('data-pagination-size');
+    // Convert the pagination size to an integer
+    const rowsPerPage = parseInt(paginationSize, 10);
+
+    let currentPage = 1;
+    let currentSortColumn = null;
+    let currentSortOrder = true; // true for ascending, false for descending
+    let paginationEnabled = true;
+
+    const tableBody = table.querySelector("tbody");
+    if (!tableBody) return;
+
+    const rows = Array.from(tableBody.querySelectorAll("tr"));
+    const totalRows = rows.length;
+    let sortedRows = rows.slice();
+
+    const renderTable = (data, page = 1, rowsPerPage = rowsPerPage) => {
+        tableBody.innerHTML = "";
+
+        const navElement = table.closest('.sortable-table-wrapper').querySelector(".sortable-table-nav");
+
+        if (paginationEnabled) {
+            const start = (page - 1) * rowsPerPage;
+            const end = start + rowsPerPage;
+            data.slice(start, end).forEach(row => tableBody.appendChild(row));
+            renderPagination(data.length, page, rowsPerPage, table);
+            if (navElement) navElement.style.display = 'block';
+        } else {
+            data.forEach(row => tableBody.appendChild(row));
+            if (navElement) navElement.style.display = 'none';
+        }
+    };
+
+    const renderPagination = (totalRows, page, rowsPerPage, table) => {
+        const totalPages = Math.ceil(totalRows / rowsPerPage);
+        const pagination = table.parentNode.querySelector(".pagination");
+        if (!pagination) return;
+
+        pagination.innerHTML = "";
+
+        for (let i = 1; i <= totalPages; i++) {
+            pagination.innerHTML += `
+                <li class="page-item ${i === page ? 'active' : ''}">
+                    <a class="page-link" href="#">${i}</a>
+                </li>
+            `;
+        }
+
+        pagination.querySelectorAll(".page-link").forEach(link => {
+            link.addEventListener("click", (e) => {
+                e.preventDefault();
+                currentPage = parseInt(e.target.textContent);
+                renderTable(sortedRows, currentPage, rowsPerPage);
+            });
+        });
+    };
+
+    const getCellValue = (tr, idx) => tr.children[idx].innerText || tr.children[idx].textContent;
+
+    const comparer = (idx, asc) => (a, b) => ((v1, v2) =>
+        v1 !== '' && v2 !== '' && !isNaN(v1) && !isNaN(v2) ? v1 - v2 : v1.toString().localeCompare(v2)
+    )(getCellValue(asc ? a : b, idx), getCellValue(asc ? b : a, idx));
+
+    table.querySelectorAll("th.sortable").forEach(th => th.addEventListener("click", () => {
+        const idx = Array.from(th.parentNode.children).indexOf(th);
+        const asc = !(currentSortColumn === idx && currentSortOrder);  // Toggle sort order
+
+        currentSortColumn = idx;
+        currentSortOrder = asc;
+
+        sortedRows.sort(comparer(idx, asc));
+
+        table.querySelectorAll('th.sortable').forEach(header => {
+            header.classList.remove('asc', 'desc');
+            header.querySelector('.fa-sort-up').classList.remove('sort-active');
+            header.querySelector('.fa-sort-down').classList.remove('sort-active');
+        });
+
+        th.classList.toggle('asc', asc);
+        th.classList.toggle('desc', !asc);
+        if (asc) {
+            th.querySelector('.fa-sort-up').classList.add('sort-active');
+            th.querySelector('.fa-sort-down').classList.remove('sort-active');
+        } else {
+            th.querySelector('.fa-sort-up').classList.remove('sort-active');
+            th.querySelector('.fa-sort-down').classList.add('sort-active');
+        }
+
+        currentPage = 1;  // Reset to the first page after sorting
+        renderTable(sortedRows, currentPage, rowsPerPage);
+    }));
+
+    const paginationToggle = table.parentNode.querySelector(".pagination-toggle");
+    if (paginationToggle) {
+        paginationToggle.addEventListener("click", () => {
+            paginationEnabled = !paginationEnabled;
+            paginationToggle.classList.toggle('disabled', !paginationEnabled);
+            paginationToggle.style.color = paginationEnabled ? 'var(--bs-parimary)' : 'var(--bs-secondary)';
+            renderTable(sortedRows, currentPage, rowsPerPage);
+        });
+    }
+
+    renderTable(sortedRows, currentPage, rowsPerPage);
+}
+
+function initializeTables() {
+    document.querySelectorAll(".sortable-table-wrapper table").forEach(table => readTable(table));
+}
+
+document.addEventListener('htmx:afterRequest', function(event) {
+    // Access the custom header from the HTMX response
+    var customHeader = event.detail.xhr.getResponseHeader('X-Initialize-Tables');
+    if (customHeader === 'initialize-tables') {
+    initializeTables();
+    }
+});

handyhelpers/static/node_modules/.bin/acorn

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict"
+
+require("../dist/bin.js")

handyhelpers/static/node_modules/.bin/css-b64-images

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+var b64img = require('..'),
+  root = process.cwd(),
+  cssFile = process.argv[2];
+
+if(!cssFile) handleError(new Error('Usage: css-b64-images file.css'));
+
+b64img.fromFile(cssFile, root, function(err, css){
+  if(err) console.error('Error:', err);
+  console.log(css);
+});
+