Sockpuppet is ultimately a port of Rails' library StimulusReflex and thus also relies on Stimulus, an excellent library from the creators of Rails (though it has no dependency on Rails and can be used entirely by itself).
You can easily install Sockpuppet to new and existing Django projects.
1
pip install django-sockpuppet
2
3
# If performance is important you can take advantage lxml parsing
4
# It will typically speed up the round trip by 30-90ms depending on the html
5
pip install django-sockpuppet[lxml]
6
7
8
# Add these into INSTALLED_APPS in settings.py
9
INSTALLED_APPS =[
10
'channels',
11
'sockpuppet'
12
]
13
14
# generates scaffolding for webpack.config.js and installs required js dependencies
15
# if you prefer to do that manually read on below.
16
python manage.py initial_sockpuppet
17
18
# scaffolds a new reflex with everything that's needed.
The terminal commands above will ensure that Sockpuppet is installed. It creates an example to get you started.
If you want or need to build your own JavaScript you need to make some more adjustments. The initial_sockpuppet command helps you to set up a JavaScript build flow with Webpack. If you don't want to do this you can use the following in your templates to load the required JavaScript.
1
{% static 'sockpuppet/sockpuppet.js'%}
Copied!
You also need to make some further configurations in settings.py to configure Channels.
Configuration
Sockpuppet depends on django-channels for the websockets functionality, and as such we need that configuration. We need to make some changes to settings.py where we need to add the following.
Instead of using redis as a channel layer you can use the in-memory channel layer. But that should ONLY be used for development purposes or tests.
1
CHANNEL_LAYERS ={
2
"default":{
3
"BACKEND":"channels.layers.InMemoryChannelLayer"
4
}
5
}
Copied!
If you already are using django-channels in your project you can take a look at the source code of the routing file in Sockpuppet and amend your routing as needed.
Javascript configuration
You may already have a working build system in javascript for your Django project. If you don't we've got you covered.
There isn't a particularly strong convention on javascript should be handled in Django, so below is a proposal on how you could organize your build setup.
So let's first install all the dependencies we need for the most minimal Webpack configuration to work.
1
npm i -D fs path sockpuppet-js stimulus stimulus_reflex webpack webpack-cli
Copied!
We also need to build and watch any changes that we make in our project. For this we add two script options into package.json
The last part is the configuration for Webpack itself.
webpack.config.js
1
const webpack =require('webpack');
2
const glob =require('glob');
3
4
5
let globOptions ={
6
ignore:['node_modules/**','venv/**']
7
}
8
9
let entryFiles = glob.sync("**/javascript/*.js", globOptions)
10
11
let entryObj ={};
12
entryFiles.forEach(function(file){
13
if(file.includes('.')){
14
let parts = file.split('/')
15
let path = parts.pop()
16
let fileName = path.split('.')[0];
17
entryObj[fileName]=`./${file}`;
18
}
19
});
20
21
const config ={
22
mode: process.env.NODE_ENV,
23
entry: entryObj,
24
output:{
25
path: __dirname +'/dist/js',
26
filename:'[name].js'
27
},
28
optimization:{
29
minimize:false
30
}
31
}
32
33
module.exports = config
Copied!
The configuration above will look for JavaScript files in the folder your_app/javascript, compile them and place the output in the folder dist/js/.
If you add that folder to STATICFILES_DIRS in settings it will pick that compiled JavaScript and you can use it in templates.
1
from pathlib import Path
2
BASE_DIR = Path.cwd()
3
STATICFILES_DIRS =[
4
("js",f"{BASE_DIR}/dist/js"),
5
]
Copied!
And that's it! You can start using Sockpuppet in your application.
Session storage
By default, Django is using the database as a backend for sessions. Examples in the quickstart will be using sessions as a way to persist data between page loads.
This may cause more strain on your database in high-traffic scenarios than would you like. Since you are already using Redis for django-channels you could use Redis as a session storage. The library django-redis has instructions to set that up.