Esempio n. 1
0
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
        },
    )
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            "longs": rsi.top(3),
            "shorts": rsi.bottom(3),
        },
    )
Esempio n. 3
0
def make_pipeline():
    rsi = RSI()
    fd = Fundamentals()
    sectors = NASDAQSectorCodes()

    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
            'ROE': fd.ROE_ART,
            #  'CAPEX': fd.CAPEX_MRQ,
            'sector': sectors,
        }, )
Esempio n. 4
0
def make_pipeline():
    """Sets up the pipeline"""
    dollar_volume = AverageDollarVolume(window_length=20)
    adv1000 = dollar_volume.top(1000)
    fd = Fundamentals(mask=adv1000)
    market_cap = fd.cshoq * fd.prccq  # this is how to calculate market cap with Computstat fields
    book_equity = fd.seqq - fd.PS  # this is a quick way to calculate book_equity
    book_to_price = book_equity / market_cap
    biggest = market_cap.top(500, mask=adv1000)
    smallest = market_cap.bottom(500, mask=adv1000)

    highpb = book_to_price.top(500, mask=adv1000)
    lowpb = book_to_price.bottom(500, mask=adv1000)

    momentum = Momentum(mask=adv1000)  # momentum
    high_momentum = momentum.top(500, mask=adv1000)
    low_momentum = momentum.bottom(500, mask=adv1000)

    volatility = Volatility(mask=adv1000)
    highvol = volatility.top(500, mask=adv1000)
    lowvol = volatility.bottom(500, mask=adv1000)

    streversal = RSI(window_length=14, mask=adv1000)
    high_streversal = streversal.top(500, mask=adv1000)
    low_streversal = streversal.bottom(500, mask=adv1000)

    universe = biggest | smallest | highpb | lowpb | low_momentum | high_momentum

    return Pipeline(
        columns={
            'returns': Returns(window_length=2),
            # 'market_cap': market_cap,  # not needed
            # 'book_to_price': book_to_price,  # not needed
            'biggest': biggest,
            'smallest': smallest,
            'highpb': highpb,
            'lowpb': lowpb,
            # 'momentum': momentum,  # not needed
            'low_momentum': low_momentum,
            'high_momentum': high_momentum,
            # 'volatility': volatility, # not needed
            'highvol': highvol,
            'lowvol': lowvol,
            # 'streversal': streversal,  # not needed
            'high_streversal': high_streversal,
            'low_streversal': low_streversal
        },
        screen=universe)
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
            'revenue': Fundamentals(field='revenue_art'),
        },
        # no screen: 1 mo -> ca. 4 minutes;
        #            1 yr -> 20m

        # base_universe: ca. 1 mo. -> 3 minutes
        #screen = base_universe()

        # tradable_stocks(): 1 mo. -> ca 1h
        # 1yr -< 1h 40m
        #screen = TradableStocksUS()

        # NamedUniverse('tradable_stocks_us'): 1yr 7m
        screen=NamedUniverse('tradable_stocks_us'))
Esempio n. 6
0
def make_pipeline(underly_sid, shortable_sid):#,DAY_HACK_ENABLED=True,BB_WIN_LEN=126,WIN_LEN=20):
    sid = SidFactor() 
    pipeline_underly_sid = sid.eq(underly_sid[0])
    print("jzzz:", type(pipeline_underly_sid))
    print("MNAME:", MNAME)
    for i in underly_sid:
        pipeline_underly_sid = pipeline_underly_sid | sid.eq(i)
        print('jzzz:', pipeline_underly_sid)
    pipeline_shortable_sid = sid.eq(shortable_sid[0])
    for i in shortable_sid:
        pipeline_shortable_sid  = pipeline_shortable_sid  | sid.eq(i)
    #Filter for our choice of assets.
    bbands = BollingerBands(window_length=BB_WIN_LEN, k=sqrt(BB_WIN_LEN/5),mask = pipeline_underly_sid)
    lower, middle, upper = bbands
    #cud = Cud()#mask(pipeline underly_sid)
    returns_1D = Returns(window_length = 2, mask = pipeline_underly_sid)
    returns_6M = Returns(window_length = WIN_LEN, mask = pipeline_underly_sid)
    returns_6M = returns_6M if DAY_HACK_ENABLED else returns_6M - returns_1D
    returns_3M = Returns(window_length = 60, mask = pipeline_underly_sid)
    returns_3M = returns_3M if DAY_HACK_ENABLED else returns_3M - returns_1D
    returns_5M = Returns(window_length = WIN_LEN, mask = pipeline_underly_sid)#for es only
    returns_5M = returns_5M if DAY_HACK_ENABLED else returns_5M - returns_1D
    
    returns_1M = Returns(window_length = 20, mask = pipeline_underly_sid)#for es only
    returns_1M = returns_1M if DAY_HACK_ENABLED else returns_1M - returns_1D
    
    returns_5D = Returns(window_length =W_WIN_LEN,mask = pipeline_underly_sid)
    returns_5D = returns_5D if DAY_HACK_ENABLED else returns_5D - returns_1D
    returns_6D = Returns(window_length =7,mask = pipeline_underly_sid) - returns_1D
    annualizedVolatility_6M = AnnualizedVolatility(window_length = WIN_LEN,mask = pipeline_underly_sid)
    annualizedVolatility_3M = AnnualizedVolatility(window_length = int(WIN_LEN/2), mask = pipeline_underly_sid)
    annualizedVolatility_1M = AnnualizedVolatility(window_length = int(WIN_LEN/6), mask = pipeline_underly_sid)
    #annualizedVolatility_6M = ComputeVol6M(mask = pipeline_underly_sid)
    #annualizedVolatility_3M = ComputeVol3M(mask = pipeline_underly_sid)
    #annualizedVolatility_1M = ComputeVol1M(mask = pipeline_underly_sid)
    annualizedVolatility = max(annualizedVolatility_6M, annualizedVolatility_3M,annualizedVolatility_1M)
    sharpes_6M = returns_6M/annualizedVolatility_6M
    raw_signals = None
    if SHARPE:
        raw_signals = sharpes_6M
    else:
        raw_signals = returns_6M
    signals = raw_signals if LONG_ONLY else (raw_signals*raw_signals)
    #positive_return = (returns_6M > 0)
    #trigger = (returns 5D > -trigger_level) if LONG_ONLY else ((returns_5D < trigger_level)

    sigtop = signals.top(NUM_TOP_POSITIONS)
    raw_sig_top = raw_signals.top(NUM_TOP_POSITIONS)
    raw_sig_bot = raw_signals.bottom(NUM_TOP_POSITIONS)

    alongs = sigtop & raw_sig_top & (raw_signals > 0) & (returns_5D > -TRIGGER_LEVEL) # & (cud >= 13)
    ashorts = sigtop & raw_sig_bot &(raw_signals <= 0 ) & (returns_5D < TRIGGER_LEVEL) & pipeline_shortable_sid
    #alongs = (annualizedVolatility_6M> 0) #shorts# signals.top(NUN TOP POSITIONS)

    if not PIPE_ENABLED:
        alongs = (annualizedVolatility_6M > 0)
        ashorts = (annualizedVolatility_6M < 0)# if LONG ONLY else longs
    long_short_screen = alongs if LONG_ONLY else (alongs | ashorts)

    my_screen = (annualizedVolatility_6M > 0) if MNAME in ['es','bd','dm','ed','md']  else long_short_screen 
    #my_screen = long_short_screen if False else (annualizedVolatility_6M > 0)#hlw
    print('finger1',MNAME)
    rsi = RSI(window_length=10,mask = pipeline_underly_sid)
    print('rsipipe',annualizedVolatility_6M)
    print('fxxxDAY_HACK_ENABLED',DAY_HACK_ENABLED)
    #Only compute volatilities for assets that satisfy the requirements of our rolling strategy.
    return Pipeline(
        columns= {
            #'cud' : cud,
            'volatility' : annualizedVolatility,
            'sharpes_6W' : sharpes_6M,
            'drets': returns_1D,
            'wrets': returns_5D,
            'returns_6D': returns_6D,
            'returns_1M': returns_1M,
            'returns_3M': returns_3M,
            'returns_5M': returns_5M,
            'returns_6M': returns_6M,
            #'signals': (signals)*signals,
           'shorts' : ashorts,
            #'wrets' : returns_5D,
            'lower' : lower,
            'middle' :middle,
            'upper' :upper,
            #'rsi':rsi.top(3),
            'rsi_longs': rsi.top(3),
            'rsi_shorts': rsi.bottom(3),
            #'annualizedVolatility :annualizedVolatility_6M,
        },
        screen = my_screen
    )