US Equity

using QuantConnect.Data.Shortable;
		
public class USEquityShortingExampleAlgorithm : QCAlgorithm
{
    private Dictionary<Symbol, RateOfChange> _rocBySymbol = new();
    private Dictionary<BollingerBands, Security> _securityByBB = new();

    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2022, 1, 1);
        // Enable automatic indicator warm-up.
        Settings.AutomaticIndicatorWarmUp = true;
        // Add a universe of low-cap penny stocks that have high upward momentum.
        AddUniverse(SelectAssets);
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<Fundamental> fundamentals)
    {
        // Select all the penny stocks that have a momentum score.
        var pennyStocks = new List<Symbol>();
        foreach (var f in fundamentals)
        {
            // Create a RateOfChange indicator for each asset.
            if (!_rocBySymbol.ContainsKey(f.Symbol))
            {
                _rocBySymbol[f.Symbol] = new RateOfChange(1);
            }
            // Update the indicator and ensure it's ready.
            if (!_rocBySymbol[f.Symbol].Update(f.EndTime, f.Price))
            {
                continue;
            }
            // Filter out assets above $5M market cap or $1 share price.
            if (f.MarketCap > 5e6 || f.Price > 1)
            {
                continue;
            }
            pennyStocks.Add(f.Symbol);
        }

        // Select the 20 penny stocks with the greatest momentum.
        return pennyStocks.OrderByDescending(symbol => _rocBySymbol[symbol].Current.Value).Take(20);
    }

    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        // Iterate through the assets that entered the universe.
        foreach (var security in changes.AddedSecurities)
        {
            // Set the shortable provider of the asset to ensure realistic short availability.
            security.SetShortableProvider(new InteractiveBrokersShortableProvider());
            // Create a BollingerBand indicator for this asset.
            var bb = BB(security.Symbol, 20, 2, resolution: Resolution.Hour);
            _securityByBB[bb] = security;
            // Attach an event handler to the indicator to track its updates.
            bb.Updated += OnBBUpdated;
            (security as dynamic).Bbands = bb;
        }

        // Liquidate and remove the indicator updates for assets that leave the universe.
        foreach (var security in changes.RemovedSecurities)
        {
            var bb = (security as dynamic).Bbands;
            DeregisterIndicator(bb);
            _securityByBB.Remove(bb);
            Liquidate(security.Symbol);
        }
    }

    private void OnBBUpdated(object indicator, IndicatorDataPoint _)
    {
        var bb = (indicator as BollingerBands);
        // When the indicator updates, ensure it's ready.
        if (!bb.IsReady)
        {
            return;
        }
        var security = _securityByBB[bb];
        // Short the asset if the price is above the upper band.
        if (!security.Holdings.Invested && security.Price > bb.UpperBand.Current.Value)
        {
            // Get the number of shares avaiable for shorting.
            var shortableQuantity = security.ShortableProvider.ShortableQuantity(security.Symbol, Time);
            if (shortableQuantity == null)
            {
                return;
            }
            // Calculate the target quantity.
            var quantity = Math.Max(CalculateOrderQuantity(security.Symbol, -0.1m), -(int)shortableQuantity);
            if (quantity != 0)
            {
                // Short the asset.
                MarketOrder(security.Symbol, quantity);
                // Place a take-profit order 10% below the current price.
                LimitOrder(security.Symbol, -quantity, 0.9m * security.BidPrice);
            }
        }
        // If the limit order isn't hit before the price drops below the middle band, 
        // exit the position and cancel the limit order.
        else if (security.Holdings.Invested && security.Price < bb.MiddleBand.Current.Value)
        {
            Liquidate(security.Symbol);
        }
    }
}

class USEquityShortingExampleAlgorithm(QCAlgorithm):
    
    _roc_by_symbol = {}
    _security_by_bb = {}

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        # Enable automatic indicator warm-up.
        self.settings.automatic_indicator_warm_up = True
        # Add a universe of low-cap penny stocks that have high upward momentum.
        self.add_universe(self._select_assets)

    def _select_assets(self, fundamentals: List[Fundamental]) -> List[Symbol]:
        # Select all the penny stocks that have a momentum score.
        penny_stocks = []
        for f in fundamentals:
            # Create a RateOfChange indicator for each asset.
            if f.symbol not in self._roc_by_symbol:
                self._roc_by_symbol[f.symbol] = RateOfChange(1)
            # Update the indicator and ensure it's ready.
            if not self._roc_by_symbol[f.symbol].update(f.end_time, f.price):
                continue
            # Filter out assets above $5M market cap or $1 share price.
            if f.market_cap > 5e6 or f.price > 1:
                continue
            penny_stocks.append(f.symbol)

        # Select the 20 penny stocks with the greatest momentum.
        return sorted(penny_stocks, key=lambda symbol: self._roc_by_symbol[symbol].current.value)[-20:]
        
    def on_securities_changed(self, changes: SecurityChanges) -> None:
        # Iterate through the assets that entered the universe.
        for security in changes.added_securities:
            # Set the shortable provider of the asset to ensure realistic short availability.
            security.set_shortable_provider(InteractiveBrokersShortableProvider())
            # Create a BollingerBand indicator for this asset.
            security.bbands = self.bb(security.symbol, 20, 2, resolution=Resolution.HOUR)
            self._security_by_bb[security.bbands] = security
            # Attach an event handler to the indicator to track its updates.
            security.bbands.updated += self.on_bb_updated
        
        # Liquidate and remove the indicator updates for assets that leave the universe.
        for security in changes.removed_securities:
            self.deregister_indicator(security.bbands)
            self._security_by_bb.pop(security.bbands, None)
            self.liquidate(security.symbol)

    def on_bb_updated(self, bb: object, _: IndicatorDataPoint) -> None:
        # When the indicator updates, ensure it's ready.
        if not bb.is_ready:
            return
        security = self._security_by_bb[bb]
        # Short the asset if the price is above the upper band.
        if not security.holdings.invested and security.price > bb.upper_band.current.value:
            # Get the number of shares avaiable for shorting.
            shortable_quantity = security.shortable_provider.shortable_quantity(security.symbol, self.time)
            if not shortable_quantity:
                return
            # Calculate the target quantity.
            quantity = max(self.calculate_order_quantity(security.symbol, -0.1), -shortable_quantity)
            if quantity: 
                # Short the asset.
                self.market_order(security.symbol, quantity)
                # Place a take-profit order 10% below the current price.
                self.limit_order(security.symbol, -quantity, 0.9 * security.bid_price)
        # If the limit order isn't hit before the price drops below the middle band, 
        # exit the position and cancel the limit order.
        elif security.holdings.invested and security.price < bb.middle_band.current.value:
            self.liquidate(security.symbol)