The application and demo are developed, built and tested in a virtualenv enviroment, supported by a number of bash shell scripts. The resultant package should work on any Python installation that meets the requirements.

Automatic builds have been set up on Travis-CI including running tests and reporting code coverage.

Current status: Travis Badge

Environment setup

To set up a development environment, first clone the repository, and then use the make_env script:

git clone

cd django-plotly-dash


The script creates a virtual environment and uses pip to install the package requirements from the requirements.txt file, and then also the extra packages for development listed in the dev_requirements.txt file. It also installs django-plotly-dash as a development package.

Redis is an optional dependency, and is used for live updates of Dash applications through channels endpoints. The prepare_redis script can be used to install Redis using Docker. It essentially pulls the container and launches it:

# prepare_redis content:
docker pull redis:4
docker run -p 6379:6379 -d redis

The use of Docker is not mandatory, and any method to install Redis can be used provided that the configuration of the host and port for channels is set correcty in the for the Django project.

During development, it can be convenient to serve the Dash components locally. Whilst passing serve_locally=True to a DjangoDash constructor will cause all of the css and javascript files for the components in that application from the local server, it is recommended to use the global serve_locally configuration setting.

Note that it is not good practice to serve static content in production through Django.

Coding and testing

The pylint and pytest packages are important tools in the development process. The global configuration used for pylint is in the pylintrc file in the root directory of the codebase.

Tests of the package are contained within the django_plotly_dash/ file, and are invoked using the Django settings for the demo. Running the tests from the perspective of the demo also enables code coverage for both the application and the demo to be measured together, simplifying the bookkeeping.

Two helper scripts are provided for running the linter and test code:

# Run pylint on django-plotly-dash module

# Run pylint on the demo code, and then execute the test suite

It is also possible to run all of these actions together:

# Run all of the checks

The goal is for complete code coverage within the test suite and for maximal (‘ten out of ten’) marks from the linter. Perfection is however very hard and expensive to achieve, so the working requirement is for every release to keep the linter score above 9.5, and ideally improve it, and for the level of code coverage of the tests to increase.


Documentation lives in the docs subdirectory as reStructuredText and is built using the sphinx toolchain.

Automatic local building of the documentation is possible with the development environment:

source env/bin/activate
cd docs && sphinx-autobuild . _build/html

In addition, the grip tool can be used to serve a rendered version of the README file:

source env/bin/activate

The online documentation is automatically built by the readthedocs infrastructure when a release is formed in the main github repository.

Release builds

This section contains the recipe for building a release of the project.

First, update the version number appropriately in django_plotly_dash/, and then ensure that the checks and tests have been run:


Next, construct the pip packages and push them to pypi:

source env/bin/activate

python sdist
python bdist_wheel

twine upload dist/*

Committing a new release to the main github repository will invoke a build of the online documentation, but first a snapshot of the development environment used for the build should be generated:

pip freeze > frozen_dev.txt

git add frozen_dev.txt
git add django_plotly_dash/

git commit -m" ... suitable commit message for this release ..."

# Create PR, merge into main repo, check content on PYPI and RTD

This preserves the state used for building and testing for future reference.

Bug reports and other issues

The ideal bug report is a pull request containing the addition of a failing test exhibiting the problem to the test suite. However, this rarely happens in practice!

The essential requirement of a bug report is that it contains enough information to characterise the issue, and ideally also provides some way of replicating it. Issues that cannot be replicated within a virtualenv are unlikely to get much attention, if any.

To report a bug, create a github issue.