I'm working on a Django project that I did not start and I am facing a problem of inheritance.
I have a big model (simplified in the example) called MyModel that is supposed to represents different kind of items.

All the instance objects of MyModel should have the same fields but the methods behaviours varies a lot depending on the item type.

Up to this moment this has been designed using a single MyModel field called item_type.
Then methods defined in MyModel check for this field and perform different logic using multiple if:

def example_method(self):if self.item_type == TYPE_A:do_this()if self.item_type == TYPE_B1:do_that()

Even more, some of the sub-types have many things in common, so let's say the subtypes B and C represents a 1st level of inheritance. Then these types have sub-types being for example B1, B2, C1, C2 (better explained in the example code below).

I would say that's not the best approach to perform polymorphism.

Now I want to change these models to use real inheritance.

Since all submodels have the same fields I think multi-table inheritance is not necessary. I was thinking to use proxy models because only their behaviour should change depending on their types.

This a pseudo-solution I came up to:

ITEM_TYPE_CHOICES = ((TYPE_A, _('Type A')),(TYPE_B1, _('Type B1')),(TYPE_B2, _('Type B2')),(TYPE_C1, _('Type C1')),(TYPE_C2, _('Type C2')))class MyModel(models.Model):item_type = models.CharField(max_length=12, choices=ITEM_TYPE_CHOICES)def common_thing(self):passdef do_something(self):passclass ModelA(MyModel):class Meta:proxy = Truedef __init__(self, *args, **kwargs):super().__init__(self, *args, **kwargs)self.item_type = TYPE_Adef do_something(self):return 'Hola'class ModelB(MyModel):class Meta:proxy = Truedef common_thing(self):passclass ModelB1(ModelB):class Meta:proxy = Truedef __init__(self, *args, **kwargs):super().__init__(self, *args, **kwargs)self.item_type = TYPE_B1def do_something(self):passclass ModelB2(ModelB):class Meta:proxy = Truedef __init__(self, *args, **kwargs):super().__init__(self, *args, **kwargs)self.item_type = TYPE_B2def do_something(self):pass

This might work if we already know the type of the object we are working on.
Let's say we want to instantiate a MyModel object of type C1 then we could simply instantiate a ModelC1 and the item_type would be set up correctly.

The problem is how to get the correct proxy model from the generic MyModel instances?

The most common case is when we get a queryset result: MyModel.objects.all(), all these objects are instances of MyModel and they don't know anything about the proxies.

I've seen around different solution like django-polymorphic but as I've understood that relies on multi-table inheritance, isn't it?

Several SO answers and custom solutions I've seen:

• https://stackoverflow.com/a/7526676/1191416
• Polymorphism in Django
• http://anthony-tresontani.github.io/Python/2012/09/11/django-polymorphism/
• https://github.com/craigds/django-typed-models
• Creating instances of Django proxy models from their base class

but none of them convinced me 100%..

Considering this might be a common scenario did anyone came up with a better solution?

When you use django-polymorphic in your base model, you'll get this casting behavior for free:

class MyModel(PolymorphicModel):pass

Each model that extends from it (proxy model or concrete model), will be casted back to that model when you do a MyModel.objects.all()