Awesome
Async Django Session
It gives you ability to share session between django and an async framework like aiohttp, starlette, fastapi etc.
pip install async-django-session
API
Backends
There's two ways of communicating to database available:
- through databases - which is compatible with most of major RDBMS:
database = databases.Database(DB_URI) await database.connect() backend = async_django_session.databases.Backend(database, SECRET_KEY)
- or directly through asyncpg (PostgreSQL only):
pool = await asyncpg.create_pool(DB_URI) backend = async_django_session.asyncpg.Backend(pool, SECRET_KEY)
Session
To fetch session from db by its key there's backend.get_session
method. If
key
is None
a new session will be created:
session = backend.get_session(key)
It's lazy so the session data won't be actually fetched until you call its
load
method. In caches the result, so it's inexpensive to call it multiple
times:
await session.load()
You can combine them into a single line as the load
method returns session
itself:
session = await backend.get_session(key).load()
Session provides dict-interface to read / write data:
session["foo"] = "bar"
print(session["foo"])
To sync session with database you should explicitly call its save
method. It
won't make unnecessary db call if the session wasn't changed (the boolean value
it returns is intend to indicate if it was the case).
saved = await session.save()
During saving of a new session a random key will be generated and available as
session.key
parameter afterwords.
Frameworks integration
There's built-in middlewares for a few frameworks to automatically load (using session id from cookies) and save sessions.
Aiohttp
After adding of session middleware:
session_middleware = async_django_session.aiohttp.middleware(
async_django_session.databases.Backend(db, SECRET_KEY)
)
app = web.Application(middlewares=[session_middleware])
You can get requests session as:
session = await request.get_session()
A full aiohttp example can be found here.
Starlette
After adding of session middleware:
async_django_session.starlette.middleware(
app, async_django_session.databases.Backend(db, SECRET))
)
Session of a current request is available as:
session = await request.state.get_session()
A working starlette example is here.
Fastapi
Perform starlette app initialization from above as fastapi based on it. After that you can get session using dependency injection as:
from async_django_session.fastapi import get_session
from async_django_session.session import Session
async def index(session: Session = Depends(get_session)):
...
A working fastapi example is here.
Running examples
Running the examples you can see different frameworks using the same session data. To see session data open http://localhost:8000/ after running of each example.
Install requirements:
cd examples
pip install -r requirements.txt
Create database and tables:
createdb async_django_session
python django_app.py migrate
Run aiohttp example which uses databases backend:
python aiohttp_app.py
Run starlette example which uses asyncpg backend:
python starlette_app.py
Run fastapi example which uses asyncpg backend:
python fastapi_app.py
Run django example:
python django_app.py runserver