def Exitall_trades(self):
rv = self.get_all_open_trades()
idsToClose = [trade.get('id') for trade in rv['trades']]
for tradeID in idsToClose:
r = trades.TradeClose(accountID=self.accountID, tradeID=tradeID)
self.client.request(r)
def close_trade(accountID, token, tradeID, units):
data = create_trade_close_data(units)
client = oandapyV20.API(access_token=token)
r = trades.TradeClose(accountID=accountID, tradeID=tradeID, data=data)
request = client.request(r)
return request
def close(self, tradeID):
close_trade = TradeCloseRequest()
r = trades.TradeClose(accountID, tradeID, data=close_trade.data)
self.api.request(r)
if self.should_print == True:
print("Closing trade: ", r.response)
return r.response
def transactions_close(ACCESS_TOKEN, ACCOUNT_ID, units_quantity, trade_id):
# Close a trade according to its id and quantity of units
client = oandapyV20.API(access_token=ACCESS_TOKEN)
data = {"units": units_quantity}
r = trades.TradeClose(accountID=ACCOUNT_ID, data=data, tradeID=trade_id)
client.request(r)
print(r.response)
def closePosition(self, trade_id):
req = trades.TradeClose(self.account_id, trade_id)
try:
res = self.client.request(req)
logger.info(f'Response in closePosition()... {res}', res)
return res
except V20Error as e:
logger.error(f'Error in closePosition() ... {e}', e)
return None
def close_trade(accountID, other_args: List[str]):
parser = argparse.ArgumentParser(
add_help=False,
prog="closetrade",
description="Close a trade by id.",
)
parser.add_argument(
"-i",
"--id",
dest="orderID",
action="store",
type=str,
required=False,
help="The Trade ID to close. ",
)
parser.add_argument(
"-u",
"--units",
dest="units",
action="store",
required=False,
help="The number of units on the trade to close. If not set it "
+ "defaults to all units. ",
)
if other_args:
if "-i" not in other_args[0]:
other_args.insert(0, "-i")
ns_parser = parse_known_args_and_warn(parser, other_args)
if not ns_parser:
return
data = {}
if ns_parser.units is not None:
data["units"] = ns_parser.units
try:
request = trades.TradeClose(accountID, ns_parser.orderID, data)
response = client.request(request)
close_data = []
close_data.append(
{
"OrderID": response["orderCreateTransaction"]["tradeClose"]["tradeID"],
"Instrument": response["orderFillTransaction"]["instrument"],
"Units": response["orderCreateTransaction"]["units"],
"Price": response["orderFillTransaction"]["price"],
"P/L": response["orderFillTransaction"]["pl"],
}
)
df = pd.DataFrame.from_dict(close_data)
print(df.to_string(index=False))
print("")
except V20Error as e:
d_error = eval(e.msg)
print(d_error["errorMessage"], "\n")
except Exception as e:
print(e, "\n")
def close_order_manually(accountID, access_token, tradeID):
"""
Closes order manually using tradeID.
"""
api = oandapyV20.API(access_token=access_token, environment="practice")
request = trades.TradeClose(accountID, tradeID)
rv = api.request(request)
print(json.dumps(rv, indent=2))
return 0
def close_trades_request(
orderID: str,
units: Union[int, None],
accountID: str = account) -> Union[pd.DataFrame, bool]:
"""Close a trade.
Parameters
----------
orderID : str
ID of the order to close
units : Union[int, None]
Number of units to close. If empty default to all.
accountID : str, optional
Oanda account ID, by default cfg.OANDA_ACCOUNT
Returns
-------
Union[pd.DataFrame, bool]
Close trades data or False
"""
if accountID == "REPLACE_ME":
console.print("Error: Oanda account credentials are required.")
return False
data = {}
if units is not None:
data["units"] = units
if client is None:
return False
try:
request = trades.TradeClose(accountID, orderID, data)
response = client.request(request)
close_data = []
close_data.append({
"OrderID":
response["orderCreateTransaction"]["tradeClose"]["tradeID"],
"Instrument":
response["orderFillTransaction"]["instrument"],
"Units":
response["orderCreateTransaction"]["units"],
"Price":
response["orderFillTransaction"]["price"],
"P/L":
response["orderFillTransaction"]["pl"],
})
if len(close_data) == 0:
return pd.DataFrame()
df_trades = pd.DataFrame.from_dict(close_data)
return df_trades
except V20Error as e:
logger.exception(str(e))
d_error = json.loads(e.msg)
console.print(d_error["errorMessage"], "\n")
return False
def close_trade(accountID, other_args: List[str]):
parser = argparse.ArgumentParser(
add_help=False,
prog="closetrade",
description="Close a trade by id.",
)
parser.add_argument(
"-i",
"--id",
dest="orderID",
action="store",
type=str,
required=False,
help="The Trade ID to close. ",
)
parser.add_argument(
"-u",
"--units",
dest="units",
action="store",
required=False,
help="The number of units on the trade to close. If not set it " +
"defaults to all units. ",
)
if other_args:
if "-i" not in other_args[0]:
other_args.insert(0, "-i")
ns_parser = parse_known_args_and_warn(parser, other_args)
if not ns_parser:
return
data = {}
if ns_parser.units is not None:
data["units"] = ns_parser.units
try:
request = trades.TradeClose(accountID, ns_parser.orderID, data)
response = client.request(request)
order_id = response["orderCreateTransaction"]["tradeClose"]["tradeID"]
order_instrument = response["orderFillTransaction"]["instrument"]
units = response["orderCreateTransaction"]["units"]
price = response["orderFillTransaction"]["price"]
pl = response["orderFillTransaction"]["pl"]
print("Order closed:")
print(f"ID: {order_id}")
print(f"Instrument: {order_instrument}")
print(f"Units: {units}")
print(f"Price: {price}")
print(f"P/L: {pl}")
print("")
except Exception as e:
print(e, "\n")
except V20Error as e:
d_error = eval(e.msg)
print(d_error["errorMessage"], "\n")
def trade_close(self, trade_id) -> Trade:
req = trades.TradeClose(self.account_id, trade_id)
try:
resp = self.client.request(req)
logger.info(f'action=trade_close resp={resp}')
except V20Error as e:
logger.error(f'action=trade_close error={e}')
raise
print(resp)
"""
def test__trade_close(self, mock_put):
"""close trade by id ."""
tid = "_v3_account_accountID_trades_close"
resp, data = fetchTestData(responses, tid)
r = trades.TradeClose(accountID, tradeID=2315)
mock_put.register_uri('PUT',
"{}/{}".format(api.api_url, r),
text=json.dumps(resp))
result = api.request(r)
self.assertTrue(result == resp)
def close_all_trades(account_ID: str) -> None:
""" Close all open trades.
Args:
account_ID (str): [description]
"""
trades_list = get_trade_list(account_ID)
for trade in trades_list:
r = trades.TradeClose(accountID=account_ID, tradeID=trade["id"])
client.request(r)
def tradeClose(tradeID):
'''
data =
{
"units": 1
}
'''
r = trades.TradeClose(accountID, tradeID)
rv = client.request(r)
print('平仓')
f1.send_msg('平仓' + '\n' + json.dumps(rv, indent=2))
def closePosition(trade_id):
client_obj = oandapyV20.API(access_token=token)
client_request = trades.TradeClose(accountID=accountID, tradeID=trade_id)
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)
return response
def close_order(order_tradeID, order_units):
""" Close an order """
ordr = TradeCloseRequest(units=order_units)
# Create TradeClose order request
r = trades.TradeClose(accountID, tradeID=order_tradeID, data=ordr.data)
# Perform the request
try:
rv = api.request(r)
except oandapyV20.exceptions.V20Error as err:
print(r.status_code, err)
else:
print(json.dumps(rv, indent=2))
def close_position(trade_id, units=None):
"""
Closes the selected position.
"""
if units:
inParam = {"units": str(units)}
else:
inParam = None
position_close = trades.TradeClose(accID, tradeID=trade_id, data=inParam)
client.request(position_close)
return position_close.response
def closetrade(self):
csvID = self.getid(self.granularity, self.instrument)
tradeID = csvID[0]
close = trades.TradeClose(self.accountID, tradeID)
self.client.request(close)
print("\n", close.response, "\n")
self.resetid(self.granularity, self.instrument)
transactionID = close.response['orderFillTransaction']['id']
recorder = oandarecord.Recorder(self.client, self.accountID,
transactionID, self.granularity,
csvID[1])
recorder.closing()
def close_trade(self, currency):
try:
req = trades.OpenTrades(accountID=self.account_id)
response = self.oanda.request(req)
trade_id = response["trades"][0]["id"]
req = trades.TradeClose(accountID=self.account_id, tradeID=trade_id)
response = self.oanda.request(req)
return response
except:
raise
def close_position(trade_account):
try:
oanda = oandapyV20.API(environment=trade_account["env"],
access_token=trade_account["accessToken"])
req = trades.OpenTrades(accountID=trade_account["accountId"])
response = oanda.request(req)
trade_id = response["trades"][0]["id"]
req = trades.TradeClose(accountID=trade_account["accountId"],
tradeID=trade_id)
response = oanda.request(req)
return response
except:
raise
def trade_close(self, trade_id):
r = trades.TradeClose(self.account_id, trade_id)
try:
res = self.client.request(r)
logger.info(f'trade_close:{res}')
except V20Error as e:
logger.error(f'trade_close_error:{e}')
raise
trade = Trade(
trade_id=trade_id,
side=constants.BUY if float(res['orderFillTransaction']['units']) > 0 else constants.SELL,
units=float(res['orderFillTransaction']['units']),
price=float(res['orderFillTransaction']['price']),
)
return trade
def trade_close(self, trade_id) -> Trade:
req = trades.TradeClose(self.account_id, trade_id)
try:
resp = self.client.request(req)
logger.info(f'action=trade_close resp={resp}')
except V20Error as e:
logger.error(f'action=trade_close error={e}')
raise
trade = Trade(trade_id=trade_id,
side=constants.BUY
if float(resp['orderFillTransaction']['units']) > 0 else
constants.SELL,
units=float(resp['orderFillTransaction']['units']),
price=float(resp['orderFillTransaction']['price']))
return trade
def close_trade(self, trade_id: str, data: dict = None):
"""
Close (partially or fully) a specific open Trade in an Account.
:param trade_id: open trade id
:param data: use this to close a trade partially. Check developer.oanda.com for details.
:return:
"""
r = trades.TradeClose(accountID=self.account_id, tradeID=trade_id, data=data)
try:
# create close trade request
logging.info(f"Closing trade: [{trade_id}]")
rv = RUNNING_ENV.api.request(r)
except V20Error as err:
logging.error(r.status_code, err)
else:
logging.info(json.dumps(rv, indent=2))
return rv.get('trades')
def close_position(self, Account, ID, pair, frame, close):
trade_ID = str(ID)
logger.info(" < closing a position for ID %s -> %s on %s", str(ID),
pair, frame)
r = trades.TradeClose(accountID=Account.accountID, tradeID=trade_ID)
try:
Account.client.request(r)
del Account.open_positions[ID] # remove from local dict
del Account.prediction[ID]
action = "Sell_Order"
time = datetime.datetime.now()
self.trade_log(ID, action, time, pair, frame)
return True
except:
logger.warning(" < could not close trade")
raise Exception("could not close position")
def close_order(self, instrument):
# check if position exist
if self.order_book[instrument]['order_type'] is None:
print('Position {} does not exist'.format(instrument))
return 1
# create and send a request
r = trades.TradeClose(accountID=self.accountID, tradeID=self.order_book[instrument]['tradeID'])
request_data = self.send_request(r)
# check if request was fulfilled and clear it
if request_data is not 1:
instrument = request_data['orderCreateTransaction']['instrument']
self.order_book[instrument]['order_type'] = None
self.order_book[instrument]['tradeID'] = None
print('Closed: {}'.format(instrument))
return 0
else:
return 1
def close_order(account_id, account_token, trade_id, debug=False):
if debug:
account_id, client = use_our_token()
else:
client = account_token
try:
r = trades.TradeClose(accountID=account_id, tradeID=f'{trade_id}')
client.request(r)
print(r.response)
return True, 'Your Order has been Closed'
except V20Error as ex:
error_msg = ex.msg.split('"errorMessage":')[1].split(',')[0]
print(f"Error : {error_msg}")
return False, error_msg
def trade_close(self, trade_id) -> Trade:
req = trades.TradeClose(self.account_id, trade_id)
try:
resp = self.client.request(req)
logger.info(f'action=trade_close resp={resp}')
except V20Error as e:
logger.error(f'action=trade_close error={e}')
requests.post(
settings.WEB_HOOK_URL,
data=json.dumps({
'text': u'cannot close trade', # 通知内容
}))
return Trade(0, constants.BUY, 0, 0)
trade = Trade(trade_id=trade_id,
side=constants.BUY
if float(resp['orderFillTransaction']['units']) > 0 else
constants.SELL,
units=float(resp['orderFillTransaction']['units']),
price=float(resp['orderFillTransaction']['price']))
return trade
def oOpenPosition(self, lots):
OK = True
opening_positions = []
# Start opening positions
for i in xrange(len(self.instruments)):
order = MarketOrderRequest(instrument=self.instruments[i],
units=lots[i])
request = orders.OrderCreate(self.ID, data=order.data)
# Again for error handling
print '\n Opening on', self.instruments[i]
try:
trd = self.client.request(request)
opening_positions.append(trd['orderFillTransaction']['id'])
print 'Success!\n'
except (oandapyV20.exceptions.V20Error) as err:
print 'Error in opening position! Cancelling trade!'
OK = False
if len(opening_positions)>0:
i = 0
while i<len(opening_positions):
request = trades.TradeClose(accountID=self.ID,
tradeID=opening_positions[i])
try:
_ = self.client.request(request)
print 'Closed ', opening_positions[i]
i += 1
except oandapyV20.exceptions.V20Error as err:
print 'Close failing as well....'
print 'Trying again...perkele perkele...'
# Adding succesfully opened positions to the all positions list
if OK:
for i in opening_positions:
self.existing_positions.append(i)
print 'Position IDs:', self.existing_positions, '\n'
return OK
def close_order(self, instrument):
# check if position exist
if not self.order_book[instrument]['order_type']:
print('Position {} does not exist'.format(instrument))
return 1
# create and send a request
tradeID = self.order_book[instrument]['tradeID']
r = trades.TradeClose(accountID=self.account_id, tradeID=tradeID)
request_data = self.send_request(r)
# check if request was fulfilled and clear it
if request_data is not 1:
instrument = request_data['orderCreateTransaction']['instrument']
self.order_book[instrument]['order_type'] = None
self.order_book[instrument]['tradeID'] = None
logger.info('Closed: {}'.format(instrument))
order_closed_details = {
"PL":
request_data["orderFillTransaction"]["pl"],
"instrument":
request_data["orderFillTransaction"]["instrument"],
"balance":
request_data["orderFillTransaction"]["accountBalance"],
"time":
to_datetime(request_data["orderFillTransaction"]["time"][:-4]),
"position":
"SHORT"
if int(request_data["orderCreateTransaction"]["units"]) < 0
else "LONG",
"tradeID":
tradeID,
}
return order_closed_details
else:
return 1
def main():
r = orders.OrderList(accountID=ACCOUNT_ID)
open_orders = api.request(r)['orders']
for order in open_orders:
r = orders.OrderCancel(accountID=ACCOUNT_ID, orderID=order['id'])
api.request(r)
r = positions.OpenPositions(accountID=ACCOUNT_ID)
open_positions = api.request(r)['positions']
for pair in pairs:
try:
l_s, entry_price, amt_owned = get_position_details(
open_positions, pair)
if l_s != '':
print('\n', pair, l_s)
logging.error(f'\n--- {pair} {l_s} ---')
df = create_df(pair)
if l_s != '':
print(df.tail())
logging.error(f'\n{df.tail()}')
signal = trade_signal(pair, df, l_s, entry_price)
if l_s != '':
print(f'signal: {signal}')
logging.error(f'signal: {signal}')
if (signal == 'buy'
or signal == 'sell') and len(open_positions) < max_trades:
payload = {
'order': {
'type': 'LIMIT',
'instrument': pair,
'units': calculate_qty(df, signal, pair),
'price': calculate_price(df, pair, signal),
'TimeInForce': 'GTC',
}
}
r = orders.OrderCreate(accountID=ACCOUNT_ID, data=payload)
api.request(r)
print(
f'\nNew {signal} position initiated for {pair} \n***************************************\n'
)
logging.error(
f'\nNew {signal} position initiated for {pair} \n***************************************\n'
)
elif signal == 'close':
r = trades.OpenTrades(accountID=ACCOUNT_ID)
open_trades = api.request(r)['trades']
for trade in open_trades:
if trade['instrument'] == pair:
r = trades.TradeClose(accountID=ACCOUNT_ID,
tradeID=trade['id'])
api.request(r)
print(
f'\nAll positions closed for {pair} \n***************************************\n'
)
logging.error(
f'\nAll positions closed for {pair} \n***************************************\n'
)
except:
print(f'error encountered... skipping {pair}')
logging.error(f'error encountered... skipping {pair}')
main()
time.sleep(60 - ((time.time() - starttime) % 60.0))
except KeyboardInterrupt:
print('\n\nKeyboard exception received. Exiting.')
r = orders.OrderList(accountID=ACCOUNT_ID)
open_orders = api.request(r)['orders']
for order in open_orders:
r = orders.OrderCancel(accountID=ACCOUNT_ID, orderID=order['id'])
api.request(r)
r = trades.OpenTrades(accountID=ACCOUNT_ID)
open_trades = api.request(r)['trades']
for trade in open_trades:
r = trades.TradeClose(accountID=ACCOUNT_ID, tradeID=trade['id'])
api.request(r)
exit()
except:
r = orders.OrderList(accountID=ACCOUNT_ID)
open_orders = api.request(r)['orders']
for order in open_orders:
r = orders.OrderCancel(accountID=ACCOUNT_ID, orderID=order['id'])
api.request(r)
r = trades.OpenTrades(accountID=ACCOUNT_ID)
open_trades = api.request(r)['trades']
for trade in open_trades:
r = trades.TradeClose(accountID=ACCOUNT_ID, tradeID=trade['id'])
api.request(r)
