[Django]-Django: how to fully decouple apps when it seems they are coupled?

Question 0

A “module” in the Python context is simply a file that contains definitions and statements. So “related modules under a package” really just means “split your code into separate files based on what the code is doing”.

Describing it as “an app made of other apps” is to start confusing Django’s concept of an app with Python’s concept of a module (which, as stated above is just a file that houses some code).

Question 1

What should I do when apps share models?

You should still try and stick to the “apps do one thing and do it well” maxim. In this case separate profile and registration apps seems like a good idea – because they have quite different functions. A registration app is going to contain the logic for allowing users to register on your site. A profile app is all about what information you will store about a user.

There is nothing wrong with these two apps having a relationship to each other – see below.

Question 2

Let’s say that my main app (or some other app that is used by the main app) utilizes some aspect of the user model (e.g. recently active members if it was a chat site). Clearly my main app gets this information from the user model. Does my main app now get bundled under the user-app?

No. It should still be a separate app, with links to the other app.

The user model is actually a good example. Django allows you to specify a custom user model that lets you store whatever additional data you want about a user.

Now, there are loads of third party apps out there that do things like registration, authentication, etc for users. They are designed to work with any user model, not just Django’s default one. The way they do that is to use get_user_model() wherever they need to reference the User model, instead of directly importing django.contrib.auth.models.User.

This means that you can use those third party apps with whatever user model you have defined for your own project.

Django’s get_user_model() utility is there to serve a very common use case. However the same principle can be extended to your own apps. If there is a dependency between your apps that you think should be swappable, then you can provide a way to swap it out – e.g., a setting/configuration that allows any other project using your app to specify an alternative.

There are hundreds of examples of this kind of configurability in the Django ecosystem. For example, Django itself ships with its own django.contrib.auth authentication app. However if you want to implement your own authentication logic, you don’t have to reimplement the entire auth app again yourself (that would be a huge pain). Instead you specify an an authentication backend that it’s auth app will use to authenticate. The auth app is designed to allow any project to swap out a core piece of its functionality with minimal effort.

So in your main app, you might define a setting that controls which profile model to use. This means that if someone else wants to use a different profile model, they simply change this setting and they’re all set. They are no longer tied to your profile app.

For example – let’s say you have a main app that has a view that displays some user data, but also provides a link to a registration view that is provided by a different app. You want anyone else to be able to use that app regardless of what registration app they are using. So you can make this view resuable like so:

In main/views.py:

from django.contrib.auth import get_user_model
from django.conf import settings
from django.urls import reverse

class UserDetailView(DetailView):

    # First of all, we're using get_user_model so that a project
    # can specify whatever user model it wants, and still use this
    # view.
    model = get_user_model()

    def get_context_data(self, *args, *kwargs):
        ctx = super().get_context_data(*args, **kwargs)
        # We want to add a link to a registration view into this template context.
        # But we want this to be configurable.
        # Your REGISTRATION_URL would be something like 'profile:registration'
        ctx['registration_link'] = reverse(settings.REGISTRATION_URL)
        return ctx

Question 3

The main app serves as the landing page/ overview in this case. I want all my other apps to use / inherit the static and template files of the main app. Where do I store all the static files and templates?

You should store the templates in each respective app. If your main app is providing the base templates, then those should reside in the main app.

If your profile app is then providing a registration view, then the template for that should live in the profile app. There is nothing wrong with it extending the base template from the main app – this can easily be overridden by a project that wants to.

It’s fine to make assumptions about how two apps are related to each other – as long as you’re careful to allow overriding of those assumptions.