Exclude non-tradable or delisted stocks during or after universe selection

To address your challenge of constructing a universe that excludes non-tradable stocks and maintains a balanced long/short portfolio, here's a structured approach using QuantConnect's capabilities:

1. Coarse Universe Selection: Use the coarse selection method to filter stocks based on criteria like price and dollar volume, ensuring only liquid stocks are included. Ensure that CoarseFundamental.HasFundamentalData is True to exclude delisted stocks.

2. Fine Universe Selection: Once the coarse universe is determined, use the fine selection method to filter further based on more detailed criteria such as P/E ratio or market cap.

3. Monitor Security Updates: Implement the OnSecuritiesChanged method. This method allows you to react when securities are added or removed from the universe. Specifically, you can manage your portfolio by liquidating positions in securities that become non-tradable.

4. Ensure Tradability in OnData: Before executing trades, check if a security is tradable using the Security.IsTradable property. This step ensures you don't attempt to trade stocks that can't be traded, thus preserving the balanced nature of your long/short portfolio.

5. Handle Exceptions: Implement logic to rebalance your portfolio whenever securities are found to be non-tradable. This can involve liquidating such positions and adjusting weights on remaining tradable securities to maintain balance between long and short positions.

Here's a conceptual outline of how you might set this up in your algorithm:

class CustomLongShortAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(100000)
        self.universe_settings.resolution = Resolution.DAILY
        self.add_universe(self.coarse_selection_function, self.fine_selection_function)

    def coarse_selection_function(self, coarse):
        # Filter based on price, volume, and ensure stocks have fundamental data
        filtered = [x for x in coarse if x.price > 10 and x.dollar_volume > 1e7 and x.has_fundamental_data]
        return [x.symbol for x in sorted(filtered, key=lambda x: x.dollar_volume, reverse=True)[:50]]

    def fine_selection_function(self, fine):
        # Further refine selection based on P/E ratio or any other fundamental data
        sorted_fine = sorted([x for x in fine if x.valuation_ratios.pe_ratio > 0], 
                             key=lambda x: x.valuation_ratios.pe_ratio)
        return [x.symbol for x in sorted_fine[:10]]

    def on_securities_changed(self, changes):
        for security in changes.removed_securities:
            if security.invested:
                self.liquidate(security.Symbol)

    def on_data(self, data):
        for symbol, security in data.securities.items():
            if not security.is_tradable:
                continue

            # Example trading logic, adjust to maintain balance
            if self.should_enter_position(security):
                self.set_holdings(security.Symbol, 0.1)
            elif self.should_exit_position(security):
                self.liquidate(security.Symbol)

    def should_enter_position(self, security):
        # Replace with your entry condition logic
        return ...

    def should_exit_position(self, security):
        # Replace with your exit condition logic
        return ...

By using these methods, you can effectively manage a universe that minimizes the inclusion of non-tradable or delisted stocks, maintaining an equal number of long and short positions in your portfolio.

Sources: Key Concepts - QuantConnect.com, Fundamental Universes - QuantConnect.com, Coarse Fine Fundamental Combo Algorithm, Coarse Fundamental Top3 Algorithm, Key Concepts - QuantConnect.com

I have tried the above. First, data.securities.items() in OnData function caused an error:
"Runtime Error: 'PythonSlice' object has no attribute 'securities'
 at on_data
   for symbol, security in data.securities.items():"

Then I tried this in OnData:
for symbol, bar in data.Bars.items():
       security = self.Securities[symbol]
       if not security.is_tradable:
           continue
Some stocks are still having data issues like:
Skipping shorting SON R735QTJ8XC9X - no data available (2015-02-20 15:30:00)
Skipping shorting KPTI VLD9RVF1PE1X - no data available (2015-02-23 15:30:00)

……..

Hi Fimmu smu

The universe selection tool will not return any delisted stocks on that day. Even the ones being subscribed will be removed after its delisting. It is likely that no reference price can be used to fill orders, so you may add a last-known-price to “initiate" the security:

def initialize(self):
    self.set_security_initializer(lambda security: security.set_market_price(self.get_last_known_price(security))

Best
Louis