Creating a Django Application using UV

Creating a web application involves numerous steps, and leveraging powerful libraries and frameworks can streamline this process. Regarding Python-based web development, Django is widely regarded as one of the best frameworks due to its speed, scalability, and sophisticated web application development capabilities. An exciting addition to this ecosystem is the `uv` library, which optimizes Django's capabilities further by providing a robust and scalable web server interface.In this blog post, we will dive into the steps required to bootstrap a Django application using uv. Whether you're a seasoned developer looking to refine your development process or a beginner eager to learn, this guide will explain all you need to know to get started.

Understanding the Basics

Before we dive in, let's paint a picture of the `uv` package. UV is a new package manager, completely written in Rust. As such, it enjoys a major and significant performance boost when it comes to bootstrapping and scaffolding applications, as well as processing and installing dependency packages.

Prerequisites

Before bootstrapping a Django application with uv, ensure that you have the following:

1. Python Installed: Ensure Python is installed on your system (version >= 3.10 is recommended).
2. UV Setup: see documentation here for more information.

Step-by-Step Guide

Step 1: Set Up Your Virtual Environment

First, let's set up a virtual environment for our Django project. With UV, this should be very easy. Open your terminal, navigate to your desired directory, and execute the following commands:

		uv venv .venv # venv is the default; if this is fine for you, go ahead and use that 
source myenv/bin/activate # On Windows use `myenv\Scripts\activate`
	

Step 2: Install Django and Uvicorn

With your virtual environment activated, install both Django and uvicorn using uv:

		uv pip install Django uvicorn
	

Step 3: Create a New Django Project

Once the installations are complete, you can bootstrap a new Django project:

		django-admin startproject my_django_app
cd my_django_app
	

Step 4: Create a Django App

Create a Django app within your project. This will allow you to segment functionality:

		python manage.py startapp my_app
	

Django’s startapp command creates a ready-to-use “skeleton” for a new application, essentially scaffolding a sub-application within your Django project. When you run a command like python manage.py startapp myapp, Django creates a new directory called myapp that contains a standardized set of files and folders meant to kickstart your development work. Here’s a breakdown of what gets set up and why:

• init.py – This empty file marks the myapp directory as a Python package, enabling Python to treat it as a module you can import.
• apps.py – This file defines an AppConfig class, which holds configuration for your app (like its name). This class helps Django manage app-specific settings and integrate it more seamlessly into your project’s overall configuration.
• models.py – This is where you’ll define your database models. It’s the starting point for declaring the data structures (with Django ORM) that your application will use.
• views.py – This file is created as a place to write your view functions or class-based views, which handle incoming HTTP requests and return responses.
• tests.py – Django adds this file to encourage test-driven development. It’s where you write tests to ensure your components function properly as your application grows.
• admin.py – This file is meant for registering your models with the Django admin site so that you can manage them via the built-in interface.
• migrations/ folder – This directory, which includes its own init.py, is the designated storage area for database migration files. When you later run python manage.py makemigrations and migrate, Django will generate and apply migrations from here.

This scaffold is intentionally minimal; it doesn’t impose any structure beyond giving you a clean slate to build on. Once the app is created, you need to add it to the project’s INSTALLED_APPS list in your settings file so Django knows about it.

Step 5: Configure the Uvicorn Server

With your application set up, it's time to configure uv. In your project's directory, create a new Python file to initiate the uvicorn server:

		# filename: run.py

import uvicorn

if name == "main":
    uvicorn.run("my_django_app.asgi:application", host="127.0.0.1", port=8000, log_level="info")
	

Step 6: Update Django to Support ASGI

Ensure your Django application can connect with ASGI. Open your Django project's ASGI configuration file, commonly found at my_django_app/asgi.py, and ensure it has the correct configuration:

		import os
from django.core.asgi import get_asgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'my_django_app.settings')

application = get_asgi_application()
	

Step 7: Run the Uvicorn Server

Execute the server configuration with:

		python run.py
	

Now, navigate to http://127.0.0.1:8000 in your web browser, and you should see the Django welcome page, indicating your application is successfully bootstrapped and running.

Conclusion

Congratulations! You've successfully bootstrapped a Django application using uv, optimizing your development process with the power of asynchronous task handling. This setup ensures a robust application capable of handling multiple requests concurrently and sets the groundwork for scalable and efficient web applications. With more involved requirements across production, development and testing environments, the greater the performance gains you'll find, particularly if you are employing `pyproject.toml`.

Feel free to explore uvicorn's extensive configurations and adapt them to suit your specific requirements. Happy coding!