ai4trade-xtquant

The xtdata module provides market data (historical and real-time K-lines, tick data, financial data, etc.) by interacting with MiniQmt.

Key operational logic:

• Connection: xtdata establishes a connection to MiniQmt, which handles the actual market data requests and returns results to the Python layer. To check data availability or switch connections, you should operate directly on MiniQmt.
• Data Availability: Before calling data retrieval interfaces, ensure MiniQmt has the required data. If data is missing, use the download_ interfaces to supplement it first.
• Subscription Model: For real-time data, set a callback. When new data arrives, it is returned via the callback. It is recommended to save subscribed data locally, as you won't need to supplement the same data type repeatedly once subscribed.
• Data Types:
  • Level 1: Use download_history_data for historical parts, subscribe_XXX for real-time parts, and get_XXX to retrieve the current buffer.
  • Level 2: Use subscribe_XXX for real-time parts and get_l2_XXX to retrieve them. Note that Level 2 functions do not store historical data and data is cleared after the trading day ends.

To build a trading strategy, you need to implement a callback class inheriting from XtQuantTraderCallback to handle real-time market and trade events, then initialize the XtQuantTrader with your client path and a unique session_id.

#coding=utf-8
from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
from xtquant.xtquant import StockAccount
from xtquant import xtconstant

class MyXtQuantTraderCallback(XtQuantTraderCallback):
    def on_disconnected(self):
        print("connection lost")
    def on_stock_order(self, order):
        print("on order callback:", order.stock_code, order.order_status, order.order_sysid)
    def on_stock_asset(self, asset):
        print("on asset callback", asset.account_id, asset.cash, asset.total_asset)
    def on_stock_trade(self, trade):
        print("on trade callback", trade.account_id, trade.stock_code, trade.order_id)
    def on_stock_position(self, position):
        print("on position callback", position.stock_code, position.volume)
    def on_order_error(self, order_error):
        print("on order_error callback", order_error.order_id, order_error.error_id, order_error.error_msg)
    def on_cancel_error(self, cancel_error):
        print("on cancel_error callback", cancel_error.order_id, cancel_error.error_id, cancel_error.error_msg)
    def on_order_stock_async_response(self, response):
        print("on_order_stock_async_response", response.account_id, response.order_id, response.seq)

if __name__ == "__main__":
    path = 'D:\\迅投极速交易终端 睿智融科版\\userdata_mini'
    session_id = 123456
    xt_trader = XtQuantTrader(path, session_id)
    acc = StockAccount('1000000365')
    callback = MyXtQuantTraderCallback()
    xt_trader.register_callback(callback)
    xt_trader.start()
    if xt_trader.connect() == 0:
        xt_trader.subscribe(acc)
        # ... trading logic ...
        xt_trader.run_forever()

Follow these steps to prepare the trading environment:

1. Register Callbacks: Use register_callback(callback) to attach an instance of XtQuantTraderCallback to receive real-time updates.
2. Start Environment: Call start() to launch the trading thread.
3. Connect: Call connect() to establish a connection to MiniQMT. This is a one-time connection; if it disconnects, you must call it again manually. It returns 0 on success.
4. Run/Wait: Use run_forever() to block the current thread and wait for events until stop() is called.
5. Stop: Call stop() to shut down the API.

# 1. Register callback
callback = MyXtQuantTraderCallback()
xt_trader.register_callback(callback)

# 2. Prepare environment
xt_trader.start()

# 3. Connect
connect_result = xt_trader.connect()
if connect_result == 0:
    print("Connected successfully")

# 4. Keep running
xt_trader.run_forever()

# 5. Stop
xt_trader.stop()

Access corporate financial statements using the following methods:

Retrieval:

• get_financial_data(stock_list, table_list, start_time, end_time, report_type)
  • table_list supports: 'Balance' (Balance Sheet), 'Income' (Income Statement), 'CashFlow' (Cash Flow Statement).
  • report_type supports: 'report_time' (cutoff date) or 'announce_time' (disclosure date).
  • Returns a dict where keys are stock codes and values are dicts containing pd.DataFrames for each requested table.

Downloading:

• download_financial_data(stock_list, table_list): A synchronous operation to download financial data to the local environment.

# Get Income Statement data
financials = get_financial_data(
    stock_list=['600000.SH'], 
    table_list=['Income'], 
    report_type='report_time'
)

# Download financial data
download_financial_data(stock_list=['600000.SH'], table_list=['Balance', 'Income'])