Developers

Rateslib is a project designed for Python built with Python and Rust. To actively develop it and submit pull requests (PRs) to the repo you will need to set up a development environment.

1) Get the files

Clone the repository and navigate to the directory.

/>$ git clone https://github.com/attack68/rateslib.git
/>$ cd rateslib

2) Setup Python and Rust

It is recommended to install Python 3.13 and Rust 1.80.

Create and activate a virtual Python environment, as below (or the equivalent for Windows).

rateslib/>$ python3 -m venv venv
rateslib/>$ source ./venv/bin/activate

3) Install development requirements

Install the package dependencies for development and then install rateslib locally in editable mode.

(venv) rateslib/>$ pip install -r requirement.txt
(venv) rateslib/>$ pip install -e .

4) Test your environment

After installing everything test that everything is successful.

(venv) rateslib/>$ pytest

5) Making changes

You can now edit and make code changes and submit them for addition to the package. The continuous integration (CI) checks on github perform 8 tasks:

• Rust Checks

  If you do not make changes to the Rust section of the code these will remain unaffected. If you do it will run:

  • cargo fmt --check: to ensure that rust code is properly formatted. If you need to make auto-formatting changes then run the following before committing:

    (venv) rateslib/>$ cargo fmt
    

  • cargo test --lib: to ensure that any introduced code does not impact the pre-existing unit tests for the existing codebase. To check this before committing run:

    (venv) rateslib/>$ cargo test --lib
    

  • cargo test --doc: to ensure that any introduced code does not impact the pre-existing tests in the rust documentation. To check this before committing run:

    (venv) rateslib/>$ cargo test --doc
    

  If you made changes to the Rust section then you must rebuild the PyO3 extension module before testing it works in Python. To do this run:

  (venv) rateslib/>$ maturin develop --release
  

• Python Checks

  If you make changes to the Python section of the code it will run:

  • ruff check: to ensure that no styling or linting errors have been introduced. You may be able to auto-fix any of these before committing by using:

    (venv) rateslib/>$ ruff check --fix
    

  • ruff format: to ensure that the Python code is correctly formatted. If the CI reports errors you can auto-format your code by locally running:

    (venv) rateslib/>$ ruff format
    

  • mypy: type checking the Python code to ensure type consistency. You should locally run the following and fix any issues before committing (note ensure you are using the latest supported Python and mypy versions, inline with the github server):

    (venv) rateslib/>$ mypy
    

  • coverage run -m pytest: this runs all the pytests and measures the coverage report of the codebase which should remain > 96%. You can this locally also before committing by using:

    (venv) rateslib/>$ coverage run -m pytest
    

• Building Documentation

  The documentation is built with Sphinx and its extensions. To locally build the documentation to debug or visualise any changes before submission, run:

  (venv) rateslib/>$ cd docs
  (venv)     docs/>$ make clean
  (venv)     docs/>$ make html
  

  In order to build docs without error you will also need to install pandoc.

  In order to generate inheritance diagrams you will need to install graphviz.

Development Plan

In no particular order…

Feature	Description
Rust extension	Continue to port classes to Rust with PyO3 extension module, also simultaneously working towards stabilising a standalone crate for Rust for linear fixed income.
Swaptions	Plan the design architecture and implementation for Swaptions and IRVolCube
Credit Default Swaps	Add a CDS Instrument and also think about Curve transformation methods for analysis between credit discount curves and hazard rates / survival curves.
Specifications for standard products	Extend the spec loader to cover wider range of Instruments particularly with respect to Bond calculations.
Documentation	Broaden the array of available tutorials, especially in regards to Bond analysis, credit analysis and Index analysis.
PnL Monitoring	Provide an automated PnL explain from multiple Solvers (i.e “open” and “close”)
Serialisation	Continue to enhance the Serialisation aspect of objects. This feature will naturally develop with the Rust extension since stronger typing provides a much more rigid framework for data manipulation.
Interactivity	Expand the available tutorials for interactivity, such as using Excel, Jupyterlite, or app packages, such as Streamlit, Dash, Panel.
Documentation	Release v2 of “Coding Interest Rates” which contains all of the mathematics and architecture changes since version 1.0.0.