Bugs can always be described to the Mailing list, but the best
way to report an issue and to ensure a timely response is to use the
issue tracker.
- Create a GitHub account.
You need to create a GitHub account to be able to create new issues
and participate in the discussion.
- Determine if your bug is really a bug.
You should not file a bug if you are requesting support. For that you can use
the Mailing list, or IRC.
- Make sure your bug hasn’t already been reported.
Search through the appropriate Issue tracker. If a bug like yours was found,
check if you have new information that could be reported to help
the developers fix the bug.
- Collect information about the bug.
To have the best chance of having a bug fixed, we need to be able to easily
reproduce the conditions that caused it. Most of the time this information
will be from a Python traceback message, though some bugs might be in design,
spelling or other errors on the website/docs/code.
If the error is from a Python traceback, include it in the bug report.
We also need to know what platform you’re running (Windows, OSX, Linux, etc),
the version of your Python interpreter, and the version of Celery, and related
packages that you were running when the bug occurred.
- Submit the bug.
By default GitHub will email you to let you know when new comments have
been made on your bug. In the event you’ve turned this feature off, you
should check back on occasion to ensure you don’t miss any questions a
developer trying to fix the bug might ask.
Bugs for a package in the Celery ecosystem should be reported to the relevant
issue tracker.
If you are unsure of the origin of the bug you can ask the
Mailing list, or just use the Celery issue tracker.
Version numbers consists of a major version, minor version and a release number.
Since version 2.1.0 we use the versioning semantics described by
semver: http://semver.org.
Stable releases are published at PyPI
while development releases are only available in the GitHub git repository as tags.
All version tags starts with “v”, so version 0.8.0 is the tag v0.8.0.
Current active version branches:
You can see the state of any branch by looking at the Changelog:
If the branch is in active development the topmost version info should
contain metadata like:
2.4.0
======
:release-date: TBA
:status: DEVELOPMENT
:branch: master
The status field can be one of:
PLANNING
The branch is currently experimental and in the planning stage.
DEVELOPMENT
The branch is in active development, but the test suite should
be passing and the product should be working and possible for users to test.
FROZEN
The branch is frozen, and no more features will be accepted.
When a branch is frozen the focus is on testing the version as much
as possible before it is released.
The master branch is where development of the next version happens.
Maintenance branches are named after the version, e.g. the maintenance branch
for the 2.2.x series is named 2.2. Previously these were named
releaseXX-maint.
The versions we currently maintain is:
2.3
This is the current series.
2.2
This is the previous series, and the last version to support Python 2.4.
2.1
This is the last version to use the carrot AMQP framework.
Recent versions use kombu.
Archived branches are kept for preserving history only,
and theoretically someone could provide patches for these if they depend
on a series that is no longer officially supported.
An archived version is named X.Y-archived.
Our currently archived branches are:
- 2.1-archived
- 2.0-archived
- 1.0-archived
Major new features are worked on in dedicated branches.
There is no strict naming requirement for these branches.
Feature branches are removed once they have been merged into a release branch.
Note
Contributing to Celery should be as simple as possible,
so none of these steps should be considered mandatory.
You can even send in patches by email if that is your preferred
work method. We won’t like you any less, any contribution you make
is always appreciated!
However following these steps may make maintainers life easier,
and may mean that your changes will be accepted sooner.
First you need to fork the Celery repository, a good introduction to this
is in the Github Guide: Fork a Repo.
After you have cloned the repository you should checkout your copy
to a directory on your machine:
$ git clone git@github.com:username/celery.git
When the repository is cloned enter the directory to set up easy access
to upstream changes:
$ cd celery
$ git remote add upstream git://github.com/ask/celery.git
$ git fetch upstream
If you need to pull in new changes from upstream you should
always use the --rebase option to git pull:
git pull --rebase upstream master
With this option you don’t clutter the history with merging
commit notes. See Rebasing merge commits in git.
If you want to learn more about rebasing see the Rebase
section in the Github guides.
If you need to work on a different branch than master you can
fetch and checkout a remote branch like this:
git checkout --track -b 3.0-devel origin/3.0-devel
For a list of branches see Branches.
To run the Celery test suite you need to install a few dependencies.
A complete list of the dependencies needed are located in
requirements/test.txt.
Installing the test requirements:
$ pip -E $VIRTUAL_ENV install -U -r requirements/test.txt
When installation of dependencies is complete you can execute
the test suite by calling nosetests:
Some useful options to nosetests are:
-x
Stop running the tests at the first test that fails.
-s
--nologcapture
Don’t capture log output.
-v
If you want to run the tests for a single test file only
you can do so like this:
$ nosetests celery.tests.test_worker.test_worker_job
When your feature/bugfix is complete you may want to submit
a pull requests so that it can be reviewed by the maintainers.
Creating pull requests is easy, and also let you track the progress
of your contribution. Read the Pull Requests section in the Github
Guide to learn how this is done.
You can also attach pull requests to existing issues by following
the steps outlined here: http://bit.ly/koJoso
Code coverage in HTML:
$ nosetests --with-coverage3 --cover3-html
The coverage output will then be located at
celery/tests/cover/index.html.
Code coverage in XML (Cobertura-style):
$ nosetests --with-coverage3 --cover3-xml --cover3-xml-file=coverage.xml
The coverage XML output will then be located at coverage.xml
There is a tox configuration file in the top directory of the
distribution.
To run the tests for all supported Python versions simply execute:
If you only want to test specific Python versions use the -e
option:
To build the documentation you need to install the dependencies
listed in requirements/docs.txt:
$ pip -E $VIRTUAL_ENV install -U -r requirements/docs.txt
After these dependencies are installed you should be able to
build the docs by running:
$ cd docs
$ rm -rf .build
$ make html
Make sure there are no errors or warnings in the build output.
After building succeeds the documentation is available at .build/html.
To use these tools you need to install a few dependencies. These dependencies
can be found in requirements/pkgutils.txt.
Installing the dependencies:
$ pip -E $VIRTUAL_ENV install -U -r requirements/pkgutils.txt
To ensure that your changes conform to PEP8 and to run pyflakes
execute:
To not return a negative exit code when this command fails use the
-E option, this can be convenient while developing:
To make sure that all modules have a corresponding section in the API
reference please execute:
$ paver autodoc
$ paver verifyindex
If files are missing you can add them by copying an existing reference file.
If the module is internal it should be part of the internal reference
located in docs/internals/reference/. If the module is public
it should be located in docs/reference/.
For example if reference is missing for the module celery.worker.awesome
and this module is considered part of the public API, use the following steps:
$ cd docs/reference/
$ cp celery.schedules.rst celery.worker.awesome.rst
$ vim celery.worker.awesome.rst
# change every occurance of ``celery.schedules`` to
# ``celery.worker.awesome``
$ vim index.rst
# Add ``celery.worker.awesome`` to the index.
# Add the file to git
$ git add celery.worker.awesome.rst
$ git add index.rst
$ git commit celery.worker.awesome.rst index.rst \
-m "Adds reference for celery.worker.awesome"
You should probably be able to pick up the coding style
from surrounding code, but it is a good idea to be aware of the
following conventions.
- All Python code must follow the PEP-8 guidelines.
pep8.py is an utility you can use to verify that your code
is following the conventions.
Lines should not exceed 78 columns.
You can enforce this in vim by setting the textwidth option:
If adhering to this limit makes the code less readable, you have one more
character to go on, which means 78 is a soft limit, and 79 is the hard
limit :)
Import order
- Python standard library (import xxx)
- Python standard library (‘from xxx import`)
- Third party packages.
- Other modules from the current package.
or in case of code using Django:
- Python standard library (import xxx)
- Python standard library (‘from xxx import`)
- Third party packages.
- Django packages.
- Other modules from the current package.
Within these sections the imports should be sorted by module name.
Example:
import threading
import time
from collections import deque
from Queue import Queue, Empty
from .datastructures import TokenBucket
from .utils import timeutils
from .utils.compat import all, izip_longest, chain_from_iterable
Wildcard imports must not be used (from xxx import *).
For distributions where Python 2.5 is the oldest support version
additional rules apply:
Absolute imports must be enabled at the top of every module:
from __future__ import absolute_import
If the module uses the with statement it must also enable that:
from __future__ import with_statement
Every future import must be on its own line, as older Python 2.5
releases did not support importing multiple features on the
same future import line:
# Good
from __future__ import absolute_import
from __future__ import with_statement
# Bad
from __future__ import absolute_import, with_statement
(Note that this rule does not apply if the package does not include
support for Python 2.5)
Note that we use “new-style` relative imports when the distribution
does not support Python versions below 2.5
Commands to make a new public stable release:
$ paver releaseok # checks pep8, autodoc index and runs tests
$ paver removepyc # Remove .pyc files.
$ git clean -xdn # Check that there's no left-over files in the repository.
$ python2.5 setup.py sdist upload # Upload package to PyPI
$ paver upload_pypi_docs
$ paver ghdocs # Build and upload documentation to Github.
If this is a new release series then you also need to do the
following: