class CorporateBuybacksDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2016, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(100000)
 
        self.aapl = self.add_equity("AAPL", Resolution.MINUTE).symbol
        self.intention_symbol = self.add_data(SmartInsiderIntention, self.aapl).symbol
        self.transaction_symbol = self.add_data(SmartInsiderTransaction, self.aapl).symbol

public class CorporateBuybacksDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol, _intentionSymbol, _transactionSymbol;
    
    public override void Initialize()
    {
        SetStartDate(2016, 1, 1);
        SetEndDate(2021, 1, 1);
        SetCash(100000);

        _symbol = AddEquity("AAPL", Resolution.Minute).Symbol;
        _intentionSymbol = AddData<SmartInsiderIntention>(_symbol).Symbol;
        _transactionSymbol = AddData<SmartInsiderTransaction>(_symbol).Symbol;
    }
}

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self.intention_symbol):
        data_point = slice[self.intention_symbol]
        self.log(f"{self.intention_symbol} intention amount at {slice.time}: {data_point.amount}")

    if slice.contains_key(self.transaction_symbol):
        data_point = slice[self.transaction_symbol]
        self.log(f"{self.transaction_symbol} transaction amount at {slice.time}: {data_point.amount}")

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_intentionSymbol))
    {
        var dataPoint = slice[_intentionSymbol];
        Log($"{_intentionSymbol} intention amount at {slice.Time}: {dataPoint.Amount}");
    }

    if (slice.ContainsKey(_transactionSymbol))
    {
        var dataPoint = slice[_transactionSymbol];
        Log($"{_transactionSymbol} transaction amount at {slice.Time}: {dataPoint.Amount}");
    }
}

def on_data(self, slice: Slice) -> None:
    for dataset_symbol, data_point in slice.get(SmartInsiderIntention).items():
        self.log(f"{dataset_symbol} intention amount at {slice.time}: {data_point.amount}")

    for dataset_symbol, data_point in slice.get(SmartInsiderTransaction).items():
        self.log(f"{dataset_symbol} transaction amount at {slice.time}: {data_point.amount}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<SmartInsiderIntention>())
    {
        var datasetSymbol = kvp.Key;
        var dataPoint = kvp.Value;
        Log($"{datasetSymbol} intention amount at {slice.Time}: {dataPoint.Amount}");
    }

    foreach (var kvp in slice.Get<SmartInsiderTransaction>())
    {
        var datasetSymbol = kvp.Key;
        var dataPoint = kvp.Value;
        Log($"{datasetSymbol} transaction amount at {slice.Time}: {dataPoint.Amount}");
    }
}

# DataFrames
intention_history_df = self.history(self.intention_symbol, 100, Resolution.DAILY)
transaction_history_df = self.history(self.transaction_symbol, 100, Resolution.DAILY)
history_df = self.history([self.intention_symbol, self.transaction_symbol], 100, Resolution.DAILY)

# Dataset objects
intention_history_bars = self.history[SmartInsiderIntention](self.intention_symbol, 100, Resolution.DAILY)
transaction_history_bars = self.history[SmartInsiderTransaction](self.transaction_symbol, 100, Resolution.DAILY)

// Dataset objects
var intentionHistory = History<SmartInsiderIntention>(_intentionSymbol, 100, Resolution.Daily);
var transactionHistory = History<SmartInsiderTransaction>(_transactionSymbol, 100, Resolution.Daily);

// Slice objects
var history = History(new[] {_intentionSymbol, _transactionSymbol}, 100, Resolution.Daily);

def initialize(self) -> None:
    self.intention_universe = self.add_universe(SmartInsiderIntentionUniverse, self.intention_selection)
    self.transaction_universe = self.add_universe(SmartInsiderTransactionUniverse, self.transaction_selection)

def intention_selection(self, alt_coarse: List[SmartInsiderIntentionUniverse]) -> List[Symbol]:
    return [d.symbol for d in alt_coarse \
                if d.percentage > 0.005 \
                and d.usd_market_cap > 100000000]

def transaction_selection(self, alt_coarse: List[SmartInsiderTransactionUniverse]) -> List[Symbol]:
    return [d.symbol for d in alt_coarse \
                if d.buyback_percentage > 0.005 \
                and d.usd_market_cap > 100000000]

private Universe _intentionUniverse;
private Universe _transactionUniverse;
public override void Initialize()
{
    _intentionUniverse = AddUniverse<SmartInsiderIntentionUniverse>(altCoarse =>
    {
        return from d in altCoarse.OfType<SmartInsiderIntentionUniverse>() 
            where d.Percentage > 0.005m && d.USDMarketCap > 100000000m
            select d.Symbol;
    });
    _transactionUniverse = AddUniverse<SmartInsiderTransactionUniverse>(altCoarse =>
    {
        return from d in altCoarse.OfType<SmartInsiderTransactionUniverse>() 
            where d.BuybackPercentage > 0.005m && d.USDMarketCap > 100000000m
            select d.Symbol;
    });
}

var intentionUniverseHistory = History(_intentionUniverse, 30, Resolution.Daily);
foreach (var intentions in intentionUniverseHistory)
{
    foreach (SmartInsiderIntentionUniverse intention in intentions)
    {
        Log($"{intention.Symbol.Value} amount at {intention.EndTime}: {intention.AmountValue}");
    }
}

var transactionUniverseHistory = History(_transactionUniverse, 30, Resolution.Daily);
foreach (var transactions in transactionHistory)
{
    foreach (SmartInsiderTransactionUniverse transaction in transactions)
    {
        Log($"{transaction.Symbol.Value} amount at {transaction.EndTime}: {transaction.Amount}");
    }
}

# DataFrame example where the columns are the SmartInsiderIntentionUniverse attributes: 
intention_history_df = self.history(self._universe, 30, Resolution.DAILY, flatten=True)

# Series example where the values are lists of SmartInsiderIntentionUniverse objects: 
intention_universe_history = self.history(self.intention_universe, 30, Resolution.DAILY)
for (_, time), intentions in intention_universe_history.items():
    for intention in intentions:
        self.log(f"{intention.symbol.value} amount value at {intention.end_time}: {intention.amount_value}")

# DataFrame example where the columns are the SmartInsiderTransactionUniverse attributes: 
transaction_history_df = self.history(self._universe, 30, Resolution.DAILY, flatten=True)

# Series example where the values are lists of SmartInsiderTransactionUniverse objects: 
transaction_universe_history = self.history(self.transaction_universe, 30, Resolution.DAILY)
for (_, time), transactions in transaction_universe_history.items():
    for transaction in transactions:
        self.log(f"{transaction.symbol.value} amount at {intention.end_time}: {intention.amount}")

var intentionUniverseHistory = qb.UniverseHistory(intentionUniverse, qb.Time.AddDays(-30), qb.Time);
foreach (var intentions in intentionUniverseHistory)
{
    foreach (SmartInsiderIntentionUniverse intention in intentions)
    {
        Console.WriteLine($"{intention.Symbol.Value} amount at {intention.EndTime}: {intention.AmountValue}");
    }
}

var transactionUniverseHistory = qb.UniverseHistory(transactionUniverse, qb.Time.AddDays(-30), qb.Time);
foreach (var transactions in transactionHistory)
{
    foreach (SmartInsiderTransactionUniverse transaction in transactions)
    {
        Console.WriteLine($"{transaction.Symbol.Value} amount at {transaction.EndTime}: {transaction.Amount}");
    }
}

# DataFrame example where the columns are the SmartInsiderIntentionUniverse attributes: 
intention_history_df = qb.universe_history(universe, qb.time-timedelta(30), qb.time, flatten=True)

# Series example where the values are lists of SmartInsiderIntentionUniverse objects: 
intention_universe_history = qb.universe_history(intention_universe, qb.time-timedelta(30), qb.time)
for (_, time), intentions in intention_universe_history.items():
    for intention in intentions:
        print(f"{intention.symbol.value} amount value at {intention.end_time}: {intention.amount_value}")

# DataFrame example where the columns are the SmartInsiderTransactionUniverse attributes: 
transaction_history_df = qb.universe_history(universe, qb.time-timedelta(30), qb.time, flatten=True)

# Series example where the values are lists of SmartInsiderTransactionUniverse objects: 
transaction_universe_history = qb.universe_history(transaction_universe, qb.time-timedelta(30), qb.time)
for (_, time), transactions in transaction_universe_history.items():
    for transaction in transactions:
        print(f"{transaction.symbol.value} amount at {transaction.end_time}: {transaction.amount}")

self.remove_security(self.intention_symbol)
self.remove_security(self.transaction_symbol)

RemoveSecurity(_intentionSymbol);
RemoveSecurity(_transactionSymbol);

from AlgorithmImports import *
from QuantConnect.DataSource import *

class CorporateBuybacksDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2016, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(100000)
 
        self.aapl = self.add_equity("AAPL", Resolution.MINUTE).symbol
        
        # Requesting insider trade intention news and actual trades to estimate the return, since insiders may have better information of the future confidence
        self.smart_insider_intention = self.add_data(SmartInsiderIntention, self.aapl).symbol
        self.smart_insider_transaction = self.add_data(SmartInsiderTransaction, self.aapl).symbol
        
        # Historical data
        history = self.history(self.smart_insider_intention, 365, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request for intentions")
        
        history = self.history(self.smart_insider_transaction, 365, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request for transactions")

    def on_data(self, slice: Slice) -> None:
        # Buy Apple whenever we receive a buyback intention or transaction notification, given the insiders may have confidence in the future to buy more
        # This news may stimulate market popularity
        if slice.contains_key(self.smart_insider_intention) or slice.contains_key(self.smart_insider_transaction):
            self.set_holdings(self.aapl, 1)
            self.entry_time = self.time
        
        # Liquidate holdings 3 days after the latest entry
        # The market popularity and possible overbrought is cooled
        if self.portfolio.invested and self.time >= self.entry_time + timedelta(days=3):
            self.liquidate()

public class CorporateBuybacksDataAlgorithm : QCAlgorithm
{
    private Symbol _aapl;
    private Symbol _smartInsiderIntention;
    private Symbol _smartInsiderTransaction;
    private DateTime _entryTime;
    
    public override void Initialize()
    {
        SetStartDate(2016, 1, 1);
        SetEndDate(2021, 1, 1);
        SetCash(100000);
        
        _aapl = AddEquity("AAPL", Resolution.Minute).Symbol;
        
        // Requesting insider trade intention news and actual trades to estimate the return, since insiders may have better information of the future confidence
        _smartInsiderIntention = AddData<SmartInsiderIntention>(_aapl).Symbol;
        _smartInsiderTransaction = AddData<SmartInsiderTransaction>(_aapl).Symbol;
        
        // Historical data
        var intentionHistory = History<SmartInsiderIntention>(_smartInsiderIntention, 365, Resolution.Daily);
        Debug($"We got {intentionHistory.Count()} items from our history request for intentions");
        
        var transactionHistory = History<SmartInsiderTransaction>(_smartInsiderTransaction, 365, Resolution.Daily);
        Debug($"We got {transactionHistory.Count()} items from our history request for transactions");
    }

    public override void OnData(Slice slice)
    {
        // Buy Apple whenever we receive a buyback intention or transaction notification, given the insiders may have confidence in the future to buy more
        // This news may stimulate market popularity
        if (slice.ContainsKey(_smartInsiderIntention) || slice.ContainsKey(_smartInsiderTransaction))
        {
            SetHoldings(_aapl, 1);
            _entryTime = Time;
        }

        // Liquidate holdings 3 days after the latest entry
        // The market popularity and possible overbrought is cooled
        if (Portfolio.Invested && Time >= _entryTime + TimeSpan.FromDays(3))
        {
            Liquidate();
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class CorporateBuybacksDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2016, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(100000)
 
        # Only interest in AAPL's insider trades information
        symbols = [Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)]
        self.add_universe_selection(ManualUniverseSelectionModel(symbols))
        self.add_alpha(CorporateBuybacksAlphaModel())
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())


class CorporateBuybacksAlphaModel(AlphaModel):
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        # Buy Apple whenever we receive a buyback intention or transaction notification, given the insiders may have confidence in the future to buy more
        # This news may stimulate market popularity, so we hold for 3 days
        if slice.contains_key(self.smart_insider_intention) or slice.contains_key(self.smart_insider_transaction):
            return [Insight.price(self.aapl, timedelta(days=3), InsightDirection.UP)]
        return []
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            self.aapl = security.symbol
            
            # Requesting insider trade intention news and actual trades to estimate the return, since insiders may have better information of the future confidence
            self.smart_insider_intention = algorithm.add_data(SmartInsiderIntention, self.aapl).symbol
            self.smart_insider_transaction = algorithm.add_data(SmartInsiderTransaction, self.aapl).symbol
            
            # Historical data
            history = algorithm.history(self.smart_insider_intention, 365, Resolution.DAILY)
            algorithm.debug(f"We got {len(history)} items from our history request for intentions")
            
            history = algorithm.history(self.smart_insider_transaction, 365, Resolution.DAILY)
            algorithm.debug(f"We got {len(history)} items from our history request for transactions")

public class CorporateBuybacksDataAlgorithm : QCAlgorithm
{

    public override void Initialize()
    {
        SetStartDate(2016, 1, 1);
        SetEndDate(2021, 1, 1);
        SetCash(100000);
        
        // Only interest in AAPL's insider trades information
        var symbols = new[] {QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA)};
        AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
        AddAlpha(new CorporateBuybacksAlphaModel());
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
    }

    public class CorporateBuybacksAlphaModel : AlphaModel
    {
        private Symbol _aapl;
        private Symbol _smartInsiderIntention;
        private Symbol _smartInsiderTransaction;

        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();
            
            // Buy Apple whenever we receive a buyback intention or transaction notification, given the insiders may have confidence in the future to buy more
            // This news may stimulate market popularity, so we hold for 3 days
            if (slice.ContainsKey(_smartInsiderIntention) || slice.ContainsKey(_smartInsiderTransaction))
            {
                insights.Add(Insight.Price(_aapl, TimeSpan.FromDays(3),  InsightDirection.Up));
            } 
            return insights;
        }

        public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                _aapl = security.Symbol;
                
                // Requesting insider trade intention news and actual trades to estimate the return, since insiders may have better information of the future confidence
                _smartInsiderIntention = algorithm.AddData<SmartInsiderIntention>(_aapl).Symbol;
                _smartInsiderTransaction = algorithm.AddData<SmartInsiderTransaction>(_aapl).Symbol;
                
                // Historical data
                var intentionHistory = algorithm.History<SmartInsiderIntention>(_smartInsiderIntention, 365, Resolution.Daily);
                algorithm.Debug($"We got {intentionHistory.Count()} items from our history request for intentions");
                
                var transactionHistory = algorithm.History<SmartInsiderTransaction>(_smartInsiderTransaction, 365, Resolution.Daily);
                algorithm.Debug($"We got {transactionHistory.Count()} items from our history request for transactions");
            }
        }
    }
}