Comment accéder aux classes enfant d'un objet dans django sans connaître le nom de la classe enfant ?

Question

Dans Django, lorsque vous avez une classe parent et plusieurs classes enfants qui en héritent, vous accédez normalement à une classe enfant par le biais de parentclass.childclass1_set ou parentclass.childclass2_set, mais que faire si je ne connais pas le nom de la classe enfant spécifique que je veux ?

Existe-t-il un moyen d'obtenir les objets liés dans le sens parent->enfant sans connaître le nom de la classe enfant ?

Answer 1

( Mise à jour : Pour Django 1.2 et les versions plus récentes, qui peuvent suivre les requêtes select_related à travers les relations inverses OneToOneField (et donc dans les hiérarchies d'héritage), il existe une meilleure technique qui ne nécessite pas l'ajout de l'outil de gestion de l'héritage. real_type sur le modèle parent. Il est disponible en tant que InheritanceManager en el django-model-utils projet.)

La façon habituelle de procéder est d'ajouter une clé étrangère à ContentType sur le modèle parent qui stocke le type de contenu de la classe "feuille" appropriée. Sans cela, vous pouvez avoir à faire un certain nombre de requêtes sur les tables enfant pour trouver l'instance, selon la taille de votre arbre d'héritage. Voici comment je l'ai fait dans un projet :

from django.contrib.contenttypes.models import ContentType
from django.db import models

class InheritanceCastModel(models.Model):
    """
    An abstract base class that provides a ``real_type`` FK to ContentType.

    For use in trees of inherited models, to be able to downcast
    parent instances to their child types.

    """
    real_type = models.ForeignKey(ContentType, editable=False)

    def save(self, *args, **kwargs):
        if self._state.adding:
            self.real_type = self._get_real_type()
        super(InheritanceCastModel, self).save(*args, **kwargs)

    def _get_real_type(self):
        return ContentType.objects.get_for_model(type(self))

    def cast(self):
        return self.real_type.get_object_for_this_type(pk=self.pk)

    class Meta:
        abstract = True

Elle est implémentée en tant que classe de base abstraite afin de la rendre réutilisable ; vous pourriez également placer ces méthodes et le FK directement sur la classe parent dans votre hiérarchie d'héritage particulière.

Cette solution ne fonctionnera pas si vous n'êtes pas en mesure de modifier le modèle parent. Dans ce cas, vous devrez vérifier manuellement toutes les sous-classes.

Answer 2

En Python, étant donné une classe X ("nouveau style"), vous pouvez obtenir ses sous-classes (directes) avec X.__subclasses__() qui renvoie une liste d'objets de classe. (Si vous voulez "d'autres descendants", vous devrez également appeler __subclasses__ sur chacune des sous-classes directes, etc etc -- si vous avez besoin d'aide sur la façon de faire cela efficacement en Python, il suffit de demander !).

Une fois que vous avez identifié d'une manière ou d'une autre une classe enfant intéressante (peut-être toutes, si vous voulez des instances de toutes les sous-classes enfants, etc,) getattr(parentclass,'%s_set' % childclass.__name__) devrait aider (si le nom de la classe enfant est 'foo' c'est juste comme accéder parentclass.foo_set -- ni plus, ni moins). Encore une fois, si vous avez besoin de précisions ou d'exemples, n'hésitez pas à demander !

Answer 3

Il s'avère que ce dont j'avais vraiment besoin était ceci :

Héritage de modèle avec type de contenu et gestionnaire conscient de l'héritage

Cela a parfaitement fonctionné pour moi. Merci à tous les autres, cependant. J'ai beaucoup appris en lisant vos réponses !

Answer 4

La solution de Carl est bonne, voici une façon de le faire manuellement s'il y a plusieurs classes enfants liées :

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

Elle utilise une fonction de _meta, dont la stabilité n'est pas garantie au fur et à mesure que django évolue, mais elle fait l'affaire et peut être utilisée à la volée si nécessaire.

Answer 5

Voici ma solution, qui utilise à nouveau _meta il n'est donc pas garanti qu'il soit stable.

class Animal(models.model):
    name = models.CharField()
    number_legs = models.IntegerField()
    ...

    def get_child_animal(self):
        child_animal = None
        for r in self._meta.get_all_related_objects():
            if r.field.name == 'animal_ptr':
                child_animal = getattr(self, r.get_accessor_name())
        if not child_animal:
            raise Exception("No subclass, you shouldn't create Animals directly")
        return child_animal

class Dog(Animal):
    ...

for a in Animal.objects.all():
    a.get_child_animal() # returns the dog (or whatever) instance