QuantSIG Template Code

class KANYEWEST(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 7, 25)
        self.set_end_date(2024, 7, 25)
        self.set_cash(100000)
        self.symbol = self.add_equity("SPY", Resolution.DAILY).Symbol
        self.set_benchmark(self.symbol)
        self.cap = 100000
        self.benchmark_chart = []
        history = self.history(self.symbol, 1800, Resolution.DAILY)
        self.model_inter, self.model_intra = self.train(history)
        self.stop_market_ticket = None

    def on_data(self, data: Slice):
        self.plot_market()
        if not data.contains_key(self.symbol):
            return
        if self.model_inter is None or self.model_intra is None:
            return
        history = self.history(self.symbol, 35, Resolution.DAILY)
        formatted_data = self.prepare_data(history)
        if formatted_data.empty:
            return
        latest_data = formatted_data.iloc[[-1]][['0_inter', '0_intra', '1_inter', '1_intra', '2_inter', '2_intra', 'SMA_10', 'SMA_20']]
        inter_pred = self.model_inter.predict(latest_data)[0]
        intra_pred = self.model_intra.predict(latest_data)[0]
        if self.stop_market_ticket is not None and self.stop_market_ticket.status == OrderStatus.SUBMITTED:
            self.transactions.cancel_order(self.stop_market_ticket.order_id)
            self.stop_market_ticket = None
        buy_threshold = 0.5
        sell_threshold = 0.4
        short_threshold = 0.35
        portfolio_weight = 0.7
        short_weight = 0.7
        if inter_pred > buy_threshold and intra_pred > buy_threshold:
            self.set_holdings(self.symbol, portfolio_weight)
            purchase_price = self.portfolio[self.symbol].price
            self.record_purchase(self.time, 0.5 * purchase_price)
            self.place_stop_market_order(purchase_price, direction="long")
        elif inter_pred < sell_threshold and inter_pred > short_threshold and intra_pred < buy_threshold and intra_pred > short_threshold: 
            pass
        elif inter_pred < short_threshold and intra_pred < short_threshold:
            self.set_holdings(self.symbol, -short_weight)
            purchase_price = self.portfolio[self.symbol].price
            self.record_purchase(self.time, 0.5 * purchase_price)
            self.place_stop_market_order(purchase_price, direction="short")

    def place_stop_market_order(self, purchase_price, direction):
        if direction == "long":
            stop_price = purchase_price * 0.99
            self.stop_market_ticket = self.stop_market_order(self.symbol, -self.portfolio[self.symbol].quantity, stop_price)
        elif direction == "short":
            stop_price = purchase_price * 1.01
            self.stop_market_ticket = self.stop_market_order(self.symbol, -self.portfolio[self.symbol].quantity, stop_price)

    def record_purchase(self, date, amount):
        # Implement the logic for recording a purchase
        pass

    def on_order_event(self, order_event):
        if self.stop_market_ticket is not None and order_event.order_id == self.stop_market_ticket.order_id:
            if order_event.status == OrderStatus.FILLED:
                execution_price = order_event.fill_price
                execution_date = self.time
                self.stop_market_ticket = None

    def train(self, history):
        df = pd.DataFrame(history)
        grads = self.prepare_data(df)
        if grads.empty:
            return None, None
        X = grads[['0_inter', '0_intra', '1_inter', '1_intra', '2_inter', '2_intra', 'SMA_10', 'SMA_20']]
        y_inter = grads['0_inter'].shift(1)[grads.index]
        y_intra = grads['0_intra'].shift(1)[grads.index]
        X = X[20:]
        y_inter = y_inter[20:]
        y_intra = y_intra[20:]
        self.model_inter = LinearRegression()
        self.model_intra = LinearRegression()
        self.model_inter.fit(X, y_inter)
        self.model_intra.fit(X, y_intra)
        return (self.model_inter, self.model_intra)

    def prepare_data(self, df):
        df = df.reset_index()
        if 'index' in df.columns:
            df.rename(columns={'index': 'time'}, inplace=True)
        elif 'time' not in df.columns:
            df.rename(columns={'time': 'time'}, inplace=True)
        df['Date'] = pd.to_datetime(df['time'])
        df.set_index('Date', inplace=True)
        df['intraday_grads'] = (df['close'] / df['open'] - 1).dropna()
        df['interday_grads'] = (df['open'] / df['close'].shift(1) - 1).dropna()
        df['intraday_grads_norm'] = (df['intraday_grads'] - df['intraday_grads'].min()) / (df['intraday_grads'].max() - df['intraday_grads'].min())
        df['interday_grads_norm'] = (df['interday_grads'] - df['interday_grads'].min()) / (df['interday_grads'].max() - df['interday_grads'].min())
        grads = df[['interday_grads_norm', 'intraday_grads_norm']]
        grads.columns = ['0_inter', '0_intra']
        grads['1_inter'] = df['interday_grads_norm'].shift(-1)
        grads['1_intra'] = df['intraday_grads_norm'].shift(-1)
        grads['2_inter'] = df['interday_grads_norm'].shift(-2)
        grads['2_intra'] = df['intraday_grads_norm'].shift(-2)
        grads['SMA_10'] = df['close'].rolling(window=10).mean()
        grads['SMA_20'] = df['close'].rolling(window=20).mean()
        return grads.dropna()

    def plot_market(self):
        hist = self.history([self.symbol], 252, Resolution.DAILY)['close'].unstack(level=0).dropna()
        self.benchmark_chart.append(hist[self.symbol].iloc[-1])
        benchmark_perf = self.benchmark_chart[-1] / self.benchmark_chart[0] * self.cap
        self.plot("Strategy Equity", "Buy & Hold", benchmark_perf)

Sources: Price Earnings Anomaly, Order Tickets - QuantConnect.com, Short Term Reversal With Futures, Keras Neural Network Algorithm, Bybit Crypto Futures Regression Algorithm