QuantConnect

from AlgorithmImports import *

class FamaFrenchFactorsAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2020, 12, 31)
        self.set_cash(100000)

        self.spy = self.add_equity("SPY", Resolution.DAILY).symbol
        self.fama_french = self.add_data(FamaFrench, "FF", Resolution.DAILY).symbol

        history = self.history[FamaFrench](self.fama_french, 60, Resolution.DAILY)
        self.debug(f"We got {len(list(history))} items from our history request")

    def on_data(self, slice):
        if not slice.contains_key(self.fama_french):
            return

        momentum = slice[self.fama_french].momentum
        if momentum is None:
            return

        # Hold the market while the momentum factor is positive
        if momentum > 0:
            self.set_holdings(self.spy, 1)

        # Step aside while it is negative
        else:
            self.liquidate(self.spy)

public class FamaFrenchFactorsAlgorithm : QCAlgorithm
{
    private Symbol _spy, _famaFrench;

    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2020, 12, 31);
        SetCash(100000);

        _spy = AddEquity("SPY", Resolution.Daily).Symbol;
        _famaFrench = AddData<FamaFrench>("FF", Resolution.Daily).Symbol;

        var history = History<FamaFrench>(_famaFrench, 60, Resolution.Daily);
        Debug($"We got {history.Count()} items from our history request");
    }

    public override void OnData(Slice slice)
    {
        if (!slice.ContainsKey(_famaFrench))
        {
            return;
        }

        var momentum = slice.Get<FamaFrench>(_famaFrench).Momentum;
        if (!momentum.HasValue)
        {
            return;
        }

        // Hold the market while the momentum factor is positive
        if (momentum > 0)
        {
            SetHoldings(_spy, 1);
        }
        // Step aside while it is negative
        else
        {
            Liquidate(_spy);
        }
    }
}

from AlgorithmImports import *

class FamaFrenchFrameworkAlgorithm(QCAlgorithm):

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

        self.universe_settings.resolution = Resolution.DAILY

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

        self.add_alpha(FamaFrenchAlphaModel(self))

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


class FamaFrenchAlphaModel(AlphaModel):

    def __init__(self, algorithm: QCAlgorithm) -> None:
        self._tradable_symbols = []

        # One subscription carries every factor, keyed by a fixed identifier
        self._fama_french = algorithm.add_data(FamaFrench, "FF", Resolution.DAILY).symbol

        history = algorithm.history[FamaFrench](self._fama_french, 60, Resolution.DAILY)
        algorithm.debug(f"We got {len(list(history))} items from our history request")

    def update(self, algorithm: QCAlgorithm, data: Slice) -> List[Insight]:
        if self._fama_french not in data:
            return []

        momentum = data[self._fama_french].momentum
        if momentum is None:
            return []

        # A positive momentum factor is a risk-on regime, so hold the universe and step aside otherwise
        direction = InsightDirection.UP if momentum > 0 else InsightDirection.FLAT
        return [Insight.price(symbol, timedelta(days=7), direction) for symbol in self._tradable_symbols]

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            if security.symbol != self._fama_french:
                self._tradable_symbols.append(security.symbol)

        for security in changes.removed_securities:
            if security.symbol in self._tradable_symbols:
                self._tradable_symbols.remove(security.symbol)

public class FamaFrenchFrameworkAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2020, 12, 31);
        SetCash(100000);

        UniverseSettings.Resolution = Resolution.Daily;

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

        AddAlpha(new FamaFrenchAlphaModel(this));

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

public class FamaFrenchAlphaModel : AlphaModel
{
    private readonly List<Symbol> _tradableSymbols = new();
    private readonly Symbol _famaFrench;

    public FamaFrenchAlphaModel(QCAlgorithm algorithm)
    {
        // One subscription carries every factor, keyed by a fixed identifier
        _famaFrench = algorithm.AddData<FamaFrench>("FF", Resolution.Daily).Symbol;

        var history = algorithm.History<FamaFrench>(_famaFrench, 60, Resolution.Daily);
        algorithm.Debug($"We got {history.Count()} items from our history request");
    }

    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
    {
        if (!data.ContainsKey(_famaFrench))
        {
            return Enumerable.Empty<Insight>();
        }

        var momentum = data.Get<FamaFrench>(_famaFrench).Momentum;
        if (momentum == null)
        {
            return Enumerable.Empty<Insight>();
        }

        // A positive momentum factor is a risk-on regime, so hold the universe and step aside otherwise
        var direction = momentum > 0 ? InsightDirection.Up : InsightDirection.Flat;
        return _tradableSymbols.Select(symbol => Insight.Price(symbol, TimeSpan.FromDays(7), direction));
    }

    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            if (security.Symbol != _famaFrench)
            {
                _tradableSymbols.Add(security.Symbol);
            }
        }

        foreach (var security in changes.RemovedSecurities)
        {
            _tradableSymbols.Remove(security.Symbol);
        }
    }
}