Order Types

public class ComboLegLimitOrderAlgorithm : QCAlgorithm
{
    private List<OrderTicket> _tickets = new();

    public override void Initialize()
    {
        SetStartDate(2024, 12, 24);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        
        var option = AddOption("GOOG");
        option.SetFilter(minStrike: -2, maxStrike: 2, minExpiry: TimeSpan.FromDays(0), maxExpiry: TimeSpan.FromDays(180));
    }

    public override void OnData(Slice slice)
    {
        if (_tickets.IsNullOrEmpty())
        {
            foreach (var kvp in slice.OptionChains)
            {
                // Select contracts
                var contracts = kvp.Value.Where(contract => contract.Right == OptionRight.Call)
                    .GroupBy(x => x.Expiry)
                    .OrderBy(grouping => grouping.Key)
                    .First()
                    .OrderBy(x => x.Strike)
                    .ToList();

                if (contracts.Count < 2)
                {
                    return;
                }

                // Create order legs
                var legs = new List<Leg>()
                {
                    Leg.Create(contracts[0].Symbol, 1, slice[contracts[0].Symbol].Close * 0.999m),
                    Leg.Create(contracts[1].Symbol, -2, slice[contracts[1].Symbol].Close * 0.999m)
                };

                // Place order
                _tickets = ComboLegLimitOrder(legs, 1);
            }
        }
        else
        {
            if (Time.Hour == 10 && Time.Minute == 45)
            {
                Quit();
                return;
            }

            foreach (var ticket in _tickets)
            {
                var orderDirection = Math.Sign(ticket.Quantity);
                var limitPrice = ticket.Get(OrderField.LimitPrice);

                // Log the limit prices and contract prices
                var quoteBar = slice.QuoteBars[ticket.Symbol];
                var currentPrice = orderDirection == 1 ? quoteBar.Ask.Low : quoteBar.Bid.High;
                var readyToFill = orderDirection == 1 ? currentPrice < limitPrice : currentPrice > limitPrice;
                Log($"{Time} - {ticket.Symbol}. Current price: {currentPrice}; Limit price: {Math.Round(limitPrice, 2)}; Order direction: {orderDirection}; Ready to fill: {readyToFill}");

                // Update the leg orders
                var response = ticket.Update(new UpdateOrderFields() 
                {
                    Quantity = 2 * orderDirection,
                    LimitPrice = limitPrice + 0.01m * orderDirection,
                    Tag = $"Update #{ticket.UpdateRequests.Count + 1}"
                });
            }
        }
    }
    
    public override void OnOrderEvent(OrderEvent orderEvent)
    {
        if (orderEvent.Status == OrderStatus.Filled)
        {
            Log($"{Time} -- Order {orderEvent.OrderId} filled at {orderEvent.FillPrice}");
        }
    }
}

import itertools
        
class ComboLegLimitOrderAlgorithm(QCAlgorithm):
    
    def initialize(self):
        self.set_start_date(2024, 12, 24) 
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        option = self.add_option("GOOG")
        option.set_filter(min_strike=-2, max_strike=2, min_expiry=timedelta(days=0), max_expiry=timedelta(days=180))
        
        self.tickets = []

    def on_data(self, slice: Slice):
        if len(self.tickets) == 0:
            for canonical_symbol, chain in slice.option_chains.items():
                # Select contracts
                contracts = [contract for contract in chain if contract.right == OptionRight.CALL]
                contracts = [(key, list(group)) for key, group in itertools.groupby(contracts, key=lambda x: x.expiry)]
                contracts.sort(key=lambda x: x[0])
                contracts = contracts[0][1]
                contracts.sort(key=lambda x: x.strike)

                if len(contracts) < 2:
                    return

                # Create order legs   
                quantities = [1, -2]
                legs = []
                for i, contract in enumerate(contracts[:2]):
                    legs.append(Leg.create(contract.symbol, quantities[i], slice[contract.symbol].close * .999))

                # Place order
                self.tickets = self.combo_leg_limit_order(legs, 1)
        else:
            if self.time.hour == 10 and self.time.minute == 45:
                self.quit()
                return

            for ticket in self.tickets:
                order_direction = np.sign(ticket.quantity)
                limit_price = ticket.get(OrderField.LIMIT_PRICE)

                # Log the limit prices and contract prices
                quote_bar = slice.quote_bars[ticket.symbol]
                current_price = quote_bar.ask.low if order_direction == 1 else quote_bar.bid.high
                ready_to_fill = current_price < limit_price if order_direction == 1 else current_price > limit_price
                self.log(f"{self.time} - {ticket.symbol}. Current price: {current_price}; Limit price: {round(limit_price, 2)}; Direction: {order_direction}; Ready to fill: {ready_to_fill}")

                # Update the leg orders
                update_settings = UpdateOrderFields()
                update_settings.quantity = 2 * order_direction
                update_settings.limit_price = limit_price + 0.01 * order_direction
                update_settings.tag = f"Update #{len(ticket.update_requests) + 1}"
                response = ticket.update(update_settings)

    def on_order_event(self, orderEvent: OrderEvent) -> None:
        if orderEvent.status == OrderStatus.FILLED:
            self.log(f"{self.time} -- Order {orderEvent.order_id} filled at {orderEvent.fill_price}")