DEV Community: Dev Mehta

Can you write FizzBuzz?

Dev Mehta — Fri, 24 Nov 2023 12:59:05 +0000

I was incredulous, when I read this post by Jeff Atwood. The post is about how Jeff was incredulous, when he read an observation from Reginald Braithwarte. Okay let's not start calling the post recursively. The post was about the frustration expressed by interviewers who encounter candidates, including those with advanced degrees, unable to perform basic programming tasks.

It's a fairly old post(old by around 16 years). I stumbled upon it today while surfing over the internet and was incredulous by this.

After a fair bit of trial and error I've discovered that people who struggle to code don't just struggle on big problems, or even smallish problems (i.e. write a implementation of a linked list). They struggle with tiny problems.

So I set out to develop questions that can identify this kind of developer and came up with a class of questions I call "FizzBuzz Questions" named after a game children often play (or are made to play) in schools in the UK. An example of a Fizz-Buzz question is the following:

Write a program that prints the numbers from 1 to 100. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz".

Most good programmers should be able to write out on paper a program which does this in a under a couple of minutes. Want to know something scary? The majority of comp sci graduates can't. I've also seen self-proclaimed senior programmers take more than 10-15 minutes to write a solution.

So after googling the meaning of word incredulous(Yeah, I am definitely adding it to my vocabulary), I thought, no, this can't be possible. I mean who in their right mind would take more than 10-15 minutes to write such a simple program, especially when they proclaim themselves to be "senior" programmers? Heck even bad programmers should be able to come up with a solution fairly quickly.

Apparently only 40% candidates passed the FizzBuzz test when all the candidates had some kind of college - or university level programming education, many had other certifications or degrees. Each candidate could point to a sizeable, completed project on which they worked.

Now, don't start solving the fizzbuzz problem if you are confident that you can, and could come up with a solution in your mind. It was presented as the lowest level of comprehension required to illustrate basic adequacy. There's no glory in being able to come up with a solution.

Between reading all these I wondered what might be the reasons people failed FizzBuzz. I have some guesses from noticing my experiences during my diploma and graduation programs(As of today, I am a sophomore year CS student):

“Copy and paste, adjust to taste”-style programming: Also known as “Coding by Googling”, this is when a developer writes applications by searching for code that’s similar to the problem that s/he’s trying to solve, copy-and-pastes it, and then tweaks it as needed.

Moving away from programming: Some of them may have started as developers only to realize they were meant more for the managerial roles, or jobs that require something to do with applications but most of their job involved something outside the realm of writing code.

This essay is heavily inspired, and to ~~some~~ most extent copied from, Jeff Atwood's post about why can't programmers program. Thank you Jeff Atwood for all the amazing codinghorror blogposts. Jeff has been writing since the year I was born, and I do not intend to pass around his work claiming being mine. I have been an avid reader of his posts, and I just wanted to share my experience and thoughts about the said why can't programmers program post when I read it.

References

How to revert migration in django?

Dev Mehta — Wed, 29 Mar 2023 00:00:00 +0000

Imagine you are a developer working on a Django web application for a client. You have been tasked with adding a new feature that requires changes to the database schema. You create a new Django migration using the python manage.py makemigrations command to make these changes. Then you apply the migration using the python manage.py migrate command, which updates the database schema.

After deploying the new feature, you receive feedback from the client that the feature is causing issues and needs to be reverted. You realize that you need to undo the changes made by the migration to restore the previous database schema. Holy hell! I hate when they do this. In this article, I will guide you on reverting migrations so that you can be saved from such horrors.

In Django, migrations are used to manage changes in your database schema. However, sometimes it's necessary to revert a migration, particularly if you made a mistake or if you want to undo a particular change.

Here's how you can revert a migration in Django

First, you need to find the migration that you want to revert. You can do this by running the following command in your terminal

python manage.py showmigrations

This will display a list of all the migrations in your project. Find the migration that you want to revert to and take note of its name.

Once you have identified the migration to revert, you can use the following command to revert it:

python manage.py migrate <app_name> <migration_name>

Replace <app_name> with the name of your app and <migration_name> with the name of the migration that you want to revert. For example:

python manage.py migrate myapp 0002_previous_migration

This will roll back the migration and undo the changes it made to your database schema.

Well akshually🤓, you don’t even need any of that, you just need the migration number of the migration you want to revert back to

python manage.py migrate myapp 0002

That's it! By following these steps, you can easily revert a migration in Django and undo any changes made to your database schema.

Happy Coding!

Django - CBVs or FBVs?

Dev Mehta — Tue, 21 Mar 2023 00:00:00 +0000

Meet Jane. Jane is a Django developer working on various projects. In one of her projects, Jane needed to build complex views which needed to be more extensible and flexible. Jane got introduced to class-based views in Django. At first, like any of us would, Jane was hesitant to rewrite her views to class-based views. But as she delved deeper, she realized that there were many benefits to using class-based views

To begin with - we use class-based views in Django because we don’t want to end up in the same situation as Jane — nobody would like to rewrite their function-based views to class-based views(you will need to - if your app scales).

Class-based views provide an alternative way to implement views as Python objects instead of functions. They do not replace function-based views, but have certain differences and advantages when compared to function-based views:

Organization of code related to specific HTTP methods (GET, POST, etc.) can be addressed by separate methods instead of conditional branching.
Object oriented techniques such as mixins (multiple inheritance) can be used to factor code into reusable components.

During the old times of django, there was only a simple method of writing views - Django would provide HttpRequest to your function and expect an HttpResponse in return. Then function-based views were introduced to ease view development. The problem with function-based generic views is that while they covered the simple cases well, there was no way to extend or customize them beyond some configuration options, limiting their usefulness in many real-world applications.

But…..

from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import MyForm

def create_post(request):
    if request.method == "POST":
        form = MyForm(request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect("/success/")
        else:
            return render(request, "post.html", {"errors":form.errors})
    else:
        form = MyForm
        return render(request, "post.html", {"form":form})

But this view works really work for me, why will I ever use a class-based view if it just does the same work, and if its hard to grasp as a beginner.

You may think like this, but what if you could do all that with this,

from django.views.generic.edit import CreateView
from .models import Post

class CreatePost(CreateView):
    model = Post
    fields = ['title', 'content']

This is just a simple example of how class-based views are more concise and readable, but that’s not it. There are more generic views that you can use like

CreateView,
UpdateView,
DeleteView,
ListView,
DetailView

Additionally, by organizing your code into methods that correspond to different parts of the request-response cycle, you can make it easier for other developers to understand what's going on. And by using mixins and generic views, you can avoid writing repetitive code that can be hard to read and maintain.

You can also subclass a class and refine methods like get_context_data for specific cases, and leave the rest as-is. You can't do that with functions.

For instance, you might need to create a new view that does everything a previous one does, but you need to include extra variables in the context. Subclass the original view and override the get_context_data method.

Also, separating the steps needed to render the template into separate methods promotes clearer code - the less done in a method, the easier it is to understand. With regular view functions, it's all dumped into one processing unit.

You might even not need to write a view for simpler cases, you can use them directly like this

path('author/<int:pk>/', DetailView.as_view(model=Author)),

You can start learning about Django class-based views from here. Once you have read the documentation or at least used CBVs a few times in your app, I would recommend using https://ccbv.co.uk/ - It is the ultimate resource for Class Based Views, giving you an easy way to view CBV code

Famous final words….

In the world of Django development, while function-based views might seem like the obvious choice, once you put on those class-based view glasses, you'll realize there's a whole new world of possibilities waiting for you.

With the power of mixins and the elegance of generic views, Django class-based views can help you build complex, extensible, and scalable views with ease. So don't be like Jane who's hesitant to make the switch, and start using class-based views today!

Happy Coding!

Best Developer Blogs to Follow in 2023

Dev Mehta — Mon, 13 Mar 2023 00:00:00 +0000

If you want to stay up-to-date as a developer, you need to immerse yourself in the coding culture. The programming field is so vast, and there is so much information to absorb that you’ll never get on top if you don’t keep involved enough in all the news and updates.

This article mainly focuses on bringing out the critical blog resources across the internet that deliver the top articles for programmers. With no further delay, we’d like to walk you through our curated list of the best developer blogs.

Please keep in mind that, this is not a top 10 list but a list of 10 blogs that I follow every day, to keep myself up with the constantly changing world of web development, and programming.

The Daily WTF - thedailywtf.com

Well, technically this is different from your how-to guide for developing good software, but rather a collection of stories of disastrous development, from project management going spectacularly bad to inexplicable coding choices.

Some articles on the website are written by contributors who share their own experiences and frustrations with coding, while others are fictional stories designed to poke fun at common industry practices and stereotypes.

While the website may not be appropriate for all audiences, it does provide a lighthearted look at the challenges and absurdities of software development to me personally.

The storytelling will keep you hooked and you will learn “what not to do” in a humorous & engaging manner.

Substack Newsletters

Again this one is not specifically a blog but its one of my personal favourite platforms to read content.

Substack — allows writers to send digital newsletters directly to their readers and monetize their work by putting it behind a paywall. One of the benefits of such a mechanism, for us readers is that due to this paywall, most of the writers produce quality work - why? because only good content sells.

Here are my favourite newsletters on substack that you could give a try(Your mileage may vary):

ByteByteGo - https://blog.bytebytego.com/ - My go-to system design learning resource
The Pragmatic Enigneer - https://newsletter.pragmaticengineer.com/ - Talks about big tech and high-growth startups, from inside
Not Boring by Packy McCormick - https://www.notboring.co/ - Talks about tech, web3, optimism and strategy but not in a boring way
Software Design, Tidy First - https://tidyfirst.substack.com/ - Book-scoped topics as articles.

HackerNoon - hackernoon.com

Hacker Noon has a very wide range of activities. It is a portal that tackles issues related to technology, software development, cryptocurrencies, and blockchain technology. You can find mostly technical articles that provide really interesting insights.

This platform is quite popular among technical specialists and tech fans, as it is an independent resource dedicated to sharing any kind of technology news stories and expert opinions. I have been publishing on hackernoon recently, and it's good for both content creators and readers - 55% of their articles are rejected if they don’t match their quality assurance.

David Walsh's Blog - davidwalsh.name

It is of the most well-known personal blogs run by a single developer. He is a senior web developer and front-end engineer, providing Internet users with the coolest programming tutorials.

If you’re in search of tutorials to improve your coding and web development skills, this blog is the best place to start with. The great thing about using this blog is that you will see real examples of the programming world. You can also find free trial versions of the software in his blog.

CodingHorror

This blog is heartily enjoyed by a lot of readers. This blog is included in this list since it’s a frank, humorous blog that discusses the challenges and ironies of software creation, its ecosystem, and how it interacts (or doesn’t) with the business world.

Since 2004, it has been around us. The blog is written by Jeff Atwood, the creator of Stack Overflow. Jeff has a brilliant way of looking at coding, and he can give you a stimulating view of the tech world when you need some inspiration.

TestDriven.io

Blog backed up by Michael Hermon - The Co-Founder/Author of realpython.com. As the name suggests his tutorials on test-driven development, django and python are unmatched. He is popular among the Django community for being one of the early adopters of Django, and a source of inspiration for bloggers like me.

Mozilla Developer Network Blogs

The Mozilla Developer Network Blog is a programming blog that covers topics such as web development, browser technology, and JavaScript. The blog is written by a team of experts who provide valuable insights into the latest trends and updates in web development. The blog also features tutorials and resources to help programmers improve their skills.

Dan McKinley’s Blog

A lot of great material on how engineering companies should be run. He has a lot of ideas that sound like common sense, e.g., choose boring technology, and ship small diffs until you realize that it's actually uncommon to find opinions that are so sensible.

Mostly distilled wisdom (as opposed to, say, detailed explanations of code).

Janet Davis’ Blog

Another “not a blog”. Damn it. Yes its not a blog but an interesting story read on how a professor moved from Grinnel to Whitman and started a CS program from scratch. The archives are great reading if you're interested in how organizations form or CS education

Jaana Dogan’s Blog

rakyll.org has posts on Go, some of which are quite in-depth, e.g., this set of notes on the Go generics proposal and Jaana's medium blog has some posts on Go as well as posts on various topics in distributed systems.

Also, Jaana's Twitter has what I think of as "intellectually honest critiques of the industry", which I think is unusual for critiques of the industry on Twitter. It's more typical to see people scoring points at the expense of nuance or even being vaguely in the vicinity of correctness, which is why I think it's worth calling out these honest critiques.

That’s it for today. I hope you enjoyed reading about my personal list of top developer blogs to follow in 2023. Remember, there are many other great blogs out there, so don't be afraid to explore and find what works best for you. Keep learning and stay up-to-date with the latest developments in the tech industry!

Happy Coding!

Are your webapps scalable?

Dev Mehta — Wed, 08 Mar 2023 00:00:00 +0000

...Django is a widely used Python web framework that allows developers to build scalable web applications quickly and efficiently. One of the most important factors to consider when developing a website is scalability - the ability of a website to handle increasing traffic and data without sacrificing performance.

The scalability of a website is essential for businesses that are growing or expecting increased traffic from marketing campaigns or seasonal spikes in demand.

In this blog post, we will explore how scalable websites built-in Django are, what factors can affect their scalability, and how to build scalable websites using Django.

What does “scaling” mean in the context of django web apps?

Can progressively scale from a low amount of users to a high amount of users.
Have modular components that are decoupled and can be replaced if they are determined to be bottlenecks of the application.
The infrastructure that you use is scalable - more on this later.

A little bit of background

Even though the conventionally accepted norm is that - “Python is slow”. This argument is slowly dying. Django is/was used by Disqus, Pinterest, Instagram and many other apps. They surely made changes to the framework and tweaked it according to their use cases, but this gives us enough confidence that, if we keep things simple & logical we should be able to do it too.

Also, I would like to add that when I am talking about scaling django apps, I am not talking about “reduced running time with code optimization”. For that, you can read this post. I want to focus on scaling the infrastructure that the code is running on.

Django's Scalability

Django is designed to be scalable, and it has built-in features that allow developers to create websites that can handle a large amount of traffic and data. One of the most important features of Django is its ORM (Object-Relational Mapping) system. It provides a powerful and flexible way to interact with databases, which is essential for the scalability of a website.

Django also supports caching and load balancing, which helps to reduce the load on the server and ensures that the website performs well under heavy traffic.

Another factor that makes Django scalable is its modularity. Django allows developers to break down their applications into smaller, reusable components, which makes it easier to add new features and scale the website as needed.

Django's built-in support for third-party packages also makes it easy to integrate additional functionality into the website without having to write everything from scratch.

Scalable Architecture

You must have heard these phrases “vertical scaling” & “horizontal scaling”. Scaling vertically simply means adding more resources(RAM, CPU) in a monolithic manner & hope that the application would be able to handle more requests.

This may work well initially, but at last, you would want to scale horizontally - meaning spawning more machines that serve your application - or better divide your app into micro-services so that each node on the network only serves a specific part of your application.

Splitting application to individual services helps you scale them individually as your load increases. You can then, work on optimizations at a service level.(Note: Be aware of the extra communication costs among your services).

You can look at how disqus scaled django to 8 billion page views handling 45k requests per second.

A note on load balancing…

The features required to scale our application horizontally are generally features that allow our application to be stateless. Stateless applications mean that they do not keep any state. They don’t store any data, images, sessions or files within them. They use third-party services for all states, this includes things such as Databases, Memory Cache, Cloud Storage etc.

Django is great when it comes to this, and it definitely gives us the tools needed for us to run our application completely stateless:

You can replace the default SQLite database (which stores data locally) to instead store data on a database that is running on another server instance.
It supports custom File Storage Backends that allow you to store files on Amazon S3, DigitalOcean Spaces, Azure Blob Storage or any other cloud storage.
You can customize Sessions to be stored in a database or Key-Value Store (such as Redis) instead of on the file system.
You can use Cache Backends such as Memcache or Redis to store any cache on another server instead of the file system.

Each one of these features allows us to store our application state somewhere else. The key point is not which technology we choose or where we store our state, as long as it’s not stored locally with our application.

Django tools that allow for scaling

Django Storages
Memcache and Redis Cache Backends (Part of Django)
PostgreSQL, MySQL Database Backends (Part of Django)
Redis and Database Session Backends (Part of Django)

All of these tools mean that you can be ready to set up your application for statelessness and scale out of the box. If you require support for other services that are not supported by these tools, it is important to note that Django is pluggable and allows the programmer to replace most pieces with their own “Backend” class.

This means that you can often replace the existing built-in features with a custom backend for the service you want to add support for. I recently did this to store files on Digitalocean and it was very simple and straightforward.

Connections and Connection Pooling

If you have not used Django extensively, it is easy to miss out on the CONN_MAX_AGE param in settings.py that defines the maximum lifetime of your connection. This is Django’s way of connection pooling.

By default, Django, closes the connection at the end of each request. Persistent connections avoid overloading the database for each request and the cost ( it takes around ~20ms to make a DB connection ) of creating a connection is also reduced. So developers should consider setting CONN_MAX_AGE to None (unlimited persistent connections) or a suitable value depending on your request volume at the applications’ end.

Do most of your bottlenecks end up at database level?

If you are not able to scale your backend, then most likely the database is your bottleneck. There are a few quick things that can help you reduce the time to process your DB query and shorten the request/response cycle to improve performance (always think about reducing the time for the request/response cycle – the holy grail).

Indexes – Adding appropriate indexes can speed up your DB (SELECT) queries and reduce the time to respond to users. It is best to look at slow (above ~30 ms) queries and queries that are done often to look at avenues for improvements. But don’t overdo it. More indexes would impact the performance of INSERT and UPDATE and also increase the load on disks to store the indexes.
Choosing the right database – I’m used to working with Postgres and have seen great results. The community also likes it for its performance, proven capabilities at scale, data integrity and people who keep working on making it better every day.

Write your own code — if needed

Luckily, or unluckily for the world, all types of applications haven’t been built yet. New unique applications with new demands are always popping up and pushing the industry forward. This means that even though we have huge applications such as Instagram, Disqus or Bitbucket using Django in scale, it does not necessarily mean that your unique application with its own needs will not run into some unique problem.

Django has its ORM which expects you to use a SQL Database such as MySQL or PostgreSQL. If you want to use a Document Database such as MongoDB, Django might not be the right tool for you. This means that the pluggability of Django might be less than something like Flask or Express which simply let your plugin any tools you want.

With that said, this does not mean that Django is not pluggable at all. There has been a lot of effort invested in making Django pluggable and allow developers to extend it in their own ways.

Instagram is a great example, they used a very custom implementation of Django which allowed them to scale to 100’s millions of users. Django has extensive configuration possibilities with its settings.py file that allows you as the developer to configure most parts of the framework.

A few examples of what settings you can set to plug in your own custom solutions into Django:

Authentication Backend
Session Storage Backend
Cache Backend
Database Backend
Static Files Backend
Media Files Backend
Logging Handlers

On top of this, you can also create your own middlewares that allow you to hook into the HTTP Request/Response cycle.

Removing unused code

Another way to reduce the request/response time is by removing the extra middleware that your app is not benefiting from. Every request that is made to the Django backend passes through this middleware and adds extra time (20-30ms) to the request/response cycle.

If your app makes API calls to the Django backend then you don’t need to use some of the middlewares that are enabled in Django by default.

Conclusion

Well, that’s it, folks! Hope you learnt a few things today. When developing products for high loads, the key thing is to stay curious, persistent and innovative. Every small change creates an impact as the change influences millions of requests.

Keep monitoring, keep measuring and keep fixing, that’s the mantra.

Happy Coding!

Fatigue.js: The revolutionary new framework...

Dev Mehta — Mon, 06 Mar 2023 10:39:03 +0000

Welcome to yet another blog post about the latest and greatest JavaScript framework that's going to revolutionize the world of web development. That's right, we're here to talk about the hottest, trendiest, and most buzzworthy framework that everyone's talking about but nobody actually understands.

Introducing...Fatigue.js! This new framework coded by me, promises to make web development faster, easier, and more intuitive than ever before.

You may ask, how? Well, we don't know that yet, but with its cutting-edge features, sleek design, and unparalleled performance, that all of the JavaScript frameworks before Fatigue.js had, it is sure to take the web development world by storm.

But wait, what does this framework actually do? How is it different from all the other frameworks that have come before it? What problem is it solving, and is that problem even relevant to your project?

Well, to be honest, I am not really sure, are you? No. Nobody really knows what this framework does or how it works, and that's what makes it unique. It is due to these reasons that Fatigue.js will be the next big thing as it won't stop everyone from jumping on the bandwagon and declaring it the greatest thing since sliced bread.

Alright, then let's start with how to get started with fatigue.

How to Install Fatigue

Installing fatigue is fairly simple, you just need to run

npm install fatigue && npm install create-js-fatigue-cli

yarn add fatigue

Then, you can fatigue-cli from your terminal to create fatigue apps. To create your first fatigue app run:

fatigue new myproj .

Fatigue, will now install around 420 dependencies to your device, and within about 1 hours and 9 minutes, your project will be production-ready, optimized, blatantly fast, secure and containerized boilerplate ...umm what other keywords did we have for it?,anyhoo, you get the point.

Understanding the workflow to build a fatigue app

Good news, fatigue projects revolve around 3 simple steps, which even a beginner can learn.

Step-1: Download the framework, and spend the next few hours tweaking App.js.

Step-2: Realize that you have no idea what you're doing and start frantically googling for tutorials and documentation(...we provide the best documentation - trust us).

Step-3: Give up in frustration & go back to vanilla JS and jQuery.

Conclusion

In conclusion, Fatigue.js may be the latest and greatest thing in the world of web development, but that doesn't necessarily mean it's right for you.

Before jumping on any new trend, take the time to evaluate whether it actually solves a problem you're facing(or rather how is the framework different than the ones already existing), and whether it's worth the time and effort to learn.

And if you do decide to try out Fatigue.js, just remember that you're not alone in feeling overwhelmed and confused. Good luck, and happy coding!

This shitpost was inspired from a recent post, I read. While this, is meant to be parody in all sense, you can check out the linked post for more serious advice.

Hope you enjoy reading the article as much as I enjoyed writing it.

Why do you need django signals right now?

Dev Mehta — Thu, 02 Mar 2023 00:00:00 +0000

Meet Jane, a passionate software developer who loves building robust and efficient web applications using Django. Jane is currently working on a project where she needs to execute a certain piece of code based on certain events that occur in her app.

She has heard about Django signals, but she is not quite sure what they are and how they work.

Django signals are a powerful tool for executing code based on certain events in your Django application.

Signals are decoupled and allow senders to notify a set of receivers that some action has taken place.

This can be useful for automating tasks, such as sending emails, updating records, or logging data, whenever a certain event occurs in your app. In this tutorial, we will go through the process of using Django signals to execute code based on certain events in your app.

Understanding Django Signals

Django signals are a way to allow certain senders to notify a set of receivers that some action has taken place. Signals are sent by senders, using the Signal.send() method, and are received by receivers, using the @receiver decorator.

There are several built-in signals in Django, such as pre_save, post_save, pre_delete, and post_delete. These signals are sent whenever a model instance is saved or deleted. You can also create custom signals for your app.

Django signals can be used for a wide range of events, including user authentication, object creation, object deletion, and many more. By using signals, developers can create more modular and extensible code that is easier to maintain and test.

In the next section, we'll take a closer look at how Jane can use Django signals in her project to execute code based on certain events.

Creating a Signal Receiver

Now that you understand the basics of Django signals, it's time to explore how to use them in your own projects. Let's continue following the journey of our character, Jane, as she discovers the power of signals in her Django app.

Jane has been working on a web application that allows users to subscribe to different newsletters based on their interests. Whenever a user subscribes or unsubscribes from a newsletter, Jane needs to update the user's profile to reflect their choices.

She could update the user's profile directly whenever a subscription or unsubscription occurs, but that would create extra code and make her application less modular. Instead, Jane decides to use signals to keep her code clean and organized.

The first step for Jane is to define the signals that her app will use. She creates two signals, one for subscribing and one for unsubscribing, and gives them descriptive names: user_subscribedand user_unsubscribed.

She also includes any relevant data that needs to be passed along with the signal, such as the user's email.

# File: yourapp/signals.py
from django.dispatch import Signal

user_subscribed = Signal(providing_args=['user_email'])
user_unsubscribed = Signal(providing_args=['user_email'])

Once Jane has defined her signals, she needs to connect them to the appropriate functions that will execute whenever the signal is triggered. She creates two functions, subscribe_newsletter and unsubscribe_newsletter,that will update the user's profile whenever a subscription or unsubscription occurs.

# File: yourapp/signals.py
...
from django.dispatch import receiver

...
@receiver(user_subscribed)
def subscribe_newsletter(sender, **kwargs):
    user_email = kwargs['user_email']

    # Business logic
        # user = User.objects.get(email=user_email)
    # user.profile.subscriptions.add("my_newsletter")
        # user.profile.save()
    print(f"Subscribed {user_email} to our newsletter")

@receiver(user_unsubscribed)
def unsubscribe_newsletter(sender, **kwargs):
    user_email = kwargs['user_email']

    # Business logic
        # user = User.objects.get(email=user_email)
    # user.profile.subscriptions.remove("my_newsletter")
        # user.profile.save()
    print(f"Unsubscribed {user_email} from our newsletter")

# Connecting recievers & signals
user_subscribed.connect(subscribe_newsletter)
user_unsubscribed.connect(unsubscribe_newsletter)

In this example, the @receiver decorator is used to register the subscribe_newslettter() function as a receiver for the user_subscribed signal. The function simply prints it out to the console.

Use it in your views

That’s it now Jane can use those signals in her views.py file.

from .signals import user_subscribed, user_unsubscribed
from django.http import HttpResponse

def subscribe(request):
    user_email = request.GET.get('user_email')
    if user_email is None:
        return HttpResponse("Please provide a user_email parameter in GET request.")
    else:
        user_subscribed.send(sender=request.user, user_email=user_email)
        return HttpResponse(f"Subscribed {user_email} to our newsletter.")

def unsubscribe(request):
    user_email = request.GET.get('user_email')
    if user_email is None:
        return HttpResponse("Please provide a user_email parameter in GET request.")
    else:
        user_unsubscribed.send(sender=request.user, user_email=user_email)
        return HttpResponse(f"Unsubscribed {user_email} from our newsletter.")

With her signals and functions in place, Jane can now use them in her application whenever a user subscribes or unsubscribes from a newsletter. She simply needs to import the appropriate signal and send it with the relevant data.

To make it work…

There is one catch to this situation, the code isn’t functional yet. To make our code work as desired we need to import our signals into our application’s config file - apps.py

from django.apps import AppConfig

class AccountsConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'accounts'

    def ready(self) -> None:
        import accounts.signals
                print("Signals connected")

In this example, the ready() method imports the signals.py module, which contains the our signals. It then logs a message to indicate that the signal receiver has been connected.

Now when you send requests to your view endpoints, you can see your signals working in action.

Also see

You can also use in-built model signals like pre-save.

from django.contrib.auth.models import User
from django.db.models.signals import pre_save

@receiver(pre_save, sender=User)
def user_created(sender, **kwargs):
    user = kwargs['instance']
        # Other business logic you might want to add...
    print(f"Creating user, {user}")

Django documentation will always be the number 1 resource for further studying: https://docs.djangoproject.com/en/4.1/topics/signals/

Also, this is a good blog post by simpleisbetterthancomplex, if you want a detailed overview; rather than an introductory post like this one.

Conclusion

Django signals provide a powerful tool for executing code based on certain events in your application. By using signals, you can keep your code modular and organized, making it easier to maintain and update in the future.

Whether you're building a simple web app or a complex enterprise application, signals can help you streamline your code and create a more efficient development process.

Happy Coding!

If you've come this far, thanks for reading. If you like my content you can follow me here. I regularly post on my blog, you can check it out.

Also published here

Simplify your workflow with Pre-Commit Hooks

Dev Mehta — Fri, 24 Feb 2023 00:00:00 +0000

Picture this: You're a busy Django developer working on a large-scale web project with a team of developers. You spend hours coding, testing, and debugging, only to realize that your codebase is littered with small issues like formatting inconsistencies, syntax errors, or import sorting problems.

These small issues can pile up and slow down your development workflow, especially when working with a large team.

That's where pre-commit comes in. Pre-commit is a simple yet powerful tool that can help you catch these issues before they make it into your codebase. It is a git hook script.

Git hook scripts are useful for identifying simple issues before submission to code review. We run our hooks on every commit to automatically point out issues in code such as missing semicolons, trailing whitespace, and debug statements.

By pointing these issues out before code review, this allows a code reviewer to focus on the architecture of a change while not wasting time with trivial style nitpicks.

By automating code formatting, linting, and testing, pre-commit can save you time and headaches, allowing you to focus on what really matters: building great software.

In this blog post, we'll explore how to use pre-commit in Django projects. We'll cover everything from installation and configuration to creating custom hooks and integrating with CI tools.

By the end of this post, you'll have a solid understanding of how to use pre-commit to improve your workflow and streamline your development process. So, let's dive in!

Installation & Configuration

The first step to using pre-commit in your Django project is to install it using pip, the Python package manager.

pip install pre-commit

Once you have pre-commit installed, you'll need to configure it using a file called .pre-commit-config.yaml.

This configuration file is where you define the hooks that pre-commit will run on your code. A hook is a command or script that checks your code for issues like formatting errors, syntax mistakes, or security vulnerabilities. There is a wide range of hooks that you can use in your Django project, and you can also create your own custom hooks.

In your .pre-commit-config.yaml file, you'll specify which hooks you want to run and in what order. You can also set options for each hook, such as which files to run it on or what arguments to pass to the command.

For Django projects, some of the most useful pre-commit hooks include Black for code formatting, Flake8 for code linting, isort for import sorting, and Mypy for static type checking. By running these hooks automatically, you can ensure that your code is clean, consistent, and easy to read.

TLDR

To adopt pre-commit into our system, we simply perform the following actions:

Install pre-commit: pip install pre-commit
Add pre-commit to requirements.txt (or requirements-dev.txt)
Define .pre-commit-config.yaml with the hooks you want to include.
Execute pre-commit install to install git hooks in your .git/ directory.

Creating .pre-commit-config.yaml

Create a file named .pre-commit-config.yaml in your repository root directory(also your django project’s root directory).
You can generate a very basic configuration using pre-commit sample-config

Instead of creating sample-config, you can also start from scratch. In this post, I have included packages like black, flake8 ,reorder-python-imports & bandit for our django projects.

Here is a sample of pre-commit files that I am currently using for my projects. These files help me ensure that my code is clean, formatted, and free of errors before I commit it to the repository. I highly recommend using pre-commit hooks in your own projects to save time and avoid potential issues down the road.

repos:
  - repo: 'https://github.com/psf/black'
    rev: 22.10.0
    hooks:
      - id: black
        args:
          - '--line-length=88'
        language_version: python3
  - repo: 'https://github.com/PyCQA/flake8'
    rev: 5.0.4
    hooks:
      - id: flake8
        args:
          - '--max-line-length=88'
        exclude: ^(.*/migrations/|core/settings.py)
  - repo: 'https://github.com/asottile/reorder_python_imports'
    rev: v3.9.0
    hooks:
      - id: reorder-python-imports
  - repo: local
    hooks:
      - id: django-tests
        name: django-tests
        entry: python manage.py test
        always_run: true
        pass_filenames: false
        language: system
  - repo: 'https://github.com/PyCQA/bandit'
    hooks:
      - id: bandit
        name: bandit
        description: Bandit is a tool for finding common security issues in Python code
        entry: bandit
        language: python
        language_version: python3
        types:
          - python

Black is a code formatter that ensures my code follows a consistent style.

Flake8 is a linter that checks my code for syntax errors, unused imports, and other potential issues. reorder-python-imports is a tool that sorts my imports alphabetically, making them easier to read and maintain.

bandit looks for potential security vulnerabilities in your code. By running these checks automatically, you can ensure that your code is secure and free of common security issues.

In addition to using these tools, I also include a pre-commit hook that runs my unit tests before each commit. This helps me catch any bugs or regressions before they make it into the codebase.

Overall, pre-commit hooks are an essential part of my workflow, and I highly recommend incorporating them into your own development process. Note that these are my personal recommendations and not the holy grail of truth for django projects, but I hope they can serve as a helpful starting point for you.

Getting it in action

Once, you create your .pre-commit-config.yaml - configuration file, you need to install that pre-commit hook into your .git repository. Its fairly easy and simple.

To install the pre-commit hook, you just need to run git add .pre-commit-config.yaml and pre-commit install in your terminal. This will automatically install the hook into your .git directory, allowing it to run on every commit. You can also run pre-commit run to manually run the hooks on your codebase. Once installed, pre-commit will run automatically every time you commit code to your repository, ensuring that your code is clean and ready for review.

For more details you can look at pre-commit documentation.

Now the next time you make some changes in your repositories, you can run git add . to stage all changes and git commit to commit them.

Pre-commit will automatically run the hooks you specified in your .pre-commit-config.yaml file on your staged changes before the commit is finalized. This will help catch any errors or issues before they make it into your codebase and save you time and headaches down the road.

The output will be somewhat similar to the above image, if the code passes the rules defined by linters & hooks, it will be mentioned as Passed by that hook, but if the code fails for some reason, the error will be shown where it fails, and you can work on that specific code. If there were formatting issues, most of the times, black will reformat them for you.

Conclusion

By automating code formatting, linting, and testing, pre-commit can help catch errors and issues before they make it into your codebase. With a solid understanding of installation and configuration, and by using custom hooks, you can streamline your development process and ensure that your code is clean, consistent, and easy to read.

I hope this article served as a good starting point for automating some of your linting, and code quality improvement tasks. There are many amazing hooks other than these available online. You can start at https://pre-commit.com to continue learning more about this.

Happy Coding!

Make things less complicated with django model managers

Dev Mehta — Sun, 19 Feb 2023 00:00:00 +0000

In this article, we will learn about django model managers. Recently when I was scrolling through r/django reddit community, I was excited to help other django developers; solve their errors. I went through some posts and read the problems to get started, and I found the first problem, I liked to solve.

The problem was “I would like to apply logic to my apps by having methods written in models.py. What is the best way to go about this. The documentation is great for the basics but I am getting frustrated when working to apply business logic outside of views.py. Any good resources on this type of flow? Business Logic in models.py? ”

You may have faced this frustration too sometimes, because as django is a robust framework for perfectionists with deadlines, it expects us to figure this out yourself(Or, so I thought, because this question was very well covered in documentation, which you like me, might won’t have read.)

So, I gave them the solution that I generally use, to write repetitive or common django filter queries in models.py file where you define your models, like this.

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=70)
    # ...

    def get_howto_guides(self):
        return Post.objects.filter(title__istartswith="how to")

At first, I didn't see anything wrong with this. I was still learning and trying to make things work.

But soon, people on reddit pointed out that this approach was not optimal and the best place for this is the manager. A manager manages a set of models (so basically an SQL table) and a model is just a row in that table (it shouldn't know about other rows). And boy I was embarrassed.

I soon realized that as our codebase will grow, our models will become bloated with business logic that was better suited to our model managers.

It wasn't until I stumbled across the concept of model managers that I realized there was a better way to organize my code(If you use reddit, join r/django. You will get to learn so many new things daily). Model managers, I learned, are a way to encapsulate model-level operations and queries in a clean and modular way.

How to do it.

By default, Django adds a Manager with the name objects to every Django model class. However, if you want to use objects as a field name, or if you want to use a name other than objects for the Manager, you can rename it on a per-model basis. To rename the Manager for a given class, define a class attribute of type models.Manager() on that model. For example:

from django.db import models

class Post(models.Model):
    # ...
    how_to = models.Manager()

Here, Post.how_to will generate an AttributeError while, Post.how_to.all() returns all the objects from that manager.

Now, I can fit all my business logic about “How to Guide Posts” in my how_to model manager. For example, if I wanted all the posts that starts with How to, or are basically how-to-do-x type of articles, I will write the following model manager separately for those kinds of posts.

from django.db import models

class HowtoPostsManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(title__istartswith="how to")
        # istartswith lookup field is used to
        # lookup case-insensitive titles.

class Post(models.Model):
    # ...
    objects = models.Manager() # Default Manager
    how_to = models.HowtoPostsManager() # our custom manager

Now Post.objects.all(), will return all the posts from the database, while Post.how_to.all(), will return only posts whose title starts with “How to”.

This example also pointed out another interesting technique: using multiple managers on the same model. You can attach as many Manager() instances to a model as you’d like. This is a non-repetitive way to define common “filters” for your models.

QuerySets as model managers

You can also define common filters as model managers in your django models. For example,

from django.db import models

class HowtoQuery(models.QuerySet):
    def title_starts_with_howto(self):
        return self.filter(title__istartswith="how to")

class Post(models.Model):
    # ...
    objects = models.Manager() # Default Manager
    how_to = HowtoQuery.as_manager() # our custom manager

# This will be identicle to the previous code example,
# we looked at

Not every QuerySet method makes sense at the Manager level; for instance django prevents the QuerySet.delete() method from being copied onto the Manager class.

With model managers, I could write custom methods for my models that handled complex logic, filtering, and aggregation. I could also create new querysets that were specific to my application's needs, which made it easier to reuse code across my views.

As I started to use model managers more in my applications, I found that my code was becoming cleaner and easier to read. I was also able to remove a lot of code from my models and keep my business logic closer where it belonged.

In retrospect, it's hard to believe that I didn't know about model managers even after coding in Django since a considerable amount of time. But I'm grateful that I came across this concept when I did, as it completely transformed the way I wrote code and helped me to become a better Django developer.

So, to anyone who is struggling with complex views and a messy codebase, I highly recommend exploring the power of model managers in Django. You might be surprised by how much they can simplify your code and improve your overall development experience.

Happy Coding!

Top 10 Must-Have Third-Party Packages for Web Developers

Dev Mehta — Sun, 29 Jan 2023 00:00:00 +0000

First of all if you are here reading this post, to find "top 10 must have third party packages for javascript", then I am sorry, that I had to clickbait you, as we all have seen, that dev.to prefers these hashtags, more than it prefers quality content, also I had to add a "top 10" post, to get views.

Secondly, if you are a django developer and are looking for good third party packages, then you are welcome here. I had to clickbait you with titles and keywords, as the algorithm doesn't push posts from creators outside of JS Stacks, no matter how much we try to provide back to community :).

So let's begin, and yeah this is not a "top 10" list, but "10 good packages" list.

Django is a powerful web framework that makes it easy for developers to build and maintain web applications. However, as any developer knows, there are always areas where a little extra help is needed. That's where third-party packages come in. These packages are created by the community and can help to extend the functionality of your Django application in ways that would otherwise be difficult or impossible.

In this post, we will be taking a look at the top 10 must-have third-party packages for Django developers. These packages will help you to add new features, improve performance, and make development easier.

Packages Covered:

Django Debug Toolbar
Django Rest Framework
Django Extension
Django Crispy Forms
Django Haystack
Django Allauth
Django Compressor
Django Storages
Django Celery
Django CORS Headers

1. Django Debug Toolbar

Django Debug Toolbar is an incredibly useful package that helps you to debug your Django application. It adds a toolbar to your application that shows information about the current request, including the SQL queries that were run, the time it took to process the request, and much more. This package is a must-have for any developer working on a Django application.

You can read this post, to learn how to add django-debug-toolbar to your app, for optimizng the performance of your app

2. Django Rest Framework

Django Rest Framework is a powerful package that makes it easy to create RESTful APIs with Django. It provides a simple, consistent interface for interacting with your Django models and includes support for authentication, permissions, and more. If you're building a web application that needs to provide an API, then Django Rest Framework is a must-have package.

You can read this post, to learn how to use django-rest-framework to build scalable and secure APIs

3. Django Extension

Django Extension is a collection of useful management commands for Django. It includes commands for generating UML diagrams, running shell commands, and much more. This package is an absolute must-have for any Django developer who wants to save time and automate repetitive tasks.

4. Django Crispy Forms

Django Crispy Forms is a package that makes it easy to create beautiful forms in Django. It provides a simple, consistent interface for rendering forms, and includes support for Bootstrap, Foundation, and other popular CSS frameworks. If you're tired of dealing with the hassle of creating forms in Django, then this package is for you.

5. Django Haystack

Django Haystack is a package that makes it easy to add search functionality to your Django application. It provides a simple, consistent interface for working with search engines like Solr, Elasticsearch, and Whoosh. If you need to add search functionality to your application, then this package is a must-have.

6. Django Allauth

Django Allauth is a package that makes it easy to add authentication and authorization functionality to your Django application. It includes support for social authentication, email verification, and more. If you're building a web application that needs to provide authentication and authorization functionality, then this package is a must-have.

7. Django Compressor

Django Compressor is a powerful package that can help you optimize your application's performance by compressing and merging your CSS and JavaScript files. This can help reduce the number of requests your application needs to make, resulting in faster load times and improved user experience. Additionally, it also supports compressing and merging of images, which is an added bonus. With Django Compressor, you can easily minify your assets and improve the load time of your web pages.

You can read this post, to learn how to optimize the performance of your app.

8. Django Storages

Django Storages is a third-party package that allows you to use different file storage backends such as Amazon S3, Google Cloud Storage, and more. This is particularly useful when your application is growing, and you need to store large amounts of files or when you want to use a cloud-based storage solution. With Django Storages, you can easily switch between different storage backends and take advantage of their scalability and reliability.

9. Django Celery

Django Celery is a powerful package that allows you to run asynchronous tasks in the background. This can be extremely useful for tasks such as sending emails, processing images, and more. With Django Celery, you can easily schedule and manage background tasks, which can help improve the performance of your application.

10. Django CORS Headers

Django CORS Headers - This package allows you to easily add Cross-Origin Resource Sharing (CORS) headers to your Django views. CORS headers are necessary to allow cross-origin requests, which can be a common issue when developing web applications. This package provides a simple and flexible way to configure CORS headers for your project, and supports both class-based views and function-based views. It is also easily configurable and can be integrated with other libraries like Django Rest Framework. With Django CORS Headers, you can easily handle cross-origin requests and ensure that your application is accessible to all clients.

Conclusion

In conclusion, these are some of the most essential third-party packages that can help you build better web applications with Django. Whether you need to optimize your application's performance, build REST APIs, or manage background tasks, these packages have got you covered. So, the next time you're starting a new project, consider using these packages to take your development to the next level.

Happy coding!

Build Scalable and Secure APIs with Django REST Framework

Dev Mehta — Fri, 27 Jan 2023 00:00:00 +0000

Introduction

This blog post was originally published on my blog. You can check it out for more such posts

Welcome to the world of Django REST framework, where building scalable and secure APIs is as easy as wielding the Founding Titan's power. In this blog post, we will be exploring the ins and outs of Django REST framework, a popular choice for building APIs.

From setting up a new Django project to handling requests and responses with serializers and views, we will be covering it all. You'll learn how to implement authentication and authorization, and how to use the built-in features of Django REST framework to make your API development process a breeze. So grab your 3D Maneuver Gear and let's begin our journey to building the ultimate API.

In case you didn’t understand Founding Titan and 3D Maneuver Gear, it refers to the popular anime and manga series Attack on Titan, which is used as a creative and unique angle for the blog post, so young readers can grasp the content easily by correlating to it.

Brief Overview of the Importance of APIs and why Django REST Framework is a good choice for building them

Welcome to the world of Django REST framework, the gateway to the digital world like the Door of Truth of the Survey Corps.

APIs, or Application Programming Interfaces, are the backbone of modern web and mobile applications, just like the Vertical Maneuvering Equipment is to the Survey Corps. They allow different software systems to communicate with each other, share data, and perform actions, much like how the Survey Corps share information and coordinate attacks against the Titans.

With the rise of cloud-based services and the Internet of Things, the need for robust and scalable APIs has never been greater, just like how the Titans continue to threaten humanity. Django REST framework is a powerful tool for building APIs that can handle large amounts of data and traffic, just like how the Survey Corps use their equipment to fight Titans.

In this article, we'll delve into the world of Django REST framework and how it can help you build powerful and efficient APIs, just like how the Survey Corps work together to protect humanity. Join us on this journey as we explore the ins and outs of Django REST framework and discover the secrets to building great APIs.

What we will cover?

By the end of this blogpost, you will have

A brief understanding of API Development Fundamentals
How to build an API in Django - which is robust and secure framework in itself
A brief understanding of API Development Lifecycle
Building a Simple API with Django REST Framework
Advanced Features: An exploration of more advanced features of Django REST Framework, such as authentication, permissions, and pagination.
Deployment and Testing: A discussion of best practices for deploying and testing APIs in a production environment.
Additional Resources to Continue Learning Further

Setting Up a Django Project for API Development

Steps for Creating a new Django project and app.

Steps for Creating a new Django Project:

Install Django by running pip install django in your command prompt or terminal.
Create a new Django project by running django-admin startproject projectname in your command prompt or terminal. Replace "projectname" with the desired name of your project.
Change into the project directory by running cd projectname in your command prompt or terminal.
Run the development server by running python manage.py runserver in your command prompt or terminal. This will start the server and make the project available at http://127.0.0.1:8000/ in your web browser.

Steps for Creating a new Django App:

Change into the project directory by running cd projectname in your command prompt or terminal.
Create a new Django app by running python manage.py startapp appname in your command prompt or terminal. Replace "appname" with the desired name of your app.
Add your app to the INSTALLED_APPS list in the settings.py file of your project.
Create a new directory called templates inside your app directory and create an HTML template file within it.
Create a new directory called models inside your app directory and create a new Python file within it to define your app's models.
Create a new file called views.py inside your app directory to define your app's views.
Create a new file called urls.py inside your app directory to define your app's URLs.
Add the app's URLs to the project's urls.py file to make the app accessible in the browser.
Run the development server by running python manage.py runserver in your command prompt or terminal to see your app in action.

Configuring the project for API Development

Install Django REST framework by running pip install djangorestframework

Install the Django REST framework by adding 'rest_framework' to the INSTALLED_APPS list in your settings.pyfile.

Handling Requests and Responses with Serializers and Views

In the world of APIs, serializers and views are like the Titans and Survey Corps of the Django REST framework - they work together to handle incoming requests and outgoing responses.

Serializers, are responsible for handling the data and providing a clean, structured format for it to be passed on to the views. They allow for easy data validation and conversion between Python objects and JSON.

Views, are responsible for handling the incoming requests and providing an appropriate response. They use the data from the serializers to create a response that follows the proper format and structure.

In the Django REST framework, there are a variety of generic views that can be used to handle different types of requests, such as the ListAPIView for handling GET requests for a list of items, or the CreateAPIView for handling POST requests to create a new item.

To use these views, simply import them and extend them in your views.py file, like so:

from rest_framework import generics

class MyView(generics.ListAPIView):
    pass

Additionally, the Django REST framework provides a simple way to handle authentication and authorization using JWT tokens, similar to how the Survey Corps uses their omni-directional mobility gear to navigate and fight the Titans.

In this section, we will cover the basics of using serializers and views in the Django REST framework, and provide examples of how to use them to create a functional API. We will also go over some of the more advanced features of the framework, such as pagination and filtering, and provide tips for debugging and testing your API. So, ready your blades and gear up, because we're about to take on the Titans of API development!

Wait, What are Serializers?

In the world of APIs, data is often sent and received in the form of JSON or XML. Serializers in Django REST framework allow us to easily convert complex data types, such as models and querysets, into JSON or XML format.

For example, in the world of Attack on Titan, let's say we have a database of information on Titans, including their height, weight, and abilities. We can use a serializer to convert this information into a format that can be easily sent over the API to our Survey Corps app, allowing them to easily access and use this information in the field.

Just like Eren and his team have to be careful while handling Titans, we have to be careful while handling serializers and views in Django REST framework to make sure that our API is working properly and efficiently.

How to Use Serializers to Handle Data

Imagine you are creating an API for an e-commerce website where users can view and purchase products. You have a Product model with fields for name, description, price, and image. To display this information to the user, you would need to convert the Product model instance into a JSON object.

To do this, you would first create a serializer class that inherits from Serializer, and define the fields that should be included in the JSON representation of the Product model. For example:

from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.Serializer):
    name = serializers.CharField()
    description = serializers.CharField()
    price = serializers.DecimalField()
    image = serializers.ImageField()

Then, in your views, you can use this serializer to handle data.

from rest_framework import views
from .models import Product
from .serializers import ProductSerializer

class ProductView(views.APIView):
    def get(self, request, format=None):
        products = Product.objects.all()
        serializer = ProductSerializer(products, many=True)
        return Response(serializer.data)

In this example, the ProductView is handling a GET request and returning a JSON representation of all products in the database. The ProductSerializer is used to convert the queryset of Product model instances into a JSON object.

In the AOT universe, consider a scenario where you are creating an API for a database of Titans. You have a Titan model with fields for name, description, size, and type. To display this information to the user, you would need to convert the Titan model instance into a JSON object.

To do this, you would first create a serializer class that inherits from Serializer, and define the fields that should be included in the JSON representation of the Titan model. For example:

from rest_framework import serializers
from .models import Titan

class TitanSerializer(serializers.Serializer):
    name = serializers.CharField()
    description = serializers.CharField()
    size = serializers.CharField()
    type = serializers.CharField()

Then, in your views, you can use this serializer to handle data.

from rest_framework import views
from .models import Titan
from .serializers import TitanSerializer

class TitanView(views.APIView):
    def get(self, request, format=None):
        titans = Titan.objects.all()
        serializer = TitanSerializer(titans, many=True)
        return Response(serializer.data)

In this example, the TitanView is handling a GET request and returning a JSON representation of all Titans in the database. The TitanSerializer is used to convert the queryset of Titan model instances into a JSON object.

How to Use Views to Handle Responses?

In the world of AOT, views can be thought of as the gatekeepers to your API's inner workings. Just like how a skilled member of the Survey Corps would be responsible for controlling access to the inner walls, views in Django REST framework are responsible for handling incoming requests and returning appropriate responses.

To use views in Django REST framework, you first need to import the necessary classes from the rest_framework package. These classes include APIView, ViewSet, and ModelViewSet. Each of these classes provides different levels of functionality for handling requests and returning responses.

For example, you can use the APIView class for basic views that handle simple requests and return simple responses. On the other hand, you can use the ModelViewSet class for views that handle requests related to a specific model and return responses that include data from that model.

In addition to these classes, you can also use other tools provided by Django REST framework to handle views such as @action decorator, @authentication_classes and @permission_classes decorators.

Here's an example of how you might use the APIView class to handle a request and return a response in an AOT themed API:

from rest_framework.views import APIView
from rest_framework.response import Response

class AttackOnTitanAPIView(APIView):
    def get(self, request):
        data = {'message': 'Attack on Titan API is ready for action!'}
        return Response(data)

In this example, the AttackOnTitanAPIView class is a basic view that inherits from the APIView class. The get method is overridden to handle GET requests and return a response containing a message. This is just a simple example but it can be further built upon to handle more complex requests and return more dynamic responses.

So, like the Survey Corps, you can use views to control access to your API and protect it from Titans. With the help of Django REST framework's views, you can handle incoming requests and return appropriate responses, just like how Survey Corps protects the walls from Titans.

Implementing Authentication and Authorization

Authentication Methods Available in Django REST Framework

Authentication in Django REST framework is used to verify the identity of the user making a request to the API. There are several authentication methods available in Django REST framework, including:

Basic Authentication : This is a simple method of authentication where the client sends a request with a username and password in the headers. The server then verifies the credentials and returns a response.
Token Authentication : This method uses a token-based approach for authentication, where the client sends a request with a token in the headers. The server then verifies the token and returns a response.
Session Authentication : This method uses session-based authentication, where the client sends a request with a session ID in the headers. The server then verifies the session ID and returns a response.
JWT Authentication : JWT (JSON Web Token) is a popular way of handling authentication and authorization in RESTful APIs. With JWT, the client sends a request with a token in the headers, which is verified by the server.

In this blogpost, we will discuss how to use JWT tokens for authentication and authorization in AOT style.

It's important to mention that in this example, we will be using djangorestframework-jwt package.

How to use JWT Tokens for Authentication and Authorization

It is important to keep the secrets of the Survey Corps safe. And just like how Eren's Founding Titan powers are protected by a special key, we can use JSON Web Tokens (JWT) to keep our API secure.

JWT is a type of token-based authentication that is often used in RESTful APIs. It allows the server to authenticate the client without the need for a session or cookies. Instead, the client sends a token with each request, and the server verifies that the token is valid before processing the request.

To use JWT in a Django REST framework project, we can use the djangorestframework-jwt package. First, install it using pip:

pip install djangorestframework-jwt

Next, add 'rest_framework_jwt.authentication.JSONWebTokenAuthentication' to the AUTHENTICATION_CLASSES setting in your settings.py file:

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
    ),
}

Now, when a client sends a request to your API with a valid JWT in the Authorization header, the request will be considered authenticated.

Incorporating JWT tokens for authentication and authorization in views can be done by using the djangorestframework_simplejwt library. This library provides a set of views and authentication classes that can be easily added to your Django REST framework views.

First, you will need to install the library by running pip install djangorestframework_simplejwt.

Next, you will need to add the library's views and authentication classes to your project's urls.py file. Here is

from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView

urlpatterns = [
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

Then, you can add the JWTAuthentication class to the authentication_classes attribute of your views. Here is an example of how to do this:

from rest_framework_simplejwt.authentication import JWTAuthentication

class MyAPIview(APIView):
    authentication_classes = [JWTAuthentication]

In this way you will be able to authenticate and authorize your API views using JWT tokens.

Note that this is a very basic example, in real-world scenarios you will need to configure the JWT settings and handle token expiration, refresh, etc.

It's also possible to use JWT for authorization. When a client sends a request with a JWT, the server can decode the token to access the claims (e.g. user id, role) and use them to determine if the client has access to the requested resource.

However, keep in mind that JWT is not an encryption, it's a signed token. Never put sensitive data on JWT.

It is always recommended to use JWT in combination with an SSL certificate to encrypt the data in transit.

You can also use other authentication methods like SessionAuthentication and BasicAuthentication , but JWT is considered more secure and is often preferred for use in RESTful APIs.

Best Practices for Securing an API

When it comes to securing your API, there are a few best practices you should keep in mind to ensure the safety and privacy of your users' data.

Use token-based authentication. JSON Web Tokens (JWT) are a popular choice for authentication in RESTful APIs. They allow for stateless authentication and provide a secure way to transmit data between parties.
Implement role-based access control. By assigning roles to users, you can limit the actions they can perform within your API. For example, a user with the role of "admin" would have more permissions than a user with the role of "guest".
Use HTTPS. When transmitting data over the internet, it's important to use a secure protocol like HTTPS to encrypt the data and prevent man-in-the-middle attacks.
Validate user input. Always validate user input to prevent malicious attacks like SQL injection or cross-site scripting.
Monitor your API for suspicious activity. Keep an eye out for unusual patterns of usage, such as a high number of failed login attempts or a large number of requests coming from a single IP address.

By following these best practices, you can ensure that your API is secure and protected from potential threats.

Note : Always keep the theme in mind and you can use Attack on Titans references like "Just like how Eren protects the walls, it's important to protect your API with token-based authentication" etc.

Additional Features of Django REST Framework

Pagination and Filtering of API Responses

Pagination and filtering are important features of any API, as they allow the client to retrieve only the relevant data and avoid overwhelming them with unnecessary information. In Django REST framework, these features are built-in and can be easily implemented.

To paginate the results of a view, you can use the pagination_class attribute on the view. For example, if you want to use the built-in PageNumberPagination class, you can do the following:

from rest_framework.pagination import PageNumberPagination

class MyView(APIView):
    pagination_class = PageNumberPagination
    # ...

You can also customize the pagination class to suit your needs. For example, you can change the default page size or add a custom header to the response.

Filtering the results of a view is also a straightforward process. You can use the filter_backends attribute on the view to specify the filter classes that you want to use. For example, you can use the built-in DjangoFilterBackend class to filter the results based on query parameters:

from rest_framework.filters import DjangoFilterBackend

class MyView(APIView):
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['name', 'age']
    # ...

This allows clients to filter the results by sending query parameters like ?name=John&age=30.

To implement pagination and filtering, you can use Query and QuerySet provided by django-filter package and Pagination provided by django-rest-framework package. Also, you can add a custom header to response like X-Total-Count to show the total number of results.

How to use Built-In Documentation Feature?

The Django REST framework comes with a built-in documentation feature that allows developers to easily generate documentation for their APIs. This feature is based on the popular drf-yasg (Django REST framework - Yet Another Swagger Generator) library, which uses the OpenAPI specification to generate interactive documentation for APIs.

To use the built-in documentation feature, first, you need to install drf-yasg by running the following command:

pip install drf-yasg

Next, add 'drf_yasg' to your INSTALLED_APPS in the settings.py file.

INSTALLED_APPS = [
    ...,
    'drf_yasg',
]

Then, add the following to your urls.py file to enable the documentation feature:

from drf_yasg.views import get_schema_view
from drf_yasg import openapi

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

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

With this setup, you can now access the API documentation by visiting the /swagger/ or /redoc/ URLs in your browser. The documentation is generated based on the APIViews and Serializers you have defined in your project and will be automatically updated whenever you make changes to them.

You can also customize the appearance and functionality of the documentation by configuring the get_schema_view() function and the Info class to suit your needs.

Tips for Debugging and Testing the API endpoints

When building APIs with Django REST framework, it's important to have a solid debugging and testing strategy in place to ensure that your endpoints are functioning correctly. One way to do this is to use the built-in debugging tools provided by Django, such as the django-debug-toolbar and the logging module.

Another helpful tip for debugging API endpoints is to use the django-extensions package, which adds additional management commands to the Django command line, including a shell_plus command that allows you to interact with your models directly from the command line.

For testing, Django REST framework provides a APITestCase class that you can use to create test cases for your views and serializers. This class provides a client attribute that allows you to make requests to your API endpoints and check the responses.

In addition to these built-in tools, it's also a good idea to use a tool like Postman or Insomnia to manually test your API endpoints and ensure that they are returning the expected results.

You can imagine Eren Yeager trying to break through the wall, as an example of debugging and testing your API endpoints, in order to ensure that they are working correctly and securely, you should test and debug your API endpoints to make sure they are functioning as expected.

Designing and Structuring API endpoints

Best Practices for Designing and Structuring API endpoints

When designing and structuring API endpoints for your Attack on Titan themed project, it's important to consider a few best practices to ensure that your API is easy to use, maintainable, and scalable.

Use clear and consistent naming conventions : Use descriptive, easy-to-understand names for your endpoints. For example, instead of naming an endpoint /api/get_data, use /api/titans/.
Group related endpoints together : Group related endpoints together under a common prefix. For example, all endpoints related to Titans should be grouped under /api/titans/.
Use HTTP methods appropriately : Use the appropriate HTTP method for each endpoint. For example, use GET for retrieving data, POST for creating new resources, PUT for updating existing resources, and DELETE for deleting resources.
Version your API : Versioning your API is important to ensure that changes to your API do not break existing clients. This can be done by including the version number in the endpoint's URL. For example, /api/v1/titans/.
Provide clear and accurate error messages : If an error occurs, provide clear and accurate error messages to help developers troubleshoot the issue.

By following these best practices, you can ensure that your API is easy to use, maintainable, and scalable, making it a valuable tool for your team and your audience.

Different Types of API endpoints

Resource-based endpoints : These endpoints are based on a specific resource, such as a user or a product. For example, /users/ or /products/. These endpoints are typically used for CRUD (create, read, update, delete) operations on the resource.
Collection-based endpoints : These endpoints are based on a collection of resources, such as a list of users or a list of products. For example, /users/ or /products/. These endpoints are typically used to retrieve a list of resources.
Action-based endpoints : These endpoints are based on a specific action that can be performed on a resource or a collection of resources. For example, /users/search/ or /products/order/. These endpoints are typically used to perform non-CRUD operations on the resource.
Hybrid endpoints : These endpoints combine the functionality of resource-based and action-based endpoints. For example, /users/{id}/activate/ or /products/{id}/reviews/. These endpoints are typically used for more complex operations on the resource.

It is important to note that the above types of endpoints are not mutually exclusive and a single endpoint can have multiple types of functionality. For example, a /users/ endpoint may have functionality for both resource-based and collection-based operations.

When designing and structuring API endpoints, it is important to follow RESTful principles and use clear, consistent, and predictable URL structures. Additionally, it is also important to consider how the endpoints will be consumed by the client and to provide clear documentation for each endpoint.

How to Version the API?

When building an API, it's important to plan for the possibility of making changes to the API in the future. One way to do this is by versioning the API.

There are a few different ways to version an API, but the most common approach is to include the version number in the URL. For example, instead of having a URL like https://example.com/api/users, you might have https://example.com/api/v1/users to indicate that this is version 1 of the API.

Another approach is to include the version number in the request headers. For example, you might include a Accept header with the value application/vnd.example.v1+json to indicate that the client is requesting version 1 of the API.

When making changes to the API, it's important to keep the old version available for a period of time to give existing clients time to update. This is known as deprecation. It's also a good practice to document the changes made in each version of the API to make it easier for developers to understand the changes.

When it comes to AOT themed API versioning, we can use the concept of the different arcs and arcs in the anime series to version different endpoints. So an endpoint under the AOT: Arc 1 version would be different than an endpoint under the AOT: Arc 2 version.

It's important to keep in mind that versioning is a trade-off between flexibility and stability. The more versions you have, the more flexibility you have to make changes, but the more complexity you introduce for clients to keep track of. It's important to find a balance that works for your use case.

Conclusion

What have we learned?

In this blog post, we have learned about the importance of APIs and how Django REST framework can be used to build them. We have covered various topics such as setting up a Django project for API development, handling requests and responses with serializers and views, implementing authentication and authorization, and additional features of Django REST framework such as pagination and filtering of API responses, documentation and debugging and testing.

We also went over AOT themed examples and how it can be incorporated in various sections of the blog post. Additionally, we discussed best practices for designing and structuring API endpoints, different types of endpoints, and how to version the API.

Additional Resources

To continue learning about Django REST framework and building APIs, we recommend the following resources:

The official Django REST framework documentation: https://www.django-rest-framework.org/
The Django REST framework tutorial: https://www.django-rest-framework.org/tutorial/quickstart/
Building APIs with Django and Django REST framework: https://www.safaribooksonline.com/library/view/building-apis-with/9781491949268/
Django REST framework: The beginner's guide: https://www.oreilly.com/library/view/django-rest-framework/9781789802482/

Thank you for reading, and I hope you found this blog post helpful in your journey to building APIs with Django REST framework.

This blog post was originally published on my blog. You can check it out for more such posts

The Ultimate Django Cheatsheet: Because Even Ninjas Need a Little Help Sometimes

Dev Mehta — Thu, 26 Jan 2023 00:00:00 +0000

This blogpost was originally published on my blog. You can check it out for more such posts.

Are you a Django ninja who's feeling a little rusty on the details? Or a newbie just trying to navigate the complex world of web development? Well, we've got you covered with the ultimate Django cheatsheet!

First up, let's start with some basic commands. Want to create a new project? Just type django-admin startproject projectname into the command line. Want to start the development server? python manage.py runserver is your new best friend.

But what about when things get a little more complex? Fear not, because we've got you covered with some handy tips and tricks.

Want to create a new app within your project? python manage.py startapp appname is all you need.
Need to create a new database table? Use python manage.py makemigrations appname to create the initial migration, and then python manage.py migrate to actually apply the changes.
Want to add a new field to an existing table? Use python manage.py makemigrations appname again, and then python manage.py migrate as before.
Need to create a new superuser? python manage.py createsuperuser will prompt you for a username, email, and password.

And those are just the basics! With the ultimate Django cheatsheet by your side, you'll be able to tackle even the most complex projects with ease. So don't be afraid to get your hands dirty and dive into the world of web development. Because with Django, the possibilities are endless.

So, don't be afraid to use this cheatsheet like a pro and remember, even the most experienced Ninjas needs a little help sometimes.

Defining Django Models

Here's an example of a Django model for a Ninja class in the style of the popular anime/manga series Naruto:

from django.db import models

class Ninja(models.Model):
    name = models.CharField(max_length=255)
    village = models.CharField(max_length=255)
    jutsu = models.TextField()
    chakra = models.IntegerField()
    registered_date = models.DateTimeField(auto_now_add=True)
    sharingan = models.BooleanField(default=False)
    team = models.CharField(max_length=255, blank=True, null=True)
    picture = models.ImageField(upload_to='ninja_images', blank=True, null=True)

    def __str__ (self):
        return self.name

This model defines a Ninja class that inherits from models.Model. It has several fields: name, village, jutsu, chakra, registered_date, sharingan, team, and picture.

The name and village fields are both CharFields, with a maximum length of 255 characters. The jutsu field is a TextField, which can store longer pieces of text, and chakra is an IntegerField representing the amount of chakra a ninja has.

The registered_date field is a DateTimeField with auto_now_add=True this means that it will automatically be set to the current date and time when a new Ninja is created.

The sharingan field is a BooleanField which can be used to represent whether the ninja has the Sharingan or not, with a default value of False.

The team field is a CharField with a maximum length of 255 characters, and is optional(blank=True, null=True) since not all ninjas are part of a team.

Finally, the picture field is an ImageField that will handle the upload of an image of the ninja and store it in the 'ninja_images' directory.

Defining views

Here's an example of a views.py file for a Django application in the style of the popular anime/manga series Naruto:

from django.shortcuts import render
from django.http import HttpResponse
from .models import Ninja

def index(request):
    all_ninjas = Ninja.objects.all()
    context = {'all_ninjas': all_ninjas}
    return render(request, 'ninjas/index.html', context)

def ninja_detail(request, ninja_id):
    ninja = Ninja.objects.get(pk=ninja_id)
    context = {'ninja': ninja}
    return render(request, 'ninjas/ninja_detail.html', context)

def team(request, team_name):
    team_members = Ninja.objects.filter(team__iexact=team_name)
    context = {'team_members': team_members, 'team_name': team_name}
    return render(request, 'ninjas/team.html', context)

def search(request):
    query = request.GET.get('q')
    search_results = Ninja.objects.filter(name__icontains=query)
    context = {'search_results': search_results, 'query': query}
    return render(request, 'ninjas/search.html', context)

This views.py file contains several functions that handle different pages of the application:

The index function retrieves all the Ninja objects from the database using the Ninja.objects.all() method and stores them in the context dictionary. Then it renders the index.html template and passes the context to it.
The ninja_detail function retrieves a specific Ninja object from the database using the Ninja.objects.get(pk=ninja_id) method and stores it in the context dictionary. Then it renders the ninja_detail.html template and passes the context to it.
The team function retrieves all the Ninja objects that belong to a specific team using the Ninja.objects.filter(team__iexact=team_name) method and stores them in the context dictionary. Then it renders the team.html template and passes the context to it.
The search function retrieves all the Ninja objects whose name contains a specific query using the Ninja.objects.filter(name__icontains=query) method and stores them in the context dictionary. Then it renders the search.html template and passes the context to it.

It's important to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Connecting Views to URL Endpoints

Here’s an example of how to connect the views we have defined to their endpoints

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('ninja/<int:ninja_id>/', views.ninja_detail, name='ninja_detail'),
    path('team/<str:team_name>/', views.team, name='team'),
    path('search/', views.search, name='search'),
]

This urls.py file maps URLs to the corresponding views in the views.py file:

The empty string '' maps to the index view.
The string 'ninja/<int:ninja_id>/' maps to the ninja_detail view, and includes a variable ninja_id that is passed to the view as an argument.
The string 'team/<str:team_name>/' maps to the team view, and includes a variable team_name that is passed to the view as an argument.
The string 'search/' maps to the search view.

You can also notice that each path has a name, this names can be used in the template to generate URLs. Also, it's important to include this urls.py file in the main urls.py file of your project with the include function.

Rendering HTML Responses for above views

index.html

<h1>Welcome to the Ninja Database</h1>
<ul>
{% for ninja in all_ninjas %}
    <li><a href="{% url 'ninja_detail' ninja.id %}">{{ ninja.name }}</a> from {{ ninja.village }}</li>
{% endfor %}
</ul>

This template displays a heading and an unordered list of all the ninjas in the database. Each list item contains a link to the ninja_detail view for that specific ninja, using the {% url %} template tag to generate the URL and passing the ninja.id as the ninja_id argument.

ninja_detail.html

<h1>{{ ninja.name }}</h1>
<p>Village: {{ ninja.village }}</p>
<p>Jutsu: {{ ninja.jutsu }}</p>
<p>Chakra: {{ ninja.chakra }}</p>
<p>Has Sharingan: {% if ninja.sharingan %}yes{% else %}no{% endif %}</p>
<p>Team: {% if ninja.team %}{{ ninja.team }}{% else %}none{% endif %}</p>
{% if ninja.picture %}
    <img src="{{ ninja.picture.url }}" alt="{{ ninja.name }}">
{% endif %}

This template displays the details of a single ninja, including name, village, jutsu, chakra, Sharingan,etc.

Function Based Views

from django.shortcuts import render, get_object_or_404
from .models import Ninja

def index(request):
    all_ninjas = Ninja.objects.all()
    context = {'all_ninjas': all_ninjas}
    return render(request, 'ninjas/index.html', context)

def ninja_detail(request, ninja_id):
    ninja = get_object_or_404(Ninja, pk=ninja_id)
    context = {'ninja': ninja}
    return render(request, 'ninjas/ninja_detail.html', context)

def team(request, team_name):
    team_members = Ninja.objects.filter(team__iexact=team_name)
    context = {'team_members': team_members, 'team_name': team_name}
    return render(request, 'ninjas/team.html', context)

def search(request):
    query = request.GET.get('q')
    search_results = Ninja.objects.filter(name__icontains=query)
    context = {'search_results': search_results, 'query': query}
    return render(request, 'ninjas/search.html', context)

This is similar to the previous example, the main difference is the use of get_object_or_404 function in ninja_detail view to handle cases when the ninja_id passed in the URL is not found.

It's important to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Class Based Views

from django.shortcuts import render
from django.views.generic import ListView, DetailView
from .models import Ninja

class NinjaListView(ListView):
    model = Ninja
    template_name = 'ninjas/index.html'
    context_object_name = 'all_ninjas'

class NinjaDetailView(DetailView):
    model = Ninja
    template_name = 'ninjas/ninja_detail.html'
    context_object_name = 'ninja'

class TeamView(ListView):
    template_name = 'ninjas/team.html'
    context_object_name = 'team_members'

    def get_queryset(self):
        return Ninja.objects.filter(team__iexact=self.kwargs['team_name'])

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['team_name'] = self.kwargs['team_name']
        return context

class SearchView(ListView):
    template_name = 'ninjas/search.html'
    context_object_name = 'search_results'

    def get_queryset(self):
        query = self.request.GET.get('q')
        return Ninja.objects.filter(name__icontains=query)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['query'] = self.request.GET.get('q')
        return context

This is similar to the function-based views example, but it uses Django's built-in class-based views to handle the common logic of displaying lists and details of objects. The ListView and DetailView classes are generic views that handle fetching and paginating the objects from the database, and rendering the template.

It's important to notice that TeamView and SearchView are subclasses of ListView and they implement the methods get_queryset and get_context_data to handle the specific logic of displaying a team members and search results. It's important also to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Forms

from django import forms
from .models import Ninja

class NinjaForm(forms.ModelForm):
    class Meta:
        model = Ninja
        fields = ['name', 'village', 'jutsu', 'chakra', 'sharingan', 'team', 'picture']

    def __init__ (self, *args, **kwargs):
        super(). __init__ (*args, **kwargs)
        self.fields['jutsu'].widget.attrs.update({'class': 'jutsu-selector'})
        self.fields['team'].widget.attrs.update({'class': 'team-selector'})
        self.fields['picture'].widget.attrs.update({'class': 'picture-input'})

class SearchForm(forms.Form):
    query = forms.CharField(label='Search for a ninja', max_length=100)
    team = forms.ChoiceField(choices=[('', 'All teams'), ('Team 7', 'Team 7'), ('Team 8', 'Team 8'), ('Team 10', 'Team 10'), ('Akatsuki', 'Akatsuki')], required=False)

This is an example of how to create a form to manage the data of a Ninja model. The NinjaForm class is a ModelForm that is created using the Ninja model and the fields specified in the fields attribute.

The __init__ method is overriden to add classes to the widgets of the form fields, for example jutsu-selector to jutsu field, team-selector to team field and picture-input to picture field.

The SearchForm class is a regular Form class, it's created using the CharField and ChoiceField form fields. The query field is used to search for a ninja by name, and the teamfield is used to filter the search results by team.

The choices attribute of the ChoiceField is used to specify the available teams to filter by, and the required=False attribute is used to make the field optional, so the user can search for ninjas without filtering by team.

Django Apps

python manage.py startapp uchiha-clan

This command will create a new directory called "uchiha-clan" in your project's root directory. This directory will contain the necessary files and directories for a Django app, such as models.py, views.py, urls.py, migrations/ and admin.py.

You can then use the files in this directory to define your models, views, URLs, and other components of your app related to uchiha clan.

It's important to notice that after creating the app, you should make sure to add it to the INSTALLED_APPS list in the settings.py file of your project so that Django knows about the new app and can use it.

Adding an app to settings.py

Database Configuration

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Timezone Configuration

TIME_ZONE = 'UTC'

Application Configuration

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app1',
    'app2',
    'app3',
]

Middleware Configuration

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Allowed Hosts

The ALLOWED_HOSTS setting is used to specify a list of hostnames that this Django site can serve. This is a security measure to prevent an attacker from poisoning caches and password reset emails with links to malicious hosts by submitting requests with a fake HTTP Host header, which is possible even under many seemingly-safe webserver configurations.

ALLOWED_HOSTS = ['example.com', 'www.example.com']

Static files

In production, you will also want to serve your static files using a separate web server, such as Apache or Nginx, rather than using the built-in Django development server. You'll need to configure your web server to serve the files in the STATIC_ROOT directory.

Here's an example of how you might set STATIC_ROOT and STATIC_URL in your settings.py file:

STATIC_ROOT = os.path.join(BASE_DIR, 'static')
STATIC_URL = '/static/'

In addition, you might want to configure your web server to serve media files as well.

Conclusion

In conclusion, mastering the art of Django can be a daunting task, but with our ninja-inspired cheatsheet, you'll be slicing and dicing your way to the top of the leaderboard in no time! Whether you're a beginner or an expert, you'll be able to unleash the full power of the Sharingan with our easy-to-use guide. Remember, just like the Uchiha clan, you too can have the power to control the nine-tailed fox (or in this case, your code) with the right training. So what are you waiting for? Grab your kunai and get coding like a true ninja!

This blogpost was originally published on my blog. You can check it out for more such posts.