Add OnOrderEvent method to IExecutionModel

Algorithm.CSharp/ExecutionModelOrderEventsRegressionAlgorithm.cs

@@ -0,0 +1,203 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Algorithm.Framework.Alphas;
+using QuantConnect.Algorithm.Framework.Execution;
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Risk;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm demonstrating how to get order events in custom execution models
+    /// and asserting that they match the algorithm's order events.
+    /// </summary>
+    public class ExecutionModelOrderEventsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private readonly List<OrderEvent> _orderEvents = new();
+        private CustomImmediateExecutionModel _executionModel;
+
+        public override void Initialize()
+        {
+            UniverseSettings.Resolution = Resolution.Minute;
+
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            SetUniverseSelection(new ManualUniverseSelectionModel(QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)));
+            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromMinutes(20), 0.025, null));
+            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Resolution.Daily));
+
+            _executionModel = new CustomImmediateExecutionModel(this);
+            SetExecution(_executionModel);
+            SetRiskManagement(new MaximumDrawdownPercentPerSecurity(0.01m));
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            _orderEvents.Add(orderEvent);
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_executionModel.OrderEvents.Count != _orderEvents.Count)
+            {
+                throw new RegressionTestException($"Order events count mismatch. Execution model: {_executionModel.OrderEvents.Count}, Algorithm: {_orderEvents.Count}");
+            }
+
+            for (int i = 0; i < _orderEvents.Count; i++)
+            {
+                var modelEvent = _executionModel.OrderEvents[i];
+                var algoEvent = _orderEvents[i];
+
+                if (modelEvent.Id != algoEvent.Id ||
+                    modelEvent.OrderId != algoEvent.OrderId ||
+                    modelEvent.Status != algoEvent.Status)
+                {
+                    throw new RegressionTestException($"Order event mismatch at index {i}. Execution model: {_executionModel.OrderEvents[i]}, Algorithm: {_orderEvents[i]}");
+                }
+            }
+        }
+
+        private class CustomImmediateExecutionModel : ExecutionModel
+        {
+            private readonly QCAlgorithm _algorithm;
+
+            private readonly PortfolioTargetCollection _targetsCollection = new PortfolioTargetCollection();
+
+            private readonly Dictionary<int, OrderTicket> _orderTickets = new();
+
+            public List<OrderEvent> OrderEvents { get; } = new();
+
+            public CustomImmediateExecutionModel(QCAlgorithm algorithm)
+            {
+                _algorithm = algorithm;
+            }
+
+            public override void Execute(QCAlgorithm algorithm, IPortfolioTarget[] targets)
+            {
+                _targetsCollection.AddRange(targets);
+                if (!_targetsCollection.IsEmpty)
+                {
+                    foreach (var target in _targetsCollection.OrderByMarginImpact(algorithm))
+                    {
+                        var security = algorithm.Securities[target.Symbol];
+
+                        // calculate remaining quantity to be ordered
+                        var quantity = OrderSizing.GetUnorderedQuantity(algorithm, target, security, true);
+
+                        if (quantity != 0 &&
+                            security.BuyingPowerModel.AboveMinimumOrderMarginPortfolioPercentage(security, quantity,
+                                algorithm.Portfolio, algorithm.Settings.MinimumOrderMarginPortfolioPercentage))
+                        {
+                            var ticket = algorithm.MarketOrder(security, quantity, Asynchronous, target.Tag);
+                            _orderTickets[ticket.OrderId] = ticket;
+                        }
+                    }
+
+                    _targetsCollection.ClearFulfilled(algorithm);
+                }
+            }
+
+            public override void OnOrderEvent(OrderEvent orderEvent)
+            {
+                // This method will get events for all orders, but if we save the tickets in Execute we can filter
+                // to process events for orders placed by this model
+                if (_orderTickets.TryGetValue(orderEvent.OrderId, out var ticket))
+                {
+                    if (orderEvent.Status.IsFill())
+                    {
+                        _algorithm.Debug($"Purchased Stock: {orderEvent.Symbol}");
+                    }
+
+                    if (orderEvent.Status.IsClosed())
+                    {
+                        // Once the order is closed we can remove it from our tracking dictionary
+                        _orderTickets.Remove(orderEvent.OrderId);
+                    }
+                }
+
+                OrderEvents.Add(orderEvent);
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 3943;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-1.01%"},
+            {"Compounding Annual Return", "261.134%"},
+            {"Drawdown", "2.200%"},
+            {"Expectancy", "-1"},
+            {"Start Equity", "100000"},
+            {"End Equity", "101655.30"},
+            {"Net Profit", "1.655%"},
+            {"Sharpe Ratio", "8.472"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "66.840%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.091"},
+            {"Beta", "1.006"},
+            {"Annual Standard Deviation", "0.224"},
+            {"Annual Variance", "0.05"},
+            {"Information Ratio", "-33.445"},
+            {"Tracking Error", "0.002"},
+            {"Treynor Ratio", "1.885"},
+            {"Total Fees", "$10.32"},
+            {"Estimated Strategy Capacity", "$27000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Portfolio Turnover", "59.86%"},
+            {"Drawdown Recovery", "3"},
+            {"OrderListHash", "f209ed42701b0419858e0100595b40c0"}
+        };
+    }
+}

Algorithm.CSharp/RegressionTests/Universes/ETFConstituentUniverseFrameworkRegressionAlgorithm.cs

@@ -22,6 +22,7 @@
 using QuantConnect.Data;
 using QuantConnect.Data.UniverseSelection;
 using QuantConnect.Interfaces;
+using QuantConnect.Orders;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -31,7 +32,7 @@ namespace QuantConnect.Algorithm.CSharp
     public class ETFConstituentUniverseFrameworkRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         private List<ETFConstituentUniverse> ConstituentData = new List<ETFConstituentUniverse>();
-        
+
         /// <summary>
         /// Initializes the algorithm, setting up the framework classes and ETF constituent universe settings
         /// </summary>
@@ -40,7 +41,7 @@ public override void Initialize()
             SetStartDate(2020, 12, 1);
             SetEndDate(2021, 1, 31);
             SetCash(100000);
-            
+
             SetAlpha(new ETFConstituentAlphaModel());
             SetPortfolioConstruction(new ETFConstituentPortfolioModel());
             SetExecution(new ETFConstituentExecutionModel());
@@ -111,19 +112,19 @@ public void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
             public IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
             {
                 var algo = (ETFConstituentUniverseFrameworkRegressionAlgorithm) algorithm;
-                
+
                 foreach (var constituent in algo.ConstituentData)
                 {
                     if (!data.Bars.ContainsKey(constituent.Symbol) &&
                         !data.QuoteBars.ContainsKey(constituent.Symbol))
                     {
                         continue;
                     }
-                    
+
                     var insightDirection = constituent.Weight != null && constituent.Weight >= 0.01m
                         ? InsightDirection.Up
                         : InsightDirection.Down;
-                    
+
                     yield return new Insight(
                         algorithm.UtcTime,
                         constituent.Symbol,
@@ -144,7 +145,7 @@ public IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
         private class ETFConstituentPortfolioModel : IPortfolioConstructionModel
         {
             private bool _hasAdded;
-            
+
             /// <summary>
             /// Securities changed, detects if we've got new additions to the universe
             /// so that we don't try to trade every loop
@@ -203,8 +204,13 @@ public void Execute(QCAlgorithm algorithm, IPortfolioTarget[] targets)
                     algorithm.SetHoldings(target.Symbol, target.Quantity);
                 }
             }
+
+            public void OnOrderEvent(OrderEvent orderEvent)
+            {
+
+            }
         }
-        
+
         /// <summary>
         /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
         /// </summary>

Algorithm.Python/ExecutionModelOrderEventsRegressionAlgorithm.py

@@ -0,0 +1,84 @@
+# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from AlgorithmImports import *
+
+### <summary>
+### Regression algorithm demonstrating how to get order events in custom execution models
+### and asserting that they match the algorithm's order events.
+### </summary>
+class ExecutionModelOrderEventsRegressionAlgorithm(QCAlgorithm):
+    def initialize(self):
+        self._order_events = []
+        self.universe_settings.resolution = Resolution.MINUTE
+
+        self.set_start_date(2013, 10, 7)
+        self.set_end_date(2013, 10, 11)
+        self.set_cash(100000)
+
+        self.set_universe_selection(ManualUniverseSelectionModel(Symbol.create("SPY", SecurityType.EQUITY, Market.USA)))
+        self.set_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(minutes=20), 0.025, None))
+        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(Resolution.DAILY))
+
+        self._execution_model = CustomImmediateExecutionModel(self)
+        self.set_execution(self._execution_model)
+        self.set_risk_management(MaximumDrawdownPercentPerSecurity(0.01))
+
+    def on_order_event(self, order_event):
+        self._order_events.append(order_event)
+
+    def on_end_of_algorithm(self):
+        if len(self._execution_model.order_events) != len(self._order_events):
+            raise Exception(f"Order events count mismatch. Execution model: {len(self._execution_model.order_events)}, Algorithm: {len(self._order_events)}")
+
+        for i, (model_event, algo_event) in enumerate(zip(self._execution_model.order_events, self._order_events)):
+            if (model_event.id != algo_event.id or
+                model_event.order_id != algo_event.order_id or
+                model_event.status != algo_event.status):
+                raise Exception(f"Order event mismatch at index {i}. Execution model: {model_event}, Algorithm: {algo_event}")
+
+class CustomImmediateExecutionModel(ExecutionModel):
+    def __init__(self, algorithm):
+        self._algorithm = algorithm
+        self._targets_collection = PortfolioTargetCollection()
+        self._order_tickets = {}
+        self.order_events = []
+
+    def execute(self, algorithm, targets):
+        self._targets_collection.add_range(targets)
+        if not self._targets_collection.is_empty:
+            for target in self._targets_collection.order_by_margin_impact(algorithm):
+                security = algorithm.securities[target.symbol]
+
+                # calculate remaining quantity to be ordered
+                quantity = OrderSizing.get_unordered_quantity(algorithm, target, security, True)
+
+                if (quantity != 0 and
+                    BuyingPowerModelExtensions.above_minimum_order_margin_portfolio_percentage(security.buying_power_model,
+                        security, quantity, algorithm.portfolio, algorithm.settings.minimum_order_margin_portfolio_percentage)):
+                    ticket = algorithm.market_order(security.symbol, quantity, asynchronous=True, tag=target.tag)
+                    self._order_tickets[ticket.order_id] = ticket
+
+            self._targets_collection.clear_fulfilled(algorithm)
+
+    def on_order_event(self, order_event):
+        # This method will get events for all orders, but if we save the tickets in Execute we can filter
+        # to process events for orders placed by this model
+        if order_event.order_id in self._order_tickets:
+            ticket = self._order_tickets[order_event.order_id]
+            if order_event.status.is_fill():
+                self._algorithm.debug(f"Purchased Stock: {order_event.symbol}")
+            if order_event.status.is_closed():
+                del self._order_tickets[order_event.order_id]
+
+        self.order_events.append(order_event)

Algorithm/Execution/ExecutionModel.cs

@@ -15,6 +15,7 @@
 
 using QuantConnect.Algorithm.Framework.Portfolio;
 using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Orders;
 
 namespace QuantConnect.Algorithm.Framework.Execution
 {
@@ -57,5 +58,13 @@ public virtual void Execute(QCAlgorithm algorithm, IPortfolioTarget[] targets)
         public virtual void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
         {
         }
+
+        /// <summary>
+        /// New order event handler
+        /// </summary>
+        /// <param name="orderEvent">Order event to process</param>
+        public virtual void OnOrderEvent(OrderEvent orderEvent)
+        {
+        }
     }
 }