John Mee

I was looking for a way to put a lot of text next to the radio buttons in a django form. I also needed the list of radio buttons to automatically populate and vary according to the situation.

After the documentation for django being so awesome everywhere else; there is currently bugger all for this corner of the world: the radio widget. Fat lot of use that is.

It seems like django isn’t set up to do much to help you at first; but at second glance (ie: after wandering down vastly more complicated paths for hours) the solution in front your nose does work; with a bit of sourcery of course.

The second element of the tuple is presented inside the “label” tag – so any inline elements are permissible; for example:

The desired result

Or something like it

    <ul>
      <li><label for="id_ticket_0">
          <input type="radio" id="id_ticket_0" value="PARTTIME" name="ticket"/>
          <em>Part Time</em> Valid on Friday Night and Saturday Only
      </label></li>
      <li><label for="id_ticket_1">
          <input type="radio" id="id_ticket_1" value="DAYTIME" name="ticket"/>
          <em>Casual</em> Valid on Saturday Only
      </label></li>
      <li><label for="id_ticket_2">
           <input type="radio" id="id_ticket_2" value="EARLYBIRD" name="ticket"/>
           <em>Early Bird</em> Valid on Friday, Saturday, and Sunday. $15 discount for booking before 1am January 3rd, 2011
       </label></li>
    </ul>

The simple example

The trick is to “mark_safe” the content of the description then stuff whatever you need into:

    from django.utils.safestring import mark_safe
    choices = (
      ('1', mark_safe(u'<em>One</em> | This is the first option. It is awesome')),
      ('2', mark_safe(u'<em>Two</em> | This is the second option. Good too.'))
    )

The complex example

So in this example we:

1. assemble the choices into a list (any iterable structure will do)
2. pass the structure to the form’s __init__ to create our radio options on the fly
3. use a comprehension list to create an extended description for each radio option

The data structure:
Tickets are my own classes and they have attributes:

• tickets.code – as in a ticket code
• label – a pithy short description
• help – a longer description

But more about that later. First lets create some instances:

    from mymodule import ticket
    # so lets create a few
    fulltime = ticket('FULLTIME',160,'Full Time',
                  "Valid Monday to Friday inclusive")
    parttime = ticket('PARTTIME',110,'Full Time',
                  "Valid outside of business hours only")
    daytime  = ticket('DAYTIME',70,'Day Time',
                  "Valid only on weekends and public holidays")

    # and put them together in a list any way you like
    available_tickets = [fulltime, parttime, daytime]

    # now create the form
    OrderForm(tickets=available_tickets)

That probably happened in your *view* code. Now to see what happens in the *form*

    class OrderForm(ModelForm):

        def __init__(self, *args, **kwargs):
            self.tickets = kwargs.pop('tickets')
            super(OrderForm, self).__init__(*args, **kwargs)

            choices = [(t.code, mark_safe(u'<em>%s</em> %s' % (t.label, t.help)))
                    for t in self.tickets]
            self.fields['ticket'] = forms.ChoiceField(
                choices = choices,
                widget  = forms.RadioSelect()
            )

The answer is buried inside the more complex current_time example in the documentation.

Problem

You want to add a variable to the context. But you don’t want to go back and add that variable to all the views which call all the templates which invoke the tag. You just want a tag which can add some data to the context wherever its wanted. I’m looking for this kind of thing when rendering those random distractions which get dropped into sidebars and aren’t specifically related to the work of the main view, for example.

Method

To inject a variable to the context you need access to the context. To do that your custom tag will inject a node which added the data to the template context.

Example

This example adds a “coming_events” queryset to the context then loops over each result. It does that by declaring a custom tag which renders a node which adds a queryset to the context.

from django import template
from apps.events.models import Event
register = template.Library()

@register.tag
def coming_events(parser, token):
    return EventNode()

class EventNode(template.Node):
    def render(self, context):
        context['coming_events'] = Event.objects.all()
        return ''

You’d use it like this:

{% load events %}
{% coming_events %}
{% for event in coming_events %}
<div class="eventItem">
   <p>{{event.title}} {{event.data}}</p>
</div>
{% endfor %}

Extra Credit

If you’re really keen to be able to name the variable arbitrarily eg {% coming_events as events %} then look closely at the example in the documentation and note how they split the token into what’s before the ‘ as ‘ and what’s after and use the latter part to name the context variable. You’d have to implement that.

Note that if I wound up putting the HTML for each event into its own dedicated template then I’d be better off just following the standard inclusion tag example in the documentation. This solution is suggested for when you want the data without any baggage.

As posted to http://stackoverflow.com/questions/2566265

I got a little frustrated trying to find the ‘simple’ answer to change the html which is generated by the various form field widgets.

In this case the RadioSelect field generates radio buttons wrapped in an unordered list. It was annoying, and whilst I could resort to writing the html directly in the html; that’s not ideal.

The solution is not hard, just not well documented.

We need only write a “render” routine to return the string we want. Then override the default widget with our renderer, and finally specify all that in the form field definition:

from django import forms
from django.forms import ModelForm
from django.utils.safestring import mark_safe
from django.utils.encoding import force_unicode

FULFILMENT_CHOICES = (
    ('Post','Post'),
    ('Pickup','Pickup')
)

class MyRadioRenderer(forms.widgets.RadioFieldRenderer):    """Render radio buttons without the <li>"""
    def render(self):
        return mark_safe(u'\n%s\n' % u'\n'.join([u'%s'
                    % force_unicode(w) for w in self]))

class OrderForm(ModelForm):
   fulfilment = forms.ChoiceField(
              widget=forms.RadioSelect(renderer=MyRadioRenderer),
              choices=FULFILMENT_CHOICES)

Produces:

<div class="orderValue">
<label for="id_fulfilment_0"><input type="radio" id="id_fulfilment_0" value="Post" name="fulfilment"/> Post</label>
<label for="id_fulfilment_1"><input type="radio" id="id_fulfilment_1" value="Pickup" name="fulfilment"/> Pickup</label>
</div>

I have a user profile model which holds their ‘mugshot’ image. I’m using modelForm to to present a profile update form. It was easy to build a working form, but now I need a couple of tweaks to the image:

1) it saves with the filename that the user provides; I rather dictate the filename to use. I thought I’d just use the PK of the model, and the same file extension eg: “443.jpg”

2) it should replace the existing image, not append an underscore like “443___.jpg”.

Here’s my model and form:

class Member(models.Model):
    home_phone      = models.CharField(max_length=10, blank=True)
    image           = models.ImageField(upload_to='members', default="default.png")
    ...

class MemberProfileForm(forms.ModelForm):
   home_phone      = AUPhoneNumberField(required=False)

   class Meta:
       model = Member
       exclude = ('email','password','create_date','last_login','is_active')

This seems to solve it by altering the filename and deleting the existing file prior to the form save.

form = MemberProfileForm(request.POST, request.FILES, instance=request.member)
if form.is_valid():
    if form.cleaned_data['image']:
        (path, extension) = os.path.splitext(form.cleaned_data['image'].name)
        form.cleaned_data['image'].name = ('%s%s' % (request.member.id, extension))
        request.member.image.delete()
    form.save()

… excepting that most people probably want ‘request.user’, where I have ‘request.member’.