def initialize(context):
pipe = Pipeline()
attach_pipeline(pipe, 'example')
# Note that we don't call add_factor on these Factors.
# We don't need to store intermediate values if we're not going to use them
sma_short = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=30)
sma_long = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=100)
sma_val = sma_short/sma_long
# Construct the custom factor
mkt_cap = MarketCap()
# Create and apply a filter representing the top 500 equities by MarketCap
# every day.
mkt_cap_top_500 = mkt_cap.top(500)
remove_penny_stocks = sma_short > 1.0
pipe.add(sma_val, 'sma_val')
pipe.add(mkt_cap, 'mkt_cap')
# Use mkt_cap_top_500 as a mask on rank
pipe.add(sma_val.rank(mask=mkt_cap_top_500), 'sma_rank')
# Use multiple screens to narrow the universe
pipe.set_screen(mkt_cap.top(500) & remove_penny_stocks)
def make_pipeline(context):
screen = StaticAssets(context.universe)
momentum_factor = MomentumFactor()
pipe = Pipeline(columns={
'momentum_score': momentum_factor,
})
pipe.set_screen(screen)
return pipe
def initialize(context):
# Create, register and name a pipeline in initialize.
pipe = Pipeline()
attach_pipeline(pipe, 'example')
# Construct a simple moving average factor and add it to the pipeline.
sma_short = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=10)
pipe.add(sma_short, 'sma_short')
# Set a screen on the pipelines to filter out securities.
pipe.set_screen(sma_short > 1.0)
def create_high_dollar_volume_pipeline():
pipe = Pipeline()
dollar_volume = AverageDollarVolume(
window_length=63) # 63 days = 1 quarter
pipe.add(dollar_volume, 'dollar_volume')
high_dollar_volume = dollar_volume.percentile_between(
95, 100) # top 5% by dollar volume
pipe.set_screen(high_dollar_volume)
return pipe
def initialize(context):
pipeline = Pipeline()
context.vwaps = []
for length in vwaps:
name = vwap_key(length)
factor = VWAP(window_length=length)
context.vwaps.append(factor)
pipeline.add(factor, name=name)
filter_ = USEquityPricing.close.latest > 300
pipeline.add(filter_, "filter")
if set_screen:
pipeline.set_screen(filter_)
attach_pipeline(pipeline, "test")
def initialize(context):
pipeline = Pipeline()
context.vwaps = []
for length in vwaps:
name = vwap_key(length)
factor = VWAP(window_length=length)
context.vwaps.append(factor)
pipeline.add(factor, name=name)
filter_ = (USEquityPricing.close.latest > 300)
pipeline.add(filter_, 'filter')
if set_screen:
pipeline.set_screen(filter_)
attach_pipeline(pipeline, 'test')
def get_moving_average(self,
start_date,
end_date,
assets=None,
window_length=63):
moving_average = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=window_length)
pipeline = Pipeline(columns={'moving_average': moving_average})
if assets is not None:
pipeline.set_screen(StaticAssets(assets))
df = self._run_pipeline(pipeline, start_date, end_date)
return df
def make_strategy_pipeline(context):
pipe = Pipeline()
# get the strategy parameters
lookback = context.params['lookback'] * 21
v = context.params['min_volume']
# Set the volume filter
volume_filter = average_volume_filter(lookback, v)
# compute past returns
momentum = period_returns(lookback)
pipe.add(momentum, 'momentum')
pipe.set_screen(volume_filter)
return pipe
def make_strategy_pipeline(context):
pipe = Pipeline()
# get the strategy parameters
lookback = context.params['lookback']*21
v = context.params['min_volume']
# Set the volume filter
volume_filter = average_volume_filter(lookback, v)
# compute past returns
rsi_factor = technical_factor(lookback, rsi, 14)
pipe.add(rsi_factor,'rsi')
pipe.set_screen(volume_filter)
return pipe
def make_strategy_pipeline(context):
pipe = Pipeline()
# get the strategy parameters
lookback = context.params['lookback'] * 21
v = context.params['min_volume']
# Set the volume filter
volume_filter = average_volume_filter(lookback, v)
# compute past returns
vol_factor = technical_factor(lookback, volatility, 1)
skew_factor = technical_factor(lookback, skewness, None)
pipe.add(vol_factor, 'vol')
pipe.add(skew_factor, 'skew')
pipe.set_screen(volume_filter)
return pipe
def make_strategy_pipeline(context):
pipe = Pipeline()
# Set the volume filter, 126 days is roughly 6 month daily data
volume_filter = average_volume_filter(126, 1E7)
# compute past returns
rsi_factor = technical_factor(126, rsi, 14)
ema20_factor = technical_factor(126, ema, 20)
ema50_factor = technical_factor(126, ema, 50)
# add to pipelines
pipe.add(rsi_factor,'rsi')
pipe.add(ema20_factor,'ema20')
pipe.add(ema50_factor,'ema50')
pipe.set_screen(volume_filter)
return pipe
def make_pipeline():
filter1 = CNEquityPricing.volume.latest > 4000
# filter2 = CNEquityPricing.high.latest < CNEquityPricing.up_limit.latest/1000
# filter3 = CNEquityPricing.high.latest > CNEquityPricing.down_limit.latest/1000
market_cap = CNEquityPricing.close.latest * CNFinancialData.total_share_0QE.latest
universe = filter1 & market_cap.notnull()
maket_cap_1 = market_cap.deciles(mask=universe).eq(0)
market_cap_top5 = market_cap.bottom(5, mask=maket_cap_1)
# market_cap_1_top = market_cap.top(5, mask=maket_cap_1)
pipe = Pipeline()
pipe.add(market_cap, 'market_cap')
pipe.set_screen(market_cap_top5)
return pipe
def initialize(context):
pipe = Pipeline()
attach_pipeline(pipe, "example")
sma_short = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=30)
sma_long = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=100)
# Combined factors to create new factors
sma_val = sma_short / sma_long
# Create and apply a screen to remove penny stocks
remove_penny_stocks = sma_short > 1.0
pipe.set_screen(remove_penny_stocks)
pipe.add(sma_short, "sma_short")
pipe.add(sma_long, "sma_long")
pipe.add(sma_val, "sma_val")
# Rank a factor using a mask to ignore the values we're
# filtering out by passing mask=remove_penny_stocks to rank.
pipe.add(sma_val.rank(mask=remove_penny_stocks), "sma_rank")
def get_returns(self, start_date, end_date, assets=None):
open_return = Returns(window_length=2, inputs=[USEquityPricing.open])
close_return = Returns(window_length=2, inputs=[USEquityPricing.close])
inter_day_return = InterDayReturns()
intra_day_return = IntraDayReturns()
pipeline = Pipeline(
columns={
'open_return': open_return,
'close_return': close_return,
'inter_day_return': inter_day_return,
'intra_day_return': intra_day_return
})
if assets is not None:
pipeline.set_screen(StaticAssets(assets))
df = self._run_pipeline(pipeline, start_date, end_date)
df['open_return'] = df.groupby(
df.index.get_level_values('asset'))['open_return'].shift(-1)
df.dropna(inplace=True)
return df
def factor_pipe(context):
'''
function to set up a pipeline to retrieve all active syms.
We can add filters here as well.
'''
pipe = Pipeline()
sma_20 = SimpleMovingAverage(inputs=[EquityPricing.close],
window_length=20)
# Pick the top 50% of stocks ranked by dollar volume
dollar_volume = AvgDailyDollarVolumeTraded(window_length=252)
high_dollar_volume = dollar_volume.percentile_between(50, 100)
# Remove penny stocks
no_penny_stocks = sma_20 > 1
filtered_assets = high_dollar_volume & no_penny_stocks
pipe.set_screen(filtered_assets)
pipe.add(sma_20, 'sma_20')
for m in context.agent.models:
pipe.add(m.factor(inputs=[EquityPricing.close], window_length=252),
m.name)
return pipe
def initialize(context):
ws.send(msg_placeholder % "Simulation Start")
pipe = Pipeline()
attach_pipeline(pipe, "volume_pipeline")
# 100 day average dollar volume factor
dollar_volume = AverageDollarVolume(window_length=100)
pipe.add(dollar_volume, "100_day_dollar_volume")
# filter out only the top stocks by dollar volume
high_dollar_volume = dollar_volume.percentile_between(99, 100)
pipe.set_screen(high_dollar_volume)
# set the global variables
context.dev_multiplier = 2
context.max_notional = 1000000
context.min_notional = -1000000
context.days_traded = 0
ws.send(msg_placeholder % "Pipeline filter attached")
schedule_function(func=choose_and_order,
date_rule=date_rules.every_day())
def test_set_screen(self):
f, g = SomeFilter(), SomeOtherFilter()
p = Pipeline()
self.assertEqual(p.screen, None)
p.set_screen(f)
self.assertEqual(p.screen, f)
with self.assertRaises(ValueError):
p.set_screen(f)
p.set_screen(g, overwrite=True)
self.assertEqual(p.screen, g)
with self.assertRaises(TypeError) as e:
p.set_screen(f, g)
message = e.exception.args[0]
self.assertIn("expected a value of type bool or int for argument 'overwrite'", message)
def test_set_screen(self):
f, g = SomeFilter(), SomeOtherFilter()
p = Pipeline()
assert p.screen is None
p.set_screen(f)
assert p.screen == f
with pytest.raises(ValueError):
p.set_screen(f)
p.set_screen(g, overwrite=True)
assert p.screen == g
with pytest.raises(
TypeError,
match="expected a value of type bool or int for argument 'overwrite'",
):
p.set_screen(f, g)
def test_set_screen(self):
f, g = SomeFilter(), SomeOtherFilter()
p = Pipeline()
self.assertEqual(p.screen, None)
p.set_screen(f)
self.assertEqual(p.screen, f)
with self.assertRaises(ValueError):
p.set_screen(f)
p.set_screen(g, overwrite=True)
self.assertEqual(p.screen, g)
def test_set_screen(self):
f, g = SomeFilter(), SomeOtherFilter()
p = Pipeline()
self.assertEqual(p.screen, None)
p.set_screen(f)
self.assertEqual(p.screen, f)
with self.assertRaises(ValueError):
p.set_screen(f)
p.set_screen(g, overwrite=True)
self.assertEqual(p.screen, g)
def test_set_screen(self):
f, g = SomeFilter(), SomeOtherFilter()
p = Pipeline()
self.assertEqual(p.screen, None)
p.set_screen(f)
self.assertEqual(p.screen, f)
with self.assertRaises(ValueError):
p.set_screen(f)
p.set_screen(g, overwrite=True)
self.assertEqual(p.screen, g)
with self.assertRaises(TypeError) as e:
p.set_screen(f, g)
message = e.exception.args[0]
self.assertIn(
"expected a value of type bool or int for argument 'overwrite'",
message,
)
from zipline_extensions_cn.pipeline.data import CNFinancialData, CNEquityPricing
filter1 = CNEquityPricing.volume.latest > 4000
# filter2 = CNEquityPricing.high.latest < CNEquityPricing.up_limit.latest/1000
# filter3 = CNEquityPricing.high.latest > CNEquityPricing.down_limit.latest/1000
universe = filter1
# market_cap = CNEquityPricing.close.latest * CNFinancialData.total_share_0QE.latest
# market_cap_deciles = market_cap.deciles(mask=market_cap.notnull())
close = CNEquityPricing.close.latest
ipo_date_test = CNFinancialData.ipo_date_test.latest
industry_id = CNFinancialData.industry_id.latest
# market_cap_1_top = market_cap.top(5, mask=maket_cap_1)
pipe = Pipeline()
pipe.add(close, 'close')
pipe.add(industry_id, "industry_id")
pipe.add(ipo_date_test, 'ipo_date_test')
pipe.set_screen(universe)
start_date = '2019-03-06'
end_date = '2019-4-8'
from zipline_extensions_cn.research import *
results = run_pipeline(pipe, start_date, end_date)
print(results.head(10))
p = get_pricing('000001.SZ', '2019-01-31', '2020-02-04', 'up_limit')
