from quantopian.pipeline import CustomFactor
from quantopian.pipeline import Pipeline
from quantopian.research import run_pipeline
from quantopian.pipeline.filters import QTradableStocksUS
from quantopian.pipeline.data.builtin import USEquityPricing
from quantopian.pipeline.factors import AverageDollarVolume, SimpleBeta, MarketCap
from quantopian.pipeline.data import morningstar
from quantopian.pipeline.data import Fundamentals
from sklearn import preprocessing
from quantopian.pipeline.classifiers.morningstar import Sector
from scipy import stats
import numpy as np
import pandas as pd

def preprocess(a):
    
    a = np.nan_to_num(a - np.nanmean(a))
    return preprocessing.scale(a)

def make_factors():
        
    class CGO(CustomFactor):    
        inputs = [USEquityPricing.close, USEquityPricing.volume, morningstar.valuation.shares_outstanding]
        window_length=1260
        
        def compute(self, today, assets, out, close, volume, share):
            mon = 60
            unit = 21
            df_price = close   
            df_hsl = volume/share 
            copy = 1 - df_hsl
            copy[-1,:] = 1.0
            copy = copy.prod(axis=0)/copy.cumprod(axis=0)*copy
            copy = copy * df_hsl
            k = copy.sum(axis=0)
            ref_pr = ((df_price*(copy)).sum(axis=0)/k)
            if unit > 1:
                df_price = df_price[::unit,]
            CGO = ((df_price[-1,:] - ref_pr)/df_price[-1,:])
            
            out[:] = preprocess(CGO)

            
    return {
            'CGO': CGO,
            }    

start = pd.Timestamp("2014-01-05")
end = pd.Timestamp("2019-03-30")
from quantopian.pipeline.filters import StaticAssets
        
def make_pipeline():
    pipe = Pipeline() 
    my_etfs = StaticAssets(symbols(['SPY']))
    beta = SimpleBeta(target=symbols(8554),regression_length=120,
                      allowed_missing_percentage=1.0
                     )
    
    universe = QTradableStocksUS() & Sector().notnull() & beta.notnull()#& ~StaticAssets([sid(8340), sid(34648), sid(32430)])
    
    dollar_volume = AverageDollarVolume(window_length=5, mask = universe)
    high_dollar_volume = dollar_volume.top(500)
    universe &= high_dollar_volume 
    mktcap = MarketCap(mask =universe)
    universe &= mktcap.bottom(200)
            
    factors = make_factors()    
    combined_alpha = None
    for name, f in factors.iteritems():        
        fac = f(mask=universe)
        if combined_alpha == None:
            combined_alpha = fac
        else:
            combined_alpha += fac

    pipe.add(combined_alpha, 'combined_alpha')        
    pipe.set_screen(universe & combined_alpha.notnull())
    return pipe

results = run_pipeline(pipeline=make_pipeline(), start_date=start, end_date=end)

# Show the first 5 rows of factor data
results.head(5)

assets = results.index.levels[1]
pricing = get_pricing(assets, start, end, fields='open_price' # Generally, you should use open pricing. Explained more in lesson 4
)

# Show the first 5 rows of pricing_data
pricing.head(5)

from alphalens.utils import get_clean_factor_and_forward_returns

merged_data = get_clean_factor_and_forward_returns(
  factor=results, 
  prices=pricing,  
)


# Show the first 5 rows of merged_data
merged_data.head(5)