Limit-order-book (LOB) implementation in Python, with almost no dependencies.
Package currently in development.
For now, I have decided to keep this project in pure Python (no interfacing with C/C++), but that may change in the future.
A limit-order book is a useful tool for anyone working with high-frequency market data, and sometimes you just want to be able to quickly start one, feed your data and extract features.
fastlob is not well named, the goal is not to be fast, but rather to provide a simple and useful implementation. Otherwise this would not be written in Python.
But if you want to quickly prototype a trading strategy, or analyze some historical data, this is the right package for you.
This project was mainly born from the lack of good order-book packages in Python.
Functionalities:
- Place limit orders.
- Execute market orders.
- Orders can be good-till-cancel (GTC), fill-or-kill (FOK) or good-till-date (GTD).
- Cancel / update pending or partially filled orders.
- Query order status (pending, filled, partially filled, canceled...).
- Set custom tick size for price and quantities.
- Extract lob features: spread, midprice, volume, imbalance...
- Simulate historical market data.
The goal is to build an efficient and easy to use package, with a clean and comprehensible API.
We aim to keep it minimalist and simple, while keeping reasonable performances (for a pure Python implementation). We intend the final project to contain no more than 2000 lines of code.
We implement three types of orders: FOK, GTC and GTD. Every order is initially defined as limit, but will be executed as a market order if its price matches the best (bid or ask) limit price in the book.
In the case of GTD orders, the book only supports whole seconds for the order expiry (order can not be set to expire in 3.8 seconds, in this case it will be rounded to 4, nearest integer).
The package is available on PyPI, you can simply install it using
pip install fastlob
Otherwise, one can install it from source
git clone git@github.com:mrochk/fastlob.git
cd fastlob
pip install -r requirements.txt
pip install .To run the tests and check that everything is okay, run make test or python3 -m unittest discover test.
This book runs at a fixed decimal precision through the Python decimal package. The decimal precision (also called tick size) can be set via the FASTLOB_DECIMAL_PRECISION_PRICE and FASTLOB_DECIMAL_PRECISION_QTY environment variables, if not set it defaults to 2.
# examples/quickstart.py
import time, logging
from fastlob import (
Orderbook,
OrderParams,
OrderSide,
OrderType,
)
logging.basicConfig(level=logging.INFO) # maximum logging
with Orderbook(name='example') as lob: # init and start lob in cm
# every order must be created this way
params = OrderParams(
side=OrderSide.BID, # is it a buy or sell order
price=123.32, quantity=3.42, # by default runs at 2 digits decimal precision
otype=OrderType.GTD, # good-till-date order
expiry=time.time() + 120 # order will expire in two minutes
# since order is GTD, expiry must be set to some future timestamp
)
# -> at this point an exception will be raised if invalid attributes are provided
result = lob(params) # let the book process the order
assert result.success() # result object can be used to see various infos about the order execution
# order uuid is used to query our order after it's been placed
status, quantity_left = lob.get_status(result.orderid())
print(f'Current order status: {status.name}, quantity left: {quantity_left}.\n')
lob.render() # pretty-print the book state
# if lob not started using context manager, must call lob.stop() before terminatingFor more examples please check out fastlob.com.
As mentioned earlier, this package is still in early development, and contributions are more than welcome.
Please do not hesitate to contact me or directly submit a pull request if you'd like to contribute, there are also various issues open on Github.
My e-mail: mrochkoulets@gmail.com