How To Contribute¶
Every open source project lives from the generous help by contributors that sacrifice their time and
python-telegram-bot is no different. To make participation as pleasant as possible, this project adheres to the Code of Conduct by the Python Software Foundation.
Setting things up¶
python-telegram-botrepository to your GitHub account.
Clone your forked repository of
python-telegram-botto your computer:
$ git clone https://github.com/<your username>/python-telegram-bot $ cd python-telegram-bot
Add a track to the original repository:
$ git remote add upstream https://github.com/python-telegram-bot/python-telegram-bot
$ pip install -r requirements-all.txt
Install pre-commit hooks:
$ pre-commit install
Finding something to do¶
If you already know what you’d like to work on, you can skip this section.
If you have an idea for something to do, first check if it’s already been filed on the issue tracker. If so, add a comment to the issue saying you’d like to work on it, and we’ll help you get started! Otherwise, please file a new issue and assign yourself to it.
Another great way to start contributing is by writing tests. Tests are really important because they help prevent developers from accidentally breaking existing code, allowing them to build cool things faster. If you’re interested in helping out, let the development team know by posting to the Telegram group, and we’ll help you get started.
That being said, we want to mention that we are very hesitant about adding new requirements to our projects. If you intend to do this, please state this in an issue and get a verification from one of the maintainers.
Instructions for making a code change¶
The central development branch is
master, which should be clean and ready for release at any time. In general, all changes should be done as feature branches based off of
If you want to do solely documentation changes, base them and PR to the branch
doc-fixes. This branch also has its own RTD build.
Here’s how to make a one-off code change.
Choose a descriptive branch name. It should be lowercase, hyphen-separated, and a noun describing the change (so,
fuzzy-rules, but not
implement-fuzzy-rules). Also, it shouldn’t start with
Create a new branch with this name, starting from
master. In other words, run:
$ git fetch upstream $ git checkout master $ git merge upstream/master $ git checkout -b your-branch-name
Make a commit to your feature branch. Each commit should be self-contained and have a descriptive commit message that helps other developers understand why the changes were made. We also have a check-list for PRs below.
You can refer to relevant issues in the commit message by writing, e.g., “#105”.
Your code should adhere to the PEP 8 Style Guide, with the exception that we have a maximum line length of 99.
Document your code. This step is pretty important to us, so it has its own section.
The following exceptions to the above (Google’s) style guides applies:
Documenting types of global variables and complex types of class members can be done using the Sphinx docstring convention.
In addition, PTB uses some formatting/styling and linting tools in the pre-commit setup. Some of those tools also have command line tools that can help to run these tools outside of the pre-commit step. If you’d like to leverage that, please have a look at the pre-commit config file for an overview of which tools (and which versions of them) are used. For example, we use Black for code formatting. Plugins for Black exist for some popular editors. You can use those instead of manually formatting everything.
Please ensure that the code you write is well-tested and that all automated tests still pass. We have dedicated an testing page to help you with that.
Don’t break backward compatibility.
Add yourself to the AUTHORS.rst file in an alphabetical fashion.
If you want run style & type checks before committing run
$ pre-commit run -a
To actually make the commit (this will trigger tests style & type checks automatically):
$ git add your-file-changed.py
Finally, push it to your GitHub fork, run:
$ git push origin your-branch-name
When your feature is ready to merge, create a pull request.
Go to your fork on GitHub, select your branch from the dropdown menu, and click “New pull request”.
Add a descriptive comment explaining the purpose of the branch (e.g. “Add the new API feature to create inline bot queries.”). This will tell the reviewer what the purpose of the branch is.
Click “Create pull request”. An admin will assign a reviewer to your commit.
Address review comments until all reviewers give LGTM (‘looks good to me’).
When your reviewer has reviewed the code, you’ll get a notification. You’ll need to respond in two ways:
Make a new commit addressing the comments you agree with, and push it to the same branch. Ideally, the commit message would explain what the commit does (e.g. “Fix lint error”), but if there are lots of disparate review comments, it’s fine to refer to the original commit message and add something like “(address review comments)”.
In order to keep the commit history intact, please avoid squashing or amending history and then force-pushing to the PR. Reviewers often want to look at individual commits.
In addition, please reply to each comment. Each reply should be either “Done” or a response explaining why the corresponding suggestion wasn’t implemented. All comments must be resolved before LGTM can be given.
Resolve any merge conflicts that arise. To resolve conflicts between ‘your-branch-name’ (in your fork) and ‘master’ (in the
$ git checkout your-branch-name $ git fetch upstream $ git merge upstream/master $ ...[fix the conflicts]... $ ...[make sure the tests pass before committing]... $ git commit -a $ git push origin your-branch-name
At the end, the reviewer will merge the pull request.
Tidy up! Delete the feature branch from both your local clone and the GitHub repository:
$ git branch -D your-branch-name $ git push origin --delete your-branch-name
Celebrate. Congratulations, you have contributed to
Check-list for PRs¶
This checklist is a non-exhaustive reminder of things that should be done before a PR is merged, both for you as contributor and for the maintainers. Feel free to copy (parts of) the checklist to the PR description to remind you or the maintainers of open points or if you have questions on anything.
.. versionadded:: NEXT.VERSION,
.. versionchanged:: NEXT.VERSIONor
.. deprecated:: NEXT.VERSIONto the docstrings for user facing changes (for methods/class descriptions, arguments and attributes)
Created new or adapted existing unit tests
Documented code changes according to the CSI standard
Added myself alphabetically to
Added new classes & modules to the docs and all suitable
Checked the Stability Policy in case of deprecations or changes to documented behavior
If the PR contains API changes (otherwise, you can ignore this passage)
Checked the Bot API specific sections of the Stability Policy
Created a PR to remove functionality deprecated in the previous Bot API release (see here)
self._id_attrsand corresponding documentation
Added new shortcuts:
Messagefor all methods that accept
quoteargument if methods accepts
CallbackQueryfor all methods that accept either
Added new constants at
telegram.constantsand shortcuts to them as class variables
Link new and existing constants in docstrings instead of hard-coded numbers and strings
Add new message types to
Added new handlers for new update types
Add the handlers to the warning loop in the
Added new filters for new message (sub)types
Added or updated documentation for the changed class(es) and/or method(s)
Added the new method(s) to
Added or updated
Updated the Bot API version number in all places:
README_RAW.rst(including the badge), as well as
The documentation of this project is separated in two sections: User facing and dev facing.
User facing docs are hosted at RTD. They are the main way the users of our library are supposed to get information about the objects. They don’t care about the internals, they just want to know what they have to pass to make it work, what it actually does. You can/should provide examples for non obvious cases (like the Filter module), and notes/warnings.
Dev facing, on the other side, is for the devs/maintainers of this project. These doc strings don’t have a separate documentation site they generate, instead, they document the actual code.
User facing documentation¶
We use sphinx to generate static HTML docs. To build them, first make sure you’re running Python 3.9 or above and have the required dependencies:
$ pip install -r docs/requirements-docs.txt
then run the following from the PTB root directory:
$ make -C docs html
or, if you don’t have
make available (e.g. on Windows):
$ sphinx-build docs/source docs/build/html
Once the process terminates, you can view the built documentation by opening
docs/build/html/index.html with a browser.
.. versionadded:: NEXT.VERSION,
.. versionchanged:: NEXT.VERSIONor
.. deprecated:: NEXT.VERSIONto the associated documentation of your changes, depending on what kind of change you made. This only applies if the change you made is visible to an end user. The directives should be added to class/method descriptions if their general behaviour changed and to the description of all arguments & attributes that changed.
Dev facing documentation¶
We adhere to the CSI standard. This documentation is not fully implemented in the project, yet, but new code changes should comply with the CSI standard. The idea behind this is to make it very easy for you/a random maintainer or even a totally foreign person to drop anywhere into the code and more or less immediately understand what a particular line does. This will make it easier for new to make relevant changes if said lines don’t do what they are supposed to.
Assert comparison order¶
Assert statements should compare in actual == expected order.
For example (assuming
test_call is the thing being tested):
# GOOD assert test_call() == 5 # BAD assert 5 == test_call()
Properly calling callables¶
Methods, functions and classes can specify optional parameters (with default values) using Python’s keyword arg syntax. When providing a value to such a callable we prefer that the call also uses keyword arg syntax. For example:
# GOOD f(0, optional=True) # BAD f(0, True)
This gives us the flexibility to re-order arguments and more importantly to add new required arguments. It’s also more explicit and easier to read.