DEV Community: kamalakannan

Django Rest Framework Tips and Tricks

kamalakannan — Mon, 28 Jun 2021 05:19:42 +0000

Original Post in https://skamalakannan.dev/posts/django-rest-framework-tips/

Django Rest Framework is a powerful tool for creating API, and it comes with a lot of features. Here is the list of tips that will help in developing your API better.

Sending common field in all the responses

We might have use cases where we want to send a lot in all our responses, like resource URI, create date, or created user kind of fields.We can use serializer mixins for this purpose. Mixins are abstract classes, and we can define all the variables in these mixins, and we can inherit these mixins to the actual class.


from user.serializers import UserMinimumSerializer

class CreatedModifiedSerializer(serializers.Serializer):
    created_date = serializers.DateTimeField(read_only=True)
    created_by = UserMinimumSerializer(read_only=True)
    modified_date = serializers.DateTimeField(read_only=True)
    modified_by = UserMinimumSerializer(read_only=True)

    class Meta:
        abstract = True

class OrderSerializer(CreatedModifiedSerializer):

    class Meta:
        model = Order
        fields = '__all__'

In the above example, we have created a CreatedModifiedSerializer as a mixin. It will get applied to the OrderSerializer, if the Order doesn't have any one of the fields declared in the mixin, we will receive an exception.

Return computed value from the model

if you have a scenario is to send the computed value. We can create a property for a model and specify the property name directly in the Serializer class.


class Order(models.Model):
    qty = models.IntegerField()
    price_per_qty = models.DecimalField(max_digits=5, decimal_places=2, default=0.0)

    @property 
    def total_amount(self):
        return self.qty * self.price_per_qty

class OrderSerializer(models.ModelSerializer):

    class Meta:
        model = Order
        fields = ('qty', 'price_pert_qty', 'total_amount') #Total amount is property of the model

Since the total_amount is a property, it will pick it directly. We can also declare the field type, specify as read-only, or result in an AttributeError exception.

Saving nested serializer

If we want to create or update a nested model relation. drf-writable-nested is a package that comes for rescue; it supports nested serializer both create and update operations. it also available supports for OneToOne, ForeignKey, ManyToMany.
https://github.com/beda-software/drf-writable-nested

from drf_writable_nested.serializers import WritableNestedModelSerializer
from rest_framework.serializers import ModelSerializer

class OrderItemSerializer(ModelSerializer):
    class Meta:
        model = OrderItems
        fields = '__all__'

class OrderSerializer(WritableNestedModelSerializer):
    items = OrderItemSerializer(many=True)

    class Meta:
        model = Order
        fields = '__all__'

Accept object id while create and update, return object through serializer

By default, DRF accepts and returns the field in the same format. If the use case is to accept the id update and create but return the serialized object. We can use PresentablePrimaryKeyRelatedField from the drf-extra-fields package for this purpose.
The custom field takes two arguments one is the queryset of the model, and another one presentation_serializer is a serializer class for the model.

from drf_extra_fields.relations import PresentablePrimaryKeyRelatedField
from rest_framework.serializers import ModelSerializer

class OrderSerializer(ModelSerializer):
    items = OrderItemSerializer(many=True)
    order_type = PresentablePrimaryKeyRelatedField(
        queryset = OrderType.objects.all(),
        presentation_serializer=OrderTypeSerializer
    )
    class Meta:
        model = Order
        fields = '__all__'

drf-extra-fields has many more custom fields, like Base64ImageField, it will accept a image file
as base64 encoded and will return as image file. please checkout the https://github.com/Hipo/drf-extra-fields for more information

Documenting Django Rest Framework API

kamalakannan — Tue, 19 Jan 2021 11:38:37 +0000

original post in https://skamalakannan.dev/posts/document-django-rest-framework-api/

Django Rest Framework (DRF) is a potent tool to create RESTful services with Django. Though it comes with a friendly UI interface to test API, it does not provide detailed documentation.

This post will go through how to document your DRF APIs using https://github.com/axnsan12/drf-yasg/
package.

drf-yasg is an easily pluggable tool and automatically the DRF APIs.
we will see how to document our various type of APIs,

Installation and configuration

we can install drf-yasg through

pip install -U drf-yasg

To add it to our project, we need to add drf_yasg to


in settings.py
- We need to configure the URLs for the API document, and the following code generates the document

schema_view = get_schema_view(
   openapi.Info(
      title="Snippets API",
      default_version='v1',
      description="Test description",
      terms_of_service="https://www.google.com/policies/terms/",
      contact=openapi.Contact(email="contact@snippets.local"),
      license=openapi.License(name="BSD License"),
   ),
   public=True,
   permission_classes=[permissions.AllowAny],
)

and in urls .py

url(
    r"^swagger(?P<format>\.json|\.yaml)$",
    schema_view.without_ui(cache_timeout=0),
    name="schema-json",
),
url(
    r"^swagger/$",
    schema_view.with_ui("swagger", cache_timeout=0),
    name="schema-swagger-ui",
),
url(
    r"^redoc/$", schema_view.with_ui("redoc", cache_timeout=0), 
    name="schema-redoc"
),

we have configured 3 urls for swagger documentations,

first one is with our UI, this returns the JSON document for all our APIs.
second one renders swagger ui for all APIs.
the last returns the api documentation in redoc format.

That's it. We have configured the swagger documentation for our APIS, drf-yasg
We can use the swagger_auto_schema decorator to customize the API document.

it accepts the following parameters,

method(s) - HTTP method the API handles; in case of multiple HTTP methods use methods, it's a method
operation_summary - brief description of the API
request_body - request body it can be a DRF serializer or openapi.schema
responses - response from the API similar to request_body; it can be DRF serializer or openapi. schema, we can specify different responses for different HTTP response codes Here the example for adding two numbers drf API,

from rest_framework.decorators import api_view
from rest_framework.response import Response
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from rest_framework import status
from rest_framework import serializers

class NumbersSerializer(serializers.Serializer):
    x = serializers.IntegerField()
    y = serializers.IntegerField()


@swagger_auto_schema(
    methods=['POST'],
    operation_summary="Sum of Two numbers",
    request_body = NumbersSerializer,
    responses={
        200: openapi.Schema(
            type=openapi.TYPE_INTEGER,
            title="s"
        )
    }
)
@api_view(['POST'])
def add_two_numbers(request):
    data = request.data
    serializer = NumbersSerializer(data=data)
    if serializer.is_valid():
        s = serializer.data['x'] + serializer.data['y']
        return Response({'sum': s}, status=status.HTTP_200_OK)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Schema - helps us specify the object
type - defines different kinds of values, array, object, string, number, integer, boolean, and file.
title - specify the name of the variable

code sample repo - https://github.com/srkama/drf_swagger_doc

Jenkins Pipeline with Python

kamalakannan — Tue, 29 Sep 2020 08:37:36 +0000

I want to share my experience in implementing the Jenkins pipeline. In this tutorial, we will implement the Jenkins CI/CD Pipeline for Python applications. We will be building a pipeline as code, aka Declarative pipeline.

Read the full post in https://skamalakannan.dev/posts/jenkins-pipeline-python/

Adding dynamic menus in Wagtail

kamalakannan — Mon, 10 Aug 2020 05:59:00 +0000

Adding dynamic menus in Wagtail

original post in https://skamalakannan.dev/posts/wagtailmenus/
I was experimenting with wagtail CMS (Content Management System) for quite some time for one of my projects. Wagtail is a Django based CMS, which providers powerful features in building a website. In this post, I'm going to explain how we can build dynamic menus in the Wagtail website.

Read here: https://skamalakannan.dev/posts/wagtailmenus/

aerich migration package for Tortoise ORM

kamalakannan — Sat, 08 Aug 2020 11:18:35 +0000

Aerich a migration module for Tortoise ORM

original post in https://skamalakannan.dev/posts/aerich-tortoise-migration/

Async programming is getting more popular with Python in recent years. From Python 3.4, we have native async support. Currently, there are not many ORMs (Object Relation Mappers) that support async. One such notable ORM is Tortoise ORM. But it does not support migration features.

aerich package adds migrations support to Tortoise ORM. It works well with MySQL. I am yet to test with SQLite and PostgreSQL, will check and post findings.

We need Tortoise ORM version > 16.2 or above for aerich.

How it works

aerich maintains old_models.py file to which keeps tracks of last changes. Old models and current models compared, and if there are changes, respective SQL commands will be for upgrading and reverting.

aerich can be installed through pip

pip install aerich

Configuring aerich in the application pretty easy. we need to configure the TortoiseORM models.

We need to add "aerich.models" in Tortoise ORM configuration dict. It will create a table called aerich to capture the history of migrations.

TORTOISE_ORM = {
        "connections": {
            "default": "mysql://user:test_pwd@localhost:3306/communication?charset=utf8mb4"
            },
        "apps": {
            "models": {
                "models": ["app.models", "aerich.models"],
                "default_connection": "default",
            },
        }
    }

We can initiate aerich with the below command and it will initiate migrations for the application.

    aerich init -t settings.TORTOISE_ORM

* *aerich.ini* -  config file maintains aerich configurations.
* *migrations folder* - to capture all migrations.

To create initial migration files, the below creates initial migrations if not exists.

   aerich init-db

* It creates JSON file with timestamp with initial SQL commands and 
* old_models.py - keeps tracks last applied changes.

The module provides the following commands.

migrate - compares the current models with old models and creates SQL query commands.
upgrade - applies all unapplied migrations to the database.
downgrade - reverts the last applied migrations.
history - lists all applied migrations.
heads - list unapplied migrations

to clear all migrations,

truncate the aerich table
remove models folder under migrations.

aerich is a promising module for tortoise ORM.