def make_pipeline(context):
base_universe = QTradableStocksUS()
#Create Price Filter
latest_close = USEquityPricing.close.latest
penny_stock = latest_close < 5
# Create Momentum Filter
SMA200 = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=200)
SMA20 = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=20)
momentum_filter = SMA20 > SMA200
momentum_and_price = momentum_filter & penny_stock
#Create Volatility Filter
volatility = AnnualizedVolatility(inputs=[USEquityPricing.close],
window_length=30,
mask=base_universe)
high_volatility = volatility.top(1, mask=momentum_and_price)
# Combine into final filter
final_filter = penny_stock & momentum_filter & high_volatility
return Pipeline(columns={
'SMA200': SMA200,
'SMA20': SMA20,
'Last Close': latest_close,
'Annualized Volatility': volatility,
'final filter': final_filter
},
screen=final_filter)
class Volatility(CustomFactor):
inputs = [AnnualizedVolatility()]
window_length = 1
def compute(self, today, assets, out, AnnualizedVolatility):
out[:] = ((AnnualizedVolatility))
def make_pipeline():
# Using average dollar volume as the factor measuring liqiudity
return Pipeline(
columns={
'market_cap': MarketCap(),
'volatility': AnnualizedVolatility(window_length=21),
'dollar_volume': AverageDollarVolume(window_length=21)
})
def initialize(context):
#sell criteria the morning of -_-
schedule_function(sellaII, date_rules.every_day(),
time_rules.market_open(minutes=1))
#cancel all open orders before buy criteria
schedule_function(sellaIII, date_rules.every_day(),
time_rules.market_close(minutes=8))
#sell all (4 mins before sell all positions)
schedule_function(selaV, date_rules.every_day(),
time_rules.market_close(minutes=7))
for i in range(30, 380):
schedule_function(sell_criteria, date_rules.every_day(),
time_rules.market_open(minutes=i))
#pipeine initialization (2 mins before buy criteria)
schedule_function(be4tradestart, date_rules.every_day(),
time_rules.market_close(minutes=6))
#buy criteria (3 mins before sell criteria day of)
schedule_function(examplee, date_rules.every_day(),
time_rules.market_close(minutes=5))
schedule_function(mmarket, date_rules.every_day(),
time_rules.market_close(minutes=1))
set_commission(commission.PerTrade(cost=0))
set_commission(commission.PerShare(cost=0, min_trade_cost=0))
set_slippage(slippage.VolumeShareSlippage(volume_limit=1, price_impact=0))
avg_volume = AverageDollarVolume(window_length=10)
sma_2 = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=2)
sma_200 = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=200)
avg_volumee = AverageDollarVolume(window_length=2)
volatilityy = AnnualizedVolatility(annualization_factor=252)
pipe_screen = ((avg_volume >= 15000000) & (sma_2 >= sma_200) &
(avg_volumee >= 3000000) & (sma_2 >= 5.0) &
(volatilityy <= 0.93))
pipe_columns = {
'avg voI': avg_volume,
'sma2': sma_2,
'sma200': sma_200,
'avg voII': avg_volumee,
'volatility': volatilityy
}
pipe = Pipeline(columns=pipe_columns, screen=pipe_screen)
attach_pipeline(pipe, 'example')
set_long_only()
def make_pipeline():
# Base universe set to the Q500US
universe = Q500US()
roe = Fundamentals.roe.latest
new_returns = Returns(window_length=5, mask=universe)
new_returns = new_returns.zscore()
returns_range = new_returns.percentile_between(1, 30)
new_volatility = AnnualizedVolatility(mask=universe)
new_volatility = new_volatility.zscore()
volatility_range = new_volatility.percentile_between(1, 30)
pipe = Pipeline(columns={
'roe': roe,
'returns': returns_range,
'volatility': volatility_range
},
screen=universe)
return pipe
def make_pipeline():
"""
A function to create our dynamic stock selector (pipeline). Documentation on
pipeline can be found here: https://www.quantopian.com/help#pipeline-title
"""
# Base universe set to the Q1500US
# base_universe = Q1500US()
# Factor of yesterday's close price.
# yesterday_close = USEquityPricing.close.latest
pipe = Pipeline()
pipe = attach_pipeline(pipe, name='beta_metrics')
pipe.add(Beta(), "beta")
# Add other filters
factor1 = AverageDollarVolume(window_length=20)
pipe.add(factor1, 'Avg_dollar_Volume')
market_cap1 = market_cap()
pipe.add(market_cap1, 'market_cap1')
mom5 = momentum_5()
pipe.add(mom5, 'mom_5')
annual_vol = AnnualizedVolatility()
pipe.add(annual_vol, 'annual_vol')
sma3 = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=3)
pipe.add(sma3, 'sma3')
sma5 = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=5)
pipe.add(sma5, 'sma5')
sma20 = SimpleMovingAverage(inputs=[USEquityPricing.close],
window_length=20)
pipe.add(sma20, 'sma20')
# Set pipeline screen
factor1_filter = factor1 > 10**7
market_cap_top = market_cap1 < 10 * 10**9
market_cap_bottom = market_cap1 > 2 * 10**9
# annual_vol_filter = annual_vol < 0.2
# sma_filter = (sma3 > sma5) & (sma5 > sma20)
# mom5_filter = mom5 > 1
total_filter = (factor1_filter & market_cap_bottom & market_cap_top
) # & annual_vol_filter) #and mom5_filter
pipe.set_screen(total_filter)
return pipe
min_percentile=0.05, max_percentile=0.95, mask=universe_top500
).zscore()
ey = Fundamentals.oper_inc_bef_dep_ltm.latest / mcap
ey = ey.winsorize(
min_percentile=0.05, max_percentile=0.95, mask=universe_top500
).zscore()
# Momentum
# --------
lt_momentum = lt_mom(mask=universe_top500).zscore()
# Volatility
# ----------
ann_vol = AnnualizedVolatility(
inputs=[Returns(window_length=2)], window_length=66, mask=universe_top500
).zscore()
# Quality
# -------
gpa = Fundamentals.gross_inc_ltm.latest / Fundamentals.assets.latest
gpa = gpa.zscore(mask=universe_top500)
factors = {
"fcfy": fcfy,
"ey": ey,
"log_mcap": log_mcap,
"lt_mom": lt_momentum,
"ann_vol": ann_vol,
"gpa": gpa,
}
def make_pipeline(context):
## symbol universe
base_universe = Q500US() if False else Q1500US()
## filters
# Filter for primary share equities. IsPrimaryShare is a built-in filter.
primary_share = IsPrimaryShare()
# Equities listed as common stock (as opposed to, say, preferred stock).
# 'ST00000001' indicates common stock.
common_stock = morningstar.share_class_reference.security_type.latest.eq('ST00000001')
# Non-depositary receipts. Recall that the ~ operator inverts filters,
# turning Trues into Falses and vice versa
not_depositary = ~morningstar.share_class_reference.is_depositary_receipt.latest
# Equities not trading over-the-counter.
not_otc = ~morningstar.share_class_reference.exchange_id.latest.startswith('OTC')
# Not when-issued equities.
not_wi = ~morningstar.share_class_reference.symbol.latest.endswith('.WI')
# Equities without LP in their name, .matches does a match using a regular expression
not_lp_name = ~morningstar.company_reference.standard_name.latest.matches('.* L[. ]?P.?$')
# Equities with a null value in the limited_partnership Morningstar fundamental field.
not_lp_balance_sheet = morningstar.balance_sheet.limited_partnership.latest.isnull()
# Equities whose most recent Morningstar market cap is not null have fundamental data and therefore are not ETFs.
have_market_cap = morningstar.valuation.market_cap.latest.notnull()
is_cyclical = SuperSector().eq(SuperSector.CYCLICAL)
is_defensive = SuperSector().eq(SuperSector.DEFENSIVE)
is_sensitive = SuperSector().eq(SuperSector.SENSITIVE)
# Filter for stocks that pass all of our previous filters.
tradeable_stocks = (
primary_share
&common_stock
¬_depositary
¬_otc
¬_wi
¬_lp_name
¬_lp_balance_sheet
&have_market_cap
#&(is_cyclical)
#&(is_defensive)
#&(is_sensitive)
&(is_cyclical | is_defensive | is_sensitive)
)
# ToDo この範囲を色々変えてみる．
dollar_volume = AverageDollarVolume(window_length=30)
high_dollar_volume = dollar_volume.percentile_between(98, 100)
daily_volatility = AnnualizedVolatility(window_length=20)/math.sqrt(252)
sme20 = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=20)
rsi = RSI(inputs=[USEquityPricing.close])
#sector = ms.asset_classification.morningstar_sector_code
sector = Sector()
static_sectors = (sector.eq(311) |
sector.eq(309) |
sector.eq(103) |
sector.eq(101) |
sector.eq(308) |
sector.eq(206) )
if context.static_asset:
myscreen = StaticSids(context.special_sids) #context.special_assets
else:
myscreen = (base_universe & tradeable_stocks & high_dollar_volume ) # & static_sectors
pipe = Pipeline(
columns={
'prev_close': PrevClose(),
'prev_volume': PrevVolume(),
'prev_turnover': PrevClose()*PrevVolume(),
'dollar_volume': dollar_volume,
'high_dollar_volume': high_dollar_volume,
'daily_volatility': daily_volatility,
'sma20': sme20,
'rsi': rsi,
'morningstar_sector_code': sector,
},
screen=myscreen,
)
return pipe