Develop Reference

Creating a models.UniqueConstraint in abstract model

I am creating an abstract model for my django app, SrdObject. One of the characteristics of my model is that it has a pair of fields that, taken together, must be unique: 'name' and the foreign key 'module'.
Here is an example of what I had
class SrdObject(models.Model):
name = models.CharField(max_length=50)
slug_name = models.SlugField(max_length=75, unique=True)
active = models.BooleanField(default=True)
module = models.ForeignKey(Module, on_delete=models.CASCADE, related_name='%(class)s', blank=False, null=False, default='default')
class Meta:
unique_together = ['name', 'module']
ordering = ['name']
abstract = True
This seemed to be working ok, but the unique_together attribute has been marked as deprecated by django (See here), so I changed it to this
class Meta:
constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
ordering = ['name']
abstract = True
This doesn't work because the name field must be unique, and since this is an abstract class, the constraint is repeated over several models.
I also tried
models.UniqueConstraint(fields=['name', 'module'], name='{}-unique-in-module'.format(model_name))
But obviously this falls into scoping problems, so I tried a decorator method
def add_unique_in_module_constraint(cls):
cls._meta.constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
return cls
#add_unique_in_module_constraint
class SrdObject(models.Model):
class Meta:
ordering = ['name']
abstract = True
But this didn't seem to do anything.
So how do I create a models.UniqueConstraint in abstract model if every constraint needs a unique name attribute?

LATEST UPDATE
Since 3rd version you finally can do that by specifying interpolation:
Changed in Django 3.0:
Interpolation of '%(app_label)s' and '%(class)s' was added.
Example:
UniqueConstraint(fields=['room', 'date'], name='%(app_label)s_unique_booking')
OLD (Django < 3.0)
You can't do that, same problem for me, so sad...
Source: django docs
Constraints in abstract base classes
You must always specify a unique name for the constraint. As such, you cannot normally specify a constraint on an abstract base class, since the Meta.constraints option is inherited by subclasses, with exactly the same values for the attributes (including name) each time. Instead, specify the constraints option on subclasses directly, providing a unique name for each constraint.

I took this model setup:
class Module(models.Model):
pass
class SrdObject(models.Model):
name = models.CharField(max_length=50)
slug_name = models.SlugField(max_length=75, unique=True)
active = models.BooleanField(default=True)
module = models.ForeignKey(Module, on_delete=models.CASCADE, related_name='%(class)s', blank=False, null=False, default='default')
class Meta:
constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
ordering = ['name']
abstract = True
class SrdObjectA(SrdObject):
pass
class SrdObjectB(SrdObject):
pass
And then ran these tests:
class TestSrdObject(TestCase):
#classmethod
def setUpTestData(cls):
cls.module = Module.objects.create()
SrdObjectA.objects.create(name='A', module=cls.module)
def test_unique_applies_to_same_model(self):
with self.assertRaises(IntegrityError):
SrdObjectA.objects.create(name='A', module=self.module)
def test_unique_does_not_apply_to_different_model(self):
self.assertTrue(SrdObjectB.objects.create(name='A', module=self.module))
And they pass. Perhaps I'm still missing the problem you're running into?

Django combine foreign keys in a single queryset

I have a model in a Django application that is being referenced by multiple other models as a ForeignKey.
What I am looking for is for a way to create a single queryset for all objects of this class that are being referenced as ForeignKey by the rest of the classes based on some criteria.
I am not even sure if this is possible, but I thought about asking anyway.
class Person(models.Model):
pass
class Book(models.Model):
year_published = models.PositiveIntegerField()
author = models.ForeignKey(Person)
class MusicAlbum(models.Model):
year_published = models.PositiveIntegerField()
producer = models.ForeignKey(Person)
recent_books = Book.objects.filter(year_published__gte=2018)
recent_music_albums = MusicAlbum.objects.filter(year_published__gte=2018)
# How can I create a **single** queryset of the Person objects that are being referenced as `author` in `recent_books` and as `producer` in `recent_music_albums`?
Thanks for your time.

I don't have Django in front of me at the moment, but what about something like:
class Person(models.Model):
pass
class Book(models.Model):
year_published = models.PositiveIntegerField()
author = models.ForeignKey(Person, related_name='books')
class MusicAlbum(models.Model):
year_published = models.PositiveIntegerField()
producer = models.ForeignKey(Person, related_name='albums')
Person.objects.filter(books__year_published__gte=2018, albums__year_published__gte=2018)
Or, if you have to do those first two queries anyway,
Person.objects.filter(books__in=recent_books, albums__in=recent_music_albums)

You will have on Person model instances a RelatedManager for Books and MusicAlbums. Probably they will still have the default names book_set and musicalbum_set since you didn't override them.
You can use these to find the books/music albums associated with one person instance:
persons_books = person.book_set.all()
persons_musicalbums = person.musicalbum_set.all()
And similarly you can generate the relevant queryset from the model manager:
qs = Person.objects.exclude(book=None).exclude(musicalbum=None)

Same can be achieved by this :
person = Person.objects.latest('book__year_published', 'musicalbum__year_published')
or
personList = Person.objects.all().order_by('-book__year_published', '-musicalbum__year_published')

Multiprofile with abstract model

I need two type of profile:
1) the first linked to Users by onetoone relationship to expand it with some new fields.
2) the seconds indipendent from Users (and accessible only to superuser/admin): they are just objects.
The problem is that I want a easy way to change a profile from 1°type to second type and viceversa.
In "Django Designer Patterns " I find an example like this:
class BaseProfile(models.Model):
User_Types = (
(0, 'active'),
(1, 'inactive'),
)
user_type = models.IntegerField(null=True, choices=User_Types, default=0)
name = models.CharField(max_length=32, unique=True)
#many other common field
class Meta:
abstract = True
def __str__(self):
return self.name
class Profile_Active(models.Model):
user = models.OneToOneField(User, blank=True, on_delete=models.PROTECT,
related_name='profile_active', primary_key=True) #this was in BaseProfile
#some more field reserved for this type of profile
class Meta:
abstract = True
class Profile_Inactive(models.Model):
#some field reserved for this type of profile
class Meta:
abstract = True
class Profile(Profile_Inactive, Profile_Active, BaseProfile):
pass
but I don't understand how I should combine the abstract models in Profile (what I should write instead of "pass"?) and what I should achieve? Profile
will have all the fields of the three models? Which the gain respect to use a single model?
Maybe I can forget Profile and use Profile_Inactive(BaseProfile) and Profile_Active(BaseProfile)? but then how to change from one to the other?
I'm confused, help please

Is it possible/sensible to customize Django's auto-through tables to include other fields...through-factory?

I know that django will helpfully generate a through table for simple many-to-many tables. However if you want to add information about the relationship, you need a 'linker' or through table. This example from the docs gives an example:
from django.db import models
class Person(models.Model):
name = models.CharField(max_length=128)
def __str__(self): # __unicode__ on Python 2
return self.name
class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(Person, through='Membership')
def __str__(self): # __unicode__ on Python 2
return self.name
class Membership(models.Model):
person = models.ForeignKey(Person)
group = models.ForeignKey(Group)
date_joined = models.DateField()
invite_reason = models.CharField(max_length=64)
I have in my design several tables/models like group, that vary mostly just by their choices attribute. And I'll be adding more later.
Is it possible to customize what sort of through table is generated by Django's magic? If so is this sensible?
The sort of thing I'm talking about is this:
class CharacterSkillLink(models.Model):
character = models.ForeignKey('NWODCharacter', related_name='%(class)s_by_skill')
skill = models.ForeignKey('Skill', choices = SKILL_CHOICES)
value = models.IntegerRangeField(min_value=1, max_value=5)
speciality = models.CharField(max_length=200)
class CharacterAttributeLink(models.Model):
character = models.ForeignKey('NWODCharacter', related_name='%(class)s_by_skill')
attribute = models.ForeignKey('Attribute', choices = ATTRIBUTE_CHOICES)
value = model.IntegerRangeField(min_value=1, max_value=5
class CharacterArcanaLink(models.Model):
character = models.ForeignKey('Mage', related_name='%(class)s_by_skill')
arcana = models.ForeignKey('Arcana', choices = ARCANA_CHOICES)
value = model.IntegerRangeField(min_value=1, max_value=5
In the future there'll be more like these. It's be handy if there was some way to django, much like with the through_field attribute, which defines keys on the through table to use, that there should be extra values to add to it (e.g. extra_field=value).
Is this possible/sensible?

IMO, adding fields to a "through" table is a great pattern for many possible uses. I'm not sure that Django needs new syntax to handle this case, but if you think you're creating lots of these tables and mixing/matching different tables, perhaps some abstract mixins will simplify things. For Example:
class CharacterLink(models.Model):
character = models.ForeignKey('NWODCharacter')
class Meta:
abstract = True
class SkillLink(models.Model):
skill = models.ForeignKey('Skill', choices = SKILL_CHOICES)
class Meta:
abstract = True
class AttributeLink(models.Model):
attribute = models.ForeignKey('Attribute', choices = ATTRIBUTE_CHOICES)
class Meta:
abstract = True
class CharacterSkillLink(CharacterLink, SkillLink):
value = models.IntegerRangeField(min_value=1, max_value=5)
speciality = models.CharField(max_length=200)
class CharacterAttributeLink(CharacterLink, AttributeLink):
value = model.IntegerRangeField(min_value=1, max_value=5)

Django Model - Cost of inheritance

We have django project, and we found that some models become huge.
class BigModel(models.Model):
"""
Large set of fields
"""
field1 = models.IntegerField()
field2 = models.IntegerField()
field3 = models.IntegerField()
...
fieldN = models.IntegerField()
"""
Large set of methods
"""
def method1(self): pass
def method2(self): pass
def method3(self): pass
...
def methodN(self): pass
I want to divide BigModel class into smaller classes with list of methods. But in whole project we have references to BigModel class.
So my idea is to do it by small steps:
Divide BigModel class into BigFields and BigMethods. Inherit
BigMethods from BigFields. Inherit BigModel from BigMethods.
By creating proxy models and replacing references to BigModel with them in code - reduce size of BigMethods class.
So, at the moment of refactoring our code will look like this:
class BigFields(models.Model):
class Meta:
abstract = True
"""
Large set of fields
"""
field1 = models.IntegerField()
field2 = models.IntegerField()
field3 = models.IntegerField()
...
fieldN = models.IntegerField()
class BigMethods(BigFields):
class Meta:
abstract = True
"""
Large set of methods
"""
def method1(self): pass
def method2(self): pass
def method3(self): pass
...
def methodN(self): pass
class BigModel(BigMethods):
pass
How it will affect performance?
What is the cost of one level of inheritance in python?
Does metaclasses affects cost of inheritance?

If you have sequential fields like this in your model the solution is not inheritance, but breaking out these fields into a separate model and creating a one-to-many relationship. It's hard to make the point with your example models, so I'll use one from a project I was working on.
The original model looked something like this:
class Page(models.Model):
title = models.CharField(max_length=256)
section_1_title = models.CharField(max_length=256)
section_1_content = models.TextField()
section_2_title = models.CharField(max_length=256)
section_2_content = models.TextField()
section_3_title = models.CharField(max_length=256)
section_3_content = models.TextField()
...
Obviously this was a nightmare to maintain, so I changed it to the following:
class Page(models.Model):
title = models.CharField(max_length=256)
class Section(models.Model):
page = models.ForeignKey(Page, related_name='sections')
title = models.CharField(max_length=256)
content = models.TextField()
order = models.PositiveIntegerField()
class Meta:
ordering = ['order']
order_with_respect_to = 'page'