def authorize(authService, identity, session, cid):
tokenEventQueue = blpapi.EventQueue()
session.generateToken(eventQueue=tokenEventQueue)
# Process related response
ev = tokenEventQueue.nextEvent()
token = None
if ev.eventType() == blpapi.Event.TOKEN_STATUS or \
ev.eventType() == blpapi.Event.REQUEST_STATUS:
for msg in ev:
print(msg)
if msg.messageType() == TOKEN_SUCCESS:
token = msg.getElementAsString(TOKEN)
elif msg.messageType() == TOKEN_FAILURE:
break
if not token:
print("Failed to get token")
return False
# Create and fill the authorithation request
authRequest = authService.createAuthorizationRequest()
authRequest.set(TOKEN, token)
# Send authorithation request to "fill" the Identity
session.sendAuthorizationRequest(authRequest, identity, cid)
# Process related responses
startTime = datetime.datetime.today()
WAIT_TIME_SECONDS = 10
while True:
event = session.nextEvent(WAIT_TIME_SECONDS * 1000)
if event.eventType() == blpapi.Event.RESPONSE or \
event.eventType() == blpapi.Event.REQUEST_STATUS or \
event.eventType() == blpapi.Event.PARTIAL_RESPONSE:
for msg in event:
print(msg)
if msg.messageType() == AUTHORIZATION_SUCCESS:
return True
print("Authorization failed")
return False
endTime = datetime.datetime.today()
if endTime - startTime > datetime.timedelta(seconds=WAIT_TIME_SECONDS):
return False
def authorize(authService, identity, session, cid):
with g_mutex:
g_authorizationStatus[cid] = AuthorizationStatus.WAITING
tokenEventQueue = blpapi.EventQueue()
# Generate token
session.generateToken(eventQueue=tokenEventQueue)
# Process related response
ev = tokenEventQueue.nextEvent()
token = None
if ev.eventType() == blpapi.Event.TOKEN_STATUS or \
ev.eventType() == blpapi.Event.REQUEST_STATUS:
for msg in ev:
print msg
if msg.messageType() == TOKEN_SUCCESS:
token = msg.getElementAsString(TOKEN)
elif msg.messageType() == TOKEN_FAILURE:
break
if not token:
print "Failed to get token"
return False
# Create and fill the authorithation request
authRequest = authService.createAuthorizationRequest()
authRequest.set(TOKEN, token)
# Send authorithation request to "fill" the Identity
session.sendAuthorizationRequest(authRequest, identity, cid)
# Process related responses
startTime = datetime.datetime.today()
WAIT_TIME_SECONDS = datetime.timedelta(seconds=10)
while True:
with g_mutex:
if AuthorizationStatus.WAITING != g_authorizationStatus[cid]:
return AuthorizationStatus.AUTHORIZED == \
g_authorizationStatus[cid]
endTime = datetime.datetime.today()
if endTime - startTime > WAIT_TIME_SECONDS:
return False
time.sleep(1)
def generate(self, event_queue=None):
"""Generate a token."""
token = None
if event_queue is None:
event_queue = blpapi.EventQueue()
self._session.generateToken(blpapi.CorrelationId(), event_queue)
event = event_queue.nextEvent()
if event.eventType() == blpapi.Event.REQUEST_STATUS or \
event.eventType() == blpapi.Event.TOKEN_STATUS:
for msg in event:
if msg.messageType() == TOKEN_SUCCESS:
token = msg.getElementAsString(TOKEN)
return token
if msg.messageType() == TOKEN_FAILURE:
return None
return None
def _authorize(self, auth_service, identity, cid, event_queue=None):
"""Authorize the identity."""
token = self._token_generator.generate()
if token is None:
print("Failed to get token")
return False
# Create and fill the authorization request
auth_request = auth_service.createAuthorizationRequest()
auth_request.set(TOKEN, token)
if event_queue is None:
event_queue = blpapi.EventQueue()
# Send authorization request to "fill" the Identity
self._session.sendAuthorizationRequest(auth_request, identity, cid,
event_queue)
# Process related responses
start_time = datetime.datetime.today()
WAIT_TIME_SECONDS = 10
while True:
event = event_queue.nextEvent(WAIT_TIME_SECONDS * 1000)
if event.eventType() == blpapi.Event.RESPONSE or \
event.eventType() == blpapi.Event.REQUEST_STATUS or \
event.eventType() == blpapi.Event.PARTIAL_RESPONSE:
for msg in event:
print(msg)
if msg.messageType() == AUTHORIZATION_SUCCESS:
return True
print("Authorization failed")
return False
end_time = datetime.datetime.today()
max_time_diff = datetime.timedelta(seconds=WAIT_TIME_SECONDS)
if end_time - start_time > max_time_diff:
return False
def main():
global options
options = parseCmdLine()
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(options.host)
sessionOptions.setServerPort(options.port)
print "Connecting to %s:%d" % (options.host, options.port)
myEventHandler = MyEventHandler()
# Create a Session
session = blpapi.Session(sessionOptions, myEventHandler.processEvent)
# Start a Session
if not session.start():
print "Failed to start session."
return
if not session.openService("//blp/mktdata"):
print "Failed to open //blp/mktdata"
return
if not session.openService("//blp/refdata"):
print "Failed to open //blp/refdata"
return
print "Subscribing to IBM US Equity"
cid = blpapi.CorrelationId(1)
subscriptions = blpapi.SubscriptionList()
subscriptions.add("IBM US Equity", "LAST_PRICE", "", cid)
session.subscribe(subscriptions)
print "Requesting reference data IBM US Equity"
refDataService = session.getService("//blp/refdata")
request = refDataService.createRequest("ReferenceDataRequest")
request.append("securities", "IBM US Equity")
request.append("fields", "DS002")
cid2 = blpapi.CorrelationId(2)
eventQueue = blpapi.EventQueue()
session.sendRequest(request, correlationId=cid2, eventQueue=eventQueue)
try:
# Process received events
while (True):
# We provide timeout to give the chance to Ctrl+C handling:
ev = eventQueue.nextEvent(500)
for msg in ev:
print msg
# Response completly received, so we could exit
if ev.eventType() == blpapi.Event.RESPONSE:
break
# Wait for enter key to exit application
print "Press ENTER to quit"
raw_input()
finally:
# Stop the session
session.stop()
def load_time_series(self, md_request):
# if(BBGLowLevelTemplate._session is None):
logger = LoggerManager().getLogger(__name__)
session = self.start_bloomberg_session()
# else:
# session = BBGLowLevelTemplate._session
def download_data_frame(sess, eventQ, opt, ci):
if opt.security is not None:
self.send_bar_request(sess, eventQ, opt, ci)
logger.info("Waiting for data to be returned...")
return self.event_loop(sess)
else:
logger.warn("No ticker or field specified!")
return None
try:
# if can't open the session, kill existing one
# then try reopen (up to 5 times...)
i = 0
while i < 5:
if session is not None:
if not session.openService("//blp/refdata"):
logger.info("Try reopening Bloomberg session... try " +
str(i))
self.kill_session(
session) # need to forcibly kill_session since
# can't always reopen
session = self.start_bloomberg_session()
if session is not None:
if session.openService("//blp/refdata"): i = 6
else:
logger.info("Try opening Bloomberg session... try " +
str(i))
session = self.start_bloomberg_session()
i = i + 1
# Give error if still doesn't work after several tries..
if not session.openService("//blp/refdata"):
logger.error("Failed to open //blp/refdata")
return
logger.info("Creating request...")
eventQueue = blpapi.EventQueue()
# eventQueue = None
# Create a request
from blpapi import CorrelationId
options = self.fill_options(md_request)
# In some instances we might split the options if need to have
# different overrides
if isinstance(options, list):
data_frame_list = []
for op in options:
cid = CorrelationId()
data_frame_list.append(
download_data_frame(session, eventQueue, op, cid))
data_frame = Calculations().join(data_frame_list)
else:
cid = CorrelationId()
data_frame = download_data_frame(session, eventQueue, options,
cid)
finally:
# stop the session (will fail if NoneType)
try:
session.stop()
except:
pass
return data_frame
def load_time_series(self, market_data_request):
# if(BBGLowLevelTemplate._session is None):
logger = LoggerManager().getLogger(__name__)
session = self.start_bloomberg_session()
# else:
# session = BBGLowLevelTemplate._session
try:
# if can't open the session, kill existing one
# then try reopen (up to 5 times...)
i = 0
while i < 5:
if session is not None:
if not session.openService("//blp/refdata"):
logger.info("Try reopening Bloomberg session... try " +
str(i))
self.kill_session(
session
) # need to forcibly kill_session since can't always reopen
session = self.start_bloomberg_session()
if session is not None:
if session.openService("//blp/refdata"): i = 6
else:
logger.info("Try opening Bloomberg session... try " +
str(i))
session = self.start_bloomberg_session()
i = i + 1
# give error if still doesn't work after several tries..
if not session.openService("//blp/refdata"):
logger.error("Failed to open //blp/refdata")
return
logger.info("Creating request...")
eventQueue = blpapi.EventQueue()
# eventQueue = None
# create a request
from blpapi import CorrelationId
cid = CorrelationId()
options = self.fill_options(market_data_request)
if options.security is not None:
self.send_bar_request(session, eventQueue, options, cid)
logger.info("Waiting for data to be returned...")
data_frame = self.event_loop(session)
else:
logger.warn("No ticker or field specified!")
data_frame = None
finally:
# stop the session (will fail if NoneType)
try:
session.stop()
except:
pass
return data_frame
def clientRun(session, options):
print "Client is starting------"
if not session.start():
print "Failed to start client session."
return
identity = session.createIdentity()
if options.auth:
isAuthorized = False
authServiceName = "//blp/apiauth"
if session.openService(authServiceName):
authService = session.getService(authServiceName)
isAuthorized = authorize(
authService, identity, session,
blpapi.CorrelationId("cauth"))
if not isAuthorized:
print "No authorization"
return
if not session.openService(options.service):
print "Failed to open", options.service
return
service = session.getService(options.service)
request = service.createRequest("ReferenceDataRequest")
# append securities to request
# Add securities to request
securities = request.getElement("securities")
for security in options.securities:
securities.appendValue(security)
# Add fields to request
fields = request.getElement("fields")
for field in options.fields:
fields.appendValue(field)
request.set("timestamp", time.time())
print "Sendind Request:", request
eventQueue = blpapi.EventQueue()
session.sendRequest(request, identity, blpapi.CorrelationId("AddRequest"),
eventQueue)
while True:
# Specify timeout to give a chance for Ctrl-C
event = eventQueue.nextEvent(500)
if event.eventType() == blpapi.Event.TIMEOUT:
continue
print "Client received an event"
for msg in event:
with g_mutex:
if event.eventType() == blpapi.Event.RESPONSE:
if msg.hasElement("timestamp"):
responseTime = msg.getElementAsFloat("timestamp")
print "Response latency =", time.time() - responseTime
print msg
if event.eventType() == blpapi.Event.RESPONSE:
break
def get_calc_ref_data(identifier, identifier_value, fields_map, df):
data = df.copy()
for rid, row in df.iterrows():
date = pd.to_datetime(rid)
settlement_date = list(rrule(DAILY, count=3, byweekday=(MO, TU, WE, TH, FR), dtstart=date))[2]
refdate = date.strftime("%Y%m%d")
settlment_dt = settlement_date.strftime("%Y%m%d")
for key, field in fields_map.items():
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerAddress('localhost', 8194, 0)
sessionOptions.setNumStartAttempts(1)
sessionOptions.setAutoRestartOnDisconnection(True)
session = blpapi.Session(sessionOptions)
if not session.start():
print("Failed to start session.")
return 0
session.openService("//blp/refdata")
service = session.getService("//blp/refdata")
sec = "/%s/%s" % (identifier, identifier_value)
request = service.createRequest("ReferenceDataRequest")
request.append("securities", sec)
all_fields = []
request.append("fields", field)
identity = session.createIdentity()
if field == 'INT_ACC':
override_elements = [
["USER_LOCAL_TRADE_DATE", refdate]
]
elif key == "ASW$":
override_elements = [
["SETTLE_DT", settlment_dt],
["OAS_CURVE_DT", refdate],
["ASW_SWAP_CURRENCY", "USD"],
["ASW_SWAP_PAY_RESET_FREQ", "SA"],
["YAS_BOND_PX", row.PX_LAST]
]
elif key == "ASW FX":
override_elements = [
["SETTLE_DT", settlment_dt],
["OAS_CURVE_DT", refdate],
["YAS_BOND_PX", row.PX_LAST],
["ASW_SWAP_PAY_RESET_FREQ", 4]
]
elif field == "DUR_MID":
override_elements = [
["PX_BID", row.PX_BID],
["PX_ASK", row.PX_ASK],
["YAS_BOND_PX", row.PX_LAST],
["YLD_YTM_ASK", row.YLD_YTM_ASK],
["YLD_YTM_BID", row.YLD_YTM_BID],
["USER_LOCAL_TRADE_DATE", refdate],
["SETTLE_DT", settlement_date]
]
else:
override_elements = []
overrides = request.getElement("overrides")
for elem in override_elements:
override = overrides.appendElement()
override.setElement("fieldId", elem[0])
override.setElement("value", elem[1])
eventQueue = blpapi.EventQueue()
session.sendRequest(request, identity, blpapi.CorrelationId("AddRequest"),
eventQueue)
while True:
# Specify timeout to give a chance for Ctrl-C
event = eventQueue.nextEvent(500)
if event.eventType() == blpapi.Event.TIMEOUT:
continue
for msg in event:
securityData = msg.getElement(SECURITY_DATA)
securityDataList = [securityData.getValueAsElement(i) for i in range(securityData.numValues())]
for sec in securityDataList:
fieldData = sec.getElement(FIELD_DATA)
fieldDataList = [fieldData.getElement(i) for i in range(fieldData.numElements())]
if len(fieldDataList):
for fld in fieldDataList:
col = "ASW$" if key == "ASW$" else str(fld.name())
data.loc[date, col] = fld.getValue()
else:
col = "ASW$" if key == "ASW$" else field
data.loc[date, col] = np.nan
if event.eventType() == blpapi.Event.RESPONSE:
break
session.stop()
if len(data):
return (data)
else:
print("No Data found")
def get_historical_ref_data(identifier, identifier_value, fields_map, startDate, endDate):
"""
@string identifier: 'isin', 'cusip', etc.
@string identifier_value: value corresponding to identifier
@map fields_map:
@string startDate: YYYYMMDD
@string endDate: YYYYMMDD
@return: pandas.DataFrame()
Getting histoical data for given identifier and for multiple fields in dataframe
"""
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerAddress('localhost', 8194, 0)
sessionOptions.setNumStartAttempts(1)
sessionOptions.setAutoRestartOnDisconnection(True)
session = blpapi.Session(sessionOptions)
if not session.start():
print("Failed to start session.")
return 0
identity = session.createIdentity()
if not session.openService("//blp/refdata"):
print("Failed to open service")
return 0
service = session.getService("//blp/refdata")
request = service.createRequest("HistoricalDataRequest")
sec = "/%s/%s" % (identifier, identifier_value)
request.append("securities", sec)
all_fields = []
for fields in fields_map.values():
if type(fields) == str:
request.append("fields", fields)
all_fields.append(fields)
else:
for field in fields:
request.append("fields", field)
all_fields.append(field)
request.set("periodicitySelection", "DAILY")
request.set("startDate", startDate)
request.set("endDate", endDate)
eventQueue = blpapi.EventQueue()
session.sendRequest(request, identity, blpapi.CorrelationId("AddRequest"),
eventQueue)
outDF = pd.DataFrame()
while True:
# Specify timeout to give a chance for Ctrl-C
event = eventQueue.nextEvent(500)
if event.eventType() == blpapi.Event.TIMEOUT:
continue
for msg in event:
output = blpapi.event.MessageIterator(event).next().getElement(SECURITY_DATA)
security = output.getElement(SECURITY).getValueAsString()
fieldDataArray = output.getElement(FIELD_DATA)
fieldDataList = [fieldDataArray.getValueAsElement(i) for i in range(0, fieldDataArray.numValues())]
dates = map(lambda x: x.getElement(DATE).getValueAsString(), fieldDataList)
outDF = pd.DataFrame(index=dates, columns=all_fields)
outDF.index = pd.to_datetime(outDF.index)
for field in all_fields:
data = []
for row in fieldDataList:
if row.hasElement(field):
data.append(row.getElement(field).getValueAsFloat())
else:
data.append(pd.np.nan)
outDF[field] = data
if event.eventType() == blpapi.Event.RESPONSE:
break
session.stop()
if len(outDF):
return outDF
else:
print("No Data found")
def get_rating_ref_data(identifier, identifier_value, fields_map, dates):
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerAddress('localhost', 8194, 0)
sessionOptions.setNumStartAttempts(1)
sessionOptions.setAutoRestartOnDisconnection(True)
session = blpapi.Session(sessionOptions)
if not session.start():
print("Failed to start session.")
return 0
session.openService("//blp/refdata")
data = pd.DataFrame()
for date in dates:
refdate = pd.to_datetime(date).strftime("%Y%m%d")
service = session.getService("//blp/refdata")
request = service.createRequest("ReferenceDataRequest")
sec = "/%s/%s" % (identifier, identifier_value)
request.append("securities", sec)
all_fields = []
for fields in fields_map.values():
if type(fields) == str:
request.append("fields", fields)
all_fields.append(fields)
else:
for field in fields:
request.append("fields", field)
all_fields.append(field)
identity = session.createIdentity()
override_elements = [
["RATING_AS_OF_DATE_OVERRIDE", refdate]
]
overrides = request.getElement("overrides")
for elem in override_elements:
override = overrides.appendElement()
override.setElement("fieldId", elem[0])
override.setElement("value", elem[1])
eventQueue = blpapi.EventQueue()
session.sendRequest(request, identity, blpapi.CorrelationId("AddRequest"),
eventQueue)
while True:
# Specify timeout to give a chance for Ctrl-C
event = eventQueue.nextEvent(500)
if event.eventType() == blpapi.Event.TIMEOUT:
continue
for msg in event:
securityData = msg.getElement(SECURITY_DATA)
securityDataList = [securityData.getValueAsElement(i) for i in range(securityData.numValues())]
for sec in securityDataList:
fieldData = sec.getElement(FIELD_DATA)
fieldDataList = [fieldData.getElement(i) for i in range(fieldData.numElements())]
for fld in fieldDataList:
data.loc[date, str(fld.name())] = fld.getValue()
if event.eventType() == blpapi.Event.RESPONSE:
break
session.stop()
if len(data):
return (data)
else:
print("No Data found")
