Implementing WebSockets With Python and Django

WebSockets provide a robust way to enable real-time communication between clients and servers, making them perfect for applications like chat systems, live notifications, and collaborative tools. Implementing WebSockets in a Python and Django environment enhances your web application's interactivity. In this article, we'll guide you through setting up WebSockets with Django using Django Channels.

What are WebSockets?

WebSockets are a protocol that allows persistent, two-way communication between the server and the client. Unlike traditional HTTP requests, which are stateless and one-way, WebSockets maintain an open connection, allowing data to flow freely both ways until the connection is closed.

Why Use Django for WebSocket Implementation?

Django is a powerful web framework that follows the model-view-template (MVT) architectural pattern. When coupled with Django Channels, it allows developers to handle asynchronous tasks, real-time communications, and background tasks seamlessly. This makes it a perfect choice for implementing WebSockets.

Setting Up Your Django Project

Before you start with WebSockets, ensure you have a working Django project. If you haven't set one up yet, follow these steps:

Install Django:
pip install Django
Create a new project:
django-admin startproject myproject
Navigate to your project directory:
cd myproject

Installing Django Channels

Django Channels is an extension for Django that adds support for handling WebSockets in your application. Install it using pip:

pip install channels

Once installed, add ‘channels’ to your INSTALLED_APPS list in settings.py:

INSTALLED_APPS = [
    ...
    'channels',
]

Configuring Django Channels

You need to set up ASGI (Asynchronous Server Gateway Interface) as your protocol server. In your settings.py, define the following:

ASGI_APPLICATION = 'myproject.asgi.application'

Create a new file named asgi.py in your project directory and set it up as follows:

import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from myapp.routing import websocket_urlpatterns
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
application = ProtocolTypeRouter({
    'http': get_asgi_application(),
    'websocket': AuthMiddlewareStack(
        URLRouter(
            websocket_urlpatterns
        )
    ),
})

Creating WebSocket Consumers

Consumers are Python classes that handle WebSocket connections. Create a file named consumers.py in your Django app to define your WebSocket consumers:

from channels.generic.websocket import AsyncWebsocketConsumer
import json
class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = f'chat_{self.room_name}'
await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )
await self.accept()
async def disconnect(self, close_code):
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )
async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message',
                'message': message
            }
        )
async def chat_message(self, event):
        message = event['message']
await self.send(text_data=json.dumps({
            'message': message
        }))

Defining WebSocket Routes

Next, create a file named routing.py in your app. This file will define the WebSocket URL routing:

from django.urls import re_path
from . import consumers
websocket_urlpatterns = [
    re_path(r'ws/chat/(?P[^/]+)/$', consumers.ChatConsumer.as_asgi()),
]

Implementing WebSockets With Python and Django