Custom Widget for Displaying Quantity Objects in Django

You can indeed use a custom widget to format your Quantity() objects consistently across both forms and templates. This approach allows you to keep your custom object in the models while controlling how it's displayed to users.

Creating a Custom Widget

You can create a custom widget that knows how to display your Quantity() objects:

PYTHONCopied
from django import forms

class QuantityWidget(forms.TextInput):
    def format_value(self, value):
        """Format the Quantity object for display in the widget"""
        if value is None:
            return ''
        # Format your Quantity object as needed
        # For example: "5 gallons" or "5 gal"
        return f"{value.magnitude} {value.units}"
    
    def value_from_datadict(self, data, files, name):
        """Convert the submitted string back to a Quantity object"""
        value = super().value_from_datadict(data, files, name)
        # You'll need to implement parsing logic here
        # This depends on how your form accepts input
        return value

Using the Widget in Forms

You can use this widget in your forms:

PYTHONCopied
class MyModelForm(forms.ModelForm):
    class Meta:
        model = MyModel
        fields = ['quantity_field']
        widgets = {
            'quantity_field': QuantityWidget(),
        }

For Template Display

For displaying the same formatting in templates, you have a few options:

1. Model Method

Add a method to your model:

PYTHONCopied
class MyModel(models.Model):
    quantity_field = YourQuantityField()
    
    def format_quantity(self):
        """Return formatted quantity string"""
        quantity = self.quantity_field
        return f"{quantity.magnitude} {quantity.units}"

Then in templates: {{ object.format_quantity }}

2. Template Filter

Create a custom template filter:

PYTHONCopied
@register.filter
def format_quantity(quantity):
    """Format a Quantity object for display"""
    return f"{quantity.magnitude} {quantity.units}"

Then in templates: {{ object.quantity_field|format_quantity }}

Avoiding Duplication

To avoid duplicating the formatting logic, you can create a utility function that both your widget and template filter/model method use:

PYTHONCopied
# utils.py
def format_quantity(quantity):
    """Central formatting function for Quantity objects"""
    if quantity is None:
        return ''
    return f"{quantity.magnitude} {quantity.units}"

# Then in your widget:
from .utils import format_quantity

class QuantityWidget(forms.TextInput):
    def format_value(self, value):
        return format_quantity(value)
    
# And in your template filter:
@register.filter
def display_quantity(quantity):
    return format_quantity(quantity)

This approach gives you consistent formatting across your application while keeping your custom object intact in the database.