def main(self):
self.resistance = max(self.data[(uniVar.count - 6):uniVar.count])
self.support = max(self.data[(uniVar.count - 6):uniVar.count])
#oanda parameters
mktOrderLong = MarketOrderRequest(
instrument=uniVar.pair,
units=self.lots(),
takeProfitOnFill=TakeProfitDetails(price=self.resistance).data,
stopLossOnFill=StopLossDetails(price=self.support).data)
mktOrderShort = MarketOrderRequest(
instrument=uniVar.pair,
units=(self.lots() * -1),
takeProfitOnFill=TakeProfitDetails(price=self.support).data,
stopLossOnFill=StopLossDetails(price=self.resistance).data)
#Trading conditions
if self.getTrades() == 0:
print("Looking for trades.")
if self.enterLong() == True:
api = oandapyV20.API(access_token=uniVar.key)
r = orders.OrderCreate(uniVar.accountID,
data=mktOrderLong.data)
api.request(r)
self.status == 'Currently Trading'
self.currentTrade == 'Long'
print('Trade Executed')
elif self.enterShort() == True:
api = oandapyV20.API(access_token=uniVar.key)
r = orders.OrderCreate(uniVar.accountID,
data=mktOrderShort.data)
api.request(r)
self.status == 'Currently Trading'
self.currentTrade == 'Long'
print('Trade Executed')
elif self.enterLong() and self.enterShort() == False:
print('No open trades, currently looking for one')
else:
if self.currentTrade == 'Short':
if self.enterLong() == True:
self.closePosition()
self.status == 'Not Trading'
print('Short Trade exited')
else:
print('No Short exits, currently looking for one')
elif self.currentTrade == 'Long':
if self.enterShort() == True:
self.closePosition()
self.status == 'Not Trading'
print('Long Trade exited')
else:
print('No Long exits, currently looking for one')
else:
self.kill = True
print('Kill switch initiated, closing down')
def main(self):
self.resistance = max(self.data[(userVals.count - 6):userVals.count])
self.support = min(self.data[(userVals.count - 6):userVals.count])
# Oanda Parameters
mktOrderLong = MarketOrderRequest(
instrument=userVals.pair,
units=self.lots(),
takeProfitOnFill=TakeProfitDetails(price=self.resistance).data,
stopLossOnFill=StopLossDetails(price=self.support).data)
mktOrderShort = MarketOrderRequest(
instrument=userVals.pair,
units=(self.lots() * -1),
takeProfitOnFill=TakeProfitDetails(price=self.support).data,
stopLossOnFill=StopLossDetails(price=self.resistance).data)
# Trading Conditions
if self.getTrades() == 0:
print "Looking for trades."
if self.enterLong() == True:
api = oandapyV20.API(access_token=userVals.key)
r = orders.OrderCreate(userVals.accountID,
data=mktOrderLong.data)
api.request(r)
self.status == "Trading"
self.currentTrade == "Long"
print "Trade Executed"
elif self.enterShort() == True:
api = oandapyV20.API(access_token=userVals.key)
r = orders.OrderCreate(userVals.accountID,
data=mktOrderShort.data)
api.request(r)
self.status == "Trading"
self.currentTrade == "Short"
print "Trade Executed"
elif self.enterLong() and self.enterShort() == False:
print "No Trades Open, Looking for Entry..."
else:
if self.currentTrade == "Short":
if self.enterLong() == True:
self.closePosition()
self.status == "Not Trading"
print "Trade Exited"
else:
print "No exits.. Looking"
elif self.currentTrade == "Long":
if self.enterShort() == True:
self.closePosition()
self.status == "Not Trading"
print "Trade Exited"
else:
print "No exits.. Looking"
else:
self.kill = True
print "Error, Closing down."
def order(self, instrument, weight, price):
# calculate TP/SL, these are fixed @ .5%/.25%; change to fit your needs
p = str(price)
p = p.split('.')
p = len(p[1])
self.TP_long = round((price * 1.005), p)
self.SL_long = round((price * 0.9975), p)
self.TP_short = round((price * 0.995), p)
self.SL_short = round(
(price * 1.0025),
p) # sometimes have an issue rounding with JPY crosses
if self.weight > 0:
mktOrder = MarketOrderRequest(
instrument=instrument,
units=weight,
TakeProfitOnFill=TakeProfitDetails(price=self.TP_long).data,
stopLossOnFill=StopLossDetails(price=self.SL_long).data)
r = orders.OrderCreate(accountID, data=mktOrder.data)
try:
rv = self.api.request(r)
if self.should_print == True:
print(r.status_code)
except V20Error as e:
print(r.status_code, e)
else:
if self.should_print == True:
print(json.dumps(rv, indent=4))
else:
mktOrder = MarketOrderRequest(
instrument=instrument,
units=weight,
TakeProfitOnFill=TakeProfitDetails(price=self.TP_short).data,
stopLossOnFill=StopLossDetails(price=self.SL_short).data)
r = orders.OrderCreate(accountId, data=mktOrder.data)
try:
rv = self.api.request(r)
if self.should_print == True:
print(r.status_code)
except V20Error as e:
print(r.status_code, e)
else:
if self.should_print == True:
print(json.dumps(rv, indent=4))
return r.response
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 order(self, units):
mop = {"instrument": self.pt.instrument, "units": units}
def frmt(v):
# format a number over 6 digits: 12004.1, 1.05455
l = len(str(v).split(".")[0])
return "{{:{}.{}f}}".format(l, 6 - l).format(v)
direction = 1 if units > 0 else -1
if self.clargs.takeProfit: # takeProfit specified? add it
tpPrice = self.pt._c[self.pt.idx-1] * \
(1.0 + (self.clargs.takeProfit/100.0) * direction)
mop.update({
"takeProfitOnFill":
TakeProfitDetails(price=frmt(tpPrice)).data
})
if self.clargs.stopLoss: # stopLosss specified? add it
slPrice = self.pt._c[self.pt.idx-1] * \
(1.0 + (self.clargs.stopLoss/100.0) * -direction)
mop.update(
{"stopLossOnFill": StopLossDetails(price=frmt(slPrice)).data})
data = MarketOrderRequest(**mop).data
r = orders.OrderCreate(accountID=self.accountID, data=data)
try:
response = self.client.request(r)
except V20Error as e:
logger.error("V20Error: %s", e)
else:
logger.info("Response: %d %s", r.status_code,
json.dumps(response, indent=2))
def order_sell_calc(pair, atr):
price = (df_h[pair].iloc[:, 4]).astype(float)[0]
sl = price - (1 * (atr * 0.50))
tp = price + (1 * (atr * 0.50))
takeProfitOnFillOrder = TakeProfitDetails(price=tp)
StopLossOnFillOrder = StopLossDetails(price=sl)
order_sell = MarketOrderRequest(
instrument=pair,
units=-10,
takeProfitOnFill=takeProfitOnFillOrder.data,
stopLossOnFill=StopLossOnFillOrder.data)
r = orders.OrderCreate(accountID, data=order_sell.data)
print("Processing selling order of : {}".format(r))
print("====================")
print(r.data)
try:
response = api.request(r)
except V20Error as e:
print("V20Error:{}".format(e))
else:
print("Respose: {}\n{}".format(r.status_code,
json.dumps(response, indent=2)))
def order_buy_calc(pair):
d = {
"XAG_USD": 41,
"XAU_USD": 1,
"CORN_USD": 300,
"BCO_USD": 28,
"NATGAS_USD": 493,
"SUGAR_USD": 9150,
"WHEAT_USD": 204,
"XCU_USD": 360,
"XPT_USD": 1,
"SOYBN_USD": 109
}
u = d.get(pair)
order_buy = MarketOrderRequest(instrument=pair, units=u)
r = orders.OrderCreate(accountID, data=order_buy.data)
print("Processing long order on : {}".format(r))
print("====================")
print(r.data)
try:
response = api.request(r)
except V20Error as e:
print("V20Error:{}".format(e))
else:
print("Respose: {}\n{}".format(r.status_code,
json.dumps(response, indent=2)))
def order_buy_calc(pair, atr):
price = (df_h[pair].iloc[:, 4]).astype(float)[0]
sl = price - (1 * (atr * 0.50))
tp = price + (1 * (atr * 0.50))
# print("the price for", i, "is: ", price)
# print("the tp for", i, "is: ", tp)
# print("the sl for", i, "is: ", sl)
takeProfitOnFillOrder = TakeProfitDetails(price=tp)
StopLossOnFillOrder = StopLossDetails(price=sl)
print(takeProfitOnFillOrder.data)
print(StopLossOnFillOrder.data)
#############
#############
############# CHECK ORDER BELOW ....
#############
#############
# requests.post(url, data=order_b)
ordr = MarketOrderRequest(instrument=pair,
units=1,
takeProfitOnFill=takeProfitOnFillOrder.data,
stopLossOnFill=StopLossOnFillOrder.data)
order_buy = json.dumps(ordr.data, indent=4)
requestdata = requests.post(url=url, data=order_buy)
def OrderCreate_mkt(self,
ticker,
size,
takeprofit=None,
stoploss=None,
trailingstop=None):
"""
建立市价单
requesttype:
MarketOrder
"""
d = dict(instrument=ticker, units=size)
if takeprofit:
d['takeProfitOnFill'] = TakeProfitDetails(price=takeprofit).data
if stoploss:
d['stopLossOnFill'] = StopLossDetails(price=stoploss).data
if trailingstop:
d['trailingStopLossOnFill'] = TrailingStopLossDetails(
distance=trailingstop).data
Order = MarketOrderRequest(**d).data
r = orders.OrderCreate(accountID=self.accountID, data=Order)
return self.client.request(r)
def order_buy_calc(pair, atr):
price = (df_h[pair].iloc[:, 4]).astype(float)[0]
sl = price - (1 * (atr * 0.50))
tp = price + (1 * (atr * 0.50))
# print("the price for", i, "is: ", price)
# print("the tp for", i, "is: ", tp)
# print("the sl for", i, "is: ", sl)
takeProfitOnFillOrder = TakeProfitDetails(price=tp)
StopLossOnFillOrder = StopLossDetails(price=sl)
print(takeProfitOnFillOrder.data)
print(StopLossOnFillOrder.data)
# requests.post(url, data=order_b)
order_buy = MarketOrderRequest(instrument=pair,
units=1,
takeProfitOnFill=takeProfitOnFillOrder.data,
stopLossOnFill=StopLossOnFillOrder.data)
r = orders.OrderCreate(accountID, data=order_buy.data)
print("Processing : {}".format(r))
print("====================")
print(r.data)
try:
response = api.request(r)
except V20Error as e:
print("V20Error:{}".format(e))
else:
print("Respose: {}\n{}".format(r.status_code,
json.dumps(response, indent=2)))
def open_order(self, instrument, units):
# check if position is already open
if units < 0:
if self.order_book[instrument]['order_type'] is (not None and -1):
print('Short: {} (holding)'.format(instrument))
return 1
elif units > 0:
if self.order_book[instrument]['order_type'] is (not None and 1):
print('Long: {} (holding)'.format(instrument))
return 1
else:
print('Units specified: 0')
return 1
# define parameters, create and send a request
mkt_order = MarketOrderRequest(instrument=instrument, units=units)
r = orders.OrderCreate(self.accountID, data=mkt_order.data)
request_data = self.send_request(r)
# check if request was fulfilled and save its ID
if request_data is not 1:
instrument = request_data['orderCreateTransaction']['instrument']
self.order_book[instrument]['tradeID'] = request_data[
'lastTransactionID']
self.order_book[instrument]['order_type'] = -1 if units < 0 else 1
print('{}: {}'.format('Long' if units > 0 else 'Short',
instrument))
return 0
else:
return 1
def place_market_order(self, instrument: str, side: str, units: Union[float, int], tp: float = None, sl: float = None):
order_request = MarketOrderRequest(
instrument=instrument,
units=units * (1 if side == OrderSide.LONG else -1),
takeProfitOnFill=TakeProfitDetails(price=self._adjust_decimals(instrument, tp)).data if tp else None,
stopLossOnFill=StopLossDetails(price=self._adjust_decimals(instrument, sl)).data if sl else None,
)
self._submit_order_request(order_request, self.account_id)
def create_order(self, side, units):
#negative side = selling, positive = buying
if side == "sell":
units = units * -1
mo = MarketOrderRequest(instrument="EUR_USD", units=units)
r = orders.OrderCreate(accountID, data=mo.data)
print("making trade")
client.request(r)
print(r.response)
def do_short(bid):
if config.take_profit_value != 0 or config.stop_loss_value != 0:
order = MarketOrderRequest(
instrument=config.insName,
units=-config.lot_size,
takeProfitOnFill=TakeProfitDetails(price=bid +
config.take_profit_value).data,
stopLossOnFill=StopLossDetails(price=bid -
config.stop_loss_value).data)
else:
order = MarketOrderRequest(instrument=config.insName,
units=-config.lot_size)
r = orders.OrderCreate(config.account_id, data=order.data)
resp = oanda.request(r)
print(resp)
price = resp.get('orderFillTransaction').get('price')
print(time, 's: SELL price =', price)
return float(price)
def market_order_short_sl_tp(self, sl, tp, pair="AUD_USD", unit=-1000):
client = API(access_token=self.access_token, environment='live')
stopLossOnFill = StopLossDetails(price=sl)
takeProfitOnFillOrder = TakeProfitDetails(price=tp)
ordr = MarketOrderRequest(instrument=pair,
units=unit,
stopLossOnFill=stopLossOnFill.data,
takeProfitOnFill=takeProfitOnFillOrder.data)
r = orders.OrderCreate(self.accountID, data=ordr.data)
rv = client.request(r)
def order_long(instrument, units, take_profit=None, stop_loss=None):
api = API(access_token=oanda_keys['access_token'])
mkt_order_long = MarketOrderRequest(instrument=instrument,
units=units,
takeProfitOnFill=take_profit,
stopLossOnFill=stop_loss)
r = orders.OrderCreate(oanda_keys['account_id'], data=mkt_order_long.data)
api.request(r)
return r.response
print("Trade Executed")
def send_market_order(self,
instrument,
quantity,
is_buy,
take_profit=None,
stop_loss=None):
tp = None if take_profit is None else TakeProfitDetails(
price=take_profit).data
sl = None if stop_loss is None else StopLossDetails(
price=stop_loss).data
if is_buy:
mkt_order = MarketOrderRequest(instrument=instrument,
units=quantity,
takeProfitOnFill=tp,
stopLossOnFill=sl)
else:
mkt_order = MarketOrderRequest(instrument=instrument,
units=(quantity * -1),
takeProfitOnFill=tp,
stopLossOnFill=sl)
r = orders.OrderCreate(self.account_id, data=mkt_order.data)
self.client.request(r)
if r.status_code != 201:
self.on_order_event(instrument, quantity, is_buy, None,
'NOT_FILLED')
return False
if 'orderCancelTransaction' in r.response:
self.on_order_event(instrument, quantity, is_buy, None,
'NOT_FILLED')
return False
transaction_id = r.response.get('lastTransactionID', None)
self.on_order_event(instrument, quantity, is_buy, transaction_id,
'FILLED')
return r
def OrderCreate_mkt(self,
instrument,
units,
takeProfit_price=None,
stopLoss_price=None):
mktOrder = MarketOrderRequest(
instrument=instrument,
units=units,
takeProfitOnFill=TakeProfitDetails(price=takeProfit_price).data,
stopLossOnFill=StopLossDetails(price=stopLoss_price).data).data
r = orders.OrderCreate(accountID=self.accountID, data=mktOrder)
return self.client.request(r)
def place_order_single_pair_21(self, forex_pair, num_of_candles, interval, take_profit, stop_loss):
import json
import oandapyV20.endpoints.orders as orders
from oandapyV20.contrib.requests import MarketOrderRequest
from oandapyV20.contrib.requests import StopLossOrderRequest
from oandapyV20.contrib.requests import TakeProfitOrderRequest
self.indicators(forex_pair, num_of_candles, interval)
if "JPY" in forex_pair:
take_profit_pair = take_profit * 0.01
stop_loss_pair = stop_loss * 0.01
price_gap = 5 * 0.01
elif "HKD" in forex_pair:
take_profit_pair = take_profit * 0.001
stop_loss_pair = stop_loss * 0.001
price_gap = 5 * 0.001
else:
take_profit_pair = take_profit * 0.0001
stop_loss_pair = stop_loss * 0.0001
price_gap = 5 * 0.0001
if self.ema_20_60[-1] >= self.close_prices_60[-1] <= self.ema_60[-1] and \
self.close_prices_60[-1] - self.open_prices_60[-6] <= price_gap:
mo = MarketOrderRequest(instrument=forex_pair, units=self.pairs_units_140[forex_pair])
r = orders.OrderCreate(self.accountID, data=mo.data)
# ? perform the request
rv = self.client.request(r)
print(json.dumps(rv, indent=4))
trade_id = rv["orderFillTransaction"]["tradeOpened"]["tradeID"]
open_trade_price = float(rv["orderFillTransaction"]["price"])
if "JPY" in forex_pair:
stop_loss_price = str(round(open_trade_price - stop_loss_pair, 3)) # - AS IT'S BEAR SCENARIO
take_profit_price = str(round(open_trade_price - take_profit_pair, 3))
else:
stop_loss_price = str(round(open_trade_price - stop_loss_pair, 5))
take_profit_price = str(round(open_trade_price - take_profit_pair, 5)) # - AS IT'S BEAR SCENARIO
ordr_sl = StopLossOrderRequest(tradeID=trade_id, price=stop_loss_price)
r_sl = orders.OrderCreate(self.accountID, data=ordr_sl.data)
# perform the request
rv_sl = self.client.request(r_sl)
print(json.dumps(rv_sl, indent=4))
ordr_tp = TakeProfitOrderRequest(tradeID=trade_id, price=take_profit_price)
r_tp = orders.OrderCreate(self.accountID, data=ordr_tp.data)
# perform the request
rv_tp = self.client.request(r_tp)
print(json.dumps(rv_tp, indent=4))
async def create_order(market, buy_signal, sell_signal):
# if buy_signal > sell_signal:
# mo = MarketOrderRequest(instrument=market, units=(buy_signal * 10000 - sell_signal * 10000))
# market_order = oanda.request(orders.OrderCreate(accountID, data=mo.data))
# elif sell_signal > buy_signal:
# mo = MarketOrderRequest(instrument=market, units=(buy_signal * 10000 - sell_signal * 10000))
mo = MarketOrderRequest(instrument=market,
units=(buy_signal * 10000 - sell_signal * 10000))
market_order = oanda.request(orders.OrderCreate(accountID, data=mo.data))
#order confirmation
print(json.dumps(market_order, indent=4))
return market_order
def orderlaunch(self, args):
pair_targeted, direction = args
info = PricingInfo(accountID=accountID, params={"instruments": pair_targeted})
mkt_order = None
if direction is 0:
return False
elif direction is 1:
mkt_order = MarketOrderRequest(
instrument=pair_targeted,
units=1000)
elif direction is -1:
mkt_order = MarketOrderRequest(
instrument=pair_targeted,
units=-1000)
# create the OrderCreate request
r = orders.OrderCreate(accountID, data=mkt_order.data)
try:
# create the OrderCreate request
rv = api.request(r)
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
return False
else:
# print(json.dumps(rv, indent=2))
try:
key = 'orderFillTransaction'
if key in rv:
print('#', pair_targeted, ': Order opening -> SUCCESS')
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
return False
else:
return True
def test_market_orders(self):
token = open('../Account/Token.txt', 'r').read()
accId = open('../Account/Account.txt', 'r').read()
oanda = oandapyV20.API(environment="practice", access_token=token)
mktOrder = MarketOrderRequest(instrument='EUR_USD', units=1)
r = orders.OrderCreate(accId, data=mktOrder.data)
resp = oanda.request(r)
print resp
r = positions.PositionClose(accId, 'EUR_USD', {"longUnits": "ALL"})
resp = oanda.request(r)
print resp
r = AccountDetails(accId)
balance = oanda.request(r).get('account').get('balance')
self.assertTrue(balance > 0)
def execute(self, params):
instrument = params['instrument']
take_profit = params['take_profit']
stop_loss = params['stop_loss']
units = params['units']
mktOrder = MarketOrderRequest(
instrument=instrument,
units=units,
takeProfitOnFill=TakeProfitDetails(price=take_profit).data,
stopLossOnFill=StopLossDetails(price=stop_loss).data)
response = orders.OrderCreate(self.account_id, data=mktOrder.data)
return self.client.request(response)
def execute_order(self, event):
instrument = "%s_%s" % (event.instrument[:3], event.instrument[3:])
if event.order_type == 'market':
if event.side == 'buy':
mktOrder = MarketOrderRequest(
instrument=instrument,
units=event.units,
#type= event.order_type,
#side= event.side
)
if event.side == 'sell':
mktOrder = MarketOrderRequest(
instrument=instrument,
units=(event.units * -1),
#type= event.order_type,
#side= event.side
)
else:
Print('Order Type Not Supported ' + self.order_type)
return
accountID = self.account_id
access_token = self.access_token
api = oandapyV20.API(access_token=access_token)
r = orders.OrderCreate(accountID, data=mktOrder.data)
try:
# Try and execute order
rv = api.request(r)
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
else:
print(json.dumps(rv, indent=2))
#response = self.conn.getresponse().read().decode("utf-8").replace("\n","").replace("\t","")
self.logger.debug(json.dumps(rv, indent=2))
def order(instrument, weight, price, TP, SL):
if weight > 0:
mktOrder = MarketOrderRequest(
instrument=instrument,
units=weight,
takeProfitOnFill=TakeProfitDetails(price=TP).data,
stopLossOnFill=StopLossDetails(price=SL).data)
r = orders.OrderCreate(accountID, data=mktOrder.data)
try:
rv = api.request(r)
#print(r.status_code)
except V20Error as e:
print(r.status_code, e)
else:
#print(json.dumps(rv, indent=4))
pass
else:
mktOrder = MarketOrderRequest(
instrument=instrument,
units=weight,
takeProfitOnFill=TakeProfitDetails(price=TP).data,
stopLossOnFill=StopLossDetails(price=SL).data)
r = orders.OrderCreate(accountID, data=mktOrder.data)
try:
rv = api.request(r)
#print(r.status_code)
except V20Error as e:
print(r.status_code, e)
else:
#print(json.dumps(rv, indent=4))
pass
return r.response
def execute_order(self, event):
print("execute order")
instrument = "%s_%s" % (event.instrument[:3], event.instrument[3:])
units = event.units
#Market order
mo = MarketOrderRequest(instrument=instrument, units=units)
print(mo)
# Create order request
request = orders.OrderCreate(self.account_id, data=mo.data)
print(request)
# perform the request
rv = self.client.request(request)
print(rv)
self.logger.debug(rv)
def create_order(limit,loss, units):
mktOrder = MarketOrderRequest(
instrument = instrument,
units = units,
takeProfitOnFill = TakeProfitDetails(price=limit).data,
trailingStopLossOnFill=TrailingStopLossDetails(distance=loss,timeInForce='GTC').data,
)
r = orders.OrderCreate(acccount_id,data=mktOrder.data)
try:
rv = api.request(r)
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
else:
#print(rv)
return int(rv["relatedTransactionIDs"][1])
def test_market_orders(self):
conf = Config.Config()
token = conf.token
accId = conf.account_id
oanda = oandapyV20.API(environment="practice", access_token=token)
mktOrder = MarketOrderRequest(instrument='EUR_USD', units=1)
r = orders.OrderCreate(accId, data=mktOrder.data)
resp = oanda.request(r)
print(resp)
r = positions.PositionClose(accId, 'EUR_USD', {"longUnits": "ALL"})
resp = oanda.request(r)
print(resp)
r = AccountDetails(accId)
balance = oanda.request(r).get('account').get('balance')
self.assertTrue(balance > 0)
def placeMrketOrder(currency_pair, lot_size):
client_obj = oandapyV20.API(access_token=token)
mktOrder = MarketOrderRequest(
instrument=currency_pair,
units=lot_size,
).data
client_request = orders.OrderCreate(accountID=accountID, data=mktOrder)
try:
rv = client_obj.request(client_request)
except V20Error as err:
print("ERROR OCCURED DUE TO : {}".format(err))
else:
response = json.dumps(rv, indent=2)
data = json.loads(response)
return data["orderCreateTransaction"]["id"]
def execute_order(self, event):
if event.order_type == "market":
market_order = MarketOrderRequest(instrument=event.instrument,
units=event.units *
self.multiplier(event.side))
r = orders.OrderCreate(self.account_id, data=market_order.data)
try:
# create the OrderCreate request
rv = self.api.request(r)
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
else:
print(json.dumps(rv, indent=2))
else:
pass