def go_short():
# TODO: refactor this
params = {"instruments": u.pair}
r = pricing.PricingInfo(accountID=u.accountID, params=params)
client.request(r)
price_list = r.response.get('prices', {})
price_dict = price_list[0]
bids = price_dict.get('bids')
current_bids = bids[0]
current_bid_price = float(current_bids.get('price'))
take_profit = (current_bid_price-0.0050) # equivalent to 50 pips
# TODO: Adjust the above and below
position = position_size()
try:
order_data = MarketOrderRequest(instrument=u.pair,
units=-position, # tp.Units(position).value
takeProfitOnFill={
"price": tp.PriceValue(take_profit).value
},
trailingStopLossOnFill={
"distance": "0.00500"
})
r = orders.OrderCreate(u.accountID, data=order_data.data)
client.request(r)
sleep(5)
trade()
except Exception:
print("Placing short order failed, check the logs.")
logging.exception('Placing short order failed.')
def main(data):
global time
global df
global sub_df
global time_5m
api = API(access_token=access_token, environment="practice")
r = pricing.PricingInfo(accountID=accountID, params={'instruments': instruments})
rv = api.request(r)
price = float(rv['prices'][0]['bids'][0]['price'])
now = rv['prices'][0]['time'][:19]
tik_data.append([
now,
price
])
sub_df.loc[now] = price
print(sub_df)
if (time < datetime.datetime.now() and datetime.datetime.now() < time+time_5m) :
print('stream')
stream(price)
else:
time = time+time_5m
print('initial')
append_df(price)
print('last')
# ax.clear()
mpf.plot(df, type='candle', volume=True, figratio=(12,4))
print('finish')
def market_order(instrument, units, sl):
"""units can be positive or negative, stop loss (in pips) added/subtracted to price """
params = {"instruments": instrument}
account_id = "101-002-12759455-001"
r = pricing.PricingInfo(accountID=account_id, params=params)
rv = client.request(r)
if units > 0:
price = float(rv["prices"][0]["closeoutAsk"])
st_ls = price - sl
else:
price = float(rv["prices"][0]["closeoutBid"])
st_ls = price + sl
data = {
"order": {
"price": "",
"stopLossOnFill": {
"timeInForce": "GTC",
"price": str(st_ls)
},
"timeInForce": "FOK",
"instrument": str(instrument),
"units": str(units),
"type": "MARKET",
"positionFill": "DEFAULT"
}
}
return data
def getPrice(ticker_type):
accountID = "101-002-12644151-001"
api = API(
access_token=
"1040f3b6997e1c6db66f7bb3bb8b5336-4ec7a67d82e48258fe56ac32c283eb12")
params = {"instruments": ticker_type}
print(ticker_type)
r = pricing.PricingInfo(accountID=accountID, params=params)
rv = api.request(r)
data = pd.DataFrame(r.response["prices"])
data_text = json.dumps(r.response, indent=2)
ask = str(data["asks"])
bid = str(data["bids"])
#print(data_text) Update ** Allow it to be display different amount of digits properly
bid_price = ""
ask_price = ""
for ch in range(4, len(ask)):
if (ask[ch].isdigit() or ask[ch] == ".") and ch < 24:
ask_price += ask[ch]
bid_price += bid[ch]
print("ASK:" + ask_price)
print("BID:" + bid_price)
print("#######################")
return ask_price, bid_price
def stream_to_queue(self):
client = None
req = None
try:
client = oandapyV20.API(access_token=self.access_token)
params = {'instruments': self.instruments}
req = pricing.PricingInfo(accountID=self.account_id, params=params)
except Exception as e:
errmsg = 'Caught exception when connecting to stream\n' + str(e)
rq.terminate(errmsg)
res = client.request(req)
with open("history_stream.txt", "a") as file:
file.write("@streming\tinit on ready\n")
while (True):
if StreamingForexPrices.put_event.is_set():
res = client.request(req)
tick = res['prices'][0]
instrument = tick['instrument']
time = pd.Timestamp(tick['time'])
bid = tick['bids'][0]['price']
ask = tick['asks'][0]['price']
tev = TickEvent(instrument, time, bid, ask)
self.events.put(tev)
self.clear_tick_event()
with open("history_stream.txt", "a") as file:
file.write("--- put --->\n")
with open("history_stream.txt", "a") as file:
file.write("@Streaming\t{} {} (B:{}, A:{})\n".format(
tev.time, tev.instrument, tev.bid, tev.ask))
def main():
config = Config()
params = {"instruments": "USD_JPY"}
r = pricing.PricingInfo(accountID=config.ACCOUNT_ID, params=params)
_ = config.api.request(r)
print(r.response)
def oanda_prices():
"""Request instrument prices from oanda."""
with PRMS_Database() as db:
instrument_names = db.get_db_instruments()
# if prices don't exist in the database, reload them
if not instrument_names:
load_instruments()
instrument_names = db.get_db_instruments()
instrument_keys = list(instrument_names.keys())
instrument_keys_sorted = ",".join(instrument_keys) # A sorted string
params_prices = {"instruments": instrument_keys_sorted}
pricing_details = pricing.PricingInfo(accountID=accountID,
params=params_prices)
client.request(pricing_details)
pricing_details = pricing_details.response
pricing_details = pricing_details["prices"]
list_prices = []
for header in pricing_details:
instrument = header["instrument"]
name = instrument_names.get(instrument)
bid_price = header["bids"][0]["price"]
ask_price = header["asks"][0]["price"]
list_prices.append([name, bid_price, ask_price])
return list_prices
def fx_price_request(
accountID: str = account,
instrument: Union[str, None] = None) -> Union[Dict[str, str], bool]:
"""Request price for a forex pair.
Parameters
----------
accountID : str, optional
Oanda account ID, by default cfg.OANDA_ACCOUNT
instrument : Union[str, None]
The loaded currency pair, by default None
Returns
-------
Union[Dict[str, str], bool]
The currency pair price or False
"""
if accountID == "REPLACE_ME":
console.print("Error: Oanda account credentials are required.")
return False
if instrument is None:
console.print(
"Error: An instrument should be loaded before running this command."
)
return False
try:
parameters = {"instruments": instrument}
request = pricing.PricingInfo(accountID=accountID, params=parameters)
response = client.request(request)
return response
except V20Error as e:
d_error = json.loads(e.msg)
console.print(d_error["errorMessage"], "\n")
return False
def get_rates(self):
"""
return latest rate of the instrument
"""
params = {"instruments": self.__instrument}
x = (pricing.PricingInfo(self.__client.get_accountID(), params=params))
return self.__client.get_clientAPI().request(x)
def thread(self):
client = None
req = None
try:
client = oandapyV20.API(access_token=self.access_token)
params = {'instruments':self.instruments}
req = pricing.PricingInfo(accountID=self.account_id, params=params)
except Exception as e:
errmsg = 'Caught exception when connecting to stream\n' + str(e)
req.terminate(errmsg)
res = client.request(req)
self.start()
try:
while self.run:
self.wait_until_start_is_called()
time.sleep(self.tick_interval)
res = client.request(req)
tick = res['prices'][0]
instrument = tick['instrument']
self.time = pd.DatetimeIndex([pd.Timestamp(tick['time'])]).astype(np.int64)[0]//10**9
bid = float(tick['bids'][0]['price'])
ask = float(tick['asks'][0]['price'])
print('tickServer response:{}'.format(bid))
self.ticks.append(bid)
except:
print('@OANDATickServerThread : exception raised.')
traceback.print_exc()
self.fxevents.put(event_thread.EventContainer(name='exception', value=[]))
def oanda_market_hours(self, market):
params={"instruments": market}
request = pricing.PricingInfo(self.oanda_account_id, params=params)
rv = self.oanda.request(request)['prices'][0]
if rv['status'] == 'tradeable':
return True
else:
return False
def get_currency_info(ticker):
"""
Simple request that returns data on the specified currency.
"""
inParams = {"instruments": ticker}
pricing_get = pricing.PricingInfo(accountID=accID, params=inParams)
api.request(pricing_get)
return pricing_get.response
def connect_to_stream(self):
try:
client = oandapyV20.API(access_token=self.access_token)
params = {'instruments': self.instruments}
req = pricing.PricingInfo(accountID=self.account_id, params=params)
return req
except Exception as e:
errmsg = 'Caught exception when connecting to stream\n' + str(e)
rq.terminate(errmsg)
def oanda_ticker(self, market):
params={"instruments": market}
request = pricing.PricingInfo(self.oanda_account_id, params=params)
rv = self.oanda.request(request)['prices'][0]
if rv['status'] == 'tradeable':
ticker = rv['closeoutBid']
return Decimal(ticker)
else:
return None
def price():
params = {"instruments": "EUR_USD"}
price = pricing.PricingInfo(accountID=accountid, params=params)
api.request(price)
response = price.response
bid = response['prices'][0]['bids'][0]['price']
ask = response['prices'][0]['asks'][0]['price']
return bid, ask
def getCurrentPrice(instrument):
# Load config
connection = Connection()
accountID = connection.config['ACCOUNT_ID']
# Request
params = {"instruments": instrument}
r = pricing.PricingInfo(accountID, params)
return connection.API.request(r)
def get_price(params):
api = API(access_token=ACCESS_TOKEN)
try:
request = pricing.PricingInfo(accountID=ACCOUNT_ID, params=params)
response = api.request(request)
except Exception as err:
print(f'Error: {err}')
raise
return response
def get_price(self, currency):
params = {"instruments": currency}
req = pricing.PricingInfo(accountID=self.account_id, params=params)
response = self.oanda.request(req)
ask_price = response["prices"][0]["asks"][0]["price"]
bid_price = response["prices"][0]["bids"][0]["price"]
return ask_price, bid_price
def getCurrPrice(self, instrument):
r = pricing.PricingInfo(accountID=self.accountID,
params={"instruments": instrument})
rv = self.request(r)
priced = rv["prices"][0]
if instrument != priced["instrument"]:
return -1,-1
bid = priced["bids"][-1]["price"]
ask = priced["asks"][-1]["price"]
return float(bid), float(ask)
def test1():
params ={"instruments": "EUR_USD,EUR_JPY"}
# OANDAのデモ口座へのAPI接続
api = API(access_token=access_token, environment="practice")
r = pricing.PricingInfo(accountID=accountID, params=params)
rv = api.request(r)
print(rv['prices'][0]['bids'][0]['price'])
def GetPrices():
params = {"instruments" : instrument}
try:
req = pricing.PricingInfo(accountID=account_id, params=params)
res = api.request(req)
priceTime = res['prices'][0]['time']
asksPrice = res['prices'][0]['asks'][0]['price']
bidsPrice = res['prices'][0]['bids'][0]['price']
except Exception as e:
print(e)
return priceTime, asksPrice, bidsPrice
def test__pricing(self, mock_get):
"""get the pricing information for instruments."""
uri = 'https://test.com/v3/accounts/{}/pricing'.format(accountID)
resp = responses["_v3_accounts_accountID_pricing"]['response']
text = json.dumps(resp)
mock_get.register_uri('GET', uri, text=text)
params = {"instruments": "EUR_USD,EUR_JPY"}
r = pricing.PricingInfo(accountID, params=params)
result = api.request(r)
s_result = json.dumps(result)
self.assertTrue("EUR_USD" in s_result and "EUR_JPY" in s_result)
def aktualna_cena_pre(
par): # najde akutalnu cenu pre dany menovy par, sluzi na TP a SL
import oandapyV20.endpoints.pricing as pricing
params = {"instruments": str(par)}
data_filter = pricing.PricingInfo(
accountID=accountID,
params=params) # specifies values to call from request
req_prices = api.request(data_filter) # calls request, fetches data
fetched_data = data_filter.response # assigns fetched data to variable actual price, not needed
cena = fetched_data["prices"][0]["bids"][0]["price"]
return float(cena)
def pricing_info(self, instruments):
if type(instruments) == "list":
_ins = ","
_ins = _ins.join(instruments)
params = {"instruments": _ins}
else:
params = {"instruments": instruments}
endpoint = pricing.PricingInfo(self.account_id, params)
p = self.send_request(endpoint)
return p["prices"]
def test__pricing(self, mock_get):
"""get the pricing information for instruments."""
tid = "_v3_accounts_accountID_pricing"
resp, data, params = fetchTestData(responses, tid)
r = pricing.PricingInfo(accountID, params=params)
mock_get.register_uri('GET',
"{}/{}".format(api.api_url, r),
text=json.dumps(resp))
result = api.request(r)
instr = params["instruments"].split(",")
self.assertTrue(result["prices"][0]["instrument"] == instr[0]
and result["prices"][1]["instrument"] == instr[1])
def get_current_price(self, ticker):
client = oandapyV20.API(access_token=self.access_token)
params = {"instruments": ticker}
rp = pricing.PricingInfo(accountID=self.account_ID, params=params)
rv = client.request(rp)
rr = rp.response['prices'][0]
price = {}
price['ask'] = float(rr['asks'][0]['price'])
price['bid'] = float(rr['bids'][0]['price'])
# print('Current: instrument: ' + rr.get('instrument')
# + ', closeoutAsk: ' + rr.get('closeoutAsk') + ', closeoutBid: ' + rr.get('closeoutBid')
# + ', time: ' + rr.get('time'))
return price
def latest_prices(type):
##make a request to get the latest price of EUR to USD and save to database
api_pricing = pricing.PricingInfo(accountID=oanda_count_id, params=params)
api_pricing_request = oanda_api.request(api_pricing)
new_price_record = Price()
new_price_record.price = api_pricing.response["prices"][0]["bids"][0][
"price"]
new_price_record.save()
##get the maximum
##minimum and averge price of the last 100 prices
latest_prices = Price.objects.all().order_by("-date")[:100]
prices = []
prices_and_dates = []
max_price = 0
min_price = 0
avg_price = 0
for count, price in enumerate(latest_prices):
prices.append(price.price)
shaded = False
if count % 2 == 0:
shaded = True
prices_and_dates.append({
"date":
price.date.astimezone(tz).strftime('%Y-%m-%d %H:%M:%S'),
"price":
price.price,
"count":
count,
"shaded":
shaded
})
max_price = max(prices)
min_price = min(prices)
avg_price = mean(prices)
# return the minimum, mximum and average of last 100 prices and the last 100 prices
# average is rounded off to 4 decimal places
if type == "non-json":
response = {
"min": min_price,
"max": max_price,
"avg": round(avg_price, 4),
"table_data": prices_and_dates
}
else:
response = JsonResponse({
"min": min_price,
"max": max_price,
"avg": round(avg_price, 4),
"table_data": prices_and_dates
})
return response
def is_instrument_halted(self, symbol):
sleep_time = 1
while True:
try:
request = pricing.PricingInfo(accountID=self.account_id, params={"instruments": symbol})
self.oanda.request(request)
tradeable = request.response["prices"][0]["tradeable"]
break
except Exception as e:
time.sleep(sleep_time)
sleep_time = sleep_time * 2
if sleep_time > 60:
sleep_time = 1
return tradeable
def getPrice(currency):
"""
An API request to get the current price at the given pair
:param currency: Currency pair to get current price
:return: A float of the current price
"""
pair = currency[:3] + "_" + currency[
3:] # Format the currency pair by removing the '_'
params = {"instruments": pair}
r = pricing.PricingInfo(accountID=accountID, params=params)
rv = api.request(r) # Create the order request
r = r.response["prices"][0]["asks"][0][
'price'] # parse response from dictionary
r = float(r) # convert data to a float
return r
def getSpread(currency):
"""
Gets the spread of the given pair
:param currency: Currency to get the spread of
:return: A float that represents the difference between the buy and sell prices
"""
pair = currency[:3] + "_" + currency[
3:] # Format the currency pair by removing the '_'
params = {"instruments": pair}
r = pricing.PricingInfo(accountID=accountID, params=params)
rv = api.request(r) # Create the order request
sell = r.response['prices'][0]['bids'][0][
'price'] # parse response from dictionary
buy = r.response['prices'][0]['asks'][0]['price']
spread = float(buy) - float(sell)
return spread
