How do I access the child classes of an object in django without knowing the name of the child class?

(Update: For Django 1.2 and newer, which can follow select_related queries across reverse OneToOneField relations (and thus down inheritance hierarchies), there's a better technique available which doesn't require the added real_type field on the parent model. It's available as InheritanceManager in the django-model-utils project.)

The usual way to do this is to add a ForeignKey to ContentType on the Parent model which stores the content type of the proper "leaf" class. Without this, you may have to do quite a number of queries on child tables to find the instance, depending how large your inheritance tree is. Here's how I did it in one project:

from django.contrib.contenttypes.models import ContentTypefrom django.db import modelsclass InheritanceCastModel(models.Model):    """    An abstract base class that provides a ``real_type`` FK to ContentType.    For use in trees of inherited models, to be able to downcast    parent instances to their child types.    """    real_type = models.ForeignKey(ContentType, editable=False)    def save(self, *args, **kwargs):        if self._state.adding:            self.real_type = self._get_real_type()        super(InheritanceCastModel, self).save(*args, **kwargs)        def _get_real_type(self):        return ContentType.objects.get_for_model(type(self))                def cast(self):        return self.real_type.get_object_for_this_type(pk=self.pk)        class Meta:        abstract = True

This is implemented as an abstract base class to make it reusable; you could also put these methods and the FK directly onto the parent class in your particular inheritance hierarchy.

This solution won't work if you aren't able to modify the parent model. In that case you're pretty much stuck checking all the subclasses manually.

In Python, given a ("new-style") class X, you can get its (direct) subclasses with X.__subclasses__(), which returns a list of class objects. (If you want "further descendants", you'll also have to call __subclasses__ on each of the direct subclasses, etc etc -- if you need help on how to do that effectively in Python, just ask!).

Once you have somehow identified a child class of interest (maybe all of them, if you want instances of all child subclasses, etc), getattr(parentclass,'%s_set' % childclass.__name__) should help (if the child class's name is 'foo', this is just like accessing parentclass.foo_set -- no more, no less). Again, if you need clarification or examples, please ask!

Carl's solution is a good one, here's one way to do it manually if there are multiple related child classes:

def get_children(self):    rel_objs = self._meta.get_all_related_objects()    return [getattr(self, x.get_accessor_name()) for x in rel_objs if x.model != type(self)]

It uses a function out of _meta, which is not guaranteed to be stable as django evolves, but it does the trick and can be used on-the-fly if need be.