Django cheatsheet

# Create et access project folder
~$  mkdir project_name
~$  cd project_name

# Create Python virtual env
~$  python3 -m venv venv

# Activate virtual env
~$  source venv/bin/activate

# If you want to deactivate virtual env
~$  deactivate

# Install django (~= same as 4.2.*)
~$  pip install django~=4.2.0

# New django project (from project_name folder)
~$  django-admin startproject config

# Create app (from project_name folder)
~$  python manage.py startapp app_name

Django create a database table for each models present in your app using those commands:

Makemigrations: Create a file under app_name/migrations with the database structure to create

~$  python manage.py makemigrations

Migrate: Will read the migrations files and create the actual database and tables

~$  python manage.py migrate

~$  python manage.py createsuperuser

~$  python manage.py runserver  => ex.  http://127.0.0.1:8000

# Create a requirements file that contain all your project dependencies
~$  pip freeze > requirements.txt

# Install your project requirements (if a requirements file exist)
~$  pip install -r requirements.txt

# Django shell (Run project code directly)
~$ python manage.py shell

# example of code to run in the shell:
 >>> from app_name.models import User
 >>> user1 = User.objects.first()

# Prepare static folders for production
~$ python manage.py collectstatic

# Take all data from app blog and export in json
~$ python manage.py dumpdata blog > myapp.json

# Take all data in json file and import in app data table
~$ python manage.py loaddata myapp.json

# To Create or Update a message file for Translation, run this command
~$ django-admin makemessages -l de
# Updating message files
~$ django-admin compilemessages

# One-to-Many: (use double quotes if the entity is not yet declare) ex. "Supplier"
supplier = models.ForeignKey(Supplier, blank=True, null=True, on_delete=models.CASCADE,related_name="supplierother")

# on_delete can be set to models.CASCADE, models.ST_DEFAULT or models.SET_NULL
# The related_name attribute specifies the name of the reverse relation from the supplier model back to your model

# Many-to-Many:
tags = models.ManyToManyField(Tag, blank=True)

# One to One
User = models.OneToOneField(User, on_delete=models.CASCADE)

# Overwrite save method
def save(self, (*args, **kwargs):
    if not self.slug:
        self.slug = slugify(self.title)
    super().save(*args, **kwargs)

Django routing info is store in project_folder/urls.py file

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls), # pre-created admin urls routes
    path('', include('app_name.urls')) # include your app urls
]

The 'include()' method allow to link another urls.py file created in your app folder (app_name/urls.py)

from django.urls import path
from app_name import views

urlpatterns = [
    path('posts', views.index, name='posts.index'),
    path('posts/create/', views.create, name='posts.create',
    path('posts/<int:id>/', views.show, name='posts.show'),
    path('posts/<int:id>/edit/', views.edit, name='posts.edit'),
    path('posts/<int:id>/delete/', views.delete, name='posts.delete'),
    path('posts/<int:id>/<int:state>/', views.status, name='posts.status'), # two arguments
]

Templates are store in project_folder/templates or in your app_folder/templates/app_name/*.html

<!--swig25-->
<!--swig20-->

<!--swig26-->

# include template with One or More Parameters
<!--swig27-->

<!--swig21-->

<!--swig22-->

# Access to the variable in the template
<!--swig2-->

# Template variables formatting
<!--swig3-->
<!--swig4-->
<!--swig5-->
<!--swig6-->
<!--swig7-->

# Current path (ex. posts/1/show)
<!--swig8-->

# URL by name with param
<!--swig28-->

# Use static in template:
<!--swig29-->
<!--swig30-->

# Define the variable in the template
<!--swig23-->

For example, if your custom tags/filters are in a file called basetags.py, your app layout might look like this:

app_name/
└─── templatetags/
     └─── basetags.py
     __init__.py
     models.py
     views.py

• And in your template you would use the following:

<!--swig31-->

• the module must contain a module-level variable named register that is a template.Library instance, in which all the tags and filters are registered. So, near the top of your module, put the following:

Custom filters are Python functions that take one or two arguments: The value of the variable (input) – not necessarily a string. The value of the argument – this can have a default value, or be left out altogether. For example, in the filter {{ var|foo:"bar" }}, the filter foo would be passed the variable var and the argument "bar".

The Library.filter() method takes two arguments: The name of the filter – a string. The compilation function – a Python function (not the name of the function as a string). You can use register.filter() as a decorator instead:

# basetags.py
from django import template

register = template.Library()

@register.filter(name="cut")
def cut(value, arg):
    """Removes all values of arg from the given string"""
    return value.replace(arg, "")

# Most filters don’t take arguments. In this case, leave the argument out of your function
@register.filter()
def lower(value): # Only one argument.
    """Converts a string into all lowercase"""
    return value.lower()


@register.simple_tag
def to_class_name(object):
    return str(object.__class__.__name__)

# Template
# And here’s an example of how that filter would be used in Template:
<!--swig11-->

# Put the result of simple tag into a variable
<!--swig32-->
<p>Model Class Name: <!--swig12--></p>

Model manager allow model database reads and writes

# One line create and save
Article.objects.create(name='Item 1', price=19.95)

# Read all
Article.objects.all()

# Create
user = User.objects.first()
article = Article(user=user, name='Item 1', price=19.95)

# Save
article.save()

# Read one
Article.objects.get(id=1)

# Select Related (to avoid n+1 query)
posts = Post.objects.select_related('user', 'category').all()

# Read or render a 404 not found page
from django.shortcuts import get_object_or_404
article = get_object_or_404(Article, id=512)

# Filter
Article.objects.filter(model='dyson', name__icontains='dyson') # __icontains
Article.objects.filter(year__gt=2016) # __gt = greater than
Article.objects.filter(year__lt=2001) # __lt = less than

# Filter on relationship sub model field
Article.objects.get(user__username='mike')

# Ordering
Article.objects.order_by('name')     # ascending
Article.objects.order_by('-name')   # descending

# Slicing return first
Article.objects.all().order_by('name')[0]

# Slicing return last
Article.objects.all().order_by('-name')[0]

# Slicing limit/offset
Article.objects.all().order_by('name')[1..10]

# Updating
article = Article.objects.first()
article.name = 'new name'
article.save()

# One line update
Article.objects.filter(id=4).update(name='new name')

# Deleting
article = Article.objects.first()
article.delete()

# One line delete
article.objects.get(id=1).delete()

# Delete all
Article.objects.all().delete()

# Set ForeignKey field value
model1 = Model(name='dyson')
article.model = model1

# Get ForeignKey value
article1.model.name
model1.article_set.all()

# Add Many-to-Many
article1.tags.add(tag1)
article1.tags.all()
tag1.articles_set.all()

# forms.py
from django.core.exceptions import ValidationError

# field validation
def clean_first_name(self):
    data = self.cleaned_data['first_name']
    if data = 'Mike':
        raise ValidationError('Your name must not be Mike')
    return data

# form validation
def clean(self):
    first_name = self.cleaned_data['first_name']
    last_name = self.cleaned_data['last_name']
    if first_name + last_name = 'MikeTaylor':
        raise ValidationError('Your name must not be Mike Taylor')

$ pip install python-decouple

Create a file name '.env' in the root folder of your project

SECRET_KEY = 'your secret key'
ALLOWED_HOST = 127.0.0.1

In settings.py change security related settings to point to the .env file

from decouple import config

SECRET_KEY = config('SECRET_KEY')
ALLOWED_HOST = config('ALLOWED_HOST')

Celery is a distributed task queue that can collect, record, schedule, and perform tasks outside of your main program.

#Step 1: Install Celery Using pip

~$ pip install celery       # pip install celery[redis]

#Step 2. Add celery.py File in Your Project Module

# your_project/celery.py
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE','your_project_name.settings')
app = Celery('your_project_name')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

@app.task(bind=True)
def debug_task(self):
    print(f'Request: {self.request!r}')

#Step 3: Import the Celery App to Django

To ensure that the Celery app is loaded when Django starts, add the following code into the __init__.py file that sits on the project module beside on settings.py file.

# your_project/__init__.py
from .celery import app as celery_app

__all__ = ('celery_app',)

#Step 4: Download and Run Redis as a Celery ‘broker’

~$ redis-server

You can test that Redis is working properly by typing this into your terminal:

~$ redis-cli ping

Redis should reply with PONG - try it!

#Step 5: Add Redis as a Dependency in the Django Project:

~$ pip install redis

#Step 6: Celery Stuff Configure to the Django Settings File

Once Redis is up, add the following code to your settings.py file and use celery-result

~$ pip install django-celery-results

This extension enables you to store Celery task results using the Django ORM.
It defines a single model (django_celery_results.models.TaskResult) used to store task results, and you can query this database table like any other Django model.

INSTALLED_APPS = [
                … ,
                'django_celery_results',
                ]

BROKER_URL = 'redis://localhost:6379'
CELERY_RESULT_BACKEND = 'redis://localhost:6379'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = TIME_ZONE
CELERY_RESULT_BACKEND = 'django-db'
CELERY_CACHE_BACKEND = 'django-cache'

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'redis://localhost:6379/1',
        "OPTIONS": {
                    "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

#That’s it! You should now be able to use Celery with Django

Test that the Celery worker is ready to receive tasks:

~$ celery -A your_project_name worker -l info

The most important task is: Always run a worker is needed to execute the celery task if any error throws from Redis like this:

AttributeError: 'str' object has no attribute 'items'

• the solution is: you have to use Redis old version

#Step 1: Add tasks.py File to Your Django App.

# app_name/tasks.py
from celery import shared_task
from celery.decorators import task
from time import sleep


@task(name='my_first_task')
def my_first_task(duration):
    sleep(duration)
    return('first_task_done')

@shared_task
def test_func():
    for i in range(10):
        print(i)
    return 'End_OK'

@shared_task
def adding(x, y):
    time.sleep(10)
    result = x + y
    return result

#Step 2: Assign Task to the Celery.

You need to assign a task to the celery. To assign this task you need to call this function with something different. celery gives us two methods delay() and apply_async() to call task.

# Normal function call in python
~$ my_first_task()

# add task to the celery with function call
~$ my_first_task.delay()

You can send argument to the function using the delay method. To check celery on the action open a separate tab of the terminal then go to the project directory (activate environment if you are using one) and run this command again

~$ celery -A your_project_name worker -l info

# app_name/views.py
from django.http import HttpResponse
from app_name.tasks import my_first_task, test_func, adding

def index(request):
    my_first_task.delay(10)
    result = adding.delay(x=4, y=5)
    return HttpResponse(f'response done. {result}')

def test(request):
    test_func.delay()
    return HttpResponse("Done")

#Then call the view from your app URL

# app_name/urls.py
from django.urls import path
from app_name.views import index, test
urlpatterns = [
    path('celery-index/', index, name='celery_index_url'),
    path('celery-test/', test, name='celery_test_url'),
]

#Step 1: Install Supervisor on Ubuntu Server

~$ sudo apt-get install supervisor

#Step 2: Add .conf File in Supervisor

~$ sudo nano /etc/supervisor/conf.d/app_name.conf

app_name can be anything you like, it should be similar to your project name.

#Step 3: Add some Configure in app_name.conf

[program:your_app_name]
command=/path/to/env/bin/celery worker -A your_project_name --loglevel=INFO
directory=/path/to/workflow/your_project_name/
user=www-data
autostart=true
autorestart=true
stdout_logfile=/path/to/workflow/your_project_name/logs/celeryd.log
redirect_stderr=true

Describe the configure file:

[program:your_app_name]
#The name of your supervisord program

command=/path/to/env/bin/celery worker -A your_project_name --loglevel=INFO
#Set full path to celery program if using virtualenv

directory=/path/to/workflow/your_project_name/
#The directory to your Django project

user=www-data
#The web server has to be run under a specific user. That user must exist.

autostart=true
#If true, this program will start automatically when supervisord is started

autorestart=true
#May be one of false, unexpected, or true. If false, the process will never be autorestarted. If unexpected, the process will be restart when the program exits with an exit code that is not one of the exit codes associated with this process’ configuration (see exitcodes). If true, the process will be unconditionally restarted when it exits, without regard to its exit code.

stdout_logfile=/path/to/workflow/your_project_name/logs/celeryd.log
#Put process stdout output in this file

redirect_stderr=true
#If true, cause the process’ stderr output to be sent back to supervisord on its stdout file descriptor (in UNIX shell terms, this is the equivalent of executing /the/program 2>&1).

#Step 4: Inform Configuration to the Server

After adding a new program, we should run the following two commands, to inform the server to reread the configuration files and to apply any changes.

~$ sudo supervisorctl reread
~$ sudo supervisorctl update

#Managing Supervisor App

~$ sudo supervisorctl

You will be greeted with a list of the registered processes. You will see a process called your_app_name with a RUNNING status.

your_app_name                 RUNNING   pid 6853, uptime 0:22:30
supervisor>

Type help for a list of available commands.

supervisor> help
default commands (type help <topic>):
=====================================
add    exit      open  reload  restart   start   tail
avail  fg        pid   remove  shutdown  status  update
clear  maintail  quit  reread  signal    stop    version

In a nutshell, we can start, stop and restart programs bypassing the program name as an argument to the respective command. We can also take a look at the program output with the tail command. Once you are finished, you can quit.

~$ supervisor> quit