Django

In template settings  in options  add cached settings:

            'debug': DEBUG,
            'loaders': [
                ('django.template.loaders.cached.Loader', [
                    'django.template.loaders.filesystem.Loader',
                    'django.template.loaders.app_directories.Loader',

                ]),
            ],

import os
import datetime
from django.db import models
from django.utils.translation import ugettext as _


class Timestamped(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True


class Published(models.Model):
    is_published = models.BooleanField(default=False)

    class Meta:
        abstract = True


class Gallery(Timestamped, Published):
    name = models.CharField(max_length=100)

    class Meta:
        default_related_name = 'galleries'
        verbose_name = _('gallery')
        verbose_name_plural = _('galleries')

    def __str__(self):
        return self.name


def get_upload_path(instance, filename):
    return os.path.join('{}/{}/{}/{}/{}'.format(
        instance.gallery.name, datetime.datetime.now().day,
        datetime.datetime.now().month,
        datetime.datetime.now().year, filename))


class Image(Timestamped, Published):
    gallery = models.ForeignKey(Gallery)
    image = models.ImageField(upload_to=get_upload_path)

    class Meta:
        default_related_name = 'images'
        verbose_name = _('image')
        verbose_name_plural = _('images')

    def __str__(self):
        return self.image.name

class SlugValidator:
    def clean_slug(self):
        slug = self.cleaned_data['slug']
        existing_objects = self.Meta.model.objects.filter(slug=slug)
        if self.instance:
            existing_objects = existing_objects.exclude(
                pk=self.instance.pk)
        if existing_objects:
            raise ValidationError('The slug already exists')
        return slug

from django.apps import apps
from django.conf import settings
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType

User = get_user_model()

def set_permissions(apps=None, models=None, user=None, group=None):
    '''
    It is used to add permisions dynamically to a group.
    Then user is assigned to this group

    PROJECT_GROUP: is a string for example 'website_group'

    user: is a user instance

    apps: is a list of installed apps
    for example apps = ['catalogue', 'products']

    models: is a list of models
    for example models = ['category', 'task']


    '''
    perms = []
    group_name = group if group else settings.PROJECT_GROUP
    group, created = Group.objects.get_or_create(name=group_name)
    if user:
        group.user_set.add(user)
    if apps:
        for app in apps:
            app_models = apps.get_app_config(app).get_models()
            for model in app_models:
                content_type = ContentType.objects.get_for_model(model)
                permissions = Permission.objects.filter(
                    content_type=content_type)
                perms.append(permissions)
    if models:
        for model in self.models:
            content_type = ContentType.objects.get(model=model)
            permissions = Permission.objects.filter(
                content_type=content_type)
            perms.append(permissions)
    if group:
        for p in perms:
            group.permissions.add(*[perm for perm in p])

from django.urls import reverse

class AbsoluteUrlMixin:
    '''
    Example:
        class Category(AbsoluteUrlMixin, models.Model):
            name = models.CharField(max_length=100)

            url_name = 'update'

        I use the convention as pattern:

            app_name.model_name.detail

    '''
    def get_absolute_url(self):
        kwargs = {}
        slug = hasattr(self, 'slug')
        url_name = hasattr(self, 'url_name')
        kwargs['pk'] = self.pk
        if not url_name:
            url_name = 'detail'
        if slug:
            kwargs['slug'] = self.slug
        return reverse('{}.{}.{}'.format(self._meta.app_label,
            self.__class__.__name__.lower(), url_name), kwargs=kwargs)