Financial Industry Regulatory Authority

from AlgorithmImports import *

class FINRAShortSaleVolumeDataAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.short_volume_symbol = self.add_data(FINRAShortSaleVolume, aapl).symbol
        history = self.history(FINRAShortSaleVolume, self.short_volume_symbol, 60, Resolution.DAILY)

        self.debug(f"We got {len(history)} items from our history request")

    def on_data(self, slice):
        points = slice.get(FINRAShortSaleVolume)
        for point in points.values():
            # Go short when off-exchange short volume is more than half of total reported volume
            if point.short_volume_ratio is not None and point.short_volume_ratio > 0.5:
                self.set_holdings(point.symbol.underlying, -1)

            # Go long otherwise
            else:
                self.set_holdings(point.symbol.underlying, 1)

public class FINRAShortSaleVolumeDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);

        var aapl = AddEquity("AAPL", Resolution.Daily).Symbol;
        var shortVolumeSymbol = AddData<FINRAShortSaleVolume>(aapl).Symbol;
        var history = History<FINRAShortSaleVolume>(shortVolumeSymbol, 60, Resolution.Daily);

        Debug($"We got {history.Count()} items from our history request");
    }

    public override void OnData(Slice slice)
    {
        var points = slice.Get<FINRAShortSaleVolume>();
        foreach (var point in points.Values)
        {
            // Go short when off-exchange short volume is more than half of total reported volume
            if (point.ShortVolumeRatio > 0.5m)
            {
                SetHoldings(point.Symbol.Underlying, -1);
            }
            // Go long otherwise
            else
            {
                SetHoldings(point.Symbol.Underlying, 1);
            }
        }
    }
}

from AlgorithmImports import *

class FINRAShortSaleVolumeFrameworkAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        self.universe_settings.resolution = Resolution.DAILY

        symbols = [Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)]
        self.set_universe_selection(ManualUniverseSelectionModel(symbols))

        self.add_alpha(FINRAShortPressureAlphaModel())

        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        self.set_execution(ImmediateExecutionModel())


class FINRAShortPressureAlphaModel(AlphaModel):

    def __init__(self, threshold: float = 0.5) -> None:
        self._threshold = threshold
        self._symbols_by_security = {}

    def update(self, algorithm: QCAlgorithm, data: Slice) -> List[Insight]:
        insights = []
        for security_symbol, short_volume_symbol in self._symbols_by_security.items():
            if short_volume_symbol not in data:
                continue
            ratio = data[short_volume_symbol].short_volume_ratio
            if ratio is None:
                continue
            direction = InsightDirection.DOWN if ratio > self._threshold else InsightDirection.UP
            insights.append(Insight.price(security_symbol, timedelta(days=7), direction))
        return insights

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            symbol = security.symbol
            short_volume_symbol = algorithm.add_data(FINRAShortSaleVolume, symbol).symbol
            self._symbols_by_security[symbol] = short_volume_symbol
            history = algorithm.history(FINRAShortSaleVolume, short_volume_symbol, 30, Resolution.DAILY)
            algorithm.debug(f"Got {len(history)} historical short sale volume rows for {symbol}")
        for security in changes.removed_securities:
            short_volume_symbol = self._symbols_by_security.pop(security.symbol, None)
            if short_volume_symbol is not None:
                algorithm.remove_security(short_volume_symbol)

public class FINRAShortSaleVolumeFrameworkAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);

        UniverseSettings.Resolution = Resolution.Daily;

        var symbols = new[] { QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA) };
        SetUniverseSelection(new ManualUniverseSelectionModel(symbols));

        AddAlpha(new FINRAShortPressureAlphaModel());

        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        SetExecution(new ImmediateExecutionModel());
    }
}

public class FINRAShortPressureAlphaModel : AlphaModel
{
    private readonly decimal _threshold;
    private readonly Dictionary<Symbol, Symbol> _symbolsBySecurity = new();

    public FINRAShortPressureAlphaModel(decimal threshold = 0.5m)
    {
        _threshold = threshold;
    }

    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
    {
        foreach (var kvp in _symbolsBySecurity)
        {
            var securitySymbol = kvp.Key;
            var shortVolumeSymbol = kvp.Value;
            if (!data.ContainsKey(shortVolumeSymbol))
            {
                continue;
            }
            var ratio = data.Get<FINRAShortSaleVolume>(shortVolumeSymbol).ShortVolumeRatio;
            if (ratio == null)
            {
                continue;
            }
            var direction = ratio > _threshold ? InsightDirection.Down : InsightDirection.Up;
            yield return Insight.Price(securitySymbol, TimeSpan.FromDays(7), direction);
        }
    }

    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            var symbol = security.Symbol;
            var shortVolumeSymbol = algorithm.AddData<FINRAShortSaleVolume>(symbol).Symbol;
            _symbolsBySecurity[symbol] = shortVolumeSymbol;
            var history = algorithm.History<FINRAShortSaleVolume>(shortVolumeSymbol, 30, Resolution.Daily);
            algorithm.Debug($"Got {history.Count()} historical short sale volume rows for {symbol}");
        }
        foreach (var security in changes.RemovedSecurities)
        {
            if (_symbolsBySecurity.Remove(security.Symbol, out var shortVolumeSymbol))
            {
                algorithm.RemoveSecurity(shortVolumeSymbol);
            }
        }
    }
}