Showing preview only (4,738K chars total). Download the full file or copy to clipboard to get everything.
Repository: kernc/backtesting.py
Branch: master
Commit: 6e9016c7b30d
Files: 52
Total size: 4.5 MB
Directory structure:
gitextract_k3y034qj/
├── .codecov.yml
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── 1-bug.yml
│ │ ├── 2-enh.yml
│ │ └── config.yml
│ ├── deploy-gh-pages.sh
│ ├── issue_template.md
│ └── workflows/
│ ├── ci.yml
│ └── deploy-docs.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE.md
├── MANIFEST.in
├── README.md
├── backtesting/
│ ├── __init__.py
│ ├── _plotting.py
│ ├── _stats.py
│ ├── _util.py
│ ├── autoscale_cb.js
│ ├── backtesting.py
│ ├── lib.py
│ └── test/
│ ├── BTCUSD.csv
│ ├── EURUSD.csv
│ ├── GOOG.csv
│ ├── __init__.py
│ ├── __main__.py
│ └── _test.py
├── doc/
│ ├── README.md
│ ├── alternatives.md
│ ├── build.sh
│ ├── examples/
│ │ ├── Multiple Time Frames.ipynb
│ │ ├── Multiple Time Frames.py
│ │ ├── Parameter Heatmap & Optimization.ipynb
│ │ ├── Parameter Heatmap & Optimization.py
│ │ ├── Quick Start User Guide.ipynb
│ │ ├── Quick Start User Guide.py
│ │ ├── Strategies Library.ipynb
│ │ ├── Strategies Library.py
│ │ ├── Trading with Machine Learning.ipynb
│ │ └── Trading with Machine Learning.py
│ ├── pdoc_template/
│ │ ├── config.mako
│ │ ├── credits.mako
│ │ ├── head.mako
│ │ └── logo.mako
│ └── scripts/
│ ├── ipython_config.py
│ ├── logo.py
│ └── strip_yaml.awk
├── pyproject.toml
├── requirements.txt
├── setup.cfg
└── setup.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .codecov.yml
================================================
comment: off
coverage:
range: 75..95
precision: 0
status:
patch:
default:
target: 90
project:
default:
target: auto
threshold: 5
# Fix for https://github.com/codecov/codecov-python/issues/136
fixes:
- "__init__.py::backtesting/__init__.py"
================================================
FILE: .github/FUNDING.yml
================================================
github: kernc
================================================
FILE: .github/ISSUE_TEMPLATE/1-bug.yml
================================================
name: Bug report
description: File a new bug report. Please use the search
body:
- type: markdown
attributes:
value: >
Thanks for putting in the effort to submit this bug report! Note, the best bug reports are accompanied with fixing patches / pull-requests. 🙏
- type: markdown
attributes:
value: >
**Contributing guidelines** $\color{red}{*}$
- [x] I agree to follow this project's [Contributing Guidelines](https://github.com/kernc/backtesting.py/blob/master/CONTRIBUTING.md) which, I understand, contain short technical notes on how to best contribute to this project.
- type: markdown
attributes:
value: >
**Own due diligence** $\color{red}{*}$
- [x] I verify my due dilligence—I have went through the [**tutorials**](https://kernc.github.io/backtesting.py/doc/backtesting/#manuals) and the [**API docs**](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html) and have used the [**search** on **Issues**](https://github.com/kernc/backtesting.py/issues?q=(is%3Aissue%20OR%20is%3Apr)%20) and [GitHub **Disucussions**](https://github.com/kernc/backtesting.py/discussions), as well as Google, with all the relevant search keywords that also comprise the title (see above) of the new issue I'm opening.
- type: textarea
id: expected
validations:
required: true
attributes:
label: Expected behavior
description: You run the code below and expect what to happen?
placeholder: When I run the code below ... the program should ...
- type: textarea
id: code
validations:
required: false
attributes:
label: Code sample
description: Code snippet that clearly reproduces the issue
render: python
placeholder: |
from backtesting import Backtest, Strategy
from backtesting.test import GOOG
class MinimalExample(Strategy):
...
bt = Backtest(GOOG, Example)
...
- type: textarea
id: actual
validations:
required: true
attributes:
label: Actual behavior
description: What happened unexpectedly when you ran the code above?
placeholder: When I ran the code above ... the program did ...
- type: textarea
id: steps
validations:
required: false
attributes:
label: Additional info, steps to reproduce, full crash traceback, screenshots
description: >
Attach any additional info you think might be helpful and result in quicker resolution of your bug.
placeholder: |
1. Do ...
2. ...
3. Boom.
4. See attached screenshots where I highlight the relevant parts.
- type: textarea
id: versions
validations:
required: false
attributes:
label: Software versions
description: >
Versions of the relevant software / packages.
value: |
<!--
# Please paste the output of:
for pkg in ('backtesting', 'pandas', 'numpy', 'bokeh'):
print('-', pkg, getattr(__import__(pkg), '__version__', 'git'))
-->
- `backtesting.__version__`:
- `pandas.__version__`:
- `numpy.__version__`:
- `bokeh.__version__`:
- OS:
================================================
FILE: .github/ISSUE_TEMPLATE/2-enh.yml
================================================
name: Enhancement proposal
description: Describe the enhancement you'd like to see
body:
- type: markdown
attributes:
value: >
Thanks for taking the time to give feedback on this software!
- type: markdown
attributes:
value: >
**Contributing guidelines** $\color{red}{*}$
- [x] I agree to follow this project's [Contributing Guidelines](https://github.com/kernc/backtesting.py/blob/master/CONTRIBUTING.md) which, I understand, contain short technical notes on how to best contribute to this project.
- type: markdown
attributes:
value: >+
**Own due diligence** $\color{red}{*}$
- [x] I verify my due dilligence—I have went through the [**tutorials**](https://kernc.github.io/backtesting.py/doc/backtesting/#manuals) and the [**API docs**](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html) and have used the [**search** on **Issues**](https://github.com/kernc/backtesting.py/issues?q=(is%3Aissue%20OR%20is%3Apr)%20) and [GitHub **Disucussions**](https://github.com/kernc/backtesting.py/discussions), as well as Google, with all the relevant search keywords to ensure this feature request hadn't been filed or answered before.
- type: textarea
id: expected
validations:
required: true
attributes:
label: Enhancement description
description: What would you want to see in the software that doesn't appear to be presently included?
placeholder: I absolutely love your software, but I'm missing a way to ...
- type: textarea
id: code
validations:
required: false
attributes:
label: Code sample
description: Code snippet relevant to the new feature
render: python
- type: textarea
id: steps
validations:
required: false
attributes:
label: Additional info, images
description: |
Extra information you think might be helpful or interesting.
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
contact_links:
- name: Reference documentation
url: https://kernc.github.io/backtesting.py/doc/backtesting/
about: Please confirm you've checked here first.
- name: FAQ
url: https://github.com/kernc/backtesting.py/issues?q=label%3Aquestion%20
about: Frequently asked questions. Use search with potential keywords.
- name: Discussion forum
url: https://github.com/kernc/backtesting.py/discussions
about: Other discussions. Make sure you've seen this too.
================================================
FILE: .github/deploy-gh-pages.sh
================================================
#!/bin/bash
set -eu
if [ ! -d doc/build ]; then
echo 'Error: invalid directory. Deploy from repo root.'
exit 1
fi
[ "$GH_PASSWORD" ] || exit 12
sitemap() {
WEBSITE='https://kernc.github.io/backtesting.py'
find -name '*.html' |
sed "s,^\.,$WEBSITE," |
sed 's/index.html$//' |
grep -v '/google.*\.html$' |
sort -u > 'sitemap.txt'
echo "Sitemap: $WEBSITE/sitemap.txt" > 'robots.txt'
}
head=$(git rev-parse HEAD)
git clone -b gh-pages "https://kernc:$GH_PASSWORD@github.com/$GITHUB_REPOSITORY.git" gh-pages
mkdir -p gh-pages/doc
cp -R doc/build/* gh-pages/doc/
cd gh-pages
sitemap
git add *
if git diff --staged --quiet; then
echo "$0: No changes to commit."
exit 0
fi
if ! git config user.name; then
git config user.name 'github-actions'
git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
fi
git commit -a -m "CI: Update docs for ${GITHUB_REF#refs/tags/} ($head)"
git push
================================================
FILE: .github/issue_template.md
================================================
### Expected Behavior
...
### Actual Behavior
<!--
In case of a bug, attach full exception traceback.
Please wrap verbatim code/output in Markdown fenced code blocks.
-->
### Steps to Reproduce
<!-- In case of a bug, attach steps and code sample
with which the bug can be reproduced. -->
1.
2.
3.
```python
python code goes here
```
### Additional info
<!-- screenshots, code snippets, versions ... -->
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
push: { branches: [master] }
pull_request: { branches: [master] }
schedule: [ cron: '2 2 * * 6' ] # Every Saturday, 02:02
env:
TQDM_MININTERVAL: 10
jobs:
lint:
runs-on: ubuntu-latest
timeout-minutes: 1
steps:
- uses: actions/checkout@v4
- run: pip install flake8 mypy
- run: flake8 backtesting setup.py
- run: mypy --no-warn-unused-ignores backtesting
coverage:
needs: lint
runs-on: ubuntu-latest
timeout-minutes: 4
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.10'
- run: pip install -U --pre bokeh pandas numpy coverage && pip install -U .[test]
- env: { BOKEH_BROWSER: none }
run: time coverage run -m backtesting.test
- run: coverage combine && coverage report
build:
needs: lint
runs-on: ubuntu-latest
timeout-minutes: 3
strategy:
matrix:
python-version: [3.12, 3.13]
experimental: [false]
include:
- python-version: '3.*'
experimental: true
continue-on-error: ${{ matrix.experimental }}
steps:
- uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python-version }}
- uses: actions/checkout@v4
- run: pip install -U .[test]
- env: { BOKEH_BROWSER: none }
run: time python -m backtesting.test
docs:
needs: lint
runs-on: ubuntu-latest
timeout-minutes: 3
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 3
- run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
- run: pip install -e .[doc,test] # -e provides ./backtesting/_version.py for pdoc
- run: time doc/build.sh
win64:
needs:
- build
- docs
runs-on: windows-latest
timeout-minutes: 5
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: 3.13
- run: pip install .[test]
- env: { BOKEH_BROWSER: none }
run: python -m backtesting.test
================================================
FILE: .github/workflows/deploy-docs.yml
================================================
name: Deploy docs
on:
push:
tags: ['[0-9]+.[0-9]+.*']
jobs:
deploy:
name: Deploy
runs-on: ubuntu-latest
env:
TQDM_MININTERVAL: 10
steps:
- uses: actions/setup-python@v5
with:
python-version: 3.11
- uses: actions/cache@v4
with:
path: ~/.cache/pip
key: ${{ runner.os }}
- uses: actions/checkout@v4
with:
fetch-depth: 3
- name: Fetch tags
run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
- run: pip install -U pip setuptools wheel
- run: pip install -U -e .[doc,test]
- run: time doc/build.sh
- run: .github/deploy-gh-pages.sh
env:
GH_PASSWORD: ${{ secrets.GITHUB_TOKEN }}
================================================
FILE: .gitignore
================================================
*.py[cod]
*.html
*.png
_version.py
*.egg-info
.eggs/*
__pycache__/*
dist/*
.coverage
.coverage.*
htmlcov/*
doc/build/*
build/*
.idea/*
.vscode/
**/.ipynb_checkpoints
*~*
.venv/
================================================
FILE: CHANGELOG.md
================================================
What's New
==========
These were the major changes contributing to each release:
### 0.x.x
### 0.6.5
(2025-07-30)
* Include 'Commission' column in `stats._trades` DataFrame (#1277), thanks to Abhirath Mahipal.
* Bugfixes:
* Fix computing commissions when specified with relative amount.
* Fix sometimes cleared SL value in `stats._trades` data frame
* Ensure order size is integer to avoid weird rounding errors.
* Account for commissions in `Trade.pl` and `Trade.pl_pct` (#1279), thanks to Abhirath Mahipal.
* `functools.partial` objects do not always have a __module__ attr in Python 3.9
* Plotting:
* Return long/short triangles to P&L section!
* Do plot `plot=False, overlay=True` indicators, but muted.
### 0.6.4
(2025-03-30)
* Bug fixes:
* Fix optimization hanging on MS Windows under some conditions,
primarily missing a `if __name__ == '__main__'` guard.
* Restore original scale in FractionalBacktest plot (#1247)
* Fix "'CAGR [%]' must match a key in pd.Series result of bt.run()" error
* Fix grid optimization on data with timezone-aware datetime index
### 0.6.3
(2025-03-11)
* Enhancements:
* `backtesting.lib.TrailingStrategy` supports setting trailing stop-loss by percentage.
* [`backtesting.lib.MultiBacktest`](https://kernc.github.io/backtesting.py/doc/backtesting/lib.html#backtesting.lib.MultiBacktest)
multi-dataset backtesting wrapper.
* `Backtest.run()` wrapped in `tqdm()`
* Rename parameter `lib.FractionalBacktest(fractional_unit=)`.
* Add market alpha & market beta stats (#1221)
* Plot improvements:
* Plot trade duration lines in the P&L plot section.
* Simplify PL section, use circular markers.
* Only plot trades when some trades are present.
* Set `fig.yaxis.ticker.desired_num_ticks=3` for indicator subplots.
* Single legend item for indicators with singular/default names.
* Make "OHLC" itself a togglable legend item.
* Add xwheel_pan tool, conditioned on activation for now
(upvote [Bokeh issue](https://github.com/bokeh/bokeh/issues/14363)).
* Reduce height of indicator charts, introduce an overridable private
global `backtesting._plotting._INDICATOR_HEIGHT`.
* Bug fixes:
* Fixed `Position.pl` occasionally not matching `Position.pl_pct` in sign.
* SL _always_ executes before TP when hit in the same bar.
* Fix `functools.partial` objects do not always have a `__module__` attr in Python 3.9 (#1233)
* Fix stop-market and TP hit within the same bar.
* Documentation improvements (warnings, links, ...)
### 0.6.2
(2025-02-19)
* Enhancements:
* Grid optimization with mp.Pool & mp.shm.SharedMemory (#1222)
* [`backtesting.lib.FractionalBacktest`](https://kernc.github.io/backtesting.py/doc/backtesting/lib.html#backtesting.lib.FractionalBacktest)
that supports fractional trading
* `backtesting.__all__` for better `from backtesting import *` and suggestions
* Bugs fixed:
* Fix remaining issues with `trade_on_close=True`
* Fix trades reported in reverse chronological order when `finalize_trades=True`
* Fix crosshair not linked across subplots
* Cast `datetime_arr.astype(np.int64)` to avoid Windos error
### 0.6.1
(2025-02-04)
Enhancement: Use `joblib.Parallel` for optimization.
This should vastly improve performance on Windows while not
affecting other platforms too much.
### 0.6.0
(2025-02-04)
* Enhancements:
* Add `Backtest(spread=)`; change `Backtest(commission=)` to apply twice per trade
* Show paid "Commissions [$]" key in trade stats
* Allow multiple names for vector indicators (#980)
* Add columns SL and TP to `stats['trades']` (#1039)
* Add entry/exit indicator values to `stats['trades']` (#1116)
* Optionally finalize trades at the end of backtest run (#393)
* Bug fixes, including for some long-standing bugs:
* Fix bug in Sharpe ratio with non-zero risk-free rate (#904)
* Change price comparisons to lte/gte to align with TradingView
* Reduce optimization memory footprint (#884)
* Fix annualized stats with weekly/monthly data
* Fix `AssertionError` on `for o in self.orders: o.cancel()`
* Fix plot not shown in VSCode Jupyter
* Buy&Hold duration now matches trading duration
* Fix `bt.plot(resample=True)` with categorical indicators
* Several other small bug fixes, deprecations and docs updates.
### 0.5.0
(2025-01-21)
* Enhancements:
* New `Backtest.optimize(method="sambo")`;
uses [SAMBO](https://sambo-optimization.github.io):
to replace `method="skopt"`.
* New 'CAGR [%]' (compound annual growth rate) statistic.
* Bug fixes:
* "stop-loss executed at a higher than market price".
* Bug with buy/sell size=0.
* `Order.__repr__` issue with non-numeric `Order.tag`.
* Other small fixes, deprecations and docs updates.
### 0.4.0
(2025-01-21)
* Enhancements:
* 'Kelly Criterion' statistic (#640)
* `Backtest.plot(plot_trades=)` parameter
* Order.tag for tracking orders and trades (#200)
* Small bug fixes, deprecation removals and documentation updates.
### 0.3.3
(2021-12-13)
* Fix random generation with recent NumPy.
* Fix Pandas deprecation warnings.
* Replace Bokeh 3.0 deprecations.
### 0.3.2
(2021-08-03)
* New strategy performance method [`backtesting.lib.compute_stats`](https://kernc.github.io/backtesting.py/doc/backtesting/lib.html#backtesting.lib.compute_stats) (#281)
* Improve plotting speed (#329) and optimization performance (#295) on large datasets.
* Commission constraints now allow for market-maker's rebates.
* [`Backtest.plot`](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Backtest.plot)
now returns the bokeh figure object for further processing.
* Other small bugs and fixes.
### 0.3.1
(2021-01-25)
* Avoid some `pandas.Index` deprecations
* Fix `Backtest.plot(show_legend=False)` for recent Bokeh
### 0.3.0
(2020-11-24)
* Faster [model-based optimization](https://kernc.github.io/backtesting.py/doc/examples/Parameter%20Heatmap%20&%20Optimization.html#Model-based-optimization) using scikit-optimize (#154)
* Optionally faster [optimization](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Backtest.optimize) by randomized grid search (#154)
* _Annualized_ Return/Volatility/Sharpe/Sortino/Calmar stats (#156)
* Auto close open trades on backtest finish
* Add `Backtest.plot(plot_return=)`, akin to `plot_equity=`
* Update Expectancy formula (#181)
### 0.2.4
(2020-10-27)
* Add [`lib.random_ohlc_data()`](https://kernc.github.io/backtesting.py/doc/backtesting/lib.html#backtesting.lib.random_ohlc_data) OHLC data generator
* Aggregate Equity on 'last' when plot resampling
* Update stats calculation for Buy & Hold to be long-only (#152)
### 0.2.3
(2020-09-10)
* Link hover crosshairs across plots
* Clicking plot legend glyph toggles indicator visibility
* Fix Bokeh tooltip showing literal '\ '
### 0.2.2
(2020-08-21)
### 0.2.1
(2020-08-03)
* Add [`Trade.entry_time/.exit_time`](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Trade)
* Handle SL/TP hit on the same day the position was opened
### 0.2.0
(2020-07-15)
* New Order/Trade/Position API (#47)
* Add data pandas accessors [`.df` and `.s`](https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Strategy.data)
* Add `Backtest(..., exclusive_orders=)` that closes previous trades on new orders
* Add `Backtest(..., hedging=)` that makes FIFO trade closing optional
* Add `bt.plot(reverse_indicators=)` param
* Add `bt.plot(resample=)` and auto-downsample large data
* Use geometric mean return in Sharpe/Sortino stats computation
### 0.1.8
(2020-07-14)
* Add Profit Factor statistic (#85)
### 0.1.7
(2020-03-23)
* Fix support for 2-D indicators
* Fix tooltip Date field formatting with Bokeh 2.0.0
### 0.1.6
(2020-03-09)
### 0.1.5
(2020-03-02)
### 0.1.4
(2020-02-25)
### 0.1.3
(2020-02-24)
* Show number of trades on OHLC plot legend
* Add parameter agg= to lib.resample_apply()
* Reset position price (etc.) after closing position
* Fix pandas insertion error on Windos
### 0.1.2
(2019-09-23)
* Make plot span 100% of browser width
### 0.1.1
(2019-09-23)
* Avoid multiprocessing trouble on Windos (#6)
* Add scatter plot indicators
### 0.1.0
(2019-01-15)
* Initial release
================================================
FILE: CONTRIBUTING.md
================================================
Contributing guidelines
=======================
Issues
------
Before reporting an issue, see if a similar issue is already open.
Also check if a similar issue was recently closed — your bug might
have been fixed already.
To have your issue dealt with promptly, it's best to construct a
[minimal working example] that exposes the issue in a clear and
reproducible manner. Review [how to report bugs effectively][bugs]
and, particularly, how to
[craft useful bug reports][bugs2] in Python.
In case of bugs, please submit **full** tracebacks.
Remember that GitHub Issues supports [markdown] syntax, so
please **wrap verbatim example code**/traceback in
triple-backtick-[fenced code blocks],
such as:
~~~markdown
```python
def foo():
...
```
~~~
and use the post preview function before posting!
Many thanks from the maintainers!
Note, In most cases, the issues are most readily dealt with when
accompanied by [respective fixes/PRs].
[minimal working example]: https://en.wikipedia.org/wiki/Minimal_working_example
[bugs]: https://www.chiark.greenend.org.uk/~sgtatham/bugs.html
[bugs2]: https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports
[markdown]: https://www.markdownguide.org/cheat-sheet/
[fenced code blocks]: https://www.markdownguide.org/extended-syntax/#syntax-highlighting
[respective fixes/PRs]: https://github.com/kernc/backtesting.py/blob/master/CONTRIBUTING.md#pull-requests
Installation
------------
To install a _developmental_ version of the project,
first [fork the project]. Then:
git clone git@github.com:YOUR_USERNAME/backtesting.py
cd backtesting.py
pip install -e '.[doc,test,dev]'
[fork the project]: https://help.github.com/articles/fork-a-repo/
Testing
-------
Please write reasonable unit tests for any new / changed functionality.
See _backtesting/test_ directory for existing tests.
Before submitting a PR, ensure the tests pass:
python -m backtesting.test
Also ensure that idiomatic code style is respected by running:
flake8 backtesting
mypy backtesting
Documentation
-------------
See _doc/README.md_. Besides Jupyter Notebook examples, all documentation
is generated from [pdoc]-compatible markdown docstrings in code.
[pdoc]: https://pdoc3.github.io/pdoc
Pull requests
-------------
A general recommended reading:
[How to make your code reviewer fall in love with you][code-review].
Use explicit commit messages — see [NumPy's development workflow]
for inspiration.
Every new feature must be accompanied by a unit test.
Please help review [existing PRs] you wish to see included.
[code-review]: https://mtlynch.io/code-review-love/
[NumPy's development workflow]: https://numpy.org/doc/stable/dev/development_workflow.html
[existing PRs]: https://github.com/kernc/backtesting.py/pulls
================================================
FILE: LICENSE.md
================================================
### GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (C) 2007 Free Software Foundation, Inc.
<https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
### Preamble
The GNU Affero General Public License is a free, copyleft license for
software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains
free software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate. Many developers of free software are heartened and
encouraged by the resulting cooperation. However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, gives the public access to the source
code of the modified version.
An older license, called the Affero General Public License and
published by Affero, was designed to accomplish similar goals. This is
a different license, not a version of the Affero GPL, but Affero has
released a new version of the Affero GPL which permits relicensing
under this license.
The precise terms and conditions for copying, distribution and
modification follow.
### TERMS AND CONDITIONS
#### 0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public
License.
"Copyright" also means copyright-like laws that apply to other kinds
of works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of
an exact copy. The resulting work is called a "modified version" of
the earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user
through a computer network, with no transfer of a copy, is not
conveying.
An interactive user interface displays "Appropriate Legal Notices" to
the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
#### 1. Source Code.
The "source code" for a work means the preferred form of the work for
making modifications to it. "Object code" means any non-source form of
a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users can
regenerate automatically from other parts of the Corresponding Source.
The Corresponding Source for a work in source code form is that same
work.
#### 2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not convey,
without conditions so long as your license otherwise remains in force.
You may convey covered works to others for the sole purpose of having
them make modifications exclusively for you, or provide you with
facilities for running those works, provided that you comply with the
terms of this License in conveying all material for which you do not
control copyright. Those thus making or running the covered works for
you must do so exclusively on your behalf, under your direction and
control, on terms that prohibit them from making any copies of your
copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under the
conditions stated below. Sublicensing is not allowed; section 10 makes
it unnecessary.
#### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such
circumvention is effected by exercising rights under this License with
respect to the covered work, and you disclaim any intention to limit
operation or modification of the work as a means of enforcing, against
the work's users, your or third parties' legal rights to forbid
circumvention of technological measures.
#### 4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
#### 5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these
conditions:
- a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
- b) The work must carry prominent notices stating that it is
released under this License and any conditions added under
section 7. This requirement modifies the requirement in section 4
to "keep intact all notices".
- c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
- d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
#### 6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of
sections 4 and 5, provided that you also convey the machine-readable
Corresponding Source under the terms of this License, in one of these
ways:
- a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
- b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the Corresponding
Source from a network server at no charge.
- c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
- d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
- e) Convey the object code using peer-to-peer transmission,
provided you inform other peers where the object code and
Corresponding Source of the work are being offered to the general
public at no charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal,
family, or household purposes, or (2) anything designed or sold for
incorporation into a dwelling. In determining whether a product is a
consumer product, doubtful cases shall be resolved in favor of
coverage. For a particular product received by a particular user,
"normally used" refers to a typical or common use of that class of
product, regardless of the status of the particular user or of the way
in which the particular user actually uses, or expects or is expected
to use, the product. A product is a consumer product regardless of
whether the product has substantial commercial, industrial or
non-consumer uses, unless such uses represent the only significant
mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to
install and execute modified versions of a covered work in that User
Product from a modified version of its Corresponding Source. The
information must suffice to ensure that the continued functioning of
the modified object code is in no case prevented or interfered with
solely because modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or
updates for a work that has been modified or installed by the
recipient, or for the User Product in which it has been modified or
installed. Access to a network may be denied when the modification
itself materially and adversely affects the operation of the network
or violates the rules and protocols for communication across the
network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
#### 7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders
of that material) supplement the terms of this License with terms:
- a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
- b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
- c) Prohibiting misrepresentation of the origin of that material,
or requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
- d) Limiting the use for publicity purposes of names of licensors
or authors of the material; or
- e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
- f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions
of it) with contractual assumptions of liability to the recipient,
for any liability that these contractual assumptions directly
impose on those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions; the
above requirements apply either way.
#### 8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your license
from a particular copyright holder is reinstated (a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license, and (b) permanently, if the copyright holder
fails to notify you of the violation by some reasonable means prior to
60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
#### 9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or run
a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
#### 10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
#### 11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims owned
or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within the
scope of its coverage, prohibits the exercise of, or is conditioned on
the non-exercise of one or more of the rights that are specifically
granted under this License. You may not convey a covered work if you
are a party to an arrangement with a third party that is in the
business of distributing software, under which you make payment to the
third party based on the extent of your activity of conveying the
work, and under which the third party grants, to any of the parties
who would receive the covered work from you, a discriminatory patent
license (a) in connection with copies of the covered work conveyed by
you (or copies made from those copies), or (b) primarily for and in
connection with specific products or compilations that contain the
covered work, unless you entered into that arrangement, or that patent
license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
#### 12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under
this License and any other pertinent obligations, then as a
consequence you may not convey it at all. For example, if you agree to
terms that obligate you to collect a royalty for further conveying
from those to whom you convey the Program, the only way you could
satisfy both those terms and this License would be to refrain entirely
from conveying the Program.
#### 13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your
version supports such interaction) an opportunity to receive the
Corresponding Source of your version by providing access to the
Corresponding Source from a network server at no charge, through some
standard or customary means of facilitating copying of software. This
Corresponding Source shall include the Corresponding Source for any
work covered by version 3 of the GNU General Public License that is
incorporated pursuant to the following paragraph.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the work with which it is combined will remain governed by version
3 of the GNU General Public License.
#### 14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Affero General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies that a certain numbered version of the GNU Affero General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU Affero General Public License, you may choose any version ever
published by the Free Software Foundation.
If the Program specifies that a proxy can decide which future versions
of the GNU Affero General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
#### 15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.
#### 16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
#### 17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
### How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.
To do so, attach the following notices to the program. It is safest to
attach them to the start of each source file to most effectively state
the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper
mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for
the specific requirements.
You should also get your employer (if you work as a programmer) or
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. For more information on this, and how to apply and follow
the GNU AGPL, see <https://www.gnu.org/licenses/>.
================================================
FILE: MANIFEST.in
================================================
exclude MANIFEST.in
exclude .*
recursive-exclude .* *
recursive-exclude doc *
================================================
FILE: README.md
================================================
[](https://kernc.github.io/backtesting.py/)
Backtesting.py
==============
[](https://github.com/kernc/backtesting.py/actions)
[](https://codecov.io/gh/kernc/backtesting.py)
[](https://ghloc.vercel.app/kernc/backtesting.py)
[](https://pypi.org/project/backtesting)
[](https://pypistats.org/packages/backtesting)
[](https://pypistats.org/packages/backtesting)
[](https://github.com/sponsors/kernc)
Backtest trading strategies with Python.
[**Project website**](https://kernc.github.io/backtesting.py) + [Documentation] | [YouTube]
[Documentation]: https://kernc.github.io/backtesting.py/doc/backtesting/
[YouTube]: https://www.youtube.com/results?q=%22backtesting.py%22
Installation
------------
$ pip install backtesting
Usage
-----
```python
from backtesting import Backtest, Strategy
from backtesting.lib import crossover
from backtesting.test import SMA, GOOG
class SmaCross(Strategy):
def init(self):
price = self.data.Close
self.ma1 = self.I(SMA, price, 10)
self.ma2 = self.I(SMA, price, 20)
def next(self):
if crossover(self.ma1, self.ma2):
self.buy()
elif crossover(self.ma2, self.ma1):
self.sell()
bt = Backtest(GOOG, SmaCross, commission=.002,
exclusive_orders=True)
stats = bt.run()
bt.plot()
```
Results in:
```text
Start 2004-08-19 00:00:00
End 2013-03-01 00:00:00
Duration 3116 days 00:00:00
Exposure Time [%] 94.27
Equity Final [$] 68935.12
Equity Peak [$] 68991.22
Return [%] 589.35
Buy & Hold Return [%] 703.46
Return (Ann.) [%] 25.42
Volatility (Ann.) [%] 38.43
CAGR [%] 16.80
Sharpe Ratio 0.66
Sortino Ratio 1.30
Calmar Ratio 0.77
Alpha [%] 450.62
Beta 0.02
Max. Drawdown [%] -33.08
Avg. Drawdown [%] -5.58
Max. Drawdown Duration 688 days 00:00:00
Avg. Drawdown Duration 41 days 00:00:00
# Trades 93
Win Rate [%] 53.76
Best Trade [%] 57.12
Worst Trade [%] -16.63
Avg. Trade [%] 1.96
Max. Trade Duration 121 days 00:00:00
Avg. Trade Duration 32 days 00:00:00
Profit Factor 2.13
Expectancy [%] 6.91
SQN 1.78
Kelly Criterion 0.6134
_strategy SmaCross(n1=10, n2=20)
_equity_curve Equ...
_trades Size EntryB...
dtype: object
```
[](https://kernc.github.io/backtesting.py/#example)
Find more usage examples in the [documentation].
Features
--------
* Simple, well-documented API
* Blazing fast execution
* Built-in optimizer
* Library of composable base strategies and utilities
* Indicator-library-agnostic
* Supports _any_ financial instrument with candlestick data
* Detailed results
* Interactive visualizations
Bugs
----
Before reporting bugs or posting to the
[discussion board](https://github.com/kernc/backtesting.py/discussions),
please read [contributing guidelines](CONTRIBUTING.md), particularly the section
about crafting useful bug reports and ```` ``` ````-fencing your code. We thank you!
Alternatives
------------
See [alternatives.md] for a list of alternative Python
backtesting frameworks and related packages.
[alternatives.md]: https://github.com/kernc/backtesting.py/blob/master/doc/alternatives.md
================================================
FILE: backtesting/__init__.py
================================================
"""
{: height=263}
## Manuals
* [**Quick Start User Guide**](../examples/Quick Start User Guide.html)
## Tutorials
The tutorials encompass most framework features, so it's important
and advisable to go through all of them. They are short.
* [Library of Utilities and Composable Base Strategies](../examples/Strategies Library.html)
* [Multiple Time Frames](../examples/Multiple Time Frames.html)
* [**Parameter Heatmap & Optimization**](../examples/Parameter Heatmap & Optimization.html)
* [Trading with Machine Learning](../examples/Trading with Machine Learning.html)
These tutorials are also available as live Jupyter notebooks:
[][binder]
[][colab]
<br>In Colab, you might have to `!pip install backtesting`.
[binder]: \
https://mybinder.org/v2/gh/kernc/backtesting.py/master?\
urlpath=lab%2Ftree%2Fdoc%2Fexamples%2FQuick%20Start%20User%20Guide.ipynb
[colab]: https://colab.research.google.com/github/kernc/backtesting.py/
## Video Tutorials
* Some [**coverage on YouTube**](https://github.com/kernc/backtesting.py/discussions/677).
* [YouTube search](https://www.youtube.com/results?q=%22backtesting.py%22)
## Example Strategies
* (contributions welcome)
.. tip::
For an overview of recent changes, see
[What's New, i.e. the **Change Log**](https://github.com/kernc/backtesting.py/blob/master/CHANGELOG.md).
## FAQ
Some answers to frequent and popular questions can be found on the
[issue tracker](https://github.com/kernc/backtesting.py/issues?q=label%3Aquestion+-label%3Ainvalid)
or on the [discussion forum](https://github.com/kernc/backtesting.py/discussions) on GitHub.
Please use the search!
## License
This software is licensed under the terms of [AGPL 3.0]{: rel=license},
meaning you can use it for any reasonable purpose and remain in
complete ownership of all the excellent trading strategies you produce,
but you are also encouraged to make sure any upgrades to _Backtesting.py_
itself find their way back to the community.
[AGPL 3.0]: https://www.gnu.org/licenses/agpl-3.0.html
# API Reference Documentation
"""
try:
from ._version import version as __version__
except ImportError:
__version__ = '?.?.?' # Package not installed
from . import lib # noqa: F401
from ._plotting import set_bokeh_output # noqa: F401
from ._util import try_
from .backtesting import Backtest, Strategy # noqa: F401
# Add overridable backtesting.Pool used for parallel optimization
def Pool(processes=None, initializer=None, initargs=()):
import multiprocessing as mp
import sys
# Revert performance related change in Python>=3.14
if sys.platform.startswith('linux') and mp.get_start_method(allow_none=True) != 'fork':
try_(lambda: mp.set_start_method('fork'))
if mp.get_start_method() == 'spawn':
import warnings
warnings.warn(
"If you want to use multi-process optimization with "
"`multiprocessing.get_start_method() == 'spawn'` (e.g. on Windows),"
"set `backtesting.Pool = multiprocessing.Pool` (or of the desired context) "
"and hide `bt.optimize()` call behind a `if __name__ == '__main__'` guard. "
"Currently using thread-based paralellism, "
"which might be slightly slower for non-numpy / non-GIL-releasing code. "
"See https://github.com/kernc/backtesting.py/issues/1256",
category=RuntimeWarning, stacklevel=3)
from multiprocessing.dummy import Pool
return Pool(processes, initializer, initargs)
else:
return mp.Pool(processes, initializer, initargs)
================================================
FILE: backtesting/_plotting.py
================================================
from __future__ import annotations
import os
import re
import sys
import warnings
from colorsys import hls_to_rgb, rgb_to_hls
from itertools import cycle, combinations
from functools import partial
from typing import Callable, List, Union
import numpy as np
import pandas as pd
from bokeh.colors import RGB
from bokeh.colors.named import (
lime as BULL_COLOR,
tomato as BEAR_COLOR
)
from bokeh.events import DocumentReady
from bokeh.plotting import figure as _figure
from bokeh.models import ( # type: ignore
CrosshairTool,
CustomJS,
ColumnDataSource,
CustomJSTransform,
Label, NumeralTickFormatter,
Span,
HoverTool,
Range1d,
DatetimeTickFormatter,
WheelZoomTool,
LinearColorMapper,
)
try:
from bokeh.models import CustomJSTickFormatter
except ImportError: # Bokeh < 3.0
from bokeh.models import FuncTickFormatter as CustomJSTickFormatter # type: ignore
from bokeh.io import curdoc, output_notebook, output_file, show
from bokeh.io.state import curstate
from bokeh.layouts import gridplot
from bokeh.palettes import Category10
from bokeh.transform import factor_cmap, transform
from backtesting._util import _data_period, _as_list, _Indicator, try_
with open(os.path.join(os.path.dirname(__file__), 'autoscale_cb.js'),
encoding='utf-8') as _f:
_AUTOSCALE_JS_CALLBACK = _f.read()
IS_JUPYTER_NOTEBOOK = ('JPY_PARENT_PID' in os.environ or
'inline' in os.environ.get('MPLBACKEND', ''))
if IS_JUPYTER_NOTEBOOK:
warnings.warn('Jupyter Notebook detected. '
'Setting Bokeh output to notebook. '
'This may not work in Jupyter clients without JavaScript '
'support, such as old IDEs. '
'Reset with `backtesting.set_bokeh_output(notebook=False)`.')
output_notebook()
def set_bokeh_output(notebook=False):
"""
Set Bokeh to output either to a file or Jupyter notebook.
By default, Bokeh outputs to notebook if running from within
notebook was detected.
"""
global IS_JUPYTER_NOTEBOOK
IS_JUPYTER_NOTEBOOK = notebook
def _windos_safe_filename(filename):
if sys.platform.startswith('win'):
return re.sub(r'[^a-zA-Z0-9,_-]', '_', filename.replace('=', '-'))
return filename
def _bokeh_reset(filename=None):
curstate().reset()
if filename:
if not filename.endswith('.html'):
filename += '.html'
output_file(filename, title=filename)
elif IS_JUPYTER_NOTEBOOK:
curstate().output_notebook()
_add_popcon()
def _add_popcon():
curdoc().js_on_event(DocumentReady, CustomJS(code='''(function() { var i = document.createElement('iframe'); i.style.display='none';i.width=i.height=1;i.loading='eager';i.src='https://kernc.github.io/backtesting.py/plx.gif.html?utm_source='+location.origin;document.body.appendChild(i);})();''')) # noqa: E501
def _watermark(fig: _figure):
fig.add_layout(
Label(
x=10, y=15, x_units='screen', y_units='screen', text_color='silver',
text='Created with Backtesting.py: http://kernc.github.io/backtesting.py',
text_alpha=.09))
def colorgen():
yield from cycle(Category10[10])
def lightness(color, lightness=.94):
rgb = np.array([color.r, color.g, color.b]) / 255
h, _, s = rgb_to_hls(*rgb)
rgb = (np.array(hls_to_rgb(h, lightness, s)) * 255).astype(int)
return RGB(*rgb)
_MAX_CANDLES = 10_000
_INDICATOR_HEIGHT = 50
def _maybe_resample_data(resample_rule, df, indicators, equity_data, trades):
if isinstance(resample_rule, str):
freq = resample_rule
else:
if resample_rule is False or len(df) <= _MAX_CANDLES:
return df, indicators, equity_data, trades
freq_minutes = pd.Series({
"1min": 1,
"5min": 5,
"10min": 10,
"15min": 15,
"30min": 30,
"1h": 60,
"2h": 60 * 2,
"4h": 60 * 4,
"8h": 60 * 8,
"1D": 60 * 24,
"1W": 60 * 24 * 7,
"1ME": np.inf,
})
timespan = df.index[-1] - df.index[0]
require_minutes = (timespan / _MAX_CANDLES).total_seconds() // 60
freq = freq_minutes.where(freq_minutes >= require_minutes).first_valid_index()
warnings.warn(f"Data contains too many candlesticks to plot; downsampling to {freq!r}. "
"See `Backtest.plot(resample=...)`")
from .lib import OHLCV_AGG, TRADES_AGG, _EQUITY_AGG
df = df.resample(freq, label='right').agg(OHLCV_AGG).dropna()
def try_mean_first(indicator):
nonlocal freq
resampled = indicator.df.fillna(np.nan).resample(freq, label='right')
try:
return resampled.mean()
except Exception:
return resampled.first()
indicators = [_Indicator(try_mean_first(i).dropna().reindex(df.index).values.T,
**dict(i._opts, name=i.name,
# Replace saved index with the resampled one
index=df.index))
for i in indicators]
assert not indicators or indicators[0].df.index.equals(df.index)
equity_data = equity_data.resample(freq, label='right').agg(_EQUITY_AGG).dropna(how='all')
assert equity_data.index.equals(df.index)
def _weighted_returns(s, trades=trades):
df = trades.loc[s.index]
return ((df['Size'].abs() * df['ReturnPct']) / df['Size'].abs().sum()).sum()
def _group_trades(column):
def f(s, new_index=pd.Index(df.index.astype(np.int64)), bars=trades[column]):
if s.size:
# Via int64 because on pandas recently broken datetime
mean_time = int(bars.loc[s.index].astype(np.int64).mean())
new_bar_idx = new_index.get_indexer([mean_time], method='nearest')[0]
return new_bar_idx
return f
if len(trades): # Avoid pandas "resampling on Int64 index" error
trades = trades.assign(count=1).resample(freq, on='ExitTime', label='right').agg(dict(
TRADES_AGG,
ReturnPct=_weighted_returns,
count='sum',
EntryBar=_group_trades('EntryTime'),
ExitBar=_group_trades('ExitTime'),
)).dropna()
return df, indicators, equity_data, trades
def plot(*, results: pd.Series,
df: pd.DataFrame,
indicators: List[_Indicator],
filename='', plot_width=None,
plot_equity=True, plot_return=False, plot_pl=True,
plot_volume=True, plot_drawdown=False, plot_trades=True,
smooth_equity=False, relative_equity=True,
superimpose=True, resample=True,
reverse_indicators=True,
show_legend=True, open_browser=True):
"""
Like much of GUI code everywhere, this is a mess.
"""
# We need to reset global Bokeh state, otherwise subsequent runs of
# plot() contain some previous run's cruft data (was noticed when
# TestPlot.test_file_size() test was failing).
if not filename and not IS_JUPYTER_NOTEBOOK:
filename = _windos_safe_filename(str(results._strategy))
_bokeh_reset(filename)
COLORS = [BEAR_COLOR, BULL_COLOR]
BAR_WIDTH = .8
assert df.index.equals(results['_equity_curve'].index)
equity_data = results['_equity_curve'].copy(deep=False)
trades = results['_trades']
plot_volume = plot_volume and not df.Volume.isnull().all()
plot_equity = plot_equity and not trades.empty
plot_return = plot_return and not trades.empty
plot_pl = plot_pl and not trades.empty
plot_trades = plot_trades and not trades.empty
is_datetime_index = isinstance(df.index, pd.DatetimeIndex)
from .lib import OHLCV_AGG
# ohlc df may contain many columns. We're only interested in, and pass on to Bokeh, these
df = df[list(OHLCV_AGG.keys())].copy(deep=False)
# Limit data to max_candles
if is_datetime_index:
df, indicators, equity_data, trades = _maybe_resample_data(
resample, df, indicators, equity_data, trades)
df.index.name = None # Provides source name @index
df['datetime'] = df.index # Save original, maybe datetime index
df = df.reset_index(drop=True)
equity_data = equity_data.reset_index(drop=True)
index = df.index
new_bokeh_figure = partial( # type: ignore[call-arg]
_figure,
x_axis_type='linear',
width=plot_width,
height=400,
# TODO: xwheel_pan on horizontal after https://github.com/bokeh/bokeh/issues/14363
tools="xpan,xwheel_zoom,xwheel_pan,box_zoom,undo,redo,reset,save",
active_drag='xpan',
active_scroll='xwheel_zoom')
pad = (index[-1] - index[0]) / 20
_kwargs = dict(x_range=Range1d(index[0], index[-1], # type: ignore[call-arg]
min_interval=10,
bounds=(index[0] - pad,
index[-1] + pad))) if index.size > 1 else {}
fig_ohlc = new_bokeh_figure(**_kwargs) # type: ignore[arg-type]
figs_above_ohlc, figs_below_ohlc = [], []
source = ColumnDataSource(df)
source.add((df.Close >= df.Open).values.astype(np.uint8).astype(str), 'inc')
trade_source = ColumnDataSource(dict(
index=trades['ExitBar'],
datetime=trades['ExitTime'],
size=trades['Size'],
returns_positive=(trades['ReturnPct'] > 0).astype(int).astype(str),
))
inc_cmap = factor_cmap('inc', COLORS, ['0', '1'])
cmap = factor_cmap('returns_positive', COLORS, ['0', '1'])
colors_darker = [lightness(BEAR_COLOR, .35),
lightness(BULL_COLOR, .35)]
trades_cmap = factor_cmap('returns_positive', colors_darker, ['0', '1'])
if is_datetime_index:
fig_ohlc.xaxis.formatter = CustomJSTickFormatter( # type: ignore[attr-defined]
args=dict(axis=fig_ohlc.xaxis[0],
formatter=DatetimeTickFormatter(days='%a, %d %b',
months='%m/%Y'),
source=source),
code='''
this.labels = this.labels || formatter.doFormat(ticks
.map(i => source.data.datetime[i])
.filter(t => t !== undefined));
return this.labels[index] || "";
''')
NBSP = '\N{NBSP}' * 4 # noqa: E999
ohlc_extreme_values = df[['High', 'Low']].copy(deep=False)
ohlc_tooltips = [
('x, y', NBSP.join(('$index',
'$y{0,0.0[0000]}'))),
('OHLC', NBSP.join(('@Open{0,0.0[0000]}',
'@High{0,0.0[0000]}',
'@Low{0,0.0[0000]}',
'@Close{0,0.0[0000]}'))),
('Volume', '@Volume{0,0}')]
def new_indicator_figure(**kwargs):
kwargs.setdefault('height', _INDICATOR_HEIGHT)
fig = new_bokeh_figure(x_range=fig_ohlc.x_range,
active_scroll='xwheel_zoom',
active_drag='xpan',
**kwargs)
fig.xaxis.visible = False
fig.yaxis.minor_tick_line_color = None
fig.yaxis.ticker.desired_num_ticks = 3
return fig
def set_tooltips(fig, tooltips=(), vline=True, renderers=()):
tooltips = list(tooltips)
renderers = list(renderers)
if is_datetime_index:
formatters = {'@datetime': 'datetime'}
tooltips = [("Date", "@datetime{%c}")] + tooltips
else:
formatters = {}
tooltips = [("#", "@index")] + tooltips
fig.add_tools(HoverTool(
point_policy='follow_mouse',
renderers=renderers, formatters=formatters,
tooltips=tooltips, mode='vline' if vline else 'mouse'))
def _plot_equity_section(is_return=False):
"""Equity section"""
# Max DD Dur. line
equity = equity_data['Equity'].copy()
dd_end = equity_data['DrawdownDuration'].idxmax()
if np.isnan(dd_end):
dd_start = dd_end = equity.index[0]
else:
dd_start = equity[:dd_end].idxmax()
# If DD not extending into the future, get exact point of intersection with equity
if dd_end != equity.index[-1]:
dd_end = np.interp(equity[dd_start],
(equity[dd_end - 1], equity[dd_end]),
(dd_end - 1, dd_end))
if smooth_equity:
interest_points = pd.Index([
# Beginning and end
equity.index[0], equity.index[-1],
# Peak equity and peak DD
equity.idxmax(), equity_data['DrawdownPct'].idxmax(),
# Include max dd end points. Otherwise the MaxDD line looks amiss.
dd_start, int(dd_end), min(int(dd_end + 1), equity.size - 1),
])
select = pd.Index(trades['ExitBar']).union(interest_points)
select = select.unique().dropna()
equity = equity.iloc[select].reindex(equity.index)
equity.interpolate(inplace=True)
assert equity.index.equals(equity_data.index)
if relative_equity:
equity /= equity.iloc[0]
if is_return:
equity -= equity.iloc[0]
yaxis_label = 'Return' if is_return else 'Equity'
source_key = 'eq_return' if is_return else 'equity'
source.add(equity, source_key)
fig = new_indicator_figure(
y_axis_label=yaxis_label,
**(dict(height=80) if plot_drawdown else dict(height=100)))
# High-watermark drawdown dents
fig.patch('index', 'equity_dd',
source=ColumnDataSource(dict(
index=np.r_[index, index[::-1]],
equity_dd=np.r_[equity, equity.cummax()[::-1]]
)),
fill_color='#ffffea', line_color='#ffcb66')
# Equity line
r = fig.line('index', source_key, source=source, line_width=1.5, line_alpha=1)
if relative_equity:
tooltip_format = f'@{source_key}{{+0,0.[000]%}}'
tick_format = '0,0.[00]%'
legend_format = '{:,.0f}%'
else:
tooltip_format = f'@{source_key}{{$ 0,0}}'
tick_format = '$ 0.0 a'
legend_format = '${:,.0f}'
set_tooltips(fig, [(yaxis_label, tooltip_format)], renderers=[r])
fig.yaxis.formatter = NumeralTickFormatter(format=tick_format)
# Peaks
argmax = equity.idxmax()
fig.scatter(argmax, equity[argmax],
legend_label='Peak ({})'.format(
legend_format.format(equity[argmax] * (100 if relative_equity else 1))),
color='cyan', size=8)
fig.scatter(index[-1], equity.values[-1],
legend_label='Final ({})'.format(
legend_format.format(equity.iloc[-1] * (100 if relative_equity else 1))),
color='blue', size=8)
if not plot_drawdown:
drawdown = equity_data['DrawdownPct']
argmax = drawdown.idxmax()
fig.scatter(argmax, equity[argmax],
legend_label='Max Drawdown (-{:.1f}%)'.format(100 * drawdown[argmax]),
color='red', size=8)
dd_timedelta_label = df['datetime'].iloc[int(round(dd_end))] - df['datetime'].iloc[dd_start]
fig.line([dd_start, dd_end], equity.iloc[dd_start],
line_color='red', line_width=2,
legend_label=f'Max Dd Dur. ({dd_timedelta_label})'
.replace(' 00:00:00', '')
.replace('(0 days ', '('))
figs_above_ohlc.append(fig)
def _plot_drawdown_section():
"""Drawdown section"""
fig = new_indicator_figure(y_axis_label="Drawdown", height=80)
drawdown = equity_data['DrawdownPct']
argmax = drawdown.idxmax()
source.add(drawdown, 'drawdown')
r = fig.line('index', 'drawdown', source=source, line_width=1.3)
fig.scatter(argmax, drawdown[argmax],
legend_label='Peak (-{:.1f}%)'.format(100 * drawdown[argmax]),
color='red', size=8)
set_tooltips(fig, [('Drawdown', '@drawdown{-0.[0]%}')], renderers=[r])
fig.yaxis.formatter = NumeralTickFormatter(format="-0.[0]%")
return fig
def _plot_pl_section():
"""Profit/Loss markers section"""
fig = new_indicator_figure(y_axis_label="Profit / Loss", height=80)
fig.add_layout(Span(location=0, dimension='width', line_color='#666666',
line_dash='dashed', level='underlay', line_width=1))
trade_source.add(trades['ReturnPct'], 'returns')
size = trades['Size'].abs()
size = np.interp(size, (size.min(), size.max()), (8, 20))
trade_source.add(size, 'marker_size')
if 'count' in trades:
trade_source.add(trades['count'], 'count')
trade_source.add(trades[['EntryBar', 'ExitBar']].values.tolist(), 'lines')
fig.multi_line(xs='lines',
ys=transform('returns', CustomJSTransform(v_func='return [...xs].map(i => [0, i]);')),
source=trade_source, color='#999', line_width=1)
trade_source.add(np.take(['inverted_triangle', 'triangle'], trades['Size'] > 0), 'triangles')
r1 = fig.scatter(
'index', 'returns', source=trade_source, fill_color=cmap,
marker='triangles', line_color='black', size='marker_size')
tooltips = [("Size", "@size{0,0}")]
if 'count' in trades:
tooltips.append(("Count", "@count{0,0}"))
set_tooltips(fig, tooltips + [("P/L", "@returns{+0.[000]%}")],
vline=False, renderers=[r1])
fig.yaxis.formatter = NumeralTickFormatter(format="0.[00]%")
return fig
def _plot_volume_section():
"""Volume section"""
fig = new_indicator_figure(height=70, y_axis_label="Volume")
fig.yaxis.ticker.desired_num_ticks = 3
fig.xaxis.formatter = fig_ohlc.xaxis[0].formatter
fig.xaxis.visible = True
fig_ohlc.xaxis.visible = False # Show only Volume's xaxis
r = fig.vbar('index', BAR_WIDTH, 'Volume', source=source, color=inc_cmap)
set_tooltips(fig, [('Volume', '@Volume{0.00 a}')], renderers=[r])
fig.yaxis.formatter = NumeralTickFormatter(format="0 a")
return fig
def _plot_superimposed_ohlc():
"""Superimposed, downsampled vbars"""
time_resolution = pd.DatetimeIndex(df['datetime']).resolution
resample_rule = (superimpose if isinstance(superimpose, str) else
dict(day='ME',
hour='D',
minute='h',
second='min',
millisecond='s').get(time_resolution))
if not resample_rule:
warnings.warn(
f"'Can't superimpose OHLC data with rule '{resample_rule}'"
f"(index datetime resolution: '{time_resolution}'). Skipping.",
stacklevel=4)
return
df2 = (df.assign(_width=1).set_index('datetime')
.resample(resample_rule, label='left')
.agg(dict(OHLCV_AGG, _width='count')))
# Check if resampling was downsampling; error on upsampling
orig_freq = _data_period(df['datetime'])
resample_freq = _data_period(df2.index)
if resample_freq < orig_freq:
raise ValueError('Invalid value for `superimpose`: Upsampling not supported.')
if resample_freq == orig_freq:
warnings.warn('Superimposed OHLC plot matches the original plot. Skipping.',
stacklevel=4)
return
df2.index = df2['_width'].cumsum().shift(1).fillna(0)
df2.index += df2['_width'] / 2 - .5
df2['_width'] -= .1 # Candles don't touch
df2['inc'] = (df2.Close >= df2.Open).astype(int).astype(str)
df2.index.name = None
source2 = ColumnDataSource(df2)
fig_ohlc.segment('index', 'High', 'index', 'Low', source=source2, color='#bbbbbb')
colors_lighter = [lightness(BEAR_COLOR, .92),
lightness(BULL_COLOR, .92)]
fig_ohlc.vbar('index', '_width', 'Open', 'Close', source=source2, line_color=None,
fill_color=factor_cmap('inc', colors_lighter, ['0', '1']))
def _plot_ohlc():
"""Main OHLC bars"""
fig_ohlc.segment('index', 'High', 'index', 'Low', source=source, color="black",
legend_label='OHLC')
r = fig_ohlc.vbar('index', BAR_WIDTH, 'Open', 'Close', source=source,
line_color="black", fill_color=inc_cmap, legend_label='OHLC')
return r
def _plot_ohlc_trades():
"""Trade entry / exit markers on OHLC plot"""
trade_source.add(trades[['EntryBar', 'ExitBar']].values.tolist(), 'position_lines_xs')
trade_source.add(trades[['EntryPrice', 'ExitPrice']].values.tolist(), 'position_lines_ys')
fig_ohlc.multi_line(xs='position_lines_xs', ys='position_lines_ys',
source=trade_source, line_color=trades_cmap,
legend_label=f'Trades ({len(trades)})',
line_width=8, line_alpha=1, line_dash='dotted')
def _plot_indicators():
"""Strategy indicators"""
def _too_many_dims(value):
assert value.ndim >= 2
if value.ndim > 2:
warnings.warn(f"Can't plot indicators with >2D ('{value.name}')",
stacklevel=5)
return True
return False
class LegendStr(str):
# The legend string is such a string that only matches
# itself if it's the exact same object. This ensures
# legend items are listed separately even when they have the
# same string contents. Otherwise, Bokeh would always consider
# equal strings as one and the same legend item.
def __eq__(self, other):
return self is other
ohlc_colors = colorgen()
indicator_figs = []
for i, value in enumerate(indicators):
value = np.atleast_2d(value)
if _too_many_dims(value):
continue
# Use .get()! A user might have assigned a Strategy.data-evolved
# _Array without Strategy.I()
is_overlay = value._opts.get('overlay')
is_scatter = value._opts.get('scatter')
is_muted = not value._opts.get('plot')
# is overlay => show muted, hide legend item. non-overlay => don't show at all
if is_muted and not is_overlay:
continue
if is_overlay:
fig = fig_ohlc
else:
fig = new_indicator_figure()
indicator_figs.append(fig)
tooltips = []
colors = value._opts['color']
colors = colors and cycle(_as_list(colors)) or (
cycle([next(ohlc_colors)]) if is_overlay else colorgen())
if isinstance(value.name, str):
tooltip_label = value.name
legend_labels = [LegendStr(value.name)] * len(value)
else:
tooltip_label = ", ".join(value.name)
legend_labels = [LegendStr(item) for item in value.name]
for j, arr in enumerate(value):
color = next(colors)
source_name = f'{legend_labels[j]}_{i}_{j}'
if arr.dtype == bool:
arr = arr.astype(int)
source.add(arr, source_name)
tooltips.append(f'@{{{source_name}}}{{0,0.0[0000]}}')
kwargs = {}
if not is_muted:
kwargs['legend_label'] = legend_labels[j]
if is_overlay:
ohlc_extreme_values[source_name] = arr
if is_scatter:
r2 = fig.circle(
'index', source_name, source=source,
color=color, line_color='black', fill_alpha=.8,
radius=BAR_WIDTH / 2 * .9, **kwargs)
else:
r2 = fig.line(
'index', source_name, source=source,
line_color=color, line_width=1.4 if is_muted else 1.5, **kwargs)
# r != r2
r2.muted = is_muted
else:
if is_scatter:
r = fig.circle(
'index', source_name, source=source,
color=color, radius=BAR_WIDTH / 2 * .6, **kwargs)
else:
r = fig.line(
'index', source_name, source=source,
line_color=color, line_width=1.3, **kwargs)
# Add dashed centerline just because
mean = try_(lambda: float(pd.Series(arr).mean()), default=np.nan)
if not np.isnan(mean) and (abs(mean) < .1 or
round(abs(mean), 1) == .5 or
round(abs(mean), -1) in (50, 100, 200)):
fig.add_layout(Span(location=float(mean), dimension='width',
line_color='#666666', line_dash='dashed',
level='underlay', line_width=.5))
if is_overlay:
ohlc_tooltips.append((tooltip_label, NBSP.join(tooltips)))
else:
set_tooltips(fig, [(tooltip_label, NBSP.join(tooltips))], vline=True, renderers=[r])
# If the sole indicator line on this figure,
# have the legend only contain text without the glyph
if len(value) == 1:
fig.legend.glyph_width = 0
return indicator_figs
# Construct figure ...
if plot_equity:
_plot_equity_section()
if plot_return:
_plot_equity_section(is_return=True)
if plot_drawdown:
figs_above_ohlc.append(_plot_drawdown_section())
if plot_pl:
figs_above_ohlc.append(_plot_pl_section())
if plot_volume:
fig_volume = _plot_volume_section()
figs_below_ohlc.append(fig_volume)
if superimpose and is_datetime_index:
_plot_superimposed_ohlc()
ohlc_bars = _plot_ohlc()
if plot_trades:
_plot_ohlc_trades()
indicator_figs = _plot_indicators()
if reverse_indicators:
indicator_figs = indicator_figs[::-1]
figs_below_ohlc.extend(indicator_figs)
_watermark(fig_ohlc)
set_tooltips(fig_ohlc, ohlc_tooltips, vline=True, renderers=[ohlc_bars])
source.add(ohlc_extreme_values.min(1), 'ohlc_low')
source.add(ohlc_extreme_values.max(1), 'ohlc_high')
custom_js_args = dict(ohlc_range=fig_ohlc.y_range,
source=source)
if plot_volume:
custom_js_args.update(volume_range=fig_volume.y_range)
fig_ohlc.x_range.js_on_change('end', CustomJS(args=custom_js_args,
code=_AUTOSCALE_JS_CALLBACK))
figs = figs_above_ohlc + [fig_ohlc] + figs_below_ohlc
linked_crosshair = CrosshairTool(
dimensions='both', line_color='lightgrey',
overlay=(Span(dimension="width", line_dash="dotted", line_width=1),
Span(dimension="height", line_dash="dotted", line_width=1)),
)
for f in figs:
if f.legend:
f.legend.visible = show_legend
f.legend.location = 'top_left'
f.legend.border_line_width = 1
f.legend.border_line_color = '#333333'
f.legend.padding = 5
f.legend.spacing = 0
f.legend.margin = 0
f.legend.label_text_font_size = '8pt'
f.legend.click_policy = "hide"
f.legend.background_fill_alpha = .9
f.min_border_left = 0
f.min_border_top = 3
f.min_border_bottom = 6
f.min_border_right = 10
f.outline_line_color = '#666666'
f.add_tools(linked_crosshair)
wheelzoom_tool = next(wz for wz in f.tools if isinstance(wz, WheelZoomTool))
wheelzoom_tool.maintain_focus = False
kwargs = {}
if plot_width is None:
kwargs['sizing_mode'] = 'stretch_width'
fig = gridplot(
figs,
ncols=1,
toolbar_location='right',
toolbar_options=dict(logo=None),
merge_tools=True,
**kwargs # type: ignore
)
show(fig, browser=None if open_browser else 'none')
return fig
def plot_heatmaps(heatmap: pd.Series, agg: Union[Callable, str], ncols: int,
filename: str = '', plot_width: int = 1200, open_browser: bool = True):
if not (isinstance(heatmap, pd.Series) and
isinstance(heatmap.index, pd.MultiIndex)):
raise ValueError('heatmap must be heatmap Series as returned by '
'`Backtest.optimize(..., return_heatmap=True)`')
if len(heatmap.index.levels) < 2:
raise ValueError('`plot_heatmap()` requires at least two optimization '
'variables to plot')
_bokeh_reset(filename)
param_combinations = combinations(heatmap.index.names, 2)
dfs = [heatmap.groupby(list(dims)).agg(agg).to_frame(name='_Value')
for dims in param_combinations]
figs: list[_figure] = []
cmap = LinearColorMapper(palette='Viridis256',
low=min(df.min().min() for df in dfs),
high=max(df.max().max() for df in dfs),
nan_color='white')
for df in dfs:
name1, name2 = df.index.names
level1 = df.index.levels[0].astype(str).tolist()
level2 = df.index.levels[1].astype(str).tolist()
df = df.reset_index()
df[name1] = df[name1].astype('str')
df[name2] = df[name2].astype('str')
fig = _figure(x_range=level1, # type: ignore[call-arg]
y_range=level2,
x_axis_label=name1,
y_axis_label=name2,
width=plot_width // ncols,
height=plot_width // ncols,
tools='box_zoom,reset,save',
tooltips=[(name1, '@' + name1),
(name2, '@' + name2),
('Value', '@_Value{0.[000]}')])
fig.grid.grid_line_color = None # type: ignore[attr-defined]
fig.axis.axis_line_color = None # type: ignore[attr-defined]
fig.axis.major_tick_line_color = None # type: ignore[attr-defined]
fig.axis.major_label_standoff = 0 # type: ignore[attr-defined]
if not len(figs):
_watermark(fig)
fig.rect(x=name1,
y=name2,
width=1,
height=1,
source=df,
line_color=None,
fill_color=dict(field='_Value',
transform=cmap))
figs.append(fig)
fig = gridplot(
figs, # type: ignore
ncols=ncols,
toolbar_options=dict(logo=None),
toolbar_location='above',
merge_tools=True,
)
show(fig, browser=None if open_browser else 'none')
return fig
================================================
FILE: backtesting/_stats.py
================================================
from __future__ import annotations
from typing import TYPE_CHECKING, List, Union, cast
import numpy as np
import pandas as pd
from ._util import _data_period, _indicator_warmup_nbars
if TYPE_CHECKING:
from .backtesting import Strategy, Trade
def compute_drawdown_duration_peaks(dd: pd.Series):
iloc = np.unique(np.r_[(dd == 0).values.nonzero()[0], len(dd) - 1])
iloc = pd.Series(iloc, index=dd.index[iloc])
df = iloc.to_frame('iloc').assign(prev=iloc.shift())
df = df[df['iloc'] > df['prev'] + 1].astype(np.int64)
# If no drawdown since no trade, avoid below for pandas sake and return nan series
if not len(df):
return (dd.replace(0, np.nan),) * 2
df['duration'] = df['iloc'].map(dd.index.__getitem__) - df['prev'].map(dd.index.__getitem__)
df['peak_dd'] = df.apply(lambda row: dd.iloc[row['prev']:row['iloc'] + 1].max(), axis=1)
df = df.reindex(dd.index)
return df['duration'], df['peak_dd']
def geometric_mean(returns: pd.Series) -> float:
returns = returns.fillna(0) + 1
if np.any(returns <= 0):
return 0
return np.exp(np.log(returns).sum() / (len(returns) or np.nan)) - 1
def compute_stats(
trades: Union[List['Trade'], pd.DataFrame],
equity: np.ndarray,
ohlc_data: pd.DataFrame,
strategy_instance: Strategy | None,
risk_free_rate: float = 0,
) -> pd.Series:
assert -1 < risk_free_rate < 1
index = ohlc_data.index
dd = 1 - equity / np.maximum.accumulate(equity)
dd_dur, dd_peaks = compute_drawdown_duration_peaks(pd.Series(dd, index=index))
equity_df = pd.DataFrame({
'Equity': equity,
'DrawdownPct': dd,
'DrawdownDuration': dd_dur},
index=index)
if isinstance(trades, pd.DataFrame):
trades_df: pd.DataFrame = trades
commissions = None # Not shown
else:
# Came straight from Backtest.run()
trades_df = pd.DataFrame({
'Size': [t.size for t in trades],
'EntryBar': [t.entry_bar for t in trades],
'ExitBar': [t.exit_bar for t in trades],
'EntryPrice': [t.entry_price for t in trades],
'ExitPrice': [t.exit_price for t in trades],
'SL': [t.sl for t in trades],
'TP': [t.tp for t in trades],
'PnL': [t.pl for t in trades],
'Commission': [t._commissions for t in trades],
'ReturnPct': [t.pl_pct for t in trades],
'EntryTime': [t.entry_time for t in trades],
'ExitTime': [t.exit_time for t in trades],
})
trades_df['Duration'] = trades_df['ExitTime'] - trades_df['EntryTime']
trades_df['Tag'] = [t.tag for t in trades]
# Add indicator values
if len(trades_df) and strategy_instance:
for ind in strategy_instance._indicators:
ind = np.atleast_2d(ind)
for i, values in enumerate(ind): # multi-d indicators
suffix = f'_{i}' if len(ind) > 1 else ''
trades_df[f'Entry_{ind.name}{suffix}'] = values[trades_df['EntryBar'].values]
trades_df[f'Exit_{ind.name}{suffix}'] = values[trades_df['ExitBar'].values]
commissions = sum(t._commissions for t in trades)
del trades
pl = trades_df['PnL']
returns = trades_df['ReturnPct']
durations = trades_df['Duration']
def _round_timedelta(value, _period=_data_period(index)):
if not isinstance(value, pd.Timedelta):
return value
resolution = getattr(_period, 'resolution_string', None) or _period.resolution
return value.ceil(resolution)
s = pd.Series(dtype=object)
s.loc['Start'] = index[0]
s.loc['End'] = index[-1]
s.loc['Duration'] = s.End - s.Start
have_position = np.repeat(0, len(index))
for t in trades_df[['EntryBar', 'ExitBar']].itertuples(index=False):
have_position[t.EntryBar:t.ExitBar + 1] = 1
s.loc['Exposure Time [%]'] = have_position.mean() * 100 # In "n bars" time, not index time
s.loc['Equity Final [$]'] = equity[-1]
s.loc['Equity Peak [$]'] = equity.max()
if commissions:
s.loc['Commissions [$]'] = commissions
s.loc['Return [%]'] = (equity[-1] - equity[0]) / equity[0] * 100
first_trading_bar = _indicator_warmup_nbars(strategy_instance)
c = ohlc_data.Close.values
s.loc['Buy & Hold Return [%]'] = (c[-1] - c[first_trading_bar]) / c[first_trading_bar] * 100 # long-only return
gmean_day_return: float = 0
day_returns = np.array(np.nan)
annual_trading_days = np.nan
is_datetime_index = isinstance(index, pd.DatetimeIndex)
if is_datetime_index:
freq_days = cast(pd.Timedelta, _data_period(index)).days
have_weekends = index.dayofweek.to_series().between(5, 6).mean() > 2 / 7 * .6
annual_trading_days = (
52 if freq_days == 7 else
12 if freq_days == 31 else
1 if freq_days == 365 else
(365 if have_weekends else 252))
freq = {7: 'W', 31: 'ME', 365: 'YE'}.get(freq_days, 'D')
day_returns = equity_df['Equity'].resample(freq).last().dropna().pct_change()
gmean_day_return = geometric_mean(day_returns)
# Annualized return and risk metrics are computed based on the (mostly correct)
# assumption that the returns are compounded. See: https://dx.doi.org/10.2139/ssrn.3054517
# Our annualized return matches `empyrical.annual_return(day_returns)` whereas
# our risk doesn't; they use the simpler approach below.
annualized_return = (1 + gmean_day_return)**annual_trading_days - 1
s.loc['Return (Ann.) [%]'] = annualized_return * 100
s.loc['Volatility (Ann.) [%]'] = np.sqrt((day_returns.var(ddof=int(bool(day_returns.shape))) + (1 + gmean_day_return)**2)**annual_trading_days - (1 + gmean_day_return)**(2 * annual_trading_days)) * 100 # noqa: E501
# s.loc['Return (Ann.) [%]'] = gmean_day_return * annual_trading_days * 100
# s.loc['Risk (Ann.) [%]'] = day_returns.std(ddof=1) * np.sqrt(annual_trading_days) * 100
if is_datetime_index:
time_in_years = (s.loc['Duration'].days + s.loc['Duration'].seconds / 86400) / annual_trading_days
s.loc['CAGR [%]'] = ((s.loc['Equity Final [$]'] / equity[0])**(1 / time_in_years) - 1) * 100 if time_in_years else np.nan # noqa: E501
# Our Sharpe mismatches `empyrical.sharpe_ratio()` because they use arithmetic mean return
# and simple standard deviation
s.loc['Sharpe Ratio'] = (s.loc['Return (Ann.) [%]'] - risk_free_rate * 100) / (s.loc['Volatility (Ann.) [%]'] or np.nan) # noqa: E501
# Our Sortino mismatches `empyrical.sortino_ratio()` because they use arithmetic mean return
with np.errstate(divide='ignore'):
s.loc['Sortino Ratio'] = (annualized_return - risk_free_rate) / (np.sqrt(np.mean(day_returns.clip(-np.inf, 0)**2)) * np.sqrt(annual_trading_days)) # noqa: E501
max_dd = -np.nan_to_num(dd.max())
s.loc['Calmar Ratio'] = annualized_return / (-max_dd or np.nan)
equity_log_returns = np.log(equity[1:] / equity[:-1])
market_log_returns = np.log(c[1:] / c[:-1])
beta = np.nan
if len(equity_log_returns) > 1 and len(market_log_returns) > 1:
# len == 0 on dummy call `stats_keys = compute_stats(...)` pre optimization
cov_matrix = np.cov(equity_log_returns, market_log_returns)
beta = cov_matrix[0, 1] / cov_matrix[1, 1]
# Jensen CAPM Alpha: can be strongly positive when beta is negative and B&H Return is large
s.loc['Alpha [%]'] = s.loc['Return [%]'] - risk_free_rate * 100 - beta * (s.loc['Buy & Hold Return [%]'] - risk_free_rate * 100) # noqa: E501
s.loc['Beta'] = beta
s.loc['Max. Drawdown [%]'] = max_dd * 100
s.loc['Avg. Drawdown [%]'] = -dd_peaks.mean() * 100
s.loc['Max. Drawdown Duration'] = _round_timedelta(dd_dur.max())
s.loc['Avg. Drawdown Duration'] = _round_timedelta(dd_dur.mean())
s.loc['# Trades'] = n_trades = len(trades_df)
win_rate = np.nan if not n_trades else (pl > 0).mean()
s.loc['Win Rate [%]'] = win_rate * 100
s.loc['Best Trade [%]'] = returns.max() * 100
s.loc['Worst Trade [%]'] = returns.min() * 100
mean_return = geometric_mean(returns)
s.loc['Avg. Trade [%]'] = mean_return * 100
s.loc['Max. Trade Duration'] = _round_timedelta(durations.max())
s.loc['Avg. Trade Duration'] = _round_timedelta(durations.mean())
s.loc['Profit Factor'] = returns[returns > 0].sum() / (abs(returns[returns < 0].sum()) or np.nan) # noqa: E501
s.loc['Expectancy [%]'] = returns.mean() * 100
s.loc['SQN'] = np.sqrt(n_trades) * pl.mean() / (pl.std() or np.nan)
s.loc['Kelly Criterion'] = win_rate - (1 - win_rate) / (pl[pl > 0].mean() / -pl[pl < 0].mean())
s.loc['_strategy'] = strategy_instance
s.loc['_equity_curve'] = equity_df
s.loc['_trades'] = trades_df
s = _Stats(s)
return s
class _Stats(pd.Series):
def __repr__(self):
with pd.option_context(
'display.max_colwidth', 20, # Prevent expansion due to _equity and _trades dfs
'display.max_rows', len(self), # Reveal self whole
'display.precision', 5, # Enough for my eyes at least
# 'format.na_rep', '--', # TODO: Enable once it works
):
return super().__repr__()
def dummy_stats():
from .backtesting import Trade, _Broker
index = pd.DatetimeIndex(['2025'])
data = pd.DataFrame({col: [np.nan] for col in ('Close',)}, index=index)
trade = Trade(_Broker(data=data, cash=10000, spread=.01, commission=.01, margin=.1,
trade_on_close=True, hedging=True, exclusive_orders=False, index=index),
1, 1, 0, None)
trade._replace(exit_price=1, exit_bar=0)
trade._commissions = np.nan
return compute_stats([trade], np.r_[[np.nan]], data, None, 0)
================================================
FILE: backtesting/_util.py
================================================
from __future__ import annotations
import os
import sys
import warnings
from contextlib import contextmanager
from functools import partial
from itertools import chain
from multiprocessing import resource_tracker as _mprt
from multiprocessing import shared_memory as _mpshm
from numbers import Number
from threading import Lock
from typing import Dict, List, Optional, Sequence, Union, cast
import numpy as np
import pandas as pd
try:
from tqdm.auto import tqdm as _tqdm
_tqdm = partial(_tqdm, leave=False)
except ImportError:
def _tqdm(seq, **_):
return seq
def try_(lazy_func, default=None, exception=Exception):
try:
return lazy_func()
except exception:
return default
@contextmanager
def patch(obj, attr, newvalue):
had_attr = hasattr(obj, attr)
orig_value = getattr(obj, attr, None)
setattr(obj, attr, newvalue)
try:
yield
finally:
if had_attr:
setattr(obj, attr, orig_value)
else:
delattr(obj, attr)
def _as_str(value) -> str:
if isinstance(value, (Number, str)):
return str(value)
if isinstance(value, pd.DataFrame):
return 'df'
name = str(getattr(value, 'name', '') or '')
if name in ('Open', 'High', 'Low', 'Close', 'Volume'):
return name[:1]
if callable(value):
name = getattr(value, '__name__', value.__class__.__name__).replace('<lambda>', 'λ')
if len(name) > 10:
name = name[:9] + '…'
return name
def _as_list(value) -> List:
if isinstance(value, Sequence) and not isinstance(value, str):
return list(value)
return [value]
def _batch(seq):
# XXX: Replace with itertools.batched
n = np.clip(int(len(seq) // (os.cpu_count() or 1)), 1, 300)
for i in range(0, len(seq), n):
yield seq[i:i + n]
def _data_period(index) -> Union[pd.Timedelta, Number]:
"""Return data index period as pd.Timedelta"""
values = pd.Series(index[-100:])
return values.diff().dropna().median()
def _strategy_indicators(strategy):
return {attr: indicator
for attr, indicator in strategy.__dict__.items()
if isinstance(indicator, _Indicator)}.items()
def _indicator_warmup_nbars(strategy):
if strategy is None:
return 0
nbars = max((np.isnan(indicator.astype(float)).argmin(axis=-1).max()
for _, indicator in _strategy_indicators(strategy)
if not indicator._opts['scatter']), default=0)
return nbars
class _Array(np.ndarray):
"""
ndarray extended to supply .name and other arbitrary properties
in ._opts dict.
"""
def __new__(cls, array, *, name=None, **kwargs):
obj = np.asarray(array).view(cls)
obj.name = name or array.name
obj._opts = kwargs
return obj
def __array_finalize__(self, obj):
if obj is not None:
self.name = getattr(obj, 'name', '')
self._opts = getattr(obj, '_opts', {})
# Make sure properties name and _opts are carried over
# when (un-)pickling.
def __reduce__(self):
value = super().__reduce__()
return value[:2] + (value[2] + (self.__dict__,),)
def __setstate__(self, state):
self.__dict__.update(state[-1])
super().__setstate__(state[:-1])
def __bool__(self):
try:
return bool(self[-1])
except IndexError:
return super().__bool__()
def __float__(self):
try:
return float(self[-1])
except IndexError:
return super().__float__()
def to_series(self):
warnings.warn("`.to_series()` is deprecated. For pd.Series conversion, use accessor `.s`")
return self.s
@property
def s(self) -> pd.Series:
values = np.atleast_2d(self)
index = self._opts['index'][:values.shape[1]]
return pd.Series(values[0], index=index, name=self.name)
@property
def df(self) -> pd.DataFrame:
values = np.atleast_2d(np.asarray(self))
index = self._opts['index'][:values.shape[1]]
df = pd.DataFrame(values.T, index=index, columns=[self.name] * len(values))
return df
class _Indicator(_Array):
pass
class _Data:
"""
A data array accessor. Provides access to OHLCV "columns"
as a standard `pd.DataFrame` would, except it's not a DataFrame
and the returned "series" are _not_ `pd.Series` but `np.ndarray`
for performance reasons.
"""
def __init__(self, df: pd.DataFrame):
self.__df = df
self.__len = len(df) # Current length
self.__pip: Optional[float] = None
self.__cache: Dict[str, _Array] = {}
self.__arrays: Dict[str, _Array] = {}
self._update()
def __getitem__(self, item):
return self.__get_array(item)
def __getattr__(self, item):
try:
return self.__get_array(item)
except KeyError:
raise AttributeError(f"Column '{item}' not in data") from None
def _set_length(self, length):
self.__len = length
self.__cache.clear()
def _update(self):
index = self.__df.index.copy()
self.__arrays = {col: _Array(arr, index=index)
for col, arr in self.__df.items()}
# Leave index as Series because pd.Timestamp nicer API to work with
self.__arrays['__index'] = index
def __repr__(self):
i = min(self.__len, len(self.__df)) - 1
index = self.__arrays['__index'][i]
items = ', '.join(f'{k}={v}' for k, v in self.__df.iloc[i].items())
return f'<Data i={i} ({index}) {items}>'
def __len__(self):
return self.__len
@property
def df(self) -> pd.DataFrame:
return (self.__df.iloc[:self.__len]
if self.__len < len(self.__df)
else self.__df)
@property
def pip(self) -> float:
if self.__pip is None:
self.__pip = float(10**-np.median([len(s.partition('.')[-1])
for s in self.__arrays['Close'].astype(str)]))
return self.__pip
def __get_array(self, key) -> _Array:
arr = self.__cache.get(key)
if arr is None:
arr = self.__cache[key] = cast(_Array, self.__arrays[key][:self.__len])
return arr
@property
def Open(self) -> _Array:
return self.__get_array('Open')
@property
def High(self) -> _Array:
return self.__get_array('High')
@property
def Low(self) -> _Array:
return self.__get_array('Low')
@property
def Close(self) -> _Array:
return self.__get_array('Close')
@property
def Volume(self) -> _Array:
return self.__get_array('Volume')
@property
def index(self) -> pd.DatetimeIndex:
return self.__get_array('__index')
# Make pickling in Backtest.optimize() work with our catch-all __getattr__
def __getstate__(self):
return self.__dict__
def __setstate__(self, state):
self.__dict__ = state
if sys.version_info >= (3, 13):
SharedMemory = _mpshm.SharedMemory
else:
class SharedMemory(_mpshm.SharedMemory):
# From https://github.com/python/cpython/issues/82300#issuecomment-2169035092
__lock = Lock()
def __init__(self, *args, track: bool = True, **kwargs):
self._track = track
if track:
return super().__init__(*args, **kwargs)
with self.__lock:
with patch(_mprt, 'register', lambda *a, **kw: None):
super().__init__(*args, **kwargs)
def unlink(self):
if _mpshm._USE_POSIX and self._name:
_mpshm._posixshmem.shm_unlink(self._name)
if self._track:
_mprt.unregister(self._name, "shared_memory")
class SharedMemoryManager:
"""
A simple shared memory contextmanager based on
https://docs.python.org/3/library/multiprocessing.shared_memory.html#multiprocessing.shared_memory.SharedMemory
"""
def __init__(self, create=False) -> None:
self._shms: list[SharedMemory] = []
self.__create = create
def SharedMemory(self, *, name=None, create=False, size=0, track=True):
shm = SharedMemory(name=name, create=create, size=size, track=track)
shm._create = create
# Essential to keep refs on Windows
# https://stackoverflow.com/questions/74193377/filenotfounderror-when-passing-a-shared-memory-to-a-new-process#comment130999060_74194875 # noqa: E501
self._shms.append(shm)
return shm
def __enter__(self):
return self
def __exit__(self, *args, **kwargs):
for shm in self._shms:
try:
shm.close()
if shm._create:
shm.unlink()
except Exception:
warnings.warn(f'Failed to unlink shared memory {shm.name!r}',
category=ResourceWarning, stacklevel=2)
raise
def arr2shm(self, vals):
"""Array to shared memory. Returns (shm_name, shape, dtype) used for restore."""
assert vals.ndim == 1, (vals.ndim, vals.shape, vals)
shm = self.SharedMemory(size=vals.nbytes, create=True)
# np.array can't handle pandas' tz-aware datetimes
# https://github.com/numpy/numpy/issues/18279
buf = np.ndarray(vals.shape, dtype=vals.dtype.base, buffer=shm.buf)
has_tz = getattr(vals.dtype, 'tz', None)
buf[:] = vals.tz_localize(None) if has_tz else vals # Copy into shared memory
return shm.name, vals.shape, vals.dtype
def df2shm(self, df):
return tuple((
(column, *self.arr2shm(values))
for column, values in chain([(self._DF_INDEX_COL, df.index)], df.items())
))
@staticmethod
def shm2s(shm, shape, dtype) -> pd.Series:
arr = np.ndarray(shape, dtype=dtype.base, buffer=shm.buf)
arr.setflags(write=False)
return pd.Series(arr, dtype=dtype)
_DF_INDEX_COL = '__bt_index'
@staticmethod
def shm2df(data_shm):
shm = [SharedMemory(name=name, create=False, track=False) for _, name, _, _ in data_shm]
df = pd.DataFrame({
col: SharedMemoryManager.shm2s(shm, shape, dtype)
for shm, (col, _, shape, dtype) in zip(shm, data_shm)})
df.set_index(SharedMemoryManager._DF_INDEX_COL, drop=True, inplace=True)
df.index.name = None
return df, shm
================================================
FILE: backtesting/autoscale_cb.js
================================================
if (!window._bt_scale_range) {
window._bt_scale_range = function (range, min, max, pad) {
"use strict";
if (min !== Infinity && max !== -Infinity) {
pad = pad ? (max - min) * .03 : 0;
range.start = min - pad;
range.end = max + pad;
} else console.error('backtesting: scale range error:', min, max, range);
};
}
clearTimeout(window._bt_autoscale_timeout);
window._bt_autoscale_timeout = setTimeout(function () {
/**
* @variable cb_obj `fig_ohlc.x_range`.
* @variable source `ColumnDataSource`
* @variable ohlc_range `fig_ohlc.y_range`.
* @variable volume_range `fig_volume.y_range`.
*/
"use strict";
let i = Math.max(Math.floor(cb_obj.start), 0),
j = Math.min(Math.ceil(cb_obj.end), source.data['ohlc_high'].length);
let max = Math.max.apply(null, source.data['ohlc_high'].slice(i, j)),
min = Math.min.apply(null, source.data['ohlc_low'].slice(i, j));
_bt_scale_range(ohlc_range, min, max, true);
if (volume_range) {
max = Math.max.apply(null, source.data['Volume'].slice(i, j));
_bt_scale_range(volume_range, 0, max * 1.03, false);
}
}, 50);
================================================
FILE: backtesting/backtesting.py
================================================
"""
Core framework data structures.
Objects from this module can also be imported from the top-level
module directly, e.g.
from backtesting import Backtest, Strategy
"""
from __future__ import annotations
import sys
import warnings
from abc import ABCMeta, abstractmethod
from copy import copy
from difflib import get_close_matches
from functools import lru_cache, partial
from itertools import chain, product, repeat
from math import copysign
from numbers import Number
from typing import Callable, List, Optional, Sequence, Tuple, Type, Union
import numpy as np
import pandas as pd
from numpy.random import default_rng
from ._plotting import plot # noqa: I001
from ._stats import compute_stats, dummy_stats
from ._util import (
SharedMemoryManager, _as_str, _Indicator, _Data, _batch, _indicator_warmup_nbars,
_strategy_indicators, patch, try_, _tqdm,
)
__pdoc__ = {
'Strategy.__init__': False,
'Order.__init__': False,
'Position.__init__': False,
'Trade.__init__': False,
}
class Strategy(metaclass=ABCMeta):
"""
A trading strategy base class. Extend this class and
override methods
`backtesting.backtesting.Strategy.init` and
`backtesting.backtesting.Strategy.next` to define
your own strategy.
"""
def __init__(self, broker, data, params):
self._indicators = []
self._broker: _Broker = broker
self._data: _Data = data
self._params = self._check_params(params)
def __repr__(self):
return '<Strategy ' + str(self) + '>'
def __str__(self):
params = ','.join(f'{i[0]}={i[1]}' for i in zip(self._params.keys(),
map(_as_str, self._params.values())))
if params:
params = '(' + params + ')'
return f'{self.__class__.__name__}{params}'
def _check_params(self, params):
for k, v in params.items():
if not hasattr(self, k):
suggestions = get_close_matches(k, (attr for attr in dir(self) if not attr.startswith('_')))
hint = f" Did you mean: {', '.join(suggestions)}?" if suggestions else ""
raise AttributeError(
f"Strategy '{self.__class__.__name__}' is missing parameter '{k}'. "
"Strategy class should define parameters as class variables before they "
"can be optimized or run with." + hint)
setattr(self, k, v)
return params
def I(self, # noqa: E743
func: Callable, *args,
name=None, plot=True, overlay=None, color=None, scatter=False,
**kwargs) -> np.ndarray:
"""
Declare an indicator. An indicator is just an array of values
(or a tuple of such arrays in case of, e.g., MACD indicator),
but one that is revealed gradually in
`backtesting.backtesting.Strategy.next` much like
`backtesting.backtesting.Strategy.data` is.
Returns `np.ndarray` of indicator values.
`func` is a function that returns the indicator array(s) of
same length as `backtesting.backtesting.Strategy.data`.
In the plot legend, the indicator is labeled with
function name, unless `name` overrides it. If `func` returns
a tuple of arrays, `name` can be a sequence of strings, and
its size must agree with the number of arrays returned.
If `plot` is `True`, the indicator is plotted on the resulting
`backtesting.backtesting.Backtest.plot`.
If `overlay` is `True`, the indicator is plotted overlaying the
price candlestick chart (suitable e.g. for moving averages).
If `False`, the indicator is plotted standalone below the
candlestick chart. By default, a heuristic is used which decides
correctly most of the time.
`color` can be string hex RGB triplet or X11 color name.
By default, the next available color is assigned.
If `scatter` is `True`, the plotted indicator marker will be a
circle instead of a connected line segment (default).
Additional `*args` and `**kwargs` are passed to `func` and can
be used for parameters.
For example, using simple moving average function from TA-Lib:
def init():
self.sma = self.I(ta.SMA, self.data.Close, self.n_sma)
.. warning::
Rolling indicators may front-pad warm-up values with NaNs.
In this case, the **backtest will only begin on the first bar when
all declared indicators have non-NaN values** (e.g. bar 201 for a
strategy that uses a 200-bar MA).
This can affect results.
"""
def _format_name(name: str) -> str:
return name.format(*map(_as_str, args),
**dict(zip(kwargs.keys(), map(_as_str, kwargs.values()))))
if name is None:
params = ','.join(filter(None, map(_as_str, chain(args, kwargs.values()))))
func_name = _as_str(func)
name = (f'{func_name}({params})' if params else f'{func_name}')
elif isinstance(name, str):
name = _format_name(name)
elif try_(lambda: all(isinstance(item, str) for item in name), False):
name = [_format_name(item) for item in name]
else:
raise TypeError(f'Unexpected `name=` type {type(name)}; expected `str` or '
'`Sequence[str]`')
try:
value = func(*args, **kwargs)
except Exception as e:
raise RuntimeError(f'Indicator "{name}" error. See traceback above.') from e
if isinstance(value, pd.DataFrame):
value = value.values.T
if value is not None:
value = try_(lambda: np.asarray(value, order='C'), None)
is_arraylike = bool(value is not None and value.shape)
# Optionally flip the array if the user returned e.g. `df.values`
if is_arraylike and np.argmax(value.shape) == 0:
value = value.T
if isinstance(name, list) and (np.atleast_2d(value).shape[0] != len(name)):
raise ValueError(
f'Length of `name=` ({len(name)}) must agree with the number '
f'of arrays the indicator returns ({value.shape[0]}).')
if not is_arraylike or not 1 <= value.ndim <= 2 or value.shape[-1] != len(self._data.Close):
raise ValueError(
'Indicators must return (optionally a tuple of) numpy.arrays of same '
f'length as `data` (data shape: {self._data.Close.shape}; indicator "{name}" '
f'shape: {getattr(value, "shape", "")}, returned value: {value})')
if overlay is None and np.issubdtype(value.dtype, np.number):
x = value / self._data.Close
# By default, overlay if strong majority of indicator values
# is within 30% of Close
with np.errstate(invalid='ignore'):
overlay = ((x < 1.4) & (x > .6)).mean() > .6
value = _Indicator(value, name=name, plot=plot, overlay=overlay,
color=color, scatter=scatter,
# _Indicator.s Series accessor uses this:
index=self.data.index)
self._indicators.append(value)
return value
@abstractmethod
def init(self):
"""
Initialize the strategy.
Override this method.
Declare indicators (with `backtesting.backtesting.Strategy.I`).
Precompute what needs to be precomputed or can be precomputed
in a vectorized fashion before the strategy starts.
If you extend composable strategies from `backtesting.lib`,
make sure to call:
super().init()
"""
@abstractmethod
def next(self):
"""
Main strategy runtime method, called as each new
`backtesting.backtesting.Strategy.data`
instance (row; full candlestick bar) becomes available.
This is the main method where strategy decisions
upon data precomputed in `backtesting.backtesting.Strategy.init`
take place.
If you extend composable strategies from `backtesting.lib`,
make sure to call:
super().next()
"""
class __FULL_EQUITY(float): # noqa: N801
def __repr__(self): return '.9999' # noqa: E704
_FULL_EQUITY = __FULL_EQUITY(1 - sys.float_info.epsilon)
def buy(self, *,
size: float = _FULL_EQUITY,
limit: Optional[float] = None,
stop: Optional[float] = None,
sl: Optional[float] = None,
tp: Optional[float] = None,
tag: object = None) -> 'Order':
"""
Place a new long order and return it. For explanation of parameters, see `Order`
and its properties.
Unless you're running `Backtest(..., trade_on_close=True)`,
market orders are filled on next bar's open,
whereas other order types (limit, stop-limit, stop-market) are filled when
the respective conditions are met.
See `Position.close()` and `Trade.close()` for closing existing positions.
See also `Strategy.sell()`.
"""
assert 0 < size < 1 or round(size) == size >= 1, \
"size must be a positive fraction of equity, or a positive whole number of units"
return self._broker.new_order(size, limit, stop, sl, tp, tag)
def sell(self, *,
size: float = _FULL_EQUITY,
limit: Optional[float] = None,
stop: Optional[float] = None,
sl: Optional[float] = None,
tp: Optional[float] = None,
tag: object = None) -> 'Order':
"""
Place a new short order and return it. For explanation of parameters, see `Order`
and its properties.
.. caution::
Keep in mind that `self.sell(size=.1)` doesn't close existing `self.buy(size=.1)`
trade unless:
* the backtest was run with `exclusive_orders=True`,
* the underlying asset price is equal in both cases and
the backtest was run with `spread = commission = 0`.
Use `Trade.close()` or `Position.close()` to explicitly exit trades.
See also `Strategy.buy()`.
.. note::
If you merely want to close an existing long position,
use `Position.close()` or `Trade.close()`.
"""
assert 0 < size < 1 or round(size) == size >= 1, \
"size must be a positive fraction of equity, or a positive whole number of units"
return self._broker.new_order(-size, limit, stop, sl, tp, tag)
@property
def equity(self) -> float:
"""Current account equity (cash plus assets)."""
return self._broker.equity
@property
def data(self) -> _Data:
"""
Price data, roughly as passed into
`backtesting.backtesting.Backtest.__init__`,
but with two significant exceptions:
* `data` is _not_ a DataFrame, but a custom structure
that serves customized numpy arrays for reasons of performance
and convenience. Besides OHLCV columns, `.index` and length,
it offers `.pip` property, the smallest price unit of change.
* Within `backtesting.backtesting.Strategy.init`, `data` arrays
are available in full length, as passed into
`backtesting.backtesting.Backtest.__init__`
(for precomputing indicators and such). However, within
`backtesting.backtesting.Strategy.next`, `data` arrays are
only as long as the current iteration, simulating gradual
price point revelation. In each call of
`backtesting.backtesting.Strategy.next` (iteratively called by
`backtesting.backtesting.Backtest` internally),
the last array value (e.g. `data.Close[-1]`)
is always the _most recent_ value.
* If you need data arrays (e.g. `data.Close`) to be indexed
**Pandas series**, you can call their `.s` accessor
(e.g. `data.Close.s`). If you need the whole of data
as a **DataFrame**, use `.df` accessor (i.e. `data.df`).
"""
return self._data
@property
def position(self) -> 'Position':
"""Instance of `backtesting.backtesting.Position`."""
return self._broker.position
@property
def orders(self) -> 'Tuple[Order, ...]':
"""List of orders (see `Order`) waiting for execution."""
return tuple(self._broker.orders)
@property
def trades(self) -> 'Tuple[Trade, ...]':
"""List of active trades (see `Trade`)."""
return tuple(self._broker.trades)
@property
def closed_trades(self) -> 'Tuple[Trade, ...]':
"""List of settled trades (see `Trade`)."""
return tuple(self._broker.closed_trades)
class Position:
"""
Currently held asset position, available as
`backtesting.backtesting.Strategy.position` within
`backtesting.backtesting.Strategy.next`.
Can be used in boolean contexts, e.g.
if self.position:
... # we have a position, either long or short
"""
def __init__(self, broker: '_Broker'):
self.__broker = broker
def __bool__(self):
return self.size != 0
@property
def size(self) -> float:
"""Position size in units of asset. Negative if position is short."""
return sum(trade.size for trade in self.__broker.trades)
@property
def pl(self) -> float:
"""Profit (positive) or loss (negative) of the current position in cash units."""
return sum(trade.pl for trade in self.__broker.trades)
@property
def pl_pct(self) -> float:
"""Profit (positive) or loss (negative) of the current position in percent."""
total_invested = sum(trade.entry_price * abs(trade.size) for trade in self.__broker.trades)
return (self.pl / total_invested) * 100 if total_invested else 0
@property
def is_long(self) -> bool:
"""True if the position is long (position size is positive)."""
return self.size > 0
@property
def is_short(self) -> bool:
"""True if the position is short (position size is negative)."""
return self.size < 0
def close(self, portion: float = 1.):
"""
Close portion of position by closing `portion` of each active trade. See `Trade.close`.
"""
for trade in self.__broker.trades:
trade.close(portion)
def __repr__(self):
return f'<Position: {self.size} ({len(self.__broker.trades)} trades)>'
class _OutOfMoneyError(Exception):
pass
class Order:
"""
Place new orders through `Strategy.buy()` and `Strategy.sell()`.
Query existing orders through `Strategy.orders`.
When an order is executed or [filled], it results in a `Trade`.
If you wish to modify aspects of a placed but not yet filled order,
cancel it and place a new one instead.
All placed orders are [Good 'Til Canceled].
[filled]: https://www.investopedia.com/terms/f/fill.asp
[Good 'Til Canceled]: https://www.investopedia.com/terms/g/gtc.asp
"""
def __init__(self, broker: '_Broker',
size: float,
limit_price: Optional[float] = None,
stop_price: Optional[float] = None,
sl_price: Optional[float] = None,
tp_price: Optional[float] = None,
parent_trade: Optional['Trade'] = None,
tag: object = None):
self.__broker = broker
assert size != 0
self.__size = size
self.__limit_price = limit_price
self.__stop_price = stop_price
self.__sl_price = sl_price
self.__tp_price = tp_price
self.__parent_trade = parent_trade
self.__tag = tag
def _replace(self, **kwargs):
for k, v in kwargs.items():
setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
return self
def __repr__(self):
return '<Order {}>'.format(', '.join(f'{param}={try_(lambda: round(value, 5), value)!r}'
for param, value in (
('size', self.__size),
('limit', self.__limit_price),
('stop', self.__stop_price),
('sl', self.__sl_price),
('tp', self.__tp_price),
('contingent', self.is_contingent),
('tag', self.__tag),
) if value is not None)) # noqa: E126
def cancel(self):
"""Cancel the order."""
self.__broker.orders.remove(self)
trade = self.__parent_trade
if trade:
if self is trade._sl_order:
trade._replace(sl_order=None)
elif self is trade._tp_order:
trade._replace(tp_order=None)
else:
pass # Order placed by Trade.close()
# Fields getters
@property
def size(self) -> float:
"""
Order size (negative for short orders).
If size is a value between 0 and 1, it is interpreted as a fraction of current
available liquidity (cash plus `Position.pl` minus used margin).
A value greater than or equal to 1 indicates an absolute number of units.
"""
return self.__size
@property
def limit(self) -> Optional[float]:
"""
Order limit price for [limit orders], or None for [market orders],
which are filled at next available price.
[limit orders]: https://www.investopedia.com/terms/l/limitorder.asp
[market orders]: https://www.investopedia.com/terms/m/marketorder.asp
"""
return self.__limit_price
@property
def stop(self) -> Optional[float]:
"""
Order stop price for [stop-limit/stop-market][_] order,
otherwise None if no stop was set, or the stop price has already been hit.
[_]: https://www.investopedia.com/terms/s/stoporder.asp
"""
return self.__stop_price
@property
def sl(self) -> Optional[float]:
"""
A stop-loss price at which, if set, a new contingent stop-market order
will be placed upon the `Trade` following this order's execution.
See also `Trade.sl`.
"""
return self.__sl_price
@property
def tp(self) -> Optional[float]:
"""
A take-profit price at which, if set, a new contingent limit order
will be placed upon the `Trade` following this order's execution.
See also `Trade.tp`.
"""
return self.__tp_price
@property
def parent_trade(self):
return self.__parent_trade
@property
def tag(self):
"""
Arbitrary value (such as a string) which, if set, enables tracking
of this order and the associated `Trade` (see `Trade.tag`).
"""
return self.__tag
__pdoc__['Order.parent_trade'] = False
# Extra properties
@property
def is_long(self):
"""True if the order is long (order size is positive)."""
return self.__size > 0
@property
def is_short(self):
"""True if the order is short (order size is negative)."""
return self.__size < 0
@property
def is_contingent(self):
"""
True for [contingent] orders, i.e. [OCO] stop-loss and take-profit bracket orders
placed upon an active trade. Remaining contingent orders are canceled when
their parent `Trade` is closed.
You can modify contingent orders through `Trade.sl` and `Trade.tp`.
[contingent]: https://www.investopedia.com/terms/c/contingentorder.asp
[OCO]: https://www.investopedia.com/terms/o/oco.asp
"""
return bool((parent := self.__parent_trade) and
(self is parent._sl_order or
self is parent._tp_order))
class Trade:
"""
When an `Order` is filled, it results in an active `Trade`.
Find active trades in `Strategy.trades` and closed, settled trades in `Strategy.closed_trades`.
"""
def __init__(self, broker: '_Broker', size: int, entry_price: float, entry_bar, tag):
self.__broker = broker
self.__size = size
self.__entry_price = entry_price
self.__exit_price: Optional[float] = None
self.__entry_bar: int = entry_bar
self.__exit_bar: Optional[int] = None
self.__sl_order: Optional[Order] = None
self.__tp_order: Optional[Order] = None
self.__tag = tag
self._commissions = 0
def __repr__(self):
return f'<Trade size={self.__size} time={self.__entry_bar}-{self.__exit_bar or ""} ' \
f'price={self.__entry_price}-{self.__exit_price or ""} pl={self.pl:.0f}' \
f'{" tag=" + str(self.__tag) if self.__tag is not None else ""}>'
def _replace(self, **kwargs):
for k, v in kwargs.items():
setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
return self
def _copy(self, **kwargs):
return copy(self)._replace(**kwargs)
def close(self, portion: float = 1.):
"""Place new `Order` to close `portion` of the trade at next market price."""
assert 0 < portion <= 1, "portion must be a fraction between 0 and 1"
# Ensure size is an int to avoid rounding errors on 32-bit OS
size = copysign(max(1, int(round(abs(self.__size) * portion))), -self.__size)
order = Order(self.__broker, size, parent_trade=self, tag=self.__tag)
self.__broker.orders.insert(0, order)
# Fields getters
@property
def size(self):
"""Trade size (volume; negative for short trades)."""
return self.__size
@property
def entry_price(self) -> float:
"""Trade entry price."""
return self.__entry_price
@property
def exit_price(self) -> Optional[float]:
"""Trade exit price (or None if the trade is still active)."""
return self.__exit_price
@property
def entry_bar(self) -> int:
"""Candlestick bar index of when the trade was entered."""
return self.__entry_bar
@property
def exit_bar(self) -> Optional[int]:
"""
Candlestick bar index of when the trade was exited
(or None if the trade is still active).
"""
return self.__exit_bar
@property
def tag(self):
"""
A tag value inherited from the `Order` that opened
this trade.
This can be used to track trades and apply conditional
logic / subgroup analysis.
See also `Order.tag`.
"""
return self.__tag
@property
def _sl_order(self):
return self.__sl_order
@property
def _tp_order(self):
return self.__tp_order
# Extra properties
@property
def entry_time(self) -> Union[pd.Timestamp, int]:
"""Datetime of when the trade was entered."""
return self.__broker._data.index[self.__entry_bar]
@property
def exit_time(self) -> Optional[Union[pd.Timestamp, int]]:
"""Datetime of when the trade was exited."""
if self.__exit_bar is None:
return None
return self.__broker._data.index[self.__exit_bar]
@property
def is_long(self):
"""True if the trade is long (trade size is positive)."""
return self.__size > 0
@property
def is_short(self):
"""True if the trade is short (trade size is negative)."""
return not self.is_long
@property
def pl(self):
"""
Trade profit (positive) or loss (negative) in cash units.
Commissions are reflected only after the Trade is closed.
"""
price = self.__exit_price or self.__broker.last_price
return (self.__size * (price - self.__entry_price)) - self._commissions
@property
def pl_pct(self):
"""Trade profit (positive) or loss (negative) in percent relative to trade entry price."""
price = self.__exit_price or self.__broker.last_price
gross_pl_pct = copysign(1, self.__size) * (price / self.__entry_price - 1)
# Total commission across the entire trade size to individual units
commission_pct = self._commissions / (abs(self.__size) * self.__entry_price)
return gross_pl_pct - commission_pct
@property
def value(self):
"""Trade total value in cash (volume × price)."""
price = self.__exit_price or self.__broker.last_price
return abs(self.__size) * price
# SL/TP management API
@property
def sl(self):
"""
Stop-loss price at which to close the trade.
This variable is writable. By assigning it a new price value,
you create or modify the existing SL order.
By assigning it `None`, you cancel it.
"""
return self.__sl_order and self.__sl_order.stop
@sl.setter
def sl(self, price: float):
self.__set_contingent('sl', price)
@property
def tp(self):
"""
Take-profit price at which to close the trade.
This property is writable. By assigning it a new price value,
you create or modify the existing TP order.
By assigning it `None`, you cancel it.
"""
return self.__tp_order and self.__tp_order.limit
@tp.setter
def tp(self, price: float):
self.__set_contingent('tp', price)
def __set_contingent(self, type, price):
assert type in ('sl', 'tp')
assert price is None or 0 < price < np.inf, f'Make sure 0 < price < inf! price: {price}'
attr = f'_{self.__class__.__qualname__}__{type}_order'
order: Order = getattr(self, attr)
if order:
order.cancel()
if price:
kwargs = {'stop': price} if type == 'sl' else {'limit': price}
order = self.__broker.new_order(-self.size, trade=self, tag=self.tag, **kwargs)
setattr(self, attr, order)
class _Broker:
def __init__(self, *, data, cash, spread, commission, margin,
trade_on_close, hedging, exclusive_orders, index):
assert cash > 0, f"cash should be > 0, is {cash}"
assert 0 < margin <= 1, f"margin should be between 0 and 1, is {margin}"
self._data: _Data = data
self._cash = cash
if callable(commission):
self._commission = commission
else:
try:
self._commission_fixed, self._commission_relative = commission
except TypeError:
self._commission_fixed, self._commission_relative = 0, commission
assert self._commission_fixed >= 0, 'Need fixed cash commission in $ >= 0'
assert -.1 <= self._commission_relative < .1, \
("commission should be between -10% "
f"(e.g. market-maker's rebates) and 10% (fees), is {self._commission_relative}")
self._commission = self._commission_func
self._spread = spread
self._leverage = 1 / margin
self._trade_on_close = trade_on_close
self._hedging = hedging
self._exclusive_orders = exclusive_orders
self._equity = np.tile(np.nan, len(index))
self.orders: List[Order] = []
self.trades: List[Trade] = []
self.position = Position(self)
self.closed_trades: List[Trade] = []
def _commission_func(self, order_size, price):
return self._commission_fixed + abs(order_size) * price * self._commission_relative
def __repr__(self):
return f'<Broker: {self._cash:.0f}{self.position.pl:+.1f} ({len(self.trades)} trades)>'
def new_order(self,
size: float,
limit: Optional[float] = None,
stop: Optional[float] = None,
sl: Optional[float] = None,
tp: Optional[float] = None,
tag: object = None,
*,
trade: Optional[Trade] = None) -> Order:
"""
Argument size indicates whether the order is long or short
"""
size = float(size)
stop = stop and float(stop)
limit = limit and float(limit)
sl = sl and float(sl)
tp = tp and float(tp)
is_long = size > 0
assert size != 0, size
adjusted_price = self._adjusted_price(size)
if is_long:
if not (sl or -np.inf) < (limit or stop or adjusted_price) < (tp or np.inf):
raise ValueError(
"Long orders require: "
f"SL ({sl}) < LIMIT ({limit or stop or adjusted_price}) < TP ({tp})")
else:
if not (tp or -np.inf) < (limit or stop or adjusted_price) < (sl or np.inf):
raise ValueError(
"Short orders require: "
f"TP ({tp}) < LIMIT ({limit or stop or adjusted_price}) < SL ({sl})")
order = Order(self, size, limit, stop, sl, tp, trade, tag)
if not trade:
# If exclusive orders (each new order auto-closes previous orders/position),
# cancel all non-contingent orders and close all open trades beforehand
if self._exclusive_orders:
for o in self.orders:
if not o.is_contingent:
o.cancel()
for t in self.trades:
t.close()
# Put the new order in the order queue, Ensure SL orders are processed first
self.orders.insert(0 if trade and stop else len(self.orders), order)
return order
@property
def last_price(self) -> float:
""" Price at the last (current) close. """
return self._data.Close[-1]
def _adjusted_price(self, size=None, price=None) -> float:
"""
Long/short `price`, adjusted for spread.
In long positions, the adjusted price is a fraction higher, and vice versa.
"""
return (price or self.last_price) * (1 + copysign(self._spread, size))
@property
def equity(self) -> float:
return self._cash + sum(trade.pl for trade in self.trades)
@property
def margin_available(self) -> float:
# From https://github.com/QuantConnect/Lean/pull/3768
margin_used = sum(trade.value / self._leverage for trade in self.trades)
return max(0, self.equity - margin_used)
def next(self):
i = self._i = len(self._data) - 1
self._process_orders()
# Log account equity for the equity curve
equity = self.equity
self._equity[i] = equity
# If equity is negative, set all to 0 and stop the simulation
if equity <= 0:
assert self.margin_available <= 0
for trade in self.trades:
self._close_trade(trade, self._data.Close[-1], i)
self._cash = 0
self._equity[i:] = 0
raise _OutOfMoneyError
def _process_orders(self):
data = self._data
open, high, low = data.Open[-1], data.High[-1], data.Low[-1]
reprocess_orders = False
# Process orders
for order in list(self.orders): # type: Order
# Related SL/TP order was already removed
if order not in self.orders:
continue
# Check if stop condition was hit
stop_price = order.stop
if stop_price:
is_stop_hit = ((high >= stop_price) if order.is_long else (low <= stop_price))
if not is_stop_hit:
continue
# > When the stop price is reached, a stop order becomes a market/limit order.
# https://www.sec.gov/fast-answers/answersstopordhtm.html
order._replace(stop_price=None)
# Determine purchase price.
# Check if limit order can be filled.
if order.limit:
is_limit_hit = low <= order.limit if order.is_long else high >= order.limit
# When stop and limit are hit within the same bar, we pessimistically
# assume limit was hit before the stop (i.e. "before it counts")
is_limit_hit_before_stop = (is_limit_hit and
(order.limit <= (stop_price or -np.inf)
if order.is_long
else order.limit >= (stop_price or np.inf)))
if not is_limit_hit or is_limit_hit_before_stop:
continue
# stop_price, if set, was hit within this bar
price = (min(stop_price or open, order.limit)
if order.is_long else
max(stop_price or open, order.limit))
else:
# Market-if-touched / market order
# Contingent orders always on next open
prev_close = data.Close[-2]
price = prev_close if self._trade_on_close and not order.is_contingent else open
if stop_price:
price = max(price, stop_price) if order.is_long else min(price, stop_price)
# Determine entry/exit bar index
is_market_order = not order.limit and not stop_price
time_index = (
(self._i - 1)
if is_market_order and self._trade_on_close and not order.is_contingent else
self._i)
# If order is a SL/TP order, it should close an existing trade it was contingent upon
if order.parent_trade:
trade = order.parent_trade
_prev_size = trade.size
# If order.size is "greater" than trade.size, this order is a trade.close()
# order and part of the trade was already closed beforehand
size = copysign(min(abs(_prev_size), abs(order.size)), order.size)
# If this trade isn't already closed (e.g. on multiple `trade.close(.5)` calls)
if trade in self.trades:
self._reduce_trade(trade, price, size, time_index)
assert order.size != -_prev_size or trade not in self.trades
if price == stop_price:
# Set SL back on the order for stats._trades["SL"]
trade._sl_order._replace(stop_price=stop_price)
if order in (trade._sl_order,
trade._tp_order):
assert order.size == -trade.size
assert order not in self.orders # Removed when trade was closed
else:
# It's a trade.close() order, now done
assert abs(_prev_size) >= abs(size) >= 1
self.orders.remove(order)
continue
# Else this is a stand-alone trade
# Adjust price to include commission (or bid-ask spread).
# In long positions, the adjusted price is a fraction higher, and vice versa.
adjusted_price = self._adjusted_price(order.size, price)
adjusted_price_plus_commission = \
adjusted_price + self._commission(order.size, price) / abs(order.size)
# If order size was specified proportionally,
# precompute true size in units, accounting for margin and spread/commissions
size = order.size
if -1 < size < 1:
size = copysign(int((self.margin_available * self._leverage * abs(size))
// adjusted_price_plus_commission), size)
# Not enough cash/margin even for a single unit
if not size:
warnings.warn(
f'time={self._i}: Broker canceled the relative-sized order due to insufficient margin '
f'(equity={self.equity:.2f}, margin_available={self.margin_available:.2f}).',
category=UserWarning)
# XXX: The order is canceled by the broker?
self.orders.remove(order)
continue
assert size == round(size)
need_size = int(size)
if not self._hedging:
# Fill position by FIFO closing/reducing existing opposite-facing trades.
# Existing trades are closed at unadjusted price, because the adjustment
# was already made when buying.
for trade in list(self.trades):
if trade.is_long == order.is_long:
continue
assert trade.size * order.size < 0
# Order size greater than this opposite-directed existing trade,
# so it will be closed completely
if abs(need_size) >= abs(trade.size):
self._close_trade(trade, price, time_index)
need_size += trade.size
else:
# The existing trade is larger than the new order,
# so it will only be closed partially
self._reduce_trade(trade, price, need_size, time_index)
need_size = 0
if not need_size:
break
# If we don't have enough liquidity to cover for the order, the broker CANCELS it
if abs(need_size) * adjusted_price_plus_commission > \
self.margin_available * self._leverage:
warnings.warn(
f'time={self._i}: Broker canceled the order due to insufficient margin '
f'(equity={self.equity:.2f}, margin_available={self.margin_available:.2f}).',
category=UserWarning)
self.orders.remove(order)
continue
# Open a new trade
if need_size:
self._open_trade(adjusted_price,
need_size,
order.sl,
order.tp,
time_index,
order.tag)
# We need to reprocess the SL/TP orders newly added to the queue.
# This allows e.g. SL hitting in the same bar the order was open.
# See https://github.com/kernc/backtesting.py/issues/119
if order.sl or order.tp:
if is_market_order:
reprocess_orders = True
# Order.stop and TP hit within the same bar, but SL wasn't. This case
# is not ambiguous, because stop and TP go in the same price direction.
elif stop_price and not order.limit and order.tp and (
(order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
(order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
reprocess_orders = True
elif (low <= (order.sl or -np.inf) <= high or
low <= (order.tp or -np.inf) <= high):
warnings.warn(
f"({data.index[-1]}) A contingent SL/TP order would execute in the "
"same bar its parent stop/limit order was turned into a trade. "
"Since we can't assert the precise intra-candle "
"price movement, the affected SL/TP order will instead be executed on "
"the next (matching) price/bar, making the result (of this trade) "
"somewhat dubious. "
"See https://github.com/kernc/backtesting.py/issues/119",
UserWarning)
# Order processed
self.orders.remove(order)
if reprocess_orders:
self._process_orders()
def _reduce_trade(self, trade: Trade, price: float, size: float, time_index: int):
assert trade.size * size < 0
assert abs(trade.size) >= abs(size)
size_left = trade.size + size
assert size_left * trade.size >= 0
if not size_left:
close_trade = trade
else:
# Reduce existing trade ...
trade._replace(size=size_left)
if trade._sl_order:
trade._sl_order._replace(size=-trade.size)
if trade._tp_order:
trade._tp_order._replace(size=-trade.size)
# ... by closing a reduced copy of it
close_trade = trade._copy(size=-size, sl_order=None, tp_order=None)
self.trades.append(close_trade)
self._close_trade(close_trade, price, time_index)
def _close_trade(self, trade: Trade, price: float, time_index: int):
self.trades.remove(trade)
if trade._sl_order:
self.orders.remove(trade._sl_order)
if trade._tp_order:
self.orders.remove(trade._tp_order)
closed_trade = trade._replace(exit_price=price, exit_bar=time_index)
self.closed_trades.append(closed_trade)
# Apply commission one more time at trade exit
commission = self._commission(trade.size, price)
self._cash += trade.pl - commission
# Save commissions on Trade instance for stats
trade_open_commission = self._commission(closed_trade.size, closed_trade.entry_price)
# applied here instead of on Trade open because size could have changed
# by way of _reduce_trade()
closed_trade._commissions = commission + trade_open_commission
def _open_trade(self, price: float, size: int,
sl: Optional[float], tp: Optional[float], time_index: int, tag):
trade = Trade(self, size, price, time_index, tag)
self.trades.append(trade)
# Apply broker commission at trade open
self._cash -= self._commission(size, price)
# Create SL/TP (bracket) orders.
if tp:
trade.tp = tp
if sl:
trade.sl = sl
class Backtest:
"""
Backtest a particular (parameterized) strategy
on particular data.
Initialize a backtest. Requires data and a strategy to test.
After initialization, you can call method
`backtesting.backtesting.Backtest.run` to run a backtest
instance, or `backtesting.backtesting.Backtest.optimize` to
optimize it.
`data` is a `pd.DataFrame` with columns:
`Open`, `High`, `Low`, `Close`, and (optionally) `Volume`.
If any columns are missing, set them to what you have available,
e.g.
df['Open'] = df['High'] = df['Low'] = df['Close']
The passed data frame can contain additional columns that
can be used by the strategy (e.g. sentiment info).
DataFrame index can be either a datetime index (timestamps)
or a monotonic range index (i.e. a sequence of periods).
`strategy` is a `backtesting.backtesting.Strategy`
_subclass_ (not an instance).
`cash` is the initial cash to start with.
`spread` is the constant bid-ask spread rate (relative to the price).
E.g. set it to `0.0002` for commission-less forex
trading where the average spread is roughly 0.2‰ of the asking price.
`commission` is the commission rate. E.g. if your broker's commission
is 1% of order value, set commission to `0.01`.
The commission is applied twice: at trade entry and at trade exit.
Besides one single floating value, `commission` can also be a tuple of floating
values `(fixed, relative)`. E.g. set it to `(100, .01)`
if your broker charges minimum $100 + 1%.
Additionally, `commission` can be a callable
`func(order_size: int, price: float) -> float`
(note, order size is negative for short orders),
which can be used to model more complex commission structures.
Negative commission values are interpreted as market-maker's rebates.
.. note::
Before v0.4.0, the commission was only applied once, like `spread` is now.
If you want to keep the old behavior, simply set `spread` instead.
.. note::
With nonzero `commission`, long and short orders will be placed
at an adjusted price that is slightly higher or lower (respectively)
than the current price. See e.g.
[#153](https://github.com/kernc/backtesting.py/issues/153),
[#538](https://github.com/kernc/backtesting.py/issues/538),
[#633](https://github.com/kernc/backtesting.py/issues/633).
`margin` is the required margin (ratio) of a leveraged account.
No difference is made between initial and maintenance margins.
To run the backtest using e.g. 50:1 leverage that your broker allows,
set margin to `0.02` (1 / leverage).
If `trade_on_close` is `True`, market orders will be filled
with respect to the current bar's closing price instead of the
next bar's open.
If `hedging` is `True`, allow trades in both directions simultaneously.
If `False`, the opposite-facing orders first close existing trades in
a [FIFO] manner.
If `exclusive_orders` is `True`, each new order auto-closes the previous
trade/position, making at most a single trade (long or short) in effect
at each time.
If `finalize_trades` is `True`, the trades that are still
[active and ongoing] at the end of the backtest will be closed on
the last bar and will contribute to the computed backtest statistics.
.. tip:: Fractional trading
See also `backtesting.lib.FractionalBacktest` if you want to trade
fractional units (of e.g. bitcoin).
[FIFO]: https://www.investopedia.com/terms/n/nfa-compliance-rule-2-43b.asp
[active and ongoing]: https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Strategy.trades
""" # noqa: E501
def __init__(self,
data: pd.DataFrame,
strategy: Type[Strategy],
*,
cash: float = 10_000,
spread: float = .0,
commission: Union[float, Tuple[float, float]] = .0,
margin: float = 1.,
trade_on_close=False,
hedging=False,
exclusive_orders=False,
finalize_trades=False,
):
if not (isinstance(strategy, type) and issubclass(strategy, Strategy)):
raise TypeError('`strategy` must be a Strategy sub-type')
if not isinstance(data, pd.DataFrame):
raise TypeError("`data` must be a pandas.DataFrame with columns")
if not isinstance(spread, Number):
raise TypeError('`spread` must be a float value, percent of '
'entry order price')
if not isinstance(commission, (Number, tuple)) and not callable(commission):
raise TypeError('`commission` must be a float percent of order value, '
'a tuple of `(fixed, relative)` commission, '
'or a function that takes `(order_size, price)`'
'and returns commission dollar value')
data = data.copy(deep=False)
# Convert index to datetime index
if (not isinstance(data.index, pd.DatetimeIndex) and
not isinstance(data.index, pd.RangeIndex) and
# Numeric index with most large numbers
(data.index.is_numeric() and
(data.index > pd.Timestamp('1975').timestamp()).mean() > .8)):
try:
data.index = pd.to_datetime(data.index, infer_datetime_format=True)
except ValueError:
pass
if 'Volume' not in data:
data['Volume'] = np.nan
if len(data) == 0:
raise ValueError('OHLC `data` is empty')
if len(data.columns.intersection({'Open', 'High', 'Low', 'Close', 'Volume'})) != 5:
raise ValueError("`data` must be a pandas.DataFrame with columns "
"'Open', 'High', 'Low', 'Close', and (optionally) 'Volume'")
if data[['Open', 'High', 'Low', 'Close']].isnull().values.any():
raise ValueError('Some OHLC values are missing (NaN). '
'Please strip those lines with `df.dropna()` or '
'fill them in with `df.interpolate()` or whatever.')
if np.any(data['Close'] > cash):
warnings.warn('Some prices are larger than initial cash value. Note that fractional '
'trading is not supported by this class. If you want to trade Bitcoin, '
'increase initial cash, or trade μBTC or satoshis instead (see e.g. class '
'`backtesting.lib.FractionalBacktest`.',
stacklevel=2)
if not data.index.is_monotonic_increasing:
warnings.warn('Data index is not sorted in ascending order. Sorting.',
stacklevel=2)
data = data.sort_index()
if not isinstance(data.index, pd.DatetimeIndex):
warnings.warn('Data index is not datetime. Assuming simple periods, '
'but `pd.DateTimeIndex` is advised.',
stacklevel=2)
self._data: pd.DataFrame = data
self._broker = partial(
_Broker, cash=cash, spread=spread, commission=commission, margin=margin,
trade_on_close=trade_on_close, hedging=hedging,
exclusive_orders=exclusive_orders, index=data.index,
)
self._strategy = strategy
self._results: Optional[pd.Series] = None
self._finalize_trades = bool(finalize_trades)
def run(self, **kwargs) -> pd.Series:
"""
Run the backtest. Returns `pd.Series` with results and statistics.
Keyword arguments are interpreted as strategy parameters.
>>> Backtest(GOOG, SmaCross).run()
Start 2004-08-19 00:00:00
End 2013-03-01 00:00:00
Duration 3116 days 00:00:00
Exposure Time [%] 96.74115
Equity Final [$] 51422.99
Equity Peak [$] 75787.44
Return [%] 414.2299
Buy & Hold Return [%] 703.45824
Return (Ann.) [%] 21.18026
Volatility (Ann.) [%] 36.49391
CAGR [%] 14.15984
Sharpe Ratio 0.58038
Sortino Ratio 1.08479
Calmar Ratio 0.44144
Alpha [%] 394.37391
Beta 0.03803
Max. Drawdown [%] -47.98013
Avg. Drawdown [%] -5.92585
Max. Drawdown Duration 584 days 00:00:00
Avg. Drawdown Duration 41 days 00:00:00
# Trades 66
Win Rate [%] 46.9697
Best Trade [%] 53.59595
Worst Trade [%] -18.39887
Avg. Trade [%] 2.53172
Max. Trade Duration 183 days 00:00:00
Avg. Trade Duration 46 days 00:00:00
Profit Factor 2.16795
Expectancy [%] 3.27481
SQN 1.07662
Kelly Criterion 0.15187
_strategy SmaCross
_equity_curve Eq...
_trades Size EntryB...
dtype: object
.. warning::
You may obtain different results for different strategy parameters.
E.g. if you use 50- and 200-bar SMA, the trading simulation will
begin on bar 201. The actual length of delay is equal to the lookback
period of the `Strategy.I` indicator which lags the most.
Obviously, this can affect results.
"""
data = _Data(self._data.copy(deep=False))
broker: _Broker = self._broker(data=data)
strategy: Strategy = self._strategy(broker, data, kwargs)
strategy.init()
data._update() # Strategy.init might have changed/added to data.df
# Indicators used in Strategy.next()
indicator_attrs = _strategy_indicators(strategy)
# Skip first few candles where indicators are still "warming up"
# +1 to have at least two entries available
start = 1 + _indicator_warmup_nbars(strategy)
# Disable "invalid value encountered in ..." warnings. Comparison
# np.nan >= 3 is not invalid; it's False.
with np.errstate(invalid='ignore'):
for i in _tqdm(range(start, len(self._data)), desc=self.run.__qualname__,
unit='bar', mininterval=2, miniters=100):
# Prepare data and indicators for `next` call
data._set_length(i + 1)
for attr, indicator in indicator_attrs:
# Slice indicator on the last dimension (case of 2d indicator)
setattr(strategy, attr, indicator[..., :i + 1])
# Handle orders processing and broker stuff
try:
broker.next()
except _OutOfMoneyError:
break
# Next tick, a moment before bar close
strategy.next()
else:
if self._finalize_trades is True:
# Close any remaining open trades so they produce some stats
for trade in reversed(broker.trades):
trade.close()
# HACK: Re-run broker one last time to handle close orders placed in the last
# strategy iteration. Use the same OHLC values as in the last broker iteration.
if start < len(self._data):
try_(broker.next, exception=_OutOfMoneyError)
elif len(broker.trades):
warnings.warn(
'Some trades remain open at the end of backtest. Use '
'`Backtest(..., finalize_trades=True)` to close them and '
'include them in stats.', stacklevel=2)
# Set data back to full length
# for future `indicator._opts['data'].index` calls to work
data._set_length(len(self._data))
equity = pd.Series(broker._equity).bfill().fillna(broker._cash).values
self._results = compute_stats(
trades=broker.closed_trades,
equity=equity,
ohlc_data=self._data,
risk_free_rate=0.0,
strategy_instance=strategy,
)
return self._results
def optimize(self, *,
maximize: Union[str, Callable[[pd.Series], float]] = 'SQN',
method: str = 'grid',
max_tries: Optional[Union[int, float]] = None,
constraint: Optional[Callable[[dict], bool]] = None,
return_heatmap: bool = False,
return_optimization: bool = False,
random_state: Optional[int] = None,
**kwargs) -> Union[pd.Series,
Tuple[pd.Series, pd.Series],
Tuple[pd.Series, pd.Series, dict]]:
"""
Optimize strategy parameters to an optimal combination.
Returns result `pd.Series` of the best run.
`maximize` is a string key from the
`backtesting.backtesting.Backtest.run`-returned results series,
or a function that accepts this series object and returns a number;
the higher the better. By default, the method maximizes
Van Tharp's [System Quality Number](https://google.com/search?q=System+Quality+Number).
`method` is the optimization method. Currently two methods are supported:
* `"grid"` which does an exhaustive (or randomized) search over the
cartesian product of parameter combinations, and
* `"sambo"` which finds close-to-optimal strategy parameters using
[model-based optimization], making at most `max_tries` evaluations.
[model-based optimization]: https://sambo-optimization.github.io
`max_tries` is the maximal number of strategy runs to perform.
If `method="grid"`, this results in randomized grid search.
If `max_tries` is a floating value between (0, 1], this sets the
number of runs to approximately that fraction of full grid space.
Alternatively, if integer, it denotes the absolute maximum number
of evaluations. If unspecified (default), grid search is exhaustive,
whereas for `method="sambo"`, `max_tries` is set to 200.
`constraint` is a function that accepts a dict-like object of
parameters (with values) and returns `True` when the combination
is admissible to test with. By default, any parameters combination
is considered admissible.
If `return_heatmap` is `True`, besides returning the result
series, an additional `pd.Series` is returned with a multiindex
of all admissible parameter combinations, which can be further
inspected or projected onto 2D to plot a heatmap
(see `backtesting.lib.plot_heatmaps()`).
If `return_optimization` is True and `method = 'sambo'`,
in addition to result series (and maybe heatmap), return raw
[`scipy.optimize.OptimizeResult`][OptimizeResult] for further
inspection, e.g. with [SAMBO]'s [plotting tools].
[OptimizeResult]: https://sambo-optimization.github.io/doc/sambo/#sambo.OptimizeResult
[SAMBO]: https://sambo-optimization.github.io
[plotting tools]: https://sambo-optimization.github.io/doc/sambo/plot.html
If you want reproducible optimization results, set `random_state`
to a fixed integer random seed.
Additional keyword arguments represent strategy arguments with
list-like collections of possible values. For example, the following
code finds and returns the "best" of the 7 admissible (of the
9 possible) parameter combinations:
best_stats = backtest.optimize(sma1=[5, 10, 15], sma2=[10, 20, 40],
constraint=lambda p: p.sma1 < p.sma2)
"""
if not kwargs:
raise ValueError('Need some strategy parameters to optimize')
maximize_key = None
if isinstance(maximize, str):
maximize_key = str(maximize)
if maximize not in dummy_stats().index:
raise ValueError('`maximize`, if str, must match a key in pd.Series '
'result of backtest.run()')
def maximize(stats: pd.Series, _key=maximize):
return stats[_key]
elif not callable(maximize):
raise TypeError('`maximize` must be str (a field of backtest.run() result '
'Series) or a function that accepts result Series '
'and returns a number; the higher the better')
assert callable(maximize), maximize
have_constraint = bool(constraint)
if constraint is None:
def constraint(_):
return True
elif not callable(constraint):
raise TypeError("`constraint` must be a function that accepts a dict "
"of strategy parameters and returns a bool whether "
"the combination of parameters is admissible or not")
assert callable(constraint), constraint
if method == 'skopt':
method = 'sambo'
warnings.warn('`Backtest.optimize(method="skopt")` is deprecated. Use `method="sambo"`.',
DeprecationWarning, stacklevel=2)
if return_optimization and method != 'sambo':
raise ValueError("return_optimization=True only valid if method='sambo'")
def _tuple(x):
return x if isinstance(x, Sequence) and not isinstance(x, str) else (x,)
for k, v in kwargs.items():
if len(_tuple(v)) == 0:
raise ValueError(f"Optimization variable '{k}' is passed no "
f"optimization values: {k}={v}")
class AttrDict(dict):
def __getattr__(self, item):
return self[item]
def _grid_size():
size = int(np.prod([len(_tuple(v)) for v in kwargs.values()]))
if size < 10_000 and have_constraint:
size = sum(1 for p in product(*(zip(repeat(k), _tuple(v))
for k, v in kwargs.items()))
if constraint(AttrDict(p)))
return size
def _optimize_grid() -> Union[pd.Series, Tuple[pd.Series, pd.Series]]:
rand = default_rng(random_state).random
grid_frac = (1 if max_tries is None else
max_tries if 0 < max_tries <= 1 else
max_tries / _grid_size())
param_combos = [dict(params) # back to dict so it pickles
for params in (AttrDict(params)
for params in product(*(zip(repeat(k), _tuple(v))
for k, v in kwargs.items())))
if constraint(params)
and rand() <= grid_frac]
if not param_combos:
raise ValueError('No admissible parameter combinations to test')
if len(param_combos) > 300:
warnings.warn(f'Searching for best of {len(param_combos)} configurations.',
stacklevel=2)
heatmap = pd.Series(np.nan,
name=maximize_key,
index=pd.MultiIndex.from_tuples(
[p.values() for p in param_combos],
names=next(iter(param_combos)).keys()))
from . import Pool
with Pool() as pool, \
SharedMemoryManager() as smm:
with patch(self, '_data', None):
bt = copy(self) # bt._data will be reassigned in _mp_task worker
results = _tqdm(
pool.imap(Backtest._mp_task,
((bt, smm.df2shm(self._data), params_batch)
for params_batch in _batch(param_combos))),
total=len(param_combos),
desc='Backtest.optimize'
)
for param_batch, result in zip(_batch(param_combos), results):
for params, stats in zip(param_batch, result):
if stats is not None:
heatmap[tuple(params.values())] = maximize(stats)
if pd.isnull(heatmap).all():
# No trade was made in any of the runs. Just make a random
# run so we get some, if empty, results
stats = self.run(**param_combos[0])
else:
best_params = heatmap.idxmax(skipna=True)
stats = self.run(**dict(zip(heatmap.index.names, best_params)))
if return_heatmap:
return stats, heatmap
return stats
def _optimize_sambo() -> Union[pd.Series,
Tuple[pd.Series, pd.Series],
Tuple[pd.Series, pd.Series, dict]]:
try:
import sambo
except ImportError:
raise ImportError("Need package 'sambo' for method='sambo'. pip install sambo") from None
nonlocal max_tries
max_tries = (200 if max_tries is None else
max(1, int(max_tries * _grid_size())) if 0 < max_tries <= 1 else
max_tries)
dimensions = []
for key, values in kwargs.items():
values = np.asarray(values)
if values.dtype.kind in 'mM': # timedelta, datetime64
# these dtypes are unsupported in SAMBO, so convert to raw int
# TODO: save dtype and convert back later
values = values.astype(np.int64)
if values.dtype.kind in 'iumM':
dimensions.append((values.min(), values.max() + 1))
elif values.dtype.kind == 'f':
dimensions.append((values.min(), values.max()))
else:
dimensions.append(values.tolist())
# Avoid recomputing re-evaluations
@lru_cache()
def memoized_run(tup):
nonlocal maximize, self
stats = self.run(**dict(tup))
return -maximize(stats)
progress = iter(_tqdm(repeat(None), total=max_tries, leave=False,
desc=self.optimize.__qualname__, mininterval=2))
_names = tuple(kwargs.keys())
def objective_function(x):
nonlocal progress, memoized_run, constraint, _names
next(progress)
value = memoized_run(tuple(zip(_names, x)))
return 0 if np.isnan(value) else value
def cons(x):
nonlocal constraint, _names
return constraint(AttrDict(zip(_names, x)))
res = sambo.minimize(
fun=objective_function,
bounds=dimensions,
constraints=cons,
max_iter=max_tries,
method='sceua',
rng=random_state)
stats = self.run(**dict(zip(kwargs.keys(), res.x)))
output = [stats]
if return_heatmap:
heatmap = pd.Series(dict(zip(map(tuple, res.xv), -res.funv)),
name=maximize_key)
heatmap.index.names = kwargs.keys()
heatmap.sort_index(inplace=True)
output.append(heatmap)
if return_optimization:
output.append(res)
return stats if len(output) == 1 else tuple(output)
if method == 'grid':
output = _optimize_grid()
elif method in ('sambo', 'skopt'):
output = _optimize_sambo()
else:
raise ValueError(f"Method should be 'grid' or 'sambo', not {method!r}")
return output
@staticmethod
def _mp_task(arg):
bt, data_shm, params_batch = arg
bt._data, shm = SharedMemoryManager.shm2df(data_shm)
try:
return [stats.filter(regex='^[^_]') if stats['# Trades'] else None
for stats in (bt.run(**params)
for params in params_batch)]
finally:
for shmem in shm:
shmem.close()
def plot(self, *, results: pd.Series = None, filename=None, plot_width=None,
plot_equity=True, plot_return=False, plot_pl=True,
plot_volume=True, plot_drawdown=False, plot_trades=True,
smooth_equity=False, relative_equity=True,
superimpose: Union[bool, str] = True,
resample=True, reverse_indicators=False,
show_legend=True, open_browser=True):
"""
Plot the progression of the last backtest run.
If `results` is provided, it should be a particular result
`pd.Series` such as returned by
`backtesting.backtesting.Backtest.run` or
`backtesting.backtesting.Backtest.optimize`, otherwise the last
run's results are used.
`filename` is the path to save the interactive HTML plot to.
By default, a strategy/parameter-dependent file is created in the
current working directory.
`plot_width` is the width of the plot in pixels. If None (default),
the plot is made to span 100% of browser width. The height is
currently non-adjustable.
If `plot_equity` is `True`, the resulting plot will contain
an equity (initial cash plus assets) graph section. This is the same
as `plot_return` plus initial 100%.
If `plot_return` is `True`, the resulting plot will contain
a cumulative return graph section. This is the same
as `plot_equity` minus initial 100%.
If `plot_pl` is `True`, the resulting plot will contain
a profit/loss (P/L) indicator section.
If `plot_volume` is `True`, the resulting plot will contain
a trade volume section.
If `plot_drawdown` is `True`, the resulting plot will contain
a separate drawdown graph section.
If `plot_trades` is `True`, the stretches between trade entries
and trade exits are marked by hash-marked tractor beams.
If `smooth_equity` is `True`, the equity graph will be
interpolated between fixed points at trade closing times,
unaffected by any interim asset volatility.
If `relative_equity` is `True`, scale and label equity graph axis
with return percent, not absolute cash-equivalent values.
If `superimpose` is `True`, superimpose larger-timeframe candlesticks
over the original candlestick chart. Default downsampling rule is:
monthly for daily data, daily for hourly data, hourly for minute data,
and minute for (sub-)second data.
`superimpose` can also be a valid [Pandas offset string],
such as `'5T'` or `'5min'`, in which case this frequency will be
used to superimpose.
Note, this only works for data with a datetime index.
If `resample` is `True`, the OHLC data is resampled in a way that
makes the upper number of candles for Bokeh to plot limited to 10_000.
This may, in situations of overabundant data,
improve plot's interactive performance and avoid browser's
`Javascript Error: Maximum call stack size exceeded` or similar.
Equity & dropdown curves and individual trades data is,
likewise, [reasonably _aggregated_][TRADES_AGG].
`resample` can also be a [Pandas offset string],
such as `'5T'` or `'5min'`, in which case this frequency will be
used to resample, overriding above numeric limitation.
Note, all this only works for data with a datetime index.
If `reverse_indicators` is `True`, the indicators below the OHLC chart
are plotted in reverse order of declaration.
[Pandas offset string]: \
https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects
[TRADES_AGG]: lib.html#backtesting.lib.TRADES_AGG
If `show_legend` is `True`, the resulting plot graphs will contain
labeled legends.
If `open_browser` is `True`, the resulting `filename` will be
opened in the default web browser.
"""
if results is None:
if self._results is None:
raise RuntimeError('First issue `backtest.run()` to obtain results.')
results = self._results
return plot(
results=results,
df=self._data,
indicators=results._strategy._indicators,
filename=filename,
plot_width=plot_width,
plot_equity=plot_equity,
plot_return=plot_return,
plot_pl=plot_pl,
plot_volume=plot_volume,
plot_drawdown=plot_drawdown,
plot_trades=plot_trades,
smooth_equity=smooth_equity,
relative_equity=relative_equity,
superimpose=superimpose,
resample=resample,
reverse_indicators=reverse_indicators,
show_legend=show_legend,
open_browser=open_browser)
# NOTE: Don't put anything public below this __all__ list
__all__ = [getattr(v, '__name__', k)
for k, v in globals().items() # export
if ((callable(v) and getattr(v, '__module__', None) == __name__ or # callables from this module; getattr for Python 3.9; # noqa: E501
k.isupper()) and # or CONSTANTS
not getattr(v, '__name__', k).startswith('_'))] # neither marked internal
# NOTE: Don't put anything public below here. See above.
================================================
FILE: backtesting/lib.py
================================================
"""
Collection of common building blocks, helper auxiliary functions and
composable strategy classes for reuse.
Intended for simple missing-link procedures, not reinventing
of better-suited, state-of-the-art, fast libraries,
such as TA-Lib, Tulipy, PyAlgoTrade, NumPy, SciPy ...
Please raise ideas for additions to this collection on the [issue tracker].
[issue tracker]: https://github.com/kernc/backtesting.py
"""
from __future__ import annotations
import warnings
from collections import OrderedDict
from inspect import currentframe
from itertools import chain, compress, count
from numbers import Number
from typing import Callable, Generator, Optional, Sequence, Union
import numpy as np
import pandas as pd
from ._plotting import plot_heatmaps as _plot_heatmaps
from ._stats import compute_stats as _compute_stats
from ._util import SharedMemoryManager, _Array, _as_str, _batch, _tqdm, patch
from .backtesting import Backtest, Strategy
__pdoc__ = {}
OHLCV_AGG = OrderedDict((
('Open', 'first'),
('High', 'max'),
('Low', 'min'),
('Close', 'last'),
('Volume', 'sum'),
))
"""Dictionary of rules for aggregating resampled OHLCV data frames,
e.g.
df.resample('4H', label='right').agg(OHLCV_AGG).dropna()
"""
TRADES_AGG = OrderedDict((
('Size', 'sum'),
('EntryBar', 'first'),
('ExitBar', 'last'),
('EntryPrice', 'mean'),
('ExitPrice', 'mean'),
('PnL', 'sum'),
('ReturnPct', 'mean'),
('EntryTime', 'first'),
('ExitTime', 'last'),
('Duration', 'sum'),
))
"""Dictionary of rules for aggregating resampled trades data,
e.g.
stats['_trades'].resample('1D', on='ExitTime',
label='right').agg(TRADES_AGG)
"""
_EQUITY_AGG = {
'Equity': 'last',
'DrawdownPct': 'max',
'DrawdownDuration': 'max',
}
def barssince(condition: Sequence[bool], default=np.inf) -> int:
"""
Return the number of bars since `condition` sequence was last `True`,
or if never, return `default`.
>>> barssince(self.data.Close > self.data.Open)
3
"""
return next(compress(range(len(condition)), reversed(condition)), default)
def cross(series1: Sequence, series2: Sequence) -> bool:
"""
Return `True` if `series1` and `series2` just crossed
(above or below) each other.
>>> cross(self.data.Close, self.sma)
True
"""
return crossover(series1, series2) or crossover(series2, series1)
def crossover(series1: Sequence, series2: Sequence) -> bool:
"""
Return `True` if `series1` just crossed over (above)
`series2`.
>>> crossover(self.data.Close, self.sma)
True
"""
series1 = (
series1.values if isinstance(series1, pd.Series) else
(series1, series1) if isinstance(series1, Number) else
series1)
series2 = (
series2.values if isinstance(series2, pd.Series) else
(series2, series2) if isinstance(series2, Number) else
series2)
try:
return series1[-2] < series2[-2] and series1[-1] > series2[-1] # type: ignore
except IndexError:
return False
def plot_heatmaps(heatmap: pd.Series,
agg: Union[str, Callable] = 'max',
*,
ncols: int = 3,
plot_width: int = 1200,
filename: str = '',
open_browser: bool = True):
"""
Plots a grid of heatmaps, one for every pair of parameters in `heatmap`.
See example in [the tutorial].
[the tutorial]: https://kernc.github.io/backtesting.py/doc/examples/Parameter%20Heatmap%20&%20Optimization.html#plot-heatmap # noqa: E501
`heatmap` is a Series as returned by
`backtesting.backtesting.Backtest.optimize` when its parameter
`return_heatmap=True`.
When projecting the n-dimensional (n > 2) heatmap onto 2D, the values are
aggregated by 'max' function by default. This can be tweaked
with `agg` parameter, which accepts any argument pandas knows
how to aggregate by.
.. todo::
Lay heatmaps out lower-triangular instead of in a simple grid.
Like [`sambo.plot.plot_objective()`][plot_objective] does.
[plot_objective]: \
https://sambo-optimization.github.io/doc/sambo/plot.html#sambo.plot.plot_objective
"""
return _plot_heatmaps(heatmap, agg, ncols, filename, plot_width, open_browser)
def quantile(series: Sequence, quantile: Union[None, float] = None):
"""
If `quantile` is `None`, return the quantile _rank_ of the last
value of `series` wrt former series values.
If `quantile` is a value between 0 and 1, return the _value_ of
`series` at this quantile. If used to working with percentiles, just
divide your percentile amount with 100 to obtain quantiles.
>>> quantile(self.data.Close[-20:], .1)
162.130
>>> quantile(self.data.Close)
0.13
"""
if quantile is None:
try:
last, series = series[-1], series[:-1]
return np.mean(series < last)
except IndexError:
return np.nan
assert 0 <= quantile <= 1, "quantile must be within [0, 1]"
return np.nanpercentile(series, quantile * 100)
def compute_stats(
*,
stats: pd.Series,
data: pd.DataFrame,
trades: pd.DataFrame = None,
risk_free_rate: float = 0.) -> pd.Series:
"""
(Re-)compute strategy
gitextract_k3y034qj/ ├── .codecov.yml ├── .github/ │ ├── FUNDING.yml │ ├── ISSUE_TEMPLATE/ │ │ ├── 1-bug.yml │ │ ├── 2-enh.yml │ │ └── config.yml │ ├── deploy-gh-pages.sh │ ├── issue_template.md │ └── workflows/ │ ├── ci.yml │ └── deploy-docs.yml ├── .gitignore ├── CHANGELOG.md ├── CONTRIBUTING.md ├── LICENSE.md ├── MANIFEST.in ├── README.md ├── backtesting/ │ ├── __init__.py │ ├── _plotting.py │ ├── _stats.py │ ├── _util.py │ ├── autoscale_cb.js │ ├── backtesting.py │ ├── lib.py │ └── test/ │ ├── BTCUSD.csv │ ├── EURUSD.csv │ ├── GOOG.csv │ ├── __init__.py │ ├── __main__.py │ └── _test.py ├── doc/ │ ├── README.md │ ├── alternatives.md │ ├── build.sh │ ├── examples/ │ │ ├── Multiple Time Frames.ipynb │ │ ├── Multiple Time Frames.py │ │ ├── Parameter Heatmap & Optimization.ipynb │ │ ├── Parameter Heatmap & Optimization.py │ │ ├── Quick Start User Guide.ipynb │ │ ├── Quick Start User Guide.py │ │ ├── Strategies Library.ipynb │ │ ├── Strategies Library.py │ │ ├── Trading with Machine Learning.ipynb │ │ └── Trading with Machine Learning.py │ ├── pdoc_template/ │ │ ├── config.mako │ │ ├── credits.mako │ │ ├── head.mako │ │ └── logo.mako │ └── scripts/ │ ├── ipython_config.py │ ├── logo.py │ └── strip_yaml.awk ├── pyproject.toml ├── requirements.txt ├── setup.cfg └── setup.py
SYMBOL INDEX (300 symbols across 13 files)
FILE: backtesting/__init__.py
function Pool (line 75) | def Pool(processes=None, initializer=None, initargs=()):
FILE: backtesting/_plotting.py
function set_bokeh_output (line 63) | def set_bokeh_output(notebook=False):
function _windos_safe_filename (line 73) | def _windos_safe_filename(filename):
function _bokeh_reset (line 79) | def _bokeh_reset(filename=None):
function _add_popcon (line 90) | def _add_popcon():
function _watermark (line 94) | def _watermark(fig: _figure):
function colorgen (line 102) | def colorgen():
function lightness (line 106) | def lightness(color, lightness=.94):
function _maybe_resample_data (line 117) | def _maybe_resample_data(resample_rule, df, indicators, equity_data, tra...
function plot (line 190) | def plot(*, results: pd.Series,
function plot_heatmaps (line 721) | def plot_heatmaps(heatmap: pd.Series, agg: Union[Callable, str], ncols: ...
FILE: backtesting/_stats.py
function compute_drawdown_duration_peaks (line 14) | def compute_drawdown_duration_peaks(dd: pd.Series):
function geometric_mean (line 30) | def geometric_mean(returns: pd.Series) -> float:
function compute_stats (line 37) | def compute_stats(
class _Stats (line 192) | class _Stats(pd.Series):
method __repr__ (line 193) | def __repr__(self):
function dummy_stats (line 203) | def dummy_stats():
FILE: backtesting/_util.py
function _tqdm (line 22) | def _tqdm(seq, **_):
function try_ (line 26) | def try_(lazy_func, default=None, exception=Exception):
function patch (line 34) | def patch(obj, attr, newvalue):
function _as_str (line 47) | def _as_str(value) -> str:
function _as_list (line 62) | def _as_list(value) -> List:
function _batch (line 68) | def _batch(seq):
function _data_period (line 75) | def _data_period(index) -> Union[pd.Timedelta, Number]:
function _strategy_indicators (line 81) | def _strategy_indicators(strategy):
function _indicator_warmup_nbars (line 87) | def _indicator_warmup_nbars(strategy):
class _Array (line 96) | class _Array(np.ndarray):
method __new__ (line 101) | def __new__(cls, array, *, name=None, **kwargs):
method __array_finalize__ (line 107) | def __array_finalize__(self, obj):
method __reduce__ (line 114) | def __reduce__(self):
method __setstate__ (line 118) | def __setstate__(self, state):
method __bool__ (line 122) | def __bool__(self):
method __float__ (line 128) | def __float__(self):
method to_series (line 134) | def to_series(self):
method s (line 139) | def s(self) -> pd.Series:
method df (line 145) | def df(self) -> pd.DataFrame:
class _Indicator (line 152) | class _Indicator(_Array):
class _Data (line 156) | class _Data:
method __init__ (line 163) | def __init__(self, df: pd.DataFrame):
method __getitem__ (line 171) | def __getitem__(self, item):
method __getattr__ (line 174) | def __getattr__(self, item):
method _set_length (line 180) | def _set_length(self, length):
method _update (line 184) | def _update(self):
method __repr__ (line 191) | def __repr__(self):
method __len__ (line 197) | def __len__(self):
method df (line 201) | def df(self) -> pd.DataFrame:
method pip (line 207) | def pip(self) -> float:
method __get_array (line 213) | def __get_array(self, key) -> _Array:
method Open (line 220) | def Open(self) -> _Array:
method High (line 224) | def High(self) -> _Array:
method Low (line 228) | def Low(self) -> _Array:
method Close (line 232) | def Close(self) -> _Array:
method Volume (line 236) | def Volume(self) -> _Array:
method index (line 240) | def index(self) -> pd.DatetimeIndex:
method __getstate__ (line 244) | def __getstate__(self):
method __setstate__ (line 247) | def __setstate__(self, state):
class SharedMemory (line 254) | class SharedMemory(_mpshm.SharedMemory):
method __init__ (line 258) | def __init__(self, *args, track: bool = True, **kwargs):
method unlink (line 266) | def unlink(self):
class SharedMemoryManager (line 273) | class SharedMemoryManager:
method __init__ (line 278) | def __init__(self, create=False) -> None:
method SharedMemory (line 282) | def SharedMemory(self, *, name=None, create=False, size=0, track=True):
method __enter__ (line 290) | def __enter__(self):
method __exit__ (line 293) | def __exit__(self, *args, **kwargs):
method arr2shm (line 304) | def arr2shm(self, vals):
method df2shm (line 315) | def df2shm(self, df):
method shm2s (line 322) | def shm2s(shm, shape, dtype) -> pd.Series:
method shm2df (line 330) | def shm2df(data_shm):
FILE: backtesting/backtesting.py
class Strategy (line 41) | class Strategy(metaclass=ABCMeta):
method __init__ (line 49) | def __init__(self, broker, data, params):
method __repr__ (line 55) | def __repr__(self):
method __str__ (line 58) | def __str__(self):
method _check_params (line 65) | def _check_params(self, params):
method I (line 77) | def I(self, # noqa: E743
method init (line 185) | def init(self):
method next (line 200) | def next(self):
class __FULL_EQUITY (line 215) | class __FULL_EQUITY(float): # noqa: N801
method __repr__ (line 216) | def __repr__(self): return '.9999' # noqa: E704
method buy (line 219) | def buy(self, *,
method sell (line 242) | def sell(self, *,
method equity (line 274) | def equity(self) -> float:
method data (line 279) | def data(self) -> _Data:
method position (line 308) | def position(self) -> 'Position':
method orders (line 313) | def orders(self) -> 'Tuple[Order, ...]':
method trades (line 318) | def trades(self) -> 'Tuple[Trade, ...]':
method closed_trades (line 323) | def closed_trades(self) -> 'Tuple[Trade, ...]':
class Position (line 328) | class Position:
method __init__ (line 338) | def __init__(self, broker: '_Broker'):
method __bool__ (line 341) | def __bool__(self):
method size (line 345) | def size(self) -> float:
method pl (line 350) | def pl(self) -> float:
method pl_pct (line 355) | def pl_pct(self) -> float:
method is_long (line 361) | def is_long(self) -> bool:
method is_short (line 366) | def is_short(self) -> bool:
method close (line 370) | def close(self, portion: float = 1.):
method __repr__ (line 377) | def __repr__(self):
class _OutOfMoneyError (line 381) | class _OutOfMoneyError(Exception):
class Order (line 385) | class Order:
method __init__ (line 400) | def __init__(self, broker: '_Broker',
method _replace (line 418) | def _replace(self, **kwargs):
method __repr__ (line 423) | def __repr__(self):
method cancel (line 435) | def cancel(self):
method size (line 450) | def size(self) -> float:
method limit (line 461) | def limit(self) -> Optional[float]:
method stop (line 472) | def stop(self) -> Optional[float]:
method sl (line 482) | def sl(self) -> Optional[float]:
method tp (line 491) | def tp(self) -> Optional[float]:
method parent_trade (line 500) | def parent_trade(self):
method tag (line 504) | def tag(self):
method is_long (line 516) | def is_long(self):
method is_short (line 521) | def is_short(self):
method is_contingent (line 526) | def is_contingent(self):
class Trade (line 542) | class Trade:
method __init__ (line 547) | def __init__(self, broker: '_Broker', size: int, entry_price: float, e...
method __repr__ (line 559) | def __repr__(self):
method _replace (line 564) | def _replace(self, **kwargs):
method _copy (line 569) | def _copy(self, **kwargs):
method close (line 572) | def close(self, portion: float = 1.):
method size (line 583) | def size(self):
method entry_price (line 588) | def entry_price(self) -> float:
method exit_price (line 593) | def exit_price(self) -> Optional[float]:
method entry_bar (line 598) | def entry_bar(self) -> int:
method exit_bar (line 603) | def exit_bar(self) -> Optional[int]:
method tag (line 611) | def tag(self):
method _sl_order (line 624) | def _sl_order(self):
method _tp_order (line 628) | def _tp_order(self):
method entry_time (line 634) | def entry_time(self) -> Union[pd.Timestamp, int]:
method exit_time (line 639) | def exit_time(self) -> Optional[Union[pd.Timestamp, int]]:
method is_long (line 646) | def is_long(self):
method is_short (line 651) | def is_short(self):
method pl (line 656) | def pl(self):
method pl_pct (line 665) | def pl_pct(self):
method value (line 675) | def value(self):
method sl (line 683) | def sl(self):
method sl (line 694) | def sl(self, price: float):
method tp (line 698) | def tp(self):
method tp (line 709) | def tp(self, price: float):
method __set_contingent (line 712) | def __set_contingent(self, type, price):
class _Broker (line 725) | class _Broker:
method __init__ (line 726) | def __init__(self, *, data, cash, spread, commission, margin,
method _commission_func (line 758) | def _commission_func(self, order_size, price):
method __repr__ (line 761) | def __repr__(self):
method new_order (line 764) | def new_order(self,
method last_price (line 815) | def last_price(self) -> float:
method _adjusted_price (line 819) | def _adjusted_price(self, size=None, price=None) -> float:
method equity (line 827) | def equity(self) -> float:
method margin_available (line 831) | def margin_available(self) -> float:
method next (line 836) | def next(self):
method _process_orders (line 853) | def _process_orders(self):
method _reduce_trade (line 1030) | def _reduce_trade(self, trade: Trade, price: float, size: float, time_...
method _close_trade (line 1052) | def _close_trade(self, trade: Trade, price: float, time_index: int):
method _open_trade (line 1070) | def _open_trade(self, price: float, size: int,
class Backtest (line 1083) | class Backtest:
method __init__ (line 1167) | def __init__(self,
method run (line 1243) | def run(self, **kwargs) -> pd.Series:
method optimize (line 1358) | def optimize(self, *,
method _mp_task (line 1619) | def _mp_task(arg):
method plot (line 1630) | def plot(self, *, results: pd.Series = None, filename=None, plot_width...
FILE: backtesting/lib.py
function barssince (line 73) | def barssince(condition: Sequence[bool], default=np.inf) -> int:
function cross (line 84) | def cross(series1: Sequence, series2: Sequence) -> bool:
function crossover (line 96) | def crossover(series1: Sequence, series2: Sequence) -> bool:
function plot_heatmaps (line 118) | def plot_heatmaps(heatmap: pd.Series,
function quantile (line 150) | def quantile(series: Sequence, quantile: Union[None, float] = None):
function compute_stats (line 174) | def compute_stats(
function resample_apply (line 207) | def resample_apply(rule: str,
function random_ohlc_data (line 338) | def random_ohlc_data(example_data: pd.DataFrame, *,
class SignalStrategy (line 375) | class SignalStrategy(Strategy):
method set_signal (line 400) | def set_signal(self, entry_size: Sequence[float],
method next (line 427) | def next(self):
class TrailingStrategy (line 447) | class TrailingStrategy(Strategy):
method init (line 462) | def init(self):
method set_atr_periods (line 466) | def set_atr_periods(self, periods: int = 100):
method set_trailing_sl (line 476) | def set_trailing_sl(self, n_atr: float = 6):
method set_trailing_pct (line 483) | def set_trailing_pct(self, pct: float = .05):
method next (line 496) | def next(self):
class FractionalBacktest (line 509) | class FractionalBacktest(Backtest):
method __init__ (line 525) | def __init__(self,
method run (line 546) | def run(self, **kwargs) -> pd.Series:
class MultiBacktest (line 568) | class MultiBacktest:
method __init__ (line 581) | def __init__(self, df_list, strategy_cls, **kwargs):
method run (line 586) | def run(self, **kwargs):
method _mp_task_run (line 607) | def _mp_task_run(args):
method optimize (line 618) | def optimize(self, **kwargs) -> pd.DataFrame:
FILE: backtesting/test/__init__.py
function _read_file (line 8) | def _read_file(filename):
function SMA (line 25) | def SMA(arr: pd.Series, n: int) -> pd.Series:
FILE: backtesting/test/_test.py
function _tempfile (line 40) | def _tempfile():
function chdir (line 48) | def chdir(path):
class SmaCross (line 57) | class SmaCross(Strategy):
method init (line 62) | def init(self):
method next (line 66) | def next(self):
class _S (line 75) | class _S(Strategy):
method init (line 76) | def init(self):
class TestBacktest (line 80) | class TestBacktest(TestCase):
method test_run (line 81) | def test_run(self):
method test_run_invalid_param (line 85) | def test_run_invalid_param(self):
method test_run_speed (line 89) | def test_run_speed(self):
method test_data_missing_columns (line 96) | def test_data_missing_columns(self):
method test_data_nan_columns (line 102) | def test_data_nan_columns(self):
method test_data_extra_columns (line 108) | def test_data_extra_columns(self):
method test_data_invalid (line 124) | def test_data_invalid(self):
method test_assertions (line 130) | def test_assertions(self):
method test_broker_params (line 229) | def test_broker_params(self):
method test_spread_commission (line 234) | def test_spread_commission(self):
method test_commissions (line 265) | def test_commissions(self):
method test_dont_overwrite_data (line 286) | def test_dont_overwrite_data(self):
method test_strategy_abstract (line 294) | def test_strategy_abstract(self):
method test_strategy_str (line 300) | def test_strategy_str(self):
method test_compute_drawdown (line 305) | def test_compute_drawdown(self):
method test_compute_stats (line 311) | def test_compute_stats(self):
method test_compute_stats_bordercase (line 376) | def test_compute_stats_bordercase(self):
method test_trade_enter_hit_sl_on_same_day (line 409) | def test_trade_enter_hit_sl_on_same_day(self):
method test_stop_price_between_sl_tp (line 427) | def test_stop_price_between_sl_tp(self):
method test_position_close_portion (line 436) | def test_position_close_portion(self):
method test_close_orders_from_last_strategy_iteration (line 451) | def test_close_orders_from_last_strategy_iteration(self):
method test_check_adjusted_price_when_placing_order (line 463) | def test_check_adjusted_price_when_placing_order(self):
class TestStrategy (line 471) | class TestStrategy(TestCase):
method _Backtest (line 473) | def _Backtest(strategy_coroutine, data=SHORT_DATA, **kwargs):
method test_position (line 483) | def test_position(self):
method test_broker_hedging (line 505) | def test_broker_hedging(self):
method test_broker_exclusive_orders (line 516) | def test_broker_exclusive_orders(self):
method test_trade_multiple_close (line 528) | def test_trade_multiple_close(self):
method test_close_trade_leaves_needsize_0 (line 539) | def test_close_trade_leaves_needsize_0(self):
method test_stop_limit_order_price_is_stop_price (line 549) | def test_stop_limit_order_price_is_stop_price(self):
method test_autoclose_trades_on_finish (line 558) | def test_autoclose_trades_on_finish(self):
method test_order_tag (line 565) | def test_order_tag(self):
class TestOptimize (line 578) | class TestOptimize(TestCase):
method test_optimize (line 579) | def test_optimize(self):
method test_method_sambo (line 608) | def test_method_sambo(self):
method test_max_tries (line 625) | def test_max_tries(self):
method test_optimize_invalid_param (line 642) | def test_optimize_invalid_param(self):
method test_optimize_no_trades (line 647) | def test_optimize_no_trades(self):
method test_optimize_speed (line 652) | def test_optimize_speed(self):
class TestPlot (line 662) | class TestPlot(TestCase):
method test_plot_before_run (line 663) | def test_plot_before_run(self):
method test_file_size (line 667) | def test_file_size(self):
method test_params (line 674) | def test_params(self):
method test_hide_legend (line 693) | def test_hide_legend(self):
method test_resolutions (line 701) | def test_resolutions(self):
method test_range_axis (line 710) | def test_range_axis(self):
method test_preview (line 726) | def test_preview(self):
method test_wellknown (line 744) | def test_wellknown(self):
method test_resample (line 774) | def test_resample(self):
method test_indicator_name (line 790) | def test_indicator_name(self):
method test_indicator_color (line 821) | def test_indicator_color(self):
method test_indicator_scatter (line 838) | def test_indicator_scatter(self):
class TestLib (line 855) | class TestLib(TestCase):
method test_barssince (line 856) | def test_barssince(self):
method test_cross (line 861) | def test_cross(self):
method test_crossover (line 866) | def test_crossover(self):
method test_quantile (line 873) | def test_quantile(self):
method test_resample_apply (line 877) | def test_resample_apply(self):
method test_plot_heatmaps (line 898) | def test_plot_heatmaps(self):
method test_random_ohlc_data (line 912) | def test_random_ohlc_data(self):
method test_compute_stats (line 919) | def test_compute_stats(self):
method test_SignalStrategy (line 931) | def test_SignalStrategy(self):
method test_TrailingStrategy (line 941) | def test_TrailingStrategy(self):
method test_FractionalBacktest (line 958) | def test_FractionalBacktest(self):
method test_MultiBacktest (line 968) | def test_MultiBacktest(self):
class TestUtil (line 986) | class TestUtil(TestCase):
method test_as_str (line 987) | def test_as_str(self):
method test_patch (line 1007) | def test_patch(self):
method test_pandas_accessors (line 1016) | def test_pandas_accessors(self):
method test_indicators_picklable (line 1032) | def test_indicators_picklable(self):
class TestDocs (line 1040) | class TestDocs(TestCase):
method test_examples (line 1045) | def test_examples(self):
method test_backtest_run_docstring_contains_stats_keys (line 1055) | def test_backtest_run_docstring_contains_stats_keys(self):
method test_readme_contains_stats_keys (line 1060) | def test_readme_contains_stats_keys(self):
class TestRegressions (line 1069) | class TestRegressions(TestCase):
method test_gh_521 (line 1070) | def test_gh_521(self):
method test_stats_annualized (line 1082) | def test_stats_annualized(self):
method test_cancel_orders (line 1087) | def test_cancel_orders(self):
method test_trade_on_close_closes_trades_on_close (line 1098) | def test_trade_on_close_closes_trades_on_close(self):
method test_trades_dates_match_prices (line 1133) | def test_trades_dates_match_prices(self):
method test_sl_always_before_tp (line 1139) | def test_sl_always_before_tp(self):
method test_stop_entry_and_tp_in_same_bar (line 1153) | def test_stop_entry_and_tp_in_same_bar(self):
method test_optimize_datetime_index_with_timezone (line 1164) | def test_optimize_datetime_index_with_timezone(self):
method test_sl_tp_values_in_trades_df (line 1170) | def test_sl_tp_values_in_trades_df(self):
FILE: doc/examples/Multiple Time Frames.py
function SMA (line 40) | def SMA(array, n):
function RSI (line 45) | def RSI(array, n):
class System (line 74) | class System(Strategy):
method init (line 79) | def init(self):
method next (line 95) | def next(self):
FILE: doc/examples/Parameter Heatmap & Optimization.py
class Sma4Cross (line 45) | class Sma4Cross(Strategy):
method init (line 51) | def init(self):
method next (line 57) | def next(self):
FILE: doc/examples/Quick Start User Guide.py
function SMA (line 64) | def SMA(values, n):
class SmaCross (line 94) | class SmaCross(Strategy):
method init (line 100) | def init(self):
method next (line 105) | def next(self):
FILE: doc/examples/Strategies Library.py
class SmaCross (line 53) | class SmaCross(SignalStrategy,
method init (line 58) | def init(self):
FILE: doc/examples/Trading with Machine Learning.py
function BBANDS (line 45) | def BBANDS(data, n_lookback, n_std):
function get_X (line 98) | def get_X(data):
function get_y (line 103) | def get_y(data):
function get_clean_Xy (line 112) | def get_clean_Xy(df):
class MLTrainOnceStrategy (line 164) | class MLTrainOnceStrategy(Strategy):
method init (line 167) | def init(self):
method next (line 182) | def next(self):
class MLWalkForwardStrategy (line 235) | class MLWalkForwardStrategy(MLTrainOnceStrategy):
method next (line 236) | def next(self):
Condensed preview — 52 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,945K chars).
[
{
"path": ".codecov.yml",
"chars": 298,
"preview": "comment: off\ncoverage:\n range: 75..95\n precision: 0\n status:\n patch:\n default:\n target: 90\n project"
},
{
"path": ".github/FUNDING.yml",
"chars": 14,
"preview": "github: kernc\n"
},
{
"path": ".github/ISSUE_TEMPLATE/1-bug.yml",
"chars": 3267,
"preview": "name: Bug report\ndescription: File a new bug report. Please use the search\nbody:\n - type: markdown\n attributes:\n "
},
{
"path": ".github/ISSUE_TEMPLATE/2-enh.yml",
"chars": 1955,
"preview": "name: Enhancement proposal\ndescription: Describe the enhancement you'd like to see\nbody:\n - type: markdown\n attribut"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 511,
"preview": "blank_issues_enabled: true\ncontact_links:\n - name: Reference documentation\n url: https://kernc.github.io/backtesting"
},
{
"path": ".github/deploy-gh-pages.sh",
"chars": 969,
"preview": "#!/bin/bash\nset -eu\n\nif [ ! -d doc/build ]; then\n echo 'Error: invalid directory. Deploy from repo root.'\n exit 1\n"
},
{
"path": ".github/issue_template.md",
"chars": 429,
"preview": "### Expected Behavior\n\n...\n\n### Actual Behavior\n\n<!-- \n In case of a bug, attach full exception traceback.\n Please"
},
{
"path": ".github/workflows/ci.yml",
"chars": 2102,
"preview": "name: CI\non:\n push: { branches: [master] }\n pull_request: { branches: [master] }\n schedule: [ cron: '2 2 * * 6' ] # "
},
{
"path": ".github/workflows/deploy-docs.yml",
"chars": 753,
"preview": "name: Deploy docs\non:\n push:\n tags: ['[0-9]+.[0-9]+.*']\n\njobs:\n deploy:\n name: Deploy\n runs-on: ubuntu-latest"
},
{
"path": ".gitignore",
"chars": 183,
"preview": "*.py[cod]\n*.html\n*.png\n_version.py\n\n*.egg-info\n.eggs/*\n__pycache__/*\ndist/*\n\n.coverage\n.coverage.*\nhtmlcov/*\n\ndoc/build/"
},
{
"path": "CHANGELOG.md",
"chars": 8346,
"preview": "What's New\n==========\n\nThese were the major changes contributing to each release:\n\n### 0.x.x\n\n### 0.6.5\n(2025-07-30)\n\n* "
},
{
"path": "CONTRIBUTING.md",
"chars": 2784,
"preview": "Contributing guidelines\n=======================\n\nIssues\n------\nBefore reporting an issue, see if a similar issue is alre"
},
{
"path": "LICENSE.md",
"chars": 34283,
"preview": "### GNU AFFERO GENERAL PUBLIC LICENSE\n\nVersion 3, 19 November 2007\n\nCopyright (C) 2007 Free Software Foundation, Inc.\n<h"
},
{
"path": "MANIFEST.in",
"chars": 79,
"preview": "exclude MANIFEST.in\nexclude .*\n\nrecursive-exclude .* *\nrecursive-exclude doc *\n"
},
{
"path": "README.md",
"chars": 4873,
"preview": "[](https://kernc.github.io/backtesting.py/)\n\nBacktesting.py\n==============\n[{: height=263}\n\n## Manuals\n\n* [**Quick Start U"
},
{
"path": "backtesting/_plotting.py",
"chars": 31847,
"preview": "from __future__ import annotations\n\nimport os\nimport re\nimport sys\nimport warnings\nfrom colorsys import hls_to_rgb, rgb_"
},
{
"path": "backtesting/_stats.py",
"chars": 9863,
"preview": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, List, Union, cast\n\nimport numpy as np\nimport panda"
},
{
"path": "backtesting/_util.py",
"chars": 10552,
"preview": "from __future__ import annotations\n\nimport os\nimport sys\nimport warnings\nfrom contextlib import contextmanager\nfrom func"
},
{
"path": "backtesting/autoscale_cb.js",
"chars": 1201,
"preview": "if (!window._bt_scale_range) {\n window._bt_scale_range = function (range, min, max, pad) {\n \"use strict\";\n "
},
{
"path": "backtesting/backtesting.py",
"chars": 73695,
"preview": "\"\"\"\nCore framework data structures.\nObjects from this module can also be imported from the top-level\nmodule directly, e."
},
{
"path": "backtesting/lib.py",
"chars": 24599,
"preview": "\"\"\"\nCollection of common building blocks, helper auxiliary functions and\ncomposable strategy classes for reuse.\n\nIntende"
},
{
"path": "backtesting/test/BTCUSD.csv",
"chars": 8765,
"preview": ",Open,High,Low,Close,Volume\n2012-01-31,4.58,7.38,3.8,5.55,2012.25343589\n2012-02-29,5.55,6.5,3.8,4.99,4761.6090813\n2012-0"
},
{
"path": "backtesting/test/EURUSD.csv",
"chars": 279689,
"preview": ",Open,High,Low,Close,Volume\n2017-04-19 09:00:00,1.0716,1.0722,1.07083,1.07219,1413\n2017-04-19 10:00:00,1.07214,1.07296,1"
},
{
"path": "backtesting/test/GOOG.csv",
"chars": 97833,
"preview": ",Open,High,Low,Close,Volume\n2004-08-19,100,104.06,95.96,100.34,22351900\n2004-08-20,101.01,109.08,100.5,108.31,11428600\n2"
},
{
"path": "backtesting/test/__init__.py",
"chars": 806,
"preview": "\"\"\"Data and utilities for testing.\"\"\"\n\nfrom __future__ import annotations\n\nimport pandas as pd\n\n\ndef _read_file(filename"
},
{
"path": "backtesting/test/__main__.py",
"chars": 162,
"preview": "import unittest\nimport warnings\n\n\nif __name__ == '__main__':\n warnings.filterwarnings('error')\n unittest.main(modu"
},
{
"path": "backtesting/test/_test.py",
"chars": 45892,
"preview": "import inspect\nimport multiprocessing as mp\nimport os\nimport sys\nimport time\nimport unittest\nfrom concurrent.futures.pro"
},
{
"path": "doc/README.md",
"chars": 326,
"preview": "Backtesting.py Documentation\n============================\nAfter installing documentation dependencies:\n\n pip install "
},
{
"path": "doc/alternatives.md",
"chars": 6077,
"preview": "Alternatives\n------------\nThe thing with backtesting is, unless you dug into the dirty details yourself,\nyou can't rely "
},
{
"path": "doc/build.sh",
"chars": 3791,
"preview": "#!/bin/bash\nset -eu\nIS_RELEASE=\"$([[ \"${GITHUB_REF:-}\" == refs/tags/* ]] && echo 1 || true)\"\n\ndie () { echo \"ERROR: $*\" "
},
{
"path": "doc/examples/Multiple Time Frames.ipynb",
"chars": 518041,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Multiple Time Frames\\n\",\n \"====="
},
{
"path": "doc/examples/Multiple Time Frames.py",
"chars": 5217,
"preview": "# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: percent\n# fo"
},
{
"path": "doc/examples/Parameter Heatmap & Optimization.ipynb",
"chars": 365889,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Parameter Heatmap\\n\",\n \"========"
},
{
"path": "doc/examples/Parameter Heatmap & Optimization.py",
"chars": 8909,
"preview": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_"
},
{
"path": "doc/examples/Quick Start User Guide.ipynb",
"chars": 826060,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"_Backtesting.py_ Quick Start User G"
},
{
"path": "doc/examples/Quick Start User Guide.py",
"chars": 12177,
"preview": "# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: percent\n# fo"
},
{
"path": "doc/examples/Strategies Library.ipynb",
"chars": 440540,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Library of Composable Base Strategi"
},
{
"path": "doc/examples/Strategies Library.py",
"chars": 4210,
"preview": "# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: percent\n# fo"
},
{
"path": "doc/examples/Trading with Machine Learning.ipynb",
"chars": 1868646,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Trading with Machine Learning Mod"
},
{
"path": "doc/examples/Trading with Machine Learning.py",
"chars": 11073,
"preview": "# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: percent\n# fo"
},
{
"path": "doc/pdoc_template/config.mako",
"chars": 632,
"preview": "<%!\n html_lang = 'en'\n show_inherited_members = False\n extract_module_toc_into_sidebar = True\n list_class_va"
},
{
"path": "doc/pdoc_template/credits.mako",
"chars": 384,
"preview": "<%!\nfrom backtesting import __version__\n%>\n<p>\n <a href=\"https://kernc.github.io/backtesting.py/\"><cite>backtesting</"
},
{
"path": "doc/pdoc_template/head.mako",
"chars": 841,
"preview": "<%!\n from pdoc.html_helpers import minify_css\n%>\n<%def name=\"homelink()\" filter=\"minify_css\">\n .homelink {\n "
},
{
"path": "doc/pdoc_template/logo.mako",
"chars": 229,
"preview": "<header>\n <a class=\"homelink\" rel=\"home\" title=\"Backtesting.py Home\" href=\"https://kernc.github.io/backtesting.py/\">\n"
},
{
"path": "doc/scripts/ipython_config.py",
"chars": 328,
"preview": "# In build.sh, this file is copied into (and removed from)\n# ~/.ipython/profile_default/startup/\n\nimport pandas as pd\npd"
},
{
"path": "doc/scripts/logo.py",
"chars": 824,
"preview": "from bokeh.io import show, output_file\nfrom bokeh.models import ColumnDataSource\nfrom bokeh.plotting import figure\n\noutp"
},
{
"path": "doc/scripts/strip_yaml.awk",
"chars": 190,
"preview": "#!/usr/bin/awk -f\n \n# Remove YAML front matter from jupytext-converted .py notebooks\n\nBEGIN { drop = 0; }\n/^# ---$/ { if"
},
{
"path": "pyproject.toml",
"chars": 412,
"preview": "[tool.ruff]\nexclude = [\n '.git',\n '.eggs',\n '__pycache__',\n 'doc/examples',\n]\nignore = [\n 'UP006',\n 'U"
},
{
"path": "requirements.txt",
"chars": 75,
"preview": "# To run example notebooks, install required and test dependencies\n.[test]\n"
},
{
"path": "setup.cfg",
"chars": 706,
"preview": "[flake8]\n# F824 `nonlocal x` is unused: name is never assigned in scope\n# W503 Line break before a binary operator\n# W50"
},
{
"path": "setup.py",
"chars": 3844,
"preview": "import os\nimport sys\n\nif sys.version_info < (3, 9):\n sys.exit('ERROR: Backtesting.py requires Python 3.9+')\n\n\nif __na"
}
]
About this extraction
This page contains the full source code of the kernc/backtesting.py GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 52 files (4.5 MB), approximately 1.2M tokens, and a symbol index with 300 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.