def get_datapath(start, end ): try: s = Stock(sys.argv[1]) except: print('Need to provide Stock symbol as an argument') sys.exit(1) return s.range2csv(start, end)
def __init__(self, stock=None): if stock is None: self._stock = Stock() else: self._stock = stock self._orders = [] self._completed = []
def simulate_market(): all_trades = [] for item in TEST_DATA: current_trade_raw = item.pop('trade') current_stock = Stock(**item) current_trade_raw['stock'] = current_stock current_trade = Trade(**current_trade_raw) all_trades.append(current_trade) return all_trades
def __init__(self): self._id = 0 self._order = [ ] # a list of Order. order's id should be in increasing order # self._category = ['Mains': self._mainsMenu, 'Drinks': self._drinksMenu, 'Sides': self._sidesMenu] self._name = "" # Restaurant name self._mainsMenu = [] # a list of Mains self._drinksMenu = [] # a list of drinks self._sidesMenu = [] # a list of sides self._stock = Stock() self._statusList = [ 'Not Submitted', 'Pending', 'Preparing', 'Ready', 'Picked Up' ]
def test_stock_update(self): goog = Stock("GooG") goog.update(datetime(2014, 2, 12), 10) self.assertEqual(10, goog.price)
import sys from os.path import abspath, join, dirname sys.path.insert(0, join(abspath(dirname(__file__)), '..')) dirpath = join(abspath(dirname(__file__)), '..') outpath = join(dirpath, 'out') from src.stock import Stock from src.simulate_pool import run_simulate_pool from src.test_strategy_pool import get_strategy_pool from src.log import init_log logging = init_log() stock = Stock() def get_stock_pool(): return [ '600000.SH', '002032.SZ', '600030.SH', '601318.SH', '000001.SZ', '000002.SZ', '600612.SH', '600188.SH', '600340.SH', '600048.SH', '000048.SH', '601966.SH',
class StockTest(unittest.TestCase): @classmethod def setUpClass(cls): pass def setUp(self): self.stock = Stock("GOOG") def trend_fixture(self, prices): """Create new prices in price history from a list of Float. To be used in the tests below.""" return [self.stock.update(datetime(2015, 12, i+1), price=p) for i, p in enumerate(prices)] def test_should_create_Stock_object(self): self.assertIsInstance(self.stock, Stock) self.assertRaises( ValueError, self.trend_fixture, [80, -78.3, 81.1] ) def test_price_of_a_new_stock_class_should_be_None(self): self.assertIsNone(self.stock.price) def test_should_update_price(self): """Requirement: * Price has to update properly via a `update` method, with a timestamp also" """ self.stock.update(datetime(2015, 12, 5), price=80) self.assertEqual(self.stock.price, 80) def test_negative_price_should_raise_valuerror(self): """Requirement: * Price cannot be negative""" # assertRaise returns a context! Cool with self.assertRaises(ValueError): self.stock.update(datetime(2015, 12, 5), -1) def test_after_multiple_updates_should_return_ordered(self): """Requirement: * After multiple updates, elements in stock.price_history should be ordered from the latest to the oldest""" self.stock.update(datetime(2015, 12, 5), price=80) self.stock.update(datetime(2015, 12, 6), price=82.6) self.stock.update(datetime(2015, 12, 4), price=81) self.stock.update(datetime(2015, 12, 9), price=87.6) self.stock.update(datetime(2015, 12, 7), price=81.9) self.stock.update(datetime(2015, 12, 8), price=84.9) self.assertEqual( [s[1] for s in self.stock.price_history], [81, 80, 82.6, 81.9, 84.9, 87.6] ) def test_after_multiple_updates_should_return_last(self): """Requirement: * After multiple updates, stock.price returns the latest price""" self.stock.update(datetime(2015, 12, 5), price=80) self.stock.update(datetime(2015, 12, 6), price=82.6) self.stock.update(datetime(2015, 12, 4), price=81) self.stock.update(datetime(2015, 12, 9), price=87.6) self.stock.update(datetime(2015, 12, 7), price=81.9) self.stock.update(datetime(2015, 12, 8), price=84.9) self.assertAlmostEqual(self.stock.price, 87.6, delta=0.1) def tearDown(self): print(self.stock) if self.stock.price is not None else None del self.stock pass @classmethod def tearDownClass(cls): pass
def setUp(self): self.stock = Stock("GOOG")
def test_ma_factor(self): test_stock = Stock('AAPL') ma_fac = MovingAverageFactor(short_term=20, long_term=100) ma_1 = ma_fac(stock=test_stock, end_date='2019-11-15')
class System(): def __init__(self, stock=None): if stock is None: self._stock = Stock() else: self._stock = stock self._orders = [] self._completed = [] #self._curr_id = 0 def check_status(self, ID): order = self.get_order(ID) completed_order = self.get_completed_order(ID) if (order is None and completed_order is None): raise InvalidID("No order exists for ID of:" + str(ID)) if order is None: return True else: return False def get_orders(self): return self._orders def get_completed(self): return self._completed def get_completed_order(self, ID): for order in self._completed: if (order.get_ID() == ID): return order return None def get_stock(self): return self._stock def update_status(self, ID): updating_order = self.get_order(ID) updating_order.set_status(True) self._completed.append(updating_order) self.remove_order(ID) def get_order(self, ID): for order in self._orders: if (order.get_ID() == ID): return order return None def generate_id(self): ID = len(self._orders) + len(self._completed) + 1 #self._curr_id += 1 return ID def new_order(self, id): new_order = Order() new_order.set_ID(id) self._orders.append(new_order) return new_order def remove_order(self, ID): self._orders.remove(self.get_order(ID)) def update_stock(self, item, quantity): self._stock.update_item(item, quantity) def max_allowed(self, item): return self._stock.get_item_stock(item) def check_stocks(self, order, stocks): errors = [] order_list = order.get_order_list() for item in order_list: if (isinstance(item, Wrap)): stocks['Wrap'] -= 1 if (isinstance(item, Main)): for ingredient in item.get_ingredients(): stocks[ingredient] -= item.get_ingredients()[ingredient] elif (item.get_name() == "Small fries"): stocks["Fries"] -= 75 elif (item.get_name() == "Medium fries"): stocks["Fries"] -= 125 elif (item.get_name() == "Large fries"): stocks["Fries"] -= 175 elif (item.get_name() == "Small orange juice"): stocks["Orange juice"] -= 250 elif (item.get_name() == "Medium orange juice"): stocks["Orange juice"] -= 450 elif (item.get_name() == "Large orange juice"): stocks["Orange juice"] -= 600 elif (item.get_name() == "Nuggets 3P"): stocks["Nuggets"] -= 3 elif (item.get_name() == "Nuggets 6P"): stocks["Nuggets"] -= 6 elif (item.get_name() == "Small chocolate sundae"): stocks["Chocolate sundae"] -= 200 elif (item.get_name() == "Medium chocolate sundae"): stocks["Chocolate sundae"] -= 300 elif (item.get_name() == "Large chocolate sundae"): stocks["Chocolate sundae"] -= 380 elif (item.get_name() == "Small strawberry sundae"): stocks["Strawberry sundae"] -= 200 elif (item.get_name() == "Medium strawberry sundae"): stocks["Strawberry sundae"] -= 300 elif (item.get_name() == "Large strawberry sundae"): stocks["Strawberry sundae"] -= 380 else: stocks[item.get_name()] -= 1 for item in stocks: if (stocks[item] < 0): errors.append( 'Amount of ' + item + ' selected exceeds existing stock amount. Please create a new order' ) if (len(errors) != 0): return False, stocks, errors else: return True, stocks, errors def confirm_order(self, my_order): valid_order, stock_copy, errors = self.check_stocks( my_order, self._stock.get_stock().copy()) if valid_order == False: raise OrderError(errors) if (len(my_order.get_order_list()) == 0): raise OrderError("Your order has no items.") my_order.set_confirmed(True) #self._orders.append(my_order) self._stock.set_stock(stock_copy) return True, my_order.get_ID() def add_to_order(self, item, ID): order = self.get_order(ID) order.add_item(item) def get_main_list(self): burger = SingleBurger() ingredients = [] for ingredient in burger.get_ingredient_prices(): ingredients.append(ingredient) return ingredients def get_sidelist(self): eg_side = Side("Small fries") sidelist = [] for key, value in eg_side._side_prices.items(): sidelist.append(key) return sidelist def get_drinklist(self): eg_drink = Drink("Coke can") drinklist = [] for key, value in eg_drink._drink_prices.items(): drinklist.append(key) return drinklist
rdf = None if df is not None: return df.tail(1) else: pass return rdf def simu_callback(future): pass if __name__ == '__main__': stock = Stock() init_amount = 100000 worker_cnt = 2 max_add_cnt = 4 stop_price_factor = 4 if len(sys.argv) >= 2: worker_cnt = int(sys.argv[1]) if len(sys.argv) >= 3: max_add_cnt = int(sys.argv[2]) if len(sys.argv) >= 4: stop_price_factor = int(sys.argv[2]) print("worker count = %s, max add count %s, stop_price_factor %s" % (worker_cnt, max_add_cnt, stop_price_factor)) df_concept_detail = stock.get_concept_detail() df = None with concurrent.futures.ProcessPoolExecutor(max_workers=worker_cnt) as executor: ft_map = {executor.submit(simulate, row['symbol']): row['symbol'] for i, row in stock.stock_df.iterrows()}
import sys from os.path import abspath, join, dirname sys.path.insert(0, join(abspath(dirname(__file__)), '..')) print(sys.path) from src.stock import Stock import pandas as pd sys.path.append("..") tsStock = Stock() keyword = '000001' df = tsStock.get_daily_data(keyword, '2019-01-02', '') print(df) # start_date = pd.to_datetime('20100101'); # print (start_date) # # print (start_date.strftime("%Y-%m-%d"))
def test_stock(self): # we will buy 10 stocks of apple on 2019-12-02 # we will sell 1 stock on 2019-12-03 # we will sell 9 stocks on 2019-12-09 # Open prices # 2019-12-02: 267.269989 # 2019-12-03: 258.309998 # 2019-12-09: 270.000000 test_stock = Stock('AAPL') self.assertEqual(test_stock.get_symbol(), 'AAPL') #get price test_price = test_stock.get_price('2019-12-02') self.assertAlmostEqual(test_price, 267.269989, places=2) # get price for a range test_price_df = test_stock.get_price_history(start_date='2019-12-01', end_date='2019-12-09') #market was open on 02,03,04,05,06,09:6 rows self.assertEqual(test_price_df.shape[0], 6) # buy 10 test_stock.buy(date='2019-12-02', num=10) self.assertAlmostEqual(test_stock.get_total_buy_cost(), 2672.69989, places=2) self.assertAlmostEqual(test_stock.get_total_sell_cost(), 0., places=2) # sell 1 test_stock.sell(date='2019-12-03', num=1) self.assertEqual(test_stock.is_held(), True) self.assertAlmostEqual(test_stock.get_total_buy_cost(), 2672.69989, places=2) self.assertAlmostEqual(test_stock.get_total_sell_cost(), 258.309998, places=2) # 258.309998 * 9 self.assertAlmostEqual(test_stock.get_valuation('2019-12-03'), 2324.7899820000002, places=2) # sell the remaining one and check not held test_stock.sell(date='2019-12-09', num=9) self.assertEqual(test_stock.is_held(), False) self.assertAlmostEqual(test_stock.get_total_buy_cost(), 2672.69989, places=2) # 258.309998 * 1 + 270.000000 * 9 self.assertAlmostEqual(test_stock.get_total_sell_cost(), 2688.309998, places=2) self.assertAlmostEqual(test_stock.get_valuation('2019-12-09'), 0., places=2)
def test_negative_price_should_throw_ValueError(self): goog = Stock("GooG") with self.assertRaises(ValueError): goog.update(datetime(2014, 2, 3), -1)
def test_price_should_be_null(self): stock = Stock("GooG") self.assertIsNone(stock.price)
def test_linreg_factor(self): test_stock = Stock('AAPL') linreg = LinRegFactor(num_days=30) beta = linreg(stock=test_stock, end_date='2019-11-15')