This section describes how the project is organized.
Nilearn uses issues for tracking bugs, requesting potential features, and holding project discussions.
When creating an issue, the user is responsible for a very basic labeling categorizing the issue:
for bug reports.
for documentation related questions or requests.
for feature requests.
First of all, the user might have mislabeled the issue, in which case a member of the Core developers team needs to correct the labels.
In addition to these basic labels, we have many more labels which describes in more detail a given issue. First, we try to describe the estimated amount of work required to solve each issue:
The issue is likely to require a serious amount of work (more than a couple of days).
The issue is likely to require a decent amount of work (in between a few hours and a couple days).
The issue is likely to require a small amount of work (less than a few hours).
We also try to quantify the estimated impact of the proposed change on the project:
Solving this issue will have a high impact on the project.
Solving this issue will have a decent impact on the project.
Solving this issue will have a small impact on the project.
Finally, we also indicate the priority level of the issue:
The task is urgent and needs to be addressed as soon as possible.
The task is important but not urgent and should be addressed over the next few months.
The task is not urgent and can be delayed.
Some issues—particular those which are low effort and low to medium priority—can serve as good starting project for new contributors. We label these issues with the label which can be seen as an equivalent to a “very low effort” label. Because of this, good first issues do not require a separate effort label.
Some other labels can be used to describe further the topic of the issue:
This issue is related to the Nilearn’s API.
This issue tackles code quality (code refactoring, PEP8…).
This issue is related to datasets or the
This issue is used to hold a general discussion on a specific topic where community feedback is desired (no need to specify effort, priority, or impact here).
This issue is related to the
This issue describes a problem with the project’s infrastructure (CI/CD…).
The issue describes a problem with the installation of Nilearn.
This issue is related to maintenance work.
The issue is related to plotting functionalities.
The issue is related to testing.
This issue is a usage question and should have been posted on neurostars.
For a complete list of all issue labels that can be used to describe and their description, see this page
Usually we expect the issue’s author to close the issue, but there are several possible reasons for a community member to close an issue:
The issue has been solved: kindly asked the author whether the issue can be closed. In the absence of reply, close the issue after two weeks.
The issue is a usage question: label the issue with and kindly redirect the author to neurostars. Close the issue afterwards.
The issue has no recent activity (no messages in the last three months): ping the author to see if the issue is still relevant. In the absence of reply, label the issue with
stalledand close it after 2 weeks.
Tox is set to facilitate testing and managing environments during development and ensure that the same commands can easily be run locally and in CI.
Install it with:
pip install tox
You can set up certain environment or run certain command by calling
tox with no extra argument will simply run
all the default commands defined in the tox configuration (
tox list to view all environment descriptions.
tox run to run a specific environment.
tox run -e lint
Some environments allow passing extra argument:
# only run black
tox run -e lint -- black
# only run some tests
tox -e test_plotting -- nilearn/glm/tests/test_contrasts.py
You can also run any arbitrary command in a given environment with
tox exec -e test_latest -- python -m pytest nilearn/_utils/tests/test_data_gen.py
How to make a release?#
This section describes how to make a new release of Nilearn. It is targeted to the specific case of Nilearn although it contains generic steps for packaging and distributing projects. More detailed information can be found on packaging.python.org.
We assume that we are in a clean state where all the Pull Requests (PR) that we wish to include in the new release have been merged.
Prepare code for the release#
The repository should be checked and updated in preparation for the release.
One thing that must be done before the release is made is
from the current
[x.y.z].dev tag to the new version number.
Additionally, make sure all deprecations that are supposed to be removed with this new version have been addressed.
If this new release comes with dependency version bumps (Python, Numpy…), make sure to implement and test these changes beforehand. Ideally, these would have been done before such as to update the code base if necessary. Finally, make sure the documentation can be built correctly.
Prepare the release#
Switch to a new branch locally:
git checkout -b REL-x.y.z
First we need to prepare the release by updating the file
to make sure all the new features, enhancements, and bug fixes are included in their respective sections.
Tehn we need to make sure that all the entries in each section of the changelog
nilearn/doc/changes/latest.rst a) have a label,
and b) are sorted by their “label” alphabetically.
- :bdg-success:`API` ...
- :bdg-dark:`Code` ...
- :bdg-info:`Plotting` ...
We also need to write a “Highlights” section promoting the most important additions that come with this new release.
Finally, we need to change the title from
.. currentmodule:: nilearn
.. include:: names.rst
**Released MONTH YEAR**
- Nilearn now includes functionality A
We must also ensure that every entry in
starts with a “badge” (see the Changelog section).
Once we have made all the necessary changes to
nilearn/doc/changes/latest.rst, we should rename it into
x.y.z is the corresponding version number.
We then need to update
nilearn/doc/changes/whats_new.rst and replace:
.. include:: latest.rst
.. include:: x.y.z.rst
Add these changes and submit a PR:
git add doc/changes/
git commit -m "REL x.y.z"
git push origin REL-x.y.z
Once the PR has been reviewed and merged, pull from master and tag the merge commit:
git checkout main
git pull upstream main
git tag x.y.z
git push upstream --tags
When building the distribution as described below,
hatch-vcs, defined in
extracts the version number using this tag and writes it to a
Build of stable docs#
Once the new version tag of a release is pushed upstream following the step
above, the Github Actions workflow
release-docs.yml will be triggered
automatically to build the stable docs and push them to
our github pages repository
nilearn/nilearn.github.io. The workflow can
also be triggered from the Actions tab.
Build the distributions and upload them to Pypi#
First of all we should make sure we don’t include files that shouldn’t be present:
git checkout x.y.z
If the workspace contains a
dist folder, make sure to clean it:
rm -r dist
In order to build the binary wheel files, we need to install build:
pip install build
And, in order to upload to
Pypi, we will use twine that you can also install with
pip install twine
Build the source and binary distributions:
python -m build
This should add two files to the
one for the source distribution that should look like
one for the built distribution that should look like
This will also update
Optionally, we can run some basic checks with
twine check dist/*
twine upload dist/*
Once the upload is completed, make sure everything looks good on Pypi. Otherwise you will probably have to fix the issue and start over a new release with the patch number incremented.
At this point, we need to upload the binaries to GitHub and link them to the tag.
To do so, go to the Nilearn GitHub page under the “Releases” tab,
and edit the
x.y.z tag by providing a description,
and upload the distributions we just created (you can just drag and drop the files).
Build and deploy the documentation manually#
This step is now automated as described above. If there is a need to run it manually please follow the instructions below.
Before building the documentation, make sure that the following LaTeX dependencies are installed on your system:
You can check if each package is installed by using
command -v <command-name> as in:
command -v dvipng
If the package is installed, then the path to its location on your system will be returned. Otherwise, you can install using your system’s package manager or from source, for example:
See available linux distributions of texlive-latex-base and texlive-latex-extra:
We now need to update the documentation.
export VERSIONTAG=$(git describe --tags --abbrev=0)
This will build the documentation (beware, this is time consuming…) and push it to the GitHub pages repo.
At this point, the release has been made.
We also need to create a new file
doc/changes/latest.rst with a title
and the usual
Bug Fixes, and
Changes sections for the version currently under development:
.. currentmodule:: nilearn
.. include:: names.rst
Finally, we need to include this new file in
.. include:: latest.rst