Addresses Peer-Review

Author: AlexCatarino

Algorithm.CSharp/CustomSignalExportDemonstrationAlgorithm.cs

@@ -14,11 +14,13 @@
 */
 
 using Newtonsoft.Json;
+using QuantConnect.Algorithm.Framework.Portfolio;
 using QuantConnect.Algorithm.Framework.Portfolio.SignalExports;
 using QuantConnect.Api;
 using QuantConnect.Data;
 using QuantConnect.Interfaces;
 using System;
+using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text;
@@ -43,6 +45,7 @@ public override void Initialize()
 
             /// Our custom signal export accepts all asset types
             AddEquity("SPY", Resolution.Second);
+            AddCrypto("BTCUSD", Resolution.Second);
             AddForex("EURUSD", Resolution.Second);
             AddFutureContract(QuantConnect.Symbol.CreateFuture("ES", Market.CME, new DateTime(2023, 12, 15), null));
             AddOptionContract(QuantConnect.Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 130, new DateTime(2023, 9, 1)));
@@ -57,7 +60,7 @@ public override void Initialize()
         /// <param name="slice"></param>
         public override void OnData(Slice slice)
         {
-            foreach (var ticker in new[] { "SPY", "EURUSD" })
+            foreach (var ticker in new[] { "SPY", "EURUSD", "BTCUSD" })
             {
                 if (!Portfolio[ticker].Invested && Securities[ticker].HasData)
                 {
@@ -74,10 +77,17 @@ internal class CustomSignalExport : ISignalExportTarget
 
         public bool Send(SignalExportTargetParameters parameters)
         {
-            var message = JsonConvert.SerializeObject(parameters.Targets);
+            object SimplePayload(PortfolioTarget target)
+            {
+                var newTarget = PortfolioTarget.Percent(parameters.Algorithm, target.Symbol, target.Quantity);
+                return new { symbol = newTarget.Symbol.Value, quantity = newTarget.Quantity };
+            };
+
+            var message = JsonConvert.SerializeObject(parameters.Targets.Select(SimplePayload));
             using var httpMessage = new StringContent(message, Encoding.UTF8, "application/json");
             using HttpResponseMessage response = _httpClient.PostAsync(_requestUri, httpMessage).Result;
             var result = response.Content.ReadFromJsonAsync<RestResponse>().Result;
+            parameters.Algorithm.Log($"Send #{parameters.Targets.Count} targets. Success: {result.Success}");
             return result.Success;
         }
 
@@ -86,6 +96,7 @@ public bool Send(SignalExportTargetParameters parameters)
 }
 
 /*
+# To test the algorithm, you can create a simple Python Flask application (app.py) and run flask
 # $ flask --app app run 
 
 # app.py:
@@ -95,6 +106,7 @@ from json import loads
 @app.post('/')
 def handle_positions():
     result = loads(request.data)
+    print(result)
     return jsonify({'success': True,'message': f'{len(result)} positions received'})
 if __name__ == '__main__':
     app.run(debug=True)

Algorithm.Python/CustomSignalExportDemonstrationAlgorithm.py

@@ -30,6 +30,7 @@ def initialize(self) -> None:
 
         # Our custom signal export accepts all asset types
         self.add_equity("SPY", Resolution.SECOND)
+        self.add_crypto("BTCUSD", Resolution.SECOND)
         self.add_forex("EURUSD", Resolution.SECOND)
         self.add_future_contract(Symbol.create_future("ES", Market.CME, datetime(2023, 12, 15), None))
         self.add_option_contract(Symbol.create_option("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 130, datetime(2023, 9, 1)))
@@ -39,22 +40,27 @@ def initialize(self) -> None:
 
     def on_data(self, data: Slice) -> None:
         '''Buy and hold EURUSD and SPY'''
-        for ticker in [ "SPY", "EURUSD" ]:
+        for ticker in [ "SPY", "EURUSD", "BTCUSD" ]:
             if not self.portfolio[ticker].invested and self.securities[ticker].has_data:
                 self.set_holdings(ticker, 0.5)
 
 from requests import post
 class CustomSignalExport:
     def send(self, parameters: SignalExportTargetParameters) -> bool:
-        data = { x.symbol.value: x.quantity for x in parameters.targets }
+        targets = [PortfolioTarget.percent(parameters.algorithm, x.symbol, x.quantity) 
+                   for x in parameters.targets] ;
+        data = [ {'symbol' : x.symbol.value, 'quantity': x.quantity} for x in targets ]
         response = post("http://localhost:5000/", json = data)
         result = response.json()
-        return result.get('success', False)        
+        success = result.get('success', False)
+        parameters.algorithm.log(f"Send #{len(parameters.targets)} targets. Success: {success}");
+        return success      
 
     def dispose(self):
         pass
 
 '''
+# To test the algorithm, you can create a simple Python Flask application (app.py) and run flask
 # $ flask --app app run 
 
 # app.py:
@@ -64,6 +70,7 @@ def dispose(self):
 @app.post('/')
 def handle_positions():
     result = loads(request.data)
+    print(result)
     return jsonify({'success': True,'message': f'{len(result)} positions received'})
 if __name__ == '__main__':
     app.run(debug=True)

Common/Algorithm/Framework/Portfolio/SignalExports/SignalExportManager.cs

@@ -22,7 +22,6 @@
 using System;
 using System.Linq;
 using QuantConnect.Util;
-using QLNet;
 
 namespace QuantConnect.Algorithm.Framework.Portfolio.SignalExports
 {
@@ -35,7 +34,7 @@ public class SignalExportManager
         /// <summary>
         /// Records the time of the first order event of a group of events
         /// </summary>
-        private DateTime _initialOrderEventTimeUtc = Time.EndOfTime;
+        private ReferenceWrapper<DateTime> _initialOrderEventTimeUtc = new(Time.EndOfTime);
 
         /// <summary>
         /// List of signal export providers
@@ -85,19 +84,37 @@ public void AddSignalExportProvider(ISignalExportTarget signalExport)
         /// <param name="signalExport">Signal export provider</param>
         public void AddSignalExportProvider(PyObject signalExport)
         {
-            AddSignalExportProvider(new SignalExportTargetPythonWrapper(signalExport));
+            if (!signalExport.TryConvert<ISignalExportTarget>(out var managedSignalExport))
+            {
+                managedSignalExport = new SignalExportTargetPythonWrapper(signalExport);
+            }
+            AddSignalExportProvider(managedSignalExport);
         }
 
         /// <summary>
         /// Adds one or more new signal exports providers
         /// </summary>
         /// <param name="signalExports">One or more signal export provider</param>
-        [Obsolete("This method is deprecated. Please use AddSignalExportProvider(ISignalExportTarget).")]
         public void AddSignalExportProviders(params ISignalExportTarget[] signalExports)
         {
             signalExports.DoForEach(AddSignalExportProvider);
         }
 
+        /// <summary>
+        /// Adds one or more new signal exports providers
+        /// </summary>
+        /// <param name="signalExports">One or more signal export provider</param>
+        public void AddSignalExportProviders(PyObject signalExports)
+        {
+            using var _ = Py.GIL();
+            if (!signalExports.IsIterable())
+            {
+                AddSignalExportProvider(signalExports);
+                return;
+            }
+            PyList.AsList(signalExports).DoForEach(AddSignalExportProvider);
+        }
+
         /// <summary>
         /// Sets the portfolio targets from the algorihtm's Portfolio and sends them with the
         /// algorithm being ran to the signal exports providers already set
@@ -215,9 +232,9 @@ private IEnumerable<PortfolioTarget> GetPortfolioTargets(decimal totalPortfolioV
         /// <param name="orderEvent">Event information</param>
         public void OnOrderEvent(OrderEvent orderEvent)
         {
-            if (_initialOrderEventTimeUtc == Time.EndOfTime && orderEvent.Status.IsFill())
+            if (_initialOrderEventTimeUtc.Value == Time.EndOfTime && orderEvent.Status.IsFill())
             {
-                _initialOrderEventTimeUtc = DateTime.UtcNow;
+                _initialOrderEventTimeUtc = new(orderEvent.UtcTime);
             }
         }
 
@@ -227,19 +244,28 @@ public void OnOrderEvent(OrderEvent orderEvent)
         /// <param name="currentTimeUtc">The current time of synchronous events</param>
         public void Flush(DateTime currentTimeUtc)
         {
-            if (_initialOrderEventTimeUtc == Time.EndOfTime || !AutomaticExportTimeSpan.HasValue)
+            var initialOrderEventTimeUtc = _initialOrderEventTimeUtc.Value;
+            if (initialOrderEventTimeUtc == Time.EndOfTime || !AutomaticExportTimeSpan.HasValue)
             {
                 return;
             }
 
-            if (currentTimeUtc - _initialOrderEventTimeUtc < AutomaticExportTimeSpan)
+            if (currentTimeUtc - initialOrderEventTimeUtc < AutomaticExportTimeSpan)
             {
                 return;
             }
-            
-            var success = SetTargetPortfolioFromPortfolio();
-            Logging.Log.Trace($"SignalExportManager.Flush({currentTimeUtc:T}) :: Success: {success}. Initial OrderEvent Time: {_initialOrderEventTimeUtc:T}");
-            _initialOrderEventTimeUtc = Time.EndOfTime;
+
+            try
+            {
+                SetTargetPortfolioFromPortfolio();
+            }
+            catch (Exception exception)
+            {
+                // SetTargetPortfolioFromPortfolio logs all known error on LEAN side.
+                // Exceptions occurs in the ISignalExportTarget.Send method (user-defined).
+                _algorithm.Error($"Failed to send portfolio target(s). Reason: {exception.Message}.{Environment.NewLine}{exception.StackTrace}");
+            }
+            _initialOrderEventTimeUtc = new(Time.EndOfTime);
         }
     }
 }

Common/Python/SignalExportTargetPythonWrapper.cs

@@ -22,12 +22,14 @@ namespace QuantConnect.Python
     /// <summary>
     /// Provides an implementation of <see cref="ISignalExportTarget"/> that wraps a <see cref="PyObject"/> object
     /// </summary>
-    /// <remarks>
-    /// Constructor for initialising the <see cref="SignalExportTargetPythonWrapper"/> class with wrapped <see cref="PyObject"/> object
-    /// </remarks>
-    /// <param name="model">Python benchmark model</param>
-    public class SignalExportTargetPythonWrapper(PyObject model) : BasePythonWrapper<ISignalExportTarget>(model), ISignalExportTarget
+    public class SignalExportTargetPythonWrapper : BasePythonWrapper<ISignalExportTarget>, ISignalExportTarget
     {
+        /// <summary>
+        /// Constructor for initialising the <see cref="SignalExportTargetPythonWrapper"/> class with wrapped <see cref="PyObject"/> object
+        /// </summary>
+        /// <param name="instance">The underlying python instance</param>
+        public SignalExportTargetPythonWrapper(PyObject instance) : base(instance) { }
+
         /// <summary>
         /// Interface to send positions holdings to different 3rd party API's
         /// </summary>