#django

The Django team is happy to announce the release of Django 6.0. The release notes assembles a mosaic of modern tools and thoughtful design. A few highlights are: Template Partials: modularize templates using small, named fragments for cleaner, more maintainable code. (GSoC project by Farhan Ali Raza, mentored by Carlton Gibson) Background Tasks: run code outside the HTTP request-response cycle with a built-in, flexible task framework. (Jake Howard)

Modern CSS supports many of the features natively that the build tools were created for. CSS nesting to organize code, variables, @supports for feature detection. JavaScript ES6 / ES2015 was a big step forward, and the language has been progressing steadily ever since. It now has native module support with the import / export keywords Meanwhile, with HTTP/2 performance improvements, parallel requests can be made over the same connection, removing the constraints of the HTTP/1.x protocol.

Full Django in a single file

This proposal sets out to provide an interface and base implementation for long-running background tasks in Django.

A few years ago at work, I had a project which offered an opportunity to look at the new generation of async-first, type-hint-driven Python web frameworks. For reasons which aren’t particularly relevant today, on that project I ended up choosing Litestar, which is the one that doesn’t have a ravenous all-consuming hype machine surrounding it. And I’m very glad I did, because today I’m more convinced than ever it was the right choice, and for the last 18 months or so every new project I’ve started at my day job has been built with Litestar.

Ten years ago we threw a multi-day 10th birthday party for Django back in its birthtown of Lawrence, Kansas. As a personal celebration of the 20th, I’m revisiting the talk I gave at that event and writing it up here.

On July 13th 2005, Jacob Kaplan-Moss made the first commit to the public repository that would become Django. Twenty years and 400+ releases later, here we are – Happy 20th birthday Django! 🎉

Django Extensions is a collection of custom extensions for the Django Framework.

Possible alternative to Celery for background job processing

This post is about providing some guidance on how to make your simple Django app production-ready and deploying to Fly.io.

Django package enabling user-specific SQLite databases

Especially for side projects with limited traffic requirements and scaling concerns, the promise of SQLite is that it can remove a lot of ongoing hassles. Without a separate database, cache, or queue, there is less network traffic (because the SQLite file is local), and less servers to manage, maintain, and backup.

If you’re using Amazon S3 to store your website’s files, and you want some of them to be private, only accessible to certain users, and particularly if you’re using Django, here’s how.

Similar to Profiling Middleware, but uses cProfile instead of hotshot. Append ?prof to the URL to see profiling output instead of page output.

Similar to Profiling Middleware, but uses cProfile instead of hotshot. Append ?prof to the URL to see profiling output instead of page output.

Trust is a Django app for managing the trust levels of your users. All users start out with a default amount of trust, and as they do good things they gain trust, and as they do bad things they lose trust.

In the twelve-factor model, all configuraiton variables are stored in the OS environment. This makes updating settings in the deployed application way easier but what to do in local development?

In the twelve-factor model, all configuraiton variables are stored in the OS environment. This makes updating settings in the deployed application way easier but what to do in local development?

Single domain web sites are so boring. Custom subdomains are a great way to provide customization for customers of SaaS products and to differentiate content without resorting to long URL paths. Implementing subdomain support in a web application isn’t

Single domain web sites are so boring. Custom subdomains are a great way to provide customization for customers of SaaS products and to differentiate content without resorting to long URL paths. Implementing subdomain support in a web application isn’t

Like Apache’s mod_xsendfile, Nginx’s X-Accel module provides for internal redirects. An x-accel-redirct is internal because instead of redirecting the client’s request to another URL, it redirects the location of Nginx’s request to another resource.

Like Apache’s mod_xsendfile, Nginx’s X-Accel module provides for internal redirects. An x-accel-redirct is internal because instead of redirecting the client’s request to another URL, it redirects the location of Nginx’s request to another resource.

Meet the Django Pony (the unofficial framework mascot), Unchained!

I’ve been using Travis-CI for a while now. Both my personal projects, and even several of the libraries we maintain at DISQUS rely on it for Continuous Integration. I figured it was about time to confess my undenying love for Travis, and throw up some notes about the defaults we use in our projects.

I’ve been using Travis-CI for a while now. Both my personal projects, and even several of the libraries we maintain at DISQUS rely on it for Continuous Integration. I figured it was about time to confess my undenying love for Travis, and throw up some notes about the defaults we use in our projects.

Sometimes you can’t avoid using HTTPS right starting from development (such as for developing Facebook canvas applications). You can setup Apache on your local machine and go through a bunch of trouble setting up your domain and setting up the certificate etc but there’s an easy way of using Django’s python manage.py runserver to work with HTTPS.

Sometimes you can’t avoid using HTTPS right starting from development (such as for developing Facebook canvas applications). You can setup Apache on your local machine and go through a bunch of trouble setting up your domain and setting up the certificate etc but there’s an easy way of using Django’s python manage.py runserver to work with HTTPS.

So I started wondering - what if we just created a real user for every person who visited the site? Django already has support for creating users with unusable passwords - so if we just create a user with an unusable password every time a new person comes along, log them in, and then at some future point (presumably once they've fallen in love with your site) they can set themselves up with a real username and password. And as a bonus, all that data that they created while messing about with the site sticks around, and carries over into their 'real' user.

Without too much complication or any hardware source of randomness, this seems like a reasonable method for API key generation.

Without too much complication or any hardware source of randomness, this seems like a reasonable method for API key generation.

If you’re prototyping a new project, or if you’re a start-up and need to ship something, or if you’re just one person working on a little app with a few (even a few tens of thousands) of users, odds are that none of those benefits are worth losing the nice stuff Django gives you, or the time it takes to build APIs (even using existing apps to do it) or abstraction layers between the silos.

If you’re prototyping a new project, or if you’re a start-up and need to ship something, or if you’re just one person working on a little app with a few (even a few tens of thousands) of users, odds are that none of those benefits are worth losing the nice stuff Django gives you, or the time it takes to build APIs (even using existing apps to do it) or abstraction layers between the silos.

A one click Django installation for Raspberry Pi

Also, as part of a plan to re-emphasize a digital and local focus, Mediaphormedia, which created the internationally accepted Django Web framework, released 10 employees and will phase out its commercial software operations to serve only the company’s specific internal needs. The change was announced to employees and clients earlier this week.

Also, as part of a plan to re-emphasize a digital and local focus, Mediaphormedia, which created the internationally accepted Django Web framework, released 10 employees and will phase out its commercial software operations to serve only the company’s specific internal needs. The change was announced to employees and clients earlier this week.

Making strings in templates localizable is exceptionally easy. Making strings in Python localizable is a little more complicated. The short answer, though, is just wrap the string in _().

The key parts are the get_urls function and the admin_update_feeds view. The get_urls method returns the urls for this admin to which we are adding our custom view. The custom view does the updating of the lifestream feeds and returns the user to the Item model's changelist view. We get the url for that view by calling reverse with the pattern "<namespace>:<app>_<model>_changelist" which in our case is "admin:lifestream_item_changelist" since the django admin uses the admin namespace.

WebDAV implemented as a Django application. The motivation for this project is to allow authentication of users against Django's contrib.auth system, while also exporting different directories per user. Many Django tools and app can be combined with this such as django-digest etc. to provide a powerful WebDAV server.

WebDAV implemented as a Django application. The motivation for this project is to allow authentication of users against Django's contrib.auth system, while also exporting different directories per user. Many Django tools and app can be combined with this such as django-digest etc. to provide a powerful WebDAV server.

We have several Django servers behind an EC2 load balancer, as well as a few Celery boxes, a RabbitMQ box, a Node.js box, and a Redis box.

But what if you're allowing your users to create their own survey questions, so that you don't know ahead of time how many answers you'll need? Luckily, you can add fields to the form as you're constructing it, in addition to specifying them as class attributes. If you have all your survey questions in a list (let's call it questions just to be confusing), you could create a Survey class that looks like this:

A Python RFC2397 ("data url") implementation

Below is example code that allows you to resize images using Django’s models.ImageField and PIL library. Hopefully this saves someone some time as it took me a few hours to come up with a solution.

This test upload handler terminates the connection if more than a quota (5MB) is uploaded.

"On Twitter, I asked, “what’s your favorite third-party Django app?” Eight hours later, I’ve got about 50 replies."

"This snippet for Piston allows you to offer a choice of authentication methods to clients."

"As my Django sites get larger and larger, there inevitably comes a point where I want access to the current request from deep inside some function that doesn't have the request object. The latest reason was that I wanted a model class helper to have access to the session so it could access some debug flags. "

"This is exactly the kind of cross-cutting concern (note the use of a signal publisher for notification!) that would be better handled with a signal from the microblogging app. Perhaps the app could have published “tweet received” as a signal, with an optional “module for common associated applications” dispatching that event to logging, activity streams, notifications or whatever as available. The presence of explicit publication would have signaled to any developer to look for subscribers, so I don’t think this is a dangerous case of unlabeled subroutines and the potential for spaghetti code that goes with it. Most Django apps are small silos of code; it would not have been onerous to separate out and isolate this cross-cutting concern from the rest of the microblogging application’s functionality."

"If you use a source control system (CVS, SVN, ...), or want to publish your application on the web, it may be a good idea to move sensitive or machine/user specific settings like database passwords and such out of the main settings.py file. "

"A template extension system for marking points in your django templates as 'plugin-points', and providing plugins which inject themselves at those points. Multiple applications can be injected at each plugin point, and 'registered' plugin-points can have the visibility, order and access of the plugins controlled via DB models. This control can be done on a site wide or per-user basis. Thus you can allow users to add, remove, and reorder the plugins on their profile page for instance."

"Generate generic activity streams from the actions on your site. Users can follow any actor's activities for personalized streams."

"Sore Thumb is a Python module to process images in to thumbnails, and apply effects that may be difficult or impossible to do in the browser."

"With django-filetransfers you can write reusable Django apps that handle uploads and downloads in an abstract way."

"A mini-framework for Django for creating RESTful APIs."

"Here at Sourcefabric we have been looking in to what software stack to use for our next web products. This discussion used to be (oh, 5-10 years ago) a lot simpler, mainly involving choosing an operating systems, a language, and a database. But now it’s about higher-level things like out-of-the-box support for commenting, activity streams, ajax, cloud storage, deployment tools, scalability, geolocation, tagging, RESTful interfaces, search, twitter, facebook, and a whole lot more. Users and customers are starting to expect all of this built into any web application you build. Building applications these days is largely about integrating a large number of existing technologies instead of building something from scratch."

"Freshen is an acceptance testing framework for Python, inspired by Cucumber and has the same goal: make BDD fun, but using Python instead of Ruby. Freshen uses the same syntax of Cucumber (Gherkin Syntax) and runs as a plugin of Nose, a powerful Python tool for using daily when you with TDD"

"If you want a solid python web framework on neat hosting infrastructure, Django and Google App Engine form a good match. "

"It's a clever solution because you end up defining what doesn't get cached instead of what does get cached. It's a sideways way of looking at the problem -- sort of like how Django's template inheritance system defines which parts of the page change instead of defining server-side includes of the common bits."

"Start changing one single line of code in an application build on top of Drupal or ezPublish, to name only the two major ones, and you are in trouble. The moment you need something that is not natively supported, you enter the Dark Zone of CMS hell. You are going to spend a lot of money on development. You will never see the end of the tunnel. That is, until someone says, a few years from now, “Do we need all that crap? Let’s build something that fits our needs and that actually works”.Given number of available open-source CMS solutions, building one on your own sounds like a stupid idea. But if your website is 50% content management and 50% something else, you probably need to start with a web application framework like symfony or Django, rather than a CMS. These frameworks provide plugins that do part of the Content Management job already, so creating a CMS today is like assembling Lego bricks to build something that exactly fits your needs."

"I've written a small Python script that is a fully functional, self-contained, self-starting Django application."

Whoa. Django running and hosted on an iPhone.

"In my humble opinion, this kind of “dumbed-down” templating results in only one thing: more lines of code in the application modules, lines of code that are really only about presentation, and should be in the templates."

"After several Java (J2EE) development jobs Leah Culver wanted to learn a new programming language. Following a friend’s suggestion, she began “playing around” with a Python Web framework called Django last January."

'having ORM isn't "hiding SQL".'

"For the second entry in my series of posts about the Django template language (part one was an introduction), I've chosen to focus on its inheritance capability, which is probably its most powerful feature."

"This brief tutorial will show you how to make use of CRUD generic views in your Django application."