def call_order_list(account_id, account_token, instrument, debug=False):
trade_list = []
if debug:
account_id, client = use_our_token()
else:
client = account_token
params = {"instrument": instrument}
try:
r = orders.OrderList(accountID=account_id, params=params)
client.request(r)
# print(r.response)
# print('\n')
for num, res in enumerate(r.response['orders']):
# print(f"order {instrument!r} no.{num} has trade ID : {res['tradeID']}")
trade_list.append(res['tradeID'])
return trade_list
except V20Error as ex:
error_msg = ex.msg.split('"errorMessage":')[1].split(',')[0]
print(f"Error : {error_msg}")
return error_msg
def updateids(self, instrument, granularity):
df = self.getids()
csvID = self.getid(granularity, instrument)
params = {"instrument": instrument}
o = orders.OrderList(self.accountID, params=params)
t = trades.TradesList(self.accountID, params=params)
self.client.request(o)
self.client.request(t)
orderlist = [x['id'] for x in o.response['orders']]
tradelist = [x['id'] for x in t.response['trades']]
if csvID[0] in orderlist:
return
elif csvID[0] in tradelist:
return
else:
for x in tradelist:
p = {'id': x}
t = trans.TransactionDetails(self.accountID, p['id'])
self.client.request(t)
orderID = t.response['transaction']['orderID']
if orderID == csvID[0]:
if csvID[1] == 0:
df.loc[granularity, instrument]['Consolidating'] = x
elif csvID[1] == 1:
df.loc[granularity, instrument]['Trending'] = x
df.to_csv("Data/tradeid.csv",
sep=',',
encoding='utf-8',
index_label="Granularity")
return
def get_OrderList(self, ticker):
"""
可以获得特定ticker的 Pending Order
"""
r = orders.OrderList(accountID=self.accountID,
params={"instrument": ticker})
return self.client.request(r)
def test__orders_list(self, mock_get):
"""get the orders information for an account."""
uri = 'https://test.com/v3/accounts/{}/orders'.format(accountID)
resp = responses["_v3_accounts_accountID_orders"]['response']
text = json.dumps(resp)
mock_get.register_uri('GET', uri, text=text)
r = orders.OrderList(accountID)
result = api.request(r)
self.assertTrue(
len(result['orders']) == 1
and result['orders'][0]['instrument'] == "EUR_USD")
def isorderpending(self):
csvID = self.getcsvID()
orderList = orders.OrderList(accountID=self.accountID,
params=self.params)
self.client.request(orderList)
try:
orderIDList = [x['id'] for x in orderList.response['orders']]
if csvID in orderIDList:
return True
return False
except Exception:
print("isorderpending error")
def test__orders_list(self, mock_get):
"""get the orders for an account."""
tid = "_v3_accounts_accountID_orders_list"
resp, data = fetchTestData(responses, tid)
r = orders.OrderList(accountID)
mock_get.register_uri('GET',
"{}/{}".format(api.api_url, r),
text=json.dumps(resp))
result = api.request(r)
self.assertTrue(
len(result['orders']) == len(resp['orders']) and
result['orders'][0]['instrument'] ==
resp['orders'][0]['instrument'])
def list_orders(accountID, other_args: List[str]):
parser = argparse.ArgumentParser(
add_help=False,
prog="list",
description="List order history",
)
parser.add_argument(
"-s",
"--state",
dest="state",
action="store",
default="ALL",
required=False,
help="Select state for order list. ",
)
parser.add_argument(
"-c",
"--count",
dest="count",
action="store",
default=20,
required=False,
help="the number of orders to retrieve ",
)
ns_parser = parse_known_args_and_warn(parser, other_args)
if not ns_parser:
return
parameters = {}
parameters["state"] = ns_parser.state.upper()
parameters["count"] = ns_parser.count
try:
request = orders.OrderList(accountID, parameters)
response = client.request(request)
df = pd.DataFrame.from_dict(response["orders"])
df = df[["id", "instrument", "units", "price", "state", "type"]]
print(df)
print("")
except KeyError:
print("No orders were found\n")
except V20Error as e:
# pylint: disable=W0123
d_error = eval(e.msg)
print(d_error["errorMessage"], "\n")
def canorder(self):
csvID = self.getcsvID()
tradeList = trades.TradesList(accountID=self.accountID,
params=self.params)
orderList = orders.OrderList(accountID=self.accountID,
params=self.params)
self.client.request(tradeList)
self.client.request(orderList)
try:
tradeIDList = [x['id'] for x in tradeList.response['trades']]
orderIDList = [x['id'] for x in orderList.response['orders']]
if csvID not in tradeIDList:
if csvID not in orderIDList:
return True
return False
except Exception:
print("ordernow error")
def order_history_request(
order_state: str,
order_count: int,
accountID: str = account) -> Union[pd.DataFrame, bool]:
"""Request the orders list from Oanda.
Parameters
----------
order_state : str
Filter orders by a specific state ("PENDING", "CANCELLED", etc.)
order_count : int
Limit the number of orders to retrieve
accountID : str, optional
Oanda account ID, by default cfg.OANDA_ACCOUNT
"""
if accountID == "REPLACE_ME":
console.print("Error: Oanda account credentials are required.")
return False
parameters: Dict[str, Union[str, int]] = {}
parameters["state"] = order_state
parameters["count"] = order_count
if client is None:
return False
try:
request = orders.OrderList(accountID, parameters)
response = client.request(request)
df_order_list = pd.DataFrame.from_dict(response["orders"])
df_order_list = df_order_list[[
"id", "instrument", "units", "price", "state", "type"
]]
return df_order_list
except KeyError:
logger.exception("No orders were found")
console.print("No orders were found\n")
return False
except V20Error as e:
logger.exception(str(e))
d_error = json.loads(e.msg)
console.print(d_error["errorMessage"], "\n")
return False
},
"timeInForce": "GTC",
"instrument": "EUR_USD",
"units": "-100",
"type": "LIMIT",
"positionFill": "DEFAULT"
}
}
# r = orders.OrderCreate(accountID, data=data)
# client.request(r)
# create_order = pd.Series(r.response['orderCreateTransaction'])
# print(create_order)
"""
# 2 Get a list of open orders for an account
"""
r = orders.OrderList(accountID)
client.request(r)
account_orders_list = pd.Series(r.response['orders'][0])
print(account_orders_list)
"""
# 3 List all Pending Orders in an Account, before you cancel an order (pending order == open order)
use OrdersPending(), in lieu of the above OrderList() to cancel open orders
"""
r = orders.OrdersPending(accountID)
client.request(r)
res = r.response['orders']
last_order_id = res[0][
'id'] # also used directly below to get details for a single order
# print(res)
display_all_pending_orders = pd.Series(
def get_account_orders(cls):
"""
Get all orders fro the account.
"""
r = orders.OrderList(cls.account_id)
return cls.client.request(r)
def order_list(accountID, token):
client = oandapyV20.API(access_token=token)
r = orders.OrderList(accountID)
request = client.request(r)
return request
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}')
def list_orders(self):
endpoint = orders.OrderList(self.account_id)
self.send_request(endpoint)
return endpoint.response
def orders(self):
r = orders.OrderList(self.account_id)
return self.api.request(r)
def get_order_list(account_ID: str) -> List[Dict]:
""" Retrieve a list of open orders
"""
r = orders.OrderList(account_ID)
resp = client.request(r)
return resp["orders"]
def OrdersOrderList(access_token, accountID):
'Get a list of orders for an account'
r = orders.OrderList(accountID)
client = API(access_token=access_token)
client.request(r)
return readable_output(Munch(r.response)), Munch(r.response)
# and current_pl() < daily_take_profit and current_pl() > daily_stop_loss
while time.time() <= timeout:
try:
current_time = time.strftime('%Y-%m-%d %H:%M:%S')
print("\n----- passthrough at ",
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
'-----')
logging.error(f'\n######## PASSTHROUGH AT {current_time} ########')
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']
def get_OrderList(self, ticker):
r = orders.OrderList(accountID=self.accountID,
params={"instrument": ticker})
return self.client.request(r)
accountID = config_trading['DataOandaAccount']
access_token = config_trading['DataOandaToken']
# Telegram Config
TOKEN = config_trading['DataTgrChatID']
chatid = config_trading['DataTgrToken']
# tb = telebot.TeleBot(TOKEN)
# Do Not Touch
pairs_traded = '%s,%s' % (str(instrument_1), str(instrument_2))
pairs_traded_dict = {instrument_1, instrument_2}
api = API(access_token=access_token, environment="practice")
stream = PricingStream(accountID=accountID, params={"instruments": pairs_traded})
orders_list = orders.OrderList(accountID)
trades_list = trades.TradesList(accountID)
current_holding = 0
df_x_ = 0
df_y_ = 0
def get_src_cls(source_name):
return getattr(sys.modules[__name__], source_name)
class EGCointegration(Strategy):
def __init__(self, x, y, on, col_name, is_cleaned=True):
if is_cleaned is not True:
x, y = EGCointegration.clean_data(x, y, on, col_name)
def listOrder():
r = orders.OrderList(accountID)
api.request(r)
print(r.response)
