TqSdk Python Library

TqSdk is designed to be a flexible, low-overhead toolkit rather than a rigid framework. Key design principles include:

• No Presupposed Strategy Models: TqSdk does not force a specific strategy structure on you. It provides general resources and capabilities instead of strategy templates. You can fetch data and issue instructions arbitrarily within a single program and use multiple TqApi instances in one program.
• Code Simplicity: The library aims to keep user code aligned with their actual requirements. To achieve this, it avoids multi-threading (preventing synchronization issues) and avoids callback models (preventing complex state machine management).
• Verifiable Behavior: TqSdk uses a data-flow architecture and logs all received data packets to ensure that issues can be reproduced and debugged using the logs as test cases.
• Seamless Mode Switching: Switching between Live (实盘), Simulation (模拟), and Backtesting (回测) modes typically requires only a single-point modification in your code.

TqSdk uses a data flow architecture where components are connected via TqChan objects. A TqChan is essentially an asyncio.Queue used as a unidirectional data pipe: one component puts data packets into the channel, and another component retrieves them sequentially.

Data Flow Directions

Upstream (e.g., Placing an Order)

1. The user program calls a function in TqApi (e.g., TqApi.insert_order).
2. TqApi generates a data packet and places it into api_send_chan.
3. TqAccount retrieves the packet from api_send_chan and, based on the aid field, places it into td_send_chan.
4. The Websocket Client connected to the trading gateway retrieves the packet from td_send_chan and sends it over the network.

Downstream (e.g., Receiving Market Data)

1. The Websocket Client connected to the market data gateway receives a packet from the network and places it into md_recv_chan.
2. TqAccount retrieves the packet from md_recv_chan and places it into api_recv_chan.
3. TqApi retrieves the packet from api_recv_chan and merges the market data contained in the packet into its in-memory storage.

Switching Operating Modes

You can switch between live trading, simulation, and backtesting by replacing specific components in the data flow:

• Live Trading: Uses TqAccount to bridge the API and the trading gateways.
• Simulation: Replace TqAccount with TqSim to simulate trading behavior.
• Backtesting: Uses TqBacktest instead of TqAccount, utilizing backtest_recv_chan and backtest_send_chan to manage data flow between TqApi and the backtesting engine.

Unlike vn.py, which uses a centralized runner that calls user-defined strategy classes (subclasses of CtaTemplate), TqSdk follows an inverted architecture. In TqSdk, the user's strategy code is the caller, and the TqSdk library is the callee.

Each strategy in TqSdk is implemented as a standalone Python script/process. This design provides several advantages:

• Multi-core utilization: Running multiple strategies allows for full use of multi-CPU computing power.
• Isolation: Each strategy can be started, stopped, debugged, or modified independently without affecting other running strategies.
• Flexibility: Users can freely combine any functions from the TqSdk package, such as using multiple contracts, different timeframes (K-lines), or combining Tick and Orderbook data within a single strategy.
• Integration: Easier to integrate with other third-party libraries or frameworks.

TqSdk is an open-source Python library for quantitative trading. It provides a full solution including historical and real-time data, development debugging, backtesting, simulated trading, live trading, monitoring, and risk management.

To use TqSdk, you typically follow this workflow:

1. Initialize a TqApi instance with a TqAccount and TqAuth.
2. Subscribe to market data using api.get_quote(symbol).
3. Use TargetPosTask to manage position adjustments.
4. Run a loop using api.wait_update() to process data updates and execute logic.

from tqsdk import TqApi, TqAuth, TqAccount, TargetPosTask

# Create TqApi instance and specify trading account
api = TqApi(TqAccount("H宏源期货", "4003242", "123456"), auth=TqAuth("快期账户", "账户密码"))

# Subscribe to near-month contract quote
q_2610 = api.get_quote("SHFE.rb2610")
# Create position adjustment tool for near-month contract
t_2610 = TargetPosTask(api, "SHFE.rb2610")

# Subscribe to far-month contract quote
q_2701 = api.get_quote("SHFE.rb2701")
# Create position adjustment tool for far-month contract
t_2701 = TargetPosTask(api, "SHFE.rb2701")

while True:
    api.wait_update()  # Wait for data update
    spread = q_2610.last_price - q_2701.last_price  # Calculate spread
    print("当前价差:", spread)
    
    if spread > 250:
        print("价差过高: 空近月，多远月")
        t_2610.set_target_volume(-1)  # Set target to short 1 lot
        t_2701.set_target_volume(1)   # Set target to long 1 lot
    elif spread < 200:
        print("价差回复: 清空持仓")
        t_2610.set_target_volume(0)
        t_2701.set_target_volume(0)