def __init__(self):
self._stock_levels = {}
self._sides = item.initialise_sides(self._stock_levels)
self._drinks = item.initialise_drinks(self._stock_levels)
self._ingredients = item.initialise_ingredients(self._stock_levels)
self._buns = item.initialise_buns(self._stock_levels)
self._order_manager = OrderManager()
self._lookup = {}
obj_list = (*self._sides, *self._drinks, *self._ingredients,
*self._buns)
for obj in obj_list:
self._lookup[obj.name] = obj
standard_burger_buns = [self.get_object_by_name("Sesame bun")] * 2
standard_burger_fillings = [
self.get_object_by_name(name)
for name in ("Beef Patty", "Cheddar Cheese", "Tomato Sauce")
]
standard_wrap_fillings = [
self.get_object_by_name(name)
for name in ("Chicken Patty", "Tomato", "Lettuce")
]
self._standard_burger = Burger(standard_burger_fillings,
standard_burger_buns)
self._standard_wrap = Wrap(standard_wrap_fillings)
def setUp(self):
self.order_manager = OrderManager()
self.person_1 = new_person(
{'username': '******', 'name': 'Name1', 'surname': 'Surname1', 'password': '******',
'passwordRetype': 'test123', 'email': '*****@*****.**'})
self.person_1.number_of_stocks = 5
self.person_1.save()
self.person_2 = new_person(
{'username': '******', 'name': 'Name2', 'surname': 'Surname2', 'password': '******',
'passwordRetype': 'test123', 'email': '*****@*****.**'})
self.person_3 = new_person(
{'username': '******', 'name': 'Name3', 'surname': 'Surname3', 'password': '******',
'passwordRetype': 'test123', 'email': '*****@*****.**'})
self.bidding_round = BiddingRound.objects.create(is_active=True)
stock_order_1 = StockOrder()
stock_order_1.owner = self.person_1
stock_order_1.order_type = BUY
stock_order_1.order_price_per_share = 8.5
stock_order_1.order_amount_of_shares = 10
stock_order_1.bidding_round = self.bidding_round
stock_order_2 = StockOrder()
stock_order_2.owner = self.person_1
stock_order_2.order_type = BUY
stock_order_2.order_price_per_share = 7.5
stock_order_2.order_amount_of_shares = 5
stock_order_2.bidding_round = self.bidding_round
stock_order_3 = StockOrder()
stock_order_3.owner = self.person_1
stock_order_3.order_type = BUY
stock_order_3.order_price_per_share = 6.5
stock_order_3.order_amount_of_shares = 15
stock_order_3.bidding_round = self.bidding_round
stock_order_arch = StockOrder()
stock_order_arch.owner = self.person_1
stock_order_arch.order_type = SELL
stock_order_arch.order_price_per_share = 5
stock_order_arch.order_amount_of_shares = 100
stock_order_arch.bidding_round = self.bidding_round
stock_order_arch.is_archived = True
self.order_1_person_1 = self.order_manager.place_order(stock_order_1)
self.order_2_person_1 = self.order_manager.place_order(stock_order_2)
self.order_3_person_1 = self.order_manager.place_order(stock_order_3)
self.order_archived_person_1 = create_stock_order(stock_order_arch)
self.order_1_person_2 = StockOrder.objects.create(owner=self.person_2)
self.order_2_person_2 = StockOrder.objects.create(owner=self.person_2)
self.order_1_person_3 = StockOrder.objects.create(owner=self.person_2)
def main():
try:
market = sys.argv[1]
except IndexError:
market = 'not a currency pair'
if market not in constants.MARKETS:
while True:
market = str(
input(
"Please specify which currency pair to use (btcusd, ltcusd, etc)."
))
if market in constants.MARKETS:
break
running = True
md = MarketDataInterface(market)
ts = TradingStrategy(market)
om = OrderManager(market)
while running:
action = ts.get_final_strategy()
price = (md.get_ticker_data(False))['value']
order_details = om.get_order_status(id)
if action['action'] == "buy":
result = om.buy(pair=market, risk=action['risk'], price=price)
order_details = om.get_order_status(result)
if result[0]:
logging.info('Successfully bought {0}{1} at {2}{3}'.format(
order_details['actual_amount'], market[:3],
order_details['actual_end_price'], market[-3:]))
else:
logging.info('Buy failed')
elif action['action'] == "sell":
result = om.sell(pair=market, risk=action['risk'], price=price)
order_details = om.get_order_status(result)
if result:
logging.info('Successfully sold {0}{1} at {2}{3}'.format(
order_details['amount'], market[:3],
order_details['price'], market[-3:]))
else:
logging.info('Sell failed')
elif action['action'] == "wait":
logging.info('Waited {}s, did not trade'.format(
settings.MAIN_TIMER))
else:
running = False
logging.error('Unsupported action')
time.sleep(settings.MAIN_TIMER)
if not running:
print('order error')
def test_checker(self):
#we expect the first order created to have an id of 0
self.x = OrderManager()
assert self.x.id_exists('0') == False
self.x.create_new_order()
assert self.x.id_exists('0') == True
def __init__(self):
# 股票 -> 策略
self.strategy_instance = StrategyFactory().create()
# 股票 -> 仓位
self.stock_position_dic = {}
# 订单管理
self.order_manager = OrderManager(self.stock_position_dic)
self.quote_manager = QuoteManager()
self.cumPNL = 0
def test_setters(self):
self.x = OrderManager()
id1 = self.x.create_new_order()
assert len(self.x.orders) == 1
assert type(self.x.orders[0]) == Order
assert type(self.x.get_order_by_id(id1)) == Order
id2 = self.x.create_new_order()
assert len(self.x.orders) == 2
def test_invalid_cases(self):
self.x = OrderManager()
with pytest.raises(TypeError):
self.x.get_order_by_id('1.1')
with pytest.raises(TypeError):
self.x.get_order_by_id(1.1)
with pytest.raises(KeyError):
self.x.get_order_by_id('1')
assert self.x.id_exists('a') == False
def process_order(self, order, delay=0):
order_manager = OrderManager(self)
is_acknowledged = order_manager.acknowledge_order(order)
time.sleep(delay)
if is_acknowledged:
print("order is acknowledged")
print(order.acknowledged)
print(order.rejected)
print(order_manager.warehouses)
order_manager.ship_order(order=order)
else:
print("There is no inventory for this order")
print(order.acknowledged)
print(order.rejected)
print(order_manager.warehouses)
def setUp(self):
self.lp_2_gateway = deque()
self.ob_2_ts = deque()
self.ts_2_om = deque()
self.ms_2_om = deque()
self.om_2_ts = deque()
self.gw_2_om = deque()
self.om_2_gw = deque()
self.liquidityProvider = LiquidityProvider(self.lp_2_gateway)
self.bookBuilder = OrderBook(self.lp_2_gateway, self.ob_2_ts)
self.tradingStrategy = TradingStrategy(self.ob_2_ts, self.ts_2_om,
self.om_2_ts)
self.marketSimulator = MarketSimulator(self.om_2_gw, self.gw_2_om)
self.orderManager = OrderManager(self.ts_2_om, self.om_2_ts,
self.om_2_gw, self.gw_2_om)
def __init__(self, exchange):
self.exchange = exchange
self.orderManager = OrderManager()
self.logger.info("Initiate Price Arbitrage Algo")
self._buildFxTree() # build fx tree for all possible conversions
# build list of leaves
root = self.tree.root # get root
w = Walker() # tree walker
# unwrap nested tuple returned by Walker to a flat list of FXPair
def unwrapWalkerToFlatList(x):
if isinstance(x, tuple):
if len(x) == 0: return []
s = []
for t in x:
s.extend(unwrapWalkerToFlatList(t))
return s
else:
if x.getFXPair() is None: return [] # skip root element
else: return [x.getFXPair()]
self.conversion_paths = {} # all conversion paths for the pair <pair: [pair1, pair2...]>
# build list of all conversion paths
for k in FXNode.treeNodesWithSamePair.keys(): # iterate all pairs
alternative_list = FXNode.treeNodesWithSamePair[k] # get list of leaves representing same pair but with different conversion path
paths = []
for c in alternative_list: # iterate all leaves (same pair but different paths)
if not c.is_leaf:
continue # iterate only leaves
path = unwrapWalkerToFlatList(w.walk(root, c)) # get path from root to this leaf
paths.append(path) # list of lists
if not k in self.conversion_paths.keys():
self.conversion_paths[k] = list(paths)
else:
self.conversion_paths[k].append(list(paths))
# set event triggers
self.exchange.setEventHandler(tradeHandler=self.updateTradeHandler, orderHandler=self.updateOrderHandler)
def __init__(self, *args, **kwargs):
super(TestOrderManager, self).__init__(*args, **kwargs)
self.server = app.test_client()
self.order_manager = OrderManager(self.server)
self.test_data_key = "1"
self.test_data = {"Toppings": "beef", "Sizes": "Large"}
self.test_data_key2 = "2"
self.test_data2 = {"Toppings": "Chicken", "Sizes": "Small"}
self.test_data_key3 = "3"
self.test_data3 = {"Toppings": "Fish", "Sizes": "Medium"}
#reset what is on the test_client first due to other test
r = self.server.get(self.order_manager._URL).get_json()
for k in r.keys():
self.server.delete(self.order_manager._URL, json=k)
#initialize the server and push the test_data first
#use dumps because it is more consistent with the ordermanager adding method
self.server.post(self.order_manager._URL,
json={self.test_data_key: json.dumps(self.test_data)})
self.server.post(
self.order_manager._URL,
json={self.test_data_key2: json.dumps(self.test_data2)})
def main():
lp_2_gateway = deque()
ob_2_ts = deque()
ts_2_om = deque()
om_2_ts = deque()
gw_2_om = deque()
om_2_gw = deque()
lp = LiquidityProvider(lp_2_gateway)
ob = OrderBook(lp_2_gateway, ob_2_ts)
ts = TradingStrategy(ob_2_ts, ts_2_om, om_2_ts)
ms = MarketSimulator(om_2_gw, gw_2_om)
om = OrderManager(ts_2_om, om_2_ts, om_2_gw, gw_2_om)
lp.read_tick_data_from_data_source()
while len(lp_2_gateway) > 0:
ob.handle_order_from_gateway()
ts.handle_input_from_bb()
om.handle_input_from_ts()
ms.handle_order_from_gw()
om.handle_input_from_market()
ts.handle_response_from_om()
lp.read_tick_data_from_data_source()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('market',
type=str,
choices=constants.MARKETS,
help='currency pair - btcusd, ltcusd, etc')
market = (parser.parse_args()).market
logging.info('the market {} was chosen'.format(market))
ts = TradingStrategy(market)
om = OrderManager(market)
md = MarketDataInterface(market)
running = True
while running:
action = ts.get_final_strategy()
price = Decimal(str((md.get_ticker_data(False))[3]))
time = datetime.datetime.now()
if abs((time - datetime.datetime.strptime(
md.get_ticker_data(False)[2],
'%Y-%m-%d %H:%M:%S')).seconds) > 600:
logging.error('database is out of date, exiting')
running = False
balance = om.get_balance()
if None in balance.values():
logging.info('failed to get account balance')
try:
if action['action'] == 'buy':
amount = (Decimal(str(action['risk'])) *
Decimal(balance['second_available']) / price)
elif action['action'] == 'sell':
amount = (Decimal(str(action['risk'])) *
Decimal(balance['available']))
else:
amount = Decimal('0')
except TypeError:
logging.exception('could not determine amount')
amount = Decimal('0')
if action['action'] in ['buy', 'sell']:
if market[-3:] in ['usd', 'eur']:
if (amount * price) < constants.EUR_USD_MIN_TRANSACTION_SIZE:
action['action'] = 'wait'
amount = Decimal('0')
logging.info(
'do not have minimum amount ({}) to trade'.format(
constants.EUR_USD_MIN_TRANSACTION_SIZE))
price = price.quantize(Decimal('.01'))
if market[:3] in ['xrp', 'usd', 'eur']:
amount = amount.quantize(Decimal('.00001'))
else:
amount = amount.quantize(Decimal('.00000001'))
elif market[-3:] == 'btc':
if (amount * price) < constants.BTC_MIN_TRANSACTION_SIZE:
action['action'] = 'wait'
amount = Decimal('0')
logging.info(
'do not have minimum amount ({}) to trade'.format(
constants.BTC_MIN_TRANSACTION_SIZE))
price = price.quantize(Decimal('.00000001'))
if action['action'] == 'buy':
sleep(1)
order_id = om.buy(price=price, amount=amount)
if order_id:
logging.info(
'successfully bought {amount}{currency_one} at {price}{currency_two} each'
.format(amount=amount,
currency_one=market[:3],
price=price,
currency_two=market[-3:]))
elif action['action'] == 'sell':
sleep(1)
order_id = om.sell(price=price, amount=amount)
if order_id:
logging.info(
'successfully sold {amount}{currency_one} at {price}{currency_two} each'
.format(amount=amount,
currency_one=market[:3],
price=price,
currency_two=market[-3:]))
elif action['action'] == 'wait':
logging.info('waiting {}s, did not trade'.format(
settings.MAIN_TIMER))
else:
running = False
logging.error(
'exiting trader - unsupported action (supported actions: buy, sell, wait), {}'
.format(action))
sleep(1)
open_orders = om.get_open_orders()
if open_orders:
for order in open_orders:
time = datetime.datetime.now().timestamp()
sleep(1)
if datetime.datetime.strptime(
order['datetime'],
'%Y-%m-%d %H:%M:%S').timestamp() < time - 21600:
om.cancel_order(order['id'])
sleep(settings.MAIN_TIMER)
logging.info('waited {}s to trade again'.format(settings.MAIN_TIMER))
def setUp(self):
self.order_manager = OrderManager()
#COMMISSION = .0 # Cost in dollars per share traded
#COMMISSION_MIN = .0 # Minimum cost in dollars per stock traded
#COMMISSION_MAX = .0 # Maximum cost in percent of trade value
#SLIPPAGE = .0 # Average slippage in price due to market volatility
# Create QuoteManager object
quote_manager = QuoteManager(DB_FILEPATH)
# Create AccountManager object
my_account = AccountManager(START_BALANCE, MARGIN_PERCENT, quote_manager)
# Create OrderManager object
order_manager = OrderManager(quote_manager,
my_account,
slippage=SLIPPAGE,
commission_min=COMMISSION_MIN,
commission=COMMISSION,
commission_max=COMMISSION_MAX)
# Create an order_history DataFrame
order_history = {}
# Load signals data
signals = pd.read_csv(SIGNALS_PATH, index_col=0)
signal_dates = [date.replace('-', '_') for date in signals.index]
# Load GDX component symbols
gdx_symbols = pd.read_csv(GDX_CSV_PATH).symbol
gdx_symbols = gdx_symbols[gdx_symbols.isin(signals.columns)]
# Skip days until START_DAY is found
def test_init(self):
self.x = OrderManager()
assert type(self.x._orders) == dict
assert self.x._up_to_id == 0
def test_get_signature(self):
om = OrderManager('btcusd')
self.assertDictEqual(om._OrderManager__get_signature(),
{'key': 'abcdefghijklmnopqrstuvwxyz123456',
'signature': '7728462B38496C189AFAED03A0C51FAB7D2358FA0FE1995C976FF755E794489D',
'nonce': '1563871382'})
# process_order(signal_dict)
# data.db_append_history(signal_dict)
# print('Signal "%s" zpracovan s nasledujicimi parametry:' % signal_dict['puvodni_zprava'])
# print("Operace: ", signal_dict['operace'])
# print("Mnozstvi:", int(signal_dict['mnozstvi'])*int(signal_dict['nasobeni']))
# print("Cena (signal/skutecnost): %d/%d" % (signal_dict['cena'], signal_dict['skutecna_cena']))
# print("Vysledek: %s - ID: %d" % (signal_dict['vysledek'], signal_dict['order_id']))
except Exception as loop_error:
tg_client.send_message("me", "CHYBA: %s" % loop_error)
raise
if __name__ == "__main__":
print("Spoustim pripojeni k API")
try:
tg_client, tws_client = get_clients()
orderman = OrderManager(tws_client, tws_queue)
tg_client.start()
# TODO: Vytvorit sjednocenou inicializacni metodu obsahujici server clock a ID printout
while tws_client.is_error():
print(tws_client.get_error())
tws_client.refresh_next_id()
except Exception as e:
print("[CHYBA!]: Nepovedlo se pripojit k TWS nebo Telegramu")
traceback.print_exc()
the_loop()