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")