04 Apr 2025
Django community aggregator: Community blog posts
Django News - Django 5.2 is here! - Apr 4th 2025
News
Django 5.2 released
Django 5.2 is released! A few highlights are:
- All models are automatically imported in the shell by default.
- Composite primary keys support.
- Overriding a BoundField got a lot easier
And much, much more. Read the full release notes for all the details.
Django security releases issued: 5.1.8 and 5.0.14
A security fix for a potential denial-of-service vulnerability.
Django REST framework 3.16 Announcement
The latest release now fully supports Django 5.1 and the upcoming 5.2 LTS as well as Python 3.13.
π Announcing The Great Django Webring
Just in time for April 1st, Jeff launched The Great Django Webring. π
Sponsored Link 2
MongoDB Django Backend: Open Source & Ready!
Contribute or explore! The official MongoDB backend for Django is now on GitHub. Dive into the code and help shape the future of Django and MongoDB integration. Try it today!
Articles
Deleting a Django Application from a Multi-Site Kubernetes Cluster
Efficiently remove a Django application from a multi-site Kubernetes cluster by identifying and deleting the relevant ingress, deployments, and namespaces before completing DNS, IaC, and database cleanups.
Talks I want to see at DjangoCon US 2025
Tim Schilling writes a number of good talk ideas if you're still considering submitting to DjangoCon US for this fall.
Troubleshooting is a Lifestyle π
Systematically enhance Django troubleshooting by leveraging built-in indicators, error reporting, and extensible tools like the Debug Toolbar to isolate and resolve issues.
If I were starting out nowβ¦
Carlton Gibson weighs in with some wise advice to anyone new to a programming career.
How to report a security issue in an open source project
From Jacob Kaplan-Moss, how to properly report a security issue in open source. A very important issue!
Free-threaded Python on GitHub Actions
How to configure GitHub Actions to test experimental free-threaded CPython builds (GIL disabled) using various setup options, such as version suffixes, variables, and environment flags.
htmx snippets and examples
Several useful htmx snippets and examples for your Django projects.
Videos
Django Tasks Scheduler project overview with Daniel Moran
Daniel Moran provides an introduction of django-tasks-scheduler.
BREAKING: Guido van Rossum Returns as Python's BDFL
Hint: This came out on April Fools Day.
Sponsored Link 1
Ready to get your Django project to the next level?
Elevate your Django projects with HackSoft! Try our expert consulting services and kickstart your project.
Podcasts
Django Chat #179: PyCon US 2025 - Elaine Wong & Jon Banafato
Elaine and Jon are the Chair and Co-Chair of PyCon US, taking place in Pittsburgh, PA, this May. We discuss how to make the most of a conference, in-person vs online, what to wear, and more.
Django News Jobs
Senior Developer Advocate at MongoDB
Django Newsletter
Projects
suitenumerique/meet
Open source alternative to Google Meet and Zoom powered by LiveKit: HD video calls, screen sharing, and chat features. Built with Django and React.
django-csp v4.0
Content Security Policy for Django. This release contains several breaking changes. For a complete migration guide, see here.
This RSS feed is published on https://django-news.com/. You can also subscribe via email.
04 Apr 2025 3:00pm GMT
02 Apr 2025
Django community aggregator: Community blog posts
PyCon US 2025 - Elaine Wong & Jon Banafato
- PyCon US 2025
- Jon Banfato personal website
- Elaine Wong personal website
- PyCon US Hatchery Program
- PyCon Startup Row
- Conference Chats
- NICAR 2025
- pyladies
- pycon.org (lists many of the Python conferences around the world and includes an events calendar)
Sponsor
This episode was brought to you by HackSoft, your development partner beyond code. From custom software development to consulting, team augmentation, or opening an office in Bulgaria, they're ready to take your Django project to the next level!
02 Apr 2025 4:00pm GMT
28 Mar 2025
Django community aggregator: Community blog posts
Django News - 20 PRs Merged into Django Core This Week Alone! - Mar 28th 2025
Updates to Django
Today 'Updates to Django' is presented by Abigail Afi Gbadago from the DSF Board and Djangonaut Space!π
Last week we had 20 pull requests merged into Django by 14 different contributors - including 4 first-time contributors! Congratulations to mguegnol, YQ, Filip Owczarek and Ahmed Nassar for having their first commits merged into Django - welcome on board!π₯³
This week's Django highlights:
- The environment variable
HIDE_PRODUCTION_WARNINGhas been changed toDJANGO_HIDE_PRODUCTION_WARNINGto align with Django's naming conventions. - The
URLIZE_ASSUME_HTTPSsetting has been added to enhance security and smooth transition to HTTPS which aligns with Django's deprecation policy. - The
ADMINSandMANAGERSsettings have been changed to lists of strings (also with a deprecation period).
Django Newsletter
Wagtail CMS
aria-label is a letdown
Analysis of aria-label usage on Wagtail sites shows 34% of instances are likely faulty, advocating for enhanced linting, proper label alternatives, and improved accessibility documentation.
Sponsored Link 2
MongoDB Django Backend: Open Source & Ready!
Contribute or explore! The official MongoDB backend for Django is now on GitHub. Dive into the code and help shape the future of Django and MongoDB integration. Try it today!
Articles
Smoke test your Django admin site
Use parametric testing with pytest to smoke test Django admin changelist routes by dynamically extracting URL patterns and ensuring all admin pages render correctly.
π€ A better Django version/update command and Prompt-driven-development (PDD)
Jeff writes about Prompt-driven development produces (PDD), a refined self-updating Django command that checks for version updates from PyPI and automates updates while enhancing the developer experience.
"Any Updates?"
Posting 'Any updates?' on open-source project issue trackers burdens maintainers; instead, donate, volunteer, or wait patiently to support efficient progress.
How to Create a Helm Chart for a Django App
Guide details deploying Django apps with Helm charts on Kubernetes, integrating GitHub Actions, GHCR, and Ansible for automated container image releases and configuration deployments.
Building accessible web forms in Django
A step by step reference to building accessible web forms in Django.
Improving licence metadata
How to update your Python project for PEP 639.
Events
PyCon US Schedule
Check out the detailed schedule for tutorials, talks, and more this May in Pittsburgh, PA.
EuroPython Tickets
EuroPython is happening in Prague, Czech Republic this year, July 14-20. Tickets are available with further information coming soon!
Podcasts
Talking Postgres Ep25: Why Python developers just use Postgres with Dawn Wages
Django developer and PSF Foundation Chair Dawn Wages discusses why Postgres is so popular with Python & Django developers, as well as notes on Djangonaut Space, and an overview of the Postgres chapter from her upcoming Domain-Driven Django book.
Django News Jobs
Web Developer at Full Fact π
Senior Developer Advocate at MongoDB
Software engineer(all levels) at Carbon Equity
Junior Full Stack Developer - Python at Krotos
Django Newsletter
Projects
suitenumerique/docs
A collaborative note taking, wiki and documentation platform that scales. Built with Django and React. Opensource alternative to Notion or Outline.
bckohan/django-enum
Full and natural support for enumerations as Django model fields.
Sponsorship
π Sponsor Django News
Are you interested in connecting with a vibrant community of over 4,100 active Django developers? We have sponsorship opportunities for this spring and the upcoming summer season. Reach an engaged audience and support the Django community!
Explore Sponsorship Options β
Django Newsletter
This RSS feed is published on https://django-news.com/. You can also subscribe via email.
28 Mar 2025 3:00pm GMT
Cakti Share Their Favorite Tools For Streamlined Workflows
Let's jump into it!
At Caktus, we're always looking for tools that help us streamline our workflows, increase productivity, and make our day-to-day tasks more efficient. Whether you're managing projects, writing code, or debugging, the right tools can make all the difference. Here are some of our favorite tools that we love using to get the job done!
Keanya: Project Manager
Django Documentation
As I transition from software development into technical project management, I don't always have the cycles to write code as much as I would like. However, I aim to maintain my technical knowledge and skills. One of my favorite tools to achieve this is the tried and true Django documentation, which is comprehensive and incredibly user-friendly. The documentation breaks down complex concepts into digestible sections, making it fairly simple to find what you need. It is organized logically, so you can easily move from one section to another without feeling lost. This documentation isn't just a reference guide; it's also a learning tool. It covers everything from Django's core concepts to advanced features, with plenty of examples and use cases that help contextualize the information. For a technical project manager like me, the ability to access this comprehensive, easy-to-follow resource is invaluable.
Jeanette: Developer
GitHub Copilot
I love GitHub Copilot because it reduces the time I spend on repetitive tasks and writing boilerplate code, allowing me to focus more on solving problems. Its suggestions streamline my workflow by predicting and completing code snippets. Beyond that, it offers simple, in-line explanations that help me understand unfamiliar functions or syntax without breaking my workflow. This makes learning new technologies and debugging much faster, as I can quickly grasp the purpose of a given piece of code.
GitLens
GitLens is an awesome VS Code extension that makes working with Git way easier and more efficient. It gives super useful insights into code history, showing who changed what, when, and why-right inside the editor. One of my favorite features is the blame annotations, which let me see commit history inline so I can quickly understand how a file has evolved. It also comes with powerful tools, like commit searching, making it much easier to navigate big projects. Whether I'm debugging, reviewing a PR, or tracking down when a bug pops up, GitLens makes Git so much smoother to work with!
Tobias: CEO/Lead Developer
Ansible
Caktus utilizes Ansible to manage its clients' diverse infrastructure requirements, which include public cloud environments (AWS, Azure, and Google Cloud) as well as on-premise physical hardware and self-managed Kubernetes clusters in client-owned data centers. Ansible is the only tool Caktus has found that can effectively adapt to this wide range of infrastructure environments. One of my favorites is the kubernetes.core.helm module, which allows us to automate all of the Helm charts required for a cluster. In a disaster recovery scenario, this allows us to bring the system back online in a new environment as quickly as possible while minimizing the possibility of human error.
Pair Programming
As we previously wrote about on the Caktus blog and spoke about at DjangoCon Europe 2024, pair programming is a big part of our daily work life at Caktus. Pair programming remotely is far easier with a good tool, and Visual Studio Live Share and Code With Me are both good options.
Gerald: Scrum Master/Quality Assurance Analyst
Font Finder Chrome Extension
Font Finder is one of my go-to Chrome extensions when I'm testing major CSS updates to a site because it makes checking fonts quick and easy. Instead of digging through the dev tools to comb through the CSS, I can just click on any text element on the page and instantly see details like font type, size, color, line height, etc.
Page Load Time Chrome Extension
When testing data-driven sites, I like using the Page Load Time Chrome extension because it gives me an instant read on how fast a page loads without needing to dig through dev tools. It's great for spotting performance issues, especially on pages that pull in a lot of data on initial load. This extension displays the load time right in the toolbar, making it easy to track load time as I test different pages.
Go Full Page Chrome Extension
Go Full Page lets me capture full-page screenshots in one click. I've found it especially useful for capturing long pages that might have layout issues. Being able to do this without the hassle of stitching images together or taking multiple screenshots helps save time and effort.
Ronard: Developer
Direnv
Direnv allows you to load and unload environment variables depending on the current directory. It is ideal for navigating many projects at once, all you have to do is cd into the target directory and direnv handles everything from your Python virtual environment, secrets, API keys, kubeconfig for Kubernetes, and more.
Invoke Kubesae
Invoke Kubesae is one of our internal tools at Caktus. inv encompasses the most-used management tasks for working with Kubernetes clusters. As someone who manages several Kubernetes clusters, I use it daily. I love that it shortens many valuable commands, but also shows the full command on execution. It's an open-source tool and contributions are always welcomed.
Karen: Technical Director/Lead Developer
Netdata
Netdata is a system monitoring tool that makes it easy to see characteristics of system usage over time, receive alerts for problems, and automatically set up corrective actions such as restarting a service that perhaps has encountered a deadlock. It's also possible to run it entirely on-premises without any paid subscription, so it's friendly to small non-profit or limited-budget organizations.
Colin: CTO/Lead Developer
Jupyter Notebooks
Jupyter Notebooks are an invaluable tool for data analysis and visualization. They allow me to write and execute code, view results immediately, and "show my work" in a way that a script doesn't, making them ideal for prototyping. This real-time feedback loop is especially useful when working with data, as I can quickly verify that my code behaves as expected.
Jupyter Extension for Visual Studio Code
The Jupyter Extension for Visual Studio Code allows me to use Jupyter Notebooks directly within VS Code, which is my preferred code editor. This means I can open and edit .ipynb files and work with both notebooks and Python code in a single location. Additionally, I can leverage GitHub Copilot for code suggestions inside notebook cells, a feature not available when using the Jupyter Notebook server.
We hope you found this list of tools useful! At Caktus, we're always exploring ways to improve our workflows, and the right tools can make all the difference in boosting productivity and collaboration. What are some of your favorite tools? Let us know in the comments!
28 Mar 2025 1:09am GMT
27 Mar 2025
Django community aggregator: Community blog posts
Upgrade Smarter, Not Harder: Python Tools for Code Modernization
Upgrading projects is somewhat equivalent to flossing, you know you have to do it, but rarely make time for it. After all, if the project is in active development, there are exciting new features to build. And we all know that new features > project upgrades. Well not to worry, Caktus wants to make you aware of some tools that will save you from considerable repetitive work & time while simultaneously modernizing your codebase. Combined, these tools will automate part of the upgrade process, decreasing the likelihood of neglecting parts of the codebase.
Switch to f-strings with flynt
flynt is a tool to automatically convert a project's Python code from old "%-formatted" and .format(...) strings into Python 3.6+'s "f-strings".
Add the following to your .pre-commit-config.yaml file:
- repo: https://github.com/ikamensh/flynt/
rev: 1.0.1
hooks:
- id: flynt
Now run pre-commit run --all-files to apply the changes.
Uprade to the latest Python syntax with pyupgrade
pyupgrade is a tool to automatically upgrade Python syntax to newer versions.
Add the following to your .pre-commit-config.yaml file:
- repo: https://github.com/asottile/pyupgrade
rev: v3.19.1
hooks:
- id: pyupgrade
args: [--py311-plus]
Now run pre-commit run --all-files to apply the changes.
Upgrade your Django code with django-upgrade
django-upgrade is a tool to automatically upgrade Django code to the latest version.
Add the following to your .pre-commit-config.yaml file:
- repo: https://github.com/adamchainz/django-upgrade
rev: 1.23.1
hooks:
- id: django-upgrade
args: [--target-version, "4.2"]
Now run pre-commit run --all-files to apply the changes.
Having these Python tools in your toolbelt will surely make your next project update smoother and more comprehensive. They complement each other, ensuring that different parts of the codebase are upgraded, especially files that would be easy to overlook.
27 Mar 2025 3:00pm GMT
How to report a security issue in an open source project
So you've found a security issue in an open source project - or maybe just a weird problem that you think might be a security problem. What should you do next?
27 Mar 2025 5:00am GMT
Python Leiden (NL) meetup: serialisation in Python - John Labelle
(One of my summaries of the second Python Leiden (NL) meetup in Leiden, NL).
Nice subtitle for the talk: "python serialisation: this ain't your father's cruesli"... :-)
He wants to show us how dangerous it is to de-serialize content provided by someone else. His examples are at https://github.com/airza/deserialization_labs
Serialisation: converting a data structure living in memory into data you can store on disk or send over. Deserialisation is converting it back into a python object. There are interoperable formats like json and xml. Most languages have their own specific methods: python has pickle.
Serialising a dict or list is often easy. json.dumps({"some": "structure"}) But what if you've got some non-standard data structure like a python object? json serialisation won't work out of the box. And if you've got huge data structures, json (being human-readable) is slow and huge.
Pickle stores python objects in some binary format on disk. Fun fact: pickle was added to python in 1995, json only exists since 2006. I'll paste one of his examples to make clear how picle works:
import pickle
from tsukimi import Tsukimi
cat = Tsukimi("Fluffy", "Empty")
pickle.dump(cat, open("tsukimi.pickle", "wb"))
Deserialising works like this:
import pickle
cat = pickle.load(open('tsukimi.pickle', 'rb'))
print(cat.fur)
print(cat.brain)
Pickle just stores the name of the class it needs to re-create plus the contents of the attributes. So not the methods or so.
Pickle is explained here: https://docs.python.org/3/library/pickle.html . It has a nice warning right at the top: Warning: The pickle module is not secure. Only unpickle data you trust.
Pickle stores all attributes by default, if you don't want that you can define a special __reduce__() function that specifies just the attributes you want and the name of the class that can restore them. But... the name of that class is just looked up, there's no validation. So you can also pass something that's not the name of your class, but something like os.system which just calls anything on the command line...:
import os
import pickle
class EvilCat:
def __reduce__(self):
return os.system, ('export > version.txt',)
evil = EvilTsukimi()
pickle.dump(evil, open("evil.pickle", "wb"))
If the code that loads this pickle reads the version.txt (as in the exercise that he had us run), you suddenly see all the server's environ variables.
So: never let people give you pickles. Use json for user input. Or protobuf.
Pytorch (a pydata library) uses pickles. They recently started overwriting the unpickler's functionality, but he showed some ways to get around its "limitations".
He recommended looking at https://github.com/b4rdia/HackTricks/tree/master/generic-methodologies-and-resources/python/bypass-python-sandboxes
27 Mar 2025 4:00am GMT
Python Leiden (NL) meetup: how to use uv for dependency management - Michiel Beijen
(One of my summaries of the second Python Leiden (NL) meetup in Leiden, NL).
uv is the new python packaging solution that everybody should be using. He demoed it in a standard demo django wagtail project that still had a requirements.txt. Creating a virtualenv and doing a pip install worked, but it took a bit of time.
Next, he tried the venv/pip compatibility layer of uv. So uv venv and uv pip install -r requirements.txt. Oh... python -m venv .venv took 3 seconds, and uv venv 0.04 seconds. Wow. The uv pip was also much faster. Wow.
"Faster" is nice in development, but also when running your test in a CI enviroment (like github actions).
uv can also manage your python installations. It downloads a stand-alone python for you when needed, for instance if you need a version you don't have locally.
Lastly, he added a pyproject.toml and put the dependencies from requirements.txt into the pyproject.toml instead. Calling uv run manage.py automatically activates the virtualenv, install everything and run manage.py just like you'd have called python manage.py.
Installing it in such a way creates an uv.lock file with all the pinned packages just such as uv downloaded them. The file should be checked in. The dependencies only say "I want whitenoise and don't care what version", but the uv.lock tells all your colleages (or your server..) which version you've installed, keeping everything in sync.
Dependency scanners also support uv.lock. At least, "renovate" already supports it and "dependabot" support is underway.
Handy: uv tool install your-tool for installing some tool like "pre-commit" in its own virtualenv somewhere and make it available globally. uvx your-tool installs the tool temporarily for just one command. And with uv add --script your-script.py some-dependency you can add dependencies to single-file scripts. Running the script with uv run your-script.py installs those dependencies for the duration of the script.
27 Mar 2025 4:00am GMT
Python Leiden (NL) meetup: Rendering spatial data in 3d using zarr, jax, babylon.js and DuckDB - Jesse K.V.
(One of my summaries of the second Python Leiden (NL) meetup in Leiden, NL).
He's working with civil engineering, hydrology and weather data. And... he wanted to toy with 3D models. His example site: https://topography.jessekv.com/ . You can click almost anywhere in the world and get the upstream catchment. (I checked it: yes, it seems to work pretty well!)
He runs all requests through a single asyncio python thread. As a personal challenge he wanted it to handle the heavy load of a hacker news post. In the end, it worked fine. One async python thread was more than enough.
One of the tricks he used was to preprocess as much as reasonable so that most clicks are direct lookups in a database (vector data). Depending on the size of the selected area, he uses more detailed rasters for small areas and coarser ones for big areas.
He wanted a mostly-working prototype quickly, so he experimented with LLMs. Generating math code was mostly bad, but the UI code was OK.
He used duckdb with a spatial extension. Duckdb uses GDAL vector routines. This is what he used to pre-process the catchment areas on his M1 mac laptop. Afterwards, he exported it to postgres. Postgres is much more optimised for actual production use.
Duckdb doesn't always work perfectly, but if you're able to define your workload in such a way (parallelised) that you stay within the limits of your memory, you can get real good performance out of it.
Duckdb's file-based approach is also handy. Just like sqlite's files. Easy for experimenting.
zarr is what he used for pre-processing the 3D landscape. Zarr is efficient for storing large arrays of gridded data. Zarr is way nicer than netcdf. It is designed to leverage the linux page cache. And you store compressed data in memory. Storing on S3 is also well-integrated.
jax is an easy way to take numpy/scipy to make it run in parallel. JAX-metal is a jax backend that runs on his M1 macbook's GPU. Processing is aligned to chuncks for more efficient reads and writes.
For landcover, he used jax.scipy.stats.mode and for elevation jax.numpy.nanmean. (NaN: not-a-number: elevation models are made with radar technology and water areas reflect radar, resulting in NaN).
A useful trick he used was to introduce a bit of wait time for some expensive operations to make sure his service wouldn't get flooded with requests. Simply waiting a few seconds and then popping up a dialog "you're going to download 400MB, y/n?" already helped.
27 Mar 2025 4:00am GMT
21 Mar 2025
Django community aggregator: Community blog posts
Django News - Django 5.2 RC1, Python 3.14 Alpha, and New Security Discussions - Mar 21st 2025
News
Django 5.2 release candidate 1 released
The final opportunity for you to try out a composite of new features before Django 5.2 is released.
Python 3.14.0a6 Release
Python 3.14.0a6 alpha (Pi Day release) introduces deferred annotation evaluation and improved interpreter performance, offering potential efficiency gains for Django-based projects.
Discussion #154262: Ability to make GitHub issues and pull requests private when they disclose a vulnerability to the public
Django Fellow Sarah Boyce proposes enabling project owners to mark pull requests private when disclosures expose vulnerabilities, thereby restricting unauthorized access and reducing malicious exposure risks.
Django Software Foundation
Meeting minutes: DSF Board monthly meeting, March 13, 2025
The board discussed automating Contributor License Agreement emails, proposed GitHub-based bylaws updates, and coordinated community events at PyCon US and Italia 2025.
DSF member of the month - Cory Zue
Cory Zue, a seasoned Django developer and entrepreneur, excels in innovative project creation, advanced Django guides, and promoting community engagement.
Accessibility and inclusivity at FOSDEM 2025
FOSDEM 2025 highlighted inclusive web practices through Django-enabled sessions on automated accessibility testing, secure WebAuthn implementation, and innovative localization approaches.
Updates to Django
Today 'Updates to Django' is presented by Abigail Afi Gbadago from the DSF Board and Djangonaut Space!π
Last week we had 16 pull requests merged into Django by 12 different contributors - including a first-time contributor! Congratulations to haileyajohnson π for having their first commits merged into Django - welcome on board! π₯³
This week's Django highlights:
- A specialized exception has been added for forced update failures.
single_objectargument toLogEntry.objects.log_actions()has been restored.- A trailing newline has been introduced at the end of JSON serialization regardless of the indent option.
- An async interface has been added to Paginator.
Special thanks to wookkl for the long work on this PR π₯³
Django Newsletter
Wagtail CMS
uv overtakes Poetry for Wagtail
Recent statistics reveal that uv has overtaken Poetry as the second most popular package installer for Wagtail installations, prompting updates in developer documentation and tooling.
Sponsored Link 2
MongoDB Backend for Django: Dive into the Docs!
Explore the official MongoDB Django backend! Learn to connect, model, and manage data with detailed documentation. Discover how to leverage MongoDB's performance and scalability within your Django projects.
Articles
Django Template components are slowly coming
Django 5.2's introduction of simple_block_tag streamlines reusable navigation component creation through custom template tags, significantly reducing boilerplate while enhancing overall template functionality.
DjangoConUS 2024: From Wish to Tradition
Velda Kiara reflects on her journey from attending DjangoCon US in 2023 to taking on multiple leadership roles in 2024-including serving as a DEFNA director, chairing the Code of Conduct committee, and volunteering as a session chair.
Building accessible web forms in Django
Enhance Django web forms accessibility by customizing form renderers for proper aria-describedby usage to communicate errors and help text while disabling default browser validation.
Smooth Page Transitions in Modern Browsers
Implement smooth cross-page transitions in Django projects using the View Transition API and CSS animations, supporting both dynamic updates via HTMX or Alpine AJAX.
One Thing to Look Out For While Testing django-import-export
Django-import-export testing reveals that .xlsx files saved via Google Sheets lack empty columns, causing InvalidDimensions errors due to mismatched header counts.
Checking Current User Permissions in Django Templates
Explains using Django's perms object to conditionally render UI elements, such as the Wagtail admin panel link, based on the current user's permissions.
Events
DjangoCon keynote preview: Django for Data Science
If you're in the Boston area, come visit the beautiful Microsoft NERD Center and hear a talk on Django + Data Science, March 25th at 6pm.
Tutorials
Django Query Optimization - Defer, Only, and Exclude
Django QuerySet optimization techniques use defer, only, and exclude to reduce unnecessary data fetching and improve SQL performance in web applications.
Videos
Choosing Wisely: SPA vs. HTMX for Your Next Web Project with Chris May
Explore architectural trade-offs between SPAs and server-rendered apps using HTMX and AlpineJS to optimize state management, performance, and development constraints.
Sponsored Link 1
Get your business to the next level with Django!
Empower your business by leveraging the power of Django with the help of HackSoft! We are the Django experts you can count on for building your Django application. Learn more!
Podcasts
Django Chat #178: Django and Rust Tooling with Lily Foote
Lily joins us again to talk about the new Steering Council, composite primary keys in Django 5.2, working with uv package manager, and more.
Django News Jobs
Senior Developer Advocate at MongoDB
Software engineer(all levels) at Carbon Equity
Junior Full Stack Developer - Python at Krotos
Mid/senior level django developer at Green Web Foundation
Django Newsletter
Projects
django-commons/django-typer
Use Typer (type hints) to define the interface for your Django management commands.
dobicinaitis/tailwind-cli-extra
Tailwind CSS standalone CLI bundled with daisyUI.
This RSS feed is published on https://django-news.com/. You can also subscribe via email.
21 Mar 2025 3:00pm GMT
19 Mar 2025
Django community aggregator: Community blog posts
Built with Django Newsletter - 2025 Week 12
Hey, Happy Wednesday!
Why are you getting this: *You signed up to receive this newsletter on Built with Django. I promised to send you the latest projects and jobs on the site as well as any other interesting Django content I encountered during the month. If you don't want to receive this newsletter, feel free to unsubscribe anytime.
Sponsors
This issue is sponsored by CodeRabbit an AI Code Reviewer that provides context-aware feedback, refactoring suggestions and highlights code security issues.
In plain terms, you finally get a senior level developer reviewing your code! The best news is that it is completely free for any public repo! If you ask them nicely they might even give you more stuff for free.
I've been using it to develop my projects, including this one and I can't recommend it enough. At the very least, you should give it a try and judge for yourself.
Projects
- CAD Software Hub - Your Complete CAD Software Directory
- Cabot - Self-hosted, easily-deployable monitoring and alerts service - like a lightweight PagerDuty
- Papermerge - Open Source Document Management System for Digital Archives (Scanned Documents)
- Flagsmith - Open Source Feature Flagging and Remote Config Service.
- People - User-centric and self-care teams management application
- Visio - Open source alternative to Google Meet and Zoom powered by LiveKit: HD video calls, screen sharing, and chat features.
- Docs - A collaborative note taking, wiki and documentation platform that scales.
Jobs
From the Community
- Smoke test your Django admin site by Justin Duke - The article explains how to test Django admin pages by rendering their empty state. It shows how to extract all route names from the admin site and run a parameterized pytest that logs in as a superuser. This approach helps catch magic-string errors before they affect end users.
- Serving Self-hosted Healthchecks Under a Path by PΔteris Caune - Healthchecks is built for both hosted use and self-hosting. Now you can run Healthchecks on a subpath by adding a path prefix to the SITE_ROOT setting. This update avoids complex URL rewriting and works well with common reverse proxies
- Ditching Django Admin for FastHTML with HTMX by Simon Moisselin - The author replaced Django Admin with a custom dashboard built using FastHTML and HTMX for better usability and monitoring of their online school. This new dashboard focuses on key metrics like daily active users and exercise attempts, providing a more intuitive experience with automatic refresh features. The simplified code and design allow for rapid development and easier management of complex data without the limitations of a general-purpose framework.
Top 3 links from last Issue
- RecodeQR - Create QR codes you can track & edit anytime
- Life in Weeks - Create a map of your life where each week is a little box.
- Django in government where Thibaud Colas shares a list of 50,000 Django projects, focusing on 88 countries that use Django for their government websites. Brazil, the USA, and Argentina have the highest number of Django sites, showcasing various notable examples from different countries. The dataset highlights the growing use of Django in the public sector, although there are gaps in representation from some countries.
Django Changes
Here is the list of changes that have been made to Django's codebase in the last week.
Overview
This month saw significant development in Django with 17 commits focusing on async functionality, documentation improvements, test reliability, and various bug fixes. The changes span core functionality, admin interface, and developer tooling, with a notable emphasis on async support and documentation clarity.
Key Changes and Features
Major Features: - Added async support to Django's Paginator class by wookkl) - Added trailing newlines to JSON serializer output by Tom Carrick)
Bug Fixes:
- Fixed duplicate automatic imports in shell command by hesham942)
- Restored
single_objectargument in LogEntry.objects.log_actions() by Adam Johnson) - Fixed template language handling of scientific notation by haileyajohnson)
Test Improvements:
- Enhanced Selenium test reliability with proper wait conditions by Sarah Boyce)
- Updated admin tests for Chrome WebDriver compatibility by Sarah Boyce)
Documentation Enhancements:
- Added guidance about persistent database connections in ASGI environments by Carlton Gibson)
- Added JSONField query documentation examples by Clifford Gama)
- Updated URLField default scheme documentation to HTTPS by Sarah Boyce)
Support
You can support this project by using one of the affiliate links below. These are always going to be projects I use and love! No "Bluehost" crap here!
- Buttondown - Email newsletter tool I use to send you this newsletter.
- Readwise - Best reading software company out there. I you want to up your e-reading game, this is definitely for you! It also so happens that I work for Readwise. Best company out there!
- Hetzner - IMHO the best place to buy a VPS or a server for your projects. I'll be doing a tutorial on how to use this in the future.
- SaaS Pegasus is one of the best (if not the best) ways to quickstart your Django Project. If you have a business idea but don't want to set up all the boring stuff (Auth, Payments, Workers, etc.) this is for you!
19 Mar 2025 6:00pm GMT
Django and Rust Tooling - Lily Foote
- Lily on GitHub
- DSF Member of the month - Lily Foote
- Steering Council Meeting Notes
- DEP 10: New governance for the Django project
- DSF Board Meeting Notes
- Composite Primary Keys discussion and 5.2 release notes
- uv Python package manager
- PyCharm uv support and How to use uv in PyCharm
- maturin and click
- django-rusty-templates
Sponsor
This episode was brought to you by HackSoft, your development partner beyond code. From custom software development to consulting, team augmentation, or opening an office in Bulgaria, they're ready to take your Django project to the next level!
19 Mar 2025 4:00pm GMT
18 Mar 2025
Django community aggregator: Community blog posts
How to Create a Helm Chart for a Django App
At Caktus, we use Helm charts to simplify our deployment process for Django projects. Helm is a package manager for Kubernetes, and using Helm charts allows us to automate the process of writing Kubernetes configuration files for our Django applications. We use it together with GitHub Actions and Ansible to streamline our deployment processes.
This post includes an accompanying GitHub repo, which contains a simple Django project. The project is mostly based on our 2017 post about using Docker in production, so please refer to that for more context, particularly on the Dockerfile that we'll be using to build a Docker image that we'll publish to the GitHub Container Registry (GHCR).
Setting up a GitHub Actions workflow to publish a Docker image to GHCR
In order to deploy our application using Helm, we'll need to provide a container image repository from which the image for our application can be pulled. We use GHCR for this, though you can use any other container registry as well. Since we use GitHub to host our code repositories, we also use GitHub Actions to automate some deployment processes. This GitHub Actions workflow enables us to build a container image and publish it whenever a push is done to our main branch.
Create a file in the .github/workflows directory with this content. See the GitHub Actions documentation for more details:
name: Docker
on:
push:
# Change this to the branches you want to trigger publishing a new container image
branches: [main]
# Publish semver tags as releases.
tags: ["v*.*.*"]
env:
REGISTRY: ghcr.io
REGISTRY_WITH_PATH: ghcr.io/${{ github.repository_owner }}
jobs:
build-push-image:
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- name: Log into registry ${{ env.REGISTRY }}
if: github.event_name != 'pull_request'
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Extract Docker metadata
id: meta
uses: docker/metadata-action@v5
with:
images: ${{ env.REGISTRY_WITH_PATH }}/helm-charts-post
# Generate Docker tags based on the following events/attributes
tags: |
type=ref,event=branch
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}.{{hotfix}}
type=semver,pattern={{major}}.{{minor}}
type=semver,pattern={{major}}
type=sha
- name: Build and push Docker image
uses: docker/build-push-action@v5
with:
context: .
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
Now every time a commit is pushed to the main branch, a new container image will be published in your GHCR repository at https://<your-GitHub-repo-URL>/pkgs/container/<repo-name>
Setting up a Helm chart and automating its releases
For simplicity, we are creating our Helm chart in the same repo as our code, though Helm charts can be created in their own repo, where we can have the charts for different applications. Once you have installed Helm, creating a Helm chart is simple.
We first create a charts directory, where we will create our Helm chart. We will be using the chart-releaser action to automatically create new releases of our Helm chart, and it will be looking for a charts directory in our repo by default. You can rename this directory if needed, but you'll also need to change the charts_dir input for chart-releaser. You also need to create a gh-pages branch in the repo that contains your Helm chart. See all the prerequisites for the chart-releaser action.
mkdir charts -p
cd charts
helm create helm-charts-post
The helm create command creates a skeleton structure for our Helm chart, with various templates of Kubernetes config files. These templates can be edited according to your needs. For the helm-charts-post repo, we only made a few changes to the generated files:
- added a secret.yaml template, for our environment variables;
- added envFrom in the deployment.yaml template, which specifies the source from which our environment variables should be retrieved;
- and a checksum/config annotation in the deployment.yaml template, so that our deployment can be automatically restarted if our environment variables are changed.
For automatic releases using GitHub Actions, create a file in the .github/workflows directory with this content:
name: Release Charts
on:
push:
# Change this to the branches you want to trigger a new Helm chart release
branches:
- main
jobs:
release:
# depending on default permission settings for your org (contents being read-only or read-write for workloads), you will have to add permissions
# see: https://docs.github.com/en/actions/security-guides/automatic-token-authentication#modifying-the-permissions-for-the-github_token
permissions:
contents: write
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Configure Git
run: |
git config user.name "$GITHUB_ACTOR"
git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
- name: Install Helm
uses: azure/setup-helm@v3
- name: Build dependencies
run: |
helm repo add dandydev https://dandydeveloper.github.io/charts
cd charts/helm-charts-post && helm dependency build
- name: Run chart-releaser
uses: helm/chart-releaser-action@v1.6.0
env:
CR_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
Now every time a commit is pushed to the main branch, this workflow will be run, but a new Helm chart release will only be created if your chart has changed. Chart releases will be in https://<your-GitHub-repo-URL>/releases.
Using Ansible with the Helm chart for deployment
The deployment folder contains a sample Ansible playbook (deploy.yaml) that can be used to install the Helm chart. Update it as appropriate, along with the hosts definition in your Ansible inventory (inventory.yaml for our repo).
- name: Helm Charts Post deployment
hosts: k8s
gather_facts: false
vars:
ansible_python_interpreter: "{{ ansible_playbook_python }}"
tasks:
- name: Create helm-charts-post namespace
kubernetes.core.k8s:
context: "{{ k8s_context|mandatory }}"
kubeconfig: "{{ k8s_kubeconfig }}"
name: "{{ k8s_namespace }}"
api_version: v1
kind: Namespace
state: present
- name: Add helm-charts-post Helm chart
kubernetes.core.helm:
state: present
context: "{{ k8s_context|mandatory }}"
kubeconfig: "{{ k8s_kubeconfig }}"
# To test local chart. Update with the path to the chart
# chart_ref: ../../helm-charts-post/charts/helm-charts-post/
# dependency_update: yes
# Use released chart:
chart_repo_url: https://caktus.github.io/helm-charts-post
chart_ref: helm-charts-post
chart_version: "{{ k8s_chart_version }}"
release_name: helm-charts-post
release_namespace: "{{ k8s_namespace }}"
release_values: "{{ k8s_release_values }}"
wait: yes
You should have a Kubernetes node already set up and accessible either remotely or from the host itself. To test that your Ansible inventory definition is correct and the host is accessible, run:
ansible k8s -m ping
You can check that your Ansible variables are correct by running:
ansible-playbook debug.yaml -l k8s
This will print out the variables that are used in the playbook, in JSON format. The values in k8s_release_values will be used by the Helm chart to fill in its templates, and will override the default values in the chart's values.yaml file. You can copy the JSON object printed out for k8s_release_values, save it in a file, then run the following command to see what the final configuration files will look like without actually deploying the application:
helm install --debug --dry-run helm-charts-post charts/helm-charts-post/ -f path/to/the/k8s_release_values.json
When you're ready, you can deploy the application with:
ansible-playbook deploy.yaml -l k8s
To use the local Helm chart instead of the one released on GitHub, uncomment the 2 lines under "To test dev chart" and comment out the 3 lines under "Use released chart".
Summary
That concludes this high-level introduction to creating a Helm chart for deploying a Django application. Each application's needs will be different, but I hope this provides a good starting point for your Helm chart. Good luck!
18 Mar 2025 1:00pm GMT
Checking Current User Permissions in Django Templates
When developing Django applications, we often need to control which parts of the UI are accessible based on user permissions. Luckily, Django provides a straightforward way to check user permissions directly in templates using the perms object.
Using the perms Object in Django Templates
Django automatically injects a perms context β¦
18 Mar 2025 7:25am GMT
17 Mar 2025
Django community aggregator: Community blog posts
One Thing to Look Out For While Testing django-import-export
Often the applications we build at Caktus deal with large sets of Django objects. The attributes of these objects can vary, and may need updating in certain instances. One of the best ways to manage this data is via django-import-export, which is a tool that creates a way to perform these bulk updates with a file upload such as a .csv or .xlsx file.
This week my team integrated this tool in one of our projects and I encountered an interesting bug specifically around importing .xlsx files.
Below is an example .xlsx file I put together to test if the import feature was working as expected. I edited 2 objects to have values for all available attributes (rows 2-3), and rows 4-5 are 2 objects that only have a subset of values populated for the available attributes. The intent here was to test if I could be selective of what attributes I wanted to update during an import.
After constructing this .xlsx file of objects that I wanted to import/update, I attempted to upload this file only to be met with an error.
Error Message: "An error was encountered while trying to read the file. Ensure you have chosen the correct format for the file"
My initial thought was that we were not properly supporting .xlsx files, given that the same file saved as a .csv could be successfully imported. However, this was debunked after Simon, a developer on our team, looked into this issue and confirmed that he could successfully import .xlsx files without any problems. This left me confused, but after a bit of pair-debugging, we discovered that the issue stemmed from an unexpected reason.
The application I used to save my file versus the application the developer used to save theirs affected how the importer processed the file. A file saved from Google Sheets triggered an InvalidDimensions error in the logs, while the same file saved via Microsoft Excel imported without issues.
We discovered that when a .xlsx file is edited and saved in Google Sheets, its format changes slightly. Rows with empty columns as shown in the diagram below (e.g., columns C-G in rows 4-5) don't get filled with empty values when the file is saved. As a result, Django Import-Export complains because it sees those rows as having 2 only columns when it expects 7 (e.g, rows 2-3). This error occurs when a row in the import file does not have the same number of columns as the header row.
Dev Console Error:
Traceback (most recent call last):
File "/home/simon/work/caktus/odk-publish/apps/odk_publish/forms.py", line 159, in clean
self.dataset = import_format.create_dataset(data)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/simon/work/caktus/odk-publish/.direnv/python-3.12.3/lib/python3.12/site-packages/import_export/formats/base_formats.py", line 213, in create_dataset
dataset.append(row_values)
File "/home/simon/work/caktus/odk-publish/.direnv/python-3.12.3/lib/python3.12/site-packages/tablib/core.py", line 476, in append
self.rpush(row, tags)
File "/home/simon/work/caktus/odk-publish/.direnv/python-3.12.3/lib/python3.12/site-packages/tablib/core.py", line 462, in rpush
self.insert(self.height, row=row, tags=tags)
File "/home/simon/work/caktus/odk-publish/.direnv/python-3.12.3/lib/python3.12/site-packages/tablib/core.py", line 450, in insert
self._validate(row)
File "/home/simon/work/caktus/odk-publish/.direnv/python-3.12.3/lib/python3.12/site-packages/tablib/core.py", line 267, in _validate
raise InvalidDimensions
tablib.exceptions.InvalidDimensions
After we discovered this, we updated the importer to account for this edge case. This experience was a good reminder that files that seem identical can behave very differently, depending on how they're processed when saved.
17 Mar 2025 7:00pm GMT
15 Mar 2025
Django community aggregator: Community blog posts
Django Query Optimization - Defer, Only, and Exclude
In this article, we'll look at the differences between Django QuerySet's defer, only, and exclude methods.
15 Mar 2025 3:28am GMT