DEV Community: Shivam Rohilla

Judiro AI: India’s Smart Legal AI for Lawyers, Advocates & Legal Professionals | Using DjangoRestFramework & Tailwind CSS

Shivam Rohilla — Tue, 20 Jan 2026 20:39:27 +0000

The Indian legal ecosystem is evolving fast — and AI is no longer optional.

Meet Judiro AI, a next-gen Legal AI platform built for Indian lawyers, advocates, and law firms.

Judiro AI is designed to help legal professionals draft faster, research smarter, and work efficiently using Artificial Intelligence.

🔍 What is Judiro AI?

Judiro AI is an AI-powered legal assistant built using modern backend architecture (Django Rest Framework) and a fast, responsive frontend (Tailwind CSS), optimized for performance, scalability, and real-world legal use cases.

If you’re searching for:
• Legal AI in India
• AI Lawyer platform
• AI Advocate tools
• AI for legal drafting
• Indian legal AI software

👉 Judiro AI is built exactly for that.

⸻

🧠 How Judiro AI Helps Lawyers & Advocates

Judiro AI assists legal professionals in:
• AI Legal Drafting (NDAs, Agreements, Legal Notices, Contracts)
• Clause generation & improvement
• Legal language correction
• Time-saving document automation
• AI-powered legal assistance for Indian law

Unlike generic AI tools, Judiro AI focuses on Indian legal workflows, making it practical for advocates, law firms, and legal startups.

⸻

⚙️ Technology Behind Judiro AI

Judiro AI is built with a modern, scalable tech stack:
• Django Rest Framework (DRF) for secure and scalable APIs
• Tailwind CSS for fast, clean, and responsive UI
• AI models for legal reasoning, drafting assistance, and productivity

This ensures:
• Fast response times
• Secure handling of legal data
• Scalable architecture for future legal AI features

⸻

🇮🇳 Built for Indian Legal System

Most AI lawyer tools are global and generic.
Judiro AI is different.

It is built keeping in mind:
• Indian legal terminology
• Advocate workflows
• Indian contracts & agreements
• Practical use cases for Indian courts & law firms

If you are an Indian advocate looking for an AI legal assistant, Judiro AI is built for you.

⸻

🚀 Why Judiro AI Matters

Lawyers don’t need replacement.
They need leverage.

Judiro AI helps advocates:
• Save drafting time
• Reduce repetitive work
• Focus on strategy, clients, and court work

AI doesn’t replace lawyers —
AI empowers lawyers who use it early.

Legal AI
AI Lawyer India
AI Advocate
Legal AI India
AI for Lawyers
AI Legal Drafting
Indian Legal AI
Judiro AI

How to store users location in django using GeoDjango

Shivam Rohilla — Wed, 31 Jan 2024 09:19:02 +0000

Hello devs, In this blog we'll learn about storing user location in django with the longitude and latitude and for that we will use GeoDjango, Django provides a framework called GeoDjango, and with the help of GeoDjango we can store the user location parameters (Latitude and Longitude), and point the user location on map in django admin.

So, basically I'm storing the user location and the parameter in django while signup or user creation, and with the help of that we can know the user exact location.

and for storing the user location with django, we are using Postgresql database, which provides postgis extension, and supports the user location functionality, and I'm using Mac, so, please manage the Postgis path and extension according to your OS, so let's start code now:-

Post link for source code



How To Store Users Location In Django Using Geodjango pythondjangogeek.com

Geo Django and Postgresql Installation



brew install postgres
brew install postgis

download the postgres app from this link:-



https://postgresapp.com/downloads.html

Installing Geospatial Libraries



brew install gdal
brew install geos
brew install libgeoip

add library path in django setting.py file



GDAL_LIBRARY_PATH = '/opt/homebrew/Cellar/gdal/3.8.3/lib/libgdal.dylib'
GEOS_LIBRARY_PATH = '/opt/homebrew/Cellar/geos/3.12.1/lib/libgeos_c.dylib'

Setting up Django project



django-admin startproject userlocation

and now mention postgis in settings.py



INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.gis',
    'rest_framework.authtoken',
    'rest_framework',
    'users'
]

Now, we will create models.py



from django.contrib.auth.models import User
from django.contrib.gis.db import models


class Customer(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='user_profile')
    name = models.CharField(max_length=100)
    location = models.PointField(blank=True, null=True)
    longitude = models.FloatField()
    latitude = models.FloatField()

    def __str__(self):
        return self.name

ww'll store user longitude and latitude and also location with the PointField, this field will show the map on Django admin like this:-

Admin.py file



from django.contrib import admin
from .models import Customer
from django.contrib.gis.admin import OSMGeoAdmin


@admin.register(Customer)
class CustomerAdmin(OSMGeoAdmin):
    list_display = ['id', 'name', 'user', 'location', 'longitude', 'latitude']
    search_fields = ['name', 'user__username']

Serializers.py file



from rest_framework import serializers
from django.contrib.auth.models import User
from .models import Customer

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['username', 'password', 'email']

class CustomerSerializer(serializers.ModelSerializer):
    user = UserSerializer()

    class Meta:
        model = Customer
        fields = ['id', 'user', 'name', 'location', 'longitude', 'latitude']

Views.py file



from rest_framework import generics
from rest_framework.response import Response
from rest_framework import status
from django.contrib.auth.models import User
from django.contrib.auth import authenticate, login
from rest_framework.authtoken.models import Token
from django.contrib.gis.geos import Point
from .models import Customer
from .serializers import CustomerSerializer, UserSerializer

class CustomerListCreateView(generics.ListCreateAPIView):
    queryset = Customer.objects.all()
    serializer_class = CustomerSerializer

    def create(self, request, *args, **kwargs):
        user_serializer = UserSerializer(data=request.data.get('user'))
        customer_serializer = self.get_serializer(data=request.data)

        user_serializer.is_valid(raise_exception=True)
        customer_serializer.is_valid(raise_exception=True)

        # Create User instance
        user = User.objects.create_user(**user_serializer.validated_data)

        # Extract latitude and longitude from the request data
        latitude = request.data.get('latitude', None)
        longitude = request.data.get('longitude', None)

        # Check if both latitude and longitude are present
        if latitude is not None and longitude is not None:
            # Create a Point object with the given latitude and longitude
            location = Point(float(longitude), float(latitude))
            customer_serializer.validated_data['location'] = location

        # Create Customer instance
        customer_serializer.validated_data['user'] = user
        self.perform_create(customer_serializer)

        # Create and return token
        token, created = Token.objects.get_or_create(user=user)


        headers = self.get_success_headers(customer_serializer.data)
        return Response({'token': token.key, **customer_serializer.data}, status=status.HTTP_201_CREATED, headers=headers)

class CustomerDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Customer.objects.all()
    serializer_class = CustomerSerializer

class UserLoginView(generics.CreateAPIView):
    serializer_class = UserSerializer

    def create(self, request, *args, **kwargs):
        username = request.data.get('username', '')
        password = request.data.get('password', '')

        user = authenticate(request, username=username, password=password)

        if user is not None:
            login(request, user)
            token, created = Token.objects.get_or_create(user=user)
            serializer = UserSerializer(user)
            return Response({'token': token.key, **serializer.data})
        else:
            return Response({'detail': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)

URLs.py file



from django.urls import path
from .views import CustomerListCreateView, CustomerDetailView, UserLoginView

urlpatterns = [
    path('customers/', CustomerListCreateView.as_view(), name='customer-list-create'),
    path('customers/<int:pk>/', CustomerDetailView.as_view(), name='customer-detail'),
    path('login/', UserLoginView.as_view(), name='user-login'),
]

so, that's how you can implement the user location in django using GeoDjango, and you can connect with me.

Thank You.
Shivam Rohilla | Python Developer

How to use Redis in Django to optimize Your Django Performance

Shivam Rohilla — Fri, 13 Oct 2023 07:38:19 +0000

Hello Devs, In this Post we'll learn about Redis and Django, Redis and Django combination is awesome if your Api's are slow and not responding or your server is showing 502 error.

Post Link:- https://pythondjangogeek.com/django/how-to-use-redis-in-django-to-optimize-your-django/
Linkedin:- https://www.linkedin.com/in/shivamrohillaa/
Github Link:- https://github.com/ShivamRohilllaa/django-redis

So, let's talk about Redis

Redis is fast and basically it's a storage system, which stores your data and set all the data in cache.
and then you can retrieve your data through the cache.

How Redis Boosts Django Performance

we use Redis with Django, when our api's are slows down due to multiple database queries. then we use caching to store the data and access the data frequently, when your data is set in redis, you just have to call the cache function(I'll explain in code below), and that cache function returns the data without hit the database, it's a one time process, it hits the database while set the cache or when we store the data in cache. and that's how redis speed up the api's or django queries, and it reduce the database load, and it's fast.

Using Redis with Django: A Step-by-Step Guide

So, now we'll learn how to use redis with django for optimization.
We'll test redis with 10k+ objects.

So, first of all download Redis:-

Download Redis
Redis for 64-bit Windows from this GitHub page: https://github.com/MicrosoftArchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.msi

and after installing this, Go to your installed directory and run the redis-cli

and now we start our django project, I hope you guys know how to create a django project and django app.

Now, add redis configuration in django settings.py


CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',  # Replace with your Redis server details
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}

now create a model in models.py file,

class Post(models.Model):
    title = models.CharField(max_length=250)
    description = models.TextField()

    def __str__(self):
        return self.title

and add some objects and run script for adding duplicate data in the model, now we write main logic for the redis for set the cache and get the cache,

from django.shortcuts import render
from post.models import Post
from django.core.cache import cache
from django.http import HttpResponse

# Create your views here.

def home(request):
    qs = Post.objects.all()
    context = {'qs':qs}
    return render(request, 'index.html', context)

def set_data_in_cache(request):
    # Retrieve the data you want to cache
    qs = Post.objects.all()

    # Set the data in the Redis cache
    cache.set('post_data_key', qs)

    return HttpResponse("Data has been set in the cache.")

def get_data_from_cache(request):
    # Get the data from the Redis cache
    cached_data = cache.get('post_data_key')
    print(cached_data, 'cached_data')

    if cached_data is not None:
        # If data is found in the cache, you can use it as needed
        return render(request, 'redis_data.html', {'qs': cached_data})
    else:
        # If data is not found in the cache, you may choose to retrieve it from the database
        qs = Post.objects.all()
        return render(request, 'index.html', {'qs': qs})

we use two function for set and get the cache in redis, and that's so simple and easy,

for set the cache we use:- cache.set('post_data_key') for get the cache we use:- cache.get('post_data_key')`

and we set the Post model data in redis cache key and then we fetch the data from the cache key which you set in redis, and there's one more thing and that is timeout, if you want to expire your cache key so you can add the timeout while setting the cache key, you can use timeout=20 or any number, and if you don't want to expire your key, then use timeout=None, so that's how we can optimize our django app with the use of Redis.

Thank You
Shivam Rohilla | Python Developer

How to create a CRUD API in Django Rest Framework with APIView, ViewSets, and Swagger Documentation

Shivam Rohilla — Sun, 06 Aug 2023 18:04:45 +0000

Are you looking to develop a robust CRUD (Create, Read, Update, Delete) API in Django Rest Framework? In this blog post, we'll guide you through the process of building a CRUD API using both APIView and ViewSets, and we'll enhance it with Swagger documentation for easy API exploration and testing.

Django Rest Framework (DRF) is a powerful toolkit for building Web APIs in Django. It provides a flexible and easy-to-use framework for creating RESTful APIs with features like authentication, serialization, and request/response handling. We'll utilize two different approaches offered by DRF to build our CRUD API.

APIViews:

APIViews in DRF allow us to define the API logic as class-based views. We'll create an APIView-based class that handles the different HTTP methods (GET, POST, PUT, DELETE) to perform the respective CRUD operations. With the help of the swagger_auto_schema decorator, we'll also add detailed Swagger annotations for request and response descriptions.

from rest_framework import status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.views import APIView
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelAPIView(APIView):
    @swagger_auto_schema(
        operation_description="Get all models",
        responses={200: MyModelSerializer(many=True)}
    )
    def get(self, request):
        queryset = MyModel.objects.all()
        serializer = MyModelSerializer(queryset, many=True)
        return Response(serializer.data)

    @swagger_auto_schema(
        operation_description="Create a new model",
        request_body=MyModelSerializer,
        responses={201: MyModelSerializer()}
    )
    def post(self, request):
        serializer = MyModelSerializer(data=request.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)

    @swagger_auto_schema(
        operation_description="Update a model",
        request_body=MyModelSerializer,
        responses={200: MyModelSerializer()}
    )
    def put(self, request, pk):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        serializer = MyModelSerializer(instance, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    @swagger_auto_schema(
        operation_description="Delete a model"
    )
    def delete(self, request, pk):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        instance.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

ViewSets:

ViewSets in DRF provide a higher-level abstraction for building APIs. We'll create a ViewSet-based class that encapsulates the logic for handling different actions like list, create, retrieve, update, and delete. By registering the ViewSet with a router, we'll automatically generate the URL patterns for our API. Similar to the APIView approach, we'll use the swagger_auto_schema decorator to add Swagger annotations for clear API documentation.

from rest_framework import status
from rest_framework.response import Response
from rest_framework.viewsets import ViewSet
from rest_framework.decorators import action
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelViewSet(ViewSet):
    @swagger_auto_schema(
        operation_description="Get all models",
        responses={200: MyModelSerializer(many=True)}
    )
    def list(self, request):
        queryset = MyModel.objects.all()
        serializer = MyModelSerializer(queryset, many=True)
        return Response(serializer.data)

    @swagger_auto_schema(
        operation_description="Create a new model",
        request_body=MyModelSerializer,
        responses={201: MyModelSerializer()}
    )
    def create(self, request):
        serializer = MyModelSerializer(data=request.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)

    @swagger_auto_schema(
        operation_description="Get a model by ID",
        responses={200: MyModelSerializer()}
    )
    def retrieve(self, request, pk=None):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        serializer = MyModelSerializer(instance)
        return Response(serializer.data)

    @swagger_auto_schema(
        operation_description="Update a model",
        request_body=MyModelSerializer,
        responses={200: MyModelSerializer()}
    )
    def update(self, request, pk=None):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        serializer = MyModelSerializer(instance, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    @swagger_auto_schema(
        operation_description="Delete a model"
    )
    def destroy(self, request, pk=None):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        instance.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

    @swagger_auto_schema(
        operation_description="Custom action",
        responses={200: "Custom action executed"}
    )
    @action(detail=True, methods=['post'])
    def custom_action(self, request, pk=None):
        try:
            instance = MyModel.objects.get(pk=pk)
        except MyModel.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)

        # Perform custom action here

        return Response("Custom action executed", status=status.HTTP_200_OK)

Swagger Documentation:

Swagger is an open-source toolset for designing, building, documenting, and consuming RESTful APIs. By incorporating Swagger into our DRF project, we can generate interactive API documentation that allows developers to explore and test the API endpoints effortlessly. We'll use the drf-yasg package, which integrates Swagger with DRF, to automatically generate the API documentation based on the Swagger annotations we added.

To install drf-yasg, run the following command:

pip install drf-yasg

Once installed, you can configure Swagger in your project's urls.py file as follows:

from django.urls import path, include
from rest_framework import routers
from .views import MyModelViewSet, MyModelAPIView
from drf_yasg.views import get_schema_view
from drf_yasg import openapi

router = routers.DefaultRouter()
router.register(r'models', MyModelViewSet)

schema_view = get_schema_view(
    openapi.Info(
        title="Your API",
        default_version='v1',
        description="API documentation powered by Swagger",
        terms_of_service="https://your-terms-of-service-url.com/",
        contact=openapi.Contact(email="contact@your-api.com"),
        license=openapi.License(name="Your API License"),
    ),
    public=True,
)

urlpatterns = [
    path('', include(router.urls)),
    path('api-docs/', schema_view.with_ui('swagger', cache_timeout=0), name='api-docs'),
    # Other paths in your URL configuration
]

In this tutorial, we've covered the basics of building a CRUD API using both APIView and ViewSets in Django Rest Framework. We've also learned how to enhance the API documentation using Swagger and the drf-yasg package. By following this guide, you can create a powerful and well-documented API that adheres to RESTful principles and provides a seamless experience for developers consuming your API.

Stay tuned for more Django Rest Framework tutorials and explore the limitless possibilities of building robust and scalable APIs with Django!

Shivam Rohilla | Python Developer
Thank You

How to Send Emails in Django: A Step-by-Step Guide

Shivam Rohilla — Fri, 20 Jan 2023 18:33:40 +0000

Django is a popular web framework for building web applications in Python. One of the common tasks when building web applications is sending emails. In this blog post, we will learn how to send emails in Django.

First, we need to configure the email settings in the settings.py file. We can use the built-in EmailBackend or use an external service like Gmail or Amazon SES. Here's an example of how to configure the email settings using the built-in EmailBackend:

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = 'your_email@gmail.com'
EMAIL_HOST_PASSWORD = 'your_password'

Once the email settings are configured, we can use the built-in send_mail function to send emails. Here's an example of how to use the send_mail function:

from django.core.mail import send_mail

send_mail(
    'Subject',
    'Here is the message.',
    'from@example.com',
    ['to@example.com'],
    fail_silently=False,
)

The send_mail function takes five arguments:

Subject: The subject of the email.
Message: The message of the email.
From email: The email address of the sender.
List of recipient emails: A list of email addresses of the recipients.
fail_silently: A boolean value that indicates whether to raise an exception if the email fails to send.
You can also use the EmailMessage class to create more advanced emails with multiple recipients, cc, bcc, attachments and headers.

from django.core.mail import EmailMessage

email = EmailMessage(
    'Hello',
    'Body goes here',
    'from@example.com',
    ['first@example.com', 'second@example.com'],
    ['bcc@example.com'],
    reply_to=['another@example.com'],
    headers={'Message-ID': 'foo'},
)

email.send()

That's it! With these simple steps, you can send emails in Django. You can also use other libraries like Celery to handle sending emails asynchronously.

Thank You
Shivam Rohilla | Python Developer

Create a CRUD API in four steps using DjangoRestFramework.

Shivam Rohilla — Tue, 03 Jan 2023 20:43:02 +0000

DjangoRestFramework (DRF) is a powerful toolkit for building APIs in the Django web framework. It provides a set of tools and libraries for building APIs, including serialization, validation, authentication, and more. DRF is designed to make it easy for developers to create APIs that can be consumed by a variety of clients, including web and mobile applications. With DRF, developers can build APIs that support CRUD (create, read, update, delete) operations, as well as custom endpoints for specific functionality. Overall, DRF is a popular choice for building APIs in Django due to its flexibility and ease of use.

Post link:- 

https://pythondjangogeek.com/django/create-a-crud-api-in-four-steps-using-djangorestfr/

CRUD API, or Create, Read, Update, and Delete API, allows developers to create an API that performs basic database operations. In this blog, we will go through the steps of creating a CRUD API using DjangoRestFramework in four simple steps.

Setup Django and Django Rest Framework:

First, make sure you have Django and Django Rest Framework installed on your machine. If you don't have them installed, you can install them using pip:

pip install django
pip install djangorestframework

Once you have them installed, create a new Django project and app:

django-admin startproject myproject
cd myproject
python manage.py startapp myapp

Create a Model:
In this step, we will create a model that represents the object that we want to store in our API. For example, let's say we want to store a list of tasks. We can create a Task model with the following fields:

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    completed = models.BooleanField(default=False)

Create a Serializer and a View:

Next, we need to create a serializer and a view to handle the incoming HTTP requests. A serializer is used to convert the data in our model into a JSON format that can be sent over the internet.

from rest_framework import serializers
from .models import Task

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

The view will handle the incoming HTTP requests and return a response. We can create a view using Django Rest Framework's generic views:

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

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

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

Create a URL pattern:
Finally, we need to create a URL pattern that maps the incoming HTTP requests to our view. Add the following to your urls.py file:

from django.urls import path
from . import views

urlpatterns = [
    path('tasks/', views.TaskList.as_view(), name='task_list'),
    path('tasks/<int:pk>/', views.TaskDetail.as_view(), name='task_detail'),
]

That's it! With these four steps, you have created a CRUD API using Django Rest Framework. You can test your API using a tool
like Postman or by making HTTP requests using Python's requests library.

Shivam Rohilla | Python Developer
Thank You

How to work with Django forms.

Shivam Rohilla — Sat, 28 May 2022 12:48:43 +0000

Hello guys, today we'll learn how to work with django forms, as we know that we use django forms to save data in the models, django forms generate the HTML Forms to save the data, django provides the Form class that is used to generate html form.

Source code:- https://github.com/ShivamRohilllaa/django-form

So, now we are creating a django form, in forms.py

from django import forms

class TaskForm(forms.Form):
    Title = forms.CharField(max_length = 200)
    description = forms.TextField(max_length = 500)

now write a view for saving the data.

from django.shortcuts import render, redirect
from .forms import TaskForm
from .models import Task
# Create your views here.

def index(request):
    tform = TaskForm()
    if request.method == 'POST':
        form = TaskForm(request.POST)
        if form.is_valid():
            title = form.cleaned_data['title']
            description = form.cleaned_data['description']
            data = Task.objects.create(title=title, description=description)     
    context = {'form':tform}              
    return render(request, 'index.html', context)

then render this form in index.html

    <form method='POST'>
    {% csrf_token %}    
    {{form}}
    <button class="btn" type="submit" value="submit"> Save </button>
    </form>

See the output below and fill the data in form and then press save button after that check the django admin if data is saved or not.

Output

For More and contact:- https://webdevcodes.com/django/how-to-work-with-django-forms/

Thank You
Shivam Rohilla | Python Developer

User Authentication in DjangoRestFramework using SimpleJWT [Login, Signup]

Shivam Rohilla — Tue, 22 Mar 2022 09:24:05 +0000

Hello Devs, In this blog you will learn how to create User Authentication, login and signup API's in djangorestframework using SimpleJWT.

Source Code:- https://github.com/ShivamRohilllaa/DjangoRestFramework-UserAuthentication/

Post Link:- https://pythondjangogeek.com/django/streamlined-user-authentication-with-django-and-si/

I hope you guys knows how to create a django project so I am skipping those steps and let's jump on code directly.

Create virtual enviornment,

python3 -m venv envname

Install these packages:-

django
djangorestframework
djangorestframework-simplejwt

Add restframework in your installed apps in settings.py file:

INSTALLED_APPS = [
    'rest_framework',
]

and add these settings for rest_framework and simpleJWT.

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    )
}    

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(days=15),
    'AUTH_HEADER_TYPES': ('Bearer',),
    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
}

Create Model for a student

class Student(models.Model):
    auth = models.OneToOneField(User, on_delete=models.CASCADE, related_name='student_profile')
    name = models.CharField(max_length=100)
    email = models.EmailField(max_length=100)

    def __str__(self):
        return self.name

and now we will create user signup and user profile serializers for signup and login

from rest_framework import serializers
from userapp.models import Student
from django.contrib.auth.models import User

class UserSignupSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('first_name', 'last_name', 'email', 'password')

    extra_kwargs = {
        'first_name': {'required': True, 'allow_blank': False},
        'last_name': {'required': True, 'allow_blank': False},
        'email': {'required': True, 'allow_blank': False},
        'password': {'required': True, 'allow_blank': False},        
    }    


class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('id', 'first_name', 'last_name', 'email', 'username')

now write views for utilise the serializers

from django.shortcuts import render
from .models import Student
from .serializers import UserSignupSerializer, UserSerializer
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User

@api_view(['POST'])
def signup(request):
    data = request.data
    serializer = UserSignupSerializer(data=data)
    if serializer.is_valid():
        if not User.objects.filter(username=data['email']).exists():
            user = User.objects.create(first_name=data['first_name'], last_name=data['last_name'], username=data['email'], email=data['email'], password=make_password(data['password']))
            user.save()
            student = Student.objects.create(auth=user, name=data['first_name'], email=data['email'])
            return Response({'message':'User Created Successfully'}, status=status.HTTP_201_CREATED)
        else:
            return Response({'message':'User Already Exists'}, status=status.HTTP_400_BAD_REQUEST)
    else:
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(['GET'])
def login(request):
    data = request.data
    if User.objects.filter(username=data['email']).exists():
        user = User.objects.get(username=data['email'])
        if user.check_password(data['password']):
            return Response(UserSerializer(instance=user).data, status=status.HTTP_200_OK)
        else:
            return Response({'message':'Invalid Password'}, status=status.HTTP_400_BAD_REQUEST)
    else:
        return Response({'message':'User Does Not Exist'}, status=status.HTTP_400_BAD_REQUEST)

Now map these views in urls.py

urlpatterns = [
    path('signup/', views.signup, name='signup'),
    path('login/', views.login, name='login'),

and for testing these endpoints use postman and pass these responses

for singup api

{
"first_name": "demo",
"last_name": "demo",
"email": "demo@gmail.com",
"password": "demo"
}

for login

{
"email": "demo@gmail.com",
"password": "demo"
}

Source Code

Source Code:- https://github.com/ShivamRohilllaa/DjangoRestFramework-UserAuthentication/

Thank You
Shivam Rohilla | Python Developer

DM me your queries:-
https://www.linkedin.com/in/shivamrohillaa/

How to make a Rock Paper Scissors game in Django

Shivam Rohilla — Fri, 14 Jan 2022 18:02:12 +0000

Hello Devs,
In this Post I'm gonna show you how to make a rock paper scissors game in Django using Python logic.

Original Post / For More:-

https://www.webdevcodes.com/python/how-to-make-a-rock-paper-scissors-game-in-django/

Here's a Github Repo and Source Code, Live demo

https://github.com/ShivamRohilllaa/rock-paper-scissors

Live demo

https://stonepsgame.herokuapp.com/

I hope you know how to create a django project directory and base and how to create apps, so I'm going to point straightly.

So, we are gonna create following things in the project

1) Start Game / Create User
2) Game Page
3) Messages
4) Result / Store user result
5) End Game

So, now let's create models in models.py

from django.contrib.auth.models import User

class Player(models.Model):
    '''
    Player model 
    '''
    name = models.CharField(max_length=50)
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='player')

    def __str__(self):
        return self.name


class Result(models.Model):
    '''
    Result model in which all players result will be stored
    '''
    player = models.ForeignKey("Player", on_delete=models.CASCADE, related_name='score')
    bot_move = models.CharField(max_length=50, blank=True)
    user_move = models.CharField(max_length=50, blank=True)
    status = models.CharField(max_length=50, blank=True)

    def __str__(self):
        return 'Status -- ' + self.status + ' ' + self.player.name

Run these commands


python manage.py makemigrations
python manage.py migrate

Now we will create user on home page and take input from user and stored in our database.

So let's create views


def home(request):
    '''
    homepage and start game logic
    '''
    if request.method=='POST':
        playername = request.POST.get('name')
        if User.objects.filter(username__iexact=playername):
            messages.warning(request, 'This name is already exists, please try another one.')
            return HttpResponseRedirect(request.path_info)
        create_user = User.objects.create(first_name=playername, username=playername)
        create_player = Player.objects.create(name=playername, user=create_user)
        return redirect('start_game')

    return render(request, 'index.html')

In the above code, we store username from form and will create user objects from form input and if someone is already entered a username so it will show error message.

and here's a Python simple logic for game and learn how to implement python logic in django.
we make a list and store rock paper and scissors move in list and then make a bot using python random library so we can play against a bot. and when we play a move we will see a message and that message is implemented using django messages framework.

def game(request):
    '''
    Rock, paper and scissor logic
    '''
    gamelist = ['rock', 'paper', 'scissors']
    bot_action = random.choice(gamelist)
    user = Player.objects.all().last()

    if request.method == 'POST':
        user_answer = request.POST.get('name')

        if user_answer == bot_action:
            messages.info(request, f"Both players selected. It's a tie!")
            result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Tie')
            log.debug("Both players selected. It's a tie!")

        elif user_answer == "rock":
            if bot_action == "scissors":
                messages.success(request, "Rock smashes scissors! You win!")
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Win')
                log.debug(f"Rock smashes scissors! You win! - Actions: Bot - {bot_action} User - {user_answer}")
            else:
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Lose')
                messages.info(request, "Paper covers rock! You lose.")
                log.debug(f"Paper covers rock! You lose. Actions: Bot - {bot_action} User - {user_answer}" )

        elif user_answer == "paper":
            if bot_action == "rock":
                messages.success(request, "Paper covers rock! You win!")
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Win')
                log.debug(f"Paper covers rock! You win! Actions: Bot - {bot_action} User - {user_answer}")
            else:
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Lose')
                messages.info(request, "Scissors cuts paper! You lose.")
                log.debug(f"Scissors cuts paper! You lose. Actions: Bot - {bot_action} User - {user_answer}")

        elif user_answer == "scissors":
            if bot_action == "paper":
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Win')
                messages.success(request, "Scissors cuts paper! You win!")
                log.debug(f"Scissors cuts paper! You win! Actions: Bot - {bot_action} User - {user_answer}")
            else:
                result = Result.objects.create(player=user, bot_move=bot_action, user_move=user_answer, status='Lose')
                messages.info(request, "Rock smashes scissors! You lose.")
                log.debug(f"Rock smashes scissors! You lose. Actions: Bot - {bot_action} User - {user_answer}")

    return render(request, 'game.html', {'user':user})

here's a result page in which you can see your result for every move.

def result(request):
    '''
    All users results
    '''
    res = Result.objects.all().order_by('-id')
    context = {'res':res}
    return render(request, 'result.html', context)

Now define views urls path in urls.py

urlpatterns = [
    path('', views.home, name='home'),
    path('start-game/', views.game, name='start_game'),
    path('result/', views.result, name='result'),
]

Here's a Github Repo and Source Code, Live demo

https://github.com/ShivamRohilllaa/rock-paper-scissors

Live demo

https://stonepsgame.herokuapp.com/

Here's images of Project

Django Formset: Submit two django forms at once.

Shivam Rohilla — Sat, 25 Dec 2021 10:51:35 +0000

Hello Devs, In this Post I'm gonna show you how can we submit two django forms at once and this is also called django inline forms, for example I have two forms one is for Question and another one is for Answers, and I want a inline form, like one question and that question have four answers, ok so let's see how can we do that.

Source Code:- 
https://github.com/ShivamRohilllaa/django-formset

Original Post:- https://www.webdevcodes.com/django/django-formset-submit-two-django-forms-at-once/

First of all create two tables in models.py:

class Question(models.Model):
    text = models.CharField(max_length=200, unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return str(self.text)

    #Reverse relationship
    def get_answers(self):
        return self.answers.all()   

class Answer(models.Model):
    text = models.CharField(max_length=200, verbose_name='Answer')
    correct = models.BooleanField()
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='answers')
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"question {self.question.text}, answer: {self.text}. correct: {self.correct}"

Now create modelforms in forms.py:

from django.forms.models import modelformset_factory


class QuestionsForm(forms.ModelForm):
    text = forms.CharField(label='Question', required=True)

    class Meta:
        model = Question
        fields = ['text']


AnswerFormset = modelformset_factory(
    Answer,
    fields=('text', 'correct'),
    extra=4,
    widgets={ 'text': forms.TextInput(attrs={ 'class': 'form-control','placeholder': 'Enter Answer here'}
            )
        }
)

import modelformset_factory then use modelformset_factory this in that form in which you want to show extra fields. for example one question have multiple answers, so we modelformset_factory in answer form

Now create views for that forms.


def add_questions(request):
    ques= QuestionsForm()
    formset = AnswerFormset(queryset=Answer.objects.none())
    if request.method=='POST':
        ques= QuestionsForm(request.POST)
        formset = AnswerFormset(request.POST)
        if ques.is_valid() and formset.is_valid():
            ques = ques.save()
            for form in formset:
                answer = form.save(commit=False)
                answer.question = ques
                answer.save() 
            return redirect('home')
    return render(request, "add-ques.html", {'ques':ques, 'formset':formset})


def home(request):
    ques = Question.objects.all()
    context = {'ques':ques}
    return render(request, 'index.html', context)

Now render that form in your template

<form action="." method='post'>
        {% csrf_token %}
        {% for field in ques %}
        <div class="form-group">
            <label for="text">{{field.label}}:</label>
            {{field}}
        </div>
        {% endfor %}
        {% comment %} {{ques}}
        {{formset}} {% endcomment %}
        {{ formset.management_form }}
        {% for field in formset %}
        <div class="form-group mt-5 mb-5">
          <label for="text">{{field.label}}</label>
          {{field.text}}
        </div>
        {% endfor %}
        <button type="submit" class="btn btn-primary">Submit</button>
      </form>

that's it and this is how your form look like

Source Code:- 
https://github.com/ShivamRohilllaa/django-formset

Thank you
Shivam Rohilla Python Developer

What is FastAPI ? Why it's so demanding.

Shivam Rohilla — Wed, 11 Aug 2021 20:09:11 +0000

Hello guys, In this Article I'll tell you something about the python new web API framework - FastAPi Framework.

What is FastAPI ?

FastAPI is a new python web framework, FastAPI is modern and very fast, high-performance. FastAPI is used for building web applications and API's with Python and FastAPI was released in 2018 and FastAPI mainly used for making the data science applications as well as ecommerce. FastAPI enables the developers to use REST API interface and use many functions to implement them into applications, developers uses FastAPI to create login/Signup, authenticate and create accounts etc.

Why it's so demanding.

FastAPI has a great future guys, companies uses this because it's very fast and highly securable and it has many feature like security and authentication, Dependency Injection, Unlimited plugins and etc, many big giants tech companies already using this framework for their data science applications and web applications, there are many companies like Microsoft and Netflix, Uber etc. Even my company use this framework, It's only 3 years old framework and it's already in trend, maybe this framework create thousands of jobs in future.

FastAPI documentation

https://fastapi.tiangolo.com/

Youtube Channels and Playlists for fastAPI

1) Bitfumes
https://www.youtube.com/watch?v=7t2alSnE2-I

2) IsaiahT Tech
Complete Playlist
https://www.youtube.com/watch?v=tKL6wEqbyNs&list=PLShTCj6cbon9gK9AbDSxZbas1F6b6C_Mx

3) Very Academy
https://www.youtube.com/watch?v=NH4VZaP3_9s&t=242s

for more visit:- https://webdevcodes.com/python/what-is-fastapi-why-its-so-demanding/

Find me on Linkedin

https://www.linkedin.com/in/shivamrohillaa/

Thank You
Shivam Rohilla | Python Developer

Most demanding backend framework in Software industry.

Shivam Rohilla — Sat, 07 Aug 2021 17:58:53 +0000

Hello Devs, In this blog, I'll tell you something about the most trending and demanding backend framework in the software industry and obviously it's highly paid.
and that backend framework is Django Python Web Framework, yes Django is the most demanding and highly paid backend framework in the software industry and Django is used widely in Web Development and Django is the most lovable Backend framework. Django is the best framework.

What is Python ?

As we know Python is the best programming language in 2021, Python ranks in Top 3 programming language according to TIOBE INDEX, Python is a high-level programming language, many big companies and tech giants use Python as their primary language and they uses Python framework as the primary framework because of their scalability, and that companies are Google, Instagram, Spotify, Quora, and Dropbox, Facebook.

What is Django ?

Django is a high-level Python Web Framework, it follows MVT(Model, View, Template) architecture and it's highly scalable and secure, enables rapid development and great community, yeah but it's cost effective, I never suggest Django for smaller projects.

Here are the Top Companies who uses Django.

Disqus
YouTube
Instagram
Spotify
Bitbucket
DropBox
Mozilla
Pinterest
The Washington Post
Eventbrite

You can create many types of application in Django like Ecommerce, Social Network, Chat Applications, Food delivery projects, blogging applications etc.
It enables the rapid development and you can create a simple ecommerce website in just 3-4 hours, it's very fast, but Django is cost effective, it's hosting is very expensive and Most probably Django is used in highly scalable application like Youtube or Instagram.

Django Developers Salary, Country Wise

The average Django developer salary in the USA is $100,000 per year or $51.28 per hour. Entry level positions start at $63,375 per year while most experienced workers make up to $140,000 per year.

For complete details

https://www.talent.com/salary?job=django+developer

If you are a beginner and want to learn Django so you can check my this blog, I shared top youtube channels and their playlist.

https://pythondjangogeek.com/django/top-youtube-channels-to-learn-django-for-everyone/

for projects

https://github.com/ShivamRohilllaa/

Thank You | Shivam Rohilla