In questa lezione relativa al corso “basi del trading algoritmico con Python” descriviamo come
effettuare il trading automatico con Interactive Brokers usando l’API e Python tramite il wrapper IBPy.
Interactive Brokers è uno dei principali broker utilizzati dai trader algoritmici retail grazie ai requisiti minimi di capitale relativamente bassi (10.000 USD) e a un’API robusta. In questa lezione utilizzeremo un account demo per automatizzare l’invio di ordini tramite l’API di Interactive Brokers, usando Python e il pacchetto IBPy.
Nota: non esiste alcuna affiliazione con Interactive Brokers. Abbiamo semplicemente testato il software in vari contesti e quindi acquisito una certa familiarità con la loro piattaforma.
L’API di Interactive Brokers
Interactive Brokers è un broker globale che si rivolge sia a trader retail che a operatori istituzionali automatizzati. Per questo motivo ha sviluppato una GUI avanzata chiamata Trader Workstation (TWS).
Oltre alla TWS è disponibile anche un componente più leggero chiamato IB Gateway, che consente l’accesso ai server IB senza interfaccia grafica. Per i nostri scopi di trading automatico Interactive Brokers, non useremo direttamente la GUI, ma può essere utile per scopi dimostrativi.
L’architettura dell’API si basa su un modello client/server che fornisce dati di mercato in tempo reale e storici, oltre all’esecuzione degli ordini. In questa lezione, l’API verrà usata per inviare ordini automatici tramite IBPy.
IBPy è un wrapper dell’API Java di IB, pensato per facilitarne l’utilizzo con Python. Le librerie principali sono ib.ext e ib.opt, con quest’ultima che funge da interfaccia ad alto livello.
Nella seguente implementazione del trading automatico con Interactive Brokers prevediamo di invia un semplice ordine di mercato per acquistare 100 azioni Google. Vogliamo usare il routing intelligente per cercare il miglior prezzo disponibile.
Implementazione in Python
Per iniziare, è necessario un account Interactive Brokers e un ambiente Python configurato. È inoltre richiesta l’installazione di IBPy, che collegherà il codice all’API. Se necessario, consulta la lezione sull’ambiente di backtesting in Python.
Installare IBPy
IBPy è un wrapper Python dell’API Java di IB che semplifica lo sviluppo di sistemi di trading automatico con Interactive Brokers. Sarà la base per tutte le comunicazioni con IB, almeno fino all’introduzione del protocollo FIX. Essendo un progetto GitHub, va installato da git. Su Ubuntu:
sudo apt-get install git-core
Una volta installato git, è possibile creare una sottodirectory per memorizzare IBPy. In questo esempio lo abbiamo semplicemente collocato sotto directory home:
mkdir ~/ibapi
Lo step successivo è scaricare IBPy tramite git clone
Assicuriamoci di entrare nella directory IbPy ed effettuare l’installazione con l’ambiente virtuale Python preferito:
cd ~/ibapi/IbPy
python setup.py.in install
Questo completa l’installazione di IBPy.
Il prossimo passo è aprire TWS
Trading Automatico con Interactive Brokers
Il seguente codice implementa una semplice gestione degli ordine basato sulle API. Il codice è lontano dall’essere usato in produzione, ma dimostra la funzionalità essenziale dell’API per il trading automatico con Interactive Brokers e come utilizzarla per l’esecuzione degli ordini. Tutto il seguente codice è contenuto nel fileib_api_demo.py. Il primo passaggio consiste nell’importare gli oggetti Contract e Order dalla libreria ib.ext. Inoltre importiamo gli oggetti Connection e message dalla libreria ib.opt.
# ib_api_demo.py
from ib.ext.Contract import Contract
from ib.ext.Order import Order
from ib.opt import Connection, message
IB ci offre la possibilità di gestire gli errori e le risposte del server tramite un meccanismo di callback. Le seguenti due funzioni non fanno altro che stampare il contenuto dei messaggi restituiti dal server. Un sistema di produzione più sofisticato dovrebbe implementare la logica per assicurare il funzionamento continuo del sistema nel caso di generazione di eccezioni:
# ib_api_demo.py
def error_handler(msg):
"""Gestione per la cattura dei messagi di errori"""
print("Server Error: %s" % msg)
def reply_handler(msg):
"""Gestione delle risposte dal server"""
print("Server Response: %s, %s" % (msg.typeName, msg))
Le seguenti due funzioni completano la creazione degli oggetti Contract e Order, impostando i rispettivi parametri:
# ib_api_demo.py
def create_contract(symbol, sec_type, exch, prim_exch, curr):
"""
Crea un oggetto Contract definendo cosa sarà
acquistato, in quale exchange e in quale valuta.
symbol - Il simbolo del ticker per il contratto
sec_type - Il tipo di asset per il contratto ("STK" è "stock")
exch - La borsa su cui eseguire il contratto
prim_exch - Lo scambio principale su cui eseguire il contratto
curr - La valuta in cui acquistare il contratto
"""
contract = Contract()
contract.m_symbol = symbol
contract.m_secType = sec_type
contract.m_exchange = exch
contract.m_primaryExch = prim_exch
contract.m_currency = curr
return contract
def create_order(order_type, quantity, action):
"""
Crea un oggetto Ordine (Market/Limit) per andare long/short.
order_type - "MKT", "LMT" per ordini a mercato o limite
quantity - Numero intero di asset dell'ordine
action - 'BUY' o 'SELL'
"""
order = Order()
order.m_orderType = order_type
order.m_totalQuantity = quantity
order.m_action = action
return order
Conclusione
La funzione __main__ inizialmente crea un oggetto Connection verso Trader Workstation, che deve essere in esecuzione affinché il codice funzioni. Le funzioni di gestione degli errori e di risposta vengono quindi registrate con l’oggetto di connessione. Successivamente viene definita una variabile order_id. In un sistema di produzione questo deve essere incrementato per ogni ordine.
I passi successivi sono la creazione di un Contract e di un Order che rappresenta un market-order per acquistare 100 unità di azioni Google. L’ultimo compito è quello di piazzare quell’ordine tramite il metodo placeOrder dell’oggetto Connection. Quindi ci disconnettiamo da TWS:
# ib_api_demo.py
if __name__ == "__main__":
# Collegarsi alla Trader Workstation (TWS) in esecuzione
# sulla solita porta 7496, con un clientId di 100
# (Il clientId è scelto da noi e avremo bisogno di
# ID separati sia per la connessione di esecuzione che per
# connessione dati di mercato)
tws_conn = Connection.create(port=7496, clientId=100)
tws_conn.connect()
# Assegna la funzione di gestione degli errori definita
# sopra alla connessione TWS
tws_conn.register(error_handler, 'Error')
# Assegna tutti i messaggi di risposta del server alla
# funzione reply_handler definita sopra
tws_conn.registerAll(reply_handler)
# Crea un ordine ID che sia "globale" per questa sessione. Questo
# dovrà essere incrementato una volta inviati nuovi ordini.
order_id = 1
# Crea un contratto in stock GOOG tramite il routing degli ordini SMART
goog_contract = create_contract('GOOG', 'STK', 'SMART', 'SMART', 'USD')
# si va long di 100 azioni di Google
goog_order = create_order('MKT', 100, 'BUY')
# Uso della connessione per inviare l'ordine a IB
tws_conn.placeOrder(order_id, goog_contract, goog_order)
# Disconnessione da TWS
tws_conn.disconnect()
Infine è sufficiente lanciare lo script Python:
python ib_api_demo.py
Immediatamente si può vedere che si apre un tab “API” su Trader Workstation, mostrando il market order per andare long di 100 azioni su Google
Il codice completo presentato in questa lezione, parte del pacchetto python per il backtest TQBacktest, è disponibile nel seguente repository GitHub: https://github.com/tradingquant-it/TQBacktest.”