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')
def test_stock_update(self):
goog = Stock("GooG")
goog.update(datetime(2014, 2, 12), 10)
self.assertEqual(10, goog.price)
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_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')
