Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Django: Get all implementations of an Abstract Base Class

Tags:

django

I have defined some models which look like this:

class ABClass(models.Model):
   #common attributes
   class Meta:
     abstract = True

class ConcreteClass1(ABClass):
   #implementation specific attributes

class ConcreteClass2(ABClass):
   #implementation specific attributes

class ModifiedConcreteClass1(ConcreteClass1):
   #implementation specific attributes

I have a view which takes a 'type' parameter which specifies the type of class to display. If 'type=None' I want to display all descendents of ABClass (in this case, ConcreteClass{1,2}, ModifiedConcreteClass1). I have poked around the documentation and cannot seem to find a way of doing this which does not require list of ConcreteClasses be maintained. ABClass.__subclasses__() seemed promising but it returns an empty list when I call it.

At present the best strategy I have is to create a CLASS_LIST variable in models.py which is populated with all descendents of ABClass at runtime using inspect methods. Is there a way to do this using the django api?

Thanks

like image 412
pisswillis Avatar asked Nov 13 '09 15:11

pisswillis


3 Answers

A list of ConcreteClasses is already maintained if you have 'django.contrib.contenttypes' in INSTALLED_APPS.

Here is how I do it:

class GetSubclassesMixin(object):
    @classmethod
    def get_subclasses(cls):
        content_types = ContentType.objects.filter(app_label=cls._meta.app_label)
        models = [ct.model_class() for ct in content_types]
        return [model for model in models
                if (model is not None and
                    issubclass(model, cls) and
                    model is not cls)]

class ABClass(GetSubclassesMixin, models.Model):
    pass

When you need a list of subclasses, just call ABClass.get_subclasses().

I am using this with concrete base classes, but I don't see a reason for this not to work with abstract ones.

This approach works even if your concrete subclasses are in different Django apps. Note however that they should have the same app_label as the base class so the code in get_subclasses() can find them.

like image 104
utapyngo Avatar answered Nov 13 '22 12:11

utapyngo


I haven't look at what Django does when you set abstract True in the backend, but I played with this and I found that this works. Please note, it only works in Python 2.6

from abc import ABCMeta

class ABClass():
    __metaclass__ = ABCMeta

class ConcreteClass1(ABClass):
     pass

class ConcreteClass2(ABClass):
     pass

print ABClass.__subclasses__()

Results in

[<class '__main__.ConcreteClass1'>, <class '__main__.ConcreteClass2'>]

Without using the ABCMeta and __metaclass__, you will receive an empty list.

You can read a good description of what's going on here. Only problem with this, and I'm not sure if it will affect you is I can't quite figure out why when I create an instance of ABClass, it can't find the subclasses. Perhaps by playing around a bit and reading the doc more it might get you somewhere.

Let me know how this works for you, as I am genuinely curious on the true answer.

like image 20
Bartek Avatar answered Nov 13 '22 13:11

Bartek


Take a look at this similar question:

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

My solution to that was essentially this:

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)]

Though there are a number of other good solutions there as well. It seems likely that you actually want the children of the base class, and not just the child classes. If not, the answers there may serve as a motivator for your solution.

like image 5
Paul McMillan Avatar answered Nov 13 '22 13:11

Paul McMillan