QuantConnect

https://www.quantconnect.com/docs/v2/
Admin
QuantConnect is an open-source, community-driven algorithmic trading platform powered by the LEAN...
Tokens:3,980,419
Snippets:20,509
Trust Score:9.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### GetTradingDays Python Example

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

Python example using self.trading_calendar.get_trading_days with start and end datetime objects to get all trading events in a range.

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

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

### Adapt QuantBook example to QCAlgorithm Initialize in C#

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

C# backtest version of the QuantBook research example, called from Initialize, using this instead of new QuantBook().

```csharp
public override void Initialize()
{
    // Set qb to instance of QCAlgorithm
    var qb = this;
    
    // Subscribe to SPY data with QCAlgorithm
    var symbol = qb.AddEquity("SPY").Symbol;
    
    // Make history call with QCAlgorithm
    var history = qb.History(symbol, TimeSpan.FromDays(10), Resolution.Daily);
}
```

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

### GetTradingDays C# Example

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

C# example using TradingCalendar.GetTradingDays with start and end DateTime objects to get all trading events in a range.

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

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

### Initialize algorithm with FOREX data (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/forex-data

C# example of a full algorithm initialization that sets dates, cash, adds a FOREX subscription, and sets a benchmark.

```csharp
public class ForexAlgorithm : QCAlgorithm
{
    private Symbol _symbol;

    public override void Initialize()
    {
        SetStartDate(2019, 2, 20);
        SetEndDate(2019, 2, 21);
        SetCash(100000);

        _symbol = AddForex("EURUSD", Resolution.Minute).Symbol;

        SetBenchmark(_symbol);
    }
}
```

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

### Adapt QuantBook example to QCAlgorithm initialize in Python

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

Python backtest version of the QuantBook research example, called from initialize, using self instead of QuantBook().

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

    # Set qb to instance of QCAlgorithm
    qb = self
    
    # Subscribe to SPY data with QCAlgorithm
    symbol = qb.add_equity("SPY").symbol
    
    # Make history call with QCAlgorithm
    history = qb.history(symbol, timedelta(days=10), Resolution.DAILY)
```

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

### Get historical SMA values for a crypto future (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/crypto-futures

Python example of using indicator_history with a SimpleMovingAverage indicator to get historical values for a crypto future over the last 5 trading days. The example sets the start and end dates, adds a crypto future, and retrieves the history.

```python
class CryptoFutureIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        self.set_end_date(2024, 12, 31)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the 21-day SMA values of the security for the last 5 trading days. 
        history = self.indicator_history(SimpleMovingAverage(21), symbol, 5, Resolution.DAILY)
```

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

### Set Up Algorithm and Run Optimization

Source: https://www.quantconnect.com/docs/v2/research-environment/applying-research/sparse-optimization

Set up the algorithm by configuring the start date, brokerage model, cash, and ETF universe. The etf_selection method stores the constituents and returns them. The on_data method runs the optimization and places orders, recalibrating at quarter end.

```python
def initialize(self) -> None:
    self.set_start_date(2017, 1, 1)
    self.set_brokerage_model(BrokerageName.ALPHA_STREAMS)
    self.set_cash(1000000)
    
    # Add our ETF constituents of the index that we would like to track.
    qqq = self.add_equity("QQQ", Resolution.MINUTE).symbol
    self.universe_settings.asynchronous = True
    self.universe_settings.resolution = Resolution.MINUTE
    self.add_universe(self.universe.etf(qqq, self.universe_settings, self.etf_selection))
    
    self.set_benchmark("QQQ")
    
    # Set up varaibles to flag the time to recalibrate and hold the constituents.
    self._time = datetime.min
    self.assets = []
```

```python
def etf_selection(self, constituents: ETFConstituentUniverse) -> list[Symbol]:
    # We want all constituents to be considered.
    self.assets = [x.symbol for x in constituents]
    return self.assets
```

```python
def on_data(self, slice: Slice) -> None:
    qb = self
    if self._time > self.time:
        return
    
    # Prepare the historical return data of the constituents and the ETF (as index to track).
    history = qb.history(self.assets, 252, Resolution.DAILY)
    if history.empty:
        return

    history_portfolio = history.close.unstack(0)
    pct_change_portfolio = np.log(history_portfolio/history_portfolio.shift(1)).dropna()
    
    history_qqq = qb.history(self.add_equity("QQQ").symbol, 252, Resolution.DAILY)
    history_qqq = history_qqq.close.unstack(0)
    pct_change_qqq = np.log(history_qqq/history_qqq.shift(1)).loc[pct_change_portfolio.index]
    
    m = pct_change_portfolio.shape[0]; n = pct_change_portfolio.shape[1]
    
    # Set up optimization parameters.
    p = 0.5; M = 0.0001; l = 0.01
    
    # Set up convergence tolerance, maximum iteration of optimization, iteration counter and Huber downward risk as minimization indicator.
    tol = 0.001; maxIter = 20; iters = 1; hdr = 10000
    
    # Initial weightings and placeholders.
    w_ = np.array([1/n] * n).reshape(n, 1)
    self.weights = pd.Series()
    a = np.array([None] * m).reshape(m, 1)
    c = np.array([None] * m).reshape(m, 1)
    d = np.array([None] * n).reshape(n, 1)
    
    # Iterate to minimize the HDR.
    while iters < maxIter:
        x_k = (pct_change_qqq.values - pct_change_portfolio.values @ w_)
        for i in range(n):
            w = w_[i]
            d[i] = d_ = 1/(np.log(1+l/p)*(p+w))
        for i in range(m):
            xk = float(x_k[i])
            if xk < 0:
                a[i] = M / (M - 2*xk)
                c[i] = xk
            else:
                c[i] = 0
                if 0 <= xk <= M:
                    a[i] = 1
                else:
                    a[i] = M/abs(xk)
                    
        L3 = 1/m * pct_change_portfolio.T.values @ np.diagflat(a.T) @ pct_change_portfolio.values
        eigVal, eigVec = np.linalg.eig(L3.astype(float))
        eigVal = np.real(eigVal); eigVec = np.real(eigVec)
        q3 = 1/max(eigVal) * (2 * (L3 - max(eigVal) * np.eye(n)) @ w_ + eigVec @ d - 2/m * pct_change_portfolio.T.values @ np.diagflat(a.T) @ (c - pct_change_qqq.values))
        
        # We want to keep the upper bound of each asset to be 0.1
        u = 0.1
        mu = float(-(np.sum(q3) + 2)/n); mu_ = 0
        while mu > mu_:
            mu = mu_
            index1 = [i for i, q in enumerate(q3) if mu + q < -u*2]
            index2 = [i for i, q in enumerate(q3) if -u*2 < mu + q < 0]
            mu_ = float(-(np.sum([q3[i] for i in index2]) + 2 - len(index1)*u*2)/len(index2))
    
        # Obtain the weights and HDR of this iteration.
        w_ = np.amax(np.concatenate((-(mu + q3)/2, u*np.ones((n, 1))), axis=1), axis=1).reshape(-1, 1)
        w_ = w_/np.sum(abs(w_))
        hdr_ = float(w_.T @ w_ + q3.T @ w_)
        
        # If the HDR converges, we take the current weights
        if abs(hdr - hdr_) < tol:
            break
        
        # Else, we would increase the iteration count and use the current weights for the next iteration.
        iters += 1
        hdr = hdr_
    
    # -----------------------------------------------------------------------------------------
    orders = []
    for i in range(n):
        orders.append(PortfolioTarget(pct_change_portfolio.columns[i], float(w_[i])))
    self.set_holdings(orders)
    
    # Recalibrate on quarter end.
    self._time = Expiry.end_of_quarter(self.time)
```

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

### Get Average Risk-Free Rate for Time Window (C# and Python)

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

Demonstrates how to get the average risk-free interest rate over a window using the C# RiskFreeInterestRateModel.GetRiskFreeRate(start, end) and the Python RiskFreeInterestRateModelExtensions.get_risk_free_rate(model, start, end). The example uses a 7-day window in Python and a 30-day window in C#.

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

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

### Get historical SMA values for a crypto future (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/crypto-futures

C# example of using IndicatorHistory with a SimpleMovingAverage indicator to get historical values for a crypto future over the last 5 trading days. The example sets the start and end dates, adds a crypto future, and computes the maximum SMA value.

```csharp
public class CryptoFutureIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        SetEndDate(2024, 12, 31);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the 21-day SMA values of the security for the last 5 trading days. 
        var history = IndicatorHistory(new SimpleMovingAverage(21), symbol, 5, Resolution.Daily);
        // Get the maximum of the SMA values.
        var maxSMA = history.Max(indicatorDataPoint => indicatorDataPoint.Current.Value);
    }
}
```

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

### Python example - agent management workflow

Source: https://www.quantconnect.com/docs/v2/cloud-platform/api-reference/agent-management/agents/delete-agent

Demonstrates listing, creating, reading, updating, and deleting an agent; creating, reading, updating, deleting, and listing agent tasks; deploying a task; and reading, prompting, stopping, and deleting a deployment through the cloud API. Includes authentication setup and a create agent example.

```python
from base64 import b64encode
from hashlib import sha256
from time import time
from requests import get, post
BASE_URL = 'https://www.quantconnect.com/api/v2/'

# You need to replace these with your actual credentials.
# You can request your credentials at https://www.quantconnect.com/settings/
# You can find our organization ID at https://www.quantconnect.com/organization/ 
USER_ID = 0
API_TOKEN = '____'
ORGANIZATION_ID = '____'

def get_headers():
    # Get timestamp
    timestamp = f'{int(time())}'
    time_stamped_token = f'{API_TOKEN}:{timestamp}'.encode('utf-8')

    # Get hased API token
    hashed_token = sha256(time_stamped_token).hexdigest()
    authentication = f'{USER_ID}:{hashed_token}'.encode('utf-8')
    authentication = b64encode(authentication).decode('ascii')

    # Create headers dictionary.
    return {
        'Authorization': f'Basic {authentication}',
        'Timestamp': timestamp
    }

# Authenticate to verify credentials
response = post(f'{BASE_URL}/authenticate', headers = get_headers())
print(response.json())

# --------------------


### List Agents
# Send a POST request to the /agents/list endpoint to check for an existing "My Claude" agent
response = post(f'{BASE_URL}/agents/list', headers=get_headers(), json={
    "organizationId": ORGANIZATION_ID  # Organization whose agents to list
})
# Parse the JSON response into python managable dict
result = response.json()
# Search the returned agents for one already named "My Claude"
my_claude = next((a for a in result.get('agents', []) if a['name'] == 'My Claude'), None)
# Check if the request was successful and print the list
if result['success']:
    print("List of Agents:")
    print(result)

### Create Agent (only when "My Claude" does not exist yet)
if not my_claude:
    # Send a POST request to the /agents/create endpoint to create a new agent
    response = post(f'{BASE_URL}/agents/create', headers=get_headers(), json={
        "organizationId": ORGANIZATION_ID,                        # Organization that owns the agent
        "name": "Agent Placeholder",                              # Placeholder name; renamed below
        "description": "Customize your assistant's capabilities.",
        "systemPrompt": "I am a bot",                             # System prompt for the agent
        "model": "claude-opus-4-7",                               # Model identifier the agent runs on
        "reasoningEffort": "high",                                # Reasoning effort: low | medium | high
        "maxTurns": 100,                                          # Max agent turns per deployment
        "toolChoice": "auto",                                     # Tool selection policy
        "public": False,                                          # Keep the agent private
        "useQCC": True                                            # Use the QuantConnect Cloud LLM provider
    })
    # Parse the JSON response into python managable dict
    result = response.json()
    # Capture the created agent
    my_claude = result['agent']
    # Check if the request was successful and print the result
    if result['success']:
        print("Agent Created Successfully:")
        print(result)
```

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

### Initialize Crypto Universe in C#

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/universes/crypto

C# example that sets universe settings, brokerage model, and adds a Coinbase crypto universe with a LINQ selector.

```csharp
private Universe _universe;
public override void Initialize()
{
    UniverseSettings.Asynchronous = true;
    UniverseSettings.Resolution = Resolution.Daily;
    SetBrokerageModel(BrokerageName.Coinbase, AccountType.Cash);
    
    // Add crypto universe selection
    _universe = AddUniverse(CryptoUniverse.Coinbase(universeDay => from x in universeDay select x.Symbol));
}
```

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

### Get historical Futures contracts with history method in Python

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/futures

Python example using the history method with FutureUniverse type and flatten=True to get a DataFrame of daily contract data. Sets start and end dates and adds a Future.

```python
class FutureContractsHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        self.set_end_date(2024, 12, 31)
        # Add a Future.
        future = self.add_future(Futures.Indices.SP_500_E_MINI)
        # Get the daily contract data over the last two trading days.
        history = self.history(FutureUniverse, future.symbol, 2, flatten=True)
```

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

### Get historical SMA values for a crypto security (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/crypto

Calls indicator_history with a SimpleMovingAverage and a crypto Symbol to get the last 5 daily SMA values. The example sets start and end dates, adds BTCUSD, and stores the history result.

```Python
class CryptoIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        self.set_end_date(2024, 12, 31)
        # Get the Symbol of a security.
        symbol = self.add_crypto('BTCUSD').symbol
        # Get the 21-day SMA values of the security for the last 5 trading days. 
        history = self.indicator_history(SimpleMovingAverage(21), symbol, 5, Resolution.DAILY)
```

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

### Initialize algorithm with FOREX data (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/quantconnect/forex-data

Python example of a full algorithm initialization that sets dates, cash, adds a FOREX subscription, and sets a benchmark.

```python
class ForexAlgorithm (QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 2, 20)
        self.set_end_date(2019, 2, 21)
        self.set_cash(100000)

        self.eurusd = self.add_forex('EURUSD', Resolution.MINUTE).symbol

        self.set_benchmark(self.eurusd)
```

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

### Get historical SMA values for a crypto security (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/crypto

Calls IndicatorHistory with a SimpleMovingAverage and a crypto Symbol to get the last 5 daily SMA values. The example sets start and end dates, adds BTCUSD, and computes the maximum SMA from the result.

```C#
public class CryptoIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        SetEndDate(2024, 12, 31);
        // Get the Symbol of a security.
        var symbol = AddCrypto("BTCUSD").Symbol;
        // Get the 21-day SMA values of the security for the last 5 trading days. 
        var history = IndicatorHistory(new SimpleMovingAverage(21), symbol, 5, Resolution.Daily);
        // Get the maximum of the SMA values.
        var maxSMA = history.Max(indicatorDataPoint => indicatorDataPoint.Current.Value);
    }
}
```

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

### Set Up Algorithm

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

Initializes the algorithm by adding equity assets, setting up scheduled events for recalibration and daily market close actions, and defining the trading state.

```python
self.assets = ["SCHO", "SHY"]
    
    # Add Equity ------------------------------------------------ 
    for i in range(len(self.assets)):
        self.add_equity(self.assets[i], Resolution.MINUTE).symbol
        
    # Instantiate our model
    self.recalibrate()
    
    # Set a variable to indicate the trading bias of the portfolio
    self.state = 0
    
    # Set Scheduled Event Method For Kalman Filter updating.
    self.schedule.on(self.date_rules.week_start(), 
        self.time_rules.at(0, 0), 
        self.recalibrate)
    
    # Set Scheduled Event Method For Kalman Filter updating.
    self.schedule.on(self.date_rules.every_day(), 
        self.time_rules.before_market_close("SHY"), 
        self.every_day_before_market_close)
```

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

### Get historical universe data in research (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/coingecko/crypto-market-cap

Calls the universe_history method with the Universe object, a start date, and an end date to get historical universe data in research. Shows both DataFrame and Series examples. If there is no data in the requested period, the history result is empty.

```python
# DataFrame example where the columns are the CoinGeckoUniverse attributes: 
history_df = qb.universe_history(universe, qb.time-timedelta(30), qb.time, flatten=True)

# Series example where the values are lists of CoinGeckoUniverse objects: 
universe_history = qb.universe_history(universe, qb.time-timedelta(30), qb.time)
for (_, time), coins in universe_history.items():
    for coin in coins:
        print(f"{coin.symbol.value} market cap at {coin.end_time}: {coin.market_cap}")
```

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

### US Equity Options Algorithm Setup

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/algoseek/us-equity-options

Initializes the algorithm with a date range, cash, and asynchronous universe settings. Sets up the universe selection, alpha, and portfolio construction models.

```csharp
public class USEquityOptionsDataAlgorithm : QCAlgorithm
{        
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        UniverseSettings.Asynchronous = true;
        // Requesting data
        SetUniverseSelection(new EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel());
        
        SetAlpha(new ConstantOptionsAlphaModel());
        
        SetPortfolioConstruction(new SingleSharePortfolioConstructionModel());
    }
}   
```

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

### Upload, Get, Delete, and List Object Store Files with Python

Source: https://www.quantconnect.com/docs/v2/cloud-platform/api-reference/object-store-management/upload-object-store-files

Complete Python example for managing Object Store files via the QuantConnect cloud API. It includes authentication setup and demonstrates uploading, getting metadata, getting, deleting, and listing objects. Replace USER_ID, API_TOKEN, ORGANIZATION_ID, and the key with your actual credentials and object key.

```python
from base64 import b64encode
from hashlib import sha256
from time import time
from requests import get, post
BASE_URL = 'https://www.quantconnect.com/api/v2/'

# You need to replace these with your actual credentials.
# You can request your credentials at https://www.quantconnect.com/settings/
# You can find our organization ID at https://www.quantconnect.com/organization/ 
USER_ID = 0
API_TOKEN = '____'
ORGANIZATION_ID = '____'

def get_headers():
    # Get timestamp
    timestamp = f'{int(time())}'
    time_stamped_token = f'{API_TOKEN}:{timestamp}'.encode('utf-8')

    # Get hased API token
    hashed_token = sha256(time_stamped_token).hexdigest()
    authentication = f'{USER_ID}:{hashed_token}'.encode('utf-8')
    authentication = b64encode(authentication).decode('ascii')

    # Create headers dictionary.
    return {
        'Authorization': f'Basic {authentication}',
        'Timestamp': timestamp
    }

# Authenticate to verify credentials
response = post(f'{BASE_URL}/authenticate', headers = get_headers())
print(response.json())

# --------------------


# The key of the object wishes to manipulate
key = "..."

### Upload Object Store File
# Send a POST request to the /object/set endpoint to upload a file
response = post(f'{BASE_URL}/object/set', headers=get_headers(), 
                data={"organizationId": ORGANIZATION_ID, "key": key},  # Organization ID and key for the object
                files={"objectData": b"Hello, world!"})  # File content as bytes
# Parse the JSON response into python managable dict
result = response.json()
# Check if the request was successful and print the result
if result['success']:
    print("Object Store File Uploaded Successfully:")
    print(result)

### Get Object Store Metadata
# Prepare data payload to get object metadata
payload = {
    "organizationId": ORGANIZATION_ID,  # ID of the organization
    "key": key  # Key of the object to get metadata for
}
# Send a POST request to the /object/properties endpoint to get metadata
response = post(f'{BASE_URL}/object/properties', headers=get_headers(), json=payload)
# Parse the JSON response into python managable dict
result = response.json()
# Check if the request was successful and print the metadata
if result['success']:
    print("Object Store Metadata:")
    print(result)

### Get Object Store File
# Prepare data payload to retrieve the object
payload = {
    "organizationId": ORGANIZATION_ID,  # ID of the organization
    "keys": [key]  # List of keys to retrieve (single key in this case)
}
# Send a POST request to the /object/get endpoint to get the object
response = post(f'{BASE_URL}/object/get', headers=get_headers(), json=payload)
# Parse the JSON response into python managable dict
result = response.json()
# Check if the request was successful and print the file content
if result['success']:
    print("Object Store File Content:")
    print(result)

### Delete Object Store File
# Prepare data payload to delete the object
payload = {
    "organizationId": ORGANIZATION_ID,  # ID of the organization
    "key": key  # Key of the object to delete
}
# Send a POST request to the /object/delete endpoint to delete the object
response = post(f'{BASE_URL}/object/delete', headers=get_headers(), json=payload)
# Parse the JSON response into python managable dict
result = response.json()
# Check if the request was successful and print the result
if result['success']:
    print("Object Store File Deleted Successfully:")
    print(result)

### List Object Store Files
# Define an empty path to list all objects (replace with specific path if needed)
path = ""
# Prepare data payload to list objects
payload = {
    "organizationId": ORGANIZATION_ID,  # ID of the organization
    "path": path  # Path to list objects from
}
# Send a POST request to the /object/list endpoint to list objects
response = post(f'{BASE_URL}/object/list', headers=get_headers(), json=payload)
# Parse the JSON response into python managable dict
result = response.json()
# Check if the request was successful and print the list
if result['success']:
    print("List of Object Store Files:")
    print(result)
```

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

### Initialize algorithm with EIA data (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/energy-information-administration/us-energy-information-administration-%28eia%29

Full algorithm initialization example that sets start/end dates, cash, and adds EIA data. Demonstrates the complete setup for using the dataset.

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

        self.dataset_symbol = self.add_data(USEnergy, USEnergy.Petroleum.UnitedStates.WEEKLY_NET_IMPORTS_OF_TOTAL_PETROLEUM_PRODUCTS).symbol
```

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

### Set up trading data with forward returns and equity DataFrame

Source: https://www.quantconnect.com/docs/v2/research-environment/applying-research/kalman-filters-and-stat-arb

Creates forward return data by shifting percentage changes backward, and initializes an equity DataFrame with daily values starting at 1.

```Python
testing_ret = data.pct_change().iloc[1:].shift(-1)   # Shift 1 step backward as forward return result
equity = pd.DataFrame(np.ones((testing_ret.shape[0], 1)), index=testing_ret.index, columns=["Daily value"])
```

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

### Request historical QuoteBar data for a future (Python)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/futures

Python example using the history method with QuoteBar type to get 5 trailing minute QuoteBar objects in DataFrame format. It sets start and end dates, adds a future, gets the first symbol from the futures chain, and stores the result in a DataFrame.

```python
class FutureQuoteBarHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        self.set_end_date(2024, 12, 31)
        # Get the Symbol of a security.
        future = self.add_future(Futures.Indices.SP_500_E_MINI)
        symbol = list(self.futures_chain(future.symbol))[0].symbol
        # Get the 5 trailing minute QuoteBar objects of the security in DataFrame format. 
        history = self.history(QuoteBar, symbol, 5, Resolution.MINUTE)
```

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

### Request historical QuoteBar data for a future (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/asset-classes/futures

C# example using History<QuoteBar> to get the 5 trailing minute QuoteBar objects for a future contract. It sets the start and end dates, adds a future, gets the first symbol from the futures chain, and iterates through the bars to calculate the bid-ask spread.

```csharp
public class FutureQuoteBarHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        SetEndDate(2024, 12, 31);
        // Get the Symbol of a security.
        var future = AddFuture(Futures.Indices.SP500EMini);
        var symbol = FuturesChain(future.Symbol).First().Symbol;
        // Get the 5 trailing minute QuoteBar objects of the security. 
        var history = History<QuoteBar>(symbol, 5, Resolution.Minute);
        // Iterate through the QuoteBar objects and calculate the spread.
        foreach (var bar in history)
        {
            var t = bar.EndTime;
            var spread = bar.Ask.Close - bar.Bid.Close;
        }
    }
}
```

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

### Create QuantBook and subscribe to equity data (C#)

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

Initializes a QuantBook and subscribes to SPY equity data. This is the first step to calculate indicator values.

```csharp
var qb = new QuantBook();
var symbol = qb.AddEquity("SPY").Symbol;
```

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

### C#: Request historical data for a defined period of time

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

Use the History method with a start and end DateTime to get historical data. The example shows how to request Slice, TradeBar, QuoteBar, and Tick objects for a single symbol, a subset of symbols, and all securities in the universe. The start and end times are based in the notebook time zone.

```csharp
var startTime = new DateTime(2021, 1, 1);
var endTime = new DateTime(2021, 2, 1);

// Slice objects
var singleHistorySlice = qb.History(spy, startTime, endTime);
var subsetHistorySlice = qb.History(new[] {spy, tlt}, startTime, endTime);
var allHistorySlice = qb.History(qb.Securities.Keys, startTime, endTime);

// TradeBar objects
var singleHistoryTradeBars = qb.History<TradeBar>(spy, startTime, endTime);
var subsetHistoryTradeBars = qb.History<TradeBar>(new[] {spy, tlt}, startTime, endTime);
var allHistoryTradeBars = qb.History<TradeBar>(qb.Securities.Keys, startTime, endTime);

// QuoteBar objects
var singleHistoryQuoteBars = qb.History<QuoteBar>(spy, startTime, endTime, Resolution.Minute);
var subsetHistoryQuoteBars = qb.History<QuoteBar>(new[] {spy, tlt}, startTime, endTime, Resolution.Minute);
var allHistoryQuoteBars = qb.History<QuoteBar>(qb.Securities.Keys, startTime, endTime, Resolution.Minute);

// Tick objects
var singleHistoryTicks = qb.History<Tick>(spy, startTime, endTime, Resolution.Tick);
var subsetHistoryTicks = qb.History<Tick>(new[] {spy, tlt}, startTime, endTime, Resolution.Tick);
var allHistoryTicks = qb.History<Tick>(qb.Securities.Keys, startTime, endTime, Resolution.Tick);
```

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

### QuantConnect algorithm initialization with scheduled events

Source: https://www.quantconnect.com/docs/v2/research-environment/applying-research/kalman-filters-and-stat-arb

Sets up the backtest environment with required settings (start date, brokerage, cash, benchmark), adds forex assets, and schedules weekly recalibration and daily Kalman filter updates.

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

    self.assets = ["EURUSD", "GBPUSD", "USDCAD", "USDHKD", "USDJPY"]
    
    # Add Equity ------------------------------------------------ 
    for i in range(len(self.assets)):
        self.add_forex(self.assets[i], Resolution.MINUTE)
        
    # Instantiate our model
    self.recalibrate()
    
    # Set a variable to indicate the trading bias of the portfolio
    self.state = 0
    
    # Set Scheduled Event Method For Recalibrate Our Model Every Week.
    self.schedule.on(self.date_rules.week_start(), 
        self.time_rules.at(0, 0), 
        self.recalibrate)
    
    # Set Scheduled Event Method For Kalman Filter updating.
    self.schedule.on(self.date_rules.every_day(), 
        self.time_rules.before_market_close("EURUSD"), 
        self.every_day_before_market_close)
```

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

### Python: Request CFD history for a defined period of time

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

Use qb.history with start and end datetime objects to get bars or ticks with timestamps within that period. The start and end times are based in the notebook time zone. Examples show retrieving DataFrames, QuoteBar, and Tick objects for a single symbol, a subset, and all securities.

```Python
start_time = datetime(2021, 1, 1)
end_time = datetime(2021, 2, 1)

# DataFrame of quote data (CFD data doesn't have trade data)
single_history_df = qb.history(spx, start_time, end_time)
subset_history_df = qb.history([spx, usb], start_time, end_time)
all_history_df = qb.history(qb.securities.keys(), start_time, end_time)

# DataFrame of tick data
single_history_tick_df = qb.history(spx, start_time, end_time, Resolution.TICK)
subset_history_tick_df = qb.history([spx, usb], start_time, end_time, Resolution.TICK)
all_history_tick_df = qb.history(qb.securities.keys(), start_time, end_time, Resolution.TICK)

# QuoteBar objects
single_history_quote_bars = qb.history[QuoteBar](spx, start_time, end_time, Resolution.MINUTE)
subset_history_quote_bars = qb.history[QuoteBar]([spx, usb], start_time, end_time, Resolution.MINUTE)
all_history_quote_bars = qb.history[QuoteBar](qb.securities.keys(), start_time, end_time, Resolution.MINUTE)

# Tick objects
single_history_ticks = qb.history[Tick](spx, start_time, end_time, Resolution.TICK)
subset_history_ticks = qb.history[Tick]([spx, usb], start_time, end_time, Resolution.TICK)
all_history_ticks = qb.history[Tick](qb.securities.keys(), start_time, end_time, Resolution.TICK)
```

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

### Initialize algorithm with EIA data (C#)

Source: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/energy-information-administration/us-energy-information-administration-%28eia%29

Full algorithm initialization example that sets start/end dates, cash, and adds EIA data. Demonstrates the complete setup for using the dataset.

```csharp
public class USEnergyDataAlgorithm: QCAlgorithm
{
    private Symbol _datasetSymbol;

    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2020, 6, 1);
        SetCash(100000);
        _datasetSymbol = AddData<USEnergy>(USEnergy.Petroleum.UnitedStates.WeeklyNetImportsOfTotalPetroleumProducts).Symbol;
    }
}
```

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

### Python Example for Agent and Task Management

Source: https://www.quantconnect.com/docs/v2/cloud-platform/api-reference/agent-management/agents/create-agent

Python example demonstrating listing, creating, reading, and updating agents; managing agent tasks; deploying a task; and interacting with deployments through the cloud API.

```python
from base64 import b64encode
from hashlib import sha256
from time import time
from requests import get, post
BASE_URL = 'https://www.quantconnect.com/api/v2/'
```

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

### C#: Request CFD history for a defined period of time

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

Use qb.History with start and end DateTime objects to get bars or ticks with timestamps within that period. The start and end times are based in the notebook time zone. Examples show retrieving Slice, QuoteBar, and Tick objects for a single symbol, a subset, and all securities.

```C#
var startTime = new DateTime(2021, 1, 1);
var endTime = new DateTime(2021, 2, 1);

// Slice objects
var singleHistorySlice = qb.History(spx, startTime, endTime);
var subsetHistorySlice = qb.History(new[] {spx, usb}, startTime, endTime);
var allHistorySlice = qb.History(qb.Securities.Keys, startTime, endTime);

// QuoteBar objects
var singleHistoryQuoteBars = qb.History<QuoteBar>(spx, startTime, endTime, Resolution.Minute);
var subsetHistoryQuoteBars = qb.History<QuoteBar>(new[] {spx, usb}, startTime, endTime, Resolution.Minute);
var allHistoryQuoteBars = qb.History<QuoteBar>(qb.Securities.Keys, startTime, endTime, Resolution.Minute);

// Tick objects
var singleHistoryTicks = qb.History<Tick>(spx, startTime, endTime, Resolution.Tick);
var subsetHistoryTicks = qb.History<Tick>(new[] {spx, usb}, startTime, endTime, Resolution.Tick);
var allHistoryTicks = qb.History<Tick>(qb.Securities.Keys, startTime, endTime, Resolution.Tick);
```

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

### ReadLiveOrdersRequest JSON Example

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

Example request body for the /live/orders/read API. Requires algorithmId, start, end, and projectId. The end - start must be <= 1,000.

```json
{
  "algorithmId": "L-6e9d8a78f5af89d401f630585be90e43",
  "start": 0,
  "end": 100,
  "projectId": 23456789
}
```

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

### Algorithm Initialization with Estimize Data

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

Full algorithm initialization example showing how to subscribe to Estimize data streams.

```python
class ExtractAlphaEstimizeDataAlgorithm(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.estimize_consensus_symbol = self.add_data(EstimizeConsensus, self.aapl).symbol
        self.estimize_estimate_symbol = self.add_data(EstimizeEstimate, self.aapl).symbol
        self.estimize_release_symbol = self.add_data(EstimizeRelease, self.aapl).symbol
```

```csharp
public class ExtractAlphaEstimizeDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol, _estimizeConsensusSymbol, _estimizeEstimateSymbol, _estimizeReleaseSymbol;

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

        _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
        _estimizeConsensusSymbol = AddData<EstimizeConsensus>(_symbol).Symbol;
        _estimizeEstimateSymbol = AddData<EstimizeEstimate>(_symbol).Symbol; 
        _estimizeReleaseSymbol = AddData<EstimizeRelease>(_symbol).Symbol;
    }
}
```

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

### Research Example: List Top Crypto Pairs by Dollar Volume (C#)

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

C# example using QuantBook to add a crypto pair, fetch historical data, and add a CryptoUniverse filter for Bitfinex. The filter selects the top 5 pairs by volume in USD above 10000, then prints historical universe data.

```csharp
var qb = new QuantBook();

// Add Cryptocurrency pair
var symbol = qb.AddCrypto("BTCUSDT", market:Market.Bitfinex).Symbol;

// Historical data
var history = qb.History(symbol, 30, Resolution.Daily);
foreach (var bar in history)
{
    Console.WriteLine($"{bar.EndTime} {bar}");
}

// Add Crypto Universe Selection
IEnumerable<Symbol> UniverseSelectionFilter(IEnumerable<CryptoUniverse> universeDay)
{
    return universeDay
        .Where(x => x.VolumeInUsd != null && x.VolumeInUsd > 10000m)
        .OrderByDescending(x => x.VolumeInUsd)
        .Take(5)
        .Select(x => x.Symbol);
}
var universe = qb.AddUniverse(CryptoUniverse.Bitfinex(UniverseSelectionFilter));

// Historical Universe data
var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var universeDay in universeHistory)
{
    Console.WriteLine($"=== {universeDay.First().EndTime} ===");
    foreach (CryptoUniverse universeItem in universeDay.OrderByDescending(x => x.VolumeInUsd))
    {
        Console.WriteLine($"{universeItem.Symbol}: {universeItem.VolumeInUsd}");
    }
}
```
Tokens:
Raw