Group Django commands to a folder inside the same app

Question

Is it allowed to group custom Django commands to separate folders inside the same Django app?

I have a lot of them and wanted to group them logically by purpose. Created folders but Django can't find them.

Maybe I'm trying to run them wrong. Tried:

• python manage.py process_A_related_data
• the same plus imported all commands in __init__.py
• python manage.py folderA process_A_related_data
• python manage.py folderA.process_A_related_data
• python manage.py folderA/process_A_related_data

Got following error:

Unknown command: 'folderA/process_A_related_data'
Type 'manage.py help' for usage.

Answer 1

I think you can create a basic custom command which will run other commands from relevent folders. Here is an approach you can take:

First make a folder structure like this:

management/
    commands/
       folder_a/
          process_A_related_data.py
       folder_b/
          process_A_related_data.py
       process_data.py

Then inside process_data.py, update the command like this:

from django.core import management
from django.core.management.base import BaseCommand

import importlib

class Command(BaseCommand):
   help = 'Folder Process Commands'

   def add_arguments(self, parser):
       parser.add_argument('-u', '--use', type=str, nargs='?', default='folder_a.process_A_related_data')
    
   def handle(self, *args, **options):
       try:
           folder_file_module = options['use'] if options['use'].startswith('.') else '.' + options['use']
           command = importlib.import_module(folder_file_module, package='your_app.management.commands')
           management.call_command(command.Command())
       except ModuleNotFoundError:
           self.stderr.write(f"No relevent folder found: {e.name}")

Here I am using call_command method to call other managment commands.

Then run commands like this:

python manage.py process_data --use folder_a.process_A_related_data

Finally, if you want to run commands like python manage.py folder_a.process_A_related_data, then probably you need to change in manage.py. Like this:

import re
...

try:
    from django.core.management import execute_from_command_line
except ImportError as exc:
    raise ImportError(
        "Couldn't import Django. Are you sure it's installed and "
        "available on your PYTHONPATH environment variable? Did you "
        "forget to activate a virtual environment?"
    ) from exc

if re.search('folder_[a-z].*', sys.argv[-1]):
    new_arguments = sys.argv[:-1] + ['process_data','--use', sys.argv[-1]]
    execute_from_command_line(new_arguments)
else:
    execute_from_command_line(sys.argv)

Answer 2

You should be able to partition the code by using mixins (I have not tried this in this context, though)

A standard management command looks like

from django.core.management.base import BaseCommand

class Command(BaseCommand):
   help = 'FIXME A helpful comment goes here'

    def add_arguments(self, parser):
        parser.add_argument( 'name', ...)
        # more argument definitions

    def handle(self, *args, **options):  
        # do stuff

Which can probably be replaced by a "stub" in app/management/commands:

from wherever.commands import FooCommandMixin
from django.core.management.base import BaseCommand    
class Command(FooCommandMixin, BaseCommand): 
    # autogenerated -- do not put any code in here!
    pass

and in wherever/commands

class FooCommandMixin( object):
   help = 'FIXME A helpful comment goes here'

    def add_arguments(self, parser):
        parser.add_argument( 'name', ...)
        # more argument definitions

    def handle(self, *args, **options):  
        # do the work

It would not be hard to write a script to go through a list of file names or paths (using glob.glob) using re.findall to identify appropriate class declarations, and to (re)generate a matching stub for each in the app's management/commands folder.

Also/instead Python's argparse allows for the definition of sub-commands. So you should be able to define a command that works like

./manage.py foo bar --aa --bb something --cc  and
./manage.py foo baz --bazzy a b c 

where the syntax after foo is determined by the next word (bar or baz or ...). Again I have no experience of using subcommands in this context.

Answer 3

I found no mention of support for this feature in the release notes. It looks to be that this is still not supported as of version Django 3.0. I would suggest that you use meaningful names for your files that help you specify. You could always come up w/ a naming convention!

Answer 4

A workaround could be: create a specific Django "satellite" app for each group of management commands.

In recent version of Django, the requirements for a Python module to be an app are minimal: you won't need to provide any fake models.py or other specific files as happened in the old days.

While far from perfect from a stylistic point of view, you still gain a few advantages:

• no need to hack the framework at all
• python manage.py will list the commands grouped by app
• you can control the grouping by providing suitable names to the apps
• you can use these satellite apps as container for specific unit tests

I always try to avoid fighting against the framework, even when this means to compromise, and sometimes accept it's occasional design limitations.