Bloomberg API：如何将请求与IntradayBarRequest上的响应关联？

不幸的是，我在论坛上引导相信（但没有100％确定性）彭博桌面API一次不允许多个IntradayBarRequest或IntradayTickRequest，这与HistoricalDataRequest或Subscriptions不同，其中多个同时请求是允许。Bloomberg API：如何将请求与IntradayBarRequest上的响应关联？

这个问题是因此很可能没有实际意义，除非有人告诉我，上面是不是真的

如果为真，那么处理以下问题的唯一办法，就是只有在发送每一个新的请求前一个已经处理完毕。

我使用Python彭博桌面API访问订阅（即时更新）和历史每日数据为金融证券。在这两种情况下，我都可以发送多个同时发送的请求，并且在响应到达时（不一定按发送请求的顺序），我可以使用msg.getElement（“securityData”）找出响应与哪个安全相关联.getElementAsString（“security”）在历史数据的情况下，或者在订阅数据的情况下，通过使用msg.correlationIds（）[0] .value（）事先查询我已经设置的correlationId（在订阅请求时）。

然而，我不知道如何为IntradayBarResponse请求（和WAPI文档没有帮助）做到这一点。这些似乎没有setable correlationId，也没有上述“securityData”字段。如果我发送多个intradayBarRequests，我如何才能找出响应的安全性？

这是我的代码（改编自API Python示例）。

import blpapi # interface to bloomberg 
import time # will need this for time parsing 
from optparse import OptionParser 
import pdb  # debugger, when necessary 
import csv  # for csv reading 
import string # for string parsing 
from pymongo import MongoClient 
import inspect 
from datetime import datetime 
from bson.son import SON 


def parseCmdLine(): 
    parser = OptionParser(description="Retrieve realtime data.") 
    parser.add_option("-a", 
         "--ip", 
         dest="host", 
         help="server name or IP (default: %default)", 
         metavar="ipAddress", 
         default="localhost") 
    parser.add_option("-p", 
         dest="port", 
         type="int", 
         help="server port (default: %default)", 
         metavar="tcpPort", 
         default=8194) 
    parser.add_option("--me", 
         dest="maxEvents", 
         type="int", 
         help="stop after this many events (default: %default)", 
         metavar="maxEvents", 
         default=100000000000) 
    parser.add_option("--mongohost", 
         dest="mongohost", 
         default="192.168.1.30") 
    parser.add_option("--mongoport", 
         dest="mongoport", 
         type="int", 
         default=27017) 

    (options, args) = parser.parse_args() 

    return options 


def main(): 
    options = parseCmdLine() 

    # connect to MongoDB MONGO MONGO MONGO MONGO ---------------- 
    print "Connecting to MongoDB" 
    print options.mongohost 
    print options.mongoport 
    client = MongoClient(options.mongohost, options.mongoport) # connect to MongoDB 
    db = client.bb # connect to the DB database 
    bbsecs = db.bbsecs 
    bbticks = db.bbticks 
    # now get the securities list 


    # Fill SessionOptions 
    sessionOptions = blpapi.SessionOptions() 
    sessionOptions.setServerHost(options.host) 
    sessionOptions.setServerPort(options.port) 

    print "connecting to Bloomberg" 
    print "Connecting to %s:%d" % (options.host, options.port) 

    # Create a Session 
    session = blpapi.Session(sessionOptions) 

    # Start a Session 
    if not session.start(): 
     print "Failed to start session." 
     return 

    # open the market data subscription service 
    if not session.openService("//blp/mktbar"): 
     print "Failed to open //blp/mktbar" 
     return 
    if not session.openService("//blp/refdata"): 
     print "Failed to open //blp/refdata" 
     return 



    # now startup the subscription list 
    # Now open the secs.dat file and read it, append each to subscription list 
    maxtimes = bbticks.aggregate([{'$group': {'_id':'$ticker', 'maxtime':{'$max': '$time'}}}]) # get the last updates by ticker 
    refDataService = session.getService("//blp/refdata") # start the ref 
    for i in maxtimes["result"]: 
     ticker = i["_id"] 
     tstamp = i["maxtime"] 
     request = refDataService.createRequest("IntradayBarRequest") 
     request.set("security", ticker) 
     request.set("eventType", "TRADE") 
     request.set("interval", 1) 
     request.set("startDateTime", tstamp) 
     request.set("endDateTime", datetime.now()) 
     print "Sending Request:", ticker 
     session.sendRequest(request) 

    subscriptions = blpapi.SubscriptionList() 
    secdic = dict() # a new dictionary 
    for post in bbsecs.find(): 
     print(post["ticker"]) 
     # subscribe tick 
     #subscriptions.add(str(post["ticker"]), "LAST_PRICE", [], blpapi.CorrelationId("TICK:" + str(post["ticker"]))) 
     #subscribe 1 minute bars 
     subscriptions.add("//blp/mktbar/ticker/"+str(post["ticker"]), 
          "LAST_PRICE", 
          "interval=1.0", 
          blpapi.CorrelationId(str(post["ticker"]))) 
     # setup the dictionary 
     secdic[post["bbsecnum"]] = post["ticker"] 
    if not session.openService("//blp/refdata"): 
     print "Failed to open //blp/refdata" 
     return 
    # now subscribe 
    session.subscribe(subscriptions) 


    # HISTORICALHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH 
    # Obtain previously opened service 
    #refDataService = session.getService("//blp/refdata") 
    # Create and fill the request for the historical data 
    #request = refDataService.createRequest("HistoricalDataRequest") 
    #for post in bbsecs.find(): 
    # request.getElement("securities").appendValue(str(post["ticker"])) 
    #request.getElement("fields").appendValue("LAST_PRICE") 
    #request.set("periodicityAdjustment", "ACTUAL") 
    #request.set("periodicitySelection", "DAILY") 
    #request.set("startDate", "20100101") 
    #request.set("endDate", "20121231") 
    #request.set("maxDataPoints", 2000) 
    #print "Sending Request:", request 
    # Send the request 
    #session.sendRequest(request) 
    #hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh 


    try: 
     # Process received events 
     eventCount = 0 
     while(True): 
      # We provide timeout to give the chance to Ctrl+C handling: 
      event = session.nextEvent(500) 
      for msg in event: 
       if event.eventType() == blpapi.Event.SUBSCRIPTION_STATUS: 
        #print "%s - %s" % (msg.correlationIds()[0].value(), msg) 
        print "subscription status" 
       elif event.eventType() == blpapi.Event.SUBSCRIPTION_DATA: 
        key = msg.correlationIds()[0].value() 
        if msg.messageType() == "MarketBarStart": 
         open = msg.getElementAsFloat("OPEN") 
         high = msg.getElementAsFloat("HIGH") 
         low = msg.getElementAsFloat("LOW") 
         close = msg.getElementAsFloat("CLOSE") 
         btstamp = msg.getElementAsDatetime("TIME") 
         tstamp = datetime.now() 
         print "bar", key, close, tstamp 
         bbticks.insert({"type": "BAR", "ticker": key, "value": close, \ 
           "open": open, "high": high, "low": low, "close": close, \ 
           "time": tstamp}) 
        elif msg.messageType() == "MarketBarUpdate": 
         close = msg.getElementAsFloat("CLOSE") 
         #print "tick", close, 
         #bbticks.insert({"type": "TICK", "ticker": key, "value": close, "time": tstamp}) 

        #if etype == "TRADE": 
        # if msg.hasElement("LAST_TRADE"): 
        #  key = msg.correlationIds()[0].value(), 
        #  keytype = key[:(key.index(":"))] 
        #  key = key[(key.index(":") + 1):] 
        #  value = msg.getElementAsString("LAST_TRADE") 
        #  timestamp = msg.getElementAsDatetime("TRADE_UPDATE_STAMP_RT") 
        #  print key, value, 
        #  bbticks.insert({"ticker": key, "value": value, "timestamp": timestamp}) 

       else: 
        if msg.messageType() == "HistoricalDataResponse": 
         securityData = msg.getElement("securityData") 
         security = securityData.getElementAsString("security") 
         fieldDataArray = securityData.getElement("fieldData") 
         for j in range(0, fieldDataArray.numValues()): 
          fieldData = fieldDataArray.getValueAsElement(j) 
          field = fieldData.getElement(0) 
          tstamp = field.getValueAsDatetime() 
          tstamp = datetime(tstamp.year, tstamp.month, tstamp.day) 
          field = fieldData.getElement(1) 
          close = field.getValueAsFloat() 
          #print "history", security, close, 
          #bbticks.insert({"type": "DAILY", "ticker": security, "value": close, "close": close, \ 
          #  "time": tstamp}) 
        elif msg.messageType() == "IntradayBarResponse": 
         print "IntradayBarResponse" 
         data = msg.getElement("barData").getElement("barTickData") 
         numvals = data.numValues() 
         print numvals 
         if numvals > 0: 
          print data.getValueAsElement(1).getElement(1).getValueAsFloat() 



      if event.eventType() == blpapi.Event.SUBSCRIPTION_DATA: 
       eventCount += 1 
       if eventCount >= options.maxEvents: 
        break 
    finally: 
     # Stop the session 
     session.stop() 

if __name__ == "__main__": 
    try: 
     main() 
    except KeyboardInterrupt: 
     print "Ctrl+C pressed. Stopping..."

我已经看过了eidData，即使我要求它被返回，它也是空的。我正在研究货币，而不是股票，所以不需要交换权利。

> (Pdb) print eid._Element__dataHolder IntradayBarResponse = { 
>  barData = { 
>   eidData[] = { 
>   } 
>   barTickData[] = { 
>    barTickData = { 
>     time = 2013-08-02T18:36:00.000 
>     open = 4.233100 
>     high = 4.233600 
>     low = 4.233100 
>     close = 4.233400 
>     volume = 0 
>     numEvents = 119 
>     value = 0.000000 
>    } 
>    barTickData = { 
>     time = 2013-08-02T18:37:00.000 
>     open = 4.233400 
>     high = 4.233700 
>     low = 4.233100 
>     close = 4.233500 
>     volume = 0 
>     numEvents = 96 
>     value = 0.000000 
>    } 
>    barTickData = { 
>     time = 2013-08-02T18:38:00.000 
>     open = 4.233500 
>     high = 4.233600 
>     low = 4.233300 
>     close = 4.233500 
>     volume = 0 
>     numEvents = 135 
>     value = 0.000000 
>    } 
>    barTickData = { 
>     time = 2013-08-02T18:39:00.000

我仍然在寻找一种方式，以响应请求，而无需做效率低下的请求关联....等待回应....要求等。我不知道，如果彭博社提供此功能但是。此限制似乎也存在于历史记录数据中。

来源

2013-08-03 Thomas Browne

鉴于此服务每月需要花费数千美元，所以我建议您询问提供商。 –

相信与否，这已经发生在我身上。但是，如果您要进一步调查，您将知道SERVER api每月需要花费数千美元，并且这是“提供商”提供官方API支持的唯一API。使用台式机API，确实花费数千美元，但远低于服务器，但没有支持（可疑的彭博商业战略让人们支付更多费用）。因此我的问题。谢谢。 –

我没有使用Python API，我使用的是.Net，但是我知道你可以同时有几个IntradayBarRequests“在空中”。我使用CorrelID，它工作正常。据我所知， – ytoledano

托马斯，您应该始终使用响应的correlationId来查找它与哪个请求相关联。 IIRC，参考数据和历史数据请求支持多种证券，但市场数据和日内条形图每个请求可能只有一个安全性。

这就是为什么refdata和历史响应中存在额外的“securityData”字段的原因。对于市场数据和盘中酒吧而言，相关ID足以识别请求并从而确定安全性。

希望它有帮助。

来源

2013-08-03 15:16:54

历史盘中线条（API中的“IntradayBarRequest”）不支持可设置的相关ID。那就是问题所在。答案* do *有一个相关ID，是的，但它不是用户可以设置的，据我所知，因此是无用的。一个人被迫请求，处理直到完成，然后再次请求。与历史日常数据（securityData）或实时订阅（settable correlationId）不同，在这里可以进行批量处理，这要归功于将响应与请求链接起来。 –

我不知道python API，但我使用Java API。

我仍在寻找一种将请求与响应相关联的方式，而不必执行低效率请求....等待响应....请求等。

当你发现，你不能将查询发送多个证券IntradayBarRequests和饲料不包含安全ID（如行情）方便地返回映射到您的查询。

最简单的解决方案是使用关联ID。向会话提交请求时，您可以提供自己的关联标识。下面的例子是在Java中，但我认为，蟒蛇API是相似的：

Session session = ...; //Bloomberg Session 
CorrelationId cId = new CorrelationId(); //Unique ID 
session.sendRequest(bbRequest, cId); //provide your own ID

然后，如果您使用的是异步会话，您将收到该有一个链接到原来的correlationID异步消息：

public void processEvent(Event event, Session session) { 
    for (Message msg : event) { 
     CorrelationID cId = msg.correlationID(); 
     //here you can link the result back to your original query 
    } 
}

来源

2013-08-03 21:45:44 assylias

谢谢，但我试过了，并且在Python API中出现了重复的关联ID错误。我将在明天致电彭博社的支持，试图解决这个问题。 –

每个关联应该是唯一的。您也可以提供您自己的ID。在Java中：'new CorrelationID（1）;'例如Id为1。 – assylias

@ThomasBrowne你是否设法使它工作？ – assylias

我不相信你可以下标勾选或禁止数据。这就是为什么... 对于定价数据，您会在每次更改值时收到回复。不是勾选数据只是这些价格的历史？对于小节数据，这不是一个价格的历史记录，通过按照一段时间（即10分钟，1小时）进行分组来删除一些细节。所以如果你可以订阅，你应该什么时候收到彭博社的每一个新回复？本质上，您可以创建自己的侦听器来完成分组，然后从侦听器以您自己选择的频率发出响应。

顺便说一句：我使用CLR与python的.net blp对象交谈。我的解决方案早于任何支持彭博的Python，基本上做了'不能做'的事情。

来源

2013-11-23 18:14:13 Alfista

Bloomberg API：如何将请求与IntradayBarRequest上的响应关联？

回答

相关问题