In this article, we will explore some of the top advanced Django features that you may need to be using.

1. Custom model fields

Django comes with a wide variety of built-in model fields, but sometimes you need to implement your own custom fields for specialized data types. That’s where custom model fields come in. You can write your own field that implements custom validation logic and integrates with Django’s ORM. For example, you could write a custom field that stores phone numbers as normalized strings:

from django.db import models
from phonenumbers import parse, format_number, PhoneNumberFormat

class PhoneNumberField(models.CharField):
  def __init__(self, *args, **kwargs):
    kwargs['max_length'] = 20
    super().__init__(*args, **kwargs)
    def from_db_value(self, value, expression, connection):
      if value is None:
        return value
      return format_number(parse(value), PhoneNumberFormat.E164)

    def to_python(self, value):
      if value is None or isinstance(value, str):
        return value
      return format_number(value, PhoneNumberFormat.E164)

    def get_prep_value(self, value):
      return self.to_python(value)

You could then use this field in your models like any other field:

from django.db import models
from myapp.fields import PhoneNumberField

class Contact(models.Model):
  name = models.CharField(max_length=100)
  phone_number = PhoneNumberField()

2. Caching

Django provides a caching framework that allows you to cache the results of expensive database queries or other computations. This can significantly improve the performance of your application by reducing the number of times you need to perform those operations. For example, you could cache the results of a database query using the cache_page decorator:

from django.views.decorators.cache import cache_page
from myapp.models import Product

@cache_page(60 * 15) # Cache for 15 minutes
def get_products(request):
    products = Product.objects.all()
    return render(request, 'products.html', {'products': products})

This will cache the results of the get_products view for 15 minutes, so subsequent requests will be served from the cache rather than querying the database again.

3. Asynchronous views

Django supports asynchronous views using the async and await keywords in Python. This allows you to write non-blocking code that can handle many requests simultaneously, improving the performance of your application. For example, you could use the asyncio library to write an asynchronous view that fetches data from an external API:

import asyncio
import aiohttp
from django.http import JsonResponse

async def get_data(request):
  async with aiohttp.ClientSession() as session:
    async with session.get('https://api.abdullahmujahidali.com/data') as response:
      data = await response.json()
  return JsonResponse(data)

4. Query Expressions

Django’s query expressions allow you to perform complex database queries using simple syntax. You can use query expressions to perform aggregation, filtering, and annotation operations. For example, you could use a query expression to calculate the difference between two fields:

from django.db.models import F
from myapp.models import Product

Product.objects.annotate(price_diff=F('price') - F('cost'))

5. Database Optimization

Django offers several tools to help you optimize your database queries and make your application faster. Some of these tools include:

1. Querysets: Querysets allow you to build complex queries in a chainable, object-oriented way. You can use query sets to filter, sort, and paginate your data.
2. Select Related: The select_related method allows you to fetch related objects in a single database query, rather than making multiple queries.
3. Prefetch Related: The prefetch_related method allows you to fetch related objects in a separate query, allowing you to avoid the N+1 query problem.

6. Custom Manager

Django’s model manager is a powerful tool that allows you to encapsulate query logic within a model. However, you can also create custom managers to encapsulate more complex query logic. For example, you could create a manager that fetches all objects that have been updated within the last 24 hours:

from django.db import models
from datetime import datetime, timedelta

class UpdatedWithinManager(models.Manager):
  def get_queryset(self):
    return super().get_queryset().filter(updated_at__gte=datetime.now() - timedelta(hours=24))

7. PostgreSQL-specific features

Django supports a variety of databases, but its support for PostgreSQL is especially robust. PostgreSQL offers many features that can help you optimize your database queries and make your application faster. Some of the PostgreSQL-specific features that you can use with Django include:

1. Window Functions: Window functions allow you to perform calculations across rows of a table, allowing you to do things like calculate running totals or moving averages.
2. Full-Text Search: PostgreSQL’s full-text search allows you to search for words or phrases within a document, even if they are not exact matches.
3. JSONB Fields: JSONB fields allow you to store JSON data in a PostgreSQL database and perform queries on that data.

8. Content Types

Django’s content types framework allows you to create generic relationships between models. This can be especially useful when you have a model that can be related to multiple other models. For example, you could create a model that represents a comment, and use content types to allow comments to be associated with any model in your application.

from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType

class Comment(models.Model):
  content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
  object_id = models.PositiveIntegerField()
  content_object = GenericForeignKey('content_type', 'object_id')
  text = models.TextField()

9. Custom management commands

Django comes with a powerful command-line interface for managing your application, but sometimes you need to perform more complex tasks than the built-in commands allow. That’s where custom management commands come in. You can write your own commands that perform custom logic and can be executed from the command line. For example, you could write a command that deletes all expired user accounts:

from django.core.management.base import BaseCommand
from django.contrib.auth.models import User
from datetime import datetime

class Command(BaseCommand):
  help = 'Deletes all expired user accounts'
  def handle(self, *args, **options):
    now = datetime.now()
    expired_users = User.objects.filter(last_login__lt=now)
    expired_users.delete()
    self.stdout.write(self.style.SUCCESS(f'Deleted {len(expired_users)} expired users.'))

10. Custom authentication backends

Django comes with several built-in authentication backends, but sometimes you need to implement your own custom authentication logic. That’s where custom authentication backends come in. You can write your own authentication backend that implements custom authentication logic and integrates with Django’s authentication framework. For example, you could write an authentication backend that allows users to log in with their email address instead of their username:

from django.contrib.auth.backends import BaseBackend
from django.contrib.auth.models import User

class EmailBackend(BaseBackend):
  def authenticate(self, request, email=None, password=None, **kwargs):
    try:
      user = User.objects.get(email=email)
    except User.DoesNotExist:
      return None

    if user.check_password(password):
      return user

  def get_user(self, user_id):
    try:
      return User.objects.get(pk=user_id)
    except User.DoesNotExist:
      return None

You could then add this backend to your AUTHENTICATION_BACKENDS setting in settings.py to enable it:

AUTHENTICATION_BACKENDS = [
  'myapp.backends.EmailBackend',
  'django.contrib.auth.backends.ModelBackend',
]

In conclusion, Django is a powerful web framework that offers a wide range of advanced features that can help you optimize your web application and improve its performance. By taking advantage of these features, you can create complex applications that can handle large amounts of traffic and data. From custom model fields to custom authentication backends, Django offers a variety of tools that can help you build a robust and efficient web application. So, take the road less traveled and explore these advanced features to take your Django development skills to the next level.

If you’re a Python developer, you’re probably familiar with the traditional if statement and its many variations. But did you know that Python 3.10 introduces a powerful new feature called Structural Pattern Matching? With Structural Pattern Matching, you can easily match against complex data structures like lists and dictionaries using patterns. In this post, I'll introduce you to this exciting new feature and show you how it can simplify your code and increase your productivity.

To illustrate how Structural Pattern Matching works, let’s take a look at a simple example. Suppose we have a list called data with three elements: 1, 2, and 3. We want to match against data using several different patterns. Here's the code:

data = [1, 2, 3]

match data:
    case [1, 2]:
        print("Found 1 and 2")
    case [1, x]:
        print(f"Found 1 and {x}")
    case [_, _, _]:
        print("Found a list of 3 elements")
    case _:
        print("Found something else")

The output of the code will be Found a list of 3 elements

In this code, we use the match statement to match against data using several different patterns. The first pattern matches against a list with exactly two elements: 1 and 2. The second pattern matches against a list with two elements, where the first element is 1 and the second element can be anything (stored in the variable x). The third pattern matches against a list with exactly three elements. The last pattern matches against anything else and prints a message.

With Structural Pattern Matching, you can simplify your code and make it more expressive, allowing you to focus on the logic of your program instead of the details of your data. So why not give it a try in your next Python project and see how it can help you write better code?

In conclusion, Structural Pattern Matching is a powerful new feature in Python 3.10 that can simplify your code and increase your productivity. I hope this post has given you a taste of what’s possible with this exciting new feature. If you want to learn more, be sure to check out the official Python documentation for Structural Pattern Matching.

I was developing a simple application that involved server-side rendering. I know and have used Next JS to achieve this quite a few times. I was trying to find something new that I could learn from and also share with the audience. I came across Fresh, a cutting-edge web framework that provides a seamless and flexible solution for server-side rendering, and it’s powered by Deno 👀 (but let’s not talk about Deno, that will be for some other day 😁).

Fresh is definitely worth checking out.

Here’s why Fresh is the best choice for server-side rendering:

1. Fresh is built with performance in mind. It uses a lightweight and minimalistic approach, resulting in faster page load times and better overall performance.
2. The fresh framework is beginner-friendly its intuitive API and clear documentation make it easy to get started and create complex server-side rendering applications.
3. Fresh provides 0 runtime overhead.
4. Fresh provides Island based client hydration.
5. Fresh comes with typescript and can be easily integrated with React JS etc.
6. Let’s look at the below comparison between Fresh and Next.js 13 to showcase the differences in their approach to server-side rendering

Fresh:

// server.js file
const { createServer } = require('fresh')
const { html } = require('fresh/render')

const app = createServer()

app.get('/', async (req, res) => {
  const postData = await fetch('/api/getData')
  const { mainTitle, paragraph } = await postData.json()
  const pageHtml = html`
    <html>
      <head>
        <title>${mainTitle}</title>
      </head>
      <body>
        <h1>${mainTitle}</h1>
        <p>${paragraph}</p>
      </body>
    </html>
  `
  res.send(pageHtml)
})
app.listen(3000, () => {
  console.log('Server is up and running')
})

Next.js:

// pages/index.js

import { useState, useEffect } from 'react'
function Index() {
  const [post, setPost] = useState({ mainTitle: '', body: '' })
  useEffect(() => {
    async function fetchData() {
      const res = await fetch('/api/getData')
      const json = await res.json()
      setPost(json)
    }
    fetchData()
  }, [])
  return (
    <div>
      <h1>{post.mainTitle}</h1>
      <p>{post.body}</p>
    </div>
  )
}
export default Index

Fresh takes a simpler and more direct approach to server-side rendering, with HTML created directly on the server using a template literal. The Next.js example, on the other hand, renders the HTML on the server and client using React components.

While Next.js allows for greater flexibility and control over the rendering process, it may also be more difficult and time-consuming to set up. Fresh, on the other hand, is designed to be lighter and easier to use, making it an excellent choice for basic applications or those requiring speedier performance.

Thus, Fresh’s approach to server-side rendering is simpler and more direct for creating HTML on the server, whereas Next.js allows greater flexibility and control via React components. Depending on the nature of your project, either strategy may be preferable, but Fresh’s simplicity and quickness make it an appealing alternative to investigate.