fixed bug in server.py and stock.py

Author: Edward Williams

publicBot.py

@@ -1,103 +1,103 @@
 import random
 #I'll need to change this to incorporate 
-from traderbot import traderbot
+from traderbot import TraderBot
 
 robot = TraderBot()
 
 stockArray = robot.getSymbols()
 
 #initial loop
-for ticker in stockArray
-	portfolio = robot.getPortfolio()
+for ticker in stockArray:
+  portfolio = robot.getPortfolio()
 
-	if (portfolio[ticker] != 0)
+  if (portfolio[ticker] != 0):
 
-		#selling distribution:
-		#25 percent at market price
-		#10 percent at 10 percent above market price
-		#10 percent at 10 percent below market price
-		#5 percent at 5 percent below market price
+    #selling distribution:
+    #25 percent at market price
+    #10 percent at 10 percent above market price
+    #10 percent at 10 percent below market price
+    #5 percent at 5 percent below market price
 
-		marketFraction = 0.25
-		aboveMarket = 0.10
-		tenBelowMarket = 0.10
-		fiveBelowMarket = 0.05
-			
-		price = robot.getPrice(ticker)
+    marketFraction = 0.25
+    aboveMarket = 0.10
+    tenBelowMarket = 0.10
+    fiveBelowMarket = 0.05
+      
+    price = robot.getPrice(ticker)
 
-		result = robot.ask((int)portfolio[ticker] *marketFraction , price, ticker)
-		if result == 'Accepted':
-        	print "trade accepted"
-    	elif result == 'Unsuccesful':
-        	print "trade declined"
-    	elif result == 'Pending':
-        	print "trade pending"
-    	else:
-        	print "not a recognizable order state"
-		result = robot.ask((int)portfolio[ticker]*aboveMarket, price*1.10, ticker)
-		if result == 'Accepted':
-        	print "trade accepted"
-    	elif result == 'Unsuccesful':
-        	print "trade declined"
-    	elif result == 'Pending':
-        	print "trade pending"
-    	else:
-        	print "not a recognizable order state"
-		result = robot.ask((int)portfolio[ticker]*tenBelowMarket, price*0.9, ticker)
-		if result == 'Accepted':
-        	print "trade accepted"
-    	elif result == 'Unsuccesful':
-        	print "trade declined"
-    	elif result == 'Pending':
-        	print "trade pending"
-    	else:
-        	print "not a recognizable order state"
-		result = robot.ask((int)portfolio[ticker]*fiveBelowMarket, price*0.95, ticker)
-		if result == 'Accepted':
-	        print "trade accepted"
-	    elif result == 'Unsuccesful':
-	        print "trade declined"
-	    elif result == 'Pending':
-	        print "trade pending"
-	    else:
-	        print "not a recognizable order state"
+    result = robot.ask((int)(portfolio[ticker] *marketFraction) , price, ticker)
+    if result == 'Accepted':
+      print "trade accepted"
+    elif result == 'Unsuccesful':
+      print "trade declined"
+    elif result == 'Pending':
+      print "trade pending"
+    else:
+      print "not a recognizable order state"
+    result = robot.ask((int)(portfolio[ticker]*aboveMarket), price*1.10, ticker)
+    if result == 'Accepted':
+      print "trade accepted"
+    elif result == 'Unsuccesful':
+      print "trade declined"
+    elif result == 'Pending':
+      print "trade pending"
+    else:
+      print "not a recognizable order state"
+    result = robot.ask((int)(portfolio[ticker]*tenBelowMarket), price*0.9, ticker)
+    if result == 'Accepted':
+      print "trade accepted"
+    elif result == 'Unsuccesful':
+      print "trade declined"
+    elif result == 'Pending':
+      print "trade pending"
+    else:
+      print "not a recognizable order state"
+    result = robot.ask((int)(portfolio[ticker]*fiveBelowMarket), price*0.95, ticker)
+    if result == 'Accepted':
+      print "trade accepted"
+    elif result == 'Unsuccesful':
+      print "trade declined"
+    elif result == 'Pending':
+      print "trade pending"
+    else:
+      print "not a recognizable order state"
 
 
 while True:
 
-	for ticker in stockArray:
-		portfolio = robot.getPortfolio()
-		if (portfolio[ticker] != 0):
-			trueValue = robot.getTrueValue(ticker)
-			price = robot.getPrice(ticker)
-			increment = abs(trueValue - price)/3
+  for ticker in stockArray:
+    portfolio = robot.getPortfolio()
+    if (portfolio[ticker] != 0):
+      trueValue = robot.getTrueValue(ticker)
+      price = robot.getPrice(ticker)
+      increment = abs(trueValue - price)/3
 
-			#bid for 10 percent of the total stock @ market value
-			#bid for 4 percent of total stock @ below market value
-			#bid for 3 percent of total stock @ above market value
-			#bid for 2 percent of total stock @ significantly above market value
-			#bid for 1 percent of total stock @ true value
-			if trueValue/price >1.05:
-				stockToBuy = 0.2 * robot.getVolume(ticker)
-				robot.bid((int)stockToBuy/2, price, ticker)
-				stockToBuy/= 2
-				robot.bid((int)stockToBuy*0.4, price - increment, ticker)
-				robot.bid((int)stockToBuy*0.3, price + increment, ticker)
-				robot.bid((int)stockToBuy*0.2, price + 2 * increment, ticker)
-				robot.bid((int)stockToBuy*0.1, price + 3 * increment, ticker)
+      #bid for 10 percent of the total stock @ market value
+      #bid for 4 percent of total stock @ below market value
+      #bid for 3 percent of total stock @ above market value
+      #bid for 2 percent of total stock @ significantly above market value
+      #bid for 1 percent of total stock @ true value
+      if trueValue/price >1.05:
+        stockToBuy = 0.2 * robot.getVolume(ticker)
+        robot.bid((int)(stockToBuy/2), price, ticker)
+        stockToBuy/= 2
+        robot.bid((int)(stockToBuy*0.4), price - increment, ticker)
+        robot.bid((int)(stockToBuy*0.3), price + increment, ticker)
+        robot.bid((int)(stockToBuy*0.2), price + 2 * increment, ticker)
+        robot.bid((int)(stockToBuy*0.1), price + 3 * increment, ticker)
 
-			#ask for 10 percent of the total stock @ market value
-			#ask for 4 percent of total stock @ above market value
-			#ask for 3 percent of total stock @ below market value
-			#ask for 2 percent of total stock @ significantly below market value
-			#ask for 1 percent of total stock @ true value
-			if trueValue/price < 0.95:
-				stockToSell = 0.3 * portfolio[ticker]
-				robot.ask((int)stockToSell/2, price, ticker)
-				stockToBuy/= 2
-				robot.ask((int)stockToSell*0.4, price + increment, ticker)
-				robot.ask((int)stockToSell*0.3, price - increment, ticker)
-				robot.ask((int)stockToSell*0.2, price - 2 * increment, ticker)
-				robot.ask((int)stockToSell*0.1, price - 3 * increment, ticker)
+      #ask for 10 percent of the total stock @ market value
+      #ask for 4 percent of total stock @ above market value
+      #ask for 3 percent of total stock @ below market value
+      #ask for 2 percent of total stock @ significantly below market value
+      #ask for 1 percent of total stock @ true value
+      if trueValue/price < 0.95:
+        stockToSell = 0.3 * portfolio[ticker]
+        robot.ask((int)(stockToSell/2), price, ticker)
+        stockToBuy/= 2
+        robot.ask((int)(stockToSell*0.4), price + increment, ticker)
+        robot.ask((int)(stockToSell*0.3), price - increment, ticker)
+        robot.ask((int)(stockToSell*0.2), price - 2 * increment, ticker)
+        robot.ask((int)(stockToSell*0.1), price - 3 * increment, ticker)
 
-	
+  

server.py

@@ -30,7 +30,10 @@ def ask(account_id, ticker, price, quantity):
   quantityAvailable = account.portfolio[ticker]
   if quantity > quantityAvailable:
     return 0
+
+  print "Account ID:", account_id  
   stock.sellAt(quantity, price, account_id)
+
   stocks[ticker]=stock
   return 1
 
@@ -41,6 +44,7 @@ def bid(account_id, ticker, price, quantity):
   account = accounts[account_id]
   if price * quantity > account.availableFunds:
     return 0
+  print "Account ID:", account_id  
   stock.buyAt(quantity, price, account_id)
   stocks[ticker]=stock
   return 1

stock.py

@@ -187,14 +187,14 @@ def buyAt(self, quantity, price, account_id):
     order = Order(account_id, quantity, price, self.ticker)
     self.buyQueue.append(order)
     self.buyQueue.sort(key = lambda order: order.price, reverse = True)
-    self.checkQueue()
+    self.checkQueues()
     #by price in descending
     #O(n*logn)
 
-  def sellAt(self, quantity, price, acccount_id):
+  def sellAt(self, quantity, price, account_id):
     order = Order(account_id, quantity, price, self.ticker)
     self.sellQueue.append(order)
     self.sellQueue.sort(key = lambda order: order.price)
-    self.checkQueue()
+    self.checkQueues()
     #by price in ascending
     #O(n*logn)