def read(file_list, stock_list):
for path in file_list:
name, ret = STOCK_TIMESERIES.load(path)
if name not in stock_list:
del ret
continue
yield name, ret
def prep(*file_list):
file_list = sorted(file_list)
spy_list = filter(lambda path: 'SPY' in path, file_list)
control = spy_list[0]
file_list = filter(lambda path: control != path, file_list)
label, data = STOCK_TIMESERIES.load(control)
print label
quarter = Partition.by_quarter(data)
return label, data, quarter, file_list
def action(stock_list):
target = 'file_list'
file_list = globals().get(target, [])
for path in file_list:
name, ret = STOCK_TIMESERIES.load(path)
if name not in stock_list:
del ret
continue
yield name, ret
def load(cls, data_store, ticker):
filename = '{}/{}.pkl'.format(data_store, ticker)
name, data = STOCK_TIMESERIES.load(filename)
if ticker == name:
return data
msg = '{} {}'.format(ticker, name)
msg = 'ticker does not match between filename and file content {}'.format(
msg)
raise ValueError(msg)
def loadData(*file_list):
file_list = sorted(file_list)
spy = filter(lambda stock: 'SPY' in stock, file_list)
spy_filename = spy[0]
spy_name, spy_data = STOCK_TIMESERIES.load(spy_filename)
spy_quarterly = StockTransform.by_quarter(spy_data)
key_list = spy_quarterly.keys()
file_list = filter(lambda path: spy_filename not in path, file_list)
for file_path in file_list:
name, data = STOCK_TIMESERIES.load(file_path)
quarterly = StockTransform.by_quarter(data)
for key in key_list:
if key not in quarterly: continue
if len(quarterly[key]) == 0: continue
yield key, name, data, quarterly[
key], spy_name, spy_data, spy_quarterly[key]
def prices(cls, ticker) :
data_store = cls.instance().file_list
suffix = '/{}.pkl'.format(ticker)
filename = filter(lambda x : x.endswith(suffix), data_store)
filename = list(filename)
if len(filename) > 0 :
filename = filename[0]
logging.info((filename,ticker))
name, ret = STOCK_TIMESERIES.load(filename)
ret = ret[cls._prices]
#ret = ret.reset_index(drop=False)
#ret.sort_index(inplace=True)
return ret
def prep():
target = 'file_list'
file_list = globals().get(target, [])
file_list = sorted(file_list)
spy_list = filter(lambda path: 'SPY' in path, file_list)
if not isinstance(spy_list, list):
spy_list = list(spy_list)
control = spy_list[0]
file_list = filter(lambda path: control != path, file_list)
if not isinstance(file_list, list):
file_list = list(file_list)
label, data = STOCK_TIMESERIES.load(control)
return label, data, file_list
def load(cls, data_store, ticker):
filename = '{}/{}.pkl'.format(data_store, ticker)
#if not os.path.exists(filename) :
# data = cls.read(ticker)
# STOCK_TIMESERIES.save(filename, ticker, data)
# return data
name, data = STOCK_TIMESERIES.load(filename)
if ticker == name:
return data
msg = '{} {}'.format(ticker, name)
msg = 'ticker does not match between filename and file content {}'.format(
msg)
raise ValueError(msg)
def load(self, *ticker_list):
filename_list = map(lambda ticker : '/{}.pkl'.format(ticker), ticker_list)
filename_list = list(filename_list)
logging.info((ticker_list,filename_list))
ret = {}
for i, suffix in enumerate(filename_list) :
filename = filter(lambda x : x.endswith(suffix), self.price_list)
filename = list(filename)
if len(filename) == 0 :
continue
filename = filename[0]
name, temp = STOCK_TIMESERIES.load(filename)
key = ticker_list[i]
ret[key] = temp[self.price_column]
return ret
def main(control_by_quarter, *file_list):
stable = {}
stable_key_list = [
'label', 'mean_volume', 'mean_vol_ratio', 'std_volume', 'std_vol_ratio'
]
performers = {}
performers_key_list = [
'label', 'mean_adj_close', 'mean_close_ratio', 'dev_adj_close',
'std_close_ratio'
]
ini_stable = {}
ini_performance = {}
for test in file_list:
test_label, test = STOCK_TIMESERIES.load(test)
if len(test) < 100:
del test
continue
test = Partition.by_quarter(test)
for q in sorted(test.keys()):
test_vol = test[q]['Volume']
control_vol = control_by_quarter[q]['Volume']
comp_mean = round(test_vol.mean() / control_vol.mean(), 2)
comp_std = round(test_vol.std() / control_vol.std(), 2)
if comp_std > 1.5:
continue
if test_label not in stable.keys(): stable[test_label] = {}
label = '{} vs {}'.format(control_label, test_label)
value_list = [
label,
round(test_vol.mean(), 2), comp_mean,
round(test_vol.std(), 2), comp_std
]
stable[test_label][q] = dict(zip(stable_key_list, value_list))
test_close = test[q]['Adj Close']
control_close = control_by_quarter[q]['Adj Close']
comp_mean = round(test_close.mean() / control_close.mean(), 2)
comp_std = round(test_close.std() / control_close.std(), 2)
if comp_mean < 1:
continue
label = '{} vs {}'.format(control_label, test_label)
value_list = [
label,
round(test_close.mean(), 2), comp_mean,
round(test_close.std(), 2), comp_std
]
if test_label not in performers.keys(): performers[test_label] = {}
performers[test_label][q] = dict(
zip(performers_key_list, value_list))
if test_label in stable.keys():
key_list = sorted(stable[test_label].keys())
key_list = map(lambda x: str(x), key_list)
key_list = "".join(key_list)
key = 'Q{}'.format(key_list)
if key not in ini_stable:
ini_stable[key] = []
print "Safe ", test_label, key, stable[test_label]
ini_stable[key].append(test_label)
if test_label in performers.keys():
key_list = sorted(performers[test_label].keys())
key_list = map(lambda x: str(x), key_list)
key_list = "".join(key_list)
key = 'Q{}'.format(key_list)
if key not in ini_performance:
ini_performance[key] = []
print "Good ", test_label, key, performers[test_label]
ini_performance[key].append(test_label)
del test
return ini_stable, ini_performance
def prep(*file_list):
file_list = sorted(file_list)
spy_list = filter(lambda x: 'SPY' in x, file_list)
spy = spy_list[0]
name, data = STOCK_TIMESERIES.load(spy)
return name, data