WonderTrader Wtpy

https://github.com/wondertrader/wtpy
Admin
Wtpy is a Python3 sub-framework for the WonderTrader quantitative trading system, providing...
Tokens:5,512
Snippets:44
Trust Score:9.3
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Engine Configuration Parameters (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet details the parameters added to the WtEngine constructor: genDir for specifying the data output directory and logCfg for configuring the logging system. These provide greater control over engine setup.

```python
# Conceptual Python usage of WtEngine with parameters
# from wtpy import WtEngine

# engine = WtEngine(genDir='output_data/', logCfg='log.conf')

```

--------------------------------

### Run Backtest Execution

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Starts the backtesting process. The `bAsync=False` parameter indicates that the backtest will run synchronously, and the program will wait for its completion before proceeding.

```python
#开始运行回测
engine.run_backtest(bAsync=False)
```

--------------------------------

### Install wtpy Python Package

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This command installs or upgrades the wtpy package for Python 3.8 and above from PyPI. It ensures you have the latest version of the WonderTrader Python framework.

```shell
pip install wtpy --upgrade
```

--------------------------------

### Configure Exchange Commodity Settings (SSE ETF)

Source: https://github.com/wondertrader/wtpy/blob/master/demos/README.md

Defines configuration details for a specific commodity traded on an exchange, using the Shanghai Stock Exchange (SSE) ETF as an example. It includes parameters like category, cover mode, exchange code, holiday calendar, name, price precision, tick size, trading sessions, and trade mode.

```json
{
    "SSE": {
        "ETF": {
            "category": 0,
            "covermode": 0,
            "exchg": "SSE",
            "holiday": "CHINA",
            "name": "上证ETF",
            "precision": 2,
            "pricemode": 1,
            "pricetick": 0.001,
            "session": "SD0930",
            "volscale": 1,
            "trademode": 2
        }
    }
}
```

--------------------------------

### Data Servo Module (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet details the WtDataServo module, which offers two implementation methods: direct access to the local C++ WtDtServo module (with optional web interface) or fetching data via the web interface provided by the first method. Examples are in '/demos/test_dataservo'.

```python
# Conceptual Python usage of WtDataServo
# from wtpy import WtDataServo

# servo = WtDataServo(source='local') # or source='web'
# bars = servo.get_bars(code='rb000', period='1m')

```

--------------------------------

### Historical Data Loading Extension (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the ExtDataLoader mechanism, allowing historical data to be loaded via application-level extension data loaders in both live trading and backtesting frameworks. The 'demos/test_dataexts' directory provides examples.

```python
# Conceptual Python usage of ExtDataLoader
# from wtpy.framework import ExtDataLoader

# class MyDataLoader(ExtDataLoader):
#     def load_bars(self, ...):
#         # Custom data loading logic
#         pass

# data_loader = MyDataLoader()
# data_loader.load_bars(...)
```

--------------------------------

### Historical Data Dumping Extension (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet details the ExtDataDumper mechanism. When an ExtDataDumper is registered with 'datakit', real-time data is dumped via this dumper during the end-of-day process. Examples can be found in 'demos/test_dataexts'.

```python
# Conceptual Python usage of ExtDataDumper
# from wtpy.framework import ExtDataDumper

# class MyDataDumper(ExtDataDumper):
#     def dump_bars(self, ...):
#         # Custom data dumping logic
#         pass

# data_dumper = MyDataDumper()
# # Register data_dumper with datakit
```

--------------------------------

### Initialize and Configure WtBtEngine for Backtesting

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Initializes the WtBtEngine, sets backtest date range, configures storage for backtest results, and commits the configuration. It uses EngineType.ET_CTA for the backtesting environment.

```python
from wtpy import WtBtEngine,EngineType
from Strategies.DualThrust import StraDualThrust

#创建一个运行环境，并加入策略
engine = WtBtEngine(EngineType.ET_CTA)
engine.init('../common/', "configbt.yaml")
engine.configBacktest(201909100930,201912011500)
engine.configBTStorage(mode="csv", path="../storage/")
engine.commitBTConfig()
```

--------------------------------

### Configure Risk Management Settings

Source: https://github.com/wondertrader/wtpy/blob/master/demos/README.md

Defines risk management parameters for trading strategies. Includes settings for risk span, risk scale, basic ratio, and various intra-day and multi-day trading parameters. These settings control how the trading system manages risk and capital.

```json
{
    "risk_span": 30,
    "risk_scale": 0.3,
    "basic_ratio": 101,
    "inner_day_fd":20.0,
    "inner_day_active":true,
    "multi_day_fd":60.0,
    "multi_day_active":false,
    "base_amount": 5000000
}
```

--------------------------------

### Engine Output Directory and Log Config (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet explains that the WtEngine constructor now accepts a genDir parameter to specify the data output directory and a logCfg parameter for the log configuration file. This enhances control over engine execution environment.

```python
# Conceptual Python usage of WtEngine with output dir and log config
# from wtpy import WtEngine

# engine = WtEngine(genDir='path/to/output', logCfg='path/to/log.conf')

```

--------------------------------

### Backtest Engine Slippage Setting (C++)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet notes that the backtest engine in the C++ core now supports setting slippage. This allows for more realistic backtesting by incorporating transaction cost simulation.

```cpp
// Conceptual C++ backtest engine usage with slippage
// WtBtEngine engine;
// engine.set_slippage_model(SlippageType::FIXED, 0.001); // Example: fixed slippage of 0.1%
```

--------------------------------

### YAML and JSON Configuration Loading (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet focuses on the WTSCfgLoader module, which enables configuration files to be parsed in either YAML or JSON format. This provides flexibility in managing application settings.

```python
# Conceptual Python usage of WTSCfgLoader
# from wtpy import WTSCfgLoader

# loader = WTSCfgLoader()
# config = loader.load_config('config.yaml') # or config.json
```

--------------------------------

### Multi-Period Backtesting for Optimizer (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet mentions that the CTAOptimizer (brute-force optimizer) now supports setting multiple backtest periods. This allows for more comprehensive testing and optimization across different historical timeframes.

```python
# Conceptual Python usage of CTAOptimizer with multiple periods
# from wtpy import CTAOptimizer

# optimizer = CTAOptimizer()
# periods = [('2022-01-01', '2022-12-31'), ('2023-01-01', '2023-12-31')]
# optimizer.set_backtest_periods(periods)
# results = optimizer.optimize(strategy_instance)

```

--------------------------------

### Implement and Set DualThrust Strategy

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Creates an instance of the StraDualThrust strategy with specified parameters such as name, contract code, bar count, period, days, k1, k2, and whether it's for stocks. This strategy instance is then added to the backtesting engine.

```python
'''
创建DualThrust策略的一个实例
name    策略实例名称
code    回测使用的合约代码
barCnt  要拉取的K线条数
period  要使用的K线周期，m表示分钟线
days    策略算法参数，算法引用的历史数据条数
k1      策略算法参数，上边界系数
k2      策略算法参数，下边界系数
isForStk    DualThrust策略用于控制交易品种的代码
'''
straInfo = StraDualThrust(name='pydt_IF', code="CFFEX.IF.HOT", barCnt=50, period="m5", days=30, k1=0.1, k2=0.1, isForStk=False)
engine.set_cta_strategy(straInfo)
```

--------------------------------

### Execute Pyfolio Analysis

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Calls the `analyze_with_pyfolio` function to perform performance analysis on the backtest results, using the specified fund data file and initial capital.

```python
analyze_with_pyfolio("./outputs_bt/pydt_IF/funds.csv",500000)
```

--------------------------------

### Simple Daily Fund Analysis (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the new run_simple interface in the WtBtAnalyst module. This interface performs a streamlined daily fund analysis and outputs the results to a 'summary.json' file, simplifying basic performance reporting.

```python
# Conceptual Python usage of WtBtAnalyst.run_simple
# from wtpy.apps import WtBtAnalyst

# analyst = WtBtAnalyst()
# analyst.run_simple(config_file='backtest.json')
# # Results will be in summary.json

```

--------------------------------

### Independent Backtest Visualization Page (Web)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet announces the addition of a new independent page, backtest.html. This page is dedicated to providing visual tools for backtest viewing and analysis, offering a more intuitive way to understand trading strategy performance.

```html
<!-- Conceptual HTML structure for backtest.html -->
<!-- <!DOCTYPE html>
<html>
<head>
    <title>Backtest Visualization</title>
</head>
<body>
    <h1>Backtest Results</h1>
    <div id="chartContainer"></div>
    <div id="summaryTable"></div>
    <!-- JavaScript for charting and analysis -->
</body>
</html> -->

```

--------------------------------

### Genetic Algorithm Optimizer (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet mentions the addition of a genetic algorithm parameter optimization module, WtCtaGAOptimizer. This module assists in finding optimal parameters for CTA strategies through evolutionary computation.

```python
# Conceptual Python usage of WtCtaGAOptimizer
# from wtpy import WtCtaGAOptimizer

# optimizer = WtCtaGAOptimizer()
# optimal_params = optimizer.optimize(strategy_instance, data)

```

--------------------------------

### Data Retrieval by Date (C++)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet highlights new interfaces in WtDtServo, built upon the C++ core, for retrieving tick and second-bar data by trading day. This allows for more efficient and targeted historical data access.

```cpp
// Conceptual C++ interface for retrieving ticks by date
// WtDtServo::get_ticks_by_date(trading_date)

// Conceptual C++ interface for retrieving second bars by date
// WtDtServo::get_sbars_by_date(trading_date)
```

--------------------------------

### Configure Automatic Order Open/Close Strategy

Source: https://github.com/wondertrader/wtpy/blob/master/demos/README.md

Sets the order of operations for automatic opening and closing of positions. The strategy prioritizes 'closeyestoday' over 'open' and 'closetoday' to manage margin usage and position accumulation. This configuration is crucial for managing trade execution flow.

```json
"stockindex":{
	"order":[
		{
			"action":"closeyestoday",
			"limit":0
		},
		{
			"action":"open",
			"limit":500
		},
		{
			"action":"closetoday",
			"limit":0
		}
	],
	"filters":["CFFEX.IF","CFFEX.IC","CFFEX.IH"]
}
```

--------------------------------

### Analyze Backtest Results with Pyfolio

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Defines a function `analyze_with_pyfolio` that takes a fund filename and initial capital as input. It uses pandas to read fund data, calculates returns, and then utilizes pyfolio to generate a full tear sheet for performance analysis. It also includes logic to display plots using matplotlib.

```python
def analyze_with_pyfolio(fund_filename:str, capital:float=500000):
    import pyfolio as pf
    import pandas as pd
    from datetime import datetime
    import matplotlib.pyplot as plt

    # 读取每日资金
    df = pd.read_csv(fund_filename)
    df['date'] = df['date'].apply(lambda x : datetime.strptime(str(x), '%Y%m%d'))
    df = df.set_index(df["date"])

    # 将资金转换成收益率
    ay = df['dynbalance'] + capital
    rets = ay.pct_change().fillna(0).tz_localize('UTC')

    # 调用pyfolio进行分析
    pf.create_full_tear_sheet(rets)

    # 如果在jupyter，不需要执行该语句
    plt.show()
```

--------------------------------

### Backtest Monitoring Module (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet highlights the WtBtMon module, a new component within WtMonSvr. It provides interface services specifically related to backtest management, enabling monitoring and control of backtesting processes.

```python
# Conceptual Python usage of WtBtMon (likely via WtMonSvr)
# from wtpy import WtMonSvr

# mon_svr = WtMonSvr()
# backtest_info = mon_svr.get_backtest_status(bt_id='123')

```

--------------------------------

### K-line Data Callback (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the dumpBars interface within apps.datahelper. This function provides a mechanism to directly output K-line data via callbacks as it's being generated, offering flexibility in how this data is saved or processed.

```python
# Conceptual Python usage of dumpBars interface
# from wtpy.apps import datahelper

# def kline_callback(bar_data):
#     # Process or save bar_data here
#     pass

# datahelper.dumpBars(kline_callback)
```

--------------------------------

### Custom Contract Rule Registration (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet highlights the new registerCustomRule interface added to WtBtEngine and WtEngine. This allows users to define and register custom rules for handling continuous contracts during initialization.

```python
# Conceptual Python usage of registerCustomRule
# from wtpy import WtBtEngine

# engine = WtBtEngine()
# def my_custom_rule(contract):
#     # Custom logic for contract handling
#     return True

# engine.registerCustomRule(my_custom_rule)
```

--------------------------------

### CTA Strategy Fund Data Interface (C++)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet mentions a new interface, stra_get_fund_data, added to the CTA module in the C++ core. This interface allows strategies to retrieve their fund data, likely for performance tracking or risk management.

```cpp
// Conceptual C++ CTA strategy code snippet
// class MyCtaStrategy {
// public public:
//     void on_init() {
//         // Call stra_get_fund_data to get initial fund info
//     }
//     double stra_get_fund_data() {
//         // Returns current fund data
//         return current_fund;
//     }
// private:
//     double current_fund;
// };
```

--------------------------------

### Contract List Loading from Network (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the WtCCLoader module, designed to load contract lists from network interfaces. This is useful for dynamically obtaining contract information required for trading operations.

```python
# Conceptual Python usage of WtCCLoader
# from wtpy import WtCCLoader

# cc_loader = WtCCLoader()
# contract_list = cc_loader.load_from_network('http://example.com/contracts')

```

--------------------------------

### Event Receiver Implementation (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet explains how the EventReceiver module now utilizes WtMsgQue for its operations. Separate implementations are provided for backtesting and live trading frameworks, ensuring appropriate event handling for each context.

```python
# Conceptual Python implementation of EventReceiver
# from wtpy import EventReceiver

# class MyBacktestReceiver(EventReceiver):
#     def on_event(self, event):
#         # Handle backtest events
#         pass

# class MyLiveReceiver(EventReceiver):
#     def on_event(self, event):
#         # Handle live trading events
#         pass

```

--------------------------------

### Identifying Main Contracts (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the WtHotPicker.py module, located in the 'apps' directory. This module is designed to identify the main and secondary main contracts within a given trading context.

```python
# Conceptual Python usage of WtHotPicker
# from wtpy.apps import WtHotPicker

# picker = WtHotPicker()
# main_contract, secondary_contract = picker.get_hot_contracts(code='IF')

```

--------------------------------

### Extensible Parser Access (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the WtDtEngine's support for extensible Parsers. This allows custom data parsing logic to be integrated, as demonstrated in '/demos/datakit_fut/testExtParser.py'.

```python
# Conceptual Python usage with Extensible Parser
# from wtpy import WtDtEngine
# from wtpy.parser import WtParser

# class MyParser(WtParser):
#     def parse_tick(self, raw_data):
#         # Custom tick parsing logic
#         pass

# dt_engine = WtDtEngine()
# dt_engine.register_parser(MyParser())

```

--------------------------------

### Performance Analysis Tool Expansion (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet notes that the performance analysis tool, WtBtAnalyst, has undergone significant functional expansion. This implies more detailed metrics, reporting options, and analysis capabilities.

```python
# Conceptual Python usage of WtBtAnalyst
# from wtpy.apps import WtBtAnalyst

# analyst = WtBtAnalyst()
# analyst.run_analysis(backtest_result_file='result.json')

```

--------------------------------

### Minute Bar Retrieval by Date (C++)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet showcases the addition of a get_bars_by_date interface in WtDtServo, enabling the retrieval of minute-bar data based on a specific trading day. This complements the existing tick and second-bar retrieval functionalities.

```cpp
// Conceptual C++ interface for retrieving minute bars by date
// WtDtServo::get_bars_by_date(trading_date)
```

--------------------------------

### Message Queue Wrapper (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the WtMsgQue module and its wrapper WtMQWrapper, which provides access to the underlying C++ WtMsgQue module. This facilitates inter-module communication through a message queue system.

```python
# Conceptual Python usage of WtMsgQue
# from wtpy import WtMsgQue

# mq = WtMsgQue()
# mq.publish('topic1', 'message data')
# mq.subscribe('topic1', callback_function)

```

--------------------------------

### Reading DSB/DMB Bar and Tick Data (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet details improvements and additions to the interfaces for reading data files. It mentions enhancements to read_dsb_bars and read_dsb_ticks, and the addition of read_dmb_bars and read_dmb_ticks, all utilizing the WtDtHelper.dll.

```python
# Conceptual Python usage for reading data files
# from wtpy import WtDtHelper

# dt_helper = WtDtHelper()
# dsb_bars = dt_helper.read_dsb_bars('bars.dsb')
# dmb_ticks = dt_helper.read_dmb_ticks('ticks.dmb')

```

--------------------------------

### Trader Data Dumping (C++)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the addition of a TraderDumper module, which interfaces with the underlying C++ TraderDumper. Its purpose is to redirect and capture data originating from trading interfaces, facilitating monitoring and analysis.

```cpp
// Conceptual C++ usage of TraderDumper
// TraderDumper dumper;
// dumper.redirect_trading_data();
```

--------------------------------

### Release Backtest Resources

Source: https://github.com/wondertrader/wtpy/blob/master/demos/cta_fut_bt/backtest_and_pyfolio_analyze.ipynb

Releases the resources allocated to the backtesting engine after the backtest has been completed or if it needs to be terminated. This is important for proper cleanup.

```python
engine.release_backtest()
```

--------------------------------

### Context Check for Backtest Mode (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the is_backtest attribute to the Context object. This boolean property allows code to easily determine whether the current execution environment is within a backtesting session or live trading.

```python
# Conceptual Python usage of Context.is_backtest
# from wtpy.strategy import Context

# def on_init(self, context: Context):
#     if context.is_backtest:
#         print('Running in backtest mode')
#     else:
#         print('Running in live trading mode')

```

--------------------------------

### Backtest Results Snooper Service (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces the WtBtSnooper module under 'monitor'. This module can run a simple service to extract backtest results, potentially for external consumption or analysis.

```python
# Conceptual Python usage of WtBtSnooper
# from wtpy.monitor import WtBtSnooper

# snooper = WtBtSnooper()
# # Configure and start the snooper service to extract backtest results

```

--------------------------------

### Resampling Bars Data (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet highlights the resample_bars interface added to WtDtHelper. This function allows users to resample specified .dsb data files into K-lines of different periodicities.

```python
# Conceptual Python usage of WtDtHelper.resample_bars
# from wtpy import WtDtHelper

# dt_helper = WtDtHelper()
# dt_helper.resample_bars(input_file='data.dsb', output_file='resampled.csv', target_period='5m')

```

--------------------------------

### Web UI Pagination Mechanism (Web)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the implementation of a pagination mechanism in the web UI's release package. This enhancement aims to improve performance by breaking down large datasets into manageable pages, reducing browser lag.

```javascript
// Conceptual JavaScript for pagination implementation
// function setupPagination(elementId, dataUrl, pageSize) {
//     // Logic to fetch data in chunks and display paginated content
// }

```

--------------------------------

### Web UI Table Sorting and Statistics (Web)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet indicates that certain tables within the web UI have been enhanced with sorting and statistical functions. This improves data exploration and analysis directly within the web console.

```javascript
// Conceptual JavaScript for enabling table features
// $('table.dataTable').DataTable({
//     ordering: true,
//     searching: true,
//     // ... other options for statistics if custom implemented
// });

```

--------------------------------

### High-Performance Deque Container (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet introduces DequeRecord, a high-performance container developed for the Python portion of the framework. It replaces the older WtKlinData and WtHftData, offering an estimated 5%-10% performance improvement in data caching.

```python
# Conceptual Python usage of DequeRecord
# from wtpy.container import DequeRecord

# record = DequeRecord(capacity=1000)
# record.push_back(data_item)
# item = record.pop_front()

```

--------------------------------

### Feeding Historical Data to C++ (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet highlights the new interfaces trans_bars and trans_ticks within WtDtHelper. These functions allow historical bar and tick data to be directly fed from Python into the C++ core.

```python
# Conceptual Python usage for feeding data to C++
# from wtpy import WtDtHelper

# dt_helper = WtDtHelper()
# bar_data = [...] # List of bar data objects
# tick_data = [...] # List of tick data objects

# dt_helper.trans_bars(bar_data)
# dt_helper.trans_ticks(tick_data)

```

--------------------------------

### Session Information to JSON (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet describes the addition of a toString object to SessionInfo. This method generates a JSON formatted string representation of the session information, aiding in data serialization and logging.

```python
# Conceptual Python usage of SessionInfo.toString
# from wtpy.base import SessionInfo

# session_info = SessionInfo(session_id='S1', start_time='2023-01-01')
# json_string = session_info.toString()

```

--------------------------------

### Data Handling and Conversion (Python)

Source: https://github.com/wondertrader/wtpy/blob/master/README.md

This snippet demonstrates how WTSTickStruct's buy/sell queue was modified to be unidirectional instead of an array. This change simplifies the conversion to a Pandas DataFrame in Python. Additionally, BarList and TickList were deprecated in favor of WtBarRecords and WtTickRecords for improved efficiency.

```python
# Example demonstrating conversion of WTSTickStruct to DataFrame
# (Conceptual, actual implementation depends on WtTickRecords usage)
# from wtpy import WtTickRecords
# import pandas as pd

# Assuming tick_records is an instance of WtTickRecords
# df = pd.DataFrame(tick_records.get_data())

```
Tokens:
Raw