Add python syntax check

Author: Martin-Molinero

.github/workflows/syntax-tests.yml

@@ -0,0 +1,32 @@
+name: Syntax Tests
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
+      - name: Run Syntax Test
+        uses: addnab/docker-run-action@v3
+        with:
+          image: quantconnect/lean:foundation
+          options: --workdir /__w/Lean/Lean -v /home/runner/work:/__w
+          shell: bash
+          run: |
+            pip install --no-cache-dir quantconnect-stubs && \
+            python run_syntax_check.py

Algorithm.Python/AlgorithmModeAndDeploymentTargetAlgorithm.py

@@ -26,19 +26,19 @@ def initialize(self):
         self.debug(f"Algorithm Mode: {self.algorithm_mode}. Is Live Mode: {self.live_mode}. Deployment Target: {self.deployment_target}.")
 
         if self.algorithm_mode != AlgorithmMode.BACKTESTING:
-            raise Exception(f"Algorithm mode is not backtesting. Actual: {self.algorithm_mode}")
+            raise AssertionError(f"Algorithm mode is not backtesting. Actual: {self.algorithm_mode}")
 
         if self.live_mode:
-            raise Exception("Algorithm should not be live")
+            raise AssertionError("Algorithm should not be live")
 
         if self.deployment_target != DeploymentTarget.LOCAL_PLATFORM:
-            raise Exception(f"Algorithm deployment target is not local. Actual{self.deployment_target}")
+            raise AssertionError(f"Algorithm deployment target is not local. Actual{self.deployment_target}")
 
         # For a live deployment these checks should pass:
-        # if self.algorithm_mode != AlgorithmMode.LIVE: raise Exception("Algorithm mode is not live")
-        # if not self.live_mode: raise Exception("Algorithm should be live")
+        # if self.algorithm_mode != AlgorithmMode.LIVE: raise AssertionError("Algorithm mode is not live")
+        # if not self.live_mode: raise AssertionError("Algorithm should be live")
 
         # For a cloud deployment these checks should pass:
-        # if self.deployment_target != DeploymentTarget.CLOUD_PLATFORM: raise Exception("Algorithm deployment target is not cloud")
+        # if self.deployment_target != DeploymentTarget.CLOUD_PLATFORM: raise AssertionError("Algorithm deployment target is not cloud")
 
         self.quit()

Algorithm.Python/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.py

@@ -59,7 +59,7 @@ def on_data(self, data):
                 continue
             shortable_quantity = security.shortable_provider.shortable_quantity(symbol, self.time)
             if not shortable_quantity:
-                raise Exception(f"Expected {symbol} to be shortable on {self.time.strftime('%Y%m%d')}")
+                raise AssertionError(f"Expected {symbol} to be shortable on {self.time.strftime('%Y%m%d')}")
 
             """
             Buy at least once into all Symbols. Since daily data will always use
@@ -76,22 +76,22 @@ def coarse_selection(self, coarse):
         if self.time.date() == self._20140327.date():
             gme = Symbol.create("GME", SecurityType.EQUITY, Market.USA)
             if gme not in shortable_symbols.keys():
-                raise Exception("Expected unmapped GME in shortable symbols list on 2014-03-27")
+                raise AssertionError("Expected unmapped GME in shortable symbols list on 2014-03-27")
             if "GME" not in list(map(lambda x: x.symbol.value, coarse)):
-                raise Exception("Expected mapped GME in coarse symbols on 2014-03-27")
+                raise AssertionError("Expected mapped GME in coarse symbols on 2014-03-27")
 
             expected_missing = 1
 
         missing = list(filter(lambda x: x not in selected_symbols, self.expected_symbols[self.time]))
         if len(missing) != expected_missing:
-            raise Exception(f"Expected Symbols selected on {self.time.strftime('%Y%m%d')} to match expected Symbols, but the following Symbols were missing: {', '.join(list(map(lambda x:x.value, missing)))}")
+            raise AssertionError(f"Expected Symbols selected on {self.time.strftime('%Y%m%d')} to match expected Symbols, but the following Symbols were missing: {', '.join(list(map(lambda x:x.value, missing)))}")
 
         self.coarse_selected[self.time] = True
         return selected_symbols
 
     def on_end_of_algorithm(self):
         if not all(x for x in self.coarse_selected.values()):
-            raise Exception(f"Expected coarse selection on all dates, but didn't run on: {', '.join(list(map(lambda x: x.key.strftime('%Y%m%d'), filter(lambda x:not x.value, self.coarse_selected))))}")
+            raise AssertionError(f"Expected coarse selection on all dates, but didn't run on: {', '.join(list(map(lambda x: x.key.strftime('%Y%m%d'), filter(lambda x:not x.value, self.coarse_selected))))}")
 
 class AllShortableSymbolsRegressionAlgorithmBrokerageModel(DefaultBrokerageModel):
     def __init__(self, shortable_provider):

Algorithm.Python/Alphas/ShareClassMeanReversionAlpha.py

@@ -67,7 +67,7 @@ def __init__(self, *args, **kwargs):
         self.alpha = None
         self.beta = None
         if 'tickers' not in kwargs:
-            raise Exception('ShareClassMeanReversionAlphaModel: Missing argument: "tickers"')
+            raise AssertionError('ShareClassMeanReversionAlphaModel: Missing argument: "tickers"')
         self.tickers = kwargs['tickers']
         self.position_value = None
         self.invested = False

Algorithm.Python/BaseFrameworkRegressionAlgorithm.py

@@ -46,4 +46,4 @@ def on_end_of_algorithm(self):
         # The base implementation checks for active insights
         insights_count = len(self.insights.get_insights(lambda insight: insight.is_active(self.utc_time)))
         if insights_count != 0:
-            raise Exception(f"The number of active insights should be 0. Actual: {insights_count}")
+            raise AssertionError(f"The number of active insights should be 0. Actual: {insights_count}")

Algorithm.Python/BasicTemplateCryptoFutureAlgorithm.py

@@ -60,13 +60,13 @@ def on_data(self, slice):
             self.interest_per_symbol[interest_rate.key] += 1
             self.cached_interest_rate = self.securities[interest_rate.key].cache.get_data[MarginInterestRate]()
             if self.cached_interest_rate != interest_rate.value:
-                raise Exception(f"Unexpected cached margin interest rate for {interest_rate.key}!")
+                raise AssertionError(f"Unexpected cached margin interest rate for {interest_rate.key}!")
 
         if self.fast > self.slow:
             if self.portfolio.invested == False and self.transactions.orders_count == 0:
                 self.ticket = self.buy(self.btc_usd.symbol, 50)
                 if self.ticket.status != OrderStatus.INVALID:
-                    raise Exception(f"Unexpected valid order {self.ticket}, should fail due to margin not sufficient")
+                    raise AssertionError(f"Unexpected valid order {self.ticket}, should fail due to margin not sufficient")
 
                 self.buy(self.btc_usd.symbol, 1)
 
@@ -76,14 +76,14 @@ def on_data(self, slice):
                 self.holdings_value_btc_usd = 100
 
                 if abs(self.btc_usd_holdings.total_sale_volume - self.holdings_value_btc_usd) > 1:
-                    raise Exception(f"Unexpected TotalSaleVolume {self.btc_usd_holdings.total_sale_volume}")
+                    raise AssertionError(f"Unexpected TotalSaleVolume {self.btc_usd_holdings.total_sale_volume}")
 
                 if abs(self.btc_usd_holdings.absolute_holdings_cost - self.holdings_value_btc_usd) > 1:
-                    raise Exception(f"Unexpected holdings cost {self.btc_usd_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {self.btc_usd_holdings.holdings_cost}")
 
                 # margin used is based on the maintenance rate
                 if (abs(self.btc_usd_holdings.absolute_holdings_cost * 0.05 - self.margin_used) > 1) or (BuyingPowerModelExtensions.get_maintenance_margin(self.btc_usd.buying_power_model, self.btc_usd) != self.margin_used):
-                    raise Exception(f"Unexpected margin used {self.margin_used}")
+                    raise AssertionError(f"Unexpected margin used {self.margin_used}")
 
                 self.buy(self.ada_usdt.symbol, 1000)
 
@@ -94,29 +94,29 @@ def on_data(self, slice):
                 self.holdings_value_usdt = self.ada_usdt.price * self.ada_usdt.symbol_properties.contract_multiplier * 1000
 
                 if abs(self.ada_usdt_holdings.total_sale_volume - self.holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected TotalSaleVolume {self.ada_usdt_holdings.total_sale_volume}")
+                    raise AssertionError(f"Unexpected TotalSaleVolume {self.ada_usdt_holdings.total_sale_volume}")
 
                 if abs(self.ada_usdt_holdings.absolute_holdings_cost - self.holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
 
                 if (abs(self.ada_usdt_holdings.absolute_holdings_cost * 0.05 - self.margin_used) > 1) or (BuyingPowerModelExtensions.get_maintenance_margin(self.ada_usdt.buying_power_model, self.ada_usdt) != self.margin_used):
-                    raise Exception(f"Unexpected margin used {self.margin_used}")
+                    raise AssertionError(f"Unexpected margin used {self.margin_used}")
 
                 # position just opened should be just spread here
                 self.profit = self.portfolio.total_unrealized_profit
 
                 if (5 - abs(self.profit)) < 0:
-                    raise Exception(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
+                    raise AssertionError(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
 
                 if (self.portfolio.total_profit != 0):
-                    raise Exception(f"Unexpected TotalProfit {self.portfolio.total_profit}")
+                    raise AssertionError(f"Unexpected TotalProfit {self.portfolio.total_profit}")
 
         else:
             if self.time.hour > 10 and self.transactions.orders_count == 3:
                 self.sell(self.btc_usd.symbol, 3)
                 self.btc_usd_holdings = self.btc_usd.holdings
                 if abs(self.btc_usd_holdings.absolute_holdings_cost - 100 * 2) > 1:
-                    raise Exception(f"Unexpected holdings cost {self.btc_usd_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {self.btc_usd_holdings.holdings_cost}")
 
                 self.sell(self.ada_usdt.symbol, 3000)
                 ada_usdt_holdings = self.ada_usdt.holdings
@@ -125,22 +125,22 @@ def on_data(self, slice):
                 holdings_value_usdt = self.ada_usdt.price * self.ada_usdt.symbol_properties.contract_multiplier * 2000
 
                 if abs(ada_usdt_holdings.absolute_holdings_cost - holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected holdings cost {ada_usdt_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {ada_usdt_holdings.holdings_cost}")
 
                 # position just opened should be just spread here
                 profit = self.portfolio.total_unrealized_profit
                 if (5 - abs(profit)) < 0:
-                    raise Exception(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
+                    raise AssertionError(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
                 # we barely did any difference on the previous trade
                 if (5 - abs(self.portfolio.total_profit)) < 0:
-                    raise Exception(f"Unexpected TotalProfit {self.portfolio.total_profit}")
+                    raise AssertionError(f"Unexpected TotalProfit {self.portfolio.total_profit}")
 
 
     def on_end_of_algorithm(self):
         if self.interest_per_symbol[self.ada_usdt.symbol] != 1:
-                raise Exception(f"Unexpected interest rate count {self.interest_per_symbol[self.ada_usdt.symbol]}")
+                raise AssertionError(f"Unexpected interest rate count {self.interest_per_symbol[self.ada_usdt.symbol]}")
         if self.interest_per_symbol[self.btc_usd.symbol] != 3:
-                raise Exception(f"Unexpected interest rate count {self.interest_per_symbol[self.btc_usd.symbol]}")
+                raise AssertionError(f"Unexpected interest rate count {self.interest_per_symbol[self.btc_usd.symbol]}")
 
     def on_order_event(self, order_event):
         self.debug("{0} {1}".format(self.time, order_event))

Algorithm.Python/BasicTemplateCryptoFutureHourlyAlgorithm.py

@@ -58,13 +58,13 @@ def on_data(self, slice):
             self.interest_per_symbol[interest_rate.key] += 1
             self.cached_interest_rate = self.securities[interest_rate.key].cache.get_data[MarginInterestRate]()
             if self.cached_interest_rate != interest_rate.value:
-                raise Exception(f"Unexpected cached margin interest rate for {interest_rate.key}!")
+                raise AssertionError(f"Unexpected cached margin interest rate for {interest_rate.key}!")
 
         if self.fast > self.slow:
             if self.portfolio.invested == False and self.transactions.orders_count == 0:
                 self.ticket = self.buy(self.ada_usdt.symbol, 100000)
                 if self.ticket.status != OrderStatus.INVALID:
-                    raise Exception(f"Unexpected valid order {self.ticket}, should fail due to margin not sufficient")
+                    raise AssertionError(f"Unexpected valid order {self.ticket}, should fail due to margin not sufficient")
 
                 self.buy(self.ada_usdt.symbol, 1000)
 
@@ -76,22 +76,22 @@ def on_data(self, slice):
                 self.holdings_value_usdt = self.ada_usdt.price * self.ada_usdt.symbol_properties.contract_multiplier * 1000
 
                 if abs(self.ada_usdt_holdings.total_sale_volume - self.holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected TotalSaleVolume {self.ada_usdt_holdings.total_sale_volume}")
+                    raise AssertionError(f"Unexpected TotalSaleVolume {self.ada_usdt_holdings.total_sale_volume}")
 
                 if abs(self.ada_usdt_holdings.absolute_holdings_cost - self.holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
 
                 if (abs(self.ada_usdt_holdings.absolute_holdings_cost * 0.05 - self.margin_used) > 1) or (BuyingPowerModelExtensions.get_maintenance_margin(self.ada_usdt.buying_power_model, self.ada_usdt) != self.margin_used):
-                    raise Exception(f"Unexpected margin used {self.margin_used}")
+                    raise AssertionError(f"Unexpected margin used {self.margin_used}")
 
                 # position just opened should be just spread here
                 self.profit = self.portfolio.total_unrealized_profit
 
                 if (5 - abs(self.profit)) < 0:
-                    raise Exception(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
+                    raise AssertionError(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
 
                 if (self.portfolio.total_profit != 0):
-                    raise Exception(f"Unexpected TotalProfit {self.portfolio.total_profit}")
+                    raise AssertionError(f"Unexpected TotalProfit {self.portfolio.total_profit}")
 
         else:
             # let's revert our position and double
@@ -104,23 +104,23 @@ def on_data(self, slice):
                 self.holdings_value_usdt = self.ada_usdt.price * self.ada_usdt.symbol_properties.contract_multiplier * 2000
 
                 if abs(self.ada_usdt_holdings.absolute_holdings_cost - self.holdings_value_usdt) > 1:
-                    raise Exception(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
+                    raise AssertionError(f"Unexpected holdings cost {self.ada_usdt_holdings.holdings_cost}")
 
                 # position just opened should be just spread here
                 self.profit = self.portfolio.total_unrealized_profit
                 if (5 - abs(self.profit)) < 0:
-                    raise Exception(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
+                    raise AssertionError(f"Unexpected TotalUnrealizedProfit {self.portfolio.total_unrealized_profit}")
 
                 # we barely did any difference on the previous trade
                 if (5 - abs(self.portfolio.total_profit)) < 0:
-                    raise Exception(f"Unexpected TotalProfit {self.portfolio.total_profit}")
+                    raise AssertionError(f"Unexpected TotalProfit {self.portfolio.total_profit}")
 
             if self.time.hour >= 22 and self.transactions.orders_count == 3:
                 self.liquidate()
 
     def on_end_of_algorithm(self):
         if self.interest_per_symbol[self.ada_usdt.symbol] != 1:
-                raise Exception(f"Unexpected interest rate count {self.interest_per_symbol[self.ada_usdt.symbol]}")
+                raise AssertionError(f"Unexpected interest rate count {self.interest_per_symbol[self.ada_usdt.symbol]}")
 
     def on_order_event(self, order_event):
         self.debug("{0} {1}".format(self.time, order_event))