QuantConnect

https://www.quantconnect.com/docs
Admin
QuantConnect is an open-source, cloud-based algorithmic trading platform powered by LEAN, supporting...
Tokens:1,994,819
Snippets:16,629
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### COS Method: Full Example Setup and Calculation

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/equity-options/universes

Demonstrates the complete setup for the COS method, including parameter calculation and option delta computation. It visualizes the results against actual data.

```python
# Number of terms in the series expansion, the higher the more accurate.
N = 50  
# Underlying asset price
S = atm_call[1].underlying
# Number of fractional years till expiry.
T = (expiry - date + timedelta(1)).total_seconds() / 60 / 60 / 24 / 365.25
# Get the interest rate and dividend yield to calculate the discount rate.
r = np.log(1 + InterestRateProvider().get_interest_rate(date))      # continuous transformation
q = DividendYieldProvider(equity_symbol).get_dividend_yield(date)

c1 = r - q              # under risk-neutral measure
c2 = T * iv**2          # Brownian variance
c4 = 0                  # Placeholder for additional variance (not used in this context)
L = 10                  # Parameter for the bounds

# Calculate bounds for the COS method.
b1 = c1 - L * np.sqrt(c2 + np.sqrt(c4))  # Lower bound
b2 = c1 + L * np.sqrt(c2 + np.sqrt(c4))  # Upper bound

# Calculate the put option price using the COS method.
option_delta = option_delta(N + 1, b1, b2, b1, 0, S, strikes, r, iv, T)

history_df.index = [x.id.strike_price for x in history_df.index]
ax = history_df.delta.plot(title="Delta calculation using COS method", xlabel="strike", ylabel="delta", label="actual", legend=True)
ax.plot(history_df.index, option_delta, label="COS")
ax.legend()
```

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

### Algorithm Initialization

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

Full algorithm setup including start date, cash, and data subscription.

```python
class ExtractAlphaTacticalModelDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(ExtractAlphaTacticalModel, self.aapl).symbol
```

```csharp
public class ExtractAlphaTacticalModelDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol, _datasetSymbol;

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

        _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
        _datasetSymbol = AddData<ExtractAlphaTacticalModel>(_symbol).Symbol;
    }
}
```

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

### Get Trading Days

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

Retrieve all trading events within a specified date range using start and end dates.

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

```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)
```

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

### Classic Bybit Algorithm Example

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

Demonstrates setting up a Bybit brokerage model, adding crypto assets, and executing market orders with fee considerations.

```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)
        # Set the account currency to USDT, since you can't trade with 
        # USD and the algorithm doesn't automatically convert USD & USDT
        # holdings.
        self.set_account_currency("USDT", 100_000)
        self.universe_settings.asynchronous = True
        # Bybit accepts both Cash and Margin account types. Select the
        # one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BYBIT, AccountType.MARGIN)
        # Add BTCUSDT data.
        self._btc = self.add_crypto("BTCUSDT", Resolution.MINUTE, Market.BYBIT)
        # Historical data
        history = self.history(self._btc.symbol, 30, Resolution.DAILY)
        # Add a Crypto universe that selects trading pairs on Bybit.
        universe = self.add_universe(CryptoUniverse.bybit(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 BTCUSDT, 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(
            BybitFeeModel.TAKER_NON_VIP_FEE, 
            self.settings.free_portfolio_value_percentage
        )
        quantity = (
            self.portfolio.cash_book['USDT'].amount
            / self._btc.ask_price
            * (1-buffer)
        )
        # Check if the quantity exceeds the minimum order size. On 
        # Bybit, 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)
```

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

### Initializing Cash Index Subscriptions

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

Full algorithm initialization example showing how to set up a cash 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;
    }
}
```

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

### Getting Started with US Congress Trading

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quiver-quantitative/us-congress-trading

Demonstrates how to add the dataset to an algorithm using both individual equity data and universe selection.

```python
self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
self.dataset_symbol = self.add_data(QuiverCongress, self.aapl).symbol

self._universe = self.add_universe(QuiverQuantCongressUniverse, self.universe_selection)
```

```csharp
_symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
_datasetSymbol = AddData<QuiverCongress>(_symbol).Symbol;

_universe = AddUniverse<QuiverQuantCongresssUniverse>(UniverseSelection);
```

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

### Machine Trading Example Setup

Source: https://www.quantconnect.com/docs/v2/research-environment/machine-learning/popular-libraries/stable-baselines

This example demonstrates setting up a research environment for machine trading using Stable Baselines3. It involves importing necessary libraries, initializing QuantBook, requesting historical data for multiple symbols, and preparing features and labels.

```Python
# Import the gym and stable_baselines3 library.
import gym
from stable_baselines3 import PPO
from stable_baselines3.common.vec_env import DummyVecEnv, VecNormalize

# Instantiate the QuantBook for researching.
qb = QuantBook()
# Request the daily history with the date range to be studied.
symbols = [
    qb.add_equity("SPY", Resolution.DAILY).symbol,
    qb.add_equity("GLD", Resolution.DAILY).symbol,
    qb.add_equity("TLT", Resolution.DAILY).symbol,
    qb.add_equity("USO", Resolution.DAILY).symbol,
    qb.add_equity("UUP", Resolution.DAILY).symbol
]
df = qb.history(symbols, datetime(2010, 1, 1), datetime(2024, 1, 1))

# Obtain the daily partial differencing to be the features and labels.
history = df.unstack(0)
# Select weight 0.5 here. Ideally, strike a balance between variance retained and stationarity.
partial_diff = (history.diff() * 0.5 + history * 0.5).iloc[1:].fillna(0)
history = history.close.iloc[1:]

# Split the data for training and testing to evaluate the model.
X_train = partial_diff.iloc[:-100].values
X_test = partial_diff.iloc[-100:].values
y_train = history.iloc[:-100].values
y_test = history.iloc[-100:].values
```

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

### Framework Algorithm Example for Binance

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

Demonstrates how to set up a Binance crypto universe, filter pairs by quote currency, and implement an equal-weighting portfolio model.

```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)
        # Set Account Currency to Tether, since USD and USDT will not auto-convert and USD cannot be used to trade
        self.set_account_currency("USDT", 100000)
        self.settings.free_portfolio_value_percentage = 0.05

        # Binance accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BINANCE, 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 Binance exchange
        self.add_universe(CryptoUniverse.binance(self.universe_selection_filter))
        # Get the pairs on Binance that have USDT as the quote currency.
        self._market_pairs = [
            x.key.symbol 
            for x in self.symbol_properties_database.get_symbol_properties_list(Market.BINANCE) 
            if x.value.quote_currency == self.account_currency
        ]
        
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(minutes = 20), 0.025, None))
        # Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

    def universe_selection_filter(self, universe_day: List[CryptoUniverse]) -> List[Symbol]:
        # Select pairs where the quote currency is USDT.
        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)
```

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private List<string> _marketPairs;
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        Settings.FreePortfolioValuePercentage = 0.05m;

        // Set Account Currency to Tether, since USD and USDT will not auto-convert and USD cannot be used to trade
        SetAccountCurrency("USDT", 100000);
        // Binance accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.Binance, 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 Binance exchange
        AddUniverse(CryptoUniverse.Binance(UniverseSelectionFilter));
        // Get the pairs on Binance that have USDT as the quote currency.
        _marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(Market.Binance)
            .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 USDT.
        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);
        }
    }
}
```

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

### 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

Calculate the average risk-free interest rate over a specified start and end date range.

```csharp
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
	)
```

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

### Binance US Crypto Algorithm Example

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

Demonstrates setting up a Binance US brokerage model, adding crypto assets, and handling order execution with fee buffers.

```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);
    }
}
```

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

### Requesting Historical Data by Defined Period (Python)

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/key-concepts

Examples of retrieving historical data for a specific start and end time range using Python.

```python
# EXAMPLE 5: Requesting By a Defined Period: 3 days of data at the security resolution: 
start_time = datetime(2022, 1, 1)
end_time = datetime(2022, 1, 4)

vix_data = qb.history[CBOE](vix_symbol, start_time, end_time) 
trade_bars = qb.history[TradeBar](btc_symbol, start_time, end_time) 
quote_bars = qb.history[QuoteBar](btc_symbol, start_time, end_time)
ticks = qb.history[Tick](eth_symbol, start_time, end_time)

trade_bars_df = qb.history(TradeBar, btc_symbol, start_time, end_time)
quote_bars_df = qb.history(QuoteBar, btc_symbol, start_time, end_time)
ticks_df = qb.history(Tick, eth_symbol, start_time, end_time)
df = qb.history(btc_symbol, start_time, end_time)  # Includes trade and quote data
```

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

### Initialize QuantBook in Research

Source: https://www.quantconnect.com/docs/v2/research-environment/object-store

Setup the Research Environment to access the Object Store.

```C#
// Execute the following command in first
#load "../Initialize.csx"
```

```C#
// Load the necessary assembly files.
#load "../QuantConnect.csx"
```

```C#
using QuantConnect;
using QuantConnect.Research;

var qb = new QuantBook();
```

```Python
qb = QuantBook()
```

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

### Read Project Request Example

Source: https://www.quantconnect.com/docs/v2/cloud-platform/api-reference/project-management/read-project

JSON payload for requesting project details. Provide either a projectId or a range using start and end indices.

```json
{
  "projectId": 23456789,
  "start": 0,
  "end": 100
}
```

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

### Initialize Algorithm

Source: https://www.quantconnect.com/docs/v2/research-environment/applying-research/pca-and-pairs-trading

Set up the backtest parameters including start date, brokerage model, cash, and benchmark.

```python
def initialize(self) -> None:

    #1. Required: Five years of backtest history
    self.set_start_date(2014, 1, 1)

    #2. Required: Alpha Streams Models:
    self.set_brokerage_model(BrokerageName.ALPHA_STREAMS)

    #3. Required: Significant AUM Capacity
    self.set_cash(1000000)

    #4. Required: Benchmark to SPY
    self.set_benchmark("SPY")
```

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

### Bybit Framework Algorithm

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

Demonstrates setting up a framework algorithm for Bybit, including account currency configuration, brokerage model selection, and universe filtering.

```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)
        # Set Account Currency to Tether, since USD and USDT will not auto-convert and USD cannot be used to trade
        self.set_account_currency("USDT", 100000)
        self.settings.free_portfolio_value_percentage = 0.05

        # Bybit accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BYBIT, 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 Bybit exchange
        self.add_universe(CryptoUniverse.bybit(self.universe_selection_filter))
        # Get the pairs on Bybit that have USDT as the quote currency.
        self._market_pairs = [
            x.key.symbol 
            for x in self.symbol_properties_database.get_symbol_properties_list(Market.BYBIT) 
            if x.value.quote_currency == self.account_currency
        ]
        
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(minutes = 20), 0.025, None))
        # Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

    def universe_selection_filter(self, universe_day: List[CryptoUniverse]) -> List[Symbol]:
        # Select pairs where the quote currency is USDT.
        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")
```

```csharp
public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private List<string> _marketPairs;
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        Settings.FreePortfolioValuePercentage = 0.05m;

        // Set Account Currency to Tether, since USD and USDT will not auto-convert and USD cannot be used to trade
        SetAccountCurrency("USDT", 100000);
        // Bybit accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.Bybit, 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 Bybit exchange
        AddUniverse(CryptoUniverse.Bybit(UniverseSelectionFilter));
        // Get the pairs on Bybit that have USDT as the quote currency.
        _marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(Market.Bybit)
            .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 USDT.
        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");
        }
    }
}
```

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

### International Futures Algorithm Example

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/international-future-universe

A complete algorithm implementation for trading Hang Seng Index futures, including indicator setup and market hour checks.

```csharp
public class InternationalFuturesDataAlgorithm : QCAlgorithm
{
    private Future _hsiFuture;
    private ZigZag _zz;

    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        // Set the time zone to HKT to make it more comparable with the exchange.
        SetTimeZone(TimeZones.HongKong);
        // Set the account currency as HKD to trade HSI Futures.
        SetAccountCurrency("HKD", 1000000);

        // Seed the last price of the contracts for filling.
        Settings.SeedInitialPrices = true;

        // Request HSI Futures to trade. 
        // Note that we will trade the contract with the highest open interest for liquidity.
        _hsiFuture = AddFuture(
            Futures.Indices.HangSeng,
            extendedMarketHours: true,
            dataMappingMode: DataMappingMode.LastTradingDay,
            contractDepthOffset: 0
        );
        // Adds contracts that expiry within 90 days. We will trade the farthest contract
        _hsiFuture.SetFilter(0,90);
        // Request the corresponding underlying index for feeding indicators for trade signal generation.
        var hsiIndex = AddIndex("HSI").Symbol;

        // Create a ZigZag indicator to trade Hang Seng Index price pivot points.
        _zz = ZZ(hsiIndex, 0.15m, 5, Resolution.Daily);
        // Warm up indicator for immediate readiness to trade.
        WarmUpIndicator(hsiIndex, _zz, Resolution.Daily);
    }

    public override void OnData(Slice slice)
    {
        // Only place trade if the Future contracts is in market opening hours to avoid stale fills.
        if (IsMarketOpen(_hsiFuture.Symbol) && _zz.IsReady)
        {
            var pivot = _zz.PivotType;
            FuturesChain chain;
            // If the last pivot point is low, the current trend is increasing after this low point.
            if (pivot == PivotPointType.Low && slice.FutureChains.TryGetValue(_hsiFuture.Symbol, out chain))
            {
                var contract = chain.OrderBy(x => x.Expiry).LastOrDefault()?.Symbol;                    
                SetHoldings(contract, 0.2m);
            }
            // If the last pivot point is high, the current trend decreases after this high point.
            if (pivot == PivotPointType.High && slice.FutureChains.TryGetValue(_hsiFuture.Symbol, out chain))
            {
                var contract = chain.OrderBy(x => x.Expiry).LastOrDefault()?.Symbol;                    
                SetHoldings(contract, -0.2m);
            }
        }
    }
}
```

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

### Deploy a live algorithm with IQFeed

Source: https://www.quantconnect.com/docs/v2/lean-cli/datasets/iqfeed

Use this command to initiate a live deployment using IQFeed as the data provider and a specified brokerage.

```bash
$ lean live deploy "My Project" --data-provider-live IQFeed --iqfeed-username username --iqfeed-password password --brokerage "Paper Trading"
```

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

### Manual Implied Volatility Indicator Implementation

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/future-options/greeks-and-implied-volatility/indicators

This example shows the setup of a dividend yield provider, contract filtering, and the manual update process for Implied Volatility indicators in C#.

```csharp
// Set up dividend yield provider for the underlying
        _dividendYieldProvider = new ConstantDividendYieldModel(0m);
        
        // Set up a Scheduled Event to select contract and create the indicators every day before market open.
        Schedule.On(
            DateRules.EveryDay(_future.Symbol),
            TimeRules.At(9, 0),
            UpdateContractsAndGreeks
        );
    }

    private void UpdateContractsAndGreeks()
    {
        if (_future.Mapped == null)
        {
            return;
        }
        // Get all the tradable Option contracts.
        var chain = OptionChain(_future.Mapped);
        
        // Filter the contracts down. For example, ATM contracts with atleast 1 month until expiry.
        var filteredChain = chain.Where(contract => contract.Expiry > Time.AddDays(30));
        if (filteredChain.Count() == 0)
        {
            return;
        }
        var expiry = filteredChain.Min(contract => contract.Expiry);
        filteredChain = filteredChain.Where(contract => contract.Expiry == expiry);
        
        var minStrikeDelta = filteredChain.Min(contract => Math.Abs(contract.Strike - contract.UnderlyingLastPrice));
        filteredChain = filteredChain.Where(contract => Math.Abs(contract.Strike - contract.UnderlyingLastPrice) == minStrikeDelta);

        // Group the contracts into call/put pairs.
        foreach (var group in filteredChain.GroupBy(contract => contract.Strike))
        {
            var contracts = group.ToList();
            if (contracts.Count > 1)
            {
                // Subscribe to both contracts.
                var contract1 = AddFutureOptionContract(contracts[0]);
                var contract2 = AddFutureOptionContract(contracts[1]);

                // Create and save the manual ImpliedVolatility indicators.
                foreach (var (contractA, contractB) in new[] { (contract1, contract2), (contract2, contract1) })
                {
                    var option = contractA as dynamic;
                    option.ImpliedVolatility = new ImpliedVolatility(
                            contractA.Symbol, RiskFreeInterestRateModel, _dividendYieldProvider, 
                            contractB.Symbol, _optionPricingModel
                        );
                }

                _options = (contracts[0], contracts[1]);
            }
        }
    }

    public override void OnData(Slice slice)
    {
        foreach (var (canonical, chain) in slice.OptionChains)
        {
            foreach (var option in chain)
            {
                var indicator = (Securities[option] as dynamic).ImpliedVolatility;
                var underlying = option.Symbol.Underlying;
                var mirror = QuantConnect.Symbol.CreateOption(
                    underlying.Value, option.ID.Market, option.ID.OptionStyle, 
                    option.ID.OptionRight == OptionRight.Call ? OptionRight.Put : OptionRight.Call, 
                    option.ID.StrikePrice, option.ID.Date
                ).Value;
                
                // Check if price data is available for both contracts and the underlying asset.
                var q = slice.QuoteBars;
                var b = slice.Bars;
                if (q.ContainsKey(option) && q.ContainsKey(mirror) && b.ContainsKey(underlying))
                {
                    var dataPoints = new List<IndicatorDataPoint>
                    {
                        new IndicatorDataPoint(option, q[option].EndTime, q[option].Close),
                        new IndicatorDataPoint(mirror, q[mirror].EndTime, q[mirror].Close),
                        new IndicatorDataPoint(
                            underlying, b[underlying].EndTime, b[underlying].Close
                        )
                    };
                    foreach (var dataPoint in dataPoints)
                    {
                        indicator.Update(dataPoint);
                    }

                    // Get the current value of the ImpliedVolatility indicator.
                    var value = indicator.Current.Value;
                }
            }
        }

        // Sell straddle as an example to trade.
        if (!Portfolio.Invested && _options != default)
        {
            Sell(_options.option1, 1);
            Sell(_options.option2, 1);
        }
        // Liquidate any assigned positions.
        if (_future.Mapped != null && Portfolio[_future.Mapped].Invested)
        {
            Liquidate(_future.Mapped);
        }
    }
}
```

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

### Full Algorithm Implementation

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/eurostat/macro-indicators

Complete example of initializing an algorithm and subscribing to multiple Eurostat macro indicators.

```python
class EurostatIndicatorsDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2021, 3, 31)
        self.set_cash(100000)

        self.equity = self.add_equity("SPY", Resolution.DAILY).symbol

        self.prices = self.add_data(EurostatConsumerPrices, Eurostat.Economies.GERMANY, Resolution.DAILY).symbol
        self.production = self.add_data(EurostatIndustrialProduction, Eurostat.Economies.GERMANY, Resolution.DAILY).symbol
        self.gdp = self.add_data(EurostatGrossDomesticProduct, Eurostat.Economies.GERMANY, Resolution.DAILY).symbol
```

```csharp
public class EurostatIndicatorsDataAlgorithm : QCAlgorithm
{
    private Symbol _equity, _prices, _production, _gdp;

    public override void Initialize()
    {
        SetStartDate(2018, 1, 1);
        SetEndDate(2021, 3, 31);
        SetCash(100000);

        _equity = AddEquity("SPY", Resolution.Daily).Symbol;

        _prices = AddData<EurostatConsumerPrices>(Eurostat.Economies.Germany, Resolution.Daily).Symbol;
        _production = AddData<EurostatIndustrialProduction>(Eurostat.Economies.Germany, Resolution.Daily).Symbol;
        _gdp = AddData<EurostatGrossDomesticProduct>(Eurostat.Economies.Germany, Resolution.Daily).Symbol;
    }
}
```

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

### Request Defined Time Period History

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/custom-data

Use the `history` method with a symbol, start and end `DateTime`, to get bars within a specific time range. Times are based on the notebook's timezone.

```C#
var startTime = new DateTime(2013, 7, 29);
var endTime = new DateTime(2014, 7, 29);
var history = qb.History(symbol, startTime, endTime);
```

```Python
start_time = datetime(2013, 7, 29)
end_time = datetime(2014, 7, 29)
history = qb.history(symbol, start_time, end_time)
```

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

### Get Historical Fundamental Data by Defined Date Range (Python)

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/equity-fundamental-data

Fetches historical fundamental data between specified start and end `datetime` objects. This allows for precise historical data retrieval over a custom period.

```python
start_date = datetime(2021, 1, 1)
end_date = datetime(2021, 2, 1)
```

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

### Framework Algorithm Example for Binance US

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

Demonstrates creating a dynamic universe of crypto pairs on Binance US and forming an equal-weighted portfolio.

```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(1_000_000)
        self.settings.free_portfolio_value_percentage = 0.05
        # Warm up the security with the last known price to avoid conversion error
        self.settings.seed_initial_prices = True
        self.universe_settings.asynchronous = True
        # Add Crypto Universe Selection that select crypto pairs in BinanceUS exchange
        self.add_universe(CryptoUniverse.binance_us(self._select_assets))
        # Get the pairs on Binance US 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.BINANCE_US) 
            if x.value.quote_currency == self.account_currency
        ]
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(minutes=20), 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")
```

```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");
        }
    }
}
```

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

### COS Delta Calculation Setup (Python)

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/equity-options/universes

Sets up the QuantBook environment and retrieves historical option data for calculating option Greeks using the COS method. This example focuses on preparing data for furthest expiring puts.

```Python
# Instantiate a QuantBook instance.
qb = QuantBook()
# Set the date being studied.
date = datetime(2024, 1, 4)

# Subscribe to the underlying Equity with raw data normalization and save a reference to the Equity Symbol.
equity_symbol = qb.add_equity("SPY", data_normalization_mode=DataNormalizationMode.RAW).symbol
# Request the option data by calling the add_option method with the underlying Equity Symbol.
option = qb.add_option(equity_symbol)

# Request the historical option data to obtain the data to be calculated and compared.
history_df = qb.history(option.symbol, date-timedelta(1), date, flatten=True).droplevel([0])

# Include only the furthest expiring puts.
expiry = max(x.id.date for x in history_df.index)
history_df = history_df.loc[(x for x in history_df.index if x.id.date == expiry and x.id.option_right == OptionRight.PUT)]
strikes = np.array([x.id.strike_price for x in history_df.index])
```

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

### Binance Crypto Future Algorithm Implementation

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

This example demonstrates setting up a Binance Crypto Future algorithm, including brokerage model configuration and manual universe selection.

```csharp
public class BinanceCryptoFutureDataAlgorithm : QCAlgorithm
{
    public Symbol _symbol;

    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        // Set the account currency to USDT, since you can't trade with 
        // USD and the algorithm doesn't automatically convert USD & USDT
        // holdings.
        SetAccountCurrency("USDT", 100000);
        // Binance Futures Exchange accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        SetBrokerageModel(BrokerageName.BinanceFutures, AccountType.Margin);
        UniverseSettings.Resolution = Resolution.Daily;
        UniverseSettings.Leverage = 2;
        // We only trade on BTCUSDT Future in Binance Future exchange
        var symbols = new List<Symbol> {
            QuantConnect.Symbol.Create("BTCUSDT", SecurityType.CryptoFuture, Market.Binance)
        };
        AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
        // Custom alpha model to emit insights based on the Crypto Future price data
        AddAlpha(new CryptoFutureAlphaModel());
        // Equally invest to evenly dissipate the capital concentration risk of inidividual crypto pair
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        SetExecution(new ImmediateExecutionModel());
    }
}

public class CryptoFutureAlphaModel : AlphaModel
{
    private List<Symbol> _symbols = new();

    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        var insights = new List<Insight>();

        foreach (var symbol in _symbols)
        {
            // Trade only based on updated price data
            if (!slice.Bars.ContainsKey(symbol) || !slice.QuoteBars.TryGetValue(symbol, out var quote))
            {
                continue;
            }
            var price = slice.Bars[symbol].Price;
            
            // Scalp-trade the bid-ask spread based on the supply-demand strength
            InsightDirection direction;
            if (price - quote.Bid.Close > quote.Ask.Close - price)
            {
                direction = InsightDirection.Down;
            }
            else
            {
                direction = InsightDirection.Up;
            }
            insights.Add(Insight.Price(symbol, TimeSpan.FromDays(1), direction));
        }
        return insights;
    }

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

            // Historical data
            var history = algorithm.History(symbol, 10, Resolution.Daily);
        }

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

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

### Initializing Fear and Greed Algorithm

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/fear-and-greed

Example of setting up an algorithm with Fear and Greed data subscription.

```python
class FearAndGreedDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        self._symbol = self.add_equity("SPY", Resolution.DAILY).symbol
        self._dataset_symbol = self.add_data(FearGreedIndex, "FG").symbol
```

```csharp
public class FearAndGreedDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol, _datasetSymbol;

    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);
        _symbol = AddEquity("SPY", Resolution.Daily).Symbol;
        _datasetSymbol = AddData<FearGreedIndex>("FG").Symbol;
    }
}
```

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

### Get Historical Fundamental Data by Defined Date Range (C#)

Source: https://www.quantconnect.com/docs/v2/research-environment/datasets/equity-fundamental-data

Retrieves historical fundamental data for a specific period defined by start and end `DateTime` objects. Times are based on the notebook's time zone.

```csharp
var startDate = new DateTime(2021, 1, 1);
var endDate = new DateTime(2021, 2, 1);

// Fundamental objects
var singleFundamentalHistory = qb.History<Fundamental>(symbols.First(), startDate, endDate);
var setFundamentalHistory = qb.History<Fundamental>(symbols, startDate, endDate);
var allFundamentalHistory = qb.History<Fundamental>(qb.Securities.Keys, startDate, endDate);
    
// Fundamentals objects
var allFundamentalsHistory = qb.History<Fundamentals>(qb.Securities.Keys, startDate, endDate);
```
Tokens:
Raw