Key Concepts

# Add equity for "GOOG" and print symbol id value, symbol value and encoded symbol id.
self._symbol = self.add_equity("GOOG").symbol
self.debug(self._symbol.id.value) # Prints "GOOCV"
self.debug(self._symbol.value)    # Prints "GOOG"
self.debug(str(self._symbol.id))  # Prints "GOOCV VP83T1ZUHROL"

// Add equity for "GOOG" and print symbol id value, symbol value and encoded symbol id.
var symbol = AddEquity("GOOG").Symbol;
Debug(symbol.ID.Value);       // Prints "GOOCV"
Debug(symbol.Value);          // Prints "GOOG"
Debug(symbol.ID.ToString());  // Prints "GOOCV VP83T1ZUHROL"

// Extract the market, security type, and value from the symbol with ID "GOOCV VP83T1ZUHROL".
var symbol = Symbol("GOOCV VP83T1ZUHROL");
symbol.ID.Market;     // => "USA"
symbol.SecurityType;  // => SecurityType.Equity
symbol.Value;         // => "GOOCV"

# Extract the market, security type, and value from the symbol with ID "GOOCV VP83T1ZUHROL".
symbol = self.symbol("GOOCV VP83T1ZUHROL")
symbol.id.market      # => "USA"
symbol.security_type  # => SecurityType.EQUITY
symbol.value          # => "GOOCV"

# Generate an Equity security identifier for a ticker and then create a symbol with it.
ticker = "ATHN"
security_id = SecurityIdentifier.generate_equity(ticker, Market.USA, mapping_resolve_date=datetime(2021, 12, 1))
symbol = Symbol(security_id, ticker)

// Generate an Equity security identifier for a ticker and then create a symbol with it.
var ticker = "ATHN";
var securityID = SecurityIdentifier.GenerateEquity(ticker, Market.USA, mappingResolveDate:new DateTime(2021, 12, 1));
var symbol = new Symbol(securityID, ticker);

# Example 1: Relying On Symbol Cache:
self.add_equity("IBM")          # Add by IBM string ticker, save reference to Symbol Cache.
self.market_order("IBM", 100)   # Determine refering to IBM Equity from Symbol Cache.
self.history("AAPL", 14)        # Makes a guess referring to AAPL Equity.

# Example 2: Correctly Using Symbols: 
self.ibm = self.add_equity("IBM").symbol   # Add IBM Equity string ticker, save Symbol.
self.market_order(self.ibm, 100)           # Use IBM Symbol in future API calls.

self.aapl = Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)
self.history(self.aapl, 14)

// Example 1: Relying On Symbol Cache:
AddEquity("IBM");          // Add by IBM string ticker, save reference to Symbol Cache.
MarketOrder("IBM", 100);   // Determine refering to IBM Equity from Symbol Cache.
History("AAPL", 14);       // Guess referring to AAPL Equity.

// Example 2: Correctly Using Symbols: 
var ibm = AddEquity("IBM").Symbol;   // Add IBM Equity string ticker, save Symbol.
MarketOrder(ibm, 100);               // Use IBM Symbol in future API calls.

var aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
History(aapl, 14);

# Get the CUSIP for the symbol and vice versa.
symbol = self.cusip("03783310") # AAPL Symbol
cusip = self.cusip(symbol) # AAPL CUSIP (03783310)

// Get the CUSIP for the symbol and vice versa.
var symbol = CUSIP("03783310"); // AAPL Symbol
var cusip = CUSIP(symbol); // AAPL CUSIP (03783310)

# Get the FIGI for the symbol and vice versa.
symbol = self.composite_figi("BBG000B9XRY4") # AAPL Symbol
figi = self.composite_figi(symbol) # AAPL FIGI (BBG000B9XRY4)

// Get the FIGI for the symbol and vice versa.
var symbol = CompositeFIGI("BBG000B9XRY4"); // AAPL Symbol
var figi = CompositeFIGI(symbol); // AAPL FIGI (BBG000B9XRY4)

# Get the ISIN for the symbol and vice versa.
symbol = self.isin("US0378331005") # AAPL Symbol
isin = self.isin(symbol) # AAPL ISIN (US0378331005)

// Get the ISIN for the symbol and vice versa.
var symbol = ISIN("US0378331005"); // AAPL Symbol
var isin = ISIN(symbol); // AAPL ISIN (US0378331005)

# Get the SEDOL for the symbol and vice versa
symbol = self.sedol("2046251") # AAPL Symbol
sedol = self.sedol(symbol) # AAPL SEDOL (2046251)

// Get the SEDOL for the symbol and vice versa
var symbol = SEDOL("2046251"); // AAPL Symbol
var sedol = SEDOL(symbol); // AAPL SEDOL (2046251)

public class SecurityIdentifierExampleAlgorithm : QCAlgorithm
{
    private Future _future;
    private OrderTicket _ticket;
    private ScheduledEvent _lastScheduledEvent;

    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2022, 1, 1);
        // Seed the price data to allow the mapped contract to fill despite sparse data.
        SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
    }

    public override void OnWarmupFinished()
    {
        // Since we do not subscribe to any data source, we can use the OnWarmupFinished event handler instead of OnData for the initial position.
        var es = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
        OpenFuturePosition(es, Time.AddDays(30), 1);
    }

    private void OpenFuturePosition(Symbol symbol, DateTime minExpiry, decimal quantity)
    {
        // Select the next mapped future contract with the nearest expiry,
        // which should be further than the current contract.
        var selected = FutureChainProvider.GetFutureContractList(symbol, Time)
            .Where(x => x.ID.Date > minExpiry)
            .MinBy(x => x.ID.Date);
        // Subscribe to its data to trade it.
        _future = AddFutureContract(selected, extendedMarketHours: true);

        // Buy back the corresponding number of contracts as the previous mapped contract.
        MarketOrder(_future.Symbol, quantity);

        // Schedule the next rollover to be 1 week before the expiry to avoid excessive volatility.
        // It will only be triggered once 7 days before the expiry and discarded afterward.
        if (_lastScheduledEvent != null) Schedule.Remove(_lastScheduledEvent);
        Schedule.On(
            DateRules.On(new[] { _future.Symbol.ID.Date.AddDays(-7) }),
            TimeRules.At(9, 30),
            RollOver
        );
    }

    private void RollOver()
    {
        // Save the current number of contracts to roll over to the next mapped contract.
        var quantity = _future.Holdings.Quantity;
        // Liquidate the to-be-expired contract to roll over the position.
        Liquidate(_future.Symbol);

        OpenFuturePosition(_future.Symbol.Canonical, _future.Symbol.ID.Date, quantity);
    }
}

class SecurityIdentifierExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        # Seed the price data in order to allow the mapped contract to fill despite sparse data.
        self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))
        self._last_scheduled_event = None
        
    def on_warmup_finished(self) -> None:
        # Since we do not subscribe to any data source, we can use the on_warmup_finished event handler instead of OnData for the initial position.
        es = Symbol.Create(Futures.Indices.SP_500_E_MINI, SecurityType.FUTURE, Market.CME)
        self.open_future_position(es, self.time + timedelta(30), 1)

    def open_future_position(self, symbol: Symbol, min_expiry: DateTime, quantity: float) -> None:
        # Select the next mapped future contract with the nearest expiry,
        # which should be further than the current contract.
        future_list = self.future_chain_provider.get_future_contract_list(symbol, self.time)
        selected = sorted([x for x in future_list if x.id.date > min_expiry],
                          key=lambda x: x.id.date)[0]
        # Subscribe to its data to trade it.
        self._future = self.add_future_contract(selected, extended_market_hours=True)

        # Buy back the corresponding number of contracts as the previous mapped contract.
        self.market_order(self._future.symbol, quantity)

        # Schedule the next rollover to be 1 week before the expiry to avoid excessive volatility.
        # It will only be triggered once 7 days before the expiry and discarded afterward.
        if self._last_scheduled_event:
            self.schedule.remove(self._last_scheduled_event)
        self.schedule.on(
            self.date_rules.on([self._future.symbol.id.date - timedelta(7)]),
            self.time_rules.at(9, 30),
            self.roll_over
        )

    def roll_over(self) -> None:
        # Save the current number of contracts to roll over to the next mapped contract.
        quantity = self._future.holdings.quantity
        # Liquidate the to-be-expired contract to roll over the position.
        self.liquidate(self._future.symbol)

        self.open_future_position(self._future.symbol.canonical, self._future.symbol.id.date, quantity)