While the existing `ManyToManyField` is suitable for basic relationships, some projects find need to tie objects together along with some information about their relationship. The common example is the role an actor played in a movie, but it could be used for many other things, including what "base" a dating couple has gotten to, for instance. For these cases, the common recommendation is to simply create an intermediary model with `ForeignKey`s to each of the connected models, along with any extra fields that are appropriate for the relationship. In the Hollywood example, something like this: {{{ #!python class Actor(models.Model): name = models.CharField(maxlength=255) class Movie(models.Model): title = models.CharField(maxlength=255) actors = models.ManyToManyField(Actor) }}} would become something like this instead, with the `role` field added: {{{ #!python class Actor(models.Model): name = models.CharField(maxlength=255) class Film(models.Model): title = models.CharField(maxlength=255) class Role(models.Model): actor = models.ForeignKey(Actor, related_name='roles') film = models.ForeignKey(Film, related_name='roles') role = models.CharField(maxlength=255) }}} Unfortunately, the database API then goes from this: {{{ #!python >>> for actor in film.actors.all(): ... print actor.name Graham Chapman Terry Gilliam John Cleese Eric Idle }}} to this: {{{ #!python >>> for role in film.roles.all(): ... print '%s played %s' % (role.actor.name, role.role) Graham Chapman played King Arthur Terry Gilliam played Sir Bors John Cleese played Sir Lancelot the Brave Eric Idle played Sir Robin the Not-Quite-So-Brave-as-Sir Launcelot }}} While programmers may not have a problem with this change, it is very counter-intuitive for template authors who may not have (nor should they need) an intimate understanding of how relational databases work. I'd like to propose an alternative, using a custom manager for these intermediary models, that will enable a more natural API. By simply adding one line and renaming the `related_name`s: {{{ #!python class Actor(models.Model): name = models.CharField(maxlength=255) class Film(models.Model): title = models.CharField(maxlength=255) class Role(models.Model): actor = models.ForeignKey(Actor, related_name='films') film = models.ForeignKey(Film, related_name='actors') role = models.CharField(maxlength=255) objects = models.ManyToManyManager() }}} we could get a much more intuitive API: {{{ #!python >>> for actor in film.actors.all(): ... print '%s played %s' % (actor.name, actor.role) Graham Chapman played King Arthur Terry Gilliam played Sir Bors John Cleese played Sir Lancelot the Brave Eric Idle played Sir Robin the Not-Quite-So-Brave-as-Sir Launcelot }}} This would work just as well in both directions: {{{ #!python >>> for film in john.films.all(): ... print '%s in %s' % (film.role, film.title) Sir Lancelot the Brave in Monty Python and the Holy Grail Sir Nicholas de Mimsy-Porpington in Harry Potter and the Sorceror's Stone }}} Ideally, this API would also extend the `add` method of the manager, allowing it to take keyword attributes for the relationship meta-data: {{{ #!python >>> film = Film.objects.create(title='And Now for Something Completely Different') >>> john.films.add(film, role='Sir George Head') >>> for film in john.films.all(): ... print '%s in %s' % (film.role, film.title) Sir Lancelot the Brave in Monty Python and the Holy Grail Sir Nicholas de Mimsy-Porpington in Harry Potter and the Sorceror's Stone Sir George Head in And Now for Something Completely Different }}} And without the intermediary model, there's need for an `update` function on the manager, which would handle modifying the meta-data: {{{ #!python >>> film.actors.update(john, role='Mungo the Cook') }}}