Django model relationship infos with on_delete property

Question

I want to know what models are children of a model to retrieve their on_delete property. As I know, like below, if we have ownerModel which is parent of childModel1 and check1Model:

import uuid
from django.db import models

class ownerModel(models.Model):
    ownerId = models.UUIDField(default=uuid.uuid4, unique=True, primary_key=True, editable=False, blank=True)

class check1Model(models.Model):
    checkId = models.UUIDField(default=uuid.uuid4, unique=True, primary_key=True, editable=False, blank=True)
    owner=models.ForeignKey(ownerModel,on_delete=models.CASCADE)

class childModel1(models.Model):
    childId = models.UUIDField(default=uuid.uuid4, unique=True, primary_key=True, editable=False, blank=True)
    check2=models.ForeignKey(ownerModel,on_delete=models.CASCADE)

Then we can get what models are children of ownerModel with a code like this:

class myView(views.APIView):
    def get(self, request, format=None):
        for f in ownerModel._meta.get_fields():
            if 'field' in f.__dict__.keys():
                print('***childModels***')
                print(f.__dict__)
                print()
        return Response({'0000'}, status=status.HTTP_200_OK)

I mean by checking if the field key is in __dict__.keys() in items of ownerModel._meta.get_fields().

Of course, here we get extended info about children models:

***childModels***
{'field': <django.db.models.fields.related.ForeignKey: owner>, 'model': <class 'Users.models.ownerModel'>, 'related_name': None, 'related_query_name': None, 'limit_choices_to': {}, 'parent_link': False, 'on_delete': <function 
CASCADE at 0x00000286550848B0>, 'symmetrical': False, 'multiple': True, 'field_name': 'ownerId', 'related_model': <class 'Users.models.check1Model'>, 'hidden': False}

***childModels***
{'field': <django.db.models.fields.related.ForeignKey: check2>, 'model': <class 'Users.models.ownerModel'>, 'related_name': None, 'related_query_name': None, 'limit_choices_to': {}, 'parent_link': False, 'on_delete': <function CASCADE at 0x00000286550848B0>, 'symmetrical': False, 'multiple': True, 'field_name': 'ownerId', 'related_model': <class 'Users.models.childModel1'>, 'hidden': False}

So I find these 2 conditions necessary to get child models info:

1. In child models, making sure child relationship is set up with a line like below:

models.ForeignKey(ownerModel,on_delete=models.CASCADE)

2. As said "if the field key is in __dict__.keys() in items of ownerModel._meta.get_fields()" to get children info.

But the problem is that in some cases I can't get the children info from parent model. So:

1. It makes me wonder if these 2 conditions are enough to find out which models are children of a model?
2. Are there other similar ways to get which models are children of a model?

By the way, I want to have on_delete also and having on_delete is the only reason I am using _meta.get_fields() over _meta.fields because _meta.fields doesn't provide on_delete property.

This is my code if you wanna have a look. Note that in full answer I also wanna know what has made problem. So in this case, that __dict__.keys() doesn't provide items which don't have field in their keys (doesn't provide child model details). Because generally those 2 conditions provide child model details. So later I can get child model details in all codes.

the problem is that even with for f in ownerModel._meta.get_fields(include_hidden=True) and without any further ifs doesnt retrieve lines including on_delete properties in this project. but in the other projects ownerModel._meta.get_fields() provides them. and I don't whats the cause that sometimes ownerModel._meta.get_fields() provides these relationships infos and other times doesnt.

Answer 1

you can find children of a model using Model._meta.related_objects

# Example Code
from django.utils.functional import classproperty
from django.db import models

class SomeModel(models.Model):
    class Meta:
        abstract = True
    
    @classproperty
    def related_objects(cls):
        """
        Return list of related models within the same module
        ManyToManyRel not supported
        """
        related_objects = [
            rel
            for rel in cls._meta.related_objects
            if isinstance(rel, (models.ManyToOneRel, models.OneToOneRel))
        ]
        return [
            (rel.related_model, rel.on_delete)
            for rel in related_objects
            if rel.related_model._meta.app_label == cls._meta.app_label
        ]

You can use this class as an mro for your models.

Answer 2

If you want to retrieve the backward relationships to this model, you may use ownerModel._meta.related_objects. This is however part of Django's private API and isn't officially documented/supported. You can yet find documentation in the source code.

Return all related objects pointing to the current model. The related objects can come from a one-to-one, one-to-many, or many-to-many field relation type.

Private API intended only to be used by Django itself; get_fields() combined with filtering of field properties is the public API for obtaining this field list.

You can also get similar result using the public API by filtering get_fields():

related_objects = [
    f for f in ownerModel._meta.get_fields(include_hidden=True)
    if (not f.hidden and (f.one_to_one or f.one_to_many)) or f.many_to_many
]

This solution additionally gives you the many-to-many relationships defined within ownerModel, which is likely expected if you want many-to-many at all. To exclude all the many-to-many relationships, just remove them from the condition:

related_objects = [
    f for f in ownerModel._meta.get_fields(include_hidden=True)
    if not f.hidden and (f.one_to_one or f.one_to_many)
]

A way to strictly get the backwards relationships only (ie. removing the many-to-many and one-to-one relations defined within the ownerModel), could be to test the presence of ForeignObjectRel in the field's hierarchy.

from django.db.models import ForeignObjectRel

related_objects = [
    f for f in ownerModel._meta.get_fields(include_hidden=True)
    if isinstance(f, ForeignObjectRel) and (not f.hidden or f.many_to_many)
]

---

If what you want is to display the value of the on_delete property, you can limit the results to one-to-one and one-to-many fields.

from django.db.models import ForeignObjectRel

related_objects = [
    f for f in ownerModel._meta.get_fields()
    if isinstance(f, ForeignObjectRel)
    and (f.one_to_one or f.one_to_many)
]
for f in related_objects:
    print(f, f.on_delete)

Answer 3

Update

After further investigation in the comments, it turned out that the issue was that models were not defined in a models submodule. As stated in Django docs:

Once you have defined your models, you need to tell Django you’re going to use those models. Do this by editing your settings file and changing the INSTALLED_APPS setting to add the name of the module that contains your models.py.

This requirement can also be confirmed in Django source code that handles models detection:

MODELS_MODULE_NAME = "models"


class AppConfig:

    ...

    def import_models(self):
        # Dictionary of models for this app, primarily maintained in the
        # 'all_models' attribute of the Apps this AppConfig is attached to.
        self.models = self.apps.all_models[self.label]

        if module_has_submodule(self.module, MODELS_MODULE_NAME):
            models_module_name = "%s.%s" % (self.name, MODELS_MODULE_NAME)
            self.models_module = import_module(models_module_name)

---

Original answer

There is no obvious reason why using __dict__ wouldn't work. However, __dict__ is not really meant for this kind of usage. This is not reliable and there is no reason to use it over hasattr() for instance.

Here are a few examples of what could go wrong with __dict__:

In [1]: class A:
   ...:     def __init__(self):
   ...:         self.foo = 'foobaz'
   ...:         self.bar = 'barbaz'
   ...: 

In [2]: a = A()

In [3]: a.__dict__
Out[3]: {'foo': 'foobaz', 'bar': 'barbaz'}

In [4]: class B(A):
   ...:     @property
   ...:     def bar(self):
   ...:         return 'barfoo'
   ...:     @bar.setter
   ...:     def bar(self, value):
   ...:         pass
   ...: 

In [5]: b = B()

In [6]: b.__dict__
Out[6]: {'foo': 'foobaz'}
# B redefined 'bar' as a property, which removed it from __dict__

In [7]: 'bar' in b.__dict__
Out[7]: False

In [8]: hasattr(b, 'bar')
Out[8]: True

In [9]: class C(A):
   ...:     __slots__ = ('foo', 'bar')
   ...: 

In [10]: c = C()

In [11]: c.foo
Out[11]: 'foobaz'

In [12]: c.bar
Out[12]: 'barbaz'

In [13]: c.__dict__
Out[13]: {}
# C defined 'foo' and 'bar' as slots, which removed them from __dict__

In [14]: hasattr(c, 'foo')
Out[14]: True

You could instead use hasattr():

for f in ownerModel._meta.get_fields():
    if hasattr(f, 'field'):
        print(f, f.on_delete)
        print()

However, checking on the presence of a field attribute doesn't seem to be a reliable solution to determine whether the field is a backward relation or not. I would rather recommend to rely on one_to_one and one_to_many attributes which are None for non-relation fields, and True/False for relation fields:

for f in ownerModel._meta.get_fields():
    if (f.one_to_one or f.one_to_many) and hasattr(f, 'on_delete'):
        print(f, f.on_delete)
        print()

I also included hasattr(f, 'on_delete') in the condition, to exclude OneToOneField relations defined within ownerModel. It would probably be cleaner to test isinstance(f, ForeignObjectRel) though:

from django.db.models import ForeignObjectRel

for f in ownerModel._meta.get_fields():
    if isinstance(f, ForeignObjectRel) and (f.one_to_one or f.one_to_many):
        print(f, f.on_delete)
        print()