def start(self, ignore_heartbeat=False, **kwargs):
# We want the heartbeats by default
client = API(access_token=self.access_token,
environment=self.environment)
params = {"instruments": kwargs["instruments"]}
r = pricing.PricingStream(accountID=kwargs['accountId'], params=params)
logging.info("Request is: %s with instruments: %s", r,
params['instruments'])
while True:
try:
for tick in client.request(r):
logging.info("TICK: %s", tick)
self.on_success(V1compat(tick))
except V20Error as e:
# catch API related errors that may occur
logger.error("V20Error: %s", e)
break
except ConnectionError as e:
logger.error("Connection Error: %s", e)
break
except StreamTerminated as e:
logger.error("StreamTerminated exception: %s", e)
break
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.error("Unknown exception: %s | %s | %s", exc_type,
fname, exc_tb.tb_lineno)
break
def stream(self):
"""
Description of Raw Stream:
type ('PRICE'/'HEARTBEAT')
time (str - 2017-11-01T10:29:20.628235935Z)
bids
price (float - 1.16365)
liquidity (int - 10000000)
asks
price (float - 1.16365)
liquidity (int - 10000000)
closeoutBid
price (float - 1.16365)
closeoutAsk
price (float - 1.16365)
status (str - 'tradeable')
tradeable (boolean - True)
instrument (str - 'GBP_USD')
:param input_financial_instrument: List of Financial Instruments (up to 20)
:return: connection that stream prices
"""
conn = Oanda()
input_financial_instrument = self.currencies
financial_instrument = input_financial_instrument[0]
for security in input_financial_instrument[1:]:
financial_instrument += "," + security
params = {"instruments": financial_instrument}
conn_params = pricing.PricingStream(accountID=conn.account_id, params=params)
return conn.api.request(conn_params)
def start(self, **params):
r = pricing.PricingStream(self.account_id, params)
rv = self.client.request(r)
for tick in rv:
if (tick['type'] != 'HEARTBEAT'):
print(tick)
self.on_success(tick)
def run(self):
cf = PRecordFactory(self.pt.granularity)
r = pricing.PricingStream(accountID=self.accountID,
params={"instruments": self.pt.instrument})
for tick in self.client.request(r):
rec = cf.parseTick(tick)
if rec:
self.pt.addItem(*rec)
self._botstate()
def event_new_tick(instrument):
"""
returns true if a new bar has formed since the last interval check.
"""
inParam = {"instruments": instrument}
price_stream = pricing.PricingStream(accountID=accID, params=inParam)
client.request(price_stream)
return price_stream.response
def PricingPricingStream(access_token, accountID, params=None): # check
'Get realtime pricing information for a specified list of Instruments.'
# terminate(message='') to terminate
r = pricing.PricingStream(accountID=accountID, params=params)
client = API(access_token=access_token)
client.request(r)
maxrecs = 100
for ticks in r.response:
print(dumps(ticks, indent=4, separators=(',', ': ')))
if maxrecs == 0:
r.terminate("maxrecs records received")
def _live_data(self, instrument='EUR_USD'):
"""
Subscribes to the stream of data of an instrument.
"""
s = pricing.PricingStream(accountID=self.accountID,
params={"instruments": instrument})
try:
for resp in self.client.request(s):
self.filter_data(resp)
except V20Error as e:
print("Error: {}".format(e))
def streaming_price(self, callback):
p = {"instruments": "USD_JPY"}
r = pricing.PricingStream(self.id, params=p)
api = oandapyV20.API(self.token)
rv = self.client.request(r)
for ticks in rv:
price = self._streaming_price_bits_asks(ticks)
if price is not None:
price['time'] = price['time'].split('.')[0]
price['time'] = price['time'].replace('T', ' ')
print(price['time'])
callback(datetime.strptime(price['time'], '%Y-%m-%d %H:%M:%S'),
float(price['bids']), float(price['asks']))
def __init__(self, init_invest=1000):
file = open("access.txt", "r+")
self.access_token = '82957cd1a8234cf899f729284c094d27-e31e01c267351992774813f5e64c8b43' #file.readline()
self.accountID = "101-004-12401398-001" #file.readline()
print(self.accountID)
print(self.access_token)
file.close()
self.init_invest = init_invest #initial balance
self.client = oandapyV20.API(access_token=self.access_token)
self.r = accounts.AccountDetails(
self.accountID) #requests (about out account)
params = {"instruments": "EUR_USD", "timeout": "5"}
self.pc = pricing.PricingStream(self.accountID,
params) #stream of prices
self.order_type = 'market'
self.tickcounter = 0
#self.init_balance_diff = 0
#self.cur_step = None
self.stock_owned = None
self.balance = None #== position value
self.bid_close = None
self.ask_close = None
self.bid_close_p1 = None
self.ask_close_p1 = None
# action space
self.action_space = spaces.Discrete(3)
# observation space: give estimates in order to sample and build scaler
balance_range = np.array((-init_invest * 2, init_invest * 2))
stock_range = np.array((0, init_invest * 2 // 1.5)) #stock owned
bid_range = np.array((0, 1.5))
ask_range = np.array((0, 1.5))
ask_p1_range = ask_range
bid_p1_range = bid_range
self.observation_space = spaces.Box(
low=np.array((balance_range[0], stock_range[0], bid_range[0],
ask_range[0], ask_p1_range[0], bid_p1_range[0])),
high=np.array((balance_range[1], stock_range[1], bid_range[1],
ask_range[1], ask_p1_range[1], bid_p1_range[1])))
self._reset()
def get_tickstream(self, instruments_list):
r = pricing.PricingStream(
accountID=accountID,
params={"instruments": ",".join(instruments_list)})
n = 0
stopAfter = 2 # let's terminate after receiving 3 ticks
try:
# the stream requests returns a generator so we can do ...
for tick in self.client.request(r):
print json.dumps(tick, indent=2)
if n >= stopAfter:
r.terminate()
n += 1
except StreamTerminated as err:
print(
"Stream processing ended because we made it stop after {} ticks"
.format(n))
def price_stream(pairs, currencies, bd):
'''
Request a price stream from oanda for every instrument in pairs.
With every updated price, update currency prices
Store values in db. not figured out how yet)
'''
global pairs_bid
global pairs_ask
global universe
# Stream Parameters
pairs_list = ','.join(pairs)
account='101-001-7518331-001'
client = 'f01b219340f61ffa887944e7673d85a5-'
client += '6bcb8a840148b5c366e17285c984799e'
api = oandapyV20.API(access_token=client)
params ={'instruments': pairs_list}
r = pricing.PricingStream(accountID=account, params=params)
# Begin Stream
rv = api.request(r)
for ticks in rv:
if ticks['type'] == 'PRICE':
mid = (float(ticks['asks'][0]['price']) \
+ float(ticks['bids'][0]['price'])) / 2
pairs_mid[ticks['instrument']] = mid
pairs_mid['timestamp'] = ticks['time']
universe['timestamp'] = ticks['time']
# Reduce for streaming insertion
stream = {'timestamp': ticks['time'],
'instrument': ticks['instrument'],
'ask': ticks['asks'][0]['price'],
'bid': ticks['bids'][0]['price']}
# Calculate Currencies
calculate_currencies(pairs, currencies, pairs_mid)
# Insert instrument an duniverse pricing into db
db_insert(db, 'universe', universe)
db_insert(db, 'instruments', pairs_mid)
db_insert(db, 'stream', stream)
def test__pricing_stream(self, mock_get):
"""get the streaming pricing information for instruments."""
tid = "_v3_accounts_accountID_pricing_stream"
resp, data, params = fetchTestData(responses, tid)
text = "\n".join([json.dumps(t) for t in resp])
r = pricing.PricingStream(accountID, params=params)
mock_get.register_uri('GET', "{}/{}".format(api.api_url, r), text=text)
result = []
n = 0
m = 3
with self.assertRaises(StreamTerminated):
for rec in api.request(r):
result.append(rec)
n += 1
# terminate when we have m response lines
if n == m:
r.terminate()
# the result containing m items, should equal the first m items
self.assertTrue(result == resp[0:m])
def AlgoTrader():
#api = API(access_token="77e52f20c91e859b1edbf6f63a049994-0d58a82089e68f5437225b0daffbad96")
#accountID = "101-001-7189583-001"
api = API(
access_token=
"280131fad16391b7433e29967e7fb384-9b1ad7bee86ec27e2d9234147accbea3")
accountID = "101-011-7185005-001"
config = configparser.ConfigParser() # 3
config.read('oanda.cfg') # 4
mt = MyTrader(momentum=12,
environment='practice',
access_token=config['oanda']['access_token'])
params = {"instruments": "AUD_CAD"}
r = pricing.PricingStream(accountID=accountID, params=params)
#rv = api.request(r)
maxrecs = 100
#mt.rates(account_id=config['oanda']['account_id'],
# instruments=['DE30_EUR'], ignore_heartbeat=True)
dict_o = {}
dict_i = {}
ignore_heartbeat = True
for i in range(250):
#print(i)
rv = api.request(r)
for line in rv:
dict_o.clear()
dict_i.clear()
dict_i['ask'] = float(line['closeoutAsk'])
dict_i['bid'] = float(line['closeoutBid'])
dict_i['instrument'] = line['instrument']
dict_i['time'] = line['time']
dict_o['tick'] = dict_i
#data = json.loads(line.decode("utf-8"))
mt.on_success(json.loads(json.dumps(dict_o)))
break
print("end")
def run(self):
def append_record(record):
with open(
'/media/office/0D82-9628/data/tick_data/tick_file_7.json',
'a', os.O_NONBLOCK) as f:
json.dump(record, f)
f.write(os.linesep)
# to retrieve:
# with open('my_file') as f:
# my_list = [json.loads(line) for line in f]
index = 1
cf = PRecordFactory(self.pt.granularity)
r = pricing.PricingStream(accountID=self.accountID,
params={"instruments": self.pt.instrument})
for tick in self.client.request(r):
# print(sys._getframe().f_lineno)
# print('tick ', tick)
# np.save('./tick_data/tick_' + str(index) + '.npy', tick)
# index += 1
if 'PRICE' in tick['type']:
# print(tick.keys())
print(tick)
append_record(tick)
# tick = np.load('oanda_tick.npy')
rec = cf.parseTick(tick)
# print('rec after parseTick ', rec)
# exit()
# exit()
# if rec:
# print(sys._getframe().f_lineno)
# print('rec after if ', rec)
# exit()
# self.pt.addItem(*rec)
self._botstate()
def price_stream(currency_pairs):
# Just a little titillation (can pass shit along based on, you know, stuff)
def go():
print('YES')
print()
return
# Main Body
account='101-001-7518331-001'
client = 'client=oandapyV20.API(access_token=env['client'])'
api = oandapyV20.API(access_token=client)
params ={'instruments': 'EUR_USD, EUR_JPY'}
params ={'instruments': currency_pairs}
r = pricing.PricingStream(accountID=account, params=params)
rv = api.request(r)
maxrecs = 10
for ticks in rv:
if ticks['type'] == 'PRICE':
print(json.dumps(ticks['instrument'], indent=4),",")
print(json.dumps(ticks['asks'][0]['price'], indent=4),",")
if float(ticks['asks'][0]['price']) < 1000:
go()
if maxrecs == 0:
r.terminate("maxrecs records received")
def test__pricing_stream(self, mock_get):
"""get the streaming pricing information for instruments."""
uri = 'https://test.com/v3/accounts/{}/pricing/stream'.format(
accountID)
ticks = [{"a": 10}, {"b": 20}, {"c": 30}, {"d": 40}, {"e": 50}]
text = "\n".join([json.dumps(r) for r in ticks])
mock_get.register_uri('GET', uri, text=text)
params = {"instruments": "EUR_USD,EUR_JPY"}
r = pricing.PricingStream(accountID, params=params)
result = []
n = 0
with self.assertRaises(StreamTerminated) as oErr:
for rec in api.request(r):
result.append(json.dumps(rec))
n += 1
# terminate when we have 3 response lines
if n == 3:
r.terminate()
# the result containing 3 items, should equal the first 3 items
# of the ticks
self.assertTrue("\n".join(result) == "\n".join(
json.dumps(r) for r in ticks[0:3]))
def pricing_stream(accountID, token, instruments):
params = create_parameters(instruments)
client = oandapyV20.API(access_token=token)
r = pricing.PricingStream(accountID=accountID, params=params)
request = client.request(r)
return request
def updatePosLog(self, broker, accountID):
if broker == 'oanda':
oT = dict(cfg.brokerList['oanda']['accounts'][accountID]
['tsv'].__next__())
print(oT)
if oT["type"] == "ORDER_FILL":
if "tradeOpened" in oT.keys():
oC = oT["tradeOpened"]
tempL = [
o for o in cfg.posList if o.posID == oC["tradeID"]
]
if tempL == []:
if not oT["instrument"] in cfg.pairList:
cfg.pairList.append(oT["instrument"])
cfg.pairList.sort()
client = oandapyV20.API(
access_token=cfg.brokerList['oanda']['token'])
parstreamtrans = \
{
"instruments": ",".join(cfg.pairList)
}
pstream = pricing.PricingStream(
accountID=cfg.brokerList['oanda']['accounts']
[accountID]['ID'],
params=parstreamtrans)
cfg.brokerList[broker]['psv'] = client.request(
pstream)
if float(oC["units"]) >= 0:
typePos = 'l'
else:
typePos = 's'
cfg.posList.append(
Position('oanda', accountID, oC["tradeID"],
oT["instrument"], float(oT["price"]),
abs(float(oC["units"])), typePos,
pd.Timestamp(oT["time"])))
cfg.posList[-1].status = 'o'
cfg.brokerList['oanda']['accounts'][accountID][
'log'].loc[pd.Timestamp(oT["time"])] = float(
oT["accountBalance"])
if "tradesClosed" in oT.keys():
oCl = oT["tradesClosed"]
oCl.reverse()
for ocp in oCl:
iL = [
j for j in range(cfg.posList.__len__())
if cfg.posList[j].account == accountID
and cfg.posList[j].posID == ocp["tradeID"]
]
i = int(iL[0])
v = cfg.posList[i].log.iloc[-1, ].vol - abs(
float(ocp["units"]))
p = oT["price"]
cp = float(ocp["realizedPL"])
comm = float(oT["commission"]) / oCl.__len__()
t = pd.Timestamp(oT["time"])
cfg.posList[i].log.loc[t] = {
'vol': v,
'price': p,
'closedprof': cp,
'commission': comm
}
if cfg.posList[i].log.loc[t].vol == 0:
cfg.posList[i].status = 'c'
cfg.brokerList['oanda']['accounts'][accountID][
'log'].loc[t] = float(oT["accountBalance"])
if "tradeReduced" in oT.keys():
oRe = oT["tradeReduced"]
iL = [
j for j in range(cfg.posList.__len__())
if cfg.posList[j].account == accountID
and cfg.posList[j].posID == oRe["tradeID"]
]
i = int(iL[0])
v = cfg.posList[i].log.iloc[-1, ].vol - abs(
float(oRe["units"]))
p = oT["price"]
cp = float(oT["tradeReduced"]["realizedPL"])
comm = float(oT["commission"])
t = pd.Timestamp(oT["time"])
cfg.posList[i].log.loc[t] = {
'vol': v,
'price': p,
'closedprof': cp,
'commission': comm
}
if cfg.posList[i].log.loc[t].vol == 0:
cfg.posList[i].status = 'c'
cfg.brokerList['oanda']['accounts'][accountID]['log'].loc[
t] = float(oT["accountBalance"])
def trading(self, broker):
try:
if broker == 'Forexcom':
self.ls_client = LightstreamerClient(
self.broker1.username, self.broker1.session_id,
"https://push.cityindex.com", "STREAMINGALL")
try:
self.ls_client.connect()
except Exception as e:
print("Unable to connect to Lightstreamer Server", e)
subscription = LightstreamerSubscription(
adapter="PRICES",
mode="MERGE",
items=["PRICE." + str(self.broker1.market_id)],
fields=["Bid", "Offer"])
subscription.addlistener(self.quotesHandler)
self.ls_client.subscribe(subscription)
while True:
if self.run == False:
self.ls_client.disconnect()
return None
elif broker == 'Oanda':
params = {
"instruments": self.broker2.ccy,
}
req = pricing.PricingStream(accountID=self.broker2.account_id,
params=params)
resp_stream = self.broker2.client.request(req)
for ticks in resp_stream:
if self.run == True:
if ticks['type'] != 'HEARTBEAT':
self.last_quote2['bid'] = float(
ticks['bids'][0]['price'])
self.last_quote2['ask'] = float(
ticks['asks'][0]['price'])
self.time_stamp2 = datetime.datetime.now()
if self.time_stamp2.hour == TRD_RESET_HOUR: #reset daily trade limit
self.trd_time = 0
if (self.time_stamp2-self.trd_buffer_time).total_seconds()>self.trd_buffer and \
(self.time_stamp2-self.safe_buffer_time).total_seconds()>self.safe_buffer: #only call execute when resume==True
self.locker.acquire()
self.execute()
self.locker.release()
self.stream_queue.put(broker + '(' + self.ccy +
')' + ' ' +
self.time_stamp2.strftime(
"%Y-%m-%d %H:%M:%S") +
' ' + str(self.last_quote2))
else:
return None
else:
print('unknwon broker...')
return None
except Exception as error:
try:
self.locker.release()
except Exception as lckErr:
None
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
if broker == 'Forexcom':
self.ls_client.disconnect() #disconnect first
self.broker1.connect()
elif broker == 'Oanda':
self.broker2.connect()
print(
str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) +
' ' + broker + ' trading failed: ' + str(error))
print('restarting ' + broker + ' ...')
time.sleep(30)
self.trading(broker)
from oandapyV20.exceptions import V20Error
accountID = '101-001-1407695-002'
access_token = 'f9263a6387fee52f94817d6cd8dca978-d097b210677ab84fb58b4655a33eb25c'
client = oandapyV20.API(access_token=access_token, environment="practice")
mktOrder = MarketOrderRequest(instrument="EUR_USD",
units=10000,
takeProfitOnFill=TakeProfitDetails(price=1.10).data,
stopLossOnFill=StopLossDetails(price=1.07).data
).data
r = orders.OrderCreate(accountID=accountID, data=mktOrder)
client.request(r)
instruments = ["EUR_USD", "EUR_JPY"]
s = pricing.PricingStream(accountID=accountID, params={"instruments": ",".join(instruments)})
try:
n = 0
for R in client.request(s):
print(json.dumps(R, indent=2))
n += 1
if n > 10:
s.terminate("maxrecs received: {}".format(10))
except V20Error as e:
print("Error: {}".format(e))
def test__pricing_stream_termination_1(self):
"""terminate a stream that does not exist."""
params = {"instruments": "EUR_USD,EUR_JPY"}
r = pricing.PricingStream(accountID, params=params)
with self.assertRaises(ValueError):
r.terminate()
},
"stopLoss": {
"timeInForce": "GTC",
"price": X.next()
}
}
r = trades.TradeCRCDO(accountID, tradeID=O, data=cfg)
rv = api.request(r)
print("RESP:\n{} ".format(json.dumps(rv, indent=2)))
if chc == 'streamprice':
params =\
{
"instruments": "EUR_USD,EUR_JPY"
}
r = pricing.PricingStream(accountID=accountID, params=params)
rv = api.request(r)
maxrecs = 1000
for ticks in rv:
maxrecs -= 1
print(json.dumps(ticks, indent=4), ",")
if maxrecs == 0:
# r.terminate("maxrecs records received")
break
if chc == 'streamtrans':
params = {"instruments": "EUR_USD,EUR_JPY"}
r = trans.TransactionsStream(accountID=accountID)
rv = api.request(r)
maxrecs = 5
try:
def open(self, broker, accountID, typeP, pair, vol, price,
slip): # Falta log
try:
if broker == "backtest":
cfg.posList.append(
Position(
'backtest', accountID, str(accountID), pair, price,
vol, typeP, cfg.priceList['backtest']['accounts']
[accountID].ts.max()))
cfg.posList[-1].status = 'o'
if pair[-3:] == cfg.brokerList[broker]['accounts'][accountID][
'curr']:
conv = 1
elif ('_').join([pair[-3:], cfg.brokerList[broker]['accounts'][accountID]['curr']]) in \
cfg.priceList[broker]['accounts'][accountID].index:
conv = cfg.priceList[broker]['accounts'][accountID].bid[(
'_'
).join([
pair[-3:],
cfg.brokerList[broker]['accounts'][accountID]['curr']
])]
elif ('_').join([cfg.brokerList[broker]['accounts'][accountID]['curr'], pair[-3:]]) in \
cfg.priceList[broker]['accounts'][accountID].index:
conv = cfg.priceList[broker]['accounts'][accountID].ask[(
'_'
).join([
cfg.brokerList[broker]['accounts'][accountID]['curr'],
pair[-3:]
])]**(-1)
bal = cfg.brokerList['backtest']['accounts'][accountID][
'log'].iloc[-1, ].balance - price * vol * conv
nav = bal + pd.Series(
[po.tick()
for po in cfg.posList if po.status == 'o']).sum()
cfg.brokerList['backtest']['accounts'][accountID]['log'].loc[
cfg.priceList['backtest']['accounts']
[accountID].ts.max()] = {
'balance': bal,
'NAV': nav
}
if broker == "oanda":
client = oandapyV20.API(
access_token=cfg.brokerList['oanda']['token'])
if typeP == 'l':
sign = 1
priceB = (1 + slip) * price
if typeP == 's':
sign = -1
priceB = (1 - slip) * price
data = \
{
"order": {
"units": str(sign * vol),
"instrument": pair,
"timeInForce": "FOK",
"type": "MARKET",
"positionFill": "OPEN_ONLY",
"priceBound": str(round(priceB, 5))
}
}
r = orders.OrderCreate(
cfg.brokerList['oanda']['accounts'][accountID]['ID'],
data=data)
ro = dict(client.request(r))
if "orderFillTransaction" in ro.keys():
oT = ro["orderFillTransaction"]
if "tradeOpened" in oT.keys():
oC = oT["tradeOpened"]
tempL = [
o for o in cfg.posList if o.posID == oC["tradeID"]
]
if tempL == []:
if not oT["instrument"] in cfg.pairList:
cfg.pairList.append(oT["instrument"])
cfg.pairList.sort()
client = oandapyV20.API(
access_token=cfg.brokerList['oanda']
['token'])
parstreamtrans = \
{
"instruments": ",".join(cfg.pairList)
}
pstream = pricing.PricingStream(
accountID=cfg.brokerList['oanda']
['accounts'][accountID]['ID'],
params=parstreamtrans)
cfg.brokerList[broker]['psv'] = client.request(
pstream)
if float(oC["units"]) >= 0:
typePos = 'l'
else:
typePos = 's'
cfg.posList.append(
Position('oanda', accountID, oC["tradeID"],
oT["instrument"], float(oT["price"]),
abs(float(oC["units"])), typePos,
pd.Timestamp(oT["time"])))
cfg.posList[-1].status = 'o'
cfg.brokerList['oanda']['accounts'][accountID][
'log'].loc[pd.Timestamp(oT["time"])] = float(
oT["accountBalance"])
finally:
pass
#############
'''
trade_size = 1000000 # Update this
instrument = 'AUD_CAD' # Update this
short_ticks = 5
long_ticks = 10
tick_number = 0
mid_price_list = []
initial_balance = get_nav(client, account_id)
'''
###############
# TRADING BOT #
###############
'''
# Initialises data stream
stream = pricing.PricingStream(accountID=account_id,
params={"instruments": instrument})
stream_request = api.request(stream)
# TODO Create function within function for printing all 3 lines of NAV
# TODO DO ABOVE and then add PNL as percentage as well as $$$$$
# TODO format (all) numbers (NAV/PNL)
# TODO do everything in a DataFrame and RESAMPLE to 10 seconds
# TODO CREATE A CLASS that includes functions that are together
# Trading bot
for tick in stream.response:
tick_data = json.dumps(tick) # Dict to string
tick_data = json.loads(tick_data) # String to JSON
print("----------------")
def price_stream(
pairs_index,
db,
bids_or_asks,
q1, #q2, q3, q4, q5,
oanda_api=oanda_api,
oanda_account=oanda_account):
"""
Stream Prices from Oanda for pairs list. Insert into 'pairs' table
Load data into a q if passed as argument
"""
# Create Pairs Dictionary
pairs_dictionary = dict(zip(pairs_index, [1] * len(pairs_index)))
pairs_dictionary['timestamp'] = str(np.datetime64('now'))
# Create Database
statement = 'create table if not exists pairs (' \
'id integer primary key, timestamp text not null, '
statement += ' real not null, '.join(pairs_index)
statement += ' real not null);'
database_execute(db, statement)
database_execute(db, 'delete from pairs')
# Streaming Parameters
api = oandapyV20.API(
access_token=
'f3e81960f4aa75e7e3da1f670df51fae-73d8ac6fb611eb976731c859e2517a9b')
params = {'instruments': ','.join(pairs_index)}
r = pricing.PricingStream(accountID=oanda_account, params=params)
print('Streaming Oanda Pricing Data:')
# Start Data Stream
count = 1
while True:
try:
for ticks in api.request(r):
if ticks['type'] == 'PRICE':
if ticks['instrument'] in pairs_index:
# Update Pairs Dictionary with price and time
price = float(ticks[bids_or_asks][0]['price'])
pairs_dictionary[ticks['instrument']] = price
pairs_dictionary['timestamp'] = ticks['time']
# Insert pairs Dictionary into pairs table
dictionary_insert(db, 'pairs', pairs_dictionary)
# Load row into q and update count
q1.put(count)
# q2.put(count)
# q3.put(count)
# q4.put(count)
# q5.put(count)
count += 1
# Debug - testing timestamps
if count % 500 == 0:
print('Sent {}: {}'.format(
count, ticks['time']))
print('Queued {}: {}'.format(
count, (str(datetime.datetime.now()))))
except Exception as e:
print(e)
def build_stream(self):
return pricing.PricingStream(accountID=self.client.account, params={'instruments': self.instruments} )
