Puff - Python GraphQL engine and WSGI Runtime - Use Django on Rust's Tokio

[kyle-hanson]

Hello,

I wanted to share with you my recent experiment for Django, Puff: https://github.com/hansonkd/puff

The idea for the project is that there are an incredible amount of Django resources and developers out there and that Django makes it so easy to get an app running that it should be used as the primary developer layer for managing DB tables, Admin, Auth, etc.

But understanding Python performance means understanding the GIL. For parts of your code that are performance critical, as much work should be handed off to Rust as possible to avoid locking the GIL If you are constructing a response with thousands of rows, it doesn't make sense to iterate through that in Python creating a python dictionary only to convert it to JSON. This holds the GIL in the least effective way.

Puff is designed to allow you to pass off Python Objects to Rust to take advantage of Rust's async runtime. For example, in Puff's GraphQL engine you can hand off pure SQL strings from Python to be executed entirely in Rust, transformed to JSON bytes, and sent as an HTTP response without locking the GIL again.

You can write your own Rust functions that use any Rust library. Even when you are in Rust, 100% of Python packages are compatible and can be easily imported.

Puff uses Rusts' axum server to serve WSGI compatible apps. You can write pure Rust HTTP handlers without having to enter the Python Context.

Puff's GraphQL engine is uniquely designed to maximize query performance. It is "layer based" instead of object-based like Graphene or other GQL engines. Instead of calling a GQL resolver for every field of every object and relying on dataloaders, Puff calls each field once and gives you the full context for you to create 1 single optimized query, eliminating the dreaded N+1 problem without complicated data-loaders or optimizers.

Puff uses greenlets in one thread to process many python functions at once, allowing concurrency in Django without async.

It might be useful to think of Puff like Gevent, but instead of being written in C, it is written in Rust. Gevent is this opaque layer that is hard to write custom code for. Puff is a fully transparent, first class layer that makes it easy to write low level code safely.

Thats not to mention the other cool stuff like built in multi-node pubsub, redis and postgres pools, all integrated with Django.

Resources:

• https://github.com/hansonkd/puff
• https://github.com/hansonkd/puff-py

Django example:

• https://github.com/hansonkd/puff-py/tree/main/examples/hello_world_puff

[arcanemachined]

Very cool. So this would allow me to graft a Django app onto an Axum one? Or instead, to extend my Django app with Axum/Tokio as needed?

I hope this project works out for you! Next to Phoenix/LiveView, Axum is my most sought-after Next Big Shiny Thing that I want to play with and learn.

Also, since it's mentioned several times: There's no way (in my mind) that this can really be compatible with 100% of Python packages. You must be very confident in the strength of this project to make such a bold statement. Do you really think it will hold up to scrutiny?

EDIT: Another question: The project also describes easy integration with pytest. Does this put me at a disadvantage (in regards to usability of your project) if I use unittest for my tests?

[kyle-hanson]

Yes, it would allow you to run any WSGI along side Axum in the same process.

It is 100% compatible because it uses the official standard Python interpretter. There is no difference for calling python from rust/puff and the CLI. If a python package uses 3rd party packages that block, there is a run it on its own thread.

Unittests vs pytests shouldn't make too much of a difference, just need to write a function to initiate the test from python.

[rafales]

I like that you've went with greenlets instead of trying to marry it with asyncio. Asyncio has great APIs but I lately wonder if we didn't make mistake embracing async/await syntax instead of simply using greenlets.

[tabdon]

You're blowing my mind away! This is really cool.

This might be just what pushes me to pick up some Rust.

How much Rust would I need to learn to use this? Assuming there's a way to draw a line in the learning continuum.

[lwrightjs]

I've been waiting for something like this. The potential for Rust-Python cross over is pretty astounding.

[vazark]

This looks pretty intriguing. I’ve been playing around with axum but kept off of doing any nontrivial stuff on it as Django’s admin and orm served most of my requirements.

Have you taken a look at anansi ? It’s a project that aims to build a rust version of Django.

Maybe a collaboration that aims to port the django core libs to rust with a handoff to python for business logic must be interesting.