Fix some python regression algorithms

Author: Martin-Molinero

Algorithm.Python/BasicTemplateIndexDailyAlgorithm.py

@@ -45,23 +45,23 @@ def initialize(self) -> None:
         self.settings.daily_precise_end_time = True
 
     def on_data(self, data: Slice):
-        if not self.Portfolio.Invested:
+        if not self.portfolio.invested:
             # SPX Index is not tradable, but we can trade an option
-            self.MarketOrder(self.spx_option, 1)
+            self.market_order(self.spx_option, 1)
         else:
-            self.Liquidate()
+            self.liquidate()
 
         # Count how many slices we receive with SPX data in it to assert later
-        if data.ContainsKey(self.spx):
+        if data.contains_key(self.spx):
             self.BarCounter = self.BarCounter + 1
 
     def OnEndOfAlgorithm(self):
         if self.BarCounter != self.ExpectedBarCount:
             raise ValueError(f"Bar Count {self.BarCounter} is not expected count of {self.ExpectedBarCount}")
 
         for symbol in [ self.spx_option, self.spx ]:
-            history = self.History(symbol, 10)
+            history = self.history(symbol, 10)
             if len(history) != 10:
-                raise ValueError(f"Unexpected history count: {history.Count}")
+                raise ValueError(f"Unexpected history count: {len(history)}")
             if any(x for x in history.index.get_level_values('time') if x.time() != time(15, 15, 0)):
                 raise ValueError(f"Unexpected history data time")

Algorithm.Python/CanLiquidateWithOrderPropertiesRegressionAlgorithm.py

@@ -35,5 +35,5 @@ def on_data(self, slice):
                 order_properties.time_in_force = TimeInForce.DAY
                 tickets = self.liquidate(asynchronous = True, order_properties = order_properties)
                 for ticket in tickets:
-                    if ticket.SubmitRequest.OrderProperties.TimeInForce != TimeInForce.DAY:
-                        raise AssertionError(f"The TimeInForce for all orders should be daily, but it was {ticket.SubmitRequest.OrderProperties.TimeInForce}")
+                    if ticket.submit_request.order_properties.time_in_force != TimeInForce.DAY:
+                        raise AssertionError(f"The TimeInForce for all orders should be daily, but it was {ticket.submit_request.order_properties.time_in_force}")

Algorithm.Python/ConstituentsUniverseRegressionAlgorithm.py

@@ -75,10 +75,10 @@ def on_end_of_algorithm(self):
 
     def  OnSecuritiesChanged(self, changes):
         for added in changes.added_securities:
-            self.log(f"{self.Time} AddedSecurities " + str(added))
+            self.log(f"{self.time} AddedSecurities " + str(added))
 
         for removed in changes.removed_securities:
-            self.log(f"{self.Time} RemovedSecurities " + str(removed) + str(self._step))
+            self.log(f"{self.time} RemovedSecurities " + str(removed) + str(self._step))
             # we are currently notifying the removal of AAPl twice,
             # when deselected and when finally removed (since it stayed pending)
             if removed.symbol == self._appl and self._step != 1 and self._step != 2 or removed.symbol == self._qqq and self._step != 1:

Algorithm.Python/DataConsolidationAlgorithm.py

@@ -33,8 +33,8 @@ class DataConsolidationAlgorithm(QCAlgorithm):
     def initialize(self):
         '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
 
-        self.set_start_date(DateTime(2013, 10, 7, 9, 30, 0))  #Set Start Date
-        self.set_end_date(self.start_date + timedelta(60))          #Set End Date
+        self.set_start_date(2013, 10, 7)  #Set Start Date
+        self.set_end_date(2013, 12, 7)  #Set End Date
         # Find more symbols here: http://quantconnect.com/data
         self.add_equity("SPY")
         self.add_forex("EURUSD", Resolution.HOUR)

Algorithm.Python/DescendingCustomDataObjectStoreRegressionAlgorithm.py

@@ -79,7 +79,7 @@ def on_end_of_algorithm(self):
         for i in range(len(history) - 1):
             # [1] - time
             if history.index[i][1] > history.index[i + 1][1]:
-                raise RegressionTestException(
+                raise AssertionError(
                     f"Order failure: {history.index[i][1]} > {history.index[i + 1][1]} at index {i}.")
 
     def get_custom_data_key(self):

Algorithm.Python/FundamentalUniverseSelectionAlgorithm.py

@@ -34,6 +34,7 @@ def initialize(self):
         self.set_universe_selection(FundamentalUniverseSelectionModel(self.select))
 
         self.changes = None
+        self.number_of_symbols_fundamental = 10
 
     # return a list of three fixed symbol objects
     def selection_function(self, fundamental):

Algorithm.Python/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.py

@@ -51,10 +51,10 @@ def on_data(self, data: Slice):
     def on_end_of_algorithm(self):
         not_encountered = [str(k) for k,v in self.expected_symbols.items() if not v]
         if any(not_encountered):
-            raise AggregateException(f"Expected all Symbols encountered and invested in, but the following were not found: {', '.join(not_encountered)}")
+            raise AssertionError(f"Expected all Symbols encountered and invested in, but the following were not found: {', '.join(not_encountered)}")
 
         if not self.portfolio.invested:
-            raise AggregateException("Expected holdings at the end of algorithm, but none were found.")
+            raise AssertionError("Expected holdings at the end of algorithm, but none were found.")
 
     def is_in_regular_hours(self, symbol):
         return self.securities[symbol].exchange.exchange_open

Algorithm.Python/ImmediateExecutionModelWorksWithBinanceFeeModel.py

@@ -26,10 +26,10 @@ class ImmediateExecutionModelWorksWithBinanceFeeModel(QCAlgorithm):
 
     def Initialize(self):
         # *** initial configurations and backtest ***
-        self.SetStartDate(2022, 12, 13)  # Set Start Date
-        self.SetEndDate(2022, 12, 14)  # Set End Date
-        self.SetAccountCurrency("BUSD") # Set Account Currency
-        self.SetCash("BUSD", 100000, 1)  # Set Strategy Cash
+        self.set_start_date(2022, 12, 13)  # Set Start Date
+        self.set_end_date(2022, 12, 14)  # Set End Date
+        self.set_account_currency("BUSD") # Set Account Currency
+        self.set_cash("BUSD", 100000, 1)  # Set Strategy Cash
 
         self.universe_settings.resolution = Resolution.MINUTE
 
@@ -43,7 +43,7 @@ def Initialize(self):
         self.set_execution(ImmediateExecutionModel())
 
 
-        self.SetBrokerageModel(BrokerageName.Binance, AccountType.Margin)
+        self.set_brokerage_model(BrokerageName.BINANCE, AccountType.MARGIN)
 
     def on_order_event(self, order_event: OrderEvent) -> None:
         if order_event.status == OrderStatus.FILLED:

Algorithm.Python/LiveFeaturesAlgorithm.py

@@ -12,7 +12,6 @@
 # limitations under the License.
 
 from AlgorithmImports import *
-from System.Globalization import *
 
 ### <summary>
 ### Live Trading Functionality Demonstration algorithm including SMS, Email and Web hook notifications.
@@ -47,7 +46,7 @@ def initialize(self):
 
 
     ### New Bitcoin Data Event
-    def on_data(Bitcoin, data):
+    def on_data(self, Bitcoin, data):
         if self.live_mode:
             self.set_runtime_statistic('BTC', str(data.close))
 
@@ -94,7 +93,7 @@ def get_source(self, config, date, is_live_mode):
         if is_live_mode:
             return SubscriptionDataSource("https://www.bitstamp.net/api/ticker/", SubscriptionTransportMedium.REST)
 
-        return  SubscriptionDataSource("https://www.quandl.com/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc", SubscriptionTransportMedium.REMOTE_FILE)
+        return SubscriptionDataSource("https://www.quandl.com/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc", SubscriptionTransportMedium.REMOTE_FILE)
 
 
     def reader(self, config, line, date, is_live_mode):

Algorithm.Python/MacdAlphaModelFrameworkRegressionAlgorithm.py

@@ -27,4 +27,4 @@ def initialize(self):
     def on_end_of_algorithm(self):
         expected = 4
         if self.insights.total_count != expected:
-           raise Exception(f"The total number of insights should be {expected}. Actual: {self.insights.total_count}")
+           raise AssertionError(f"The total number of insights should be {expected}. Actual: {self.insights.total_count}")

Algorithm.Python/OptionUniverseFilterGreeksRegressionAlgorithm.py

@@ -53,8 +53,8 @@ def main_filter(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
         filtered_contracts = len(list(filtered_universe))
 
         if filtered_contracts == total_contracts:
-            raise RegressionTestException(f"Expected filtered universe to have less contracts than original universe. "
-                                          f"Filtered contracts count ({filtered_contracts}) is equal to total contracts count ({total_contracts})")
+            raise AssertionError(f"Expected filtered universe to have less contracts than original universe. "
+                                 f"Filtered contracts count ({filtered_contracts}) is equal to total contracts count ({total_contracts})")
 
         return filtered_universe
 
@@ -88,4 +88,4 @@ def on_data(self, slice: Slice) -> None:
 
     def on_end_of_algorithm(self) -> None:
         if not self.option_chain_received:
-            raise RegressionTestException("Option chain was not received.")
+            raise AssertionError("Option chain was not received.")

Algorithm.Python/OptionUniverseHistoryRegressionAlgorithm.py

@@ -29,7 +29,7 @@ def initialize(self):
 
         # Level 0 of the multi-index is the date, we expect 3 dates, 3 option chains
         if historical_options_data_df.index.levshape[0] != 3:
-            raise RegressionTestException(f"Expected 3 option chains from history request, but got {historical_options_data_df.index.levshape[1]}")
+            raise AssertionError(f"Expected 3 option chains from history request, but got {historical_options_data_df.index.levshape[1]}")
 
         for date in historical_options_data_df.index.levels[0]:
             expected_chain = list(self.option_chain_provider.get_option_contract_list(option, date))
@@ -39,9 +39,9 @@ def initialize(self):
             actual_chain_count = len(actual_chain)
 
             if expected_chain_count != actual_chain_count:
-                raise RegressionTestException(f"Expected {expected_chain_count} options in chain on {date}, but got {actual_chain_count}")
+                raise AssertionError(f"Expected {expected_chain_count} options in chain on {date}, but got {actual_chain_count}")
 
             for i, symbol in enumerate(actual_chain.index):
                 expected_symbol = expected_chain[i]
                 if symbol != expected_symbol:
-                    raise RegressionTestException(f"Expected symbol {expected_symbol} at index {i} on {date}, but got {symbol}")
+                    raise AssertionError(f"Expected symbol {expected_symbol} at index {i} on {date}, but got {symbol}")

Algorithm.Python/PersistentCustomDataUniverseRegressionAlgorithm.py

@@ -35,23 +35,23 @@ def universe_selector(self, data):
     def retrieve_historical_data(self):
         history = list(self.history[StockDataSource](self._universe_symbol, datetime(2018, 1, 1), datetime(2018, 6, 1), Resolution.DAILY))
         if (len(history) == 0):
-            raise RegressionTestException(f"No historical data received for symbol {self._universe_symbol}.")
+            raise AssertionError(f"No historical data received for symbol {self._universe_symbol}.")
 
         # Ensure all values are of type StockDataSource
         for item in history:
             if not isinstance(item, StockDataSource):
-                raise RegressionTestException(f"Unexpected data type in history. Expected StockDataSource but received {type(item).__name__}.")
+                raise AssertionError(f"Unexpected data type in history. Expected StockDataSource but received {type(item).__name__}.")
 
     def OnData(self, slice: Slice):
         if self._universe_symbol not in slice:
-            raise RegressionTestException(f"No data received for the universe symbol: {self._universe_symbol}.")
+            raise AssertionError(f"No data received for the universe symbol: {self._universe_symbol}.")
         if (not self._data_received):
             self.retrieve_historical_data()
         self._data_received = True
 
     def OnEndOfAlgorithm(self) -> None:
         if not self._data_received:
-            raise RegressionTestException("No data was received after the universe selection.")
+            raise AssertionError("No data was received after the universe selection.")
 
 class StockDataSource(PythonData):
 

Algorithm.Python/RawDataRegressionAlgorithm.py

@@ -61,6 +61,6 @@ def on_data(self, data):
                 day_factor = self._factor_file.get_price_scale_factor(googl_data.time)
                 probable_raw_price = googl_data.close / day_factor  # Undo adjustment
 
-                raise Exception("Close price was incorrect; it appears to be the adjusted value"
+                raise AssertionError("Close price was incorrect; it appears to be the adjusted value"
                     if expected_raw_price == probable_raw_price else
                    "Close price was incorrect; Data may have changed.")

Algorithm.Python/WarmupAlgorithm.py

@@ -34,8 +34,8 @@ def initialize(self):
         fast_period = 60
         slow_period = 3600
 
-        self.fast = self.EMA("SPY", fast_period)
-        self.slow = self.EMA("SPY", slow_period)
+        self.fast = self.ema("SPY", fast_period)
+        self.slow = self.ema("SPY", slow_period)
 
         self.set_warmup(slow_period)
         self.first = True