***EDIT: I recently posted a better way to do this.
I just started with Google App Engine the other day. Man, who could resist a free server environment?
Being a long time Django developer (one year), I was really excited about it because it “runs django”. Now this isn’t really the case because of BigTable, which isn’t a real relational database. However, if you forgo the Django ORM and use GAE models, you can still work with the other things that make Django so awesome: templates and forms. AND, the google models are so similar to Django that you’ll barely even notice the difference.
Ok, this isn’t a full on review GAE with Django, so I’ll cut right to the chase. I’m sure you found this page when you were trying to use django forms to handle the ListProperty model field in your HTML forms. The problem is that things like ModelChoiceField and ModelMultipleChoiceField won’t work because they rely on the Django ORM. For that matter, ChoiceField and MultipleChoiceField won’t work because they return a list of strings, that although they can be the string for a db.key(), they won’t be the Key objects that your new models expect for ListProperty.
So, to get around this I just adjusted the MultipleChoiceField a bit so that it returns the list chosen fields as Key objects:
#MODELS class Toping(BaseModel): name = db.StringProperty(required=True) class Pizza(BaseModel): name = db.StringProperty(required=True) toppings = db.ListProperty(db.Key) def get_topings(self): # This returns the models themselves, not just the keys that are stored in toppings return Topping.get(self.toppings) #FORMS class PizzaForm(djangoforms.ModelForm): toppings = ListPropertyChoice( widget=forms.CheckboxSelectMultiple(), choices=[(rt.key(), rt.name) for rt in db.Query(Topping)] ) class Meta: model = Pizza #CUSTOM FIELD from django.newforms.util import ErrorList, ValidationError from django.newforms.fields import ChoiceField from django.newforms.widgets import MultipleHiddenInput, SelectMultiple from appengine_django.models import BaseModel from appengine_django.serializer.python import smart_unicode from django.utils.translation import gettext class ListPropertyChoice(ChoiceField): hidden_widget = MultipleHiddenInput def __init__(self, choices=(), required=True, widget=SelectMultiple, label=None, initial=None, help_text=None): super(ListPropertyChoice, self).__init__(choices, required, widget, label, initial, help_text) def clean(self, value): """ Validates that the input is a list or tuple. """ if self.required and not value: raise ValidationError(gettext(u'This field is required.')) elif not self.required and not value: return  if not isinstance(value, (list, tuple)): raise ValidationError(gettext(u'Enter a list of values.')) new_value =  for val in value: val = smart_unicode(val) new_value.append(val) # Validate that each value in the value list is in self.choices. valid_values = set([smart_unicode(k) for k, v in self.choices]) for val in new_value: if val not in valid_values: raise ValidationError(gettext(u'Select a valid choice. %s is not one of the available choices.') % val) # These are the only changes to the django MultipleChoice Field # we just convert the list of strings to a list of keys key_list =  for k in new_value: key_list.append(BaseModel.get(k).key()) return key_list
Now for a quick expaination… The ListPropertyChoice class itself is really just the MultipleChoiceField from Django V0.96. I had to use this because I couldn’t get the latest svn version to work w/ App Engine due to some SafeUnicode issues I haven’t looked into yet. The only real changes to that class are the last four lines which return the list of keys instead of key-strings from the form.
The only other thing that might need explanation is the get_toppings() method that I added to the Pizza model. This is just a shortcut to access the models instead of the keys, as they’re stored in the ListProperty.