# Asynchronously Request Indicator Calculation
- Python
- Proto
- C#
- Java
- C++
- JavaScript
request_indicator_calc_async(short_name, lang_type, code, kl_type, klines, num=None, input_params=None)
Description
Asynchronously request indicator calculation. The API returns a
calc_idimmediately; the actual calculation result is delivered asynchronously through the push-indicator-calc callback, paired bycalc_id.Parameters
Parameter Type Description short_name str Indicator short name lang_type IndicatorLangType Script language type code str Stock code, e.g. HK.00700kl_type KLType K-line type klines pd.DataFrame or list[dict] K-line data from request_history_kline/get_cur_klinenum int or None Use at most the first N K-lines; None means all K-lines input_params list[dict] or None Input overrides as {"index": int, "value": str}; empty uses defaultsReturn
Parameter Type Description ret RET_CODE API call result data str When ret == RET_OK, returns the `calc_id` of the calculation task, used to pair with push results str When ret != RET_OK, returns error description Example
from futu import *
import time
quote_ctx = OpenQuoteContext(host='127.0.0.1', port=11111)
class IndicatorCalcHandler(IndicatorCalcHandlerBase):
def on_recv_rsp(self, rsp_pb):
ret_code, content = super(IndicatorCalcHandler, self).on_recv_rsp(rsp_pb)
if ret_code != RET_OK:
print('error:', content)
return ret_code, content
print('calc result:', content)
return RET_OK, content
quote_ctx.set_handler(IndicatorCalcHandler())
ret, kl_data, _ = quote_ctx.request_history_kline('HK.00700', start='2024-01-01', end='2024-03-01', ktype=KLType.K_DAY)
if ret == RET_OK:
ret, calc_id = quote_ctx.request_indicator_calc_async(
'MACD', IndicatorLangType.MYLANG, 'HK.00700', KLType.K_DAY, kl_data)
if ret == RET_OK:
print('calc_id:', calc_id)
else:
print('error:', calc_id)
time.sleep(5)
quote_ctx.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Qot_RequestIndicatorCalc.proto
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
// Single input parameter override item
message IndicatorInputItem
{
required int32 index = 1; // Input parameter index, corresponds to IndicatorInfo.inputs index, 0-based
optional string value = 2; // Parameter value (string form, leave empty to use default)
}
// Security and candlestick data required for calculation
message IndicatorCalcData
{
required Qot_Common.Security security = 1; // Security
required Qot_Common.KLType klType = 2; // Candlestick period
repeated Qot_Common.KLine kLine = 3; // Candlestick data
}
message C2S
{
required string shortName = 1; // Indicator short name
required Qot_Common.IndicatorLangType langType = 2; // Script language type
required IndicatorCalcData data = 3; // Calculation data
optional int32 num = 4; // Take at most the first N candlesticks; empty = all
repeated IndicatorInputItem inputs = 5; // Input parameter overrides (optional, empty = use cloud config)
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
- Return
message S2C
{
required string calcId = 1; // Calculation task ID, paired with push result
}
message Response
{
required int32 retType = 1 [default = -400]; //RetType, return result
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
uint RequestIndicatorCalc(QotRequestIndicatorCalc.Request req);
virtual void OnReply_RequestIndicatorCalc(FTAPI_Conn client, uint nSerialNo, QotRequestIndicatorCalc.Response rsp);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
int requestIndicatorCalc(QotRequestIndicatorCalc.Request req);
void onReply_RequestIndicatorCalc(FTAPI_Conn client, int nSerialNo, QotRequestIndicatorCalc.Response rsp);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Futu::u32_t RequestIndicatorCalc(const Qot_RequestIndicatorCalc::Request &stReq);
virtual void OnReply_RequestIndicatorCalc(Futu::u32_t nSerialNo, const Qot_RequestIndicatorCalc::Response &stRsp) = 0;
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1; // Input parameter index, 0-based
optional string value = 2; // Parameter value (string form, leave empty to use default)
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1; // Security
required Qot_Common.KLType klType = 2; // Candlestick period
repeated Qot_Common.KLine kLine = 3; // Candlestick data
}
message C2S
{
required string shortName = 1; // Indicator short name
required Qot_Common.IndicatorLangType langType = 2; // Script language type
required IndicatorCalcData data = 3; // Calculation data
optional int32 num = 4; // Take at most the first N candlesticks; empty = all
repeated IndicatorInputItem inputs = 5; // Input parameter overrides (optional)
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1; // Calculation task ID, paired with push result
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Example
class Program : public FTSPI_Qot, public FTSPI_Conn
{
public:
Program() {
m_pQotApi = FTAPI::CreateQotApi();
m_pQotApi->RegisterQotSpi(this);
m_pQotApi->RegisterConnSpi(this);
}
~Program() {
if (m_pQotApi != nullptr) {
m_pQotApi->UnregisterQotSpi();
m_pQotApi->UnregisterConnSpi();
FTAPI::ReleaseQotApi(m_pQotApi);
m_pQotApi = nullptr;
}
}
void Start() {
m_pQotApi->InitConnect("127.0.0.1", 11111, false);
}
virtual void OnInitConnect(FTAPI_Conn* pConn, Futu::i64_t nErrCode, const char* strDesc) {
Qot_RequestIndicatorCalc::Request req;
Qot_RequestIndicatorCalc::C2S *c2s = req.mutable_c2s();
c2s->set_shortname("MACD");
c2s->set_langtype(Qot_Common::IndicatorLangType::IndicatorLangType_MyLang);
Qot_RequestIndicatorCalc::IndicatorCalcData *data = c2s->mutable_data();
Qot_Common::Security *sec = data->mutable_security();
sec->set_market(Qot_Common::QotMarket::QotMarket_HK_Security);
sec->set_code("00700");
data->set_kltype(Qot_Common::KLType::KLType_Day);
// Fill data->add_kline() with KLine entries as needed
m_RequestIndicatorCalcSerialNo = m_pQotApi->RequestIndicatorCalc(req);
}
virtual void OnReply_RequestIndicatorCalc(Futu::u32_t nSerialNo, const Qot_RequestIndicatorCalc::Response &stRsp) {
if (nSerialNo != m_RequestIndicatorCalcSerialNo) return;
string resp_str;
ProtoBufToBodyData(stRsp, resp_str);
cout << UTF8ToLocal(resp_str) << endl;
}
// Calculation result is delivered asynchronously via OnPush_PushIndicatorCalc (3261)
virtual void OnPush_PushIndicatorCalc(const Qot_PushIndicatorCalc::Response &stRsp) {
string resp_str;
ProtoBufToBodyData(stRsp, resp_str);
cout << "PushIndicatorCalc: " << UTF8ToLocal(resp_str) << endl;
}
protected:
FTAPI_Qot *m_pQotApi;
Futu::u32_t m_RequestIndicatorCalcSerialNo = 0;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
RequestIndicatorCalc(req);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Example
import ftWebsocket from "futu-api";
import { Common, Qot_Common } from "futu-api/proto";
import beautify from "js-beautify";
function QotRequestIndicatorCalc(){
const { RetType } = Common
const { QotMarket, KLType, IndicatorLangType } = Qot_Common
let [addr, port, enable_ssl, key] = ["127.0.0.1", 33333, false, '7522027ccf5a06b1'];
let websocket = new ftWebsocket();
websocket.onlogin = (ret, msg)=>{
if (ret) {
const req = {
c2s: {
shortName: "MACD",
langType: IndicatorLangType.IndicatorLangType_MyLang,
data: {
security: { market: QotMarket.QotMarket_HK_Security, code: "00700" },
klType: KLType.KLType_Day,
kLine: [ /* fill in KLine entries */ ],
},
},
};
websocket.RequestIndicatorCalc(req)
.then((res) => {
let { errCode, retMsg, retType, s2c } = res
console.log("RequestIndicatorCalc: errCode %d, retMsg %s, retType %d", errCode, retMsg, retType);
if(retType == RetType.RetType_Succeed){
let data = beautify(JSON.stringify(s2c), {
indent_size: 2,
space_in_empty_paren: true,
});
console.log(data);
}
})
.catch((error) => {
console.log("error:", error);
});
} else {
console.log("start error", msg);
}
};
websocket.start(addr, port, enable_ssl, key);
setTimeout(()=>{ websocket.stop(); process.exit(); }, 5000);
}
QotRequestIndicatorCalc()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
- Output
RequestIndicatorCalc: errCode 0, retMsg , retType 0
{
"calcId": "1700000000000-0"
}
1
2
3
4
2
3
4
- Python
- Proto
- C#
- Java
- C++
- JavaScript
request_indicator_calc_async(short_name, lang_type, code, kl_type, klines, num=None, input_params=None)
Description
Asynchronously request indicator calculation. The API returns a
calc_idimmediately; the actual calculation result is delivered asynchronously through the push-indicator-calc callback, paired bycalc_id.Parameters
Parameter Type Description short_name str Indicator short name lang_type IndicatorLangType Script language type code str Stock code, e.g. HK.00700kl_type KLType K-line type klines pd.DataFrame or list[dict] K-line data num int or None Use at most the first N K-lines; None means all K-lines input_params list[dict] or None Input parameter overrides (optional) Return
Parameter Type Description ret RET_CODE API call result data str When ret == RET_OK, returns the `calc_id` of the calculation task, used to pair with push results str When ret != RET_OK, returns error description Example
from moomoo import *
import time
quote_ctx = OpenQuoteContext(host='127.0.0.1', port=11111)
class IndicatorCalcHandler(IndicatorCalcHandlerBase):
def on_recv_rsp(self, rsp_pb):
ret_code, content = super(IndicatorCalcHandler, self).on_recv_rsp(rsp_pb)
if ret_code != RET_OK:
print('error:', content)
return ret_code, content
print('calc result:', content)
return RET_OK, content
quote_ctx.set_handler(IndicatorCalcHandler())
ret, kl_data, _ = quote_ctx.request_history_kline('HK.00700', start='2024-01-01', end='2024-03-01', ktype=KLType.K_DAY)
if ret == RET_OK:
ret, calc_id = quote_ctx.request_indicator_calc_async(
'MACD', IndicatorLangType.MYLANG, 'HK.00700', KLType.K_DAY, kl_data)
print('calc_id:', calc_id)
time.sleep(5)
quote_ctx.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if ret == RET_OK: print('calc_id:', calc_id) else: print('error:', calc_id) quote_ctx.close() # Remember to close the connection to avoid exhausting connection quota
</template>
<template v-slot:pb>
## Qot_RequestIndicatorCalc.proto
* **Description**
Asynchronously request indicator calculation. The API returns a `calcId` immediately; the actual calculation result is delivered asynchronously through `Qot_PushIndicatorCalc` (3261), paired by `calcId`.
* **Parameters**
```protobuf
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
uint RequestIndicatorCalc(QotRequestIndicatorCalc.Request req);
virtual void OnReply_RequestIndicatorCalc(MMAPI_Conn client, uint nSerialNo, QotRequestIndicatorCalc.Response rsp);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
int requestIndicatorCalc(QotRequestIndicatorCalc.Request req);
void onReply_RequestIndicatorCalc(MMAPI_Conn client, int nSerialNo, QotRequestIndicatorCalc.Response rsp);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Moomoo::u32_t RequestIndicatorCalc(const Qot_RequestIndicatorCalc::Request &stReq);
virtual void OnReply_RequestIndicatorCalc(Moomoo::u32_t nSerialNo, const Qot_RequestIndicatorCalc::Response &stRsp) = 0;
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Example
class Program : public MMSPI_Qot, public MMSPI_Conn
{
public:
Program() {
m_pQotApi = MMAPI::CreateQotApi();
m_pQotApi->RegisterQotSpi(this);
m_pQotApi->RegisterConnSpi(this);
}
~Program() {
if (m_pQotApi != nullptr) {
m_pQotApi->UnregisterQotSpi();
m_pQotApi->UnregisterConnSpi();
MMAPI::ReleaseQotApi(m_pQotApi);
m_pQotApi = nullptr;
}
}
void Start() {
m_pQotApi->InitConnect("127.0.0.1", 11111, false);
}
virtual void OnInitConnect(MMAPI_Conn* pConn, Moomoo::i64_t nErrCode, const char* strDesc) {
Qot_RequestIndicatorCalc::Request req;
Qot_RequestIndicatorCalc::C2S *c2s = req.mutable_c2s();
c2s->set_shortname("MACD");
c2s->set_langtype(Qot_Common::IndicatorLangType::IndicatorLangType_MyLang);
Qot_RequestIndicatorCalc::IndicatorCalcData *data = c2s->mutable_data();
Qot_Common::Security *sec = data->mutable_security();
sec->set_market(Qot_Common::QotMarket::QotMarket_HK_Security);
sec->set_code("00700");
data->set_kltype(Qot_Common::KLType::KLType_Day);
// Fill data->add_kline() with KLine entries as needed
m_RequestIndicatorCalcSerialNo = m_pQotApi->RequestIndicatorCalc(req);
}
virtual void OnReply_RequestIndicatorCalc(Moomoo::u32_t nSerialNo, const Qot_RequestIndicatorCalc::Response &stRsp) {
if (nSerialNo != m_RequestIndicatorCalcSerialNo) return;
string resp_str;
ProtoBufToBodyData(stRsp, resp_str);
cout << UTF8ToLocal(resp_str) << endl;
}
// Calculation result is delivered asynchronously via OnPush_PushIndicatorCalc (3261)
virtual void OnPush_PushIndicatorCalc(const Qot_PushIndicatorCalc::Response &stRsp) {
string resp_str;
ProtoBufToBodyData(stRsp, resp_str);
cout << "PushIndicatorCalc: " << UTF8ToLocal(resp_str) << endl;
}
protected:
MMAPI_Qot *m_pQotApi;
Moomoo::u32_t m_RequestIndicatorCalcSerialNo = 0;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
RequestIndicatorCalc(req);
Description
Asynchronously request indicator calculation. The API returns a
calcIdimmediately; the actual calculation result is delivered asynchronously throughQot_PushIndicatorCalc(3261), paired bycalcId.Parameters
message IndicatorInputItem
{
required int32 index = 1;
optional string value = 2;
}
message IndicatorCalcData
{
required Qot_Common.Security security = 1;
required Qot_Common.KLType klType = 2;
repeated Qot_Common.KLine kLine = 3;
}
message C2S
{
required string shortName = 1;
required Qot_Common.IndicatorLangType langType = 2;
required IndicatorCalcData data = 3;
optional int32 num = 4;
repeated IndicatorInputItem inputs = 5;
}
message Request
{
required C2S c2s = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- Return
message S2C
{
required string calcId = 1;
}
message Response
{
required int32 retType = 1 [default = -400];
optional string retMsg = 2;
optional int32 errCode = 3;
optional S2C s2c = 4;
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
- Security structure: Security
- Candlestick type: KLType
- Candlestick structure: KLine
- Indicator script language: IndicatorLangType
- API call result structure: RetType
Protocol ID
3260
Example
import mmWebsocket from "moomoo-api";
import { Common, Qot_Common } from "moomoo-api/proto";
import beautify from "js-beautify";
function QotRequestIndicatorCalc(){
const { RetType } = Common
const { QotMarket, KLType, IndicatorLangType } = Qot_Common
let [addr, port, enable_ssl, key] = ["127.0.0.1", 33333, false, '7522027ccf5a06b1'];
let websocket = new mmWebsocket();
websocket.onlogin = (ret, msg)=>{
if (ret) {
const req = {
c2s: {
shortName: "MACD",
langType: IndicatorLangType.IndicatorLangType_MyLang,
data: {
security: { market: QotMarket.QotMarket_HK_Security, code: "00700" },
klType: KLType.KLType_Day,
kLine: [ /* fill in KLine entries */ ],
},
},
};
websocket.RequestIndicatorCalc(req)
.then((res) => {
let { errCode, retMsg, retType, s2c } = res
console.log("RequestIndicatorCalc: errCode %d, retMsg %s, retType %d", errCode, retMsg, retType);
if(retType == RetType.RetType_Succeed){
let data = beautify(JSON.stringify(s2c), {
indent_size: 2,
space_in_empty_paren: true,
});
console.log(data);
}
})
.catch((error) => {
console.log("error:", error);
});
} else {
console.log("start error", msg);
}
};
websocket.start(addr, port, enable_ssl, key);
setTimeout(()=>{ websocket.stop(); process.exit(); }, 5000);
}
QotRequestIndicatorCalc()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
- Output
RequestIndicatorCalc: errCode 0, retMsg , retType 0
{
"calcId": "1700000000000-0"
}
1
2
3
4
2
3
4