def __init__(self, securities=[], fields=[], **kwargs):
"""
Keyword arguments:
securities : list of ISINS
fields : list of fields
kwargs : startDate and endDate (datetime.datetime object, note: hours, minutes, seconds, and microseconds must be replaced by 0)
"""
self.session = blpapi.Session()
self.session.start()
self.session.openService('//BLP/refdata')
self.refDataSvc = self.session.getService('//BLP/refdata')
self.observers = []
self.kwargs = kwargs
if len(securities) > 0 and len(fields) > 0:
# also works if securities and fields are a string
self.fillRequest(securities, fields, **kwargs)
def return_data(query):
response = {}
try:
#If we can find the country in the list of countries,
#treat it like a country with these attributes
population = wpop[query.lower()]
unemployment = unemp[query.lower()]
return countries(population, unemployment)
except:
#Otherwise it is a company, or not anything
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost("10.8.8.1")
sessionOptions.setServerPort(8194)
session = blpapi.Session(sessionOptions)
session.start()
session.openService("//blp/instruments")
instrumentService = session.getService("//blp/instruments")
request = instrumentService.createRequest("instrumentListRequest")
request.set("query", query)
request.set("maxResults", 1)
session.sendRequest(request)
event = session.nextEvent()
run = True
while (run):
event = session.nextEvent()
if event.eventType() == 5:
for msg in event:
if msg.hasElement("results"):
fields = msg.getElement("results")
if fields.numValues() > 0:
for field in fields.values():
sec = field.getElementAsString("security")
dec = field.getElementAsString("description")
return companies(sec)
run = False
else:
print "No Results Found"
run = False
else:
print "No Results Found"
run = False
def download_EMSX_History():
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(d_host)
sessionOptions.setServerPort(d_port)
print("Connecting to %s:%d" % (d_host, d_port))
eventHandler = SessionEventHandler()
session = blpapi.Session(sessionOptions, eventHandler.processEvent)
session.startAsync()
if not session.startAsync():
print("Failed to start session.")
return
session.stop()
def __init__(self,
strSecurityList=['ESM5 Index', 'VGM5 Index'],
strDataList=['BID', 'ASK'],
floatInterval=0,
intCorrIDList=[0, 1]):
threading.Thread.__init__(self)
self.session = blpapi.Session()
self.session.start()
self.session.openService("//BLP/mktdata")
if type(strSecurityList) == str:
strSecurityList = [strSecurityList]
if type(intCorrIDList) == int:
intCorrIDList = [intCorrIDList]
if type(strDataList) == str:
strDataList = [strDataList]
self.strSecurityList = strSecurityList
self.strDataList = strDataList
if len(strSecurityList) != len(intCorrIDList):
print(
'Number of securities needs to match number of Correlation IDs, overwriting IDs'
)
self.intCorrIDList = range(0, len(strSecurityList))
else:
self.intCorrIDList = intCorrIDList
self.subscriptionList = blpapi.subscriptionlist.SubscriptionList()
for (security, intCorrID) in zip(self.strSecurityList,
self.intCorrIDList):
self.subscriptionList.add(security, self.strDataList,
"interval=" + str(floatInterval),
blpapi.CorrelationId(intCorrID))
self.output = pandas.DataFrame(index=self.strSecurityList,
columns=self.strDataList)
self.dictCorrID = dict(zip(self.intCorrIDList, self.strSecurityList))
# Warning - if you mix live and delayed data you could have non
# increasing data
self.lastUpdateTimeBlmbrg = ''
self.lastUpdateTime = datetime.datetime(1900, 1, 1)
self.observers = []
def main():
options = parseCmdLine()
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(options.host)
sessionOptions.setServerPort(options.port)
print("Connecting to %s:%d" % (options.host, options.port))
eventHandler = SubscriptionEventHandler()
# Create a Session
session = blpapi.Session(sessionOptions, eventHandler.processEvent)
# Start a Session
if not session.start():
print("Failed to start session.")
return
print("Connected successfully")
service = "//blp/mktdata"
if not session.openService(service):
print("Failed to open %s service" % service)
return
subscriptions = blpapi.SubscriptionList()
for t in options.topics:
topic = service
if not t.startswith("/"):
topic += "/"
topic += t
subscriptions.add(topic, options.fields, options.options,
blpapi.CorrelationId(t))
print("Subscribing...")
session.subscribe(subscriptions)
try:
# Wait for enter key to exit application
print("Press ENTER to quit")
input()
finally:
# Stop the session
session.stop()
def __init__(self, host='localhost', port=8194):
"""
Starting bloomberg API session
close with session.close()
"""
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost('localhost')
sessionOptions.setServerPort(8194)
# Create a Session
self.session = blpapi.Session(sessionOptions)
# Start a Session
if not self.session.start():
print "Failed to start session."
self.session.nextEvent()
def __init__(self):
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(d_host)
sessionOptions.setServerPort(d_port)
print ("Connecting to %s:%d" % (d_host,d_port))
self.__sessionStarted = False
self.__serviceOpened = False
self.__session = blpapi.Session(sessionOptions)
self.__sessionStarted = self.__session.start()
if not self.__sessionStarted:
print ("Failed to start session.")
self.__serviceOpened = self.__session.openService(d_service)
if not self.__serviceOpened:
print ("Failed to open service.")
def connect_bbg(**kwargs) -> blpapi.session.Session:
"""
Create Bloomberg session and make connection
"""
logger = logs.get_logger(connect_bbg, **kwargs)
if isinstance(kwargs.get('sess', None), blpapi.session.Session):
session = kwargs['sess']
logger.debug(f'Using Bloomberg session {session} ...')
else:
sess_opts = blpapi.SessionOptions()
sess_opts.setServerHost('localhost')
sess_opts.setServerPort(kwargs.get('port', _PORT_))
session = blpapi.Session(sess_opts)
logger.debug('Connecting to Bloomberg ...')
if session.start(): return session
else: raise ConnectionError('Cannot connect to Bloomberg')
def initialize(self):
self.securities=[]
self.subscription_fields=[]
self.session_options = blpapi.SessionOptions()
self.session_options.setServerHost(self.host)
self.session_options.setServerPort(self.port)
self.session = blpapi.Session(options=self.session_options, eventHandler=self.process_event)
if not self.session.start():
raise ("Failed to start session.")
return
while not self.ready:
pass
def initializeSession(self):
if self.env == self.Environment.BETA:
self.emsxServiceName = "//blp/emapisvc_beta"
elif self.env == self.Environment.PRODUCTION:
self.emsxServiceName = "//blp/emapisvc"
self.sessionOptions = blpapi.SessionOptions()
self.sessionOptions.setServerHost(self.host)
self.sessionOptions.setServerPort(self.port)
self.session = blpapi.Session(options=self.sessionOptions,
eventHandler=self.processEvent)
#self.session = blpapi.Session(options=self.sessionOptions)
if not self.session.start():
raise ("Failed to start session.")
return
def _init(self):
# init session
opts = blpapi.SessionOptions()
opts.setServerHost(self.host)
opts.setServerPort(self.port)
self.session = session = blpapi.Session(opts)
if not session.start():
raise Exception("failed to start session")
if not session.openService("//blp/mktdata"):
raise Exception("failed to open service")
# init subscriptions
subs = blpapi.SubscriptionList()
flds = ",".join(self.fields)
istr = self.interval and "interval=%.1f" % self.interval or ""
for ticker in self.tickers:
subs.add(ticker, flds, istr, blpapi.CorrelationId(ticker))
session.subscribe(subs)
def main():
options = parseCmdLine()
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(options.host)
sessionOptions.setServerPort(options.port)
sessionOptions.setSessionIdentityOptions(options.auth['option'])
# Create a Session
session = blpapi.Session(sessionOptions)
# Start a Session
if not session.start():
raise Exception("Can't start session.")
try:
print("Session started.")
# Open service to get reference data from
if not session.openService(options.service):
raise Exception("Can't open '{0}' service.".format(
options.service))
# Obtain previously opened service
service = session.getService(options.service)
print("Service {0}:".format(options.service))
print("Service event definitions[{0}]:".format(
service.numEventDefinitions()))
# Enumerate and print all service's event definitions
for ed in service.eventDefinitions():
printElementDefinition(ed)
print()
print("Operations[{0}]:".format(service.numOperations()))
# Enumerate and print all service's operations
for operation in service.operations():
printOperation(operation, service)
finally:
# Stop the session
session.stop()
def __init__(self,
host='localhost',
port=8194,
debug=False,
timeout=500,
session=None,
identity=None):
"""
Create an object which manages connection to the Bloomberg API session
Parameters
----------
host: str
Host name
port: int
Port to connect to
debug: Boolean {True, False}
Boolean corresponding to whether to log Bloomberg Open API request
and response messages to stdout
timeout: int
Number of milliseconds before timeout occurs when parsing response.
See blp.Session.nextEvent() for more information.
session: blpapi.Session
A custom Bloomberg API session. If this is passed the host and port
parameters are ignored. This is exposed to allow the user more
customization in how they instantiate a session.
identity: blpapi.Identity
Identity to use for request authentication. This should only be
passed with an appropriate session and should already by
authenticated. This is only relevant for SAPI and B-Pipe.
"""
if session is None:
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(host)
sessionOptions.setServerPort(port)
session = blpapi.Session(sessionOptions)
self.timeout = timeout
self._session = session
self._identity = identity
# initialize logger
self.debug = debug
def bbg_init(self):
if self.session is None:
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost("localhost")
sessionOptions.setServerPort(8194)
self.session = blpapi.Session(sessionOptions)
if self.session.start():
# Open service to get historical data from
if self.session.openService(self.bbg_svc_name):
self.refDataService = self.session.getService(
self.bbg_svc_name)
else:
raise bbgException("Failed to open {}".format(
self.bbg_svc_name))
else:
raise bbgException("Failed to start session.")
def __init__(self, host=None, port=8194, appName=None):
self.Config = None
host = host or 'localhost'
port = port or 8194
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(host)
sessionOptions.setServerPort(port)
if (host.lower() != 'localhost') and (host != '127.0.0.1'):
sessionOptions.setAuthenticationOptions(
"AuthenticationMode=APPLICATION_ONLY;ApplicationAuthenticationType=APPNAME_AND_KEY;ApplicationName=JPSRV"
)
self.initialized_services = set()
self.session = blpapi.Session(sessionOptions)
if not self.session.start():
print("Failed to start session")
self.session.nextEvent()
def main():
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(d_host)
sessionOptions.setServerPort(d_port)
print("Connecting to %s:%d" % (d_host, d_port))
eventHandler = SessionEventHandler()
session = blpapi.Session(sessionOptions, eventHandler.processEvent)
if not session.startAsync():
print("Failed to start session.")
return
global bEnd
while bEnd == False:
pass
session.stop()
def open(self) -> None:
""" Start a BLP session. """
if self.active is False:
sessionOptions = blp.SessionOptions()
sessionOptions.setServerHost(self.host)
sessionOptions.setServerPort(self.port)
if self.verbose is True:
print(f'Connecting to {self.host}:{self.port}.')
self.session = blp.Session(sessionOptions)
if self.session.start() is False:
print('Failed to start session.') # Raise error
return()
if self.verbose is True:
print('Starting session...')
if self.session.openService('//blp/refdata') is False:
print('Failed to open refdata service.') # Raise error
return()
if self.verbose is True:
print('Opening refdata service...')
self.refDataService = self.session.getService('//blp/refdata')
self.active = True
def __init__(self,
session_options: blpapi.SessionOptions,
loop: asyncio.AbstractEventLoop = None):
try:
self._loop = loop or asyncio.get_running_loop()
except RuntimeError:
raise RuntimeError('Please create handler inside asyncio loop'
'or explicitly provide one')
# asyncio events to signal session start/stop
self.session_started = asyncio.Event()
self.session_stopped = asyncio.Event()
# Bloomberg session, each session get its own handler instance
self._session = blpapi.Session(options=session_options,
eventHandler=self)
self._session.startAsync()
LOGGER.debug('%s: session started', self.__class__.__name__)
# requests that are currently in process
self._current_requests: Dict[blpapi.CorrelationId, RequestBase] = {}
# all opened services; used to signal when service is ready to be used
self._services: Dict[str, asyncio.Event] = defaultdict(
lambda: asyncio.Event(loop=self._loop))
# each event type is processed by its own method
# for event description see BLPAPI-Core-Developer-Guide, section 9.2
self._method_map: Dict[int, Callable[[blpapi.Event], None]] = {
blpapi.Event.SESSION_STATUS: self._session_handler,
blpapi.Event.SERVICE_STATUS: self._service_handler,
blpapi.Event.ADMIN: self._admin_handler,
blpapi.Event.AUTHORIZATION_STATUS: self._raise_exception,
blpapi.Event.RESOLUTION_STATUS: self._raise_exception,
blpapi.Event.TOPIC_STATUS: self._raise_exception,
blpapi.Event.TOKEN_STATUS: self._raise_exception,
blpapi.Event.REQUEST: self._raise_exception,
blpapi.Event.UNKNOWN: self._raise_exception
}
def start_bloomberg_session(self):
constants = DataConstants()
tries = 0
session = None
logger = LoggerManager().getLogger(__name__)
# Try up to 5 times to start a session
while (tries < 5):
try:
# fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(constants.bbg_server)
sessionOptions.setServerPort(constants.bbg_server_port)
logger.info("Starting Bloomberg session...")
# create a Session
session = blpapi.Session(sessionOptions)
# start a Session
if not session.start():
logger.error("Failed to start session.")
return
logger.info("Returning session...")
tries = 5
except:
tries = tries + 1
# BBGLowLevelTemplate._session = session
if session is None:
logger.error("Failed to start session.")
return
return session
def __init__(self, SERVER_HOST='localhost', SERVER_PORT=8194):
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost("localhost")
sessionOptions.setServerPort(8194)
# Create a Session
self.session = blpapi.Session(sessionOptions)
self.session_started = self.session.start()
# Start a Session
if not self.session_started:
print("Failed to start session.")
#return
self.service_open = self.session.openService("//blp/refdata")
# Open service to get historical data from
if not self.service_open:
print("Failed to open //blp/refdata")
def start_bloomberg_session(self):
# fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(Constants().bbg_server)
sessionOptions.setServerPort(Constants().bbg_server_port)
self.logger.info("Starting Bloomberg session...")
# create a Session
session = blpapi.Session(sessionOptions)
# start a Session
if not session.start():
self.logger.error("Failed to start session.")
return
self.logger.info("Returning session...")
BBGLowLevelTemplate._session = session
return session
def __init__(self, host='localhost', port=8194, debug=False):
"""
Create an object which manages connection to the Bloomberg API session
Parameters
----------
host: str
Host name
port: int
Port to connect to
debug: Boolean {True, False}
Boolean corresponding to whether to log Bloomberg Open API request
and response messages to stdout
"""
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(host)
sessionOptions.setServerPort(port)
self._sessionOptions = sessionOptions
# Create a Session
self.session = blpapi.Session(sessionOptions)
# initialize logger
self.debug = debug
def make_bulk_request(ident, field):
session = blpapi.Session()
if not session.start():
return ['Error starting session']
if not session.openService('//blp/refdata'):
return ['Error opening ref data connection']
refservice = session.getService('//blp/refdata')
req = refservice.createRequest('ReferenceDataRequest')
if isinstance(ident, list):
for _id in ident:
req.append('securities', _id)
else:
req.append('securities', ident)
if isinstance(field, list):
for fld in field:
req.append('fields', fld)
else:
req.append('fields', field)
session.sendRequest(req)
result_data = []
while (True):
ev = session.nextEvent()
for msg in ev:
result_data.append(msg)
if ev.eventType() == blpapi.Event.RESPONSE:
break
session.stop()
return result_data
def main():
options = parseCmdLine()
# Fill SessionOptions
sessionOptions = blpapi.SessionOptions()
for idx, host in enumerate(options.hosts):
sessionOptions.setServerAddress(host, options.port, idx)
sessionOptions.setSessionIdentityOptions(options.auth['option'])
sessionOptions.setAutoRestartOnDisconnection(True)
sessionOptions.setNumStartAttempts(len(options.hosts))
print("Connecting to port %d on %s" % (
options.port, ", ".join(options.hosts)))
providerEventHandler = MyProviderEventHandler(options.service)
providerSession = blpapi.ProviderSession(sessionOptions,
providerEventHandler.processEvent)
requesterEventHandler = MyRequesterEventHandler()
requesterSession = blpapi.Session(sessionOptions,
requesterEventHandler.processEvent)
if options.role in ["server", "both"]:
serverRun(providerSession, options)
if options.role in ["client", "both"]:
clientRun(requesterSession, options)
# wait for enter key to exit application
print("Press ENTER to quit")
input()
if options.role in ["server", "both"]:
providerSession.stop()
if options.role in ["client", "both"]:
requesterSession.stop()
def __init__(self, server_host, server_port, connect_timeout, auto_restart_on_disconnection, num_start_attempts):
# Fill SessionOptions
session_options = blpapi.SessionOptions()
session_options.setServerHost(server_host)
session_options.setServerPort(server_port)
session_options.setConnectTimeout(connect_timeout)
session_options.setAutoRestartOnDisconnection(auto_restart_on_disconnection)
session_options.setNumStartAttempts(num_start_attempts)
print("Connecting to bloomberg host %s:%d" % (server_host, server_port))
# Create a Session
self.session = blpapi.Session(session_options)
# Start a Session
if not self.session.start():
print("Failed to start session.")
raise ConnectionError
if not self.session.openService("//blp/refdata"):
print("Failed to open //blp/refdata")
raise ConnectionError
self.ref_data_service = self.session.getService("//blp/refdata")
def connect(self):
sessionOptions = blpapi.SessionOptions()
sessionOptions.setServerHost(Bloomberg.BBG_ADDRESS['host'])
sessionOptions.setServerPort(Bloomberg.BBG_ADDRESS['port'])
logging.info(
"Connecting to %s:%s" %
(Bloomberg.BBG_ADDRESS['host'], Bloomberg.BBG_ADDRESS['port']))
# Create a Session
session = blpapi.Session(sessionOptions)
# Start a Session
if not session.start():
logging.error("Failed to start Bloomberg session.")
# Open service to get historical data from
if not session.openService("//blp/refdata"):
logging.error("Failed to open //blp/refdata")
# Obtain previously opened service
self.service = session.getService("//blp/refdata") # Start a Session
self.session = session
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 _create_session(self):
opts = blpapi.SessionOptions()
opts.setServerHost(self.host)
opts.setServerPort(self.port)
return blpapi.Session(opts)
def __init__(self):
#Bloomberg session created only once here - makes consecutive bdp() and bdh() calls faster
self.session = blpapi.Session()
self.session.start()
self.session.openService('//BLP/refdata')
self.refDataSvc = self.session.getService('//BLP/refdata')
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 20 17:13:46 2017
@author: pmonnot
"""
import blpapi
import datetime
# Create a Session
session = blpapi.Session()
# Start a Session
if not session.start():
print "Failed to start session."
if not session.openService("//blp/refdata"):
print "Failed to open //blp/refdata"
refDataService = session.getService("//blp/refdata")
request = refDataService.createRequest("HistoricalDataRequest")
request.append("securities", "AAPL US Equity")
#FIELDS - if simply one field use: #request.append("fields", "PX_LAST")
#If you wish to loop the fields
field_list = ["PX_OPEN", "PX_HIGH", "PX_LAST", "PX_VOLUME"]
for field in field_list:
request.append("fields", field)
request.set("startDate", "20170101")
request.set("endDate", "20170201")
