DEV Community: Shivam Rohilla

My Mac app just made its first sale, $2.95, and it means a lot 🥹

Shivam Rohilla — Sun, 01 Nov 2026 16:43:45 +0000

Hey everyone,

I just got my first sale for Zuno, the Mac app I’m building as a solo founder.

The payment was $2.95. Seeing someone choose to pay for something I built felt pretty special, so I wanted to share this little milestone.

Zuno helps you organise your files and keep your projects together. Its main features are:

File organiser: Browse files by type and collect related files in Project Spaces. Your originals stay where they are.
Cleanup: Find clutter and review what you want to move to Trash.
Private Vault: Keep password-protected, encrypted copies of private files.
Search: Find files quickly and preview them inside the app. I’m bootstrapping this without a paid marketing budget and learning as I go. There’s still plenty to improve, but getting that first customer feels like a meaningful start.

Here’s Zuno: https://buildmeai.co/zuno

I’ve attached a few screenshots of the app. What’s the most frustrating part of managing files on your Mac? I’d love to hear what would make Zuno more useful.

I made a free Mac app. It got nearly 8,000 clicks on the download page in a day.

Shivam Rohilla — Wed, 21 Oct 2026 16:51:46 +0000

Meet Aster, a free Mac storage analyzer that helps you find large files, see their locations and review what goes to Trash.

You finish editing a video, hit export, and your Mac tells you there isn’t enough space. Now the job has changed. Before you can publish anything, you have to work out which files you can get rid of.

You open Downloads. There are old installers, a few ZIP files and folders with names that made sense three months ago. Some can probably go. Others might belong to a project you still need.

That gap between “my Mac is full” and “I know what I can remove” is what I built Aster to help with.

I’m Shivam, the creator behind BuildMeAI, where I share the apps I’m building with AI. Aster is my native Mac storage app. It shows what is taking up space, lets you inspect the files behind the numbers, and gives you a review step before anything moves to Trash. The current release is completely free.

What the nearly 8,000 number means
When I checked on 21 October 2026, Aster’s website had recorded 7,808 download-button clicks, less than 24 hours after the counter went live on 20 October. That is the number behind this headline.

Repeat clicks are included. It doesn’t measure completed downloads, installations or unique users. I’m sharing a download-click milestone; I don’t yet have a verified active-user count.

A full Mac usually needs a closer look
A large file isn’t automatically a useless file. Your biggest folder might be the project you are working on right now. A much smaller folder might contain exports you no longer need.

macOS already gives you a useful starting point: System Settings → General → Storage. Apple’s guide to freeing up storage space on Mac explains the built-in categories and options. I’d check that first if you only need a quick overview.

Aster is useful when you want to explore a particular folder, compare file sizes and keep the full path in view while deciding what to remove.

Where Aster fits into a normal day
A creator with too many video exports
Say you have a project folder containing source footage, editing files and several exports: the first cut, a revised cut and the version you finally uploaded. You want to keep the project, but you don’t necessarily need every intermediate export.

Scan that folder and open Large files. With the biggest items at the top, you can inspect each export and its location. Keep the source material you still need; add only the files you have decided to remove to the cleanup queue.

If you want to keep something but rarely use it, moving it to an external drive may make more sense than deleting it. Aster can help you find it; the decision is still yours.

A developer moving between projects
Old projects and build caches can sit around long after you have switched to something else. Aster includes discovery for supported developer caches and logs, so you can inspect those locations alongside your other files.

A cache can still be useful. Removing one can mean waiting for an app to rebuild or download data again. Start with locations you recognize and leave anything you’re unsure about alone.

A Downloads folder that became permanent storage
You download an installer, use it once, and forget the disk image. A few weeks later, there are more installers, archives and copies of files you have already moved elsewhere.

A folder scan gives you a manageable place to start. Search by name or path, check the file details, and work through a few obvious candidates. You don’t need to clean the entire Mac in one sitting.

Aster searching for podcast in a sample folder, with Sample podcast.wav selected and its full path and Add to cleanup button visible.
Search by name or path, then inspect the selected file before adding it to cleanup. This example uses a sample audio file.
How to use Aster to find large files on your Mac
Install Aster. Download it from the official Aster page, open the DMG and drag Aster into Applications. Launch it from there.
Choose a folder. Click Scan folder and select somewhere useful, such as Downloads or a finished project. The scan depends on the access macOS allows.
Explore the results. Use the storage map to see how space is distributed, or open Large files and sort by Largest first. You can filter by size or search a file name or path.
Check before you queue. Select a file and read its full location. Use Reveal in Finder if you need more context. Choose Add to cleanup only for something you have decided to remove.
Review the exact selection. Open Cleanup, remove anything you want to keep from the queue, and click Review for Trash. Check the paths and confirm the move when you are ready.
If you prefer seeing the interface first, there’s a 78-second Aster walkthrough on the website.

Aster cleanup review showing one selected sample file, its exact path, a Back to queue control and a Move 1 item to Trash button.
The review screen shows the exact selection before you continue. No files were moved while capturing this example.
The review screen matters
I want the file name and its location to be visible when someone makes a cleanup decision. “This takes up space” is useful information. It doesn’t tell you whether the file matters to you.

Aster sends confirmed selections to macOS Trash and never empties it automatically. Moving something to Trash doesn’t immediately recover its storage space; that happens when you empty Trash yourself. Check what is there before taking that final step.

The app also discovers installed applications, supported caches and possible leftovers. “Possible” matters here: a related file may still be needed, and some applications require their own uninstallers. Aster does not promise to remove every trace of every app.

What you get for free
Aster 0.4.1 includes storage scanning, the visual map, large-file search, full paths, Finder actions, supported app and cache discovery, and reviewed cleanup. There is no account to create, license key to enter or checkout to complete.

It works on Intel and Apple Silicon Macs running macOS 14 or later. There is one universal download, so you don’t need to choose a separate installer for your chip. The app is Developer ID signed and notarized by Apple.

File names, paths and scan results stay on your Mac. The website’s visitor and download counters are separate from the app’s local storage analysis; the privacy page explains both.

A few questions worth answering
Will Aster fix a slow Mac?
Aster helps you understand storage and choose files to remove. It does not promise a speed boost, repair hardware or replace a backup. The useful result is knowing what is taking up space and making an informed cleanup decision.

Can it delete all of System Data?
No. Apple uses System Data as a broad category, not a list of files that are all safe to delete. Aster can help you inspect supported files and cache locations, but it does not offer a blanket “delete System Data” button.

Is there a paid unlock?
All implemented features in the current release are free. The optional “Buy me a pizza” link supports development; it doesn’t unlock anything.

Try it on one folder
If your Mac is running low on storage, start with a folder you know. See what is there. Look at the largest files. You might find something obvious to remove, or decide that everything in that folder is worth keeping. Either way, you’ll have a clearer answer than a storage warning.

Download Aster for free at buildmeai.co/aster.

And if a part of the app feels confusing, tell me what you were trying to do. You can reach me at shivamrohillaa@gmail.com or @buildmeai on Instagram.

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