How to implement TRKD JSON application with Python chapter 2: Quote

TRKD Overview

The Thomson Reuters Knowledge Direct (TRKD) API integrates into your website, trading platform, company intranet/extranet, advisory portal and mobile applications to provide up-to-date financial market data, news and analytics and powerful investment tools.

TRKD offers a wide range of Thomson Reuters' information and services delivered in a request-response scenario via web services using today's industry standard protocols (SOAP/XML and REST/JSON). Connectivity can be via HTTP and HTTPS, over the Internet or Delivery Direct. All data are snapshot (non-streaming) data.

With new HTTP JSON services, developers can integrate TRKD information to their application easier then before. This article provides an information regarding the basic knowledge of how to implement TRKD JSON application to consume Quote data with Python language.

TRKD Quote Service Overview

The Quotes service (TRKD RetriveItem3 endpoint) enables you to retrieve a snapshot quote or a quote chain data. TRKD API delivers snapshot prices only; you may not deliver streaming prices using TRKD API. By default TRKD provides delayed stock prices. However, if your organization has an agreement within an exchange to provide its prices in real-time, then real-time snapshot prices can be delivered by TRKD for that exchange.

The Quotes service requires the Application ID and Service Token information from TRKD Service Token in the request message’s header.

Note: Up to 75 instruments and 25 fields may be included in each request.

TRKD JSON Application Implementation Process

The JSON application requires the following steps to consume data from TRKD API services

  1. Authentication with TRKD Authentication service (TRKD Service Token) to get an service token
  2. Send a request message with the required input information with servicetoken and application id in the request header to the interested TRKD service

TRKD Quote Detail

TRKD RetriveItem3 URL and Header

The URL enponint for the TRKD Quote Service is following: https://api.trkd.thomsonreuters.com/api/Quotes/Quotes.svc/REST/Quotes_1/RetrieveItem_3

Header:

  • Content-type = application/json;charset=utf-8
  • X-Trkd-Auth-ApplicationID = Application ID
  • X-Trkd-Auth-Token = Service Token

Method:

  • Post

TRKD RetriveItem3 Request Message

The TRKD Quote RetrieveItem_3 operation request message is in JSON format. The message requires an item name (Symbol) as a mandatory input. If the fields information is not specify and "Scope" parameter value is "All", the request will be all fields data request message. The application can request specific fields data by using “:” string as a separator for each field (example “BID:ASK:CF_LAST”) in the "Fields" parameter with "Scope" parameter value "List".

An example of all fields request message structure is following

{
    “RetrieveItem_Request_3”:{
      “TrimResponse”: false,
      “ItemRequest”: {
         [{
            “RequestKey”: [{“Name”: <Item Name>, “NameType”: “RIC”}],
            “Fields”: <Field Names, separate each field with ‘:’>,
            “Scope”: “All”,
            “ProvideChainLinks”: true
         }]
      }
}

An example of the request message with specific fields subscription is shown below

{
   "RetrieveItem_Request_3": {
      "TrimResponse": false,
      "ItemRequest": [{
         "Fields": "CF_LAST:CF_HIGH:CF_LOW:CF_BID:CF_ASK:CF_YIELD",
         "RequestKey": [{
            "Name": "MSFT.O",
            "NameType": "RIC"
         }],
         "Scope": "List",
         "ProvideChainLinks": true
         }]
   }
}

"trkd_quote.py" Example Application

TRKD API Quote service provides a snapshot (non-streaming) quote data for the application. To retreive quote data, your application must send a request message in JSON formation along with an authenticated credentials (Service Token) and application id information in a request message header.

This section describes how to implement the trkd_quote.py script that performs authentication with the TRDK Service Token, then requests for quote data with all fields or specific fields based on user input via a command line.

IMPLEMENTATION DETAILS

  1. Firstly, we create a file named “trkd_quote.py” in the working directory. Then we import all required libraries at the top of the source code
    import os
    import sys
    import requests
    import json
    import getpass
    
  2. Since this application needs to send multiple HTTP request messages to TRKD Services (for authentication and request quote data), we will separate the HTTP request source code to the dedicate function call instead. We start by creating the doSendRequest() function which receives three parameters: the requested URL, request message  and request message's header. This function sends the JSON request message to the URL and returns the HTTP response from the URL to the caller via the result parameter. If the HTTP response message status code is not 200 (200 OK), it shows the error detail.
    # Send HTTP request for all services
    def doSendRequest(url, requestMsg, headers):
    	result = None
    	try:
    		##send request
    		result = requests.post(url, data=json.dumps(requestMsg), headers=headers)
    		## handle error
    		if result.status_code is not 200:
    			print('Request fail')
    			print('response status %s'%(result.status_code))
    		if result.status_code == 500: ## if username or password or appid is wrong
    			print('Error: %s'%(result.json()))
    			result.raise_for_status()
    	except requests.exceptions.RequestException as e:
    		print('Exception!!!')
    		print(e)
    		sys.exit(1)
    	return result
    
  3. Next, Then we add the code to receive the input user name, password and application id from a console
    ## ------------------------------------------ Main App ------------------------------------------ ##
    ##Get username, password and applicationid
    username = raw_input('Please input username: ')
    ##use getpass.getpass to hide user inputted password
    password = getpass.getpass(prompt='Please input password: ')
    appid = raw_input('Please input appid: ')
    
  4. Next, we create the CreateAuthorization() function to manage and handle TRKD authentication process. We pass user name, password and application id information to the function, then print out the Service Token from TRKD in the console.
    ## Perform authentication
    def CreateAuthorization(username, password, appid):
    	token = None
    	return token
    
    ## ------------------------------------------ Main App ------------------------------------------ ##
    ... #code from  previous step
    token = CreateAuthorization(username,password,appid)
    print('Token = %s'%(token))
    
  5. In the CreateAuthorization() function, we create the authentication (authenMsg), the url (authenURL) and headers variables
    ## Perform authentication
    def CreateAuthorization(username, password, appid):
    	token = None
    	##create authentication request URL, message and header
    	authenMsg = {'CreateServiceToken_Request_1': { 'ApplicationID':appid, 'Username':username,'Password':password }}
    	authenURL = 'https://api.trkd.thomsonreuters.com/api/TokenManagement/TokenManagement.svc/REST/Anonymous/TokenManagement_1/CreateServiceToken_1'
    	headers = {'content-type': 'application/json;charset=utf-8'}
  6. Next, we send this authentication request message, URL and header to the doSendRequest() function. Once the application receives the response Service Token, we send the incoming Service Token back to the caller to prints out the token.
    ##Perform authentication
    def CreateAuthorization(username, password, appid):
        ... #code froma  previouse step
        print('############### Sending Authentication request message to TRKD ###############')
        authenResult = doSendRequest(authenURL, authenMsg, headers)
        if authenResult and authenResult.status_code == 200:
            print('Authen success')
            print('response status %s'%(authenResult.status_code))
            ##get Token
            token = authenResult.json()['CreateServiceToken_Response_1']['Token']
        return token
  7. After we received the Service Token and that Token is not None, we pass the Service Token and application id to the RetreiveQuotes() function for requesting the Quote data.
    ## Perform Quote request 
    def RetrieveQuotes(token, appid):
    	pass #will be implemented in the next step
    
    
    ##------------------------------------------ Main App ------------------------------------------##
    token = CreateAuthorization(username,password,appid)
    print('Token = %s'%(token))
    ## if authentiacation success, continue subscribing Quote
    if token:
    	RetrieveQuotes(token,appid)
  8. The RetrieveQuotes() creates the Quote request message and sends it to the TRKD RetrieveItem_3 servuce via doSendRequest() function. The code prints the incoming Quote response to the console. Please note that we will show how to create the Quote request message in the next step.
    ##Perform Quote request 
    def RetrieveQuotes(token, appid):
    	quoteRequestMsg = None
    	#create quote request message
    	quoteURL = 'https://api.trkd.thomsonreuters.com/api/Quotes/Quotes.svc/REST/Quotes_1/RetrieveItem_3'
    	headers = {'content-type': 'application/json;charset=utf-8' ,'X-Trkd-Auth-ApplicationID': appid, 'X-Trkd-Auth-Token' : token}
    	print('############### Sending Quote request message to TRKD ###############')
    	quoteResult = doSendRequest(quoteURL, quoteRequestMsg,headers)
    	if quoteResult and quoteResult.status_code == 200:
    		print('Quote response message: ')
    		print(quoteResult.json())
  9. The following steps aim for creating the Quote request message in JSON format that supports both all fields and specific fields request. Firstly, we get the user input for the Item name (Symbol) and All field (yes or no) information via the console. We also define a fieldName variable with the default field names value for the field subscription.
    ##Perform Quote request 
    def RetrieveQuotes(token, appid):
    	ricName = raw_input('Please input Symbol: ')
    	fieldFiltering = raw_input('Subscribe all Field? (Yes|No)')
    	quoteRequestMsg = None
    	fieldsName =  'CF_LAST:CF_HIGH:CF_LOW:CF_BID:CF_ASK:CF_YIELD:CF_SOURCE:CF_SRC_PAGE:CF_LOTSIZE:CF_DATE:CF_TIME:CF_TICK:CF_NETCHNG:CF_EXCHNG:CF_VOLUME:CF_CLOSE:CF_OPEN:CF_NAME:CF_CURRENCY'
  10. Next, we create the Quote request message for the all field subscription  (fieldFiltering variable = “Yes”)
    ##Perform Quote request 
    def RetrieveQuotes(token, appid):
    	...
    	if fieldFiltering == 'Yes':
    	## Request all Fields
    	quoteRequestMsg = \
    		{'RetrieveItem_Request_3': {'TrimResponse': False,
    		'ItemRequest': [{'RequestKey': [{'Name': ricName, 'NameType': 'RIC'}], 'Scope': 'All',
    		'ProvideChainLinks': True}]}}
  11. Then we create the Quote request message for the specific fields subscription (fieldFiltering variable = “No”). The source code get user's interested fields from command line.
    ##Perform Quote request 
    def RetrieveQuotes(token, appid):
    	...
    	if fieldFiltering == 'Yes':
    		##Request all Fields
    		...
    	elif fieldFiltering == 'No':
    		##Request specific Fields
    		fieldsName = raw_input('Input interested Field Name in the following format (BID:ASK:TRDPRC_1)')
    		quoteRequestMsg = \
    			{'RetrieveItem_Request_3': {'TrimResponse': False,
    			'ItemRequest': [{
    			'RequestKey': [{'Name': ricName, 'NameType': 'RIC'}],
    			'Fields': fieldsName,
    			'Scope': 'List',
    			'ProvideChainLinks': True
    			}]}}

    Then the application supports both all field and specific field subscription.

Running the application

The application source code is available at GitHub. You can get it via the following git command

$>git clone git@github.com:TR-API-Samples/Example.TRKD.Python.HTTPJSON.git

All TRKD HTTP JSON python examples scripts support Python 3 and they require  the requests library.

please check the README.md in the GitHub repository for more detail.

You can run trkd_quote.py application via the following command

$>python trkd_quote.py

Then input your user name, password and application id. The result is shown in the Figure-1 below

Figure-1: The trkd_quote receives user name, password and application id via commandline

Then,  input interested Symbol and whether user wants to subscribe all fields data or not ("Yes" or "No")

Figure-2: The trkd_quote asks for interested Symbol and Field subscription

If user subscribes all field data from TRKD, TRKD Quote service returns all fields data for the subscription item to the application

Figure-3: The trkd_quote all fields subscription result

If user wants only specific field data ("No" in previous step), the application lets user inputs interested field name by using colon (":") as a separator.

Figure-4: user inputs interested field name via a command line

Then the application subscribes only specific fields for user from TRKD and display data in console.

Figure-5: TRKD Quote result for BID and ASK fields

Conclusion

TRKD Quote Service provides static quote data for users. It supports both all fields and specific fields data. Users need to authenticate permission with TRKD Service Token first, then send the quote request message with Service Token and App ID in the request message header.

References

For further details, please check out the following resources:

For any question related to this article or Elektron WebSocket API page, please use the Developer Community Q&A Forum page.