What's the accepted best practice when specifying a set of related fields in Django?

Question

Say I was creating a 'Character' model in Django for an RPG, and I wanted all the attributes (Strength, Dexterity, Stamina etc.) to be defined in a similar way, and be able to be treated in a similar way.

Obviously I could do this:

intelligence = IntegerRangeField(min_value=1, max_value=10)
wits= IntegerRangeField(min_value=1, max_value=10)
resolve = IntegerRangeField(min_value=1, max_value=10)
strength = IntegerRangeField(min_value=1, max_value=10)
dexterity = IntegerRangeField(min_value=1, max_value=10)
stamina = IntegerRangeField(min_value=1, max_value=10)
presence = IntegerRangeField(min_value=1, max_value=10)
manipulation = IntegerRangeField(min_value=1, max_value=10)
composure = IntegerRangeField(min_value=1, max_value=10)

_{IntegerRangeField definition}

But that's not particularly DRY. It also means when I get to add ~30 skills that are similar I'm going to be even less dry, and prone to mistakes.

These don't seem worth creating via foreign keys (which is the solution here), as I'd need to specify 9 of them for each attribute etc.

Is there a solution to this already that is DRY? Or will I need to roll my own?

Edit:
My Primary use of attributes and skills is to provide totals for skill checks, for instance if I want to know how many dice to roll for Programming I might specify it uses the characters intelligence+computers attributes and skill, and for example from a list of 'Tasks' (e.g. other combinations of attributes and skills) show the top five that character can perform.

---

Edit:

Looks like following the M2M route has lead me to overnormalization. Would anyone be able to suggest improvements?

Answer 1

You can use many to many field relation for this kind of situation (like @RonaldOldenburger suggested) where you need to repeat your fields. For example:

class Skill(models.Model):
    name = models.CharField(max_length=255)
    value = IntegerRangeField(min_value=1, max_value=10)

class Character(models.Model):
    name = models.CharField(max_length=255)
    skill = models.ManyToManyField(Skill)

And if you use modelform to create a Character model instance, then you can use model formset factory to add Skillto it.

Answer 2

Why don't you just work with a ManyToManyField?

That way you can easily add and manage those attributes. Also more easy to manage, as in your situation you have to add a column for each attribute.

Answer 3

Ok, I'll be blamed to death but there is also the MonkeyPatch technique (which I like and use but can lead to poor readability) or you can make a simple shortcut.

Here the monkey patch, the best part of it is that if you have a skill index somewhere, you can use it:

SKILLS = ["skill_1", "skill_2", "skill_3"]
for skill in SKILLS:
    IntegerRangeField(
        min_value=min_value, max_value=max_value
    ).contribute_to_class(MyModel, skill)

Note: it works well with migrations while you keep it in the right app models files

Here the shortcut:

def new_skill(min_value=1, max_value=10, **kwargs):
    return IntegerRangeField(
        min_value=min_value, max_value=max_value, **kwargs)

class MyModel(models.Model):
    skill_1 = new_skill()
    skill_2 = new_skill()
    skill_3 = new_skill(verbose_name=_("translatable skill name"))

Hope it can helps.

edit: You suggested to split the repetitive ugly part listing all fields in an other file so new possibility, hide hugly not dry code in an abstract class (or split models.py but it's harder to explain).

class RpgSkills(models.Model):
    skill_1 = new_skill()
    skill_2 = new_skill()
    skill_3 = new_skill(verbose_name=_("translatable skill name"))

    class Meta:
        abstract = True # means will not have any data table by it's own

Then in your models.py:

from skills_utils import RpgSkills

class Character(RpgSkills):
    name = CharField(max_length=128)

Here more about abstract classes : https://docs.djangoproject.com/en/1.7/topics/db/models/#abstract-base-classes

Or you can combine all together if you are a funny man:

here the tool:

def skill_fields(*skills):
    class MyAbstractModel(models.Model):
        class Meta:
            abstract = True

    for skill in skills:
        new_skill().contribute_to_class(MyAbstractModel, skill)
    return MyAbstractModel

here the usage:

from skills_utils import skill_fields

class Character(skill_fields("skill_1", "skill_2", *settings.MY_APP_SKILL_LIST)):
    name = CharField(max_length=128)

But this last is for those who have the finest humour only ;-)

PS: If I were you I would choose the shortcut way which leave open more customisation if you want to have some special skills with wider or smaller range and it's simply more readable for who ever can take the project after you.

Answer 4

It depends on how you're going to use these stats.

• If you need to get the list of players based on their intelligence for example; having a field for it is easier/better (your solution). That solution also involves less code (at least initially).

• If you need to list statistics, see the best characters for each, etc. you better go with the solution you linked. Ask yourself, should "intelligence" be an "entity" on its own (with a slug, a description, etc.)?

• Here is another option; let's say you just need a global "level" value for most queries and the details of the stats are only useful when checking a player:

-

from jsonfield.fields import JSONField


class User(…):
    statistics = JSONField(help_text="Intelligence, Wits, etc.")
    level = models.PositiveIntegerField(default=0)

This way you can pack your 30+ stats in one field and still query quickly on the user level/experience. You could also extend JSONField.