def processMessage(msg): SECURITY_DATA = blpapi.Name("securityData") SECURITY = blpapi.Name("security") FIELD_DATA = blpapi.Name("fieldData") securityDataArray = msg.getElement(SECURITY_DATA) for securityData in securityDataArray.values(): print(securityData.getElementAsString(SECURITY)) fieldData = securityData.getElement(FIELD_DATA) for field in fieldData.elements(): for i, row in enumerate(field.values()): for j in range(row.numElements()): e = row.getElement(j) print("Row %d col %d: %s %s" % (i, j, e.name(), e.getValue()))
def testSubscriptionFailure(self): """Sample SubscriptionFailure message""" event = blpapi.test.createEvent(blpapi.Event.SUBSCRIPTION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SubscriptionFailure")) formatter = blpapi.test.appendMessage(event, schema) content = { "reason": { "source": "TestUtil", "errorCode": -1, "category": "CATEGORY", "description": "for testing", "subcategory": "SUBCATEGORY", }, "failureDetails": [{ "fieldId": "field", "reason": { "source": "TestUtil", "errorCode": -1, "category": "CATEGORY", "description": "for testing", "subcategory": "SUBCATEGORY", } }], "resubscriptionId": 123, } formatter.formatMessageDict(content)
def testRequestTemplatePending(self): """Sample RequestTemplatePending message""" event = blpapi.test.createEvent(blpapi.Event.ADMIN) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("RequestTemplatePending")) blpapi.test.appendMessage(event, schema)
def __init__(self): super(BBGLowLevelTick, self).__init__() self.logger = LoggerManager().getLogger(__name__) # constants self.TICK_DATA = blpapi.Name("tickData") self.COND_CODE = blpapi.Name("conditionCodes") self.TICK_SIZE = blpapi.Name("size") self.TIME = blpapi.Name("time") self.TYPE = blpapi.Name("type") self.VALUE = blpapi.Name("value") self.RESPONSE_ERROR = blpapi.Name("responseError") self.CATEGORY = blpapi.Name("category") self.MESSAGE = blpapi.Name("message") self.SESSION_TERMINATED = blpapi.Name("SessionTerminated")
def testSubscriptionStarted(self): """Sample SubscriptionStarted message""" event = blpapi.test.createEvent(blpapi.Event.SUBSCRIPTION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SubscriptionStarted")) formatter = blpapi.test.appendMessage(event, schema) content = { "exceptions": [{ "fieldId": "field", "reason": { "source": "TestUtil", "errorCode": -1, "category": "CATEGORY", "description": "for testing", "subcategory": "SUBCATEGORY", } }], "resubscriptionId": 123, "streamIds": ["123", "456"], "receivedFrom": { "address": "12.34.56.78:81964" }, "reason": "TestUtil" } formatter.formatMessageDict(content)
def testNotifierReceivesSubscriptionStarted(self): """ Verify that notifier receives a `SubscriptionStarted` message. Plan: 1. Create a SubscriptionStatus admin event using blpapi.test.createEvent(). 2. Obtain the schema for SubscriptionStarted message using blpapi.test.getAdminMessageDefinition(). 3. Append a message of type `SubscriptionStarted` using blpapi.test.appendMessage(). 4. Verify that the expected message is passed to notifier.log_subscription_state(). """ event = blpapi.test.createEvent(blpapi.Event.SUBSCRIPTION_STATUS) subscription_started = blpapi.Name("SubscriptionStarted") schema_def = blpapi.test.getAdminMessageDefinition(subscription_started) blpapi.test.appendMessage(event, schema_def) self.event_processor.processEvent(event, self.mock_session) self.mock_notifier.log_subscription_state.assert_called_once() actual_message = \ self.mock_notifier.log_subscription_state.call_args[0][0] self.assertEqual(subscription_started, actual_message.messageType())
def bar(self, sec, s_date, e_date, evtType="TRADE", intvl=60): refDataService = self.session.getService("//blp/refdata") request = refDataService.createRequest("IntradayBarRequest") request.set("security", sec) request.set("eventType", evtType) request.set("interval", intvl) request.set("startDateTime", s_dt) request.set("endDateTime", e_dt) self.session.sendRequest(request) while (True): ev = self.session.nextEvent(500) if ev.eventType() == blpapi.Event.RESPONSE: a = [msg for msg in ev] break pd_barData = pd.DataFrame(columns=[ "time", "open", "high", "low", "close", "volume", "vwap" ]) bt_data = a[0].getElement(blpapi.Name("barData")).getElement( blpapi.Name("barTickData")) for bar in bt_data.values(): t = bar.getElementAsDatetime("time") o = bar.getElementAsFloat("open") h = bar.getElementAsFloat("high") l = bar.getElementAsFloat("low") c = bar.getElementAsFloat("close") v = bar.getElementAsInteger("volume") if v != 0: vwap = bar.getElementAsFloat("value") / v else: vwap = bar.getElementAsFloat("value") / 4 pd_barData = pd_barData.append( { "time": t, "open": o, "high": h, "low": l, "close": c, "volume": v, "vwap": vwap }, ignore_index=True) return (pd_barData)
def __init__(self): super(BBGLowLevelIntraday, self).__init__() # constants self.BAR_DATA = blpapi.Name("barData") self.BAR_TICK_DATA = blpapi.Name("barTickData") self.OPEN = blpapi.Name("open") self.HIGH = blpapi.Name("high") self.LOW = blpapi.Name("low") self.CLOSE = blpapi.Name("close") self.VOLUME = blpapi.Name("volume") self.NUM_EVENTS = blpapi.Name("numEvents") self.TIME = blpapi.Name("time")
def get_curve_members(field_data, field_name="CURVE_MEMBERS"): field_blp_name = blpapi.Name(field_name) curve_members_e = field_data.getElement(field_blp_name) curve_members = [ curve_members_e.getValueAsElement(i).getElementAsString( "Curve Members") for i in range(curve_members_e.numValues()) ] return curve_members
def testAuthorizationFailure(self): """ Verify that for a invalid identity the authorization returns False. Plan: 1. Create a service instance from the apiauth schema. 2. Create and format an event to represent the authorization failure. 3. Call authorize() 4. Verify the following: a. The service is opened and retrieved. b. A token is generated. c. An authorization request is sent. d. authorize() returns False. """ self.mock_session.openService.return_value = True service = blpapi.test.deserializeService(APIAUTH_SCHEMA) self.mock_session.getService.return_value = service token = "abcdefg" self.mock_token_generator.generate.return_value = token event = blpapi.test.createEvent(blpapi.Event.RESPONSE) authorization_request = blpapi.Name("AuthorizationRequest") authorization_failure_index = 1 schema_def = service \ .getOperation(authorization_request) \ .getResponseDefinitionAt(authorization_failure_index) formatter = blpapi.test.appendMessage(event, schema_def) message_content = { "reason": { "code": 101, "message": "Invalid user", "category": "BAD_ARGS", "subcategory": "INVALID_USER", "source": "test-source" } } formatter.formatMessageDict(message_content) self.mock_event_queue.nextEvent.return_value = event identity = Mock() authorization_result = self.authorizer.authorize( identity, self.mock_event_queue) self.mock_session.openService.assert_called_once() self.mock_session.getService.assert_called_once() self.mock_session.sendAuthorizationRequest.assert_called_once() self.mock_token_generator.generate.assert_called_once() self.mock_event_queue.nextEvent.assert_called_once() self.assertFalse(authorization_result)
def testDataLoss(self): """Sample DataLoss message""" event = blpapi.test.createEvent(blpapi.Event.ADMIN) schema = blpapi.test.getAdminMessageDefinition(blpapi.Name("DataLoss")) formatter = blpapi.test.appendMessage(event, schema) content = {"id": "id", "source": "Test", "numMessagesDropped": 123} formatter.formatMessageDict(content)
def testTokenGenerationSuccess(self): """Sample TokenGenerationSuccess message""" event = blpapi.test.createEvent(blpapi.Event.TOKEN_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("TokenGenerationSuccess")) formatter = blpapi.test.appendMessage(event, schema) content = {"token": "mytoken"} formatter.formatMessageDict(content)
def testTopicSubscribed(self): """Sample TopicSubscribed message""" event = blpapi.test.createEvent(blpapi.Event.TOPIC_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("TopicSubscribed")) formatter = blpapi.test.appendMessage(event, schema) content = {"topic": "mytopic", "topicWithOptions": "topicwithopts"} formatter.formatMessageDict(content)
def testResolutionSuccess(self): """Sample ResolutionSuccess message""" event = blpapi.test.createEvent(blpapi.Event.RESOLUTION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("ResolutionSuccess")) formatter = blpapi.test.appendMessage(event, schema) content = {"resolvedTopic": "//blp/myservice/rtopic"} formatter.formatMessageDict(content)
def testSlowConsumerWarningCleared(self): """Sample SlowConsumerWarningCleared message""" event = blpapi.test.createEvent(blpapi.Event.ADMIN) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SlowConsumerWarningCleared")) formatter = blpapi.test.appendMessage(event, schema) content = {"eventsDropped": 123} formatter.formatMessageDict(content)
def testServiceDeregistered(self): """Sample ServiceDeregistered message""" event = blpapi.test.createEvent(blpapi.Event.SERVICE_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("ServiceDeregistered")) formatter = blpapi.test.appendMessage(event, schema) content = {"serviceName": "//blp/myservice"} formatter.formatMessageDict(content)
def testTopicDeactivated(self): """Sample TopicDeactivated message""" event = blpapi.test.createEvent(blpapi.Event.TOPIC_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("TopicDeactivated")) formatter = blpapi.test.appendMessage(event, schema) content = {"topic": "mytopic", "reason": "TestUtil"} formatter.formatMessageDict(content)
def processMessage(self, session, sec, field): # Set various variables equal to various features within BLPAPI # These "names" references keys with the JSON that is returned by BBG after a call SECURITY_DATA = blpapi.Name("securityData") SECURITY = blpapi.Name("security") FIELD_DATA = blpapi.Name("fieldData") FIELD_EXCEPTIONS = blpapi.Name("fieldExceptions") FIELD_ID = blpapi.Name("fieldId") ERROR_INFO = blpapi.Name("errorInfo") while (True): ev = session.nextEvent(500) for msg in ev: # print(msg) if ev.eventType() == blpapi.Event.PARTIAL_RESPONSE or ev.eventType() == blpapi.Event.RESPONSE: secName = msg.getElement(SECURITY_DATA).getElementAsString(SECURITY) fieldDataArray = msg.getElement(SECURITY_DATA).getElement(FIELD_DATA) size = fieldDataArray.numValues() fieldDataList = [fieldDataArray.getValueAsElement(i) for i in range(0, size)] outDates = [x.getElementAsDatetime('date') for x in fieldDataList] dateFrame = pd.DataFrame({'date': outDates}) strData = [field] output = pd.DataFrame(columns=strData) for strD in strData: outData = [x.getElementAsFloat(strD) for x in fieldDataList] output[strD] = outData output['secID'] = secName output = pd.concat([output], axis=1) output = pd.concat([dateFrame, output], axis=1) if ev.eventType() == blpapi.Event.RESPONSE: break return output
def testSessionConnectionDown(self): """Sample SessionConnectionDown message""" event = blpapi.test.createEvent(blpapi.Event.SESSION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SessionConnectionDown")) formatter = blpapi.test.appendMessage(event, schema) content = { "server": "12.34.56.78:8194", "serverId": "ny-hostname", } formatter.formatMessageDict(content)
def testSessionConnectionUp(self): """Sample SessionConnectionUp message""" event = blpapi.test.createEvent(blpapi.Event.SESSION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SessionConnectionUp")) formatter = blpapi.test.appendMessage(event, schema) content = { "server": "12.34.56.78:8194", "serverId": "ny-hostname", "encryptionStatus": "Clear", "compressionStatus": "Uncompressed" } formatter.formatMessageDict(content)
def testAuthorizationSuccess(self): """ Verify that for a valid identity the authorization returns True. Plan: 1. Create a service instance from the apiauth schema. 2. Set the following expectations: b. Verify that service is opened and successfully retrieved. 3. Create an admin event to represent the authorization success. 4. Call authorize() 4. Verify the following: a. The service is opened and retrieved. b. A token is generated. c. An authorization request is sent. d. authorize() returns True. """ self.mock_session.openService.return_value = True service = blpapi.test.deserializeService(APIAUTH_SCHEMA) self.mock_session.getService.return_value = service token = "abcdefg" self.mock_token_generator.generate.return_value = token event = blpapi.test.createEvent(blpapi.Event.RESPONSE) authorization_success = blpapi.Name("AuthorizationSuccess") schema_def = \ blpapi.test.getAdminMessageDefinition(authorization_success) blpapi.test.appendMessage(event, schema_def) # The AuthorizationSuccess message does not have any fields, therefore # no formatting is required. self.mock_event_queue.nextEvent.return_value = event identity = Mock() authorization_result = self.authorizer.authorize( identity, self.mock_event_queue) self.mock_session.openService.assert_called_once() self.mock_session.getService.assert_called_once() self.mock_session.sendAuthorizationRequest.assert_called_once() self.mock_token_generator.generate.assert_called_once() self.mock_event_queue.nextEvent.assert_called_once() self.assertTrue(authorization_result)
def testRequestTemplateAvailable(self): """Sample RequestTemplateAvailable message""" event = blpapi.test.createEvent(blpapi.Event.ADMIN) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("RequestTemplateAvailable")) formatter = blpapi.test.appendMessage(event, schema) content = { "boundTo": { "dataConnection": [{ "address": "12.34.56.78:8194" }] } } formatter.formatMessageDict(content)
def testSessionStarted(self): """Sample SessionStarted message""" event = blpapi.test.createEvent(blpapi.Event.SESSION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SessionStarted")) formatter = blpapi.test.appendMessage(event, schema) content = { "initialEndpoints": [{ "address": "12.34.56.78:8194" }, { "address": "98.76.54.32:8194" }] } formatter.formatMessageDict(content)
def testSessionTerminated(self): """Sample SessionTerminated message""" event = blpapi.test.createEvent(blpapi.Event.SESSION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SessionTerminated")) formatter = blpapi.test.appendMessage(event, schema) content = { "reason": { "source": "TestUtil", "errorCode": -1, "category": "CATEGORY", "description": "for testing", "subcategory": "SUBCATEGORY", } } formatter.formatMessageDict(content)
def testResolutionFailure(self): """Sample ResolutionFailure message""" event = blpapi.test.createEvent(blpapi.Event.RESOLUTION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("ResolutionFailure")) formatter = blpapi.test.appendMessage(event, schema) content = { "reason": { "source": "TestUtil", "errorCode": -1, "category": "CATEGORY", "description": "for testing", "subcategory": "SUBCATEGORY", } } formatter.formatMessageDict(content)
def testServiceAvailabilityInfo(self): """Sample ServiceAvailabilityInfo message""" event = blpapi.test.createEvent(blpapi.Event.SERVICE_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("ServiceAvailabilityInfo")) formatter = blpapi.test.appendMessage(event, schema) content = { "serviceName": "//blp/myservice", "serverAdded": { "address": "12.34.56.78" }, "serverRemoved": { "address": "12.34.56.78" }, "servers": ["12.34.56.78", "12.34.56.78"] } formatter.formatMessageDict(content)
def testNotifierReceivesSubscriptionData(self): """ Verify that: 1. Compute engine receives the correct LAST_PRICE. 2. Compute engine performs the correct computation and returns the correct value. 3. The correct value is sent to the terminal. Plan: 1. Obtain the service by deserializing its schema. 2. Create a SubscriptionEvent using blpapi.test.createEvent(). 3. Obtain the element schema definition from the service. 4. Append a message of type `MarketDataEvents' using blpapi.test.appendMessage(). 5. Format the message using the formatter returned by appendMessage(). In this example the message's body is represented by { LAST_PRICE: 142.80 }. 6. Verify that the expected and actual values are the same. """ event = blpapi.test.createEvent(blpapi.Event.SUBSCRIPTION_DATA) service = blpapi.test.deserializeService(MKTDATA_SCHEMA) mktdata_events = blpapi.Name("MarketDataEvents") schema_def = service.getEventDefinition(mktdata_events) formatter = blpapi.test.appendMessage(event, schema_def) expected_last_price = 142.80 message_content = { "LAST_PRICE": expected_last_price } formatter.formatMessageDict(message_content) expected_compute_result = 200.00 self.mock_compute_engine.someVeryComplexComputation.return_value = \ expected_compute_result self.event_processor.processEvent(event, self.mock_session) self.mock_compute_engine.someVeryComplexComputation \ .assert_called_once_with(expected_last_price) self.mock_notifier.send_to_terminal \ .assert_called_once_with(expected_compute_result)
def testSessionClusterUpdate(self): """Sample SessionClusterUpdate message""" event = blpapi.test.createEvent(blpapi.Event.SESSION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SessionClusterUpdate")) formatter = blpapi.test.appendMessage(event, schema) content = { "name": "clustername", "endpointsAdded": [{ "address": "12.34.56.78:8194" }], "endpointsRemoved": [{ "address": "98.76.54.32:8194" }] } formatter.formatMessageDict(content)
def testSubscriptionStreamsDeactivated(self): """Sample SubscriptionStreamsDeactivated message""" event = blpapi.test.createEvent(blpapi.Event.SUBSCRIPTION_STATUS) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("SubscriptionStreamsDeactivated")) formatter = blpapi.test.appendMessage(event, schema) content = { "streams": [{ "id": "streamId", "endpoint": { "address": "12.34.56.78:8194" } }], "reason": "TestUtil" } formatter.formatMessageDict(content)
def testPermissionRequest(self): """Sample PermissionRequest message""" event = blpapi.test.createEvent(blpapi.Event.REQUEST) schema = blpapi.test.getAdminMessageDefinition( blpapi.Name("PermissionRequest")) formatter = blpapi.test.appendMessage(event, schema) content = { "topics": ["topic1", "topic2"], "serviceName": "//blp/mytestservice", "uuid": 1234, "seatType": 1234, "applicationId": 1234, "userName": "******", "appName": "myAppName", "deviceAddress": "myDevice" } formatter.formatMessageDict(content)