DJANGO models proxy inharitence

Question

I would like to add the methods of the 'tools' class for 2 of my django model calss. Each class will use the same methods with it's own model eample:

class mapA(models.Model):
     mInd = models.IntegerField()
     scId = models.IntegerField()

class mapB(models.Model):
     mInd = models.IntegerField()
     scId2 = models.IntegerField()

I would like to add the methods like checkInput() to both of them. So I could run:

mapBInstance.checkInput();
mapAInstance.checkInput();

Ech time the checkInput runs over the data in the mapA or mapB.

I thought about creating a tools class & let each model to inherit from it. This way the tools class will have logic which is identical to both maps.

When I read the django docs I didn't see example to this case only close solutions. Is this the correct solution (to use the proxy class)?

class Tools():
   def __init__():
      ...init class...
   def checkInput():
       ..make the checks..

class MapA(Tools, models.Model):
     mInd = models.IntegerField()
     scId = models.IntegerField()

     def checkSelf():
         self.checkInput(self.objects.filter(....))

class MapB(Tools, models.Model):
     mIndB = models.IntegerField()
     scIdB = models.IntegerField()
     def checkSelf():
         self.checkInput(self.objects.filter(....))

Answer 1

If you want MapA and MapB (it would be really helpful if you followed PEP-8 ) to be distinct models, proxy models won't help you. A proxy model is a model that is different in Python, but in the database it is exactly the same as the model it inherits from. Creating a proxy model that doesn't directly inherit from a single concrete model (one that has a table in the database) is an error.

What you're looking for is an abstract base class:

class Tools(models.Model):
    ...

    class Meta:
        abstract = True

class MapA(Tools):
    ...

class MapB(Tools):
    ...

An abstract model does not create its own table in the database. Instead, it is as if everything defined in Tools has been defined in both MapA and MapB , but the Tools class is otherwise ignored. This allows you to specify all the methods and fields just once, but still have two separate tables in the database.

Answer 2

A few things...

---

There is no this in Python, it's called self .

---

If you're in Python 2.x, tools should inherit from object . In Python 3, it's implicit, but doesn't hurt:

class tools(object):
    ...

---

If you're overriding __init__ in your mixin class ( tools ), then map classes should probably inherit from it first :

class mapA(tools, models.Model):
    ...

Only override __init__ if you really need to, it can get complicated.

---

Class names are pretty much always in CamelCase. This is not required, but is a convention. Also, It's a good idea to name mixin classes transparently:

class ToolsMixin(object):
    ...

class MapA(ToolsMixin, models.Model):
    ...

---

Other then all that, you perfectly can add a method in a mixin and use it in your models. No need for Django proxy models.