DEV Community: Sarah Hudaib

Testing and Modules

Sarah Hudaib — Wed, 18 Jan 2023 07:50:17 +0000

What are Unit tests and TDD?

Unit tests:

Unit tests are some pieces of code that exercise the input, the output, and the behavior of your code.

TDD tests:

Test-Driven Development is a strategy that entails first thinking about (and writing!) tests.

Baby Steps:

what is the smaller test that we can do against a function?

  def test_should_return_female_when_the_name_is_from_female_gender():
    detector = GenderDetector()
    expected_gender = detector.run(‘Ana’)
    assert expected_gender == ‘female’

There are some details to pay attention. The first one is the test name. The tests can be considered as your live documentation.
The test file name should follow the same name as the module name.
It’s ideal to separate the tests folder from the production code (the implementation)
Another thing to care about is the structure. A convention widely used is the AAA: Arrange, Act and Assert.

Arrange: you need to organize the data needed to execute that piece of code (input)

Act: here you will execute the code being tested (exercise the behaviour)

Assert: after executing the code, you will check if the result (output) is the same as you were expecting

The Cycle:

The cycle is made by three steps:

🆘 Write a unit test and make it fail (it needs to fail because the feature isn’t there, right? If this test passes, call the Ghostwriters, really)
✅ Write the feature and make the test pass! (you can dance after that)
🔵 Refactor the code — the first version doesn’t need to be the beautiful one (don’t be shy)

Takeaways

To remember:

The greatest advantage of TDD is to craft the software design first.
Your code will be more reliable: after a change, you can run your tests and be in peace.
The beginning may be hard — and that’s fine. You just need to practice!

How to create a REST API with Django REST framework

Sarah Hudaib — Wed, 18 Jan 2023 07:46:21 +0000

What is a REST API?

A REST API is a popular way for systems to expose useful functions and data. REST, which stands for representational state transfer, can be made up of one or more resources that can be accessed at a given URL and returned in various formats, like JSON, images, HTML, and more.

Why Django REST framework?

Django REST framework (DRF) is a powerful and flexible toolkit for building Web APIs. Its main benefit is that it makes serialization much easier.

Django REST framework is based on Django’s class-based views, so it’s an excellent option if you’re familiar with Django. It adopts implementations like class-based views, forms, model validator, QuerySet, and more.

Setting up Django REST framework

Ideally, you’d want to create a virtual environment to isolate dependencies, however, this is optional. Run the command:

python -m venv django_env

from inside your projects folder to create the virtual environment. Then, run this command to turn it on.

source ./django_env/bin/activate

Keep in mind that you’ll need to reactivate your virtual environment in every new terminal session. You’ll know that it is turned on because the environment’s name will become part of the shell prompt.

Navigate to an empty folder in your terminal and install Django and Django REST framework in your project with the commands below:

pip install django
pip install django_rest_framework

Create a Django project called todo with the following command:

django-admin startproject todo

Then, cd into the new todo folder and create a new app for your API:

django-admin startapp todo_api

Run your initial migrations of the built-in user model:

python manage.py migrate

Next, add rest_framework and todo to the INSTALLED_APPS inside the todo/todo/settings.py file:

# settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'todo_api'
]

Create a serializers.py and urls.py file in todo/todo_api and add new files as configured in the directory structure below:

├── todo
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
├── db.sqlite3
├── manage.py
└── todo_api
    ├── admin.py
    ├── serializers.py
    ├── __init__.py
    ├── models.py
    ├── urls.py
    └── views.py

Be sure to include rest_framework and URLs as shown below in your main urls.py file:

# todo/todo/urls.py : Main urls.py
from django.contrib import admin
from django.urls import path, include
from todo_api import urls as todo_urls

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api-auth/', include('rest_framework.urls')),
    path('todos/', include(todo_urls)),
]

Next, create a superuser. We’ll come back to this later:

python manage.py createsuperuser

RESTful structure: `GET`, `POST`, `PUT`, and `DELETE` methods

In a RESTful API, endpoints define the structure and usage with the GET, POST, PUT, and DELETE HTTP methods. You must organize these methods logically.

To show how to build a RESTful app with Django REST framework, we’ll create an example to-do API.

Creating models for our Django app

Let’s start by creating the model for our to-do list:

# todo/todo_api/models.py
from django.db import models
from django.contrib.auth.models import User

class Todo(models.Model):
    task = models.CharField(max_length = 180)
    timestamp = models.DateTimeField(auto_now_add = True, auto_now = False, blank = True)
    completed = models.BooleanField(default = False, blank = True)
    updated = models.DateTimeField(auto_now = True, blank = True)
    user = models.ForeignKey(User, on_delete = models.CASCADE, blank = True, null = True)

    def __str__(self):
        return self.task

After creating the model, migrate it to the database.

python manage.py makemigrations
python manage.py migrate

Model serializer

To convert the Model object to an API-appropriate format like JSON, Django REST framework uses the ModelSerializer class to convert any model to serialized JSON objects:

# todo/todo_api/serializers.py
from rest_framework import serializers
from .models import Todo
class TodoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Todo
        fields = ["task", "completed", "timestamp", "updated", "user"]

Creating API views in Django

In this section, we’ll walk through how to create two API views, list view and detail view.

List view

The first API view class deals with the todos/api/ endpoint, in which it handles GET for listing all to-dos of a given requested user and POST for creating a new to-do. Notice that we’ve added permission_classes, which allows authenticated users only:

# todo/todo_api/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework import permissions
from .models import Todo
from .serializers import TodoSerializer

class TodoListApiView(APIView):
    # add permission to check if user is authenticated
    permission_classes = [permissions.IsAuthenticated]

    # 1. List all
    def get(self, request, *args, **kwargs):
        '''
        List all the todo items for given requested user
        '''
        todos = Todo.objects.filter(user = request.user.id)
        serializer = TodoSerializer(todos, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    # 2. Create
    def post(self, request, *args, **kwargs):
        '''
        Create the Todo with given todo data
        '''
        data = {
            'task': request.data.get('task'), 
            'completed': request.data.get('completed'), 
            'user': request.user.id
        }
        serializer = TodoSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

The GET() method first fetches all the objects from the model by filtering with the requested user ID.
Then, it serializes from the model object to a JSON serialized object.
Next, it returns the response with serialized data and status as 200_OK.
The POST() method fetches the requested data and adds the requested user ID in the data dictionary.
Next, it creates a serialized object and saves the object if it’s valid.
If valid, it returns the serializer.data, which is a newly created object with status as 201_CREATED.
Otherwise, it returns the serializer.errors with status as 400_BAD_REQUEST.

Create an endpoint for the class-based view above:

# todo/todo_api/urls.py : API urls.py
from django.conf.urls import url
from django.urls import path, include
from .views import (
    TodoListApiView,
)

urlpatterns = [
    path('api', TodoListApiView.as_view()),
]

Run the Django server:

python manage.py runserver

Now, we’re ready for the first test. Navigate to http://127.0.0.1:8000/todos/api. Make sure you’re logged in with your superuser credentials:

You can create a new to-do by posting the following:

{
    "task": "New Task",
    "completed": false
}

Detail view

Now that we’ve successfully created our first endpoint view, let’s create the second endpoint todos/api/<int:todo_id> API view.

In this API view class, we need to create three methods for handling the corresponding HTTP methods, GET, PUT, and DELETE, as discussed above:

# todo/api/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from todo.models import Todo
from .serializers import TodoSerializer
from rest_framework import permissions

class TodoDetailApiView(APIView):
    # add permission to check if user is authenticated
    permission_classes = [permissions.IsAuthenticated]

    def get_object(self, todo_id, user_id):
        '''
        Helper method to get the object with given todo_id, and user_id
        '''
        try:
            return Todo.objects.get(id=todo_id, user = user_id)
        except Todo.DoesNotExist:
            return None

    # 3. Retrieve
    def get(self, request, todo_id, *args, **kwargs):
        '''
        Retrieves the Todo with given todo_id
        '''
        todo_instance = self.get_object(todo_id, request.user.id)
        if not todo_instance:
            return Response(
                {"res": "Object with todo id does not exists"},
                status=status.HTTP_400_BAD_REQUEST
            )

        serializer = TodoSerializer(todo_instance)
        return Response(serializer.data, status=status.HTTP_200_OK)

    # 4. Update
    def put(self, request, todo_id, *args, **kwargs):
        '''
        Updates the todo item with given todo_id if exists
        '''
        todo_instance = self.get_object(todo_id, request.user.id)
        if not todo_instance:
            return Response(
                {"res": "Object with todo id does not exists"}, 
                status=status.HTTP_400_BAD_REQUEST
            )
        data = {
            'task': request.data.get('task'), 
            'completed': request.data.get('completed'), 
            'user': request.user.id
        }
        serializer = TodoSerializer(instance = todo_instance, data=data, partial = True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    # 5. Delete
    def delete(self, request, todo_id, *args, **kwargs):
        '''
        Deletes the todo item with given todo_id if exists
        '''
        todo_instance = self.get_object(todo_id, request.user.id)
        if not todo_instance:
            return Response(
                {"res": "Object with todo id does not exists"}, 
                status=status.HTTP_400_BAD_REQUEST
            )
        todo_instance.delete()
        return Response(
            {"res": "Object deleted!"},
            status=status.HTTP_200_OK
        )

The GET() method first fetches the object with the ID todo_id and user as request user from the to-do model.

If the requested object is not available, it returns the response with the status as 400_BAD_REQUEST.
Otherwise, it serializes the model object to a JSON serialized object and returns the response with serializer.data and status as 200_OK.

The PUT() method fetches the to-do object if it is available in the database, updates its data with requested data, and saves the updated data in the database.

The DELETE() method fetches the to-do object if is available in the database, deletes it, and responds with a response.

Update the API urls.py as demonstrated below:

# todo/api/urls.py : API urls.py
from django.conf.urls import url
from django.urls import path, include
from .views import (
    TodoListApiView,
    TodoDetailApiView
)

urlpatterns = [
    path('api', TodoListApiView.as_view()),
    path('api/<int:todo_id>/', TodoDetailApiView.as_view()),
]

Now, if you navigate to http://127.0.0.1:8000/todos/api/<id>/, it will show the detail API view page. Notice that you correctly navigate to a valid ID. In the screenshot below, I used 7 as the ID:

Conclusion

Congratulations! You’ve successfully built your first fully functional CRUD Django REST API.

Building a RESTful API can be complicated, but Django REST framework handles complexity fairly well. I hope you have fun building new APIs using the Django REST framework, and be sure to leave a comment if you have any questions. Happy coding!

Why Virtualenv is Important for Django Development

Sarah Hudaib — Wed, 18 Jan 2023 07:28:05 +0000

Create a separate virtual environment for each project:

Virtualenv is a tool that allows you to create a separate Python environment for each Django project you work on. This can be particularly useful if you need to work with different versions of Django and/or different libraries and packages for different projects.

Example:

For example, imagine that you are working on two Django projects, Project A and Project B.

Project A requires Django 2.2 and a specific version of the library X, while Project B requires Django 3.1 and a different version of library X. Without using virtualenv, you would need to install both Django 2.2 and Django 3.1, as well as the two different versions of library X on your system. This could lead to conflicts between the different versions of Django and library X, which could make it difficult or impossible to run one or both of the projects.

However, if you use virtualenv, you can create a separate virtual environment for each project, with its own copy of Django and the required libraries. This way, you can have Django 2.2 and the specific version of library X installed in the virtual environment for Project A, and Django 3.1 and the other version of library X installed in the virtual environment for Project B. This allows you to run both projects concurrently without any conflicts.

Install and manage packages and libraries:

In addition to helping you manage dependencies, virtualenv also makes it easier to install and manage the packages and libraries that your project depends on. You can use tools like pip to install and update these dependencies within the virtual environment, without affecting the packages and libraries installed on your system.

Steps to create a virtual environment with Python:

Install virtualenv:
```
pip install virtualenv
```
Create a virtual environment with Python 3.6:
```
virtualenv -p python3.6 myenv
```

This will create a new directory called "myenv" that contains the Python 3.6 interpreter and other files needed for the virtual environment.

Activate the virtual environment:
```
source myenv/bin/activate
```

This will activate the virtual environment, and you should see the name of the virtual environment in the command prompt, like this:

(myenv)$

Install the packages you need for your project:
```
pip install django
```

You can install multiple packages by separating them with spaces, like this:

pip install django requests

Freeze the installed packages:

pip freeze > requirements.txt

This will create a file called "requirements.txt" that lists all the packages and their versions that are installed in the virtual environment. You can use this file to install the same packages in a different environment or on a different machine.

To install the packages from the requirements file, use the following command:

pip install -r requirements.txt

Sum it up!

Overall, virtualenv is a valuable tool for Django developers, as it allows you to easily manage dependencies and avoid conflicts between different versions of libraries and packages. By using virtualenv, you can ensure that your Django projects are isolated and easy to maintain.

It allows you to isolate the dependencies for different Django projects, so that you can have different versions of libraries and packages installed for each project.
It makes it easier to manage the packages and libraries that your project depends on, as you can use tools like pip to install and manage these dependencies within the virtual environment.
It can help you avoid conflicts between different versions of libraries and packages that may be required by different projects.

Maximizing Your Django Development: 6 Expert Tips

Sarah Hudaib — Wed, 18 Jan 2023 07:25:10 +0000

Maximizing Your Django Development

Django is a powerful web framework, but there are a few things you should keep in mind to make your work smoother and more effective. Here are the top tips that will make a difference in your Django project:

1. Use virtualenv

Virtualenv is a tool that allows you to create isolated Python environments for your projects. This is important because it allows you to install and use different versions of libraries and packages for each project, without worrying about conflicts or version issues. Using virtualenv also makes it easier to deploy your code, as you can specify exactly which libraries and versions your project depends on in a requirements.txt file. Without virtualenv, you may run into issues when you try to deploy your code, or when you work on multiple projects that require different library versions.

2. Use PostgreSQL

PostgreSQL is a powerful and widely recommended database for Django projects. It offers a number of advantages over other databases, including robust support for transactions, foreign keys, and stored procedures. While it may take a little extra effort to learn how to use PostgreSQL effectively, it's worth it in the long run. We recommend working with PostgreSQL locally while you are learning, so that you can get a feel for how it works and how to troubleshoot any issues that arise.

3. Use class-based views

While function-based views may seem simpler at first, class-based views can be easier to work with in medium to large projects. They offer a number of benefits, such as mixins (which allow you to reuse common code across multiple views), forms (which make it easy to handle user input), and a more organized structure for your view code. Additionally, class-based views are the way that REST APIs are typically implemented, so learning to use them will make it easier for you to work with REST APIs in the future.

4. Enable SSL/HTTPS after deployment

SSL certificates are essential for secure communication between the server and the site, and should be included in your project from the outset. Without an SSL certificate, your site will use HTTP instead of HTTPS, which is less secure and may cause issues with some browsers or services. If you are deploying on Heroku, this is a built-in feature that you can easily configure in your settings.py file. If you are deploying on Digital Ocean, you can use the free Let's Encrypt library to enable SSL on your site.

5. Use the recommended project layout

The way you organize your project's files and folders is important for ease of use and maintainability. Django's recommended layout, which includes separate folders for templates, static files, and more, makes it easy to work with the admin templates or package your code for reuse by other developers. By following this layout, you'll know exactly where to find the files you need, and you'll be able to more easily understand the structure of other Django projects you encounter.

6. Do most of the logic in the models

While it's not always possible, it's generally a good idea to put as much logic as possible into your models. This keeps your views cleaner and easier to understand, and can make your code more reusable and maintainable in the long run. For example, if you have a complex calculation that needs to be performed in multiple views, you could put that calculation in a model method and call it from the views. This way, you don't have to repeat

In conclusion, Django is a powerful and flexible web framework that can help you build scalable and maintainable web applications. By following these six tips, you can maximize your productivity and success when working with Django. Whether you are a beginner or an experienced developer, these tips will help you avoid common pitfalls and make the most of Django's many features. By using virtualenv, PostgreSQL, class-based views, SSL/HTTPS, the recommended project layout, and putting logic in models, you can take your Django development to the next level and build high-quality applications that meet the needs of your users.

Context Processors in Django

Sarah Hudaib — Wed, 18 Jan 2023 07:21:58 +0000

Introduction:

Django is a powerful web framework that follows the principles of the Don't Repeat Yourself (DRY) philosophy. One way that Django achieves this is through the use of Context Processors. In this article, we'll take a closer look at what context processors are, how they work, and how to use them in your own Django projects.

What are Context Processors?

A context processor is a function that takes the current HttpRequest object as an argument and returns a dictionary of variables that can be made available to all templates. These variables are added to the context of the request, meaning that they can be accessed in any template that is rendered as a result of that request. This allows you to include common information, such as a site logo or user details, on every page of your website, without having to include the same code in multiple views.

How do Context Processors work?

When a request is made to your Django application, the framework goes through a series of middleware and view functions to process the request and generate a response. Once the view function has returned a TemplateResponse object, Django begins to render the template that is associated with the view.

As the template is rendered, Django looks for context processors that have been defined in your application's settings. For each context processor that is found, Django calls the associated function and adds the returned dictionary of variables to the template context. This means that, once the template has been rendered, all of the variables that have been added by context processors are available to the template.

When to use Context Processors?

Context Processors are useful when you have information that needs to be available on every page of your website. Examples of this include:

A user's cart on an e-commerce site
Site-wide navigation or a site logo
User details, such as a username or avatar
Information that is needed to render the site's footer etc.

Without context processors, you would need to include the code to fetch this information in every view, making your codebase repetitive and hard to maintain. By using context processors instead, you can define the code to fetch this information in one place and make it available to all templates without having to repeat yourself.

How to Use Context Processors in Django?

To use context processors in Django, you'll first need to create a new folder within your Django project. This folder can be named anything you like, and should be located near your other apps. Inside this folder, you should create a new file called context_processors.py (or similar) and write the function that retrieves the relevant information.

Here's an example of how you could use a context processor to add a site logo and footer information to all pages:

Create a folder called utils in your project.
Inside the utils folder, create a file called context_processors.py.
In the context_processors.py, import the models you need, and define two context processor functions: one to handle the site logo, and one to handle the footer information.

# context_processors.py
from myapp.models import SiteLogo, FooterInfo

def logo_context(request):
    logo = SiteLogo.objects.first()
    return {'logo': logo}

def footer_context(request):
    footer_info = FooterInfo.objects.first()
    return {'footer_info': footer_info}

In this example, we have defined two context processors:
logo_context and footer_context.

Each context processor imports the appropriate model (SiteLogo and FooterInfo in this case) and retrieves an instance of that model. The context processor then returns a dictionary containing the information that we want to make available to the template. In this case, the logo_context function returns a dictionary containing the logo information, and the footer_context function returns a dictionary containing the footer_info.

In the settings.py file, add the context_processors.py file to the context_processors list in the TEMPLATES section.

Once you have defined your context processors, you need to add them to the context_processors list in the TEMPLATES section of your settings.py file. The context_processors list should include the full Python path to your context processor function. In the example above, where the context processors are in context_processors.py and located in the utils folder within your project, the context_processors list in the settings.py file should look like this:

TEMPLATES = [
    {
        ...
        'OPTIONS': {
            'context_processors': [
                ...
                'utils.context_processors.logo_context',
                'utils.context_processors.footer_context',
            ],
        },
    },
]

Now you can access the logo and footer information in any template, without the need to include the code to fetch this information in every view.

You need to make sure that the function names is the same of that in the context_processors.py file.

With this setup, the logo and footer_info variables will be available in all of your templates, and you can use them to display the appropriate information on your website.

For example, you could use the logo variable to display the site logo in the header of your site and the footer_info variable to display the footer information on all pages of your site.

Additional information about context processors:

It is worth mentioning that context processors can also take additional arguments such as request user, session, etc.
For example, you can use the user object in the context processor and conditionally show or hide certain elements on the website based on user permissions and authentication.

In addition, if you are working with a large project or have multiple context processors, you can organize them in different files and different folders for better organization.

Another important thing to consider is the performance of your context processors. As context processors are called on every request, it's important to make sure that the code inside your context processors is optimized for performance. This may include caching or pre-fetching certain data to reduce the number of database queries.

Sum it up:

Finally, it is important to keep in mind that Django also provides a built-in context processor called django.template.context_processors.request, which adds the request object to the template context. This context processor is included by default and can be useful when you need access to the request object in your templates, so you can use the request object to retrieve information that is not available in your context processors

In summary, context processors are a powerful tool in Django that allows you to make information available to all templates, without having to repeat yourself. With context processors, you can define the code to fetch common information in one place and make it available to all templates, improving the maintainability and readability of your code. To start using context processors, you need to create a new folder inside your Django project, create a new file called context_processors.py and write the function that retrieves the relevant information. Finally, add the context processors to the context_processors list in the TEMPLATES section in your settings.py file.

Django Channels - Building Real-time Web Applications with Django

Sarah Hudaib — Wed, 18 Jan 2023 07:18:53 +0000

Django is a widely used web framework for building web applications with Python. However, it's built mainly for handling HTTP requests and responses in a synchronous manner. With the rise of real-time web applications such as online multiplayer games, chat applications, and real-time dashboards, Django developers faced challenges in building such applications. Django Channels came to the rescue, it's an extension to Django that enables developers to handle WebSockets and other real-time communication in a way that is familiar to Django developers.

What is Django Channels?

Django Channels is a powerful tool that allows developers to build asynchronous, real-time web applications using the popular Django framework.

Handling WebSockets with Channels

Channels allows you to handle WebSockets, chat protocols, and other types of real-time communication in a way that is familiar to Django developers. It works by creating a separate layer between Django's request-response cycle and the underlying transport layer. This allows Django to handle long-running connections, such as WebSockets, in addition to traditional HTTP requests.

Consumer-based Handling

One of the key features of Channels is its support for consumer-based handling of WebSockets. Consumers are Python classes that handle WebSocket connections, similar to how views handle HTTP requests in Django. They can be used to handle different types of messages and events, such as connecting, disconnecting, and sending messages. This allows for a more organized and modular approach to WebSocket handling.

Routing System

Channels also includes a built-in routing system, which allows you to specify which consumers should handle different types of messages and events. This routing system is similar to Django's URL routing system and allows for easy and flexible handling of different types of connections.

Other Real-time Communication

In addition to WebSockets, Channels also supports other types of real-time communication, such as HTTP/2 Server Push, and other protocols that can be layered on top of it.

Setting up Channels in your Django Project

To use Channels in your Django project, you need to install the Channels package and configure your Django project to use it. This involves adding a few lines of code to your project's settings.py file and creating a new routing file to handle WebSocket connections.

First, you need to install the Channels package by running the following command:

pip install channels

Next, you need to add the Channels layer to your Django project's settings.py file. You can do this by adding the following lines of code:

import os
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from .consumers import MyConsumer

application = ProtocolTypeRouter({
    'http': get_asgi_application(),
    'websocket': URLRouter(
        path('ws/my-path/', MyConsumer.as_asgi()),
    )
})

This code sets up the Channels layer and specifies the URL routing for WebSockets connections. In this example, all WebSocket connections to the URL path 'ws/my-path/' will be handled by the 'MyConsumer' class.

Next, you need to create a file called routing.py in your Django project's root folder and add the following code to it:

from django.urls import re_path
from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/my-path/$', consumers.MyConsumer.as_asgi()),
]

This code sets up the URL routing for the WebSocket connections. In this example, all WebSocket connections to the URL path 'ws/my-path/' will be handled by the 'MyConsumer' class.

Finally, you need to add the routing.py file to your project's main urls.py file:

from django.urls import path, include

urlpatterns = [
    path('', include('routing.websocket_urlpatterns')),
]

This code tells Django to use the URLs defined in the routing.py file for handling WebSocket connections.

That's it! Now you're ready to start handling WebSocket connections in your Django project using Channels.

To Sum it up:

Django Channels is a powerful tool that allows developers to build real-time, asynchronous web applications using the familiar Django framework. Its support for WebSockets, consumer-based handling, and built-in routing system make it easy to handle real-time communication in a modular and organized way.

With Django Channels, developers can now build real-time web applications such as chat applications, multiplayer games, and real-time dashboards with ease while still leveraging the power and simplicity of the Django framework. It's a great tool for any developer looking to build real-time web applications with Django.