def utest_CheckOrders():
print '-- CheckOrders function --',
o1, o2 = [Order(BID, 999, 123.45, 100, 100) for _ in range(2)]
checkOrders(o1, o2)
o1, o2 = [Order(ASK, 9191, 32.54, 1000, 100) for _ in range(2)] # icebergs
checkOrders(o1, o2)
print 'OK'
def MakeOrders(self, currentPortfolio, targetPortfolio):
orders = []
for currentAsset in currentPortfolio:
# if exists in target, buy/sell to get to target
tgtAssetArray = [
a for a in targetPortfolio if a._symbol == currentAsset._symbol
]
if len(tgtAssetArray) > 0:
symbol = tgtAssetArray[0]._symbol
price = tgtAssetArray[0]._sharePrice
numShares = tgtAssetArray[
0]._numShares - currentAsset._numShares
if numShares > 0:
orders.append(Order("Buy", Asset(symbol, price,
numShares)))
elif numShares < 0:
orders.append(
Order("Sell", Asset(symbol, price, -numShares)))
else:
# else, sell all
orders.append(Order("Sell", currentAsset))
for targetAsset in targetPortfolio:
# if not exists in current, buy all
if not any([
a for a in currentPortfolio
if a._symbol == targetAsset._symbol
]):
orders.append(Order("Buy", targetAsset))
return orders
def run(self):
global stop
while not stop:
time.sleep(5)
command = input("commande : ").split()
if len(command) > 0:
if command[0] == "order":
start = float(time.time()) + float(command[2])
end = start + float(command[3])
order = Order(float(command[1]), start, end, time.time())
lock.acquire(1)
Agent.send({"order": Agregate(AgType.COM, order)})
lock.release()
if command[0] == "go":
for i in range(60):
print("top ", i)
start = float(time.time()) + float(command[2])
end = start + float(command[3])
order = Order(float(command[1]), start, end,
time.time())
lock.acquire(1)
Agent.send({"ORDER": Agregate(AgType.COM, order)})
lock.release()
time.sleep(float(command[2]) + float(command[3]) + 3)
stop = True
if command[0] == "stop":
stop = True
def manage_fx_hedge(portfolio, bar, order):
if Cp.hedge_fx is True and get_ccy(order.ticker) == 'USD':
# Case 1: New equity position opened, hedge the USD consideration
if portfolio.fx_position[order.ticker] == 0.0:
usd_amount_to_hedge = -1.0 * order.price * order.quantity
portfolio.fx_position[order.ticker] = usd_amount_to_hedge
fx_order = Order(open_date=bar['DealDate'],
ticker='USD-GBP',
quantity=usd_amount_to_hedge,
price=order.fx,
order_type='MKT',
ccy='GBP',
fx=1.0,
trade_status='OPEN')
# Case 2: Equity position being closed
else:
usd_amount_to_hedge = -1.0 * portfolio.fx_position[order.ticker]
portfolio.fx_position[order.ticker] = 0.0
fx_order = Order(open_date=bar['DealDate'],
ticker='USD-GBP',
quantity=usd_amount_to_hedge,
price=order.fx,
order_type='MKT',
ccy='GBP',
fx=1.0,
trade_status='CLOSE')
fx_order.trade_id = '{}_{}'.format(order.trade_id, order.ticker)
portfolio.orders.append(fx_order)
def change(self):
i = 0
if (User[CurrentUser[1]].getType() == 0):
void.setAddress(self.Page2_Address.text())
self.stackedWidget.setCurrentIndex(2)
randFood = random.randint(0, len(Menu) - 1)
temp = CurrentCart.copy()
if (User[CurrentUser[1]].getType() == 0):
addPendingOrder(Order(void, temp))
elif (User[CurrentUser[1]].getType() != 0):
if (User[CurrentUser[1]].getType() == 2):
randomFood = Food(Menu[randFood].getName() + " *Free*", 0,
Menu[randFood].getCate(),
Menu[randFood].getSpice())
User[CurrentUser[1]].addUserOrder(randomFood)
addCurrentCart(randomFood)
self.Page3_label4.show()
addPendingOrder(Order(User[CurrentUser[1]], temp))
while i < len(User[CurrentUser[1]].order):
self.Page3_listView.addItem(
User[CurrentUser[1]].order[i].getName() + "\t\t\t" +
format(User[CurrentUser[1]].order[i].getPrice(), '.2f'))
i += 1
User[CurrentUser[1]].order.clear()
print(currentCartSize())
def test_Order(self):
o1 = Order(1, 10, 2.5, datetime.now(), Side.BUY, 'FB',
OrderType.MARKET)
self.assertEqual(o1.order_id, 10)
self.assertEqual(o1.side, Side.BUY)
self.assertEqual(o1.ordertype, OrderType.MARKET)
self.assertEqual(o1.filled, 0)
self.assertEqual(o1.ticker, 'FB')
self.assertEqual(o1.price, None)
self.assertEqual(o1.quantity, int(2))
self.assertEqual(o1.is_fulfilled(), False)
o1.fill_order(1)
self.assertEqual(o1.filled, 1)
self.assertEqual(o1.is_fulfilled(), False)
o1.fill_order(2)
self.assertEqual(o1.filled, 2)
self.assertEqual(o1.is_fulfilled(), True)
with self.assertRaises(ValueError):
Order(1, 1, 2.5, datetime.now(), 'error', 'FB', OrderType.MARKET)
Order(1, 1, 2.5, datetime.now(), 'buy', 'FB', 'error')
# Test limit order
with self.assertRaises(ValueError):
Order(2, 10, 5, datetime.now(), Side.BUY, 'FB', OrderType.LIMIT)
o2 = Order(2, 10, 5, datetime.now(), Side.BUY, 'FB', OrderType.LIMIT,
3)
self.assertEqual(o2.price, 3)
self.assertEqual(o2.trades, [])
def enter_short_position(portfolio, bar, ticker):
# Money & Risk Management: Use StdDev
sd = bar['Std_Dev_pct_' + ticker]
if sd == 0.0:
sd = 1.0
fx_l = get_fx(bar, ticker) # fx rate for ticker
# position s/b between min_position and max_position e.g. between GBP3000 and GBP10000
try:
position = max(
abs(Cp.min_position),
min(abs(Cp.max_position), abs(Cp.amount_to_risk_per_trade / sd)))
except:
position = 10000.0
position = (-1.0) * position
# Determine quantity of assets
qty = int(position / (bar['EntryPrice_' + ticker] * fx_l))
# Determine stop prices
stop_price = (1 / fx_l) * (position - Cp.amount_to_risk_per_trade) / qty
deal_date = bar['DealDate']
deal_price = bar['EntryPrice_' + ticker]
ccy = get_ccy(ticker)
fx = get_fx(bar, ticker)
# Add a Market Order
market_order = Order(open_date=deal_date,
ticker=ticker,
quantity=qty,
order_type='MKT',
price=deal_price,
ccy=ccy,
fx=fx)
portfolio.trade_id[ticker] += 1
market_order.trade_id = portfolio.trade_id[ticker]
portfolio.orders.append(market_order)
# Risk Management: Add an associated Stop Order
stop_order = Order(open_date=deal_date,
ticker=ticker,
quantity=-qty,
order_type='STP',
ccy=ccy,
fx=fx)
stop_order.price = stop_price
stop_order.trade_id = market_order.trade_id
portfolio.orders.append(stop_order)
# Hedge FX risk
manage_fx_hedge(portfolio, bar, market_order)
def _prepare_for_random(self, stack_space: list, insert_no: set,
result: list):
"""
递归函数，目的是为了寻找一条合适的路径就停下来，如果递归结束都没有找到，那就输出不存在
注意：现在还没有考虑递归深度的问题
stack_space:
[(now_address),(able_index)]
[(1,2,0,0),(2,3)]
[(1,0,2,0),(1,3)]
"""
# 栈中没东西，说明本层没有合适路径，需要退回上一层寻找，直接return
if not stack_space:
return
else:
# 最后一个数字查好了以后，栈中只可能有一个元素
# 如果没有数字可以插，表示需要判断这个元素是不是满足要求
if not insert_no:
# 把该元素弹出来，去判断是不是符合要求
temp_item = stack_space.pop()
temp_address = list(temp_item[0])
temp_routine = []
# 如果满足了要求，修改标志位，修改result（result必须是可变的），return
if self._find_one_routine(Order(temp_address), temp_routine):
result.append((temp_routine, Order(temp_address)))
# 修改标志位
self._random_flag = True
return
# 如果还有能插的位置，则对该栈中的元素洗牌后，依次弹出，弹的每一个去计算新表，然后递归调用
else:
# 这里其实也可以对插入数字的队列进行洗牌，显得更加的随机
curr_insert_no = insert_no.pop()
random.shuffle(stack_space)
while stack_space and (not self._random_flag):
# 弹出一个，进行操作
temp_item = stack_space.pop()
temp_address = temp_item[0].copy()
temp_index = deque(temp_item[1].copy())
# 下面进行插入操作，可行结果放到新的stack中，进行后续递归
new_stack_space = []
# 循环进行几次，取决有有多少个空位
loop_times = len(temp_index)
for i in range(loop_times):
curr_index = temp_index.popleft()
temp_address[curr_index] = curr_insert_no
if self.arr_checker(temp_address):
# 将新的一个下一折的地址和对应空位的信息打包放入新栈
new_stack_space.append(
((temp_address.copy()), temp_index.copy()))
# 还原操作
temp_address[curr_index] = 0
temp_index.append(curr_index)
# 某一个排列对应的next的新表做好了以后，直接递归调用求下一次的
self._prepare_for_random(new_stack_space, insert_no.copy(),
result)
def test_order():
"""
This is a perfect case!
A new order initialOrder is created an then used to create updatedOrder in perfect use case. No errors.
Asserts to check updating is happening correctly.
"""
initialOrder = Order(1568390243, 'abbb11', 'AAPL', 'B', 209.00000, 100)
updatedOrder = Order(1568390247,
'abbb11',
quantity=101,
orgOrder=initialOrder)
assert updatedOrder.ticker == 'AAPL'
assert updatedOrder.quantity == 101
assert updatedOrder.side == 'B'
def utest_Order():
print '-- Order --',
o = Order( BID, 999, 123.45, 100, 100)
checkOrder(o, True, False, 999, 123.45, 100, 100)
o1 = Order( BID, 9191, 32.54, 1000, 100) # iceberg
checkOrder(o1, True, True, 9191, 32.54, 1000, 100)
o2 = Order( ASK, 999, 123.45, 100, 100)
checkOrder(o2, False, False, 999, 123.45, 100, 100)
o3 = Order( ASK, 9191, 324, 1000, 100) # iceberg
checkOrder(o3, False, True, 9191, 324, 1000, 100)
print 'OK'
def get_depth(self, base, alt):
order_book = {'bids': [], 'asks': []}
pair, swapped = self.get_validated_pair((base, alt))
if pair is None:
return
pairstr = pair[0].lower() + "_" + pair[1].lower()
if swapped:
bids, asks = btceapi.getDepth(pairstr)
else:
asks, bids = btceapi.getDepth(pairstr)
order_book['bids'] = [Order(float(b[0]), float(b[1])) for b in bids]
order_book['asks'] = [Order(float(a[0]), float(a[1])) for a in asks]
return order_book
def get_order_obj(self, msg, order_id):
''' Construct an order object '''
stock_symbol = self.get_stock_symbol_from_msg(msg)
quantity = self.get_quantity_from_add_msg(msg)
return Order(order_id, stock_symbol, quantity)
def queue_order():
if request.headers['Content-Type'] == 'application/json':
requestdatajson = request.get_json()
custid = requestdatajson['custId']
custname = requestdatajson['customerName']
itemname = requestdatajson['itemName']
neworder = Order(customerid=custid,
customername=custname,
itemname=itemname)
# neworder.displayOrder()
orderQueue.put(neworder)
responsedata = {'status': 'Order Queued'}
# resp = jsonify(responsedata)
responsedata = json.dumps(responsedata)
resp = Response(responsedata, status=201, mimetype='application/json')
return resp
else:
responsedata = {'status': '415 - Unsupported media type!!! '}
resp = jsonify(responsedata)
resp.status_code = 415
return resp
def test_remove_item(self):
order = Order(1)
pizza = Pizza("vegetarian_pizza", 0, "small")
order.add_item(pizza)
order.remove_item(1)
assert 1 not in order.ids_to_items
assert len(order.items) == 0
def process_order(self):
"""
Processes the order received.
"""
factory_mapper = FactoryMapping()
d = {}
for detail in self._order_lst:
i = 0
for value in detail:
d[self._column[i]] = value
i += 1
if d['holiday'] == "Christmas":
factory = factory_mapper.map(1)
elif d["holiday"] == "Halloween":
factory = factory_mapper.map(2)
else:
factory = factory_mapper.map(3)
corrupted = self.check_corrupted(d)
corrupted_reason = self.check_corrupted(d)
self._orders.append(
Order(ord_num=d["order_number"],
product_id=d["product_id"],
item_type=d["item"],
name=d["name"],
prod_detail=dict(d),
factory_obj=factory,
corrupted=corrupted,
corrupted_reason=corrupted_reason))
def generateSampleOrder():
from Order import Order
order = Order()
order.setLab(generateSampleLab())
order.setTestList(kgenerateTestList())
order.setPrescDetail(kgeneratePrescriptionDetail())
return order
def readStore(self): # yuki
with open('database.json', 'r') as infile:
savedStore = json.loads(infile.read())
for productData in savedStore['products']:
productId = productData['id']
productName = productData['name']
productUnit = productData['unit']
productOriginalPrice = productData['originalPrice']
productSource = productData['source']
productShelfLife = productData['shelfLife']
batches = productData['batch']
product = Product(productId, productName, productUnit,
productOriginalPrice, productSource,
productShelfLife)
for batch in batches:
sDate = batch['shelfDate'].split('-')
bShelfDate = datetime.date(int(sDate[0]), int(sDate[1]),
int(sDate[2]))
batchId = batch['batchId']
batchActualPrice = batch['actualPrice']
batchQuantity = batch['quantity']
batchShelfDate = bShelfDate
product.buildBatch(batchId, batchActualPrice, batchQuantity,
batchShelfDate, productShelfLife)
self.products.append(product)
for customerData in savedStore['customers']:
cId = customerData['id']
cPassword = customerData['password']
cName = customerData['name']
cPhoneNumber = customerData['phoneNumber']
cAddress = customerData['address']
cBalance = customerData['balance']
cShoppingCart = customerData['shoppingCart']
customer = CustomerAccount(cId, cPassword, cName, cPhoneNumber,
cAddress, cBalance)
customer.shoppingCart.setProductsInCart(cShoppingCart)
self.customers.append(customer)
for customerId in savedStore['orderHistory']:
cOrderList = savedStore['orderHistory'][customerId]
customerOrders = []
for eachOrder in cOrderList:
orderId = eachOrder['orderId']
orderCId = eachOrder['customerId']
tempShoppingCart = eachOrder['shoppingCart']
orderShoppingCart = ShoppingCart()
orderShoppingCart.setProductsInCart(tempShoppingCart)
orderTotalPrice = eachOrder['totalPrice']
dateS = eachOrder['transactionDate'].split('-')
orderTransactionDate = datetime.datetime(
int(dateS[0]), int(dateS[1]), int(dateS[2]), int(dateS[3]),
int(dateS[4]), int(dateS[5]))
order = Order(orderId, orderCId, orderShoppingCart,
orderTotalPrice, orderTransactionDate)
customerOrders.append(order)
self.orderHistory[customerId] = customerOrders
ownerData = savedStore['owner']
self.owner = OwnerAccount(ownerData['id'], ownerData['name'],
ownerData['password'])
def zic_strategy(observation):
# If the player has already traded, idle
if observation['trader'].order == None:
return None
# Obtain details from observation
time = observation['lob']['time']
tid = observation['trader'].tid
order_price = observation['trader'].order.price
order_type = observation['trader'].order.otype
min_price = observation['trader'].exchange_rules['minprice']
max_price = observation['trader'].exchange_rules['maxprice']
# Choose price
if order_type == OType.BID:
price = random.randint(min_price, order_price)
elif order_type == OType.ASK:
price = random.randint(order_price, max_price)
else:
raise RuntimeError('Observation contains malformed order.')
# Form and return order
order = Order(tid, order_type, price, 1, time)
return order
def addOrder(self,
isBuy=None,
orderId=None,
price=None,
qty=None,
peakSize=None,
order=None):
'''| TODO
| Creates and adds an order to the map of orders. In addition, pointer to the order is added to the proper map (bid/ask) and
| vector (price level). The maps are ordered, therefore, inserting elements with price as keys, automatically builds a correct
| depth of the book.
| Note: best bid is the last element (price level) of the bid map; best ask is the first element (price level) of the ask map.
|________'''
# Already checked that an order with the same Id is not present in the book
myOrder = Order(isBuy, orderId, price, qty,
peakSize) if order == None else order
self.activeOrders[myOrder.orderId] = myOrder
# TODO: Where do we deal with int*100 price as keys?
key_price = int(myOrder.price * 100)
level = self.bid if myOrder.isBuy else self.ask
if key_price not in level:
level[key_price] = Level()
level[key_price].addOrder(myOrder)
def ApproveOrRejectOrder(self, Command: ApproveOrRejectOrderCommand):
Events, SnapshotData = OrderRepository().Find(Command.OrderId, 'Order')
UpdatedOrder = Order()
UpdatedOrder.Revise(SnapshotData, Events)
Events = UpdatedOrder.procces_OrderApproveOrRejectCommand(Command)
UpdatedOrder.apply_OrderApprovedOrRejectedEvent(Events[0])
OrderRepository().Update((UpdatedOrder, ), Events, Command.MessageId)
def test_pizza_methods():
order = Order()
assert order.countPizza == 0 and order.countDrinks == 0
order.add_pizza("pepperoni small []")
assert order.countPizza == 1
assert order.user_order['pizza'][0] == \
{"pizzaType": "pepperoni", "pizzaSize": "small", "toppings": []}
order.change_type(0, "vegetarian")
assert order.user_order['pizza'][0] == \
{"pizzaType": "vegetarian", "pizzaSize": "small", "toppings": []}
order.change_size(0, "medium")
assert order.user_order['pizza'][0] == \
{"pizzaType": "vegetarian", "pizzaSize": "medium", "toppings": []}
order.change_toppings(0, "[jalapenos,olives]")
assert order.user_order['pizza'][0] == \
{"pizzaType": "vegetarian", "pizzaSize": "medium", "toppings": ['jalapenos', 'olives']}
try:
order.change_type(0, "Obama")
except ValueError:
assert order.user_order['pizza'][0] == \
{"pizzaType": "vegetarian", "pizzaSize": "medium", "toppings": ['jalapenos', 'olives']}
assert order.countPizza == 1
order.delete_pizza(0)
assert order.countPizza == 0
def addWebOrder():
from typing import Dict, List
# Converts string date into datetime object
from datetime import datetime
date: datetime = datetime.strptime(request.form["date"], '%Y-%m-%d')
# Category is a work in progress
# category= request.form["category"]
location: str = request.form["loc"]
subtotals: Dict[str, float] = {
'Nishant': float(request.form["nishant"]),
'Arjun': float(request.form["arjun"]),
'Param': float(request.form["param"]),
}
newUserName = request.form["userName"]
if newUserName:
subtotals[newUserName] = float(request.form["userTotal"])
total = float(request.form["total"])
# Adds order to database
from DB import DB
from Order import Order
excessive: List[Dict] = DB.add(Order(date, location, subtotals, total))
# Sends member a confirmation message
Twilio.Communication.send(
"\nAdded order from %s for a total of $%.2f" % (location, total),
"Nishant")
Twilio.alert(excessive)
def from_dict(self, flower_shop_dict):
self.logged_user = None
self.name = ""
if 'name' in flower_shop_dict:
self.name = flower_shop_dict['name']
self.flowers = []
if 'flowers' in flower_shop_dict:
for flower_dict in flower_shop_dict['flowers']:
flower = Flower()
flower.from_dict(flower_dict)
self.flowers.append(flower)
self.bouquets = []
if 'bouquets' in flower_shop_dict:
for bouquet_dict in flower_shop_dict['bouquets']:
bouquet = Bouquet()
bouquet.from_dict(bouquet_dict, self.flowers)
self.bouquets.append(bouquet)
self.users = []
if 'users' in flower_shop_dict:
for user_dict in flower_shop_dict['users']:
user = User()
user.from_dict(user_dict)
self.users.append(user)
self.orders = []
if 'orders' in flower_shop_dict:
for order_dict in flower_shop_dict['orders']:
order = Order()
order.from_dict(order_dict, self.bouquets)
self.orders.append(order)
self.orders_id_counter = len(self.orders)
self.users_id_counter = len(self.users)
self.flowers_id_counter = len(self.flowers)
self.bouquets_id_counter = len(self.bouquets)
def getInitActiveOrders(self):
ackMsg = self.trading_client.get_openorders()
if type(ackMsg) == dict:
if len(ackMsg['result']) == 0:
return ackMsg
else:
tmpActiveOrderList = []
for i in range(len(ackMsg['result'])):
obj = ackMsg['result'][i]
odid = str(obj['orderId'])
symbol = str(obj['instrument'])
sym_ = symbol.split('-')[0]
_sym = symbol.split('-')[1]
orderType = str(obj['type'])
price = float(obj['price'])
side = str(obj['direction'])
qty = float(obj['quantity'])
o = Order(self.exchCode, sym_, _sym, orderType, price,
side, qty)
o.odid = odid
o.status = 'ACTIVE'
o.activeTs = nowStr()
tmpActiveOrderList.append(o)
return tmpActiveOrderList
else:
intAckMsg = self.handleUnknownMsg(ackMsg['message'])
return intAckMsg
def customer_loop(self, id, containers_list, orders):
print("Hello in Klient App")
select_char = "s"
while select_char != "q":
select_char = input("Select action:\n"
"\t1. Show available offer\n"
"\t2. Submit your order\n"
"\t3. My orders\n"
"\t4. Exit\n").upper()
if select_char not in "1234" or len(select_char) != 1:
print("No such action")
continue
if select_char == '1':
for i in range(len(containers_list)):
containers_list[i].print_info(i)
elif select_char == '2':
order = Order()
for i in range(len(containers_list)):
containers_list[i].print_info(i)
container_id = int(input("Enter the container id: "))
order.set_order(id, containers_list[container_id], False)
orders.append(order)
elif select_char == '3':
for i in range(len(orders)):
if orders[i].id == id:
orders[i].print_order(i)
elif select_char == "4":
return
def strat_ma(self, n_days):
print('Executing a simple MA strategy...')
self.order_book = Order_Book(self.cash)
end_date = dt.now()
start_date = end_date - timedelta(days=n_days)
for asset in self.asset_list:
df = scrape_page(asset.name, asset.ticker, start_date, end_date)
ma = df['close'].rolling(len(df)).mean().iloc[-1]
close = df['close'].iloc[-1]
if ma > close and asset.position > 0:
self.order_book.add_order(
Order(asset, 'Sell', ma, asset.position))
elif ma < close:
self.order_book.add_order(
Order(asset, 'Buy', ma, 1 / float(df.std())))
self.order_book.execute_order()
def exit_position(portfolio, bar, ticker):
"""Creates new MKT orders to flatten current position for a ticker and cancels any associated STP orders"""
qty = -portfolio.position[ticker]
deal_date = bar['DealDate']
deal_price = bar['EntryPrice_' + ticker]
if qty != 0:
ccy = get_ccy(ticker)
fx = get_fx(bar, ticker)
# Add a Market Order to close current position
market_order = Order(open_date=deal_date,
ticker=ticker,
quantity=qty,
order_type='MKT',
price=deal_price,
ccy=ccy,
fx=fx)
market_order.trade_id = portfolio.trade_id[ticker]
market_order.trade_status = 'CLOSE'
portfolio.orders.append(market_order)
# Cancel any OPEN STP orders for the ticker
for stop_order in portfolio.orders:
if stop_order.ticker == ticker and stop_order.status == 'OPEN' and stop_order.order_type == 'STP':
stop_order.cancel_order(deal_date)
# Remove FX Hedge
manage_fx_hedge(portfolio, bar, market_order)
def test_update_total(self):
order = Order(1)
assert order.order_total == 0
pizza = Pizza("vegetarian_pizza", 0, "small")
order.add_item(pizza)
order.update_total()
assert order.order_total == 9.99
def parse(file):
file = open(file)
lines = [line.rstrip('\r\n') for line in file.readlines()]
variables = lines[0].split(' ')
r, c, drones, deadline, max_load = variables
products_count = int(lines[1])
products = [
Product(index, int(lines[2].split(' ')[index]))
for index in range(len(lines[2].split(' ')))
]
warehouse_count = int(lines[3])
# this used to have for warehouse_no in range(warehouse_count*2-1)
# - what was the *2-1 for? It makes us 19 warehouses rather than 10
warehouses = [
Warehouse(convert_coord(lines[warehouse_no + 4]),
convert_products(lines[warehouse_no + 5], products),
warehouse_no) for warehouse_no in range(warehouse_count)
]
orders_offset = 4 + warehouse_count * 2
orders_count = int(lines[orders_offset])
orders = [
Order(convert_coord(lines[order_no + orders_offset]),
lines[order_no + orders_offset + 2], order_no)
for order_no in range(orders_count * 3 - 1)
]
return {'orders': orders, 'warehouses': warehouses, 'variables': variables}
def test_drink_methods():
order = Order()
assert order.countPizza == 0 and order.countDrinks == 0
order.add_drink("coke", 2)
assert order.countDrinks == 1
assert order.user_order['drinks'] == {"coke": 2}
order.add_drink("water", 2)
assert order.user_order['drinks'] == {"water": 2, "coke": 2}
assert order.countDrinks == 2
order.change_drink_quantity("water", 7)
assert order.user_order['drinks'] == {"water": 7, "coke": 2}
order.change_drink_quantity("coke", 0)
assert order.user_order['drinks'] == {"water": 7}
assert order.countDrinks == 1
order.add_drink("water", 2)
assert order.user_order['drinks'] == {"water": 9}
try:
order.change_drink_quantity("coke", 3)
except ValueError:
assert order.user_order['drinks'] == {"water": 9}
try:
order.add_drink("ciroc", 2)
except ValueError:
assert order.user_order['drinks'] == {"water": 9}
