code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
if is_str(codelist):
codelist = codelist.split(',')
elif isinstance(codelist, list):
pass
else:
return RET_ERROR, "code list must be like ['HK.00001', 'HK.00700'] or 'HK.00001,HK.00700'"
result = []
for code in codelist:
re... | def get_multiple_history_kline(self,
codelist,
start=None,
end=None,
ktype=KLType.K_DAY,
autype=AuType.QFQ) | 获取多只股票的本地历史k线数据
:param codelist: 股票代码列表，list或str。例如：['HK.00700', 'HK.00001']，'HK.00700,HK.00001'
:param start: 起始时间，例如'2017-06-20'
:param end: 结束时间, 例如'2017-07-20'，start与end组合关系参见 get_history_kline_
:param ktype: k线类型，参见KLType
:param autype: 复权类型，参见AuType
:return: 成功时返回(... | 2.43101 | 2.264702 | 1.073435 |
return self._get_history_kline_impl(GetHistoryKlineQuery, code, start=start, end=end,
ktype=ktype, autype=autype, fields=fields) | def get_history_kline(self,
code,
start=None,
end=None,
ktype=KLType.K_DAY,
autype=AuType.QFQ,
fields=[KL_FIELD.ALL]) | 得到本地历史k线，需先参照帮助文档下载k线
:param code: 股票代码
:param start: 开始时间，例如'2017-06-20'
:param end: 结束时间，例如'2017-06-30'
start和end的组合如下：
========== ========== ========================================
start类型 end类型 说明
... | 3.467582 | 3.738527 | 0.927526 |
code_list = unique_and_normalize_list(code_list)
for code in code_list:
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of param in code_list is wrong"
return RET_ERROR, error_str
query_processor = self._ge... | def get_autype_list(self, code_list) | 获取给定股票列表的复权因子
:param code_list: 股票列表，例如['HK.00700']
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，data.DataFrame数据, 数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ==============================================================... | 4.026952 | 2.479525 | 1.624082 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of param in code is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
RtDataQuery.pack_req, RtDataQuery.unpack_rsp)
kargs = {
... | def get_rt_data(self, code) | 获取指定股票的分时数据
:param code: 股票代码，例如，HK.00700，US.APPL
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，data.DataFrame数据, 数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ================================================================... | 3.550553 | 2.756841 | 1.287906 |
param_table = {'market': market, 'plate_class': plate_class}
for x in param_table:
param = param_table[x]
if param is None or is_str(market) is False:
error_str = ERROR_STR_PREFIX + "the type of market param is wrong"
return RET_ERROR, err... | def get_plate_list(self, market, plate_class) | 获取板块集合下的子板块列表
:param market: 市场标识，注意这里不区分沪，深,输入沪或者深都会返回沪深市场的子板块（这个是和客户端保持一致的）参见Market
:param plate_class: 板块分类，参见Plate
:return: ret == RET_OK 返回pd dataframe数据，data.DataFrame数据, 数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ================... | 2.942764 | 2.667144 | 1.103339 |
if plate_code is None or is_str(plate_code) is False:
error_str = ERROR_STR_PREFIX + "the type of code is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
PlateStockQuery.pack_req, PlateStockQuery.unpack_rsp)
kargs... | def get_plate_stock(self, plate_code) | 获取特定板块下的股票列表
:param plate_code: 板块代码, string, 例如，”SH.BK0001”，”SH.BK0002”，先利用获取子版块列表函数获取子版块代码
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，data.DataFrame数据, 数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== =====================... | 3.478951 | 2.615363 | 1.330198 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of param in code is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
BrokerQueueQuery.pack_req, BrokerQueueQuery.unpack_rsp)
kargs ... | def get_broker_queue(self, code) | 获取股票的经纪队列
:param code: 股票代码
:return: (ret, bid_frame_table, ask_frame_table)或(ret, err_message)
ret == RET_OK 返回pd dataframe数据，数据列格式如下
ret != RET_OK 后面两项为错误字符串
bid_frame_table 经纪买盘数据
===================== =========== ==============... | 2.866831 | 2.317961 | 1.23679 |
return self._subscribe_impl(code_list, subtype_list, is_first_push) | def subscribe(self, code_list, subtype_list, is_first_push=True) | 订阅注册需要的实时信息，指定股票和订阅的数据类型即可
注意：len(code_list) * 订阅的K线类型的数量 <= 100
:param code_list: 需要订阅的股票代码列表
:param subtype_list: 需要订阅的数据类型列表，参见SubType
:param is_first_push: 订阅成功后是否马上推送一次数据
:return: (ret, err_message)
ret == RET_OK err_message为None
ret != RE... | 3.263302 | 6.653006 | 0.4905 |
ret, msg, code_list, subtype_list = self._check_subscribe_param(code_list, subtype_list)
if ret != RET_OK:
return ret, msg
query_processor = self._get_sync_query_processor(SubscriptionQuery.pack_unsubscribe_req,
Subs... | def unsubscribe(self, code_list, subtype_list) | 取消订阅
:param code_list: 取消订阅的股票代码列表
:param subtype_list: 取消订阅的类型，参见SubType
:return: (ret, err_message)
ret == RET_OK err_message为None
ret != RET_OK err_message为错误描述字符串 | 2.439428 | 2.396402 | 1.017955 |
is_all_conn = bool(is_all_conn)
query_processor = self._get_sync_query_processor(
SubscriptionQuery.pack_subscription_query_req,
SubscriptionQuery.unpack_subscription_query_rsp)
kargs = {
"is_all_conn": is_all_conn,
"conn_id": self.get_syn... | def query_subscription(self, is_all_conn=True) | 查询已订阅的实时信息
:param is_all_conn: 是否返回所有连接的订阅状态,不传或者传False只返回当前连接数据
:return: (ret, data)
ret != RET_OK 返回错误字符串
ret == RET_OK 返回 定阅信息的字典数据 ，格式如下:
{
'total_used': 4, # 所有连接已使用的定阅额度
'own_used': 0, # 当前连接已使用的定... | 2.505586 | 2.212219 | 1.132612 |
code_list = unique_and_normalize_list(code_list)
if not code_list:
error_str = ERROR_STR_PREFIX + "the type of code_list param is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
StockQuoteQuery.pack_req,
... | def get_stock_quote(self, code_list) | 获取订阅股票报价的实时数据，有订阅要求限制。
对于异步推送，参见StockQuoteHandlerBase
:param code_list: 股票代码列表，必须确保code_list中的股票均订阅成功后才能够执行
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ===============... | 3.180295 | 2.170569 | 1.46519 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, error_str
if num is None or isinstance(num, int) is False:
error_str = ERROR_STR_PREFIX + "the type of num param is wrong"
... | def get_rt_ticker(self, code, num=500) | 获取指定股票的实时逐笔。取最近num个逐笔
:param code: 股票代码
:param num: 最近ticker个数(有最大个数限制，最近1000个）
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ============================================... | 2.852355 | 2.43496 | 1.171418 |
param_table = {'code': code, 'ktype': ktype}
for x in param_table:
param = param_table[x]
if param is None or is_str(param) is False:
error_str = ERROR_STR_PREFIX + "the type of %s param is wrong" % x
return RET_ERROR, error_str
i... | def get_cur_kline(self, code, num, ktype=SubType.K_DAY, autype=AuType.QFQ) | 实时获取指定股票最近num个K线数据，最多1000根
:param code: 股票代码
:param num: k线数据个数
:param ktype: k线类型，参见KLType
:param autype: 复权类型，参见AuType
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，数据列格式如下
ret != RET_OK 返回错误字符串
===================== ... | 2.288502 | 2.133649 | 1.072577 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
OrderBookQuery.pack_req,
OrderBookQuery.unpack_rsp,
)... | def get_order_book(self, code) | 获取实时摆盘数据
:param code: 股票代码
:return: (ret, data)
ret == RET_OK 返回字典，数据格式如下
ret != RET_OK 返回错误字符串
{‘code’: 股票代码
‘Ask’:[ (ask_price1, ask_volume1，order_num), (ask_price2, ask_volume2, order_num),…]
‘Bid’: [ (bid_price1, bid... | 3.343067 | 3.444634 | 0.970514 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
StockReferenceList.pack_req,
StockReferenceList.unpack_rsp,
... | def get_referencestock_list(self, code, reference_type) | 获取证券的关联数据
:param code: 证券id，str，例如HK.00700
:param reference_type: 要获得的相关数据，参见SecurityReferenceType。例如WARRANT，表示获取正股相关的涡轮
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，数据列格式如下
ret != RET_OK 返回错误字符串
================= =========== =========... | 3.707133 | 2.643709 | 1.402247 |
if is_str(code_list):
code_list = code_list.split(',')
elif isinstance(code_list, list):
pass
else:
return RET_ERROR, "code list must be like ['HK.00001', 'HK.00700'] or 'HK.00001,HK.00700'"
code_list = unique_and_normalize_list(code_list)
... | def get_owner_plate(self, code_list) | 获取单支或多支股票的所属板块信息列表
:param code_list: 股票代码列表，仅支持正股、指数。list或str。例如：['HK.00700', 'HK.00001']或者'HK.00700,HK.00001'。
:return: (ret, data)
ret == RET_OK 返回pd dataframe数据，data.DataFrame数据, 数据列格式如下
ret != RET_OK 返回错误字符串
===================== =========== ==... | 2.86773 | 2.436142 | 1.17716 |
holder_type = STOCK_HOLDER_CLASS_MAP[holder_type]
if code is None or is_str(code) is False:
msg = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, msg
if holder_type < 1 or holder_type > len(STOCK_HOLDER_CLASS_MAP):
msg = ERROR_... | def get_holding_change_list(self, code, holder_type, start=None, end=None) | 获取大股东持股变动列表,只提供美股数据
:param code: 股票代码. 例如：'US.AAPL'
:param holder_type: 持有者类别，StockHolder_
:param start: 开始时间. 例如：'2016-10-01'
:param end: 结束时间，例如：'2017-10-01'。
start与end的组合如下：
========== ========== ========================================
star... | 2.944136 | 2.666822 | 1.103987 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, error_str
ret_code, msg, start, end = normalize_start_end_date(start, end, delta_days=29, default_time_end='00:00:00', prefer_end_now=False)
... | def get_option_chain(self, code, start=None, end=None, option_type=OptionType.ALL, option_cond_type=OptionCondType.ALL) | 通过标的股查询期权
:param code: 股票代码,例如：'HK.02318'
:param start: 开始日期，该日期指到期日，例如'2017-08-01'
:param end: 结束日期（包括这一天），该日期指到期日，例如'2017-08-30'。 注意，时间范围最多30天
start和end的组合如下：
========== ========== ========================================
start类型 end... | 2.959546 | 2.369012 | 1.249274 |
if code is None or is_str(code) is False:
error_str = ERROR_STR_PREFIX + "the type of code param is wrong"
return RET_ERROR, error_str
query_processor = self._get_sync_query_processor(
OrderDetail.pack_req, OrderDetail.unpack_rsp)
kargs = {
... | def get_order_detail(self, code) | 查询A股Level 2权限下提供的委托明细
:param code: 股票代码,例如：'HK.02318'
:return: (ret, data)
ret == RET_OK data为1个dict，包含以下数据
ret != RET_OK data为错误字符串
{‘code’: 股票代码
‘Ask’:[ order_num, [order_volume1, order_volume2] ]
‘Bid’: [ order_num, [... | 3.40765 | 3.323558 | 1.025302 |
'''
订阅多只股票的行情数据
:return:
'''
logger = Logs().getNewLogger('allStockQoutation', QoutationAsynPush.dir)
markets= [Market.HK,Market.US,Market.SH,Market.SZ] #,Market.HK_FUTURE,Market.US_OPTION
stockTypes = [SecurityType.STOCK,SecurityType.WARRANT,SecurityType.IDX,Secu... | def allStockQoutation(self) | 订阅多只股票的行情数据
:return: | 3.27142 | 3.14146 | 1.041369 |
'''
订阅一只股票的实时行情数据，接收推送
:param code: 股票代码
:return:
'''
#设置监听-->订阅-->调用接口
# 分时
self.quote_ctx.set_handler(RTDataTest())
self.quote_ctx.subscribe(code, SubType.RT_DATA)
ret_code_rt_data, ret_data_rt_data = self.quote_ctx.get_rt_data(code)
... | def aStockQoutation(self,code) | 订阅一只股票的实时行情数据，接收推送
:param code: 股票代码
:return: | 2.107579 | 2.014681 | 1.04611 |
bar = tiny_bar
symbol = bar.symbol
price = bar.open
up, down = self.track(symbol)
now = datetime.datetime.now()
work_time = now.replace(hour=9, minute=30, second=0)
if now == work_time:
self.before_minute_price = price
return
... | def on_bar_min1(self, tiny_bar) | 每一分钟触发一次回调 | 2.836279 | 2.804505 | 1.01133 |
quote_ctx = OpenQuoteContext(host='127.0.0.1', port=11111)
now = datetime.datetime.now()
end_str = now.strftime('%Y-%m-%d')
start = now - datetime.timedelta(days=365)
start_str = start.strftime('%Y-%m-%d')
_, temp = quote_ctx.get_history_kline(symbol, start=start_str, end... | def track(self, symbol) | 确定上下轨 | 2.489028 | 2.390671 | 1.041142 |
with self._mgr_lock:
with self._lock:
self._use_count += 1
if self._thread is None:
self._create_all()
self._thread = threading.Thread(target=self._thread_func)
self._thread.setDaemon(SysConfig.get_all_thread_daemo... | def start(self) | Should be called from main thread
:return: | 4.679489 | 4.811219 | 0.97262 |
obj = cls()
for field in obj.DESCRIPTOR.fields:
if not field.label == field.LABEL_REQUIRED:
continue
if not field.has_default_value:
continue
if not field.name in adict:
raise ConvertException('Field "%s" missing from descriptor dictionary.'
... | def dict2pb(cls, adict, strict=False) | Takes a class representing the ProtoBuf Message and fills it with data from
the dict. | 2.280597 | 2.252966 | 1.012264 |
adict = {}
if not obj.IsInitialized():
return None
for field in obj.DESCRIPTOR.fields:
if not getattr(obj, field.name):
continue
if not field.label == FD.LABEL_REPEATED:
if not field.type == FD.TYPE_MESSAGE:
adict[field.name] = getattr(obj... | def pb2dict(obj) | Takes a ProtoBuf Message obj and convertes it to a dict. | 1.775545 | 1.688292 | 1.051681 |
return dict2pb(cls, simplejson.loads(json), strict) | def json2pb(cls, json, strict=False) | Takes a class representing the Protobuf Message and fills it with data from
the json string. | 8.744045 | 12.213 | 0.715962 |
'''pre handler push
return: ret_error or ret_ok
'''
set_flag = False
for protoc in self._pre_handler_table:
if isinstance(handler, self._pre_handler_table[protoc]["type"]):
self._pre_handler_table[protoc]["obj"] = handler
return RET_OK
... | def set_pre_handler(self, handler) | pre handler push
return: ret_error or ret_ok | 6.844096 | 4.327336 | 1.581596 |
set_flag = False
for protoc in self._handler_table:
if isinstance(handler, self._handler_table[protoc]["type"]):
self._handler_table[protoc]["obj"] = handler
return RET_OK
if set_flag is False:
return RET_ERROR | def set_handler(self, handler) | set the callback processing object to be used by the receiving thread after receiving the data.User should set
their own callback object setting in order to achieve event driven.
:param handler:the object in callback handler base
:return: ret_error or ret_ok | 5.864461 | 5.071631 | 1.156326 |
if self.cb_check_recv is not None and not self.cb_check_recv() and ProtoId.is_proto_id_push(proto_id):
return
handler = self._default_handler
pre_handler = None
if proto_id in self._handler_table:
handler = self._handler_table[proto_id]['obj']
... | def recv_func(self, rsp_pb, proto_id) | receive response callback function | 2.836078 | 2.802464 | 1.011995 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
raw_acc_list = rsp_pb.s2c.accList
acc_list = [{
'acc_id': record.accID,
'trd_env': TRADE.REV_TRD_ENV_MAP[record.trdEnv] if record.trdEnv in TRADE.REV_TRD_ENV_MAP else "",
... | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 3.6114 | 3.581545 | 1.008336 |
from futuquant.common.pb.Trd_UnlockTrade_pb2 import Request
req = Request()
req.c2s.unlock = is_unlock
req.c2s.pwdMD5 = password_md5
return pack_pb_req(req, ProtoId.Trd_UnlockTrade, conn_id) | def pack_req(cls, is_unlock, password_md5, conn_id) | Convert from user request for trading days to PLS request | 3.484351 | 3.48436 | 0.999997 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
if rsp_pb.HasField('retMsg'):
return RET_OK, rsp_pb.retMsg, None
return RET_OK, "", None | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 4.002852 | 3.767695 | 1.062414 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
return RET_OK, "", None | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 5.64997 | 5.395726 | 1.047119 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
raw_funds = rsp_pb.s2c.funds
accinfo_list = [{
'power': raw_funds.power,
'total_assets': raw_funds.totalAssets,
'cash': raw_funds.cash,
'market_val': raw_funds... | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 3.210912 | 3.193005 | 1.005608 |
from futuquant.common.pb.Trd_GetPositionList_pb2 import Request
req = Request()
req.c2s.header.trdEnv = TRD_ENV_MAP[trd_env]
req.c2s.header.accID = acc_id
req.c2s.header.trdMarket = TRD_MKT_MAP[trd_mkt]
if code:
req.c2s.filterConditions.codeList.appen... | def pack_req(cls, code, pl_ratio_min,
pl_ratio_max, trd_env, acc_id, trd_mkt, conn_id) | Convert from user request for trading days to PLS request | 2.087986 | 2.193773 | 0.951779 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
raw_position_list = rsp_pb.s2c.positionList
position_list = [{
"code": merge_trd_mkt_stock_str(rsp_pb.s2c.header.trdMarket, position.code),
"stock_n... | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 2.307099 | 2.291486 | 1.006814 |
from futuquant.common.pb.Trd_GetOrderList_pb2 import Request
req = Request()
req.c2s.header.trdEnv = TRD_ENV_MAP[trd_env]
req.c2s.header.accID = acc_id
req.c2s.header.trdMarket = TRD_MKT_MAP[trd_mkt]
if code:
req.c2s.filterConditions.codeList.append(... | def pack_req(cls, order_id, status_filter_list, code, start, end,
trd_env, acc_id, trd_mkt, conn_id) | Convert from user request for trading days to PLS request | 2.029709 | 2.117067 | 0.958737 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
raw_order_list = rsp_pb.s2c.orderList
order_list = [OrderListQuery.parse_order(rsp_pb, order) for order in raw_order_list]
return RET_OK, "", order_list | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 4.02063 | 4.043612 | 0.994316 |
from futuquant.common.pb.Trd_PlaceOrder_pb2 import Request
req = Request()
serial_no = get_unique_id32()
req.c2s.packetID.serialNo = serial_no
req.c2s.packetID.connID = conn_id
req.c2s.header.trdEnv = TRD_ENV_MAP[trd_env]
req.c2s.header.accID = acc_id
... | def pack_req(cls, trd_side, order_type, price, qty,
code, adjust_limit, trd_env, sec_mkt_str, acc_id, trd_mkt, conn_id) | Convert from user request for place order to PLS request | 2.419263 | 2.49448 | 0.969847 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
order_id = str(rsp_pb.s2c.orderID)
return RET_OK, "", order_id | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 4.826351 | 4.851107 | 0.994897 |
from futuquant.common.pb.Trd_ModifyOrder_pb2 import Request
req = Request()
serial_no = get_unique_id32()
req.c2s.packetID.serialNo = serial_no
req.c2s.packetID.connID = conn_id
req.c2s.header.trdEnv = TRD_ENV_MAP[trd_env]
req.c2s.header.accID = acc_id
... | def pack_req(cls, modify_order_op, order_id, price, qty,
adjust_limit, trd_env, acc_id, trd_mkt, conn_id) | Convert from user request for place order to PLS request | 2.592449 | 2.715654 | 0.954632 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
order_id = str(rsp_pb.s2c.orderID)
modify_order_list = [{
'trd_env': TRADE.REV_TRD_ENV_MAP[rsp_pb.s2c.header.trdEnv],
'order_id': order_id
}]
return RET_OK, "", modif... | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 5.044299 | 5.076322 | 0.993692 |
from futuquant.common.pb.Trd_GetOrderFillList_pb2 import Request
req = Request()
req.c2s.header.trdEnv = TRD_ENV_MAP[trd_env]
req.c2s.header.accID = acc_id
req.c2s.header.trdMarket = TRD_MKT_MAP[trd_mkt]
if code:
req.c2s.filterConditions.codeList.app... | def pack_req(cls, code, trd_env, acc_id, trd_mkt, conn_id) | Convert from user request for place order to PLS request | 2.510081 | 2.561817 | 0.979805 |
if rsp_pb.retType != RET_OK:
return RET_ERROR, rsp_pb.retMsg, None
raw_deal_list = rsp_pb.s2c.orderFillList
deal_list = [DealListQuery.parse_deal(rsp_pb, deal) for deal in raw_deal_list]
return RET_OK, "", deal_list | def unpack_rsp(cls, rsp_pb) | Convert from PLS response to user response | 5.204016 | 5.091423 | 1.022114 |
ret_code, content = self.parse_rsp_pb(rsp_pb)
return ret_code, content | def on_recv_rsp(self, rsp_pb) | 在收到实摆盘数据推送后会回调到该函数，使用者需要在派生类中覆盖此方法
注意该回调是在独立子线程中
:param rsp_pb: 派生类中不需要直接处理该参数
:return: 参见get_order_book的返回值 | 5.116454 | 5.881272 | 0.869957 |
ret_code, content = self.parse_rsp_pb(rsp_pb)
if ret_code != RET_OK:
return ret_code, content
else:
col_list = [
'code', 'time', 'price', 'volume', 'turnover',
"ticker_direction", 'sequence', 'type', 'push_data_type',
... | def on_recv_rsp(self, rsp_pb) | 在收到实时逐笔数据推送后会回调到该函数，使用者需要在派生类中覆盖此方法
注意该回调是在独立子线程中
:param rsp_pb: 派生类中不需要直接处理该参数
:return: 参见get_rt_ticker的返回值 | 4.819226 | 4.115706 | 1.170935 |
ret_code, content = self.parse_rsp_pb(rsp_pb)
if ret_code != RET_OK:
return ret_code, content, None
else:
stock_code, bid_content, ask_content = content
bid_list = [
'code', 'bid_broker_id', 'bid_broker_name', 'bid_broker_pos'
... | def on_recv_rsp(self, rsp_pb) | 在收到实时经纪数据推送后会回调到该函数，使用者需要在派生类中覆盖此方法
注意该回调是在独立子线程中
:param rsp_pb: 派生类中不需要直接处理该参数
:return: 成功时返回(RET_OK, stock_code, [bid_frame_table, ask_frame_table]), 相关frame table含义见 get_broker_queue_ 的返回值说明
失败时返回(RET_ERROR, ERR_MSG, None) | 2.511085 | 1.942123 | 1.292959 |
ret_code, msg, conn_info_map = InitConnect.unpack_rsp(rsp_pb)
if self._notify_obj is not None:
self._notify_obj.on_async_init_connect(ret_code, msg, conn_info_map)
return ret_code, msg | def on_recv_rsp(self, rsp_pb) | receive response callback function | 5.186047 | 5.244874 | 0.988784 |
ret_code, msg, data = OrderDetail.unpack_rsp(rsp_pb)
if ret_code != RET_OK:
return ret_code, msg
else:
return RET_OK, data | def on_recv_rsp(self, rsp_pb) | receive response callback function | 4.515915 | 4.390602 | 1.028541 |
# TinyQuoteData
data = tiny_quote
str_log = "on_quote_changed symbol=%s open=%s high=%s close=%s low=%s" % (data.symbol, data.openPrice, data.highPrice, data.lastPrice, data.lowPrice)
self.log(str_log) | def on_quote_changed(self, tiny_quote) | 报价、摆盘实时数据变化时，会触发该回调 | 4.181411 | 3.672106 | 1.138696 |
return self._quant_frame.buy(price, volume, symbol, order_type, adjust_limit, acc_id) | def buy(self, price, volume, symbol, order_type=ft.OrderType.NORMAL, adjust_limit=0, acc_id=0) | 买入
:param price: 报价，浮点数 精度0.001
:param volume: 数量（股）
:param symbol: 股票 eg: 'HK.00700'
:param order_type: 订单类型
:param adjust_limit: 当非0时，会自动调整报价，以符合价位表要求， 但不会超过指定的幅度, 为0时不调整报价
:param acc_id: int, 交易账户id, 为0时取第1个可交易账户
:return: (ret, data)
ret == 0 , data = o... | 4.049726 | 5.678869 | 0.713122 |
if type(self._quant_frame) is not int:
return True
self._quant_frame = quant_frame
self._event_engine = event_engine
init_ret = self.__loadSetting(global_setting)
# 注册事件
self._event_engine.register(EVENT_BEFORE_TRADING, self.__event_before_trading)... | def init_strate(self, global_setting, quant_frame, event_engine) | TinyQuantFrame 初始化策略的接口 | 2.866311 | 2.827935 | 1.01357 |
# 添加必要的股票，以便能得到相应的股票行情数据
self.symbol_pools.append(self.symbol_ref)
if self.cta_call["enable"]:
self.symbol_pools.append(self.cta_call["symbol"])
if self.cta_put["enable"]:
self.symbol_pools.append(self.cta_put["symbol"])
# call put 的持仓量以及持仓天数
... | def on_init_strate(self) | 策略加载完配置 | 4.005172 | 3.959468 | 1.011543 |
# 读取用户现有帐户持仓信息， 数量不超过config中指定的交易数量 'trade_qty'
for cta in [self.cta_call, self.cta_put]:
pos = self.get_tiny_position(cta['symbol'])
if pos is not None:
valid_pos = pos.position - pos.frozen
valid_pos = valid_pos if valid_pos > 0 else 0
... | def on_start(self) | 策略启动入口 | 6.416731 | 6.189519 | 1.036709 |
# TinyQuoteData
if tiny_quote.symbol != self.symbol_ref:
return
# 减少计算频率，每x秒一次
dt_now = time.time()
if dt_now - self._last_dt_process < 2:
return
self._last_dt_process = dt_now
# 执行策略
self._process_cta(self.cta_call)
... | def on_quote_changed(self, tiny_quote) | 报价、摆盘实时数据变化时，会触发该回调 | 6.475973 | 6.063475 | 1.06803 |
if self.cta_call['pos'] > 0:
self.cta_call['days'] += 1
if self.cta_put['pos'] > 0:
self.cta_put['days'] += 1
self.cta_call['done'] = False
self.cta_put['done'] = False | def on_before_trading(self, date_time) | 开盘的时候检查，如果有持仓，就把持有天数 + 1 | 3.21601 | 2.829041 | 1.136785 |
self._update_cta_pos(self.cta_call)
self._update_cta_pos(self.cta_put) | def on_after_trading(self, date_time) | 收盘的时候更新持仓信息 | 6.682808 | 5.693149 | 1.173833 |
if n < 2:
result = np_array
else:
result = talib.EMA(np_array, n)
if array:
return result
return result[-1] | def ema(self, np_array, n, array=False) | 移动均线 | 2.8284 | 2.466107 | 1.146909 |
self.__is_acc_sub_push = False
self.__last_acc_list = []
ret, msg = RET_OK, ''
# auto unlock trade
if self._ctx_unlock is not None:
password, password_md5 = self._ctx_unlock
ret, data = self.unlock_trade(password, password_md5)
logger... | def on_api_socket_reconnected(self) | for API socket reconnected | 6.489609 | 6.310537 | 1.028377 |
query_processor = self._get_sync_query_processor(
GetAccountList.pack_req, GetAccountList.unpack_rsp)
kargs = {
'user_id': self.get_login_user_id(),
'conn_id': self.get_sync_conn_id()
}
ret_code, msg, acc_list = query_processor(**kargs)
... | def get_acc_list(self) | :return: (ret, data) | 3.769234 | 3.617306 | 1.042 |
# 仅支持真实交易的市场可以解锁，模拟交易不需要解锁
md5_val = ''
if is_unlock:
ret = TRADE.check_mkt_envtype(self.__trd_mkt, TrdEnv.REAL)
if not ret:
return RET_OK, Err.NoNeedUnlock.text
if password is None and password_md5 is None:
return RE... | def unlock_trade(self, password=None, password_md5=None, is_unlock=True) | 交易解锁，安全考虑，所有的交易api,需成功解锁后才可操作
:param password: 明文密码字符串 (二选一）
:param password_md5: 密码的md5字符串（二选一）
:param is_unlock: 解锁 = True, 锁定 = False
:return:(ret, data) ret == RET_OK时, data为None，如果之前已经解锁过了，data为提示字符串，指示出已经解锁
ret != RET_OK时， data为错误字符串 | 5.255801 | 5.168529 | 1.016885 |
kargs = {
'acc_id_list': acc_id_list,
'conn_id': self.get_async_conn_id(),
}
ret_code, msg, push_req_str = SubAccPush.pack_req(**kargs)
if ret_code == RET_OK:
self._send_async_req(push_req_str)
return RET_OK, None | def _async_sub_acc_push(self, acc_id_list) | 异步连接指定要接收送的acc id
:param acc_id:
:return: | 4.853071 | 4.409248 | 1.100657 |
ret, msg = self._check_trd_env(trd_env)
if ret != RET_OK:
return ret, msg
ret, msg, acc_id = self._check_acc_id_and_acc_index(trd_env, acc_id, acc_index)
if ret != RET_OK:
return ret, msg
query_processor = self._get_sync_query_processor(
... | def accinfo_query(self, trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | :param trd_env:
:param acc_id:
:param acc_index:
:return: | 2.927935 | 2.942591 | 0.995019 |
stock_str = str(code)
split_loc = stock_str.find(".")
'''do not use the built-in split function in python.
The built-in function cannot handle some stock strings correctly.
for instance, US..DJI, where the dot . itself is a part of original code'''
if 0 <= split_loc < le... | def _split_stock_code(self, code) | do not use the built-in split function in python.
The built-in function cannot handle some stock strings correctly.
for instance, US..DJI, where the dot . itself is a part of original code | 5.214606 | 2.82579 | 1.845362 |
ret, msg = self._check_trd_env(trd_env)
if ret != RET_OK:
return ret, msg
ret, msg, acc_id = self._check_acc_id_and_acc_index(trd_env, acc_id, acc_index)
if ret != RET_OK:
return ret, msg
ret, msg, stock_code = self._check_stock_code(code)
... | def position_list_query(self, code='', pl_ratio_min=None,
pl_ratio_max=None, trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | for querying the position list | 2.290987 | 2.308026 | 0.992618 |
# ret, msg = self._check_trd_env(trd_env)
# if ret != RET_OK:
# return ret, msg
ret, msg, acc_id = self._check_acc_id_and_acc_index(trd_env, acc_id, acc_index)
if ret != RET_OK:
return ret, msg
ret, content = self._split_stock_code(code)
... | def place_order(self, price, qty, code, trd_side, order_type=OrderType.NORMAL,
adjust_limit=0, trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | place order
use set_handle(HKTradeOrderHandlerBase) to recv order push ! | 3.004401 | 2.990206 | 1.004747 |
ret, msg = self._check_trd_env(trd_env)
if ret != RET_OK:
return ret, msg
ret, msg, acc_id = self._check_acc_id_and_acc_index(trd_env, acc_id, acc_index)
if ret != RET_OK:
return ret, msg
ret, msg, stock_code = self._check_stock_code(code)
... | def deal_list_query(self, code="", trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | for querying deal list | 2.450918 | 2.462568 | 0.995269 |
ret, msg = self._check_trd_env(trd_env)
if ret != RET_OK:
return ret, msg
ret, msg, acc_id = self._check_acc_id_and_acc_index(trd_env, acc_id, acc_index)
if ret != RET_OK:
return ret, msg
ret, content = self._split_stock_code(code)
if re... | def acctradinginfo_query(self, order_type, code, price, order_id=None, adjust_limit=0, trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | 查询账户下最大可买卖数量
:param order_type: 订单类型，参见OrderType
:param code: 证券代码，例如'HK.00700'
:param price: 报价，3位精度
:param order_id: 订单号。如果是新下单，则可以传None。如果是改单则要传单号。
:param adjust_limit: 调整方向和调整幅度百分比限制，正数代表向上调整，负数代表向下调整，具体值代表调整幅度限制，如：0.015代表向上调整且幅度不超过1.5%；-0.01代表向下调整且幅度不超过1%。默认0表示不调整
:p... | 2.79876 | 2.353986 | 1.188945 |
return super(OpenHKCCTradeContext, self).order_list_query(order_id, status_filter_list, code, start, end, trd_env, acc_id, acc_index) | def order_list_query(self, order_id="", status_filter_list=[], code='', start='', end='',
trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | :param order_id:
:param status_filter_list:
:param code:
:param start:
:param end:
:param trd_env:
:param acc_id:
:return: 返回值见基类及接口文档，但order_type仅有OrderType.NORMAL, order_status没有OrderStatus.DISABLED | 2.905732 | 3.462579 | 0.839181 |
return super(OpenHKCCTradeContext, self).modify_order(modify_order_op=modify_order_op,
order_id=order_id,
qty=qty,
price=price,
adjust_limit=adjust_limit,
... | def modify_order(self, modify_order_op, order_id, qty, price, adjust_limit=0, trd_env=TrdEnv.REAL, acc_id=0, acc_index=0) | 详细说明见基类接口说明，但有以下不同：不支持改单。 可撤单。删除订单是本地操作。
:param modify_order_op:
:param order_id:
:param qty:
:param price:
:param adjust_limit:
:param trd_env:
:param acc_id:
:return: | 2.064162 | 2.334654 | 0.884141 |
# TinyQuoteData
data = tiny_quote
symbol = data.symbol
str_dt = data.datetime.strftime("%Y%m%d %H:%M:%S")
# 得到日k数据的ArrayManager(vnpy)对象
am = self.get_kl_day_am(data.symbol)
array_high = am.high
array_low = am.low
array_open = am.open
... | def on_quote_changed(self, tiny_quote) | 报价、摆盘实时数据变化时，会触发该回调 | 2.785714 | 2.656111 | 1.048794 |
bar = tiny_bar
symbol = bar.symbol
str_dt = bar.datetime.strftime("%Y%m%d %H:%M:%S")
# 得到分k数据的ArrayManager(vnpy)对象
am = self.get_kl_min1_am(symbol)
array_high = am.high
array_low = am.low
array_open = am.open
array_close = am.close
... | def on_bar_min1(self, tiny_bar) | 每一分钟触发一次回调 | 2.608114 | 2.570297 | 1.014713 |
bar = tiny_bar
symbol = bar.symbol
str_dt = bar.datetime.strftime("%Y%m%d %H:%M:%S")
str_log = "on_bar_day symbol=%s dt=%s open=%s high=%s close=%s low=%s vol=%s" % (
symbol, str_dt, bar.open, bar.high, bar.close, bar.low, bar.volume)
self.log(str_log) | def on_bar_day(self, tiny_bar) | 收盘时会触发一次日k回调 | 2.389414 | 2.284781 | 1.045795 |
if n < 2:
result = np_array
else:
result = talib.SMA(np_array, n)
if array:
return result
return result[-1] | def sma(self, np_array, n, array=False) | 简单均线 | 2.491733 | 2.392501 | 1.041476 |
data = tiny_quote
symbol = data.symbol
price = data.open
#print(price)
now = datetime.datetime.now()
work_time = now.replace(hour=15, minute=55, second=0)
if now >= work_time:
ma_20 = self.get_sma(20, symbol)
ma_60 = sel... | def on_bar_min1(self, tiny_quote) | 每一分钟触发一次回调 | 2.733975 | 2.70877 | 1.009305 |
while self.__active == True:
try:
event = self.__queue.get(block = True, timeout = 1) # 获取事件的阻塞时间设为1秒
self.__process(event)
except Empty:
pass | def __run(self) | 引擎运行 | 4.397663 | 3.868042 | 1.136922 |
# 检查是否存在对该事件进行监听的处理函数
if event.type_ in self.__handlers:
# 若存在，则按顺序将事件传递给处理函数执行
[handler(event) for handler in self.__handlers[event.type_]]
# 以上语句为Python列表解析方式的写法，对应的常规循环写法为：
#for handler in self.__handlers[event.type_]:
... | def __process(self, event) | 处理事件 | 5.535668 | 5.195815 | 1.065409 |
# 将引擎设为启动
self.__active = True
# 启动事件处理线程
self.__thread.start()
# 启动计时器，计时器事件间隔默认设定为1秒
if timer:
self.__timer.start(1000) | def start(self, timer=True) | 引擎启动
timer：是否要启动计时器 | 5.633195 | 5.089653 | 1.106793 |
# 将引擎设为停止
self.__active = False
# 停止计时器
self.__timer.stop()
# 等待事件处理线程退出
self.__thread.join() | def stop(self) | 停止引擎 | 7.656974 | 6.145598 | 1.245928 |
# 尝试获取该事件类型对应的处理函数列表，若无defaultDict会自动创建新的list
handlerList = self.__handlers[type_]
# 若要注册的处理器不在该事件的处理器列表中，则注册该事件
if handler not in handlerList:
handlerList.append(handler) | def register(self, type_, handler) | 注册事件处理函数监听 | 7.107449 | 6.588154 | 1.078823 |
# 尝试获取该事件类型对应的处理函数列表，若无则忽略该次注销请求
handlerList = self.__handlers[type_]
# 如果该函数存在于列表中，则移除
if handler in handlerList:
handlerList.remove(handler)
# 如果函数列表为空，则从引擎中移除该事件类型
if not handlerList:
del self.__handlers[type_] | def unregister(self, type_, handler) | 注销事件处理函数监听 | 5.147274 | 4.696007 | 1.096096 |
if handler not in self.__generalHandlers:
self.__generalHandlers.append(handler) | def registerGeneralHandler(self, handler) | 注册通用事件处理函数监听 | 3.553724 | 3.506304 | 1.013524 |
if handler in self.__generalHandlers:
self.__generalHandlers.remove(handler) | def unregisterGeneralHandler(self, handler) | 注销通用事件处理函数监听 | 3.458196 | 3.369162 | 1.026426 |
while self.__timerActive:
# 创建计时器事件
event = Event(type_=EVENT_TIMER)
# 向队列中存入计时器事件
self.put(event)
# 等待
sleep(self.__timerSleep) | def __runTimer(self) | 运行在计时器线程中的循环函数 | 6.767612 | 6.083864 | 1.112387 |
# 将引擎设为停止
self.__active = False
# 停止计时器
self.__timerActive = False
self.__timer.join()
# 等待事件处理线程退出
self.__thread.join() | def stop(self) | 停止引擎 | 7.843931 | 6.528083 | 1.201567 |
stock_code_list = ["US.AAPL", "HK.00700"]
# subscribe "QUOTE"
ret_status, ret_data = quote_ctx.subscribe(stock_code_list, ft.SubType.QUOTE)
if ret_status != ft.RET_OK:
print("%s %s: %s" % (stock_code_list, "QUOTE", ret_data))
exit()
ret_status, ret_data = quote_ctx.query_subsc... | def _example_stock_quote(quote_ctx) | 获取批量报价，输出 股票名称，时间，当前价，开盘价，最高价，最低价，昨天收盘价，成交量，成交额，换手率，振幅，股票状态 | 2.633357 | 2.547395 | 1.033745 |
# subscribe Kline
stock_code_list = ["US.AAPL", "HK.00700"]
sub_type_list = [ft.SubType.K_1M, ft.SubType.K_5M, ft.SubType.K_15M, ft.SubType.K_30M, ft.SubType.K_60M,
ft.SubType.K_DAY, ft.SubType.K_WEEK, ft.SubType.K_MON]
ret_status, ret_data = quote_ctx.subscribe(stock_code_lis... | def _example_cur_kline(quote_ctx) | 获取当前K线，输出 股票代码，时间，开盘价，收盘价，最高价，最低价，成交量，成交额 | 2.10855 | 2.074856 | 1.016239 |
stock_code_list = ["HK.00700", "US.AAPL"]
# subscribe "TICKER"
ret_status, ret_data = quote_ctx.subscribe(stock_code_list, ft.SubType.TICKER)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
for stk_code in stock_code_list:
ret_status, ret_data = quote_ctx.get_rt_tic... | def _example_rt_ticker(quote_ctx) | 获取逐笔，输出 股票代码，时间，价格，成交量，成交金额，暂时没什么意义的序列号 | 2.667921 | 2.550959 | 1.04585 |
stock_code_list = ["US.AAPL", "HK.00700"]
# subscribe "ORDER_BOOK"
ret_status, ret_data = quote_ctx.subscribe(stock_code_list, ft.SubType.ORDER_BOOK)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
for stk_code in stock_code_list:
ret_status, ret_data = quote_ctx.ge... | def _example_order_book(quote_ctx) | 获取摆盘数据，输出 买价，买量，买盘经纪个数，卖价，卖量，卖盘经纪个数 | 2.693496 | 2.625995 | 1.025705 |
ret_status, ret_data = quote_ctx.get_trading_days("US", None, None)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
print("TRADING DAYS")
for x in ret_data:
print(x) | def _example_get_trade_days(quote_ctx) | 获取交易日列表，输出 交易日列表 | 4.342785 | 4.206146 | 1.032486 |
ret_status, ret_data = quote_ctx.get_stock_basicinfo(ft.Market.HK, ft.SecurityType.STOCK)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
print("stock_basic")
print(ret_data) | def _example_stock_basic(quote_ctx) | 获取股票信息，输出 股票代码，股票名，每手数量，股票类型，子类型所属正股 | 3.540186 | 3.330098 | 1.063088 |
ret_status, ret_data = quote_ctx.get_market_snapshot(["US.AAPL", "HK.00700"])
if ret_status != ft.RET_OK:
print(ret_data)
exit()
print("market_snapshot")
print(ret_data) | def _example_get_market_snapshot(quote_ctx) | 获取市场快照，输出 股票代码，更新时间，按盘价，开盘价，最高价，最低价，昨天收盘价，成交量，成交额，换手率，
停牌状态，上市日期，流通市值，总市值，是否涡轮，换股比例，窝轮类型，行使价格，格式化窝轮到期时间，
格式化窝轮最后到期时间，窝轮对应的正股，窝轮回收价，窝轮街货量，窝轮发行量，窝轮街货占比，窝轮对冲值，窝轮引伸波幅，
窝轮溢价 | 3.814023 | 3.766618 | 1.012585 |
stock_code_list = ["US.AAPL", "HK.00700"]
ret_status, ret_data = quote_ctx.subscribe(stock_code_list, ft.SubType.RT_DATA)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
for stk_code in stock_code_list:
ret_status, ret_data = quote_ctx.get_rt_data(stk_code)
if r... | def _example_rt_data(quote_ctx) | 获取分时数据，输出 时间，数据状态，开盘多少分钟，目前价，昨收价，平均价，成交量，成交额 | 2.487564 | 2.451915 | 1.014539 |
ret_status, ret_data = quote_ctx.get_plate_list(ft.Market.SZ, ft.Plate.ALL)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
print("plate_subplate")
print(ret_data) | def _example_plate_subplate(quote_ctx) | 获取板块集合下的子板块列表，输出 市场，板块分类,板块代码，名称，ID | 4.327622 | 3.911717 | 1.106323 |
ret_status, ret_data = quote_ctx.get_plate_stock("SH.BK0531")
if ret_status != ft.RET_OK:
print(ret_data)
exit()
print("plate_stock")
print(ret_data) | def _example_plate_stock(quote_ctx) | 获取板块下的股票列表，输出 市场，股票每手，股票名称，所属市场，子类型，股票类型 | 4.630606 | 4.69921 | 0.985401 |
stock_code_list = ["HK.00700"]
for stk_code in stock_code_list:
ret_status, ret_data = quote_ctx.subscribe(stk_code, ft.SubType.BROKER)
if ret_status != ft.RET_OK:
print(ret_data)
exit()
for stk_code in stock_code_list:
ret_status, bid_data, ask_data = ... | def _example_broker_queue(quote_ctx) | 获取经纪队列，输出 买盘卖盘的经纪ID，经纪名称，经纪档位 | 2.713614 | 2.564039 | 1.058335 |
self._socket_lock.acquire()
self._force_close_session()
self._socket_lock.release() | def close_socket(self) | close socket | 6.205824 | 5.462142 | 1.136152 |
self._socket_lock.acquire()
try:
ret = self._is_socket_ok(timeout_select)
finally:
self._socket_lock.release()
return ret | def is_sock_ok(self, timeout_select) | check if socket is OK | 2.554516 | 2.313234 | 1.104305 |
req_proto_id = 0
try:
is_socket_lock = False
ret, msg = self._create_session(is_create_socket)
if ret != RET_OK:
return ret, msg, None
self._socket_lock.acquire()
if not self.s:
self._socket_lock.releas... | def network_query(self, req_str, is_create_socket=True) | the function sends req_str to FUTU client and try to get response from the client.
:param req_str
:return: rsp_str | 2.74155 | 2.747017 | 0.99801 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.