# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from AlgorithmImports import *

### <summary>
### Example algorithm giving an introduction into using IDataConsolidators.
### This is an advanced QC concept and requires a certain level of comfort using C# and its event system.
###
### What is an IDataConsolidator?
### IDataConsolidator is a plugin point that can be used to transform your data more easily.
### In this example we show one of the simplest consolidators, the TradeBarConsolidator.
### This type is capable of taking a timespan to indicate how long each bar should be, or an
### integer to indicate how many bars should be aggregated into one.
###
### When a new 'consolidated' piece of data is produced by the IDataConsolidator, an event is fired
### with the argument of the new data.
### </summary>
### <meta name="tag" content="using data" />
### <meta name="tag" content="consolidating data" />
class DataConsolidationAlgorithm(QCAlgorithm):

    def initialize(self):
        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

        self.set_start_date(DateTime(2024, 10, 7, 9, 30, 0))  #Set Start Date
        self.set_end_date(self.start_date + timedelta(2))          #Set End Date
        # Find more symbols here: http://quantconnect.com/data
        spy = self.add_equity("SPY", Resolution.MINUTE).symbol
        eur = self.add_forex("EURUSD", Resolution.MINUTE).symbol
        self.gold = self.add_future(Futures.Metals.GOLD, \
                        resolution = Resolution.MINUTE, \
                        fill_forward=True, \
                        extended_market_hours = True, \
                        data_normalization_mode = DataNormalizationMode.FORWARD_PANAMA_CANAL, \
                        data_mapping_mode = DataMappingMode.LAST_TRADING_DAY, \
                        contract_depth_offset = 0).symbol
        spy_df = self.history(spy, 50)
        gold_df = self.history( self.gold, 50)
        spy_tradebardf = self.history(TradeBar, spy, 50)
        gold_tradebardf = self.history(TradeBar, self.gold, 50)
        
        '''goldconsolidator = self.Consolidate(Futures.Metals.GOLD, timedelta(minutes=30), self.gold_consolidation_handler)
        self.subscription_manager.add_consolidator(value, goldconsolidator)
        # define our 30 minute trade bar consolidator. we can
        # access the 30 minute bar from the DataConsolidated events
        thirty_minute_consolidator = TradeBarConsolidator(timedelta(minutes=30))

        # attach our event handler. the event handler is a function that will
        # be called each time we produce a new consolidated piece of data.
        thirty_minute_consolidator.data_consolidated += self.thirty_minute_bar_handler

        # this call adds our 30 minute consolidator to
        # the manager to receive updates from the engine
        self.subscription_manager.add_consolidator("SPY", thirty_minute_consolidator)

        # here we'll define a slightly more complex consolidator. what we're trying to produce is
        # a 3 day bar. Now we could just use a single TradeBarConsolidator like above and pass in
        # TimeSpan.from_days(3), but in reality that's not what we want. For time spans of longer than
        # a day we'll get incorrect results around weekends and such. What we really want are tradeable
        # days. So we'll create a daily consolidator, and then wrap it with a 3 count consolidator.

        # first define a one day trade bar -- this produces a consolidated piece of data after a day has passed
        one_day_consolidator = TradeBarConsolidator(timedelta(1))

        # next define our 3 count trade bar -- this produces a consolidated piece of data after it sees 3 pieces of data
        three_count_consolidator = TradeBarConsolidator(3)

        # here we combine them to make a new, 3 day trade bar. The SequentialConsolidator allows composition of
        # consolidators. It takes the consolidated output of one consolidator (in this case, the one_day_consolidator)
        # and pipes it through to the three_count_consolidator.  His output will be a 3 day bar.
        three_one_day_bar = SequentialConsolidator(one_day_consolidator, three_count_consolidator)

        # attach our handler
        three_one_day_bar.data_consolidated += self.three_day_bar_consolidated_handler

        # this call adds our 3 day to the manager to receive updates from the engine
        self.subscription_manager.add_consolidator("SPY", three_one_day_bar)

        # Custom monthly consolidator
        custom_monthly_consolidator = TradeBarConsolidator(self.custom_monthly)
        custom_monthly_consolidator.data_consolidated += self.custom_monthly_handler
        self.subscription_manager.add_consolidator("SPY", custom_monthly_consolidator)

        # API convenience method for easily receiving consolidated data
        self.consolidate("SPY", timedelta(minutes=45), self.forty_five_minute_bar_handler)
        self.consolidate("SPY", Resolution.HOUR, self.hour_bar_handler)
        self.consolidate("EURUSD", Resolution.DAILY, self.daily_eur_usd_bar_handler)

        # API convenience method for easily receiving weekly-consolidated data
        self.consolidate("SPY", Calendar.WEEKLY, self.calendar_trade_bar_handler)
        self.consolidate("EURUSD", Calendar.WEEKLY, self.calendar_quote_bar_handler)

        # API convenience method for easily receiving monthly-consolidated data
        self.consolidate("SPY", Calendar.MONTHLY, self.calendar_trade_bar_handler)
        self.consolidate("EURUSD", Calendar.MONTHLY, self.calendar_quote_bar_handler)

        # API convenience method for easily receiving quarterly-consolidated data
        self.consolidate("SPY", Calendar.QUARTERLY, self.calendar_trade_bar_handler)
        self.consolidate("EURUSD", Calendar.QUARTERLY, self.calendar_quote_bar_handler)

        # API convenience method for easily receiving yearly-consolidated data
        self.consolidate("SPY", Calendar.YEARLY, self.calendar_trade_bar_handler)
        self.consolidate("EURUSD", Calendar.YEARLY, self.calendar_quote_bar_handler)

        # some securities may have trade and quote data available, so we can choose it based on TickType:
        #self.consolidate("BTCUSD", Resolution.HOUR, TickType.TRADE, self.hour_bar_handler)   # to get TradeBar
        #self.consolidate("BTCUSD", Resolution.HOUR, TickType.QUOTE, self.hour_bar_handler)   # to get QuoteBar (default)

        self.consolidated_hour = False
        self.consolidated45_minute = False'''
        self.__last = None

    def on_data(self, data):
        if self.gold in data.Keys and data[self.gold] is not None:
            bar = data[self.gold]
            if isinstance(bar, TradeBar):
                volume = bar.volume
                close_price = bar.close
                self.log(f"TradeBar for Gold Volume: {volume}, Close Price: {close_price}")
            elif isinstance(bar, QuoteBar):
                # Use bid or ask sizes as volume, if available
                volume = bar.last_bid_size if bar.last_bid_size is not None else bar.last_ask_size
                close_price = bar.close
                self.log(f"QuoteBar for Gold Volume: {volume}, Close Price: {close_price}")

    def on_end_of_day(self):
        # close up shop each day and reset our 'last' value so we start tomorrow fresh
        self.liquidate("SPY")
        self.__last = None

    def gold_consolidation_handler(self, sender, consolidated):
        self.log('gold_consolidation_handler volume='+str(consolidated.volume)+',price = '+str(consolidated.close))

    def thirty_minute_bar_handler(self, sender, consolidated):
        '''This is our event handler for our 30 minute trade bar defined above in Initialize(). So each time the
        consolidator produces a new 30 minute bar, this function will be called automatically. The 'sender' parameter
         will be the instance of the IDataConsolidator that invoked the event, but you'll almost never need that!'''
        self.log('thirty_minute_bar_handler volume='+str(consolidated.volume))
        if self.__last is not None and consolidated.close > self.__last.close:
            self.log(f"{consolidated.time} >> SPY >> LONG  >> 100 >> {self.portfolio['SPY'].quantity}")
            self.order("SPY", 100)

        elif self.__last is not None and consolidated.close < self.__last.close:
            self.log(f"{consolidated.time} >> SPY >> SHORT  >> 100 >> {self.portfolio['SPY'].quantity}")
            self.order("SPY", -100)

        self.__last = consolidated


    def three_day_bar_consolidated_handler(self, sender, consolidated):
        ''' This is our event handler for our 3 day trade bar defined above in Initialize(). So each time the
        consolidator produces a new 3 day bar, this function will be called automatically. The 'sender' parameter
        will be the instance of the IDataConsolidator that invoked the event, but you'll almost never need that!'''
        self.log('three_day_bar_consolidated_handler volume='+str(consolidated.volume))
        self.log(f"{consolidated.time} >> Plotting!")
        self.plot(consolidated.symbol.value, "3HourBar", consolidated.close)

    def forty_five_minute_bar_handler(self, consolidated):
        ''' This is our event handler for our 45 minute consolidated defined using the Consolidate method'''
        self.log('forty_five_minute_bar_handler volume='+str(consolidated.volume))
        self.consolidated45_minute = True
        self.log(f"{consolidated.end_time} >> FortyFiveMinuteBarHandler >> {consolidated.close}")

    def hour_bar_handler(self, consolidated):
        '''This is our event handler for our one hour consolidated defined using the Consolidate method'''
        self.log('hour_bar_handler volume='+str(consolidated.volume))
        self.consolidated_hour = True
        self.log(f"{consolidated.end_time} >> FortyFiveMinuteBarHandler >> {consolidated.close}")

    def daily_eur_usd_bar_handler(self, consolidated):
        '''This is our event handler for our daily consolidated defined using the Consolidate method'''
        self.log(f"{consolidated.end_time} EURUSD Daily consolidated.")

    def calendar_trade_bar_handler(self, trade_bar):
        self.log('calendar_trade_bar_handler volume='+str(trade_bar.volume))
        self.log(f'{self.time} :: {trade_bar.time} {trade_bar.close}')

    def calendar_quote_bar_handler(self, quote_bar):
        self.log(f'{self.time} :: {quote_bar.time} {quote_bar.close}')

    def custom_monthly(self, dt):
        '''Custom Monthly Func'''
        start = dt.replace(day=1).date()
        end = dt.replace(day=28) + timedelta(4)
        end = (end - timedelta(end.day-1)).date()
        return CalendarInfo(start, end - start)

    def custom_monthly_handler(self, sender, consolidated):
        '''This is our event handler Custom Monthly function'''
        self.log('custom_monthly_handler volume='+str(consolidated.volume))
        self.log(f"{consolidated.time} >> CustomMonthlyHandler >> {consolidated.close}")

    '''def on_end_of_algorithm(self):
        if not self.consolidated_hour:
            raise Exception("Expected hourly consolidator to be fired.")

        if not self.consolidated45_minute: 
            raise Exception("Expected 45-minute consolidator to be fired.")'''

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
from AlgorithmImports import *
from Indicator import *

#S1/S3/10, 0. volume as signal
class Multifactors(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2022, 1, 1)  # Set Start Date
        self.SetCash(100000)  # Set Strategy Cash
        self.malen = 60 #int(self.get_parameter("malen"))  #20, 60, 100
        self.histlen = 1440 #int(self.get_parameter("histlen"))  #60,100,300
        self.freq = 5
        self.periodlist = [self.freq] #[1440, 60, 30, 15, 5, 1]
        self.entry = 2
        self.exit = 0
        self.symbol = None
        self.contracts = []
        self.zscores = dict()
        self.assets = dict()
        self.consolidators = dict()
        self.futures = {'yld10Y': Futures.Financials.Y_10_TREASURY_NOTE,
                'yld5Y': Futures.Financials.MICRO_Y_5_TREASURY_BOND,
                'yld2Y': Futures.Financials.MICRO_Y_2_TREASURY_BOND,
                'jpy': Futures.Currencies.JPY,
                'aud': Futures.Currencies.AUD,
                'cad': Futures.Currencies.CAD,
                'chf': Futures.Currencies.CHF,
                'commodity': Futures.Indices.SPGSCI_COMMODITY,
                'sp500':Futures.Indices.MICRO_SP_500_E_MINI,
                'gold':Futures.Metals.GOLD}
        for key, value in self.futures.items():
            self.assets[key] = self.add_future(value, \
                                resolution = Resolution.MINUTE, \
                                fill_forward=True, \
                                extended_market_hours = True, \
                                data_normalization_mode = DataNormalizationMode.FORWARD_PANAMA_CANAL, \
                                data_mapping_mode = DataMappingMode.LAST_TRADING_DAY, \
                                contract_depth_offset = 0 ).symbol
            self.zscores[key] = dict()
            self.consolidators[key] = dict()

        self.wmavolume = dict()
        self.wmavolume['gold'] = dict()
        self.volosc = dict()
        self.volosc['gold'] = dict()
        self.macd_t = dict()
        self.macd_t['gold'] = dict()
        self.corr = dict()
        self.lag= 4 
        self.lagstart = 4 
        self.lagend = 13
        self.rsquared = 0
        self.corrlens = [1440,365]

        for period in self.periodlist:
            for key, value in self.assets.items():
                self.consolidators[key][period] = self.Consolidate(value, timedelta(minutes=period), self.consolidation_handler)
                self.subscription_manager.add_consolidator(value, self.consolidators[key][period])
                self.zscores[key][period] = ZscoreBase(self.malen, self.histlen)
            self.wmavolume['gold'][period] = CustomWeightedMovingAverage(9, self.histlen)
            self.volosc['gold'][period] = VolumeOscillator(12,26,9, self.histlen)
            self.macd_t['gold'][period] = CustomeMACD(self.assets['gold'], self.malen, self.histlen, self)
            self.corr[period] = CorrelationMatrix(self.corrlens,['wmavolume'],self.lagstart, self.lagend)
        self.schedule.on(self.date_rules.every_day(), self.time_rules.At(18,0), self.add_real_contracts)
        self.set_warmup(250000, Resolution.MINUTE)

        self.model_ready = False
        self.model = CustomModel(self.histlen, 1, 0, self.lagstart, self.lagend)
        self.model_type = 0  #LS
        self.fit_model()
        self.Schedule.On(self.date_rules.every_day(), self.time_rules.every(timedelta(minutes = self.histlen)), self.fit_model)
    
    def fit_model(self):
        if self.wmavolume['gold'][self.freq].IsReady and self.volosc['gold'][self.freq].IsReady:
            datas = []
            if self.model_type == 0:
                '''data1 =  pd.DataFrame()
                data1['gold1'] = np.diff(np.log(self.zscores['gold'][self.freq].value_hist))[:fitLen-self.difflen-1]
                data1['voloscdiff'] = np.diff(self.volosc['gold'][self.freq].zscore_hist)[self.difflen:] #diff volume 1th
                data1.replace([np.inf, -np.inf], np.nan, inplace=True)
                data1.ffill(inplace=True)
                data1.dropna(inplace=True)
                datas.append(data1)'''
                '''glddiff1_AVGrevol6thidff6th
                data['gold'] = np.diff(np.log(self.zscores['gold'][self.freq].value_hist))[:-self.difflen]
                data['volume0'] = -1 * self.wmavolume['gold'][self.freq].zscore_hist[self.difflen:-1] #volume 0 value
                data['volume6diff'] = np.diff(self.wmavolume['gold'][self.freq].zscore_hist)[self.difflen:] #diff volume 6th'''
                '''glddiff1_AVGrevol6thidff6th
                x = [data[['volume0']],data[['volume6diff']]]'''
                (self.lag, self.rsquared) = self.model.curPeriodR()
                data =  pd.DataFrame()
                data['gold'] = np.log(self.zscores['gold'][self.freq].rawregress_hist)[:self.histlen-self.lag] - \
                                np.log(self.zscores['gold'][self.freq].rawregress_hist)[self.lag:self.histlen]
                data['volume'] = self.wmavolume['gold'][self.freq].zscore_hist[self.lag:self.histlen]
                data.replace([np.inf, -np.inf], np.nan, inplace=True)
                data.ffill(inplace=True)
                data.dropna(inplace=True)
                datas.append(data)
            y = [datas[0]['gold'].values.reshape((-1, 1))]
            x = [datas[0][['volume']]]
            self.model.fit(x, y)
            self.model_ready = True
            #calculate correlations
            for period in self.periodlist:
                self.corr[period].calculatecorr()
        

    def add_real_contracts(self):
        contract_symbols = self.future_chain_provider.get_future_contract_list(self.assets['gold'], self.time)
        for symbol in contract_symbols:
            if self.is_relevant_contract(symbol):
                self.add_future_contract(symbol, Resolution.MINUTE)

    def is_relevant_contract(self, symbol: Symbol) -> bool:
        return symbol.id.date <= self.time + timedelta(days=90)


    def consolidation_handler(self, trade_bar):
        period_key = self.freq
        if trade_bar.symbol in self.assets:
            period_key = getPeriod(trade_bar)
            idx = self.assets.index(trade_bar.symbol)
            self.assets[idx][period_key].update(trade_bar.end_time, trade_bar.close)
        if trade_bar.symbol == self.assets['gold']:
            period_key = getPeriod(trade_bar)
            volumesign = getVolumeSign(trade_bar)
            self.wmavolume['gold'][period_key].update(self.Time, volumesign, trade_bar.Volume)
            self.volosc['gold'][period_key].update(self.Time, trade_bar.Volume)
            ##correct wrong data value, like gold price <=0
            goldprice = trade_bar.close
            if len(self.zscores['gold'][period_key].value_hist)>0 and \
                trade_bar.close <= self.zscores['gold'][period_key].value_hist[0]*0.5:
                goldprice = self.zscores['gold'][period_key].value_hist[0]
            self.zscores['gold'][period_key].update(trade_bar.end_time, goldprice)
            self.macd_t['gold'][period_key].update(trade_bar.end_time, trade_bar.close)
            #update corr data
            self.corr[period_key].update('gold', goldprice)
            self.corr[period_key].update('wmavolume', self.wmavolume['gold'][period_key].value)

           
            if self.model_ready and period_key == self.freq:
                '''glddiff1_AVGrevol6thidff6th
                volume_score = [[-self.wmavolume['gold'][period_key].zscore_hist[self.difflen]],
                                [self.wmavolume['gold'][period_key].zscore_hist[0] - self.wmavolume['gold'][period_key].zscore_hist[1]]]'''

                volume_score = [[self.wmavolume['gold'][period_key].zscore_hist[0]]]
                
                if self.model_type == 0:
                    zscore =  self.model.predict(self.time, volume_score)
                    #predicted_difflog =  self.model.predict([macd])[0][0]
                    #predicted_difflog =  self.model.predict([yld_score])[0][0]
                    #predicted_difflog =  self.model.predict([ret])[0][0]
                    #predicted_difflog =  np.exp(self.model.predict([volume_score]))[0][0]
                    #self.residual_zscore['gold'][period_key].update(trade_bar.end_time, (predicted_difflog))
                #self.log(str(self.zscores['gold'][period_key].value_hist[0])+','+str(self.wmavolume['gold'][period_key].value)+','+str(self.wmavolume['gold'][period_key].zscore))


    def on_securities_changed(self, changes):
        for security in changes.added_securities:
            if security.symbol.value[0:2]=='GC':
                self.contracts.append(security)
                
        for security in changes.removed_securities:
            if security in self.contracts:
                self.contracts.remove(security)

    
    def holdings(self):
        holdings = [ x.Symbol for x in self.Portfolio.Values if x.Invested ]
        for symbol in holdings:
            if self.portfolio[symbol].quantity > 0:
                return (1, symbol)
            elif self.portfolio[symbol].quantity < 0:
                return (-1, symbol)
        return (0, None)
    
    def validcorr(self):
        #corrlags1 = self.corr[self.freq].getCorr()['wmavolume'+str(self.corrlens[0])]
        #corrlags2 = self.corr[self.freq].getCorr()['wmavolume'+str(self.corrlens[1])]
        return  True
        '''corrlags1[self.difflen+1]>0 and \
        corrlags1[self.difflen+1]> corrlags1[self.difflen] and \
        corrlags2[self.difflen+1]>0'''
                

    def OnData(self, data):
        if self.assets['gold'] in data.Keys and data[self.assets['gold']] is not None:
            gold_price = data[self.assets['gold']].Value
            cur_contracts = [x for x in self.contracts if x.symbol in data.Keys]
            if not self.is_warming_up and len(cur_contracts) > 0:
                tag = f'{self.lag:.4f}'+','+ f'{self.rsquared:.4f}'+',' + f'{self.model.zscore :.4f}'+',' 
                for period in self.corrlens:
                    for lag in range(self.lagstart, self.lagend):
                        corrlag = self.corr[self.freq].getCorr()['wmavolume'+str(period)][lag]
                        precorrlag = self.corr[self.freq].getPreCorr()['wmavolume'+str(period)][lag]
                        difflag = corrlag - precorrlag
                        tag = tag + f'{corrlag:.4f}' + ','  + f'{difflag:.4f}' + ','

                contract = sorted(cur_contracts, key=lambda x: x.Volume, reverse = True)[0]
                self.symbol = contract.symbol
                (curhold, cursymbol) = self.holdings()
                #S3 volume as prediction signal
                if self.model_ready: 
                    c_score = self.model.zscore 
                    '''vs = self.wmavolume['gold'][self.freq].zscore_hist[self.difflen-1]
                    vsdiff = self.wmavolume['gold'][self.freq].zscore_hist[self.difflen-1] - self.wmavolume['gold'][self.freq].zscore_hist[self.difflen]
                    oscdiff = self.volosc['gold'][self.freq].zscore_hist[self.difflen-1] - self.volosc['gold'][self.freq].zscore_hist[self.difflen]'''
                    if c_score >= self.entry and curhold <= 0:
                        if curhold < 0:
                            self.liquidate(cursymbol)
                            if self.validcorr():
                                self.ticket = self.market_order(self.symbol, 1, False, tag)
                    elif c_score <= -self.entry and curhold >= 0:
                        if curhold > 0:
                            self.liquidate(cursymbol)
                        if self.validcorr():
                            self.ticket = self.market_order(self.symbol, -1, False, tag)




                '''S1: volme as shock signal
                if abs(volume_score) >= self.entry and \
                    self.volosc['gold'][15].zscore <= -3 and \
                    self.volosc['gold'][1440].zscore >= 0:
                    if len(cur_contracts) > 0:
                        if volume_score >= self.entry and curhold <= 0:
                            if curhold < 0:
                                self.liquidate(cursymbol)
                            self.ticket = self.market_order(self.symbol, 1, False, tag)
                        elif volume_score <= -self.entry and curhold >= 0:
                            if curhold > 0:
                                self.liquidate(cursymbol)
                            self.ticket = self.market_order(self.symbol, -1, False, tag)'''


                '''S1: yld as shock signal 
                    if abs(zscore) >= self.entry:
                    if len(cur_contracts) > 0:
                        if zscore >= self.entry and curhold <= 0:
                            if curhold < 0:
                                self.liquidate(cursymbol)
                            self.ticket = self.market_order(self.symbol, 1, False, tag)
                        elif zscore <= -self.entry and curhold >= 0:
                            if curhold > 0:
                                self.liquidate(cursymbol)
                            self.ticket = self.market_order(self.symbol, -1, False, tag)
                else:
                    if curhold < 0 and zscore >= self.exit:
                        self.liquidate(cursymbol)
                    elif curhold > 0 and zscore <= self.exit:
                        self.liquidate(cursymbol)'''

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
from AlgorithmImports import *
from Indicator import *

class Multifactors(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2022, 1, 1)  # Set Start Date
        self.set_end_date(self.start_date + timedelta(2)) 
        self.SetCash(100000)  # Set Strategy Cash
        self.malen = 60 #int(self.get_parameter("malen"))  #20, 60, 100
        self.histlen = 1440 #int(self.get_parameter("histlen"))  #60,100,300
        self.freq = 5
        self.periodlist = [self.freq] #[1440, 60, 30, 15, 5, 1]
        self.entry = 2
        self.exit = 0
        self.symbol = None
        self.contracts = []
        self.zscores = dict()
        self.assets = dict()
        self.consolidators = dict()
        self.volume = 0
        self.goldprice = 0

        self.futures = {'gold':Futures.Metals.GOLD}
        for key, value in self.futures.items():
            self.assets[key] = self.add_future(value, \
                                resolution = Resolution.MINUTE, \
                                fill_forward=True, \
                                extended_market_hours = True, \
                                data_normalization_mode = DataNormalizationMode.FORWARD_PANAMA_CANAL, \
                                data_mapping_mode = DataMappingMode.LAST_TRADING_DAY, \
                                contract_depth_offset = 0 ).symbol
            trade_bars_df = self.history(TradeBar, self.assets[key], 50)
            self.zscores[key] = dict()
            self.consolidators[key] = dict()


        for period in self.periodlist:
            for key, value in self.assets.items():
                self.consolidators[key][period] = self.Consolidate(value, timedelta(minutes=period), self.consolidation_handler)
                self.subscription_manager.add_consolidator(value, self.consolidators[key][period])
    

    def consolidation_handler(self, trade_bar):
        period_key = self.freq
        if trade_bar.symbol == self.assets['gold']:
            self.volume = trade_bar.Volume
            self.goldprice = trade_bar.close

    def OnData(self, data):
        if self.assets['gold'] in data.Keys and data[self.assets['gold']] is not None:
            self.log(str(self.volume)+','+str(self.goldprice))