Quiver Quantitative

from AlgorithmImports import *
from QuantConnect.DataSource import *

class QuiverCongressDataAlgorithm(QCAlgorithm):

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

        # Requesting data per underlying data to subscribe to updated congress members' trade information
        aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        quiver_congress_symbol = self.add_data(QuiverCongress, aapl).symbol

        # Historical data
        history = self.history(QuiverCongress, quiver_congress_symbol, 60, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request");

    def on_data(self, slice: Slice) -> None:
        congress_by_symbol = slice.Get(QuiverCongress)

        # Determine net direction of Congress trades for each security to estimate the sentiment direction due to political factor
        net_quantity_by_symbol = {}
        for symbol, points in congress_by_symbol.items():
            symbol = symbol.underlying
            if symbol not in net_quantity_by_symbol:
                net_quantity_by_symbol[symbol] = 0
            # Voting weight is by order size
            for point in points:
                net_quantity_by_symbol[symbol] += (1 if point.transaction == OrderDirection.BUY else -1) * point.amount
            
        for symbol, net_quantity in net_quantity_by_symbol.items():
            if net_quantity == 0:
                self.liquidate(symbol)
                continue
            # Buy when Congress members have bought, short otherwise
            self.set_holdings(symbol, 1 if net_quantity > 0 else -1)

public class QuiverCongressDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);
        
        // Requesting data per underlying data to subscribe to updated congress members' trade information
        var aapl = AddEquity("AAPL", Resolution.Daily).Symbol;
        var quiverCongressSymbol = AddData<QuiverCongress>(aapl).Symbol;

        // Historical data
        var history = History<QuiverCongress>(quiverCongressSymbol, 60, Resolution.Daily);
        Debug($"We got {history.Count()} items from our history request");
    }

    
    public override void OnData(Slice slice)
    {
        var congressBySymbol = slice.Get<QuiverCongress>();
        
        // Determine net direction of Congress trades for each security to estimate the sentiment direction due to political factor
        var netQuantityBySymbol = new Dictionary<Symbol, decimal>();
        foreach (var (s, points) in congressBySymbol)
        {
            var symbol = s.Underlying;
            if (!netQuantityBySymbol.ContainsKey(symbol))
            {
                netQuantityBySymbol[symbol] = 0m;
            }
            // Voting weight is by order size
            foreach(QuiverCongressDataPoint point in points)
            {
                netQuantityBySymbol[symbol] += (point.Transaction == OrderDirection.Buy ? 1 : -1) * (point.Amount ?? 0m);
            }
        }
        
        foreach (var (symbol, netQuantity) in netQuantityBySymbol)
        {
            if (netQuantity == 0)
            {
                Liquidate(symbol);
                continue;
            }
            // Buy when Congress members have bought, short otherwise
            SetHoldings(symbol, netQuantity > 0 ? 1 : -1);
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class QuiverCongressDataAlgorithm(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
        # Filter according to QuiverCongress data
        self.add_universe(QuiverQuantCongressUniverse, "QuiverQuantCongresssUniverse", Resolution.DAILY, self.universe_selection)
        
        self.add_alpha(CongressAlphaModel())
        
        self.set_portfolio_construction(InsightWeightingPortfolioConstructionModel(lambda time: None))
        
        self.add_risk_management(NullRiskManagementModel())
        
        self.set_execution(ImmediateExecutionModel())

    def universe_selection(self, alt_coarse: List[QuiverQuantCongressUniverse]) -> List[Symbol]:
        # Only include the ones with large size buy, since they are estimated to be materially confident to go up
        return [d.symbol for d in alt_coarse
                    if d.amount > 200000 and d.transaction == OrderDirection.BUY]
        

class CongressAlphaModel(AlphaModel):
    
    symbol_data_by_symbol = {}

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []
        congress_by_symbol = slice.Get(QuiverCongress)

        # Determine net direction of Congress trades for each security to estimate the sentiment direction due to political factor
        net_quantity_by_symbol = {}
        for symbol, points in congress_by_symbol.items():
            symbol = symbol.underlying
            if symbol not in net_quantity_by_symbol:
                net_quantity_by_symbol[symbol] = 0
            # Voting weight is by order size
            for point in points:
                net_quantity_by_symbol[symbol] += (1 if point.transaction == OrderDirection.BUY else -1) * point.amount
        
        for symbol, net_quantity in net_quantity_by_symbol.items():
            # Buy when Congress members have bought, as they may have advance information to be confident to the return direction
            if net_quantity > 0 and not algorithm.portfolio[symbol].is_long:
                insights += [Insight.price(symbol, timedelta(7),  InsightDirection.UP, weight=0.5)]
            # Short sell when Congress members have sold
            elif net_quantity < 0 and not algorithm.portfolio[symbol].is_short:
                insights += [Insight.price(symbol, timedelta(7),  InsightDirection.DOWN, weight=0.5)]
    
        return insights

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            symbol = security.symbol
            self.symbol_data_by_symbol[symbol] = SymbolData(algorithm, symbol)
        
        for security in changes.removed_securities:
            symbol_data = self.symbol_data_by_symbol.pop(security.symbol, None)
            if symbol_data:
                symbol_data.dispose()
            
class SymbolData:
    def __init__(self, algorithm: QCAlgorithm, symbol: Symbol):
        self.algorithm = algorithm
        
        # Requesting data per underlying data to subscribe to updated congress members' trade information
        self.quiver_congress_symbol = algorithm.add_data(QuiverCongress, symbol).symbol
        
        # Historical data
        history = algorithm.history(self.quiver_congress_symbol, 14, Resolution.DAILY)
        algorithm.debug(f"We got {len(history)} items from our history request for {symbol} Quiver Congress data")
        
    def dispose(self) -> None:
        # Unsubscribe from Quiver Congress feed for this security to release computational resources
        self.algorithm.remove_security(self.quiver_congress_symbol)

public class QuiverCongressDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);
        
        // Filter according to QuiverCongress data
        AddUniverse<QuiverQuantCongressUniverse>("QuiverQuantCongresssUniverse", Resolution.Daily, altCoarse =>
        {
            // Only include the ones with large size buy, since they are estimated to be materially confident to go up
            return from d in altCoarse 
                where d.Amount > 200000 && d.Transaction == OrderDirection.Buy 
                select d.Symbol;
        });
        
        AddAlpha(new CongressAlphaModel());
        
        SetPortfolioConstruction(new InsightWeightingPortfolioConstructionModel(time => None));
        
        AddRiskManagement(new NullRiskManagementModel());
        
        SetExecution(new ImmediateExecutionModel());
    }
}

public class CongressAlphaModel : AlphaModel
{
    private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new ();

    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        var congressBySymbol = slice.Get<QuiverCongress>();
        
        // Determine net direction of Congress trades for each security to estimate the sentiment direction due to political factor
        var netQuantityBySymbol = new Dictionary<Symbol, decimal>();
        foreach (var (s, points) in congressBySymbol)
        {
            var symbol = s.Underlying;
            if (!netQuantityBySymbol.ContainsKey(symbol))
            {
                netQuantityBySymbol[symbol] = 0m;
            }
            // Voting weight is by order size
            foreach(QuiverCongressDataPoint point in points)
            {
                netQuantityBySymbol[symbol] += (point.Transaction == OrderDirection.Buy ? 1 : -1) * (point.Amount ?? 0m);
            }
        }
        
        foreach (var (symbol, netQuantity) in netQuantityBySymbol)
        {
            // Buy when Congress members have bought, as they may have advance information to be confident to the return direction
            if (netQuantity > 0 && !algorithm.Portfolio[symbol].IsLong)
            {
                yield return Insight.Price(symbol, TimeSpan.FromDays(7),  InsightDirection.Up, weight: 0.5);
            }
            
            // Short sell when Congress members have sold
            else if (netQuantity < 0 && !algorithm.Portfolio[symbol].IsShort)
            {
                yield return Insight.Price(symbol, TimeSpan.FromDays(7), InsightDirection.Down, weight: 0.5);
            }
        }
    }

    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            var symbol = security.Symbol;
            _symbolDataBySymbol.Add(symbol, new SymbolData(algorithm, symbol));
        }

        foreach (var security in changes.RemovedSecurities)
        {
            var symbol = security.Symbol;
            if (_symbolDataBySymbol.ContainsKey(symbol))
            {
                _symbolDataBySymbol[symbol].dispose();
                _symbolDataBySymbol.Remove(symbol);
            }
        }
    }
}

public class SymbolData
{
    private Symbol _quiverCongressSymbol;
    private QCAlgorithm _algorithm;
    
    public SymbolData(QCAlgorithm algorithm, Symbol symbol)
    {
        _algorithm = algorithm;
        
        // Requesting data per underlying data to subscribe to updated congress members' trade information
        _quiverCongressSymbol = algorithm.AddData<QuiverCongress>(symbol).Symbol;
        
        // Historical data
        var history = algorithm.History<QuiverCongress>(_quiverCongressSymbol, 60, Resolution.Daily);
        algorithm.Debug($"We got {history.Count()} items from our history request for {symbol} Quiver Congress data");
    }
    
    public void dispose()
    {
        // Unsubscribe from Quiver Congress feed for this security to release computational resources
        _algorithm.RemoveSecurity(_quiverCongressSymbol);
    }
}