Awesome

ZTOM

ZTOM is the Python SDK for implementing the Trade Order Management System for crypto exchanges.

It's build upon the CCXT library and simplifies the development of fail-safe applications and trading algorithms by providing tools for managing the trade orders execution and some supplementary tools for configuration, flow control, reporting and etc.

With ZTOM it's possible to create, maintain and cancel trade orders using different triggers and conditions apart from the implementation of exchange's communication API.

Could be used for Algorithmic (algo) and High Frequency Trading (hft) for prototyping and production.

Main Features:

Customizable exchanges REST API wrapper
Request throttling control
Order Book depth calculation
Order's Management
Configuration (config files, cli)
Logging, Reporting
Errors management
Offline testing:
- Back testing with prepared marked data
- Order execution emulation

Why it was created

ZTOM was created because of 2 main reasons:

First one is to fail-safe proceeding with the common exchange API use cases like working with orders, exceptions handling so it could be possible to focus on trading algorithms rather than overcoming all the tech things.

This allows to create simple and clean "syntax" framework for order management and flow control so it could be possible easily read the code and understand the implemented algorithm as good as increase the speed of development and leverage on rich Python's analytical abilities.

The second big thing in mind was the implementation of the offline mode for both market data gathering and order execution using the same code as for online trading. This allows more quickly develop the algos, emulate different cases and as a result launch actual live tests more quickly.

Code Example

The order management could be something like this:

import time
import ztom as zt

ex = zt.ccxtExchangeWrapper.load_from_id("binance")
ex.enable_requests_throttle(60, 1200) # 1200 requests per minute for binance

# just checking in offline mode
ex.set_offline_mode("test_data/markets.json", "test_data/tickers.csv")

tickers = ex.fetch_tickers()

# sleep to maintain requests rate
time.sleep(ex.requests_throttle.sleep_time()) 

# below orders object are being created - not actual orders
order1 = zt.ActionOrder.create_from_start_amount(symbol="BTC/USDT",
                                            start_currency="BTC",
                                            amount_start=1,
                                            dest_currency="USDT",
                                            price=tickers["BTC/USDT"]["ask"])

order2 = zt.ActionOrder.create_from_start_amount("USD/RUB", "USD", 1, 
                                                 "RUB", 70)
# new OrderManager object
om = zt.ActionOrderManager(ex)

# adding orders to OM
# they will not be committed to exchange at this point
om.add_order(order1)
om.add_order(order2)

i = 0

while len(om.get_open_orders()) > 0:
	
  # check if order manager has something to do like create or cancel order  
  # and if yes we will not wait for it 
  if om.pending_actions_number() == 0:
        sleep_time = ex.requests_throttle.sleep_time()
        print("Sleeping for {}s".format(sleep_time))
        time.sleep(sleep_time)
  else:
      print("!!! NO SLEEP. ACTIONS ARE PENDING !!!")

 	# here all transaction are committed with the error handling and etc
   om.proceed_orders()
    
   # just to demonstrate how to cancel the order 
   # - operation will be committed on om.proceed_orders()
    if i == 5 and not order.filled > 0 :
      order1.force_close()

    i += 1

print(order1.filled)
print(order2.filled)

Tested Exchanges

Binance

Components and Features

Components	Features
Core	most used for creation apps and algos
`ccxtExchangeWrapper`	communication to exchange via the ccxt offline exchange connection emulation
`action_order`	action order base class. allows to implement "smart" orders which could perform some actions (creation and cancellation of basic orders) in dependence from the data provided by order manager
`order_manager`	action orders lifecycle managementsafe communications with echange wrapperdata provision for ActionOrders
`bot`	configuration, logging, reporting and workflow management
`throttle`	requests throttle contoll
`trade_orders`	container of basic trade order data

Action Orders	various types of action orders
`fok_orders`	fill-or-kill order implementation (with some amount of time or on price changing)
`recovery_orders`	stop loss taker order implementation
`maker_stop_loss` (will be added soon)	maker stop loss order

Calculation helpers	Prices, amounts and other helpers for calculations
`core`	essential assets operations (without connections):trade symbol detectionorder side detectionrelative price differenceprecision convertion
`orderbook`	orderbooks in-depth amounts and prices calculations

Tech/Supplementary
`utils`	various general purpose supplementary functions
`datastorage`	csv file management
`cli`	command line tools
`timer`	operations time counter and reporter
`errors`	some custom exceptions

Reporing
`reporter`	influxdb client wrapper for db connection management
`reporter_sqla`	sqlalchemy wrapper for db connection management
`data models`	sqlalchemy tables to represent trade orders and deals
`grafana dashboards` (will be added soon)	samples of grafana dashboards

Installation

(the installation from pypi will be implemented soon)

Requirements: python3.6+ and some libs

Clone the repo:

git clone https://github.com/ztomsy/ztom.git
install the dependencies:

pip3 install -r requirements.txt
install the ztom lib

pip3 install -e .

run some tests:

python3 -m unittest -v -b

License

This project is licensed under the MIT License - see the LICENSE.md file for details