A step-by-step implementation to revoke JWTs access token immediately on user logout using middleware and Redis blacklist/denylist

JWTs are difficult to revoke due to their self-contained nature. Once issued, a JWT is valid until its expiration, regardless of whether the user’s permissions have changed or the token has been compromised. This is a flaw in the stateless nature of JWT.

Imagine this?

Standard client-side logout removes tokens from the browser and redirects users to the login screen. However, the access token remains valid until its TTL(time to live) expires, creating a vulnerability where attackers could steal and use the token. I will now present an effective solution for this issue in DRF.

The Middleware + Redis Approach

To force user logout, we must revoke/invalidate the access token using a custom approach, as this cannot be done on demand. This is done by using a DB(Redis for optimal performance)to cache the access token JTI as the Redis key with the remaining expiration time as the TTL on logout, then wire up a custom middleware to check requests for cached blacklisted access token, then revoke API access accordingly.

Typical code implementation

Before we start the code implementation, ensure you have this specific simple JWT config set to ensure refresh tokens are blakclisted on token rotation. Ensure you have PyJWT and Redis installed

# JWT Configuration
SIMPLE_JWT = {
    'ROTATE_REFRESH_TOKENS': True,
    'BLACKLIST_AFTER_ROTATION': True,
   
}

The next step is to create Redis utility functions to retrieve the access token JTI, cache it, and retrieve the value.

import time
import redis
import jwt
import logging

redis_client = redis.Redis.from_url(settings.REDIS_URL, decode_responses=True)
logger = logging.getLogger(__name__)

def _token_identifier_and_exp(token: str):
    """
    Return a (redis_key, exp_timestamp) tuple.
    - Prefer token 'jti' claim if present: key = "jwt:blacklist:jti:{jti}"
    - Otherwise fall back to SHA256(token): key = "jwt:blacklist:hash:{sha256}"
    - exp_timestamp is integer POSIX seconds or 0 if unknown.
    """
    try:
        payload = jwt.decode(token, options={"verify_signature": False})
        exp = int(payload.get("exp", 0)) if payload.get("exp") else 0
        jti = payload.get("jti")
        if jti:
            key = f"jwt:blacklist:jti:{jti}"
            return key, exp

    except Exception as e:
        exp = 0
        logger.debug("Failed to decode token for metadata: %s", exc)

    h = hashlib.sha256(token.encode('utf-8')).hexdigest()
    key = f"jwt:blacklist:hash:{h}"
    return key, exp

def blacklist_token(token: str) -> int:
    """
    Add token to redis blacklist with TTL equal to (exp - now) if exp exists,
    otherwise use JWT_BLACKLIST_DEFAULT_TTL.
    Returns TTL set (in seconds).
    """
    key, exp = _token_identifier_and_exp(token)
    now = int(time.time())
    if exp and exp > now:
        ttl = exp - now

    try:
        redis_client.setex(key, ttl, "blacklisted")
        logger.info("Blacklisted token key=%s ttl=%s", key, ttl)
    except Exception as exc:
        logger.exception("Failed to blacklist token in Redis: %s", exc)
        raise
    return ttl

def is_token_blacklisted(token: str) -> bool:
    key, _ = _token_identifier_and_exp(token)
    try:
        exists = redis_client.exists(key) == 1
        logger.info("Checked blacklist for key=%s exists=%s", key, exists)
        return exists
    except Exception as exc:
        logger.exception("Redis error while checking blacklist: %s", exc)
        return False

Force user logout

Next, use the utility functions to blacklist the access token on demand when a user logs out.

class CustomLogoutView(APIView):
    """Enhanced logout view"""
    permission_classes = [permissions.IsAuthenticated]
    authentication_classes = [JWTAuthentication]

    def post(self, request, *args, **kwargs):
        errors = []

        refresh_token = request.data.get('refresh')

        if refresh_token:
            try:
                token = RefreshToken(refresh_token)
                token.blacklist()
                logger.info("Refresh token blacklisted via SimpleJWT for user=%s", request.user.email)
            except TokenError as e:
                errors.append(f"Refresh token error: {str(e)}")
                logger.error("Refresh token error for user=%s: %s", request.user.email, str(e))

            auth = request.META.get("HTTP_AUTHORIZATION", "")
            if auth and auth.split()[0].lower() == "bearer":
                access_token = auth.split()[1].strip()
                try:
                    blacklist_token(access_token)
                    logger.info("Access token blacklisted ttl=%s for user=%s", ttl, request.user.email)
                except Exception as exc:
                    logger.exception("Failed to blacklist access token: %s", exc)
                    errors.append("Failed to blacklist access token")
        else:
            errors.append("No refresh token provided in payload or cookie")
            logger.warning("No refresh token found for user=%s", request.user.email)


        if errors:
            return Response(
                {"success": False,
                 "message": "Logout completed with errors.",
                 "errors": errors
                 },status=status.HTTP_400_BAD_REQUEST
            )

        response = Response(
            {'success': True, 'message': 'Logout successful.'},
            status=status.HTTP_200_OK
        )

        logger.info(f"User logged out: {request.user.email}")

        return response

The logout view invalidates user sessions by blacklisting refresh and access tokens from a POST request. It uses SimpleJWT to blacklist the refresh token, then blacklists the access token using the Redis custom functions. Invalid/missing tokens are handled, and the user is logged out.

Adding the Middleware

Middleware is added to prevent further requests from being processed if a token has been blacklisted.

import logging
from django.utils.deprecation import MiddlewareMixin
import time
from apps.users.utils import is_token_blacklisted

class RedisJWTBlacklistMiddleware(MiddlewareMixin):
    """
    Reject requests with a blacklisted JWT (Bearer token).
    Place this middleware early so blocked tokens are rejected before hitting views.
    """
    def process_request(self, request):
        auth = request.META.get("HTTP_AUTHORIZATION", "")
        if not auth:
            return None

        parts = auth.split()
        if len(parts) != 2 or parts[0].lower() != "bearer":
            logger.debug("Authorization header not Bearer")
            return None

        token = parts[1].strip()
        try:
            if is_token_blacklisted(token):
                logger.info("Rejected request with blacklisted token")
                return JsonResponse({"detail": "Token has been revoked."}, status=401)
        except Exception:
            return None

        return None

Conclusion

Creating a clean log-out flow with JSON Web Tokens presents challenges. I chose this approach, which I believe is the most optimal. Let me know your thoughts in the comments.

Revoke JWTs, Secure Your API — Middleware + Redis in DRF was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

We both know why you clicked this article cause it’s either you don’t know how to send an email newsletter from within your application or you’re not doing it in the most efficient way possible. That’s where I come in😉. Here’s a step-by-step guide for 🫵. Enjoy🫡

Before you dive in just a heads up that this isn’t a beginner-level tutorial, prior knowledge of Django is required! Cheers🍻

So first we create and activate our virtual environment

benji@BENJAMIN:~/email_newsletter$ virtualenv venv
benji@BENJAMIN:~/email_newsletter$ source venv/bin/activate
(venv) benji@BENJAMIN:~/email_newsletter$

Then we move over to installing and freezing our project dependencies e.g django, djangorestframewrok, drf-spectacular, etc and creating our Django project and core Django application

(venv) benji@BENJAMIN:~/email_newsletter$ pip install django drf-spectacular djangorestframework, djangorestframework-simplejwt celery redis django-celery-beat django-environ flower
(venv) benji@BENJAMIN:~/email_newsletter$ pip freeze > requirements.txt
(venv) benji@BENJAMIN:~/email_newsletter$ django-admin startproject core
(venv) benji@BENJAMIN:~/email_newsletter$ django-admin startproject email_newsletter
(venv) benji@BENJAMIN:~/email_newsletter$ django-admin startapp core
(venv) benji@BENJAMIN:~/email_newsletter$ django-admin startapp users

Time to add your Django apps and third-party packages to our project

Paste in all these necessary configurations at the bottom of the settings.py
These contain the rest framework, Djoser, drf-spectacular, JWT, Celery, and Redis settings.

### MY SETTINGS ###
DJOSER = {
    'SERIALIZERS': {
        'user_create': 'users.serializers.UserCreateSerializer',
        'current_user': 'users.serializers.CurrentUserSerializer',
    }
}


# REST FRAMEWORK SETTINGS
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ),
    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',  # drf-spectacular settings
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser',
    ],
}

SIMPLE_JWT = {
    'AUTH_HEADER_TYPES': ('JWT',),
    "ACCESS_TOKEN_LIFETIME": timedelta(days=1),
    "REFRESH_TOKEN_LIFETIME": timedelta(days=2),
}



# API Docs settings
SPECTACULAR_SETTINGS = {
    'TITLE': 'Email Newsletter App API',
    'DESCRIPTION': 'Email Newsletter App project API Documents',
    'VERSION': '1.0.0',
    'SCHEMA_PATH_PREFIX': '/backend/api/*',
    # 'SERVE_PERMISSIONS': ['rest_framework.permissions.IsAuthenticated'],
    'DISABLE_ERRORS_AND_WARNINGS': True,
    'COMPONENT_SPLIT_REQUEST': True
}

BASE_BACKEND_URL = "http://localhost:8000"


# Celery settings
CELERY_BROKER_URL = 'redis://127.0.0.1:6379/0'
CELERY_ACCEPT_CONTENT=['application/json']
CELERY_RESULT_SERIALIZER='json'
CELERY_TASK_SERIALIZER='json'
CELERY_TIMEZONE='Africa/Lagos'
CELERY_RESULT_BACKEND = 'django-db'
CELERY_TASK_TRACK_STARTED = True
CELERY_BROKER_CONNECTION_RETRY_ON_STARTUP = True

# Celery beat settings
CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers:DatabaseScheduler'

Copy this code into the project’s/ __init__.py file

from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app


__all__ = ('celery_app',)

This code snippet ensures that the Celery app is always imported when Django starts. By importing the Celery instance (app) from your Celery configuration file and including it in __all__, it makes celery_app available for other modules in your project, allowing them to recognize and use the Celery app.

Again, in the project’s folder create a celery.py file

Paste the following code into the file

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'email_newsletter.settings')

app = Celery('email_newsletter')

app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

• Importing necessary modules: It ensures compatibility and imports the needed modules.
• Setting default Django settings: os.environ.setdefault specifies your Django settings module (email_newsletter.settings).
• Creating a Celery app instance: app = Celery('email_newsletter') creates a Celery application instance named email_newsletter.
• Loading Celery settings: app.config_from_object loads Celery settings from Django's settings file using the CELERY namespace.
• Discovering tasks: app.autodiscover_tasks() automatically finds tasks defined in your Django apps.

Now we run the migrations command to add the celery tables to our database and to test that there are no errors in our configurations before we run the server.

Our Django server is up and running. Now the easy part is done — time to dockerize our application.

Buh, wait we still don’t know what the heck Celery, Celery beat, and Flower is right? Let’s break it down for you.

Celery is a task manager. Think of it like a personal assistant for your app — it handles tasks in the background so your app doesn’t get stuck doing boring, time-consuming things (like sending emails or processing data). Your app can keep doing its cool stuff while Celery takes care of the heavy lifting in the background.

Now, Celery Beat is like a scheduler for Celery. If you want something done repeatedly — like sending out email newsletters every morning at 9 AM — Celery Beat makes that happen. It tells Celery, “Hey, do this task at this time.”

And Flower? It’s the dashboard where you can see all of Celery’s hard work. It’s like the control center where you monitor the tasks that Celery is doing. You can check if tasks are running fine, or if something’s stuck.

They’re all connected because Celery does the actual work, Celery Beat schedules recurring work, and Flower lets you see the work being done in real time. It’s like having a well-oiled machine working in the background, and Flower is your window to watch it all happen

Let’s take a few moments and talk about the elephant in the room Docker and Docker compose and how they are interconnected🤔

Docker is like your go-to box for packaging up your app and all its stuff — dependencies, code, and all — so it runs the same way no matter where you launch it. But what if your app needs a bunch of these boxes, like one for the app itself, one for the database, and maybe another for some background worker? Docker Compose. It’s like the project manager coordinating all these Docker boxes, ensuring they work together smoothly. Instead of launching each box manually, you give Docker Compose the game plan, and it handles the rest, spinning up your whole setup with a single command.

So, Docker is the box, and Docker Compose is the brains behind it all. Easy peasy! Back to the tutorial🙂

Create a .dockerignore and Dockerfile in the root directory of our project
A .dockerignore file is used to specify which files and directories should be ignored by Docker when building an image. It works similarly to a .gitignore file in Git.

Paste this code in the .dockerignore file

.env
venv/
Dockerfile
migrations/
__pycache__/
db.sqlite3
.DS_Store

Paste the following code inside the Dockerfile

# Use an official Python runtime as a parent image
FROM python:3.10-slim

# Set environment variables
ENV PYTHONUNBUFFERED=1

# Set the working directory in the container
WORKDIR /app

# Install dependencies
RUN apt-get update && apt-get install -y \
    python3-venv \
    linux-headers-amd64 \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Create a virtual environment
RUN python3 -m venv /opt/venv

# Activate the virtual environment
ENV PATH="/opt/venv/bin:$PATH"

# Copy the requirements file into the container
COPY requirements.txt .

# Install the dependencies
RUN pip install --upgrade pip && pip install -r requirements.txt

# Copy the current directory contents into the container at /app
COPY . .

# Expose port 8000 for the Django application
EXPOSE 8000

# Run the Django application
CMD ["sh", "-c", "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"]

• Base Image: You’re starting with an official slim version of Python 3.10 (python:3.10-slim). This is like saying, "Hey, give me a lightweight Python environment to build my stuff on."
• Environment Variable: ENV PYTHONUNBUFFERED=1 ensures that your Python output gets printed directly to the console, which is helpful when debugging.
• Working Directory: WORKDIR /app is where you’re telling Docker, "Hey, all the magic happens here," so everything else you do from now on is relative to this directory.
• Install Dependencies: You’re installing a few necessary packages with apt-get to set up the environment for Python. Think of it as prepping the kitchen with the right tools before you start cooking.
• Virtual Environment: You’re creating a Python virtual environment (python3 -m venv /opt/venv) to keep your project’s dependencies isolated. It’s like having a sandbox where your project can play without messing with other projects.
• Activate the Virtual Environment: ENV PATH="/opt/venv/bin:$PATH" makes sure that any Python commands run within this virtual environment, so you’re using the isolated dependencies you just set up.
• Copying Requirements: COPY requirements.txt . brings in your requirements.txt file into the container, which lists all the Python packages your project needs.
• Install Python Packages: RUN pip install --upgrade pip && pip install -r requirements.txt upgrades pip (Python’s package installer) and installs all the packages listed in requirements.txt. It’s like grabbing all the ingredients you need for your recipe.
• Copy Project Files: COPY . . moves everything from your current directory into the container’s working directory (/app). You’re putting all your code into the container.
• Expose Port: EXPOSE 8000 makes port 8000 available to the outside world. This is where your Django app will be accessible from.
• Run the App: Finally, the CMD command runs your Django app by applying any migrations (updates to the database) and starting the development server so you can see it live.

Now ensure you have Docker desktop installed on your machine to build our docker image. Download Docker desktop. Instructions on how to install it and get it working on your machine 👉Link

Run the command below in the terminal. This builds our created dockerfile for our Django application.

benji@BENJAMIN:~/email_newsletter$ docker build .                                                          8.3

Ensure that the Docker build stage reaches this point. This indicates that the build was successful and the image has been created.

Next, create a docker-compose.yml file in the same directory as that of the Dockerfile and paste the code below into the file.

services:
  web:
    image: email_newsletter
    container_name: email_newsletter
    build: .
    ports:
      - 8000:8000
    volumes:
      - ./:/app
    command: >
      sh -c "python manage.py migrate &&
             python manage.py runserver 0.0.0.0:8000"
    
    depends_on:
      - postgres-db
      - redis

  postgres-db:
    image: postgres:latest
    container_name: my-postgres-container
    restart: always
    environment:
      POSTGRES_PASSWORD: examplepassword
      POSTGRES_USER: exampleuser
      POSTGRES_DB: exampledb
    volumes:
      - postgres_db_data:/var/lib/postgresql/data


  redis:
    image: redis:alpine
    container_name: my-redis-container
    restart: always
  
  celery:
    build: .
    container_name: my-celery-container
    volumes:
      - ./:/app
    command: >
      sh -c "celery -A email_newsletter.celery worker -l info" 
    depends_on:
      - redis
      - web

  flower:
    build: .
    container_name: my-flower-container
    command: celery -A email_newsletter flower --basic_auth=admin:password123
    volumes:
      - ./:/app
    ports:
      - "5555:5555"
    depends_on:
      - redis

  beat:
    build: .
    container_name: my-beat-container
    command: celery -A email_newsletter beat -l INFO --scheduler django_celery_beat.schedulers:DatabaseScheduler
    volumes:
      - .:/app
    depends_on:
      - redis
      - web


volumes:
  postgres_db_data:

1. Web Service (web)

• Image & Name: Runs the main app (email_newsletter) in a container.
• Ports: Maps port 8000 on your computer to port 8000 inside the container.
• Volumes: Links the current directory (./) to the /app directory inside the container, so any changes you make locally are reflected in the container.
• Command: Runs Django database migrations and starts the web server.
• Depends on: Ensures that postgres-db and redis services start first.

2. Postgres Service (postgres-db)

• Image & Name: Runs a Postgres database in a container.
• Environment: Sets the database name, user, and password.
• Volumes: Stores Postgres data in a Docker-managed volume (postgres_db_data), so it persists even if the container is stopped.

3. Redis Service (redis)

• Image & Name: Runs a Redis instance (used as a message broker for Celery tasks).
• Restart: Always restart the container if it stops for any reason.

4. Celery Service (celery)

• Command: Starts a Celery worker, handling background tasks (like sending emails).
• Depends on: Waits for redis and web services to start first.

5. Flower Service (flower)

• Command: Starts Flower, a web-based monitoring tool for Celery tasks, and sets a password to login to the dashboard
• Ports: Exposes Flower on port 5555.
• Depends on: Starts after redis.

6. Beat Service (beat)

• Command: Starts Celery Beat, which schedules periodic tasks (like sending email newsletters at set intervals).
• Depends on: Waits for redis and web to start first.

7. Volumes (volumes)

• Postgres Data: Defines a volume for storing the Postgres database data, so it doesn’t get lost when the container is stopped.

Run the command in the terminal docker compose up --build This command starts up all the container services as seen below

Head over to localhost:5555 to view the flower dashboard😁. A popup window will require you to input the configured username(admin) and password(password123).

So at this point, all our container services should be up and running. If you encounter any errors I’d be happy to address them in the comments section😁. Let’s move over to configuring the Django project’s app data models, views, serializers, and async celery tasks.

Create a python file called manager.py in the core app folder and paste in the code below

from django.contrib.auth.base_user import BaseUserManager
from django.utils.translation import gettext as _


class CustomUserManager(BaseUserManager):
    """
    Custom user model manager where email is the unique identifier
    for authentication instead of usernames.
    """

    def create_user(self, email, password, **extra_fields):
        if not email:
            raise ValueError(_('Users must have an email address'))
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save()
        return user

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)
        extra_fields.setdefault('is_admin', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError(_('Superuser must have is_staff=True.'))
        if extra_fields.get('is_superuser') is not True:
            raise ValueError(_('Superuser must have is_superuser=True.'))
        return self.create_user(email, password, **extra_fields)

This code defines a custom manager for user accounts where email is used as the login instead of a username.

In the CustomUserManager class:

• create_user: This method creates a regular user. It checks if an email is provided, then normalizes the email, sets the password, and saves the user.
• create_superuser: This method creates a superuser (admin). It ensures that certain fields like is_staff, is_superuser, and is_admin are set to True. If not, it throws an error.

Next, in the models.pyfile. Paste the code below

from django.db import models
from django.contrib.auth.models import AbstractUser
from .manager import CustomUserManager

# Create your models here.
class CustomUser(AbstractUser):
    GENDER_CHOICES = [
        ('male', 'Male'),
        ('female', 'Female'),
    ]
    username = models.CharField(unique=True, max_length=50, blank=False, null=False)
    email = models.EmailField(unique=True, blank=False, null=False)
    gender = models.CharField(max_length=10, choices=GENDER_CHOICES, null=False, blank=False)
    is_admin = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)
    newsletter_subscribed = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['username']

    def __str__(self):
        return self.username

class MessageBoard(models.Model):
    subscribers = models.ManyToManyField(CustomUser, related_name='messageboard', blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return str(self.id)

Now let’s make a slight change to our settings.py file

This means that the default user model for a Django project is the CustomUser model

Configure the project urls.py file for Swagger and Djoser endpoints

from django.contrib import admin
from django.urls import path, include
from drf_spectacular.views import (
    SpectacularAPIView,
    SpectacularSwaggerView,
    SpectacularRedocView,
)

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/schema/', SpectacularAPIView.as_view(), name='schema'),
    path('api/v1/schema/swagger/', SpectacularSwaggerView.as_view(), name='swagger-ui'),
    path('api/v1/schema/redoc/', SpectacularRedocView.as_view(url_name='schema'), name='redoc'),


    # AUTHENTICATION API ENDPOINTS
    path('auth/v1/', include('djoser.urls')),
    path('jwt/v1/', include('djoser.urls.jwt')),
]

Testing the swagger endpoint and it works as expected. I know I’m too good😎🔥

In the users app folder, create a new file named serializers.py. Paste the code below into the file.

from djoser.serializers import UserSerializer, UserCreateSerializer as BaseUserSerializer
from django.core.exceptions import ValidationError


class UserCreateSerializer(BaseUserSerializer):
    class Meta(BaseUserSerializer.Meta):
        fields = ['id', 'email', 'gender', 'username', 'password']



class CurrentUserSerializer(UserSerializer):
    class Meta(UserSerializer.Meta):
        fields = ['id', 'email', 'username']

This code customizes two serializers using the Djoser library, commonly used for user authentication in Django projects.

1. UserCreateSerializer: This serializer handles user creation. It adds extra fields like gender, email, username, and password when a user is being created.
2. CurrentUserSerializer: This serializer manages data for the currently logged-in user, including their id, email, and username.

In simple terms, these serializers define how user data is formatted and handled when creating a new account or viewing the current user’s info.

Still in the users folder, create a signals.py file. This file will automatically create message board instances using Django signals and assign newly created users to the specified message board.

from django.db.models.signals import post_save
from django.dispatch import receiver
from core.models import CustomUser, MessageBoard

@receiver(post_save, sender=CustomUser)
def add_user_to_message_board(sender, instance, created, **kwargs):
    if created:
        # Automatically create a MessageBoard instance if none exists
        message_board, created = MessageBoard.objects.get_or_create(id=1)
        
        # Add the user to the message board subscribers if they subscribe to the newsletter
        if instance.newsletter_subscribed:
            message_board.subscribers.add(instance)
            message_board.save()

Testing the user creation endpoint auth/v1/users/ 👇

Response👇

Now, in the users app folder create a new Python file named tasks.py. Paste the code below into the file.

from celery import shared_task
from core.models import MessageBoard
from django.conf import settings
from datetime import datetime
from django.template.loader import get_template
from django.core.mail import EmailMessage

@shared_task(name='email_newsletter')
def send_newsletter():
    subject = "Your Monthly Newsletter"
    
    subscribers = MessageBoard.objects.get(id=1).subscribers.filter(
        newsletter_subscribed=True,
    )
    
    for subscriber in subscribers:
        print(subscriber.email)
        message = get_template('newsletter.html').render(context={'name': subscriber.username})
        mail = EmailMessage(
            subject=subject, 
            body=message, 
            from_email=settings.EMAIL_HOST_USER,
            to=[subscriber.email],
            reply_to=[settings.EMAIL_HOST_USER],
            )
        mail.content_subtype = "html"
        mail.send()
    
    current_month = datetime.now().strftime('%B')
    subscriber_count = subscribers.count()   
    return f'{current_month} Newsletter to {subscriber_count} subs'

• Task Definition: The @shared_task decorator makes this a background task that can run asynchronously, meaning it won’t slow down your app.
• Fetching Subscribers: It grabs all users from a message board who are subscribed to the newsletter.
• Sending Emails: For each subscriber, it renders an HTML email template (newsletter.html) with the subscriber's name and sends the email
• Return Statement: After sending the emails, it returns a message indicating how many newsletters were sent that month.

You can now stop your docker containers using the command docker compose down and spin it up again using the command docker compose up
This is to ensure that we configured the task properly and Celery is picking it up too.

Create a templates folder in the root directory of the project and use any newsletter HTML template of your choice. Link to mine 👉 Download link

Configure the settings.py file to find your template directory

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Let’s configure our project settings to send emails to our subscribers. First install django-environ to read the environment variables for email config.

Next, import the paste the code below the initial imports in the settings.py file

import environ

env = environ.Env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Take environment variables from .env file
environ.Env.read_env(os.path.join(BASE_DIR, '.env'))

The code just tells Django where to find the .env file in our application which is in the root directory of the project

# EMAIL SETTINGS
EMAIL_HOST_USER = env('SENDER_EMAIL')
EMAIL_HOST_PASSWORD = env('SENDER_EMAIL_PASSWORD')
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.gmail.com' 
EMAIL_PORT = 465 
EMAIL_USE_TLS = False  
EMAIL_USE_SSL = True

Now create .env file in the root directory of the Django project

SENDER_EMAIL=<your-email-address>
SENDER_EMAIL_PASSWORD=<your-email-address-app-password>

Tutorial on how to generate your app passwords 👉Link

It’s time to configure the schedule for our celery beat newsletter task

At the bottom of the settings.py file add the code below.

CELERY_BEAT_SCHEDULE = {
    'send_newsletter': {
        'task': 'email_newsletter',  # Path to your Celery task
        'schedule': crontab(hours=0, minute="*/1"), # Change to match your specification
    },
}

You can use the crontab schedule to specify a wide range of periodic tasks:

• Every minute: crontab(minute='*/1')
• Every hour: crontab(minute=0)
• Specific days of the week (e.g., every Monday): crontab(minute='*/1', hour=0, day_of_week='monday') etc
• More complex schedules: See the Celery beat documentation for more crontab options.

You can change the crontab shecdule to suit your needs e.g(first of every month by 12:00AM)👇

CELERY_BEAT_SCHEDULE = {
    'send_newsletter': {
        'task': 'email_newsletter', 
        'schedule': crontab(hours=0, minute=0, day_of_week=1), 
    },
}

I won’t forget the necessary import at the top of the settings.py file😅

from celery.schedules import crontab

All that’s left to do is test our celery & celery beat configs now

Running the command docker compose down then docker compse up to refresh your containers

Lets’s check the celery and celery beat container to see it our task is being executed

As seen above the tasks are being executed every minute as seen on the container logs

Going over to Flower’s task monitoring system, we can see the task execution details below👇

Clicking into one of the tasks I get a more in-deapth detail on its excecution

Email newsletter in my inbox🥳🥳🥳🙌🙌🙌🙌

As simple as that you can send email newsletters from your application to your customers. Easy-peasy😉

Link to project Github repo 👉Link

Psst, have I got a sweet deal for 🫵🏽. Want to take your Django app to the next level?🫰🏽🔥. Check out this awesome tutorial on Deploy a Dockerized Django App on AWS EC2 with RDS, S3, Gunicorn, Nginx, and GitHub Actions CI/CD. The best part? You’ll get hands-on experience and a smoother deployment process. But wait, there’s more — use my coupon code BENEARLYEC2 to get 50% off! Happy coding!😊👋🏽

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: CoFeed | Differ
• More content at PlainEnglish.io

Unlock Async Email Magic with Docker-compose, Celery, Flower & Redis in Django Rest Framework(DRF) was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

DevOps! DevOps! DevOps! We’ve all heard of it countless times. But as a backend developer, that word echoes in my mind whenever I’m watching a coding video, taking a course, or reading an article. The buzz around Docker and Kubernetes in the tech world got me all fired up, so I decided to dive in and see what the fuss was all about!🤷🏽‍♂️

I got hooked on DevOps because I realized I needed to work smarter, especially with deployments. Docker kept popping up everywhere—at meetups, on tech blogs, and from my colleagues. So, I decided to dive in and bought a course on Udemy. Learning about containers, images, volumes, bind mounts, and container networking was like learning a new language!😵‍💫. Setting up Docker on my local machine during the initial stage was a nightmare. It’s like when you’re following a coding tutorial and suddenly everything goes haywire with a bunch of errors. So frustrating, right? Anyway, back to the story.

Man, setting up Docker desktop was a nightmare! I just wanted to learn Docker, but instead, I got to deal with a bunch of f**king🤬 error messages that made no sense to me. You know that moment in a coding tutorial when everything goes to hell and you’re suddenly drowning in terminal errors? Yep, that was me😣. It took me a whole two weeks to figure it all out. I was Googling, trying things out, and entering weird commands in my terminal left and right. I was so close to giving up. It’s kinda funny, right? It’s not at all🙂. But hey, after all that struggle, I finally made it to the home screen of Docker desktop. What a relief! 😮‍💨

After moving past the initial stage of docker — learning the Docker CLI commands and their purposes, creating, pulling, and stopping containers. I got the hang of it, Docker and I were inseparable. Within a week, I was spinning up containers like a pro😎. Seeing "Hello World" in my terminal felt like magic. It felt like a small step for man and a giant leap for humanity kinda vibe🤣. The power of Docker was undeniable. Gone were the days of "it works on my machine" excuses😂🫵. I even started experimenting with Docker Compose, orchestrating multi-container applications with ease. Though compose came with its hassles, luckily it was mostly just syntax errors because I had to accustom myself to the yaml formatting 😅.

As my projects grew so did my demands. I needed something more robust. I needed an orchestration tool. Based on the course I was following they listed two Docker Swarm and Kubernetes. The instructor started by teaching docker swarm first then Kubernetes. At the back of my mind, I thought since docker wasn’t that hard to grasp I could blow past the docker swarm section like a breeze 😌. I was wrong 😫. Docker swarm section had a total of 12 videos. The first 3 videos were easy stuff, I could totally relate docker swarm CLI commands to the original docker CLI commands learned previously 👍🏽. Now I have a total of 9 more videos to watch and guess what!. I skipped all of them. Why?. Because I didn’t understand sh*t😑. I felt so stupid thinking it would be so easy, it took a heavy blow at my confidence💔.

Moving on, after taking the heavy blow from docker swarm I mustered the courage to move over to its big brother Kubernetes. The first time I looked at Kubernetes documentation, it felt like a maze. Pods, nodes, clusters, services, resource types, deployments😵‍💫... it was overwhelming. The learning curve was steep, and I felt like I was back to square one 😭.

The challenges hit hard. There were days I wanted to pull my hair out, especially when debugging obscure errors and the docs didn’t help much honestly. ChatGPT was my debugging partner through all this. Kubernetes introduced a whole lot of new complexities, and the learning curve remained steep. There were moments of doubt where I regretted my decision to dive into DevOps 😮‍💨

Yet, I persisted, I mean I was neck deep into it already so there was no point turning back now🤷🏽‍♂️. After spending countless of tinkering and troubleshooting, I managed to deploy my first application on a Kubernetes cluster. Seeing my app running on multiple nodes and being able to scale it up and down with replica sets seamlessly was both a relief and a triumph🙌🏽🙌🏽🙌🏽

Now from the article title you can see why I went with that. DevOps is both a blessing and a curse. The frustration is real but so are the rewards. For individuals looking to delve into DevOps. Do it! The journey is worth it. All these are hurdles you are bound to meet while learning. So putting off learning it for later as a backend developer is only gonna come back and bite 🫵🏽😂

Psst, have I got a sweet deal for 🫵🏽. Want to take your Django app to the next level?🫰🏽🔥. Check out this awesome tutorial on How to deploy your Django app on DigitalOcean Droplet and set up a CI/CD pipeline with GitHub Actions. The best part? You’ll get hands-on experience and a smoother deployment process. But wait, there’s more — use my affiliate link, and you get 50% off! Happy coding!😊👋🏽

Upon signing out from our academic institutions and bidding farewell to my colleagues, many of us found ourselves thrown into the vast ocean of post-graduation life. In this article, I will recount my journey as I navigated through the highs and lows that came after my graduation.👨🏼‍🎓

Before I share my personal experiences, let me introduce myself. I am a 21-year-old solo entrepreneur who aspires to become a renowned backend developer in the tech industry👨🏼‍💻. I started my tech career at the age of 19, and it has been an incredible journey since then. From finding the right path to facing moments of doubt, I am proud of how far I’ve come🥹. Now, let’s move on to what’s next...

After bidding farewell to the confines of academia, I experienced a blend of excitement and uncertainty. I shared my achievements with my long-time classmates and friends. However, deep down, I felt apprehensive about what lay ahead. I mean, who wouldn’t?🤷🏼‍♂️ The prospect of departing from the protective bubble of school and venturing into the real world was daunting and sent shivers down my spine😬.

The first few months after my graduation were full of enthusiasm and determination to excel in my career💪🏼. However, as time passed, my job search became a frustrating experience with endless applications and rejection emails🙍🏼‍♂️. Each rejection took a toll on my confidence, and it became difficult for me to maintain a positive outlook😭.

To change my approach, I decided to focus on freelancing on Upwork. I optimized my profile and portfolio, watched multiple YouTube videos from experts on crafting a good profile and writing proposals, and searched for the right jobs. Despite all my efforts, my proposal was only viewed twice out of the multiple proposals I sent, and I wasn’t able to secure any job. Although it was progress, it was still a bit depressing😞.

After spending weeks sending job applications and scouring online job boards, I finally landed a gig thanks to one of the tech group chats I’m in🙌🏼. The job was a simple technical writing task - I had to add extra sections to a Django Rest framework tutorial. The pay wasn’t amazing, but it was enough to provide some relief from the draining job application process and give me something else to channel my energy into. Unfortunately, this sense of relief turned out to be temporary💔.

For almost a month now, I have been actively searching for a remote tech job, as well as working on my coding side projects, completing my tech courses, and writing technical articles. Although this might seem like a lot to handle, it wasn’t the physical stress that got to me, but the mental exhaustion😮‍💨. I found myself losing interest in anything related to coding or technical writing and was unable to focus on anything. As a result, I decided to take a break from everything for three weeks😫. During this time, I binge-watched numerous TV series and anime that I had been putting off for a while, such as Good Doctor, Halo, Shogun, Invincible, Shadow and Bones, and Dune. I did everything in my power to distract myself. My father noticed that I wasn’t coding as much as I used to, but I didn’t explain why he probably wouldn’t have understood what I was going through.

During the three-week break, I spent a lot of time reflecting on why I started my tech journey. Although money is one of my driving forces, it wasn’t the reason I got into tech. I simply adore the process of using lines of code to solve real-world problems❤️. I knew it wouldn’t be easy, but that didn’t deter me💪🏼. One thing that added to my mental stress was the pressure to get a “lucky break” right after school. I’ve heard countless stories of people achieving groundbreaking success after school, and I wanted to be one of them. I pushed myself to the limit, but I guess I lost sight of why I started this journey in the first place. Adding to this, I believe not everyone will get that “lucky break" right after school. Success comes in various forms, and sometimes it takes time to find your place in your desired industry. Stay true to your passion and keep nurturing that love for the craft. Everyone’s journey is unique, and it’s okay if yours unfolds differently from what you initially envisioned. Keep moving forward, one step at a time, and trust that your efforts will lead you to where you’re meant to be🫂.

As I reflect on the rollercoaster of emotions and experiences recounted in this journey, one truth stands out amidst the highs and lows: perseverance in the face of adversity is the cornerstone of personal growth📈. The transition from academia to the professional world is rarely a smooth ride; it’s a tumultuous voyage filled with uncertainty, doubt, and occasional setbacks. Yet, it’s precisely within these moments of struggle that our character is forged, and our resilience tested. It’s easy to feel disheartened when faced with rejection and uncertainty, but it’s in those moments of darkness that we discover our true strength. This journey isn’t just about finding a job or achieving success; it’s about discovering ourselves, our passions, and our purpose. So, to all those navigating the waves of post-graduation life, remember this: your journey may not unfold as planned, but trust in your abilities, stay true to your passions, and keep moving forward with unwavering determination. For it’s in the journey itself that we find the true beauty of life, amidst all its ups and downs🫵🏼.

If you’ve had issues sending emails asynchronously in Django, you're not alone. Many newbie developers rely on synchronously sending their Django emails. The result is just a horrible experience not just for the developers, but for the users too!!!

The consequences?

• Increased server load
• Reduced scalability
• Longer response times
• Poor user experience
• Risk of Email Throttling

The list goes on and on….😫

I came across a pretty neat package called Celery. If configured and used correctly it could solve these problems instantly and without any hassle😅. In the coming sections, we’ll see how Celery enables asynchronous task execution, allowing email sending to be offloaded to background workers. Cheers🥂

What is Celery?💁‍♂️

Simply put, Celery is a powerful tool used in development to handle background tasks asynchronously. Imagine you’re running a website, and certain tasks need to be performed but don’t need to be done immediately as part of the regular request-response cycle. These tasks could include sending emails, processing large datasets, or performing periodic maintenance tasks.

Celery allows you to offload these tasks to a separate process, known as a “worker,” which runs independently of your main application. This means that when a user triggers an action that requires one of these background tasks, your application can quickly respond without waiting for the task to be completed. The task is then sent to the Celery worker to be executed in the background, freeing up your application to handle other requests.

What is a Message Broker?🤔

Think of a message broker as a postal service. When you want to send a letter to someone, you drop it off at the post office. The post office then sorts and delivers the letter to its destination. Similarly, in a Celery setup, when your application needs to execute a background task, it sends a message (task) to the message broker. The message broker receives the task and ensures that it is delivered to an available Celery worker for processing.

Now, let’s relate this to Redis, which is a popular message broker often used with Celery. Redis is like a highly efficient and reliable post office. When your application sends a task to Redis, Redis stores the task in a queue. Celery workers continuously monitor this queue for new tasks. When a worker becomes available, it retrieves a task from the queue and executes it.

So by definition, a message broker is a key component in distributed systems that facilitates communication between different parts of the system by enabling the exchange of messages. In the context of Celery, a message broker acts as a middleman between the Celery application and its workers, allowing tasks to be distributed and executed asynchronously.

Project Setup

Before we start I just want to indicate that you need to have prior knowledge of Django and its inner workings before diving into Celery and Redis. This tutorial won’t cover the basics of Django eg (creating virtual environments, projects, and apps).🙂

You can download the project code here to follow along 👉link

First, we install Redis. Here’s a link to an installation guide 👉link

Requirements

• pip install django
• pip install celery
• pip install redis
• pip install django-celery-results

django-celery-results is an extension for Django and Celery that provides support for storing Celery task results in the Django database. When Celery tasks are executed asynchronously, they often produce results that may need to be stored and accessed later. django-celery-results integrates Celery with Django’s ORM (Object-Relational Mapping) to allow task results to be saved directly to the database.

In addition, django-celery-results provides an easy way to view and manage the results of our tasks in the Django admin panel.

Configuration

• Add the django-celery-results to the INSTALLED_APPS

# settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

     # third party apps
    'rest_framework',
    'rest_framework_simplejwt',
    'djoser',
    'drf_spectacular',
    'django_filters',
    'django_celery_beat',
    'django_celery_results',

    # local apps
    'core',
    'users',
    'google_login',
]

• Celery Settings

# settings.py

# CELERY SETTINGS
CELERY_BROKER_URL = 'redis://127.0.0.1:6379/0'
CELERY_ACCEPT_CONTENT=['application/json']
CELERY_RESULT_SERIALIZER='json'
CELERY_TASK_SERIALIZER='json'
CELERY_TIMEZONE='Africa/Lagos'
CELERY_RESULT_BACKEND = 'django-db'

1. CELERY_BROKER_URL: Specifies the URL of the message broker that Celery will use to send and receive messages. In this case, it’s set to Redis, which is running on the local machine (127.0.0.1) on port 6379, and uses a database 0.
2. CELERY_ACCEPT_CONTENT: Defines the content types that Celery will accept. Here, it’s set to accept JSON-formatted messages.
3. CELERY_RESULT_SERIALIZER: Specifies the serialization format for task results. It’s set to JSON, meaning task results will be serialized in JSON format.
4. CELERY_TASK_SERIALIZER: Defines the serialization format for task arguments and return values. It’s also set to JSON for consistency with task results.
5. CELERY_TIMEZONE: Sets the timezone used by Celery for scheduling tasks. In this case, it’s set to 'Africa/Lagos', it represents the timezone for Lagos, Nigeria.
6. CELERY_RESULT_BACKEND: Specifies the backend for storing task results. Here, it’s configured to use the Django database (django-db), meaning task results will be stored in the Django database.

• In the Django project directory, create a new file called celery.py

# Django_project/celery.py

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery
from django.conf import settings

# Set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'atsuko_clone.settings')

app = Celery('atsuko_clone')  # Replace 'your_project' with your project's name.

# Configure Celery using settings from Django settings.py.
app.config_from_object('django.conf:settings', namespace='CELERY')

# Celery beat settings
app.conf.beat_schedule = {}

# Load tasks from all registered Django app configs.
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)



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

• In the same directory, paste the code below in the __init__.py

# Django_project/__init__.py
from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app

__all__ = ('celery_app',)

__all__ = ('celery_app',): This line defines the __all__ attribute, which is a list containing the names of the symbols that should be exported when from package import * is used. In this case, it ensures that only celery_app is exported from the package when it's imported.

• In the users app directory, create a signals.py file

# users/signals.py
from django.db.models.signals import post_save
from django.conf import settings
from django.dispatch import receiver
from .tasks import send_registration_email

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def send_email_registration_on_register(sender, instance, created, **kwargs):
    if created:
        email = instance.email
        print(email)
        send_registration_email.delay(receiver_email=email)

What this file does is whenever a new user is created, it will send an email to the newly registered user….like a welcome email by calling the send_registration_email function.

Ensure you include the created signals.py file in the apps.py file

# users/apps.py
from django.apps import AppConfig


class UsersConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'users'

    def ready(self):
            import users.signals

• SMTP Settings

# settings.py

# EMAIL SETTINGS
EMAIL_HOST_USER = os.getenv('SENDER_EMAIL')
EMAIL_HOST_PASSWORD = os.getenv('SENDER_EMAIL_PASSWORD')

Create a .env in the Django project directory and store your EMAIL_HOST_USER and EMAIL_HOST_PASSWORD

EMAIL_HOST_USER and EMAIL_HOST_PASSWORD are the information of the sender. To get a password go to your account in Gmail. Go to Security from the sidebar.

Then click on 2-step verification. Verify it’s you by inputting your Google password.

You will be redirected to another page, scroll down to App password. Then click on the arrow.

Next, give a name to the app password then, click Create. A popup of the generated app password will be displayed. Copy your password (the text in the grey background). Paste it to your .env file.

From my personal experience, I noticed that sending email using Django’s default SMTP settings doesn’t work. It keeps giving me an SMTP server timeout error. If you have encountered such please share in the comments how you resolved such.

💡 Alternative Approach: If you’d rather avoid the hassle of configuring SMTP, handling app passwords, and dealing with Gmail’s limitations, something like Notify could be a great alternative. It lets you send transactional emails easily — either via API or directly from the dashboard — without worrying about SMTP configurations.

For this tutorial, I will be using raw Python for sending the emails for this tutorial. I promise the code is nothing too complicated😅.

• Define a new task

Create a new task.py file in the users app directory

# users/task.py

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import smtplib
import smtplib, ssl
from celery import shared_task
from django.conf import settings

@shared_task
def send_registration_email( receiver_email, message='Thank you for registering on our site.'):
    # Create a MIME object
    msg = MIMEMultipart()
        
    # Attach the message
    msg.attach(MIMEText(message, "plain"))

    # Set the email subject, sender, and receiver
    msg["Subject"] = 'welcome to GFG world'
    msg["From"] = settings.EMAIL_HOST_USER
    msg["To"] = receiver_email

    # Establish a connection to the SMTP server
    context = ssl.create_default_context()
    with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
        # Log in to the email account
        server.login(settings.EMAIL_HOST_USER, settings.EMAIL_HOST_PASSWORD)
        
        # Send the email
        server.sendmail(settings.EMAIL_HOST_USER, receiver_email, msg.as_string())

Run the Django server in the first terminal. python manage.py runserver

Run the Celery in the second terminal. celery -A atsuko_clone worker -l info

Go to http://localhost:8000/api/schema/swagger/#/auth/auth_users_create fill in the request body, then click Execute.

Once the response body gives a 201 response back, the user has been created successfully. Then check your inbox for a welcome email.🙂

Pretty nice.

Conclusion

Alright, folks, that’s the gist of it! By using Celery, you can easily set up an asynchronous email-sending system in your Django app. No more waiting around for those emails to go out — let Celery handle it in the background while you focus on the important stuff. See you in the next one👋

Psst, have I got a sweet deal for 🫵🏽. Want to take your Django app to the next level?🫰🏽🔥. Check out this awesome tutorial on Deploy a Dockerized Django App on AWS EC2 with RDS, S3, Gunicorn, Nginx, and GitHub Actions CI/CD. The best part? You’ll get hands-on experience and a smoother deployment process. But wait, there’s more — use my coupon code BENEARLYEC2 to get 50% off! Happy coding!😊👋🏽

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: Stackademic | CoFeed | Venture | Cubed
• More content at PlainEnglish.io

Asynchronously Send Emails in Django📨 was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Life’s been giving me lemons lately. So many freaking lemons. And don’t even get me started on where the heck the lemonade is. I’m Amina- a 25-year-old dreamer with a camera glued to my hand and the world on my shoulders. You see, I’ve been hustling like hustling, racing to turn my passion for photography into a career, and between hustling freelance gigs and taking care of my mom, who’s starting to get up there in age, I’ve found myself running on empty.

It’s tough out here for a dreamer. It’s so hard to keep going every day feeling like no one values your dreams. While fleeting thoughts of abandoning my ambitions for a more secure path crossed my mind during trying times, deep within I knew persisting through struggle and hardship toward my vision was the only way to find meaning.

But then, life gave me an unexpected break. I crossed paths with a big-time artist who must have felt that the universe was winking at her. She saw something in my work that I’d been blind to in my moments of — let’s keep it real — whimpering lack of confidence. She made me see that my story counted too, that my perspective was just as original as hers and worthy of being shared with the world. Something ignited within my soul, like a flame of resilience that refused to be extinguished despite the hardships life had laid upon me. It was in that pivotal instant that I glimpsed myself afresh, envisioning not one who surrenders to my circumstances but rather the designer of my fate as it unfolds. The sparks of self-determination gave light in the darkness, empowering me to write the next chapter according to my vision, not dictated by the tragedies of the past but guided by the promise of possibilities yet unseen. While the challenges lying ahead remain formidable, I stride forward with renewed confidence and determination, aware of my innate ability to craft something sweet from life’s sourest of fruits.

As a young photographer with dreams filling my heart and my camera prepared to see the world through my eyes, here I am ready to share my name — Amina — and bring my visions to life. Watch out, universe, because I’m taking control of my narrative, one shot at a time.

Table of Content

1. Introduction
2. Setting Up Your Python Environment
3. Python Libraries for Desktop Cleaning
4. Creating Your Desktop Cleaning Script
5. Customizing Cleaning Rules
6. Automating Cleaning Tasks

INTRODUCTION

Hey everyone, I want to share a cool project I created. Ever wished your desktop could clean itself up automatically? 🤔I used Python’s file management features to build a basic desktop cleaner. With a simple click, it scans specified paths for files and folders, organizing your desktop seamlessly✨. In this article, I’ll break down the key parts of the code, showing how easy it is to build handy tools like this with Python. Per the StackOverflow survey, Python's popularity makes it an excellent choice for such projects, offering ample resources and support. If you’re looking to tidy up your workspace, Python is a smart and accessible solution👌

Setting Up Your Python Environment

First, ensure you have Python on your computer if you don't click this link to download and install the latest version of Python.

In your terminal first install virtualenv. It is a tool to set up your Python environments. Since Python 3.3, a subset has been integrated into the standard library under the venv module. You can install venv to your host Python by running this command in your terminal:

pip install virtualenv

To use venv in our project, in your terminal, create a new project folder called desktop_cleaner, cd to the project folder in your terminal, and run the following command:

 python -m venv venv

When you check your project folder, you will notice that a new folder called venv has been created. venv is the name of our virtual environment, but it can be named anything you want. To activate your virtual environment for your projects run the command below

myenv\Scripts\activate

Once you see the highlighted text it indicates your virtual environment is active.

Python Libraries for Desktop Cleaning

1. Watchdog: Python API library and shell utilities to monitor file system events.
2. Shutil: module offers some high-level operations on files and collections of files. In particular, functions are provided that support file copying and removal. For operations on individual files
3. Pathlib: This module offers classes representing filesystem paths with semantics appropriate for different operating systems.
4. Datetime: The datetime module supplies classes for manipulating dates and times.

Creating Your Desktop Cleaning Script

For this tutorial, I’ll be using the Pycharm IDE but you can use any IDE or text editor of your choice that works well with Python😊.

Below is the project file structure.

desktop_cleaner/
    __init__.py
    cleanedesk.py
    EventHandler.py
    extensions.py
    ...

Now, open the created folder in your selected IDE.

Next, create an __init__.py in the desktop_cleaner folder.

In Python, the __init__.py file is used to mark a directory as a Python package. It is used to initialize the package when it is imported.

Still, within the desktop_cleaner directory, create a Python file named extension.py. This Python file will contain all the extensions for the files to be read by our code.

Within the extensions.py file, paste the code below into the file

extension_paths = {
        # No name
        'noname':  'other/uncategorized',
        # audio
        '.aif':    'media/audio',
        '.cda':    'media/audio',
        '.mid':    'media/audio',
        '.midi':   'media/audio',
        '.mp3':    'media/audio',
        '.mpa':    'media/audio',
        '.ogg':    'media/audio',
        '.wav':    'media/audio',
        '.wma':    'media/audio',
        '.wpl':    'media/audio',
        '.m3u':    'media/audio',
        # text
        '.txt':    'text/text_files',
        '.doc':    'text/microsoft/word',
        '.docx':   'text/microsoft/word',
        '.odt ':   'text/text_files',
        '.pdf':    'text/pdf',
        '.rtf':    'text/text_files',
        '.tex':    'text/text_files',
        '.wks ':   'text/text_files',
        '.wps':    'text/text_files',
        '.wpd':    'text/text_files',
        # video
        '.3g2':    'media/video',
        '.3gp':    'media/video',
        '.avi':    'media/video',
        '.flv':    'media/video',
        '.h264':   'media/video',
        '.m4v':    'media/video',
        '.mkv':    'media/video',
        '.mov':    'media/video',
        '.mp4':    'media/video',
        '.mpg':    'media/video',
        '.mpeg':   'media/video',
        '.rm':     'media/video',
        '.swf':    'media/video',
        '.vob':    'media/video',
        '.wmv':    'media/video',
        # images
        '.ai':     'media/images',
        '.bmp':    'media/images',
        '.gif':    'media/images',
        '.jpg':    'media/images',
        '.jpeg':   'media/images',
        '.png':    'media/images',
        '.ps':     'media/images',
        '.psd':    'media/images',
        '.svg':    'media/images',
        '.tif':    'media/images',
        '.tiff':   'media/images',
        '.cr2':    'media/images',
        # internet
        '.asp':    'other/internet',
        '.aspx':   'other/internet',
        '.cer':    'other/internet',
        '.cfm':    'other/internet',
        '.cgi':    'other/internet',
        '.pl':     'other/internet',
        '.css':    'other/internet',
        '.htm':    'other/internet',
        '.js':     'other/internet',
        '.jsp':    'other/internet',
        '.part':   'other/internet',
        '.php':    'other/internet',
        '.rss':    'other/internet',
        '.xhtml':  'other/internet',
        '.html':   'other/internet',
        # compressed
        '.7z':     'other/compressed',
        '.arj':    'other/compressed',
        '.deb':    'other/compressed',
        '.pkg':    'other/compressed',
        '.rar':    'other/compressed',
        '.rpm':    'other/compressed',
        '.tar.gz': 'other/compressed',
        '.z':      'other/compressed',
        '.zip':    'other/compressed',
        # disc
        '.bin':    'other/disc',
        '.dmg':    'other/disc',
        '.iso':    'other/disc',
        '.toast':  'other/disc',
        '.vcd':    'other/disc',
        # data
        '.csv':    'programming/database',
        '.dat':    'programming/database',
        '.db':     'programming/database',
        '.dbf':    'programming/database',
        '.log':    'programming/database',
        '.mdb':    'programming/database',
        '.sav':    'programming/database',
        '.sql':    'programming/database',
        '.tar':    'programming/database',
        '.xml':    'programming/database',
        '.json':   'programming/database',
        # executables
        '.apk':    'other/executables',
        '.bat':    'other/executables',
        '.com':    'other/executables',
        '.exe':    'other/executables',
        '.gadget': 'other/executables',
        '.jar':    'other/executables',
        '.wsf':    'other/executables',
        # fonts
        '.fnt':    'other/fonts',
        '.fon':    'other/fonts',
        '.otf':    'other/fonts',
        '.ttf':    'other/fonts',
        # presentations
        '.key':    'text/presentations',
        '.odp':    'text/presentations',
        '.pps':    'text/presentations',
        '.ppt':    'text/presentations',
        '.pptx':   'text/presentations',
        # programming
        '.c':      'programming/c&c++',
        '.class':  'programming/java',
        '.java':   'programming/java',
        '.py':     'programming/python',
        '.sh':     'programming/shell',
        '.h':      'programming/c&c++',
        # spreadsheets
        '.ods':    'text/microsoft/excel',
        '.xlr':    'text/microsoft/excel',
        '.xls':    'text/microsoft/excel',
        '.xlsx':   'text/microsoft/excel',
        # system
        '.bak':    'text/other/system',
        '.cab':    'text/other/system',
        '.cfg':    'text/other/system',
        '.cpl':    'text/other/system',
        '.cur':    'text/other/system',
        '.dll':    'text/other/system',
        '.dmp':    'text/other/system',
        '.drv':    'text/other/system',
        '.icns':   'text/other/system',
        '.ico':    'text/other/system',
        '.ini':    'text/other/system',
        '.lnk':    'text/other/system',
        '.msi':    'text/other/system',
        '.sys':    'text/other/system',
        '.tmp':    'text/other/system'
        }

The code above categorizes all the widely used file extensions on a PC. I couldn't cover all of them😅.

Create another Python file called Evenhandler.py in the desktop_cleaner directory.

The primary purpose of this file is to determine how the directory subfolders will be stored based on their various file extensions.

Now copy the code below into the file

import shutil
from datetime import date
from pathlib import Path

from watchdog.events import FileSystemEventHandler

from extensions import extension_paths


def add_date_to_path(path: Path):
    """
    Helper function that adds current year/month to destination path. If the path
    doesn't already exist, it is created.

    :param Path path: destination root to append subdirectories based on date
    """
    dated_path = path / f'{date.today().year}' / f'{date.today().strftime("%b").upper()}'
    dated_path.mkdir(parents=True, exist_ok=True)
    return dated_path


def rename_file(source: Path, destination_path: Path):
    """
    Helper function that renames file to reflect new path. If a file of the same
    name already exists in the destination folder, the file name is numbered and
    incremented until the filename is unique (prevents overwriting files).

    :param Path source: source of file to be moved
    :param Path destination_path: path to destination directory
    """
    if Path(destination_path / source.name).exists():
        increment = 0

        while True:
            increment += 1
            new_name = destination_path / f'{source.stem}_{increment}{source.suffix}'

            if not new_name.exists():
                return new_name
    else:
        return destination_path / source.name


class EventHandler(FileSystemEventHandler):
    def __init__(self, watch_path: Path, destination_root: Path):
        self.watch_path = watch_path.resolve()
        self.destination_root = destination_root.resolve()

    def on_modified(self, event):
        for child in self.watch_path.iterdir():
            # skips directories and non-specified extensions
            if child.is_file() and child.suffix.lower() in extension_paths:
                destination_path = self.destination_root / extension_paths[child.suffix.lower()]
                destination_path = add_date_to_path(path=destination_path)
                destination_path = rename_file(source=child, destination_path=destination_path)
                shutil.move(src=child, dst=destination_path)

Explaining the above code blocks

from pathlib import Path
from datetime import date

• The function is named add_date_to_path.
• It takes one parameter, pathwhich is expected to be an instance of the Path class.

current_year = date.today().year
current_month = date.today().strftime("%b").upper()

• date.today().year gets the current year.
• date.today().strftime("%b").upper() gets the current month in abbreviated format (e.g., "Jan") and converts it to uppercase.

dated_path = path / f'{current_year}' / f'{current_month}'

path / f'{current_year}' / f'{current_month}' creates a new Path object by appending the current year and month as subdirectories to the original path.

dated_path.mkdir(parents=True, exist_ok=True)

• mkdir creates the directories specified in the path.
• parents=True ensures that parent directories are also created if they don't exist.
• exist_ok=True prevents an error if the directories already exist.

return dated_path

The function returns the final Path object representing the destination path with the current year and month.

Overall, this function is a utility that helps organize destination paths based on the current year and month, creating the necessary directories if they don’t already exist.

def rename_file(source: Path, destination_path: Path):
    """
    Helper function that renames a file to reflect a new path. If a file with
    the same name already exists in the destination folder, the file name is
    numbered and incremented until the filename is unique (prevents overwriting files).

    :param Path source: source of the file to be moved
    :param Path destination_path: path to the destination directory
    """

• The function is named rename_file.
• It takes two parameters: source (the source path of the file to be moved) and destination_path (the path to the destination directory).
• The docstring provides information about what the function does and how to use it.

if Path(destination_path / source.name).exists():

Check if a file with the same name already exists in the destination folder.

increment = 0

while True:
    increment += 1
    new_name = destination_path / f'{source.stem}_{increment}{source.suffix}'

    if not new_name.exists():
        return new_name

If a file with the same name exists, it starts incrementing a counter (increment) and constructs a new filename until a unique filename is found

return new_name

The function returns the new Path object representing the unique filename.

else:
    return destination_path / source.name

• If no file with the same name exists in the destination folder, it returns the original filename.

This function helps ensure that files are moved to a destination directory with a unique name to prevent overwriting existing files. The filename is modified by appending an incrementing number to it if necessary.

Import Statements:

pathlib import Path
from watchdog.events import FileSystemEventHandler
import shutil

• Path is a class from the pathlib module that represents file system paths.
• FileSystemEventHandler is a class from the watchdog.events module that provides event handlers for file system events.
• shutil is a module for file operations.

Class Definition:

class EventHandler(FileSystemEventHandler):

• Defines a class named EventHandler that inherits from FileSystemEventHandler.

Constructor (__init__ method):

def __init__(self, watch_path: Path, destination_root: Path):
    self.watch_path = watch_path.resolve()
    self.destination_root = destination_root.resolve()

• The constructor initializes the watch_path and destination_root attributes by resolving the provided paths.

on_modified Method:

def on_modified(self, event):
    for child in self.watch_path.iterdir():
        # skips directories and non-specified extensions
        if child.is_file() and child.suffix.lower() in extension_paths:
            destination_path = self.destination_root / extension_paths[child.suffix.lower()]
            destination_path = add_date_to_path(path=destination_path)
            destination_path = rename_file(source=child, destination_path=destination_path)
            shutil.move(src=child, dst=destination_path)

• This method is called when a file is modified in the watched directory.
• It iterates over files in the watch_path.
• It checks if the file is a regular file and has an extension specified in extension_paths.
• It constructs the destination path based on the extension, adds the current date to the path, and renames the file if needed.
• Finally, it moves the file to the calculated destination path using shutil.move.

This class seems to be part of a file-watching system where files are moved based on their extension and modified events. The add_date_to_path and rename_file functions are used for organizing and renaming files. Note that extension_paths should be defined somewhere in your code, as it's referenced in the if condition.

Now let’s create a new Python file named cleandesk.py to put all the functionality together😁

Copy the code below into your newly created Python file

from pathlib import Path
from time import sleep

from watchdog.observers import Observer

from EventHandler import EventHandler

if __name__ == '__main__':
    watch_path_1 = Path.home() / 'Downloads'
    watch_path_2 = Path.home() / 'Pictures'
    watch_path_3 = Path.home() / 'Desktop'
    destination_root_1 = Path.home() / 'Downloads/holder of things'
    destination_root_2 = Path.home() / 'Pictures/holder of things'
    destination_root_3 = Path.home() / 'Desktop/holder of things'

    event_handler_1 = EventHandler(watch_path=watch_path_1, destination_root=destination_root_1)
    event_handler_2 = EventHandler(watch_path=watch_path_2, destination_root=destination_root_2)
    event_handler_3 = EventHandler(watch_path=watch_path_3, destination_root=destination_root_3)

    observer_1 = Observer()
    observer_1.schedule(event_handler_1, f'{watch_path_1}', recursive=True)
    observer_1.start()

    observer_2 = Observer()
    observer_2.schedule(event_handler_2, f'{watch_path_2}', recursive=True)
    observer_2.start()

    observer_3 = Observer()
    observer_3.schedule(event_handler_3, f'{watch_path_3}', recursive=True)
    observer_3.start()

    try:
        while True:
            sleep(60)
    except KeyboardInterrupt:
        observer_1.stop()
        observer_2.stop()
        observer_3.stop()
    observer_1.join()
    observer_2.join()
    observer_3.join()

This script is a Python program that uses the watchdog library to monitor three different directories (Downloads, Pictures, and Desktop) for file system events (such as file modifications) and automatically organizes files in those directories into a corresponding "holder of things" subdirectory.

Let’s break down the script in detail:

Import Statements:

from pathlib import Path
from time import sleep
from watchdog.observers import Observer
from EventHandler import EventHandler

• Path is a class from the pathlib module that represents file system paths.
• sleep is a function from the time module that pauses the execution of the script for a specified number of seconds.
• Observer is a class from the watchdog.observers module that observes file system events.
• EventHandler is a custom class defined in a separate EventHandler.py file, handling file system events.

Main Execution Block:

if __name__ == '__main__':

• This common Python idiom checks whether the script is being run as the main program.

Directory Paths:

watch_path_1 = Path.home() / 'Downloads'
watch_path_2 = Path.home() / 'Pictures'
watch_path_3 = Path.home() / 'Desktop'
destination_root_1 = Path.home() / 'Downloads/holder of things'
destination_root_2 = Path.home() / 'Pictures/holder of things'
destination_root_3 = Path.home() / 'Desktop/holder of things'

• Path.home() returns the home directory of the current user.
• Three watch_path variables are defined for the directories to be watched (Downloads, Pictures, and Desktop).
• Three destination_root variables are defined for the corresponding "holder of things" subdirectories.

Event Handlers and Observers:

event_handler_1 = EventHandler(watch_path=watch_path_1, destination_root=destination_root_1)
event_handler_2 = EventHandler(watch_path=watch_path_2, destination_root=destination_root_2)
event_handler_3 = EventHandler(watch_path=watch_path_3, destination_root=destination_root_3)

observer_1 = Observer()
observer_1.schedule(event_handler_1, f'{watch_path_1}', recursive=True)
observer_1.start()

observer_2 = Observer()
observer_2.schedule(event_handler_2, f'{watch_path_2}', recursive=True)
observer_2.start()

observer_3 = Observer()
observer_3.schedule(event_handler_3, f'{watch_path_3}', recursive=True)
observer_3.start()

• Three instances of the EventHandler class are created, each associated with a different pair of watch_path and destination_root.
• Three instances of the Observer class are created and configured to use the respective event handlers and directories.
• The observers start to monitor the specified directories.

Main Loop and Exception Handling:

try:
    while True:
        sleep(60)
except KeyboardInterrupt:
    observer_1.stop()
    observer_2.stop()
    observer_3.stop()
observer_1.join()
observer_2.join()
observer_3.join()

• The script enters a main loop where it sleeps for 60 seconds (sleep(60)) to keep the program running.
• It catches a KeyboardInterrupt exception (typically triggered by pressing Ctrl+C in the terminal) to gracefully stop the observers.
• observer.stop() is called for each observer to stop monitoring.
• observer.join() is called for each observer to wait for the observer's thread to finish.

This script is essentially a main Python file organizer that continuously watches three directories for modifications and organizes files into corresponding subdirectories. It uses the watchdog library for efficient file system event handling.
For testing purposes, you can run the cleandesk.py file to see the Python magic happen as the specified directories are cleaned up.

Customizing Cleaning Rules

To customize the cleaning rules for your Python desktop cleaner, you can modify the extension_paths dictionary. Here are five ways you can customize the rules:

1. Add New File Extensions:

• To include additional file types, simply add new key-value pairs to the extension_paths dictionary. For example:

'.new_ext': 'custom_folder/custom_subfolder'

2. Modify Existing Paths:

• Adjust the destination paths for existing file extensions to suit your organization's preferences. For instance:

'.txt': 'text/my_text_files'

3. Create New Categories:

• Introduce new categories by specifying unique folder structures for certain file types. For example:

'.xyz': 'custom_category/subfolder

4. Exclude Specific Extensions:

• If you want to exclude certain file types from being organized, you can remove them from the extension_paths dictionary. For instance:

del extension_paths['.unwanted_ext']

5. Change Root Destination Paths:

• Modify the root destination paths for different watch paths by adjusting the destination_root variables in the main script. For example:

destination_root_1 = Path.home() / 'Downloads/new_destination'

Remember to consider the organizational structure that makes the most sense for your workflow and adjust the paths accordingly. After making changes, restart the script to apply the updated cleaning rules.👍

Automating the Cleaning Task

Now to automate the cleaning Python script on your computer we are gonna be using the Windows task scheduler to run the script at predefined intervals.

To run your Python scheduler you will need to create a task, create an action, add the path to your Python executable file and to your Python script, and add a trigger to schedule your script.

1. Create Your First Task

Search for “Task Scheduler”.

This will open the Windows Task Scheduler GUI.

Go to Actions > Create Task…

Give the task a name.

Click “OK”.

2. Create an Action

Go to Actions > New

Click “OK”.

3. Add the Python Executable File to the Program Script

Find the Python Path using where python in the command line.

From the command prompt copy the script to use in the action.

C:\yourpath\python.exe

or in my case

C:\Users\Kodi_\AppData\Local\Programs\Python\Python310\python.exe

In Program/Script, add the path you copied from the command line.

Click “OK”.

4. Add the Path to Your Python Script in the Arguments

Go to the folder where your Python script is located. Right-click on the file and select Copy as path.

If you have a file located at this location.

C:\user\your_python_project_path\yourFile.py

In the "Add arguments (optional)” box, you will add the name of your python file.

cleandesk.py

In the "Start in (optional)" box, you will add the location of your python file.

C:\Users\Kodi_\Downloads\desktop_cleaner-master\desktop_cleaner

Click “OK”.

5. Trigger Your Script Execution

Go to “Triggers” > New

Choose the repetition that you want. Here you can schedule Python scripts to run daily, weekly, monthly, or just one time.

Once, you have set this up, your trigger is now active and your Python script will run automatically every day.

Now the Python cleaner will run every day at every hour. Pretty neat if you ask me😉.

In conclusion, if you want an easy way to keep your desktop from spiraling into chaos, look no further than a Python cleanup script. With a little coding knowledge, you can customize a solution that perfectly fits your workflow. Say goodbye to desktop clutter — with Python on your side, a tidy desktop is only a script away! 👉Soruce code👈

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: Stackademic | CoFeed | Venture | Cubed
• More content at PlainEnglish.io

Python Magic: Streamlining Your Desktop with a Cleanup Script👌 was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Table of Content

1. Drawbacks and Challenges
2. Balancing Human and AI in Coding Education
3. Summary

DRAWBACKS AND CHALLENGES

As artificial intelligence becomes increasingly adept at assisting with educational tasks like tutoring, grading assignments, and answering questions, some schools, and coding boot camps have started experimenting with “AI teaching assistants” to help students learn coding fundamentals. On the surface, the promise of having a digital tutor available around the clock seems ideal. But is overreliance on AI for learning to code a good thing? Here are a few potential downsides and challenges to consider.

Overreliance Could Stunt Problem-Solving Skills

While AI teaching assistants are great for looking up syntax rules or walkthroughs of sample code, there’s a risk that students could become too dependent on the technology for hands-on problem-solving. Part of learning to code is figuring things out through trial and error, and students need to develop the ability to troubleshoot issues independently. If students start outsourcing all their problems to an AI tutor, it could hinder the development of important debugging skills. Interacting with a human teacher who can ask follow-up questions and think through problems out loud is invaluable for strengthening these self-sufficient problem-solving muscles.

Lack of Human Interaction May Limit Learning

As any experienced coder will tell you, the process of learning to code is as much about collaboration and communication as it is about memorizing syntax. Human teachers provide social-emotional support, help students through frustrating blocks, and foster a community of learners helping one another. While AI can be helpful, it lacks the interpersonal elements of learning. Things like explaining concepts verbally, having nuanced discussions, and providing individualized feedback tailored to learning styles are still better handled by people rather than programs. Sole reliance on AI risks missing out on the motivation and accountability that comes from learning alongside other students and instructors.

Potential for Bias and Limitations in Algorithms

Like all AI systems, teaching assistants developed using machine learning algorithms will only be as unbiased and comprehensive as the data used to train them. If the training data reflects a narrow range of human technical skills, problem domains, or cultural viewpoints, it could inadvertently propagate those limitations. For example, an AI may have a harder time explaining concepts that require reasoning about the social or ethical implications of coding. There’s also the risk of blind spots when it comes to atypical learning approaches or advanced interdisciplinary concepts. Having human experts who can adapt lessons to diverse individual needs helps overcome these algorithmic limitations.

Finding the Right Balance: Teaching Code with a Mix of Machine and Mentor

As an overworked coding student, the promise of AI handling all my homework assignments sounds pretty great. Who wouldn’t want a robot teacher who never gets tired, never takes a day off, and gives perfect feedback every time? On the other hand, having a real human teacher does have some advantages over our metallic friends. So how do we find the right balance between AI and actual people in the classroom?

First of all, let’s be real — AI is amazing but it’s not perfect. Those robot teachers may be tireless, but they’re also soulless! There’s no replacing the joy of making your real teacher laugh during class or bonding with them over your shared love of coding. AI can check syntax and run test cases like nobody’s business, but it lacks the human touch of actually understanding where a student is struggling and tailoring help specifically for them.

Not to mention, AI is still pretty narrow — it’s great at specific technical tasks but lacks common sense reasoning. Imagine trying to explain a complex conceptual problem to a robot! “I’m sorry, I do not experience confusion or have an intuitive understanding of abstract concepts. Have you tried rephrasing your question using only terminology from our training data?” No thanks, I’ll take my chances with a person.😅

So clearly, AI alone cannot replace human teachers. But that doesn’t mean it has no role to play! Used judiciously as a supplement to — not a substitute for — real teachers, AI tools have huge potential to enhance learning. For example, robots could handle basic grading and feedback for homework problems, freeing up instructors to focus on higher-level guidance. AI tutoring systems could provide on-demand help for basic syntax and code structure outside of class hours. And virtual assistants may one day be able to recommend additional learning resources tailored to individual student’s strengths and weaknesses.

The future of education lies not in choosing humans or AI, but in finding the right balance. With humans to provide empathy, creativity, and expert guidance, and AI to handle routine tasks at scale, students could get the best of both worlds. So, rest easy coding students — those AI models aren’t replacing teachers just yet. But they might just do your homework for you if you ask nicely!😂

In the end, the key is using AI is to augment human teachers rather than replace them. A balanced approach that leverages the unique capabilities of both can truly enhance learning outcomes.

SUMMARY

AI is revolutionizing coding education by offering personalized learning plans, real-time feedback, and automated grading. However, overreliance on AI may hinder problem-solving skills and limit holistic learning. A balanced approach that combines AI and human instruction is crucial to fostering well-rounded problem-solving skills and supporting students effectively. The future of coding education lies in a harmonious blend of AI and human instruction.

Perspective on the Future

As technology advances, the role of AI in coding education will likely continue to evolve. The key lies in finding the right balance between AI and human instructors. While AI can offer tremendous benefits in terms of personalized learning and efficiency, it cannot replace the human touch, empathy, and creativity that human teachers bring to the table. The future of coding education is not an “either-or” scenario but a synergistic blend of AI and human guidance. The article emphasizes the significance of using AI as a tool to augment human teaching rather than as a wholesale replacement. With this balanced approach, the potential for enhanced learning outcomes in coding education is vast, offering students the best of both worlds.

CALL TO ACTION

Alright, my fellow coding enthusiasts, it’s time to wrap this up. I want to hear from you, so don’t be shy. Share your thoughts and experiences with AI in coding, and let’s keep the conversation going. And remember, the future of coding is bright, thanks to AI. So, let’s embrace it and see where it takes us. Happy coding!✨

Further Reading and Resources:

• Forbes: Can AI Be Your Coding Teacher?
• How to Train a Machine Learning Model Using Paperspace
• The Guardian: Artificial intelligence could revolutionize coding education
• “5 Ways AI Can Make Coding Education More Accessible” by EdSurge: Discover practical applications of AI in making coding education more inclusive and equitable for students of diverse backgrounds and abilities.
• “AI in Education: Transforming Learning for a Digital Age” by OECD: This comprehensive report explores the potential and challenges of AI in education, offering valuable insights for educators and policymakers.

Table of Content

1. Introduction
2. Settings up the project
3. Working with Supabase
4. Deployment on Vercel
5. Challenges and Lessons Learned
6. Benefits and Final Thoughts
7. Conclusion
8. Tips and Takeaways
9. References and Resources

1. INTRODUCTION

Hey there, fellow developers!👋 I recently wrote an article on kowe.io where I embarked on an exciting journey to deploy my Django application. I wanted to share my experiences with you as I navigated the intricacies of Django app deployment. One of the most significant decisions I had to make was where and how to host the application and its database. After extensive research and a bit of trial and error, I decided to go with Vercel for hosting and Supabase for the database🚀.

2. SETTING UP PROJECT

Now, let’s dive into the nitty-gritty🐱‍🏍. My project’s architecture relies heavily on Django’s flexibility, the robust ecosystem of packages, and the wealth of resources in its documentation. Django is like an old friend to me, offering a structured approach to application development while still allowing me to handle complex data relationships.

For the database, I opted for Supabase, a versatile and developer-friendly platform that simplifies database management and provides real-time capabilities. The beauty of it is how seamlessly it integrates with my Django application. It made development and testing feel like a breeze😉✨.

3. WORKING WITH SUPABASE

Integrating my Django app with Supabase was smoother than I expected, thanks to their Supabase database URL that includes everything you need to connect to your Supabase database. It’s that straightforward! it’s just like plug-and-play. This cloud database platform not only simplified database management but also enhanced my Django application’s capabilities.

Supabase’s strength lies in its user-friendly interface. Setting up your database and managing it becomes a breeze. Whether you need to design a new schema, migrate data, or make real-time changes to your database structure, the Supabase dashboard is your go-to tool🤞.

4. DEPLOYMENT ON VERCEL

Deploying my Django application on Vercel wasn’t very straightforward(I’ll dive deeper into that in the next section). For those that don't know Vercel’s platform is primarily designed for hosting and deploying frontend and serverless applications. While it’s exceptionally well-suited for serving frontend code, static assets, and serverless functions, it doesn’t provide native support for hosting traditional server-side applications, including those built with server-side frameworks like Django.😞

If you have a server-side application, consider other hosting providers or cloud platforms better suited to manage server-side code. However, if your application is still small and in the testing phase, then deployment on Vercel can still work. 👍

5. CHALLENGES AND LESSONS LEARNED

Of course, no journey is complete without its fair share of challenges😅. I encountered a significant challenge during the deployment of my application on Vercel. Upon the completion of the deployment process, the application presented a 504 Gateway Timeout error, signifying that the request from the wsgi.py file to the web server had timed out🤦‍♂️. This issue was unexpected, particularly because I had previously deployed the same application to Railway without encountering this error.

In my quest to understand the root cause, I conducted research on Vercel’s platform. It came to my attention that Vercel’s serverless functions, which require a request from the wsgi.py, have a default time limit of 10 seconds for processing requests, especially applicable to hobby projects.

Given the complexity of my Django project, which consisted of four(4) separate apps, it exceeded the specified time limit to send a request, ultimately resulting in the 504 Gateway Timeout error. In order to increase the timeout for serverless functions on Vercel, this typically requires an upgrade to a paid plan which was a major deal breaker for me.💔

In the quest to resolve the 504 Gateway Timeout error on Vercel, I found myself at a crossroads🤷‍♀️. The existing Django project, with its intricate structure and multiple apps, had exceeded Vercel’s serverless function timeout of 10 seconds. While the idea of breaking down the project into smaller, more manageable components had crossed my mind, I faced the reality that significant refactoring would be required😫.

Refactoring, while a valid solution, would mean a substantial overhaul of the existing codebase, restructuring, and optimizing it to fit within Vercel’s constraints. It would have been a time-consuming and resource-intensive process, and there was no guarantee of success without extensive testing and fine-tuning.

In light of these considerations💡, I began to explore an alternative path. It dawned on me that I could create an entirely new Django project specifically tailored to align with Vercel’s serverless function limitations. This fresh project would be designed from the ground up to operate seamlessly within the 10-second time frame, without the need for extensive refactoring and adjustments.

The decision to opt for a new project had its advantages. It provided a clean slate, allowing me to architect the application with Vercel’s constraints in mind from the outset. This approach promised a quicker resolution to the 504 error, as well as a more efficient development process without the need to unravel and rebuild the existing codebase.

6. BENEFITS AND FINAL THOUGHTS

The benefits of deploying my Django app on Vercel with Supabase were well worth the journey. Though the deployment process was not as efficient as I had hoped, it really taught me the importance of the adaptability of applications to meet the requirements of hosting platforms.

7. CONCLUSION

My journey deploying a Django application on Vercel with Supabase was a rewarding experience, and I wanted to share it with you. It’s my hope that my story provides guidance and inspiration for others considering similar deployment options. When you combine the power of Django with the hosting capabilities of Vercel and the versatility of Supabase, the possibilities for web application development become boundless.

8. TIPS AND TAKEAWAYS

• Consider Django & Supabase for a versatile and scalable application stack.
• Opt to use Vercel for small projects that don’t require much scalability.
• Before choosing a hosting platform learn its strengths and limitations.

9. REFERENCES AND RESOURCES

• Django Documentation
• Vercel Documentation
• Supabase Documentation
• Tutorial on how to deploy your Django project using Vercel & Supabase