Forem: Ahmedur Rahman Shovon

Writing Django custom command

Ahmedur Rahman Shovon — Thu, 26 Sep 2019 10:01:43 +0000

When developing application using Django framework, we extensively use various Django commands.
Few common Django commands we use regularly are:

python manage.py runserver
python manage.py makemigrations
python manage.py migrate

These commands are built in and lies within Django itself.

We can also write custom Django admin command. Today I will show an example of wrinting custom Django admin command.

These custom admin commands can be invoked using manage.py COMMAND_NAME.

To add custom Django admin command, firstly we need to add a directory management/commands to any of the apps folder.

Suppose, we need to write a custom Django admin command to insert some data from a CSV file to existing model.

Let's name the command as insert_upazila_office_reports.py.

We have following CSV files:

acland_offices_rank.csv
uno_offices_rank.csv

After placing the files in respective directories, directory structure may look like this:

APPLICATION_ROOT
├── manage.py
├── PROJECT_ROOT
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── APP1
│   ├── admin.py
│   ├── apps.py
│   ├── fixtures
│   │   ├── fixture_1.json
│   │   └── fixture_2.json
│   ├── __init__.py
│   ├── management
│   │   └── commands
│   │       ├── insert_upazila_office_reports.py
│   │       ├── acland_offices_rank.csv
│   │       └── uno_offices_rank.csv
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   └── __init__.py
│   ├── models.py
│   ├── templates
│   │   ├── base_generic.html
│   │   └── index.html
│   ├── tests.py
│   ├── urls.py
│   └── views.py
└── requirements.txt

The name of the CSV file will be passed as argument to the Django command.

The desired functionality of our command is to insert data from passed CSV files to existing model.

This command will insert data from CSV file to UNOOfficeReport model assuming the CSV file name is passed.
Additionally, it will insert data to ACLandOfficeReport model if --acland optional argument is passed.

Let's create the insert_upazila_office_reports.py.

import csv
import os
from django.apps import apps
from django.core.management.base import BaseCommand, CommandError
from reports.models import UNOOfficeReport, ACLandOfficeReport


class Command(BaseCommand):
    help = "Insert Upazila office reports from a CSV file. " \
           "CSV file name(s) should be passed. " \
           "If no optional argument (e.g.: --acland) is passed, " \
           "this command will insert UNO office reports."

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.model_name = UNOOfficeReport

    def insert_upazila_report_to_db(self, data):
        try:
            self.model_name.objects.create(
                upazila=data["upazila"],
                rank=data["rank"],
                office_name=data["office_name"]
            )
        except Exception as e:
            raise CommandError("Error in inserting {}: {}".format(
                self.model_name, str(e)))

    def get_current_app_path(self):
        return apps.get_app_config('reports').path

    def get_csv_file(self, filename):
        app_path = self.get_current_app_path()
        file_path = os.path.join(app_path, "management",
                                 "commands", filename)
        return file_path

    def add_arguments(self, parser):
        parser.add_argument('filenames',
                            nargs='+',
                            type=str,
                            help="Inserts Upazila Office reports from CSV file")
        # Named (optional) arguments
        parser.add_argument(
            '--acland',
            action='store_true',
            help='Insert AC land office reports rather than UNO office',
        )

    def handle(self, *args, **options):
        if options['acland']:
            self.model_name = ACLandOfficeReport

        for filename in options['filenames']:
            self.stdout.write(self.style.SUCCESS('Reading:{}'.format(filename)))
            file_path = self.get_csv_file(filename)
            try:
                with open(file_path) as csv_file:
                    csv_reader = csv.reader(csv_file, delimiter=',')
                    for row in csv_reader:
                        if row != "":
                            words = [word.strip() for word in row]
                            upazila_name = words[0]
                            office_name = words[1]
                            rank = int(words[2])
                            data = {}
                            data["upazila"] = upazila_name
                            data["office_name"] = office_name
                            data["rank"] = rank
                            self.insert_upazila_report_to_db(data)
                            self.stdout.write(
                                self.style.SUCCESS('{}_{}: {}'.format(
                                        upazila_name, office_name,                                        
                                        rank
                                        )
                                )
                            )


            except FileNotFoundError:
                raise CommandError("File {} does not exist".format(
                    file_path))

We can invoke the command like:

python manage.py insert_upazila_office_reports uno_offices_rank.csv

python manage.py insert_upazila_office_reports --acland acland_offices_rank.csv

Important fact about writing custom Django admin command

The command should be a Python class extending BaseCommand class from django.core.management.base
The command file should be placed in management/commands directory.
If you implement __init__ in your subclass of BaseCommand, you must call BaseCommand’s __init__:

  class Command(BaseCommand):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # ...

Figure to get details of our custom Django admin command:

(venv) ➜  nothi git:(master) python manage.py insert_upazila_office_reports --help
usage: manage.py insert_upazila_office_reports [-h] [--acland] [--version]
                                               [-v {0,1,2,3}]
                                               [--settings SETTINGS]
                                               [--pythonpath PYTHONPATH]
                                               [--traceback] [--no-color]
                                               [--force-color]
                                               filenames [filenames ...]

Insert Upazila office reports from a CSV file. CSV file name(s) should be
passed. If no optional argument (e.g.: --acland) is passed, this command will
insert UNO office reports.

positional arguments:
  filenames             Inserts Upazila Office reports from CSV file

optional arguments:
  -h, --help            show this help message and exit
  --acland              Insert AC land office reports rather than UNO office
  --version             show program's version number and exit
  -v {0,1,2,3}, --verbosity {0,1,2,3}
                        Verbosity level; 0=minimal output, 1=normal output,
                        2=verbose output, 3=very verbose output
  --settings SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Raise on CommandError exceptions
  --no-color            Don't colorize the command output.
  --force-color         Force colorization of the command output.

Reference:

Django documentation on Writing custom django-admin commands

This post is first published in https://arshovon.com/blog/django-custom-command/

Update

Added Django Custom Command to Django Docs Example Polls Application in this Github code repository: https://github.com/arsho/django-custom-command

Inheritance in Python

Ahmedur Rahman Shovon — Sat, 21 Oct 2017 20:51:28 +0000

Inheritance is one of the core topic of object oriented programming. It comes handy in a lot of scenarios while designing or developing a complex software. Python supports inheritance with an use of a minimum number of syntax and semantics.

Inheritance is the mechanism of inheriting the properties and methods of an existing class. The inherited class can add more methods and or properties of its own. The class which is used as basis for inheritance is called the base class or parent class or super class. On the other hand, the class that inherits from the parent class is called the child class or subclass or derived class.

Let's see an example of inheritance:

class Animal:
    def eat(self):
        print("It eats.")
    def sleep(self):
        print("It sleeps.")

class Bird(Animal):
    def fly(self):
        print("It flies in the sky.")

    def sing(self):
        print("It sings.")

print(issubclass(Bird, Animal))

duck = Bird()
print(isinstance(duck, Bird))

duck.eat()
duck.sleep()
duck.fly()
duck.sing()

Here Bird class inherits the Animal class. So, Animal is the parent class (also known as super class or base class) and Bird is the child class (also known as sub class or derived class). The issubclass method ensures that Bird is a subclass of Animal class.

Then we created an instance of Bird class called duck. In this case, the isinstance method ensures that duck is an instance of Bird class. We called the methods of Animal class to check if they are inherited in Bird class. Each animal eats and sleeps. Birds are also animals. So, they inherited the properties of animals. On the contrary, only birds can fly and sing. These two characteristics distinguish them from other animals.

Now, let's help the birds to sing their songs. Install a Python package called pyttsx3 to give life to the bird.

You can simply install the package using pip install pyttsx3.

After installing the package, we are going to create a new file called speaker.py which includes a single class named Speaker. This class will convert any text to sound. The speaker.py contains:

import pyttsx3

class Speaker:
    engine = pyttsx3.init()
    def speak(self, text = "No sound is found."):
        print(text)
        self.engine.say(text)
        self.engine.runAndWait()

Then, add another class called SingingBird that inherits both Bird class and Speaker class in our case study example. It is called Multiple Inheritance. Update the previous code as follow:

from speaker import Speaker
class Animal:
    def eat(self):
        print("It eats.")
    def sleep(self):
        print("It sleeps.")

class Bird(Animal):
    def fly(self):
        print("It flies in the sky.")
    def sing(self):
        print("It sings.")
    def speak(self, text = "No sound is found."):
        print("It can not speak but can write it.")
        print(text)

class SingingBird(Speaker, Bird):
    def __init__(self, birdName = "Bird Name"):
        self.birdName = birdName
    def printBirdName(self):
        print("This is a {birdName}!".format(birdName = self.birdName))

print(SingingBird.__bases__)

duck = SingingBird("Duck")
duck.printBirdName()
duck.eat()
duck.sleep()
duck.fly()
duck.sing()
duck.speak("Quack quack, quack quack, quack quack")

The output looks like:

(<class '__main__.Bird'>, <class 'speaker.Speaker'>)
This is a Duck!
It eats.
It sleeps.
It flies in the sky.
It sings.
Quack quack, quack quack, quack quack

The __bases__ attribute of SingingBird shows (<class '__main__.Bird'>, <class '__main__.Speaker'>) which ensures the multiple inheritance of that class. So, we see that Python supports Multiple Inheritance like a charm.

We see that speak method exists in both Bird and Speaker class. As SingingBird inherits both Bird class and Speaker class, why speak method of Speaker class is being invoked? The answer is SingingBird invokes the first speak method of it's base classes. If a method is implemented differently by two or more of the super classes, the order of the class method should be maintained.

The methods in the earlier classes override the methods in later ones. So, if we create SingingBird like class SingingBird(Bird, Speaker) it would override (making the bird mute!) the speak method of the Speaker class. Reversing their order like this: class SingingBird(Speaker, Bird) would make the speak method of Speaker class accessible.

All codes can be found in this gist.

Thanks to David Griffin for giving vital suggestions to improve this post.