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)