Second Tick Data

Here is a QuantConnect Python algorithm that matches 'Digitall’s' detailed description:

from AlgorithmImports import *

class DigitallStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        # Track previous close prices
        self._yesterday_close: Dict[Symbol, float] = {}
        # Store today's official open price
        self._today_open_price: Dict[Symbol, float] = {}
        # Daily watchlist of symbols
        self._daily_watchlist: List[Symbol] = []
        # Keep track of symbols already exited (to ensure no re-entry in same day)
        self._exited_symbols: Set[Symbol] = set()
        # Track entry prices for positions
        self._entry_prices: Dict[Symbol, float] = {}

        # Configure the environment
        self.set_time_zone(TimeZones.NEW_YORK)
        self.set_brokerage_model(BrokerageName.DEFAULT)
        self.universe_settings.resolution = Resolution.MINUTE
        self.universe_settings.extended_market_hours = True
        self.set_warmup(1, Resolution.DAILY)

        # Create a Coarse/Fine universe
        self.add_universe(self.coarse_selection_function, self.fine_selection_function)

        # Morning watchlist selection scheduled at 9:30:10
        self.schedule.on(self.date_rules.every_day(),
                         self.time_rules.at(9, 30, 10),
                         self.morning_selection)

        # End-of-day liquidation scheduled at 15:59:50
        self.schedule.on(self.date_rules.every_day(),
                         self.time_rules.at(15, 59, 50),
                         self.end_of_day_liquidate)

    def coarse_selection_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Save coarse close prices for gap calculations
        for c in coarse:
            if c.has_fundamental_data and c.price > 0:
                self._yesterday_close[c.symbol] = c.price

        # Filter on price >= 0.25, volume > 1 million
        filtered = [x.symbol for x in coarse
                    if x.has_fundamental_data and x.volume > 1_000_000 and x.price >= 0.25]
        return filtered

    def fine_selection_function(self, fine: List[FineFundamental]) -> List[Symbol]:
        # Trivial fine filter, keep them all
        return [f.symbol for f in fine]

    def morning_selection(self) -> None:
        # Clear previous day's data
        self._daily_watchlist.clear()
        self._exited_symbols.clear()
        self._entry_prices.clear()

        candidates = []
        for symbol, todayOpen in self._today_open_price.items():
            if symbol in self._yesterday_close:
                y_close = self._yesterday_close[symbol]
                if y_close > 0 and todayOpen >= 0.25:
                    gap_percent = (todayOpen - y_close) / y_close
                    candidates.append((symbol, gap_percent))

        # Sort in descending order by gap-up percentage, take top 100
        candidates.sort(key=lambda x: x[1], reverse=True)
        top_symbols = [x[0] for x in candidates[:100]]
        self._daily_watchlist = top_symbols
        self.log(f"Daily watchlist count: {len(self._daily_watchlist)}")

        # Add symbol subscriptions using second resolution
        for sym in self._daily_watchlist:
            if not self.securities.contains_key(sym):
                self.add_equity(sym.value, Resolution.SECOND, extended_market_hours=True)

    def on_data(self, data: Slice) -> None:
        # Record the official open price at the first bar after 9:30
        for kvp in data.bars.items():
            symbol = kvp.key
            bar = kvp.value
            if symbol not in self._today_open_price:
                # The first bar after 9:30 local is assigned as the official open
                if self.time.hour == 9 and self.time.minute >= 30:
                    self._today_open_price[symbol] = bar.open

        # Check triggers for watchlist symbols
        for symbol in list(self._daily_watchlist):
            if symbol not in data.bars:
                continue

            bar = data.bars[symbol]
            current_price = bar.close

            # If already in position, check exit conditions
            if symbol in self._entry_prices:
                entry_price = self._entry_prices[symbol]
                if entry_price > 0:
                    # +30% exit
                    if current_price >= 1.3 * entry_price:
                        self.liquidate(symbol)
                        self._daily_watchlist.remove(symbol)
                        self._exited_symbols.add(symbol)
                        self.debug(f"Sell {symbol} at +30% from entry.")
                    # -30% exit
                    elif current_price <= 0.7 * entry_price:
                        self.liquidate(symbol)
                        self._daily_watchlist.remove(symbol)
                        self._exited_symbols.add(symbol)
                        self.debug(f"Sell {symbol} at -30% from entry.")

            # If not in position, check entry condition (+40% from open)
            else:
                if symbol in self._today_open_price:
                    off_open = self._today_open_price[symbol]
                    if off_open > 0 and current_price >= 1.4 * off_open:
                        quantity = self.calculate_order_quantity(symbol, 0.01)
                        if quantity != 0:
                            self.market_order(symbol, quantity)
                            self._entry_prices[symbol] = current_price
                            self.debug(f"Buy {symbol} triggered at {current_price}")

    def end_of_day_liquidate(self) -> None:
        # Liquidate all positions and clear all daily data
        self.liquidate()
        self._daily_watchlist.clear()
        self._entry_prices.clear()
        self._today_open_price.clear()
        self._exited_symbols.clear()
        self.debug("EOD Liquidation & watchlist cleared.")

This structure creates a daily dynamic watchlist, manages positions according to your specs, and is set up to scan US equities universe across all NYSE/NASDAQ tiers. You can enhance logic around precise premarket volume using custom data, if deeper premarket granularity is absolutely essential. Let me know if you'd like code for that!

Sources: True Beats - QuantConnect.com, WallStreetBets - QuantConnect.com, Momentum And State Of Market Filters, Head & Shoulders TA Pattern Detection, Tactical - QuantConnect.com