The Power of Django Rest Framework: Streamline Your API Development

The Power of Django Rest Framework: Streamline Your API Development

Check out my previous blog about Django Best Practices: Tips for Writing Better Code.

Introduction

In today’s fast-paced world of web development, building robust and efficient APIs is crucial for creating successful web applications. Django Rest Framework (DRF) is a powerful toolkit that simplifies API development in Django, a popular Python web framework. With its comprehensive features and intuitive design, DRF empowers developers to streamline the process of building RESTful APIs.

In this blog, We’ll explore the power of Django Rest Framework and provide a step-by-step guide to help you get started.

What is Django Rest Framework?

Django Rest Framework is a powerful and flexible toolkit that extends Django’s capabilities to handle API development. It provides a set of tools and libraries that simplify common tasks such as serialization, authentication, and request handling. DRF follows the principles of Representational State Transfer (REST) and encourages the use of HTTP methods for (CRUD) creating, reading, updating, and deleting resources.

Advantages of Using Django Rest Framework

• Built-in support for serialization and deserialization of complex data types.
• Comprehensive authentication and authorization mechanisms.
• Robust request handling with support for various HTTP methods.
• Modular and reusable code with class-based views and viewsets.
• Extensive documentation and a large community for support and guidance.
• Seamless integration with Django ORM for database operations.
• Testability with built-in testing tools.

Prerequisites

Before diving into Django Rest Framework, it’s recommended to have a basic understanding of the following technologies:

Python: Django Rest Framework is built on top of Django, a Python web framework. Familiarity with Python programming language and its syntax is essential.

• Python Official Website: https://www.python.org/

[Note: Use Virtual Environment For Good. 👍 ]

Steps

1. Installation and Setup

To get started with Django Rest Framework, you need to have Django installed. Assuming you have a Django project set up, follow these steps to install DRF:

1. Open your terminal or command prompt.
2. Create a virtual environment (recommended) and Activate the virtual environment.
3. Install Django and Django Rest Framework using pip

pip install django djangorestframework

2. Creating a Basic API

Step 1: Create a Django project

Use the following command to create a new Django project:

django-admin startproject myproject

This will create a new Django project in a directory called myproject.

Step 2: Create a Django app

Use the following command to create a new Django application:

cd myproject
python manage.py startapp myapp

Step 3: Configure Django

Configure Django to Use Redis as the Cache Backend: Open your Django project’s settings.py file and write the following code :

# settings.py

INSTALLED_APPS = [
    # 👇 1. Add Django Rest Framework to installed apps
    'rest_framework',  
    'myapp',
]

# 👇 2. Add Django Rest Framework Configuration
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ],
}

Let’s break down these configuration settings:

1. INSTALLED_APPS: Add 'rest_framework' to the INSTALLED_APPS list to include Django Rest Framework in your project.
2. DEFAULT_PERMISSION_CLASSES: This setting defines the default permission classes applied to all API views. In the example above, it sets the default permission class to IsAuthenticated, which ensures that only authenticated users have access to the API endpoints. You can customize the permission classes based on your requirements.
3. DEFAULT_AUTHENTICATION_CLASSES: This setting specifies the default authentication classes for the API views. In the example above, it includes SessionAuthentication and TokenAuthentication. SessionAuthentication uses Django's session framework for authentication, while TokenAuthentication allowing authentication using tokens. You can choose the authentication classes that suit your application's needs.
4. DEFAULT_RENDERER_CLASSES: This setting determines the default renderer classes for API responses. In the example above, it includes JSONRenderer, which serializes data as JSON. You can add or customize renderer classes based on the desired response formats (e.g., XML, HTML).
5. DEFAULT_PARSER_CLASSES: This setting defines the default parser classes for parsing incoming API requests. In the example above, it includes JSONParser, which parses incoming requests with JSON data. You can add or modify parser classes as per your application's requirements.

These settings provide a basic configuration for Django Rest Framework. However, you can explore and adjust these settings based on your specific needs, such as adding additional authentication classes, pagination configurations, or content negotiation settings.

Remember to review the Django Rest Framework documentation for more detailed information on available settings and their usage: https://www.django-rest-framework.org/api-guide/settings/

Step 4: Add myapp URL

In this, For accessing our application myapp urls we have to add the following line to the myproject/urls.py file

from django.contrib import admin
from django.urls import path, include # 👈 1. add this 

urlpatterns = [
 
    path('admin/', admin.site.urls),

    # 👇 2. add this line too
    path('api/', include('myapp.urls')),

]

Step 5: Add Views URLs

In this, For accessing our views function urls. We have to add the following line to the myapp/urls.py file

Open the myapp folder and create a new file urls.py and write the following code:

from django.urls import path
from .views import TaskListCreateAPIView, TaskRetrieveUpdateDestroyAPIView

urlpatterns = [
    path('tasks/', TaskListCreateAPIView.as_view(), name='task-list-create'),
    path('tasks/<int:pk>/', TaskRetrieveUpdateDestroyAPIView.as_view(), name='task-retrieve-update-destroy'),
]

Step 6: Define Model

Define a Task model in your Django app’s models.py file.

Open models.py from myapp folder and write the below code:

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    completed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

In this, We are importing the models module from the django.db package. This module contains the necessary classes and utilities for defining database models in Django.

The code then defines a Task model by subclassing the models.Model class. A model in Django represents a database table and its associated fields. Each field in the model class corresponds to a column in the database table.

In this specific example, the Task model has the following fields:

• title: This field is defined as a CharField with a maximum length of 100 characters. It represents the title or name of the task.
• description: This field is defined as a TextField, which can hold a larger amount of text. It represents the description or details of the task.
• completed: This field is defined as a BooleanField with a default value of False. It represents whether the task is completed or not.
• created_at: This field is defined as a DateTimeField with the auto_now_add attribute set to True. It automatically sets the field's value to the current date and time when a new Task instance is created.

By defining the Task model in this way, Django will handle the creation and management of the corresponding database table. It also provides convenient methods and attributes for querying, updating, and deleting Task objects.

Step 7: Define Serializers

Create a serializer class in serializers.py that defines how the Task model should be serialized.

Create a new file serializers.py inside the myapp folder and write the following code:

from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    class Meta:
        model = Task
        fields = ['id', 'title', 'description', 'completed', 'created_at']

TaskSerializer class. This serializer is responsible for converting Task model instances to JSON representations and vice versa, facilitating data serialization and deserialization in Django Rest Framework.

• from rest_framework import serializers: This line imports the serializers module from the rest_framework package. The serializers module provides classes and utilities for defining serializers in Django Rest Framework.
• from .models import Task: This line imports the Task model from the current directory. It allows us to reference the Task model in our serializer.
• TaskSerializer(serializers.ModelSerializer): This class is a subclass of serializers.ModelSerializer, which provides a convenient way to create a serializer class that maps closely to a model. By extending this class, we inherit its functionality and can customize it further if needed.
• class Meta: The Meta class nested within the TaskSerializer class allows us to specify metadata options for the serializer.
• model = Task: This line specifies the model class that the serializer is associated with. In this case, it is the Task model we imported earlier.
• fields = ['id', 'title', 'description', 'completed', 'created_at']: This line specifies the fields that should be included in the serialized representation of a Task instance. Here, we have included the id, title, description, completed, and created_at fields. These fields will be serialized to JSON when the serializer is used to convert a Task object to a JSON representation.

The TaskSerializer class provides a straightforward way to define how a Task object should be serialized and deserialized in the API views. It maps the fields from the Task model to the corresponding JSON keys, making it easy to work with JSON data when interacting with the API endpoints.

Step 8: Views and Handling HTTP Requests

DRF provides class-based views to handle HTTP requests. Class-based views offer a powerful and flexible way to handle different HTTP methods.

In our example, we defined two views: TaskListCreateAPIView and TaskRetrieveUpdateDestroyAPIView. TaskListCreateAPIView handles the GET and POST methods for listing and creating tasks, while TaskRetrieveUpdateDestroyAPIView handles the GET, PUT, PATCH, and DELETE methods for retrieving, updating, and deleting individual tasks.

Open views.py from myapp folder and write the following code:

from rest_framework import generics, permissions
from .models import Task
from .serializers import TaskSerializer

class TaskListCreateAPIView(generics.ListCreateAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer    

class TaskRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer

• from rest_framework import generics, permissions: This line imports the generics module and the permissions module from the rest_framework package. These modules provide classes and utilities for creating API views and managing permissions in Django Rest Framework.
• from .models import Task: This line imports the Task model from the current directory (assuming the models.py file is in the same directory as this code). It allows us to use the Task model in our API views.
• from .serializers import TaskSerializer: This line imports the TaskSerializer class from the serializers module in the current directory. The serializer is responsible for converting model instances to JSON and vice versa, facilitating data serialization and deserialization in the API views.
• TaskListCreateAPIView: This class is a subclass of generics.ListCreateAPIView, which provides the basic implementation for a view that handles both list and create operations for a model. By extending this class, we inherit its functionality and can customize it further if needed.
• queryset = Task.objects.all(): This line sets the queryset attribute of the view to Task.objects.all(), which retrieves all Task objects from the database. This queryset will be used to fetch the data for the list operation.
• serializer_class = TaskSerializer: This line sets the serializer_class attribute of the view to TaskSerializer, which specifies the serializer to be used for serializing and deserializing the Task objects.
• TaskRetrieveUpdateDestroyAPIView: This class is a subclass of generics.RetrieveUpdateDestroyAPIView, which provides the implementation for retrieving, updating, and deleting a single model instance. Again, by extending this class, we inherit its functionality and can customize it further if needed.
• queryset = Task.objects.all(): This line sets the queryset attribute of the view to Task.objects.all(), which retrieves all Task objects from the database. This queryset will be used to fetch the data for the retrieve operation.
• serializer_class = TaskSerializer: This line sets the serializer_class attribute of the view to TaskSerializer, specifying the serializer to be used for serializing and deserializing the Task objects.

By defining these API view classes, we can handle different operations such as listing, creating, retrieving, updating, and deleting Task objects through the provided endpoints.

Note that the TaskSerializer class should be properly defined in the serializers module, and the Task model should be defined in the models module for this code to work correctly.

Step 9: Authentication and Permissions

DRF provides comprehensive authentication and authorization mechanisms to secure your API endpoints. It includes various authentication classes such as TokenAuthentication, SessionAuthentication, and JSONWebTokenAuthentication.

To enable authentication and permissions, you can modify the views.py file as follows:

from rest_framework import generics, permissions
from .models import Task
from .serializers import TaskSerializer

class TaskListCreateAPIView(generics.ListCreateAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer
    # 👇 1. Add this line for authentication
    permission_classes = [permissions.IsAuthenticated]

class TaskRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer
    # 👇 2. Add this line for authentication
    permission_classes = [permissions.IsAuthenticated]  

By adding permission_classes = [permissions.IsAuthenticated], we ensure that only authenticated users can access the API endpoints. You can customize the permissions as per your specific requirements.

These are just examples of how you can handle authentication and permissions using DRF. You can explore other authentication classes and create custom permission classes based on your application’s needs.

3. Running and Testing

I. To proceed, please open the terminal within the myproject folder and execute the following command:

python manage.py makemigrations
python manage.py migrate

The first part, python3 manage.py makemigrations, is used to create new database migration files based on any changes made to the models in your Django project. The migration files serve as a blueprint for applying and managing changes to the database schema.

The second part, python3 manage.py migrate, applies the generated migration files to the database, synchronizes the schema with the models, and updates the database structure accordingly.

By running these commands in the terminal, you ensure that any changes made to your Django models are properly reflected in the database, allowing you to work with the latest schema and data in your project.

II. To proceed, with creating an admin account and logging in to your Django application, execute the following command:

python manage.py createsuperuser

III. Now, Run the development server

This command starts the development server, allowing you to run your Django project locally.

python manage.py runserver

Once executed, you should see an output indicating that the server is running.

IV. Testing

Now, you can access your Django application by opening a web browser and entering the URL provided in the terminal output, typically http://127.0.0.1:8000/api/tasks . This will allow you to interact with your Django application and test its functionality.

To get started, Open any browser and visit http://127.0.0.1:8000/api/tasks/. It will display the following warning message because we have restricted access to this page.

It will display the following warning message because we have restricted access to this page

To proceed, you must first log in, and then the functionality will be available.

Now, visit http://127.0.0.1:8000/admin Enter your login credentials to access the Django admin panel.

Now, return to the home page at http://127.0.0.1:8000/api/tasks/. You will notice that the name of the admin is displayed in the top right corner. Additionally, the creation and listing options are functional.

To Create a Task, input the necessary information in the provided input boxes and create two tasks.

To List Tasks, click on the GET button, and it will display all the tasks.

To Retrieve a specific item, access http://127.0.0.1:8000/api/tasks/2 to view the second task’s data exclusively.

For Updating a Task, you will find input boxes below where you can modify the content. Click on the PUT button to save your changes.

To Delete a Task, simply click on the delete button, and it will remove the task.

Afterward, return to the home page at http://127.0.0.1:8000/api/tasks/. Only one task will be displayed.

We have successfully performed all the CRUD operations (Create, Retrieve, Update, and Delete) on the tasks.

For more detailed information on the endpoints, refer to the provided image below.

Task App Endpoints

Testing Task CRUD

Conclusion

Django Rest Framework empowers developers to streamline API development in Django. With its comprehensive features for serialization, view handling, authentication, and permissions, DRF provides a robust framework for building RESTful APIs. By following the step-by-step guide and leveraging the power of DRF, you can create efficient and secure APIs for your web applications. So, dive into Django Rest Framework and unlock the full potential of API development.

That’s it! Enjoy coding and exploring the capabilities of Django Rest Framework to streamline your API development.

Happy Coding!

Thank you for taking the time to read this blog about The Power of Django Rest Framework: Streamline Your API Development. I hope that you found the information presented here useful and informative.

If you have any questions or comments about the information presented in this blog, please feel free to reach out. Thank you again for reading!

Support my passion for sharing development knowledge by making a donation to Buy Me a Coffee. Your contribution helps me create valuable content and resources. Thank you for your support!

Resources

Home - Django REST framework

Django

Django Packages : Reusable apps, sites and tools directory for Django

Django Rest Framework - An Introduction - Real Python