QuantConnect

https://www.quantconnect.com/docs/v2/writing-algorithms
Admin
QuantConnect is a cloud-based algorithmic trading platform that provides a feature-complete API for...
Tokens:2,070,498
Snippets:12,992
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### FrameworkAlphaModelAlgorithm Implementation

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/algorithm-framework/alpha/key-concepts

This example demonstrates the setup of a QCAlgorithm using a ManualUniverseSelectionModel for Forex symbols, a custom InterestRateAlphaModel, and an EqualWeightingPortfolioConstructionModel.

```python
class FrameworkAlphaModelAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)

        # Use daily resolution since the interest rate signal is daily.
        self.universe_settings.resolution = Resolution.DAILY
        # Add a universe of selected list of Forex.
        forex = [
            Symbol.create("AUDUSD", SecurityType.FOREX, Market.OANDA),
            Symbol.create("EURUSD", SecurityType.FOREX, Market.OANDA),
            Symbol.create("GBPUSD", SecurityType.FOREX, Market.OANDA),
            Symbol.create("USDCAD", SecurityType.FOREX, Market.OANDA),
            Symbol.create("USDCHF", SecurityType.FOREX, Market.OANDA),
            Symbol.create("USDJPY", SecurityType.FOREX, Market.OANDA)
        ]
        self.add_universe_selection(ManualUniverseSelectionModel(forex))
        # Using a custom alpha model to trade forex based on interest rate.
        self.add_alpha(InterestRateAlphaModel(self))
        # Equally invested in insights to dissipate capital risk evenly.
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

class InterestRateAlphaModel(AlphaModel):
    # Use a 365d SMA indicator of daily interest rate to estimate if the interest rate cycle is upward or downward.
    _sma = SimpleMovingAverage(365)

    def __init__(self, algorithm: QCAlgorithm) -> None:
        self._algorithm = algorithm

        # Warm up the SMA indicator.
        current = algorithm.time
        provider = algorithm.risk_free_interest_rate_model
        dt = current - timedelta(365)
        while dt <= current:
            rate = provider.get_interest_rate(dt)
            self._sma.update(dt, rate)
            self._was_rising = rate > self._sma.current.value
            dt += timedelta(1)

        # Set a schedule to update the interest rate trend indicator every day.
        algorithm.schedule.on(
            algorithm.date_rules.every_day(),
            algorithm.time_rules.at(0, 1),
            self.update_interest_rate
        )

    def update_interest_rate(self) -> None:
        # Update interest rate to the SMA indicator to estimate its trend.
        rate = self._algorithm.risk_free_interest_rate_model.get_interest_rate(self._algorithm.time)
        self._sma.update(self._algorithm.time, rate)
        self._was_rising = rate > self._sma.current.value

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []
        
        # Split the forexes by whether the quote currency is USD.
        quote_usd = []
        base_usd = []
        for symbol, security in algorithm.securities.items():
            if security.quote_currency.symbol == Currencies.USD:
                quote_usd.append(symbol)
            else:
                base_usd.append(symbol)

        rate = algorithm.risk_free_interest_rate_model.get_interest_rate(algorithm.time)
        # During the rising interest rate cycle, long the forexes with USD as the base currency and short the ones with USD as the quote currency.
        if rate > self._sma.current.value:
            insights.extend(
                [Insight.price(symbol, timedelta(1), InsightDirection.UP) for symbol in base_usd] + 
                [Insight.price(symbol, timedelta(1), InsightDirection.DOWN) for symbol in quote_usd]
            )
        # During the downward interest rate cycle, short the forexes with USD as the base currency and long the ones with USD as the quote currency.
        elif rate < self._sma.current.value:
            insights.extend(
                [Insight.price(symbol, timedelta(1), InsightDirection.DOWN) for symbol in base_usd] + 
                [Insight.price(symbol, timedelta(1), InsightDirection.UP) for symbol in quote_usd]
            )
        # If the interest rate cycle is steady for a long time, we expect a flip in the cycle.
        elif self._was_rising:
            insights.extend(
                [Insight.price(symbol, timedelta(1), InsightDirection.DOWN) for symbol in base_usd] + 
                [Insight.price(symbol, timedelta(1), InsightDirection.UP) for symbol in quote_usd]
            )
        else:
            insights.extend(
                [Insight.price(symbol, timedelta(1), InsightDirection.UP) for symbol in base_usd] + 
                [Insight.price(symbol, timedelta(1), InsightDirection.DOWN) for symbol in quote_usd]
            )

        return insights
```

--------------------------------

### Coinbase Algorithm Implementation

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/coinbase-crypto-price-data

A complete algorithm example showing the setup of the Coinbase brokerage model, asset subscription, historical data retrieval, and order execution logic.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Crypto _btc;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        UniverseSettings.Asynchronous = true;
        SetCash(100000);
        // Coinbase accepts Cash account type only. AccountType.Margin
        // results in an exception.
        SetBrokerageModel(BrokerageName.Coinbase, AccountType.Cash);
        // Add BTCUSD data.
        _btc = AddCrypto("BTCUSD", Resolution.Minute, Market.Coinbase);   
        // Historical data
        var history = History(_btc.Symbol, 30, Resolution.Daily);
        // Add a Crypto universe that selects trading pairs on Coinbase.
        var universe = AddUniverse(CryptoUniverse.Coinbase(SelectAssets));
        // Historical Universe data
        var universeHistory = History(universe, 30, Resolution.Daily);
        foreach (var universeDay in universeHistory)
        {
            foreach (CryptoUniverse universeItem in universeDay)
            {
                var symbol = universeItem.Symbol;
                var price = universeItem.Close;
            }
        }
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<CryptoUniverse> universeDay)
    {
        // Filter for materially traded Crypto pairs with significant 
        // size and dollar volume, assuming higher capital flow in for 
        // higher return.
        return from universeItem in universeDay
                where universeItem.Volume >= 100m 
                && universeItem.VolumeInUsd > 10000000m
                select universeItem.Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Speculate-invest all available free cash on BTCUSD, repecting 
        // the order quantity restrictions to avoid invalid orders.
        if (Portfolio.CashBook["BTC"].Amount != 0)
        {
            return;
        }
        // Define a buffer so that we can scale down the order size,
        // avoiding trading errors.
        var buffer = Math.Max(CoinbaseFeeModel.TakerAdvanced1, Settings.FreePortfolioValuePercentage);
        var quantity = Portfolio.CashBook["USD"].Amount / _btc.AskPrice * (1-buffer);
        // Check if the quantity exceeds the minimum order size. On 
        // Coinbase, the minimum order size is measured in the base 
        // currency (BTC in this case).
        if (Math.Abs(quantity) < _btc.SymbolProperties.MinimumOrderSize)
        {
            return;
        }
        MarketOrder(_btc, quantity);
    }
}
```

--------------------------------

### Framework Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/us-index-option-universe

An example of setting up the universe selection, alpha model, and portfolio construction in a QuantConnect algorithm.

```csharp
// Universe selection that select based on liquidity of the option contracts (by open interest)
AddUniverseSelection(new IndexOptionsUniverseSelectionModel());
// Custom alpha model that use Delta and Gamma to signal insights
AddAlpha(new OptionDeltaGammaAlphaModel());
// To maintain long-short size equal, use a PCM that order a single contract
SetPortfolioConstruction(new SingleSharePortfolioConstructionModel());
}
}
```

--------------------------------

### Classic Coinbase Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/coinbase-crypto-price-data

A complete algorithm implementation showing the setup of the Coinbase brokerage model, historical data retrieval, universe selection, and order execution.

```python
from AlgorithmImports import *


class CoinAPIDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.universe_settings.asynchronous = True
        self.set_cash(100_000)
        # Coinbase accepts Cash account type only. AccountType.MARGIN
        # results in an exception.
        self.set_brokerage_model(BrokerageName.COINBASE, AccountType.CASH)
        # Add BTCUSD data.
        self._btc = self.add_crypto("BTCUSD", Resolution.MINUTE, Market.COINBASE)
        # Historical data
        history = self.history(self._btc.symbol, 30, Resolution.DAILY)
        # Add a Crypto universe that selects Crypto pairs on Coinbase.
        universe = self.add_universe(CryptoUniverse.coinbase(self._select_assets))
        # Historical Universe data
        universe_history = self.history(universe, 30, Resolution.DAILY)
        for (universe_symbol, time), universe_day in universe_history.items():
            for universe_item in universe_day:
                symbol = universe_item.symbol
                price = universe_item.close

    def _select_assets(self, universe_day):
        # Filter for materially traded Crypto pairs with significant 
        # size and dollar volume, assuming higher capital flow in for 
        # higher return.
        return [universe_item.symbol for universe_item in universe_day
                if universe_item.volume >= 100 
                and universe_item.volume_in_usd > 10_000_000]

    def on_data(self, slice: Slice) -> None:
        # Speculate-invest all available free cash on BTCUSD, repecting 
        # the order quantity restrictions to avoid invalid orders.
        if self.portfolio.cash_book['BTC'].amount != 0:
            return
        # Define a buffer so that we can scale down the order size,
        # avoiding trading errors.
        buffer = max(
            CoinbaseFeeModel.TAKER_ADVANCED_1, 
            self.settings.free_portfolio_value_percentage
        )
        quantity = (
            self.portfolio.cash_book['USD'].amount
            / self._btc.ask_price
            * (1-buffer)
        )
        # Check if the quantity exceeds the minimum order size. On 
        # Coinbase, the minimum order size is measured in the base 
        # currency (BTC in this case).
        if abs(quantity) < self._btc.symbol_properties.minimum_order_size:
            return
        self.market_order(self._btc, quantity)
```

--------------------------------

### Retrieve Asset Time Zone

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/key-concepts/time-modeling/time-zones

Use the MarketHoursDatabase to get the time zone for a specific asset. The Python example uses the instance method, while the C# example uses the static method.

```python
# Get the time zone of an asset.
time_zone = self.market_hours_database.get_data_time_zone(Market.USA, self._symbol, SecurityType.EQUITY)
```

```csharp
// Get the time zone of an asset.
var timeZone = MarketHoursDatabase.GetDataTimeZone(Market.USA, _symbol, SecurityType.Equity);
```

--------------------------------

### Algorithm Initialization with Bitfinex Data

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

Example of setting up a full algorithm class with Bitfinex brokerage model and data subscription.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    
    public override void Initialize()
    {
        SetStartDate(2020, 6, 1);
        SetEndDate(2021, 6, 1);
        SetCash(100000);

        // Bitfinex accepts both Cash and Margin type account.
        SetBrokerageModel(BrokerageName.Bitfinex, AccountType.Margin);
        
        _symbol = AddCrypto("BTCUSD", Resolution.Minute, Market.Bitfinex).Symbol;
    }
}
```

--------------------------------

### Get Crypto Universe History

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/universe-data

Retrieves historical data for a cryptocurrency universe defined by Coinbase. The C# example iterates through the history to find the top gainer, while the Python example flattens the history data.

```C#
public class CryptoUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        SetEndDate(2024, 12, 31);
        // Add a universe of Cryptocurrencies.
        var universe = AddUniverse(CryptoUniverse.Coinbase(data => data.Select(x => x.Symbol)));
        // Get 5 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var universeDay in history)
        {
            var t = universeDay.EndTime;
            // Select the Crypto with the largest daily return on this day.
            var topGainer = universeDay
                .Select(c => c as CryptoUniverse)
                .OrderByDescending(c => (c.Close - c.Open) / c.Open)
                .First();
        }
    }
}
```

```python
class CryptoUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        self.set_end_date(2024, 12, 31)
        # Add a universe of Cryptocurrencies.
        universe = self.add_universe(CryptoUniverse.coinbase(lambda data: [x.symbol for x in data]))
        # Get 5 days of history for the universe.
        history = self.history(universe, timedelta(5), flatten=True)
```

--------------------------------

### Get Trading Days

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/trading-calendar

Retrieve all trading events between a start and end date using the get_trading_days method.

```python
start_date = datetime(2022, 6, 1)
end_date = datetime(2022, 7, 1)
trading_days = self.trading_calendar.get_trading_days(start_date, end_date)
```

--------------------------------

### Algorithm Initialization with Bitfinex Data

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

Example of setting up a full algorithm class with Bitfinex brokerage model and data subscription.

```python
class CoinAPIDataAlgorithm(QCAlgorithm):

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

        # Bitfinex accepts both Cash and Margin type account.
        self.set_brokerage_model(BrokerageName.BITFINEX, AccountType.MARGIN)
        
        self.btcusd = self.add_crypto("BTCUSD", Resolution.MINUTE, Market.BITFINEX).symbol
```

--------------------------------

### Get Trading Days

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/trading-calendar

Retrieve all trading events between a start and end date using the GetTradingDays method.

```csharp
var startDate = new DateTime(2022, 6, 1);
var endDate = new DateTime(2022, 7, 1);
var tradingDays = TradingCalendar.GetTradingDays(startDate, endDate);
```

--------------------------------

### Framework Algorithm Example (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

Creates a dynamic universe of Bitfinex crypto pairs and forms an equal-weighted portfolio using C#.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private List<string> _marketPairs;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        Settings.FreePortfolioValuePercentage = 0.05m;
        // Bitfinex accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.Bitfinex, AccountType.Margin);

        // Warm up the security with the last known price to avoid conversion error
        Settings.SeedInitialPrices = true;
        UniverseSettings.Asynchronous = true;
        UniverseSettings.Resolution = Resolution.Minute;
        // Add Crypto Universe Selection that select crypto pairs in Bitfinex exchange            
        AddUniverse(CryptoUniverse.Bitfinex(SelectAssets));
        // Get the pairs on Bitfinex that have USD as the quote currency.
        _marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(Market.Bitfinex)
            .Where(x => x.Value.QuoteCurrency == AccountCurrency)
            .Select(x => x.Key.Symbol)
            .ToList();
        AddAlpha( new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromHours(4), 0.025, null) );
        // Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<CryptoUniverse> universeDay)
    {
        // Select pairs where the quote currency is USD.
        return universeDay.Where(c => _marketPairs.Contains(c.Symbol.Value))
            // Filter for materially traded crypto pairs with significant size and dollar volume, assuming higher capital flow in for higher return
            .OrderBy(c => c.VolumeInUsd)
            .TakeLast(3)
            .Select(c => c.Symbol);
    }

    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        foreach(var security in changes.AddedSecurities)
        {
            // Historical data
            var history = History(security.Symbol, 30, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
        }
    }
}
```

--------------------------------

### Getting Started with Upcoming IPOs

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/eod-historical-data/upcoming-ipos

Demonstrates how to add the Upcoming IPOs dataset to an algorithm using AddData or AddUniverse.

```python
self.add_data(EODHDUpcomingIPOs, "ipos")
self.add_universe(EODHDUpcomingIPOs, self.selection_function)
```

```csharp
AddData<EODHDUpcomingIPOs>("ipos");
AddUniverse<EODHDUpcomingIPOs>(SelectionFunction);
```

--------------------------------

### Classic Binance US Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/binance-us-crypto-price-data

A comprehensive example showing how to set up a Binance US brokerage model, add crypto assets, and manage orders while respecting account currency and fee constraints.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Crypto _btc;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        // Set USDT as the account currency so we can trade BTCUSDT.
        SetAccountCurrency("USDT", 100000);
        UniverseSettings.Asynchronous = true;
        // Binance US accepts Cash account type only. AccountType.Margin
        // results in an exception.
        SetBrokerageModel(BrokerageName.BinanceUS, AccountType.Cash);
        // Add BTCUSDT data.
        _btc = AddCrypto("BTCUSDT", Resolution.Minute, Market.BinanceUS);   
        // Historical data
        var history = History(_btc.Symbol, 30, Resolution.Daily);
        // Add a Crypto universe that selects trading pairs on Binance US.
        var universe = AddUniverse(CryptoUniverse.BinanceUS(SelectAssets));
        // Historical Universe data
        var universeHistory = History(universe, 30, Resolution.Daily);
        foreach (var universeDay in universeHistory)
        {
            foreach (CryptoUniverse universeItem in universeDay)
            {
                var symbol = universeItem.Symbol;
                var price = universeItem.Close;
            }
        }
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<CryptoUniverse> universeDay)
    {
        // Filter for materially traded Crypto pairs with significant 
        // size and dollar volume, assuming higher capital flow in for 
        // higher return.
        return from universeItem in universeDay
                where universeItem.Volume >= 100m 
                && universeItem.VolumeInUsd > 10000000m
                select universeItem.Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Speculate-invest all available free cash on BTCUSDT, repecting 
        // the order quantity restrictions to avoid invalid orders.
        if (Portfolio.CashBook["BTC"].Amount != 0)
        {
            return;
        }
        // Define a buffer so that we can scale down the order size,
        // avoiding trading errors.
        var buffer = Math.Max(BinanceFeeModel.TakerTier1Fee, Settings.FreePortfolioValuePercentage);
        var quantity = Portfolio.CashBook["USDT"].Amount / _btc.AskPrice * (1-buffer);
        // Check if the quantity exceeds the minimum order size. On 
        // Binance US, the minimum order size is measured in the quote 
        // currency (USDT in this case).
        var minimumOrderSize = _btc.SymbolProperties.MinimumOrderSize / _btc.AskPrice;
        if (Math.Abs(quantity) < minimumOrderSize)
        {
            return;
        }
        MarketOrder(_btc, quantity);
    }
}
```

--------------------------------

### Framework Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/extractalpha/true-beats

Initializes the algorithm with True Beats data, sets up a universe, and adds the alpha model.

```python
def initialize(self) -> None:
    self.set_start_date(2024, 9, 1)
    self.set_end_date(2024, 9, 30)
    self.set_cash(100_000)
    # Seed the price of each asset with its last known price to avoid trading errors.
    self.settings.seed_initial_prices = True
    # Add a universe that runs at the start of each month.
    spy = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
    date_rule = self.date_rules.month_start(spy)
    self.universe_settings.schedule.on(date_rule)
    self.add_universe_selection(LiquidEquitiesUniverseSelectionModel())
    # Custom alpha model to trade based on true beats data signals
    self.add_alpha(ExtractAlphaTrueBeatsAlphaModel())
    # Invest equally and dollar-neutral to evenly dissipate capital risk and hedge systematic risk
    self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
    self.set_execution(ImmediateExecutionModel())
```

--------------------------------

### Get Average Risk-Free Rate for a Time Window

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/reality-modeling/risk-free-interest-rate/key-concepts

Retrieve the average risk-free interest rate over a specified time window using start and end dates.

```C#
public override void OnData(Slice slice)
{
	var avgRiskFreeInterestRate = RiskFreeInterestRateModel.GetRiskFreeRate(Time.AddDays(-30), Time);
}
```

```Python
def on_data(self, slice: Slice) -> None:
	avg_risk_free_interest_rate = RiskFreeInterestRateModelExtensions.get_risk_free_rate(
		self.risk_free_interest_rate_model, 
		self.time-timedelta(7), self.time
	)
```

--------------------------------

### Get Historical Universe Data in Research (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/eod-historical-data/upcoming-ipos

Call the History method with the Universe object, start date, and end date to retrieve historical data.

```csharp
var universeHistory = qb.History(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var ipos in universeHistory)
{
    foreach (EODHDUpcomingIPOs ipo in ipos)
    {
        Console.WriteLine($"{ipo.Symbol} offer price at {ipo.IpoDate}: {ipo.OfferPrice}");
    }
}
```

--------------------------------

### Framework Algorithm Example (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

Creates a dynamic universe of Bitfinex crypto pairs and forms an equal-weighted portfolio using Python.

```python
from AlgorithmImports import *


class CoinAPIDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        self.settings.free_portfolio_value_percentage = 0.05
        # Bitfinex accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BITFINEX, AccountType.MARGIN)

        # Warm up the security with the last known price to avoid conversion error
        self.settings.seed_initial_prices = True
        self.universe_settings.asynchronous = True
        self.universe_settings.resolution = Resolution.MINUTE
        # Add Crypto Universe Selection that select crypto pairs in Bitfinex exchange
        self.add_universe(CryptoUniverse.bitfinex(self._select_assets))
        # Get the pairs on Bitfinex that have USD as the quote currency.
        self._market_pairs = [
            x.key.symbol 
            for x in self.symbol_properties_database.get_symbol_properties_list(Market.BITFINEX) 
            if x.value.quote_currency == self.account_currency
        ]
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(hours=4), 0.025, None))
        # Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

    def _select_assets(self, universe_day: List[CryptoUniverse]) -> List[Symbol]:
        # Select pairs where the quote currency is USD.
        pairs = [c for c in universe_day if c.symbol.value in self._market_pairs]
        # Filter for materially traded crypto pairs with significant dollar volume, assuming higher capital flow in for higher return.
        pairs = sorted(pairs, key=lambda c: c.volume_in_usd)[-3:]      
        return [c.symbol for c in pairs]

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # Historical data
            history = self.history(security.symbol, 30, Resolution.DAILY)
            self.debug(f"We got {len(history)} items from our history request")
```

--------------------------------

### Fine Tuning Chronos-T5

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/machine-learning/hugging-face/popular-models/chronos-t5

This example demonstrates the complete workflow for fine-tuning a Chronos-T5 model, including logging setup, dataset filtering, model configuration, and training execution.

```python
# Set up logging for the train object.
train.logger = getLogger()
train.logger.setLevel(INFO)
# Ensure output_dir is a Path object.
output_dir = Path(output_dir)
# Convert probability from string to a list, or set default if 
# None.
if isinstance(probability, str):
    probability = literal_eval(probability)
elif probability is None:
    probability = [1.0 / len(training_data)] * len(training_data)
# Convert tokenizer_kwargs from string to a dictionary.
if isinstance(tokenizer_kwargs, str):
    tokenizer_kwargs = literal_eval(tokenizer_kwargs)
# Enable reproducibility.
set_seed(1, True)
# Create datasets for training, filtered by criteria.
train_datasets = [
    Filter(
        partial(
            has_enough_observations,
            min_length=min_past + prediction_length,
            max_missing_prop=max_missing_prop,
        ),
        PandasDataset(data_frame, freq="D"),
    )
    for data_frame in training_data
]
# Load the model with the specified configuration.
model = load_model(
    model_id=model_id,
    model_type=model_type,
    vocab_size=n_tokens,
    random_init=random_init,
    tie_embeddings=tie_embeddings,
    pad_token_id=pad_token_id,
    eos_token_id=eos_token_id,
)
# Define the configuration for the Chronos 
# tokenizer and other settings.
chronos_config = ChronosConfig(
    tokenizer_class=tokenizer_class,
    tokenizer_kwargs=tokenizer_kwargs,
    n_tokens=n_tokens,
    n_special_tokens=n_special_tokens,
    pad_token_id=pad_token_id,
    eos_token_id=eos_token_id,
    use_eos_token=use_eos_token,
    model_type=model_type,
    context_length=context_length,
    prediction_length=prediction_length,
    num_samples=num_samples,
    temperature=temperature,
    top_k=top_k,
    top_p=top_p,
)

# Add extra items to model config so that 
# it's saved in the ckpt.
model.config.chronos_config = chronos_config.__dict__
# Create a shuffled training dataset with the 
# specified parameters.
shuffled_train_dataset = ChronosDataset(
    datasets=train_datasets,
    probabilities=probability,
    tokenizer=chronos_config.create_tokenizer(),
    context_length=context_length,
    prediction_length=prediction_length,
    min_past=min_past,
    mode="training",
).shuffle(shuffle_buffer_length=shuffle_buffer_length)

# Define the training arguments.
training_args = TrainingArguments(
    output_dir=str(output_dir),
    per_device_train_batch_size=per_device_train_batch_size,
    learning_rate=learning_rate,
    lr_scheduler_type=lr_scheduler_type,
    warmup_ratio=warmup_ratio,
    optim=optim,
    logging_dir=str(output_dir / "train-logs"),
    logging_strategy="steps",
    logging_steps=log_steps,
    save_strategy="steps",
    save_steps=save_steps,
    report_to=["tensorboard"],
    max_steps=max_steps,
    gradient_accumulation_steps=gradient_accumulation_steps,
    dataloader_num_workers=dataloader_num_workers,
    tf32=tf32,  # remove this if not using Ampere GPUs (e.g., A100)
    torch_compile=torch_compile,
    ddp_find_unused_parameters=False,
    remove_unused_columns=False,
)

# Create a Trainer instance for training the model.
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=shuffled_train_dataset,
)
# Start the training process.
trainer.train()
# Save the trained model to the output directory.
model.save_pretrained(output_dir)
# Return the path to the output directory.
return output_dir
```

--------------------------------

### Framework Algorithm Example for Short Availability

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/us-equities-short-availability

This example demonstrates setting up a manual universe, using a ConstantAlphaModel to emit short insights, and implementing a custom ShortableExecutionModel with an InteractiveBrokersShortableProvider.

```python
from AlgorithmImports import *


class ShortAvailabilityDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(1000)
        # Seed the security price as the last known price, such that the price data is immediately available at initial rebalance
        self.settings.seed_initial_prices = True

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

        # Emit down-direction insights to short all securities in the universe            
        self.set_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.DOWN, timedelta(1)))
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        self.set_execution(ShortableExecutionModel())

    # On Margin Call, emit flat-direction insights to liquidate the positions
    def on_margin_call_warning(self) -> None:
        self.emit_insights([Insight.price(kvp.key, timedelta(1), InsightDirection.FLAT)
            for kvp in self.securities if kvp.value.invested])

    def _custom_security_initializer(self, security: Security) -> None:
        # Set the shortable provider as IB
        security.set_shortable_provider(InteractiveBrokersShortableProvider())

class ShortableExecutionModel(ExecutionModel):
    def __init__(self) -> None:
        self.targets_collection = PortfolioTargetCollection()

    def execute(self, algorithm: QCAlgorithm, targets: List[PortfolioTarget]) -> None:
        '''Immediately submits orders for the specified portfolio targets.
        Args:
            algorithm: The algorithm instance
            targets: The portfolio targets to be ordered'''

        # for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
        self.targets_collection.add_range(targets)
        if self.targets_collection.count > 0:
            for target in self.targets_collection.order_by_margin_impact(algorithm):
                # calculate remaining quantity to be ordered
                quantity = OrderSizing.get_unordered_quantity(algorithm, target)
                # If the quantity is negative, ensure that the security is shortable
                if quantity > 0 or algorithm.shortable(target.symbol, quantity):
                    algorithm.market_order(target.symbol, quantity)

            self.targets_collection.clear_fulfilled(algorithm)
```

--------------------------------

### Bitfinex Crypto Algorithm Implementation

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

This example demonstrates setting up a Bitfinex brokerage model, adding crypto assets, performing historical data lookups, and implementing a universe selection filter.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Crypto _btc;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        UniverseSettings.Asynchronous = true;
        SetCash(100000);
        // Bitfinex accepts both Cash and Margin account types. Select the
        // one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.Bitfinex, AccountType.Margin);
        // Add BTCUSD data.
        _btc = AddCrypto("BTCUSD", Resolution.Minute, Market.Bitfinex);   
        // Historical data
        var history = History(_btc.Symbol, 30, Resolution.Daily);
        // Add a Crypto universe that selects trading pairs on Bitfinex.
        var universe = AddUniverse(CryptoUniverse.Bitfinex(SelectAssets));
        // Historical Universe data
        var universeHistory = History(universe, 30, Resolution.Daily);
        foreach (var universeDay in universeHistory)
        {
            foreach (CryptoUniverse universeItem in universeDay)
            {
                var symbol = universeItem.Symbol;
                var price = universeItem.Close;
            }
        }
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<CryptoUniverse> universeDay)
    {
        // Filter for materially traded Crypto pairs with significant 
        // size and dollar volume, assuming higher capital flow in for 
        // higher return.
        return from universeItem in universeDay
                where universeItem.Volume >= 100m 
                && universeItem.VolumeInUsd > 10000000m
                select universeItem.Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Speculate-invest all available free cash on BTCUSD, repecting 
        // the order quantity restrictions to avoid invalid orders.
        if (Portfolio.CashBook["BTC"].Amount != 0)
        {
            return;
        }
        // Define a buffer so that we can scale down the order size,
        // avoiding trading errors.
        var buffer = Math.Max(BitfinexFeeModel.TakerFee, Settings.FreePortfolioValuePercentage);
        var quantity = Portfolio.CashBook["USD"].Amount / _btc.AskPrice * (1-buffer);
        // Check if the quantity exceeds the minimum order size. On 
        // Bitfinex, the minimum order size is measured in the base
        // currency (BTC in this case).
        if (Math.Abs(quantity) < _btc.SymbolProperties.MinimumOrderSize)
        {
            return;
        }
        MarketOrder(_btc, quantity);
    }
}
```

--------------------------------

### Classic Algorithm Example -- FESX Futures

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/tickdata/international-futures

A complete algorithm implementation for trading EURO STOXX 50 futures, including indicator setup and rollover logic.

```python
from AlgorithmImports import *


class InternationalFuturesDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        # Set the time zone to Berlin to make it more comparable with the exchange.
        self.set_time_zone(TimeZones.BERLIN)
        # Set the account currency as EUR to trade FSX Futures.
        self.set_account_currency("EUR", 1000000)
        # Seed the last price of the contracts for filling.
        self.settings.seed_initial_prices = True

        # Request FESX Futures to trade. 
        # Note that we will trade the contract with the highest open interest for liquidity.
        self.fesx_future = self.add_future(
            Futures.Indices.EURO_STOXX_50,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.LAST_TRADING_DAY,
            contract_depth_offset=0
        )
        # Request the corresponding underlying Index for feeding indicator for trade signal generation.
        fesx_index = self.add_index("SX5E").symbol

        # Create a MACD indicator to trade EuroStoxx trend changes on the fast-slow term trend convergence.
        self._macd = self.macd(fesx_index, 12, 26, 9, resolution=Resolution.DAILY)
        # Warm up indicator for immediate readiness to trade.
        self.warm_up_indicator(fesx_index, self._macd, Resolution.DAILY)

    def on_data(self, slice: Slice) -> None:
        # Only place trade if the Future contracts is in market opening hours to avoid stale fills.
        if self.is_market_open(self.fesx_future.symbol) and self._macd.is_ready:
            # To identify a sensitive change in trend, use the change in the histogram value of the MACD.
            histogram = self._macd.histogram
            histogram_chg = histogram.current.value - histogram.previous.value
            # Positive histogram value increasing means the fast trend is rising faster than the slow trend, indicating a strong uptrend.
            if histogram_chg > 0 and histogram.current.value > 0 and not self.portfolio[self.fesx_future.symbol].is_long:
                self.set_holdings(self.fesx_future.mapped, 0.2)
            # Negative histogram value decreasing means the slow trend is dropping faster than the fast trend, indicating a strong downtrend.
            elif histogram_chg < 0 and histogram.current.value < 0 and not self.portfolio[self.fesx_future.symbol].is_short:
                self.set_holdings(self.fesx_future.mapped, -0.2)

        # Handle rollover in case the current mapped contract changes.
        for _, changed_event in slice.symbol_changed_events.items():
            old_symbol = changed_event.old_symbol
            new_symbol = self.add_future_contract(changed_event.new_symbol).symbol
            quantity = self.portfolio[old_symbol].quantity
            # Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
            self.liquidate(old_symbol)
            if quantity != 0:
                self.market_order(new_symbol, quantity)
```

--------------------------------

### Classic Kraken Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/kraken-crypto-price-data

This example demonstrates setting up a Kraken brokerage model, adding BTCUSD data, using historical data, and filtering a crypto universe.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Crypto _btc;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        UniverseSettings.Asynchronous = true;
        SetCash(100000);
        // Kraken accepts both Cash and Margin account types. Select the
        // one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.Kraken, AccountType.Margin);
        // Add BTCUSD data.
        _btc = AddCrypto("BTCUSD", Resolution.Minute, Market.Kraken);   
        // Historical data
        var history = History(_btc.Symbol, 30, Resolution.Daily);
        // Add a Crypto universe that selects trading pairs on Kraken.
        var universe = AddUniverse(CryptoUniverse.Kraken(SelectAssets));
        // Historical Universe data
        var universeHistory = History(universe, 30, Resolution.Daily);
        foreach (var universeDay in universeHistory)
        {
            foreach (CryptoUniverse universeItem in universeDay)
            {
                var symbol = universeItem.Symbol;
                var price = universeItem.Close;
            }
        }
    }

    private IEnumerable<Symbol> SelectAssets(IEnumerable<CryptoUniverse> universeDay)
    {
        // Filter for materially traded Crypto pairs with significant 
        // size and dollar volume, assuming higher capital flow in for 
        // higher return.
        return from universeItem in universeDay
                where universeItem.Volume >= 100m 
                && universeItem.VolumeInUsd > 10000000m
                select universeItem.Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Speculate-invest all available free cash on BTCUSD, repecting 
        // the order quantity restrictions to avoid invalid orders.
        if (Portfolio.CashBook["BTC"].Amount != 0)
        {
            return;
        }
        // Define a buffer so that we can scale down the order size,
        // avoiding trading errors.
        var buffer = Math.Max(KrakenFeeModel.TakerTier1CryptoFee, Settings.FreePortfolioValuePercentage);
        var quantity = Portfolio.CashBook["USD"].Amount / _btc.AskPrice * (1-buffer);
        // Check if the quantity exceeds the minimum order size. On 
        // Kraken, the minimum order size is measured in the base 
        // currency (BTC in this case).
        if (Math.Abs(quantity) < _btc.SymbolProperties.MinimumOrderSize)
        {
            return;
        }
        MarketOrder(_btc, quantity);
    }
}
```

--------------------------------

### Initializing Cash Index Algorithm

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/cash-indices

Shows how to set up an algorithm and add an index subscription within the Initialize method.

```python
class CashIndexAlgorithm(QCAlgorithm):

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

        self.vix = self.add_index("VIX").symbol
```

```csharp
public class CashIndexAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    
    public override void Initialize()
    {
        SetStartDate(2020, 6, 1);
        SetEndDate(2021, 6, 1);
        SetCash(100000);
        
        _symbol = AddIndex("VIX").Symbol;
    }
}
```

--------------------------------

### Classic Algorithm Example for Bitfinex

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/bitfinex-crypto-price-data

A Python algorithm that buys and holds Bitcoin on the Bitfinex exchange, demonstrating brokerage model setup, universe selection, and order execution.

```python
from AlgorithmImports import *


class CoinAPIDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.universe_settings.asynchronous = True
        self.set_cash(100_000)
        # Bitfinex accepts both Cash and Margin account types. Select the
        # one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BITFINEX, AccountType.MARGIN)
        # Add BTCUSD data.
        self._btc = self.add_crypto("BTCUSD", Resolution.MINUTE, Market.BITFINEX)
        # Historical data
        history = self.history(self._btc.symbol, 30, Resolution.DAILY)
        # Add a Crypto universe that selects Crypto pairs on Bitfinex.
        universe = self.add_universe(CryptoUniverse.bitfinex(self._select_assets))
        # Historical Universe data
        universe_history = self.history(universe, 30, Resolution.DAILY)
        for (universe_symbol, time), universe_day in universe_history.items():
            for universe_item in universe_day:
                symbol = universe_item.symbol
                price = universe_item.close

    def _select_assets(self, universe_day):
        # Filter for materially traded Crypto pairs with significant 
        # size and dollar volume, assuming higher capital flow in for 
        # higher return.
        return [universe_item.symbol for universe_item in universe_day
                if universe_item.volume >= 100 
                and universe_item.volume_in_usd > 10_000_000]

    def on_data(self, slice: Slice) -> None:
        # Speculate-invest all available free cash on BTCUSD, repecting 
        # the order quantity restrictions to avoid invalid orders.
        if self.portfolio.cash_book['BTC'].amount != 0:
            return
        # Define a buffer so that we can scale down the order size,
        # avoiding trading errors.
        buffer = max(
            BitfinexFeeModel.TAKER_FEE, 
            self.settings.free_portfolio_value_percentage
        )
        quantity = (
            self.portfolio.cash_book['USD'].amount
            / self._btc.ask_price
            * (1-buffer)
        )
        # Check if the quantity exceeds the minimum order size. On 
        # Bitfinex, the minimum order size is measured in the base
        # currency (BTC in this case).
        if abs(quantity) < self._btc.symbol_properties.minimum_order_size:
            return
        self.market_order(self._btc, quantity)
```

--------------------------------

### Framework Algorithm Example (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/binance-us-crypto-price-data

An example algorithm that creates a dynamic universe of Crypto pairs on the Binance US exchange and forms an equal-weighted portfolio.

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Symbol _btcusd;
    private List<string> _marketPairs;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(1000000);
        Settings.FreePortfolioValuePercentage = 0.05m;
        // Warm up the security with the last known price to avoid conversion error
        Settings.SeedInitialPrices = true;
        UniverseSettings.Asynchronous = true;
        UniverseSettings.Resolution = Resolution.Minute;
        // Add Crypto Universe Selection that select crypto pairs in BinanceUS exchange
        AddUniverse(CryptoUniverse.BinanceUS(UniverseSelectionFilter));
        // Get the pairs on Binance US that have USD as the quote currency.
        _marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(Market.BinanceUS)
            .Where(x => x.Value.QuoteCurrency == AccountCurrency)
            .Select(x => x.Key.Symbol)
            .ToList();
        AddAlpha( new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromMinutes(20), 0.025, null) );
        // Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
    }

    private IEnumerable<Symbol> UniverseSelectionFilter(IEnumerable<CryptoUniverse> universeDay)
    {
        // Select pairs where the quote currency is USD.
        return universeDay.Where(c => _marketPairs.Contains(c.Symbol.Value))
            // Filter for materially traded crypto pairs with significant size and dollar volume, assuming higher capital flow in for higher return
            .OrderBy(c => c.VolumeInUsd)
            .TakeLast(3)
            .Select(c => c.Symbol);
    }

    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        foreach(var security in changes.AddedSecurities)
        {
            // Historical data
            var history = History(security.Symbol, 30, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
        }
    }
}
```
Tokens:
Raw