Skip to content

Latest commit

 

History

History
195 lines (127 loc) · 6.8 KB

CONTRIBUTING.md

File metadata and controls

195 lines (127 loc) · 6.8 KB
Raw

Contributing

Set up your dev environment

If you want to contribute code to xrpl-py, the following sections describe how to set up your developer environment.

Set up Python environment

To make it easy to manage your Python environment with xrpl-py, including switching between versions, install pyenv and follow these steps:

  • Install pyenv:

      brew install pyenv

    For other installation options, see the pyenv README.

  • Use pyenv to install the optimized version for xrpl-py (currently 3.9.1):

      pyenv install 3.9.1

  • Set the global version of Python with pyenv:

      pyenv global 3.9.1

Set up shell environment

To enable autocompletion and other functionality from your shell, add pyenv to your environment.

These steps assume that you're using a Zsh shell. For other shells, see the pyenv README.

  • Add pyenv init to your Zsh shell:

      echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.zshrc

  • Source or restart your terminal:

      . ~/.zshrc

Manage dependencies and virtual environments

To simplify managing library dependencies and the virtual environment, xrpl-py uses poetry.

  • Install poetry:

      curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -
  poetry install

Set up pre-commit hooks

To run linting and other checks, xrpl-py uses pre-commit.

Note: You only need to install pre-commit if you want to contribute code to xrpl-py.

  • Install pre-commit:

      pip3 install pre-commit
  pre-commit install

Run the linter

To run the linter:

poetry run flake8 ./xrpl

Running Tests

Individual Tests

# Works for single or multiple unit/integration tests
# Ex: poetry run poe test tests/unit/models/test_response.py tests/integration/transactions/test_account_delete.py
poetry run poe test FILE_PATHS

Unit Tests

poetry run poe test_unit

Integration Tests

To run integration tests, you'll need a standalone rippled node running with WS port 6006 and JSON RPC port 5005. You can run a docker container for this:

docker run -p 5005:5005 -p 6006:6006 -it natenichols/rippled-standalone:latest

To actually run the tests:

poetry run poe test_integration

Code Coverage

To run both unit and integration tests and see code coverage:

poetry run poe test_coverage

To see manually code coverage after running unit tests or integration tests:

poetry run coverage report

Running tests with different Python versions

To switch your python version before running tests:

pyenv local 3.9
poetry env use python3.9
poetry install

Replace python3.9 with whatever version of Python you want to use (you must have it installed with pyenv for it to work).

Generate reference docs

You can see the complete reference documentation at xrpl-py docs. You can also generate them locally using poetry and sphinx:

# Go to the docs/ folder
cd docs/

# Build the docs
poetry run sphinx-apidoc -o source/ ../xrpl
poetry run make html

To see the output:

# Go to docs/_build/html/
cd docs/_build/html/

# Open the index file to view it in a browser:
open index.html

Write integration tests

  1. If adding functionality to a new part of the library, create new file with a class that inherits IntegrationTestCase from tests.integration.integration_test_case to store all individual tests under (ex: class TestWallet(IntegrationTestCase)). Otherwise, add to an existing file.
  2. Create an async function for each test case (unless the test is only being used for the sync client)
  3. Include the @test_async_and_sync decorator to test against all client types, unless you specifically only want to test with one client. You can also use the decorator to:
    • Limit tests to sync/async only
    • Limit the number of retries
    • Use Testnet instead of a standalone network
    • Import modules for sync equivalents of any async functions used
  4. Be sure to reuse pre-made values, WALLET, DESTINATION, TESTNET_WALLET, TESTNET_DESTINATION, OFFER, and PAYMENT_CHANNEL, from tests/integrations/reusable_values.py
  5. Be sure to use condensed functions, like submit_transaction_async and sign_and_reliable_submission_async, from tests/integrations/it_utils.py

Examples can be found in subfolders of tests/integrations

Update definitions.json

Use this repo to generate a new definitions.json file from the rippled source code. Instructions are available in that README.

Release process

Editing the Code

  • Your changes should have unit and/or integration tests.
  • Your changes should pass the linter.
  • Your code should pass all the unit and integration tests on Github (which check all versions of Python).
  • Open a PR against master and ensure that all CI passes.
  • Get a full code review from one of the maintainers.
  • Merge your changes.

Release

  1. Create a branch off master that properly increments the version in pyproject.toml and updates the CHANGELOG appropriately. We follow Semantic Versioning.
  2. Merge this branch into master.
  3. Locally build and download the package.
    1. Pull master locally.
    2. Run poetry build to build the package locally.
    3. Locally download the package by running pip install path/to/local/xrpl-py/dist/.whl.
    4. Make sure that this local installation works as intended, and that the changes are reflected properly.
  4. Run poetry publish --dry-run and make sure everything looks good.
  5. Publish the update by running poetry publish.
    • This will require entering PyPI login info.
  6. Create a new Github release/tag off of this branch.
  7. Send an email to xrpl-announce.

Mailing Lists

We have a low-traffic mailing list for announcements of new xrpl-py releases. (About 1 email every couple of weeks)

If you're using the XRP Ledger in production, you should run a rippled server and subscribe to the ripple-server mailing list as well.