PEP8 Fix: Assigning to a Method

Author: AlexCatarino

Algorithm.Python/BasicTemplateOptionEquityStrategyAlgorithm.py

@@ -30,7 +30,7 @@ def initialize(self):
 
         equity = self.add_equity(self.underlying_ticker)
         option = self.add_option(self.underlying_ticker)
-        self.option_symbol = option.symbol
+        self._option_symbol = option.symbol
 
         # set our strike/expiry filter for this option chain
         option.set_filter(lambda u: (u.strikes(-2, +2)
@@ -39,9 +39,9 @@ def initialize(self):
                                      .expiration(0, 180)))
 
     def on_data(self, slice: Slice):
-        if self.portfolio.invested or not self.is_market_open(self.option_symbol): return
+        if self.portfolio.invested or not self.is_market_open(self._option_symbol): return
 
-        chain = slice.option_chains.get_value(self.option_symbol)
+        chain = slice.option_chains.get_value(self._option_symbol)
         if chain is None:
             return
 
@@ -57,7 +57,7 @@ def on_data(self, slice: Slice):
         middle_strike = call_contracts[1].strike
         higher_strike = call_contracts[2].strike
 
-        option_strategy = OptionStrategies.call_butterfly(self.option_symbol, higher_strike, middle_strike, lower_strike, expiry)
+        option_strategy = OptionStrategies.call_butterfly(self._option_symbol, higher_strike, middle_strike, lower_strike, expiry)
 
         self.order(option_strategy, 10)
 

Algorithm.Python/Benchmarks/IndicatorRibbonBenchmark.py

@@ -19,25 +19,25 @@ class IndicatorRibbonBenchmark(QCAlgorithm):
     def initialize(self):
         self.set_start_date(2010, 1, 1)  #Set Start Date
         self.set_end_date(2018, 1, 1)    #Set End Date
-        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol
+        self._spy = self.add_equity("SPY", Resolution.MINUTE).symbol
         count = 50
         offset = 5
         period = 15
-        self.ribbon = []
+        self._ribbon = []
         # define our sma as the base of the ribbon
-        self.sma = SimpleMovingAverage(period)
+        self._sma = SimpleMovingAverage(period)
 
         for x in range(count):
             # define our offset to the zero sma, these various offsets will create our 'displaced' ribbon
             delay = Delay(offset*(x+1))
             # define an indicator that takes the output of the sma and pipes it into our delay indicator
-            delayed_sma = IndicatorExtensions.of(delay, self.sma)
+            delayed_sma = IndicatorExtensions.of(delay, self._sma)
             # register our new 'delayed_sma' for automatic updates on a daily resolution
-            self.register_indicator(self.spy, delayed_sma, Resolution.DAILY)
-            self.ribbon.append(delayed_sma)
+            self.register_indicator(self._spy, delayed_sma, Resolution.DAILY)
+            self._ribbon.append(delayed_sma)
 
     def on_data(self, data):
         # wait for our entire ribbon to be ready
-        if not all(x.is_ready for x in self.ribbon): return
-        for x in self.ribbon:
+        if not all(x.is_ready for x in self._ribbon): return
+        for x in self._ribbon:
             value = x.current.value

Algorithm.Python/BybitCustomDataCryptoRegressionAlgorithm.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 from datetime import time
+import os
 from AlgorithmImports import *
 
 ### <summary>
@@ -29,22 +30,22 @@ def initialize(self) -> None:
         self.set_brokerage_model(BrokerageName.BYBIT, AccountType.CASH)
 
         symbol = self.add_crypto("BTCUSDT").symbol
-        self.btc_usdt = self.add_data(CustomCryptoData, symbol, Resolution.MINUTE).symbol
+        self._btc_usdt = self.add_data(CustomCryptoData, symbol, Resolution.MINUTE).symbol
 
         # create two moving averages
-        self.fast = self.ema(self.btc_usdt, 30, Resolution.MINUTE)
-        self.slow = self.ema(self.btc_usdt, 60, Resolution.MINUTE)
+        self._fast = self.ema(self._btc_usdt, 30, Resolution.MINUTE)
+        self._slow = self.ema(self._btc_usdt, 60, Resolution.MINUTE)
 
     def on_data(self, data: Slice) -> None:
-        if not self.slow.is_ready:
+        if not self._slow.is_ready:
             return
 
-        if self.fast.current.value > self.slow.current.value:
+        if self._fast.current.value > self._slow.current.value:
             if self.transactions.orders_count == 0:
-                self.buy(self.btc_usdt, 1)
+                self.buy(self._btc_usdt, 1)
         else:
             if self.transactions.orders_count == 1:
-                self.liquidate(self.btc_usdt)
+                self.liquidate(self._btc_usdt)
 
     def on_order_event(self, order_event: OrderEvent) -> None:
         self.debug(f"{self.time} {order_event}")
@@ -53,7 +54,7 @@ class CustomCryptoData(PythonData):
     def get_source(self, config: SubscriptionDataConfig, date: datetime, is_live_mode: bool) -> SubscriptionDataSource:
         tick_type_string = Extensions.tick_type_to_lower(config.tick_type)
         formatted_date = date.strftime("%Y%m%d")
-        source = os.path.join(Globals.DataFolder, "crypto", "bybit", "minute",
+        source = os.path.join(Globals.data_folder, "crypto", "bybit", "minute",
                               config.symbol.value.lower(), f"{formatted_date}_{tick_type_string}.zip")
 
         return SubscriptionDataSource(source, SubscriptionTransportMedium.LOCAL_FILE, FileFormat.CSV)

Algorithm.Python/CallbackCommandRegressionAlgorithm.py

@@ -22,11 +22,12 @@ class VoidCommand():
     parameters: Dict[str, str] = {}
     targettime: datetime | None = None
 
-    def run(self, algo: QCAlgorithm) -> bool | None:
+    def run(self, algo: QCAlgorithm) -> bool:
         if not self.targettime or self.targettime != algo.time:
-            return
+            return False
         tag = self.parameters["tag"]
         algo.order(self.target[0], self.get_quantity(), tag=tag)
+        return True
 
     def get_quantity(self):
         return self.quantity
@@ -36,7 +37,7 @@ class BoolCommand(Command):
     array_test: List[str] = []
     result: bool = False
 
-    def run(self, algo: QCAlgorithm) -> bool | None:
+    def run(self, algo: QCAlgorithm) -> bool:
         trade_ibm = self.my_custom_method()
         if trade_ibm:
             algo.debug(f"BoolCommand.run: {str(self)}")

Algorithm.Python/CompleteOrderTagUpdateAlgorithm.py

@@ -48,14 +48,14 @@ def on_data(self, data: Slice) -> None:
     def on_order_event(self, order_event: OrderEvent) -> None:
         if order_event.status == OrderStatus.CANCELED:
             if not self._limit_order_ticket or order_event.order_id != self._limit_order_ticket.order_id:
-                raise Exception("The only canceled order should have been the limit order.")
+                raise AssertionError("The only canceled order should have been the limit order.")
 
             # update canceled order tag
             self.update_order_tag(self._limit_order_ticket, self.tag_after_canceled, "Error updating order tag after canceled")
         elif order_event.status == OrderStatus.FILLED:
             self._market_order_ticket = list(self.transactions.get_order_tickets(lambda x: x.order_type == OrderType.MARKET))[0]
             if not self._market_order_ticket or order_event.order_id != self._market_order_ticket.order_id:
-                raise Exception("The only filled order should have been the market order.")
+                raise AssertionError("The only filled order should have been the market order.")
 
             # update filled order tag
             self.update_order_tag(self._market_order_ticket, self.tag_after_fill, "Error updating order tag after fill")

Algorithm.Python/CustomDataPropertiesRegressionAlgorithm.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 from AlgorithmImports import *
 
 ### <summary>
@@ -25,23 +26,23 @@ class CustomDataPropertiesRegressionAlgorithm(QCAlgorithm):
 
     def initialize(self) -> None:
         self.set_start_date(2020, 1, 5)   # Set Start Date
-        self.set_end_date(2020, 1, 10)     # Set End Date
-        self.set_cash(100000)           # Set Strategy Cash
+        self.set_end_date(2020, 1, 10)    # Set End Date
+        self.set_cash(100000)             # Set Strategy Cash
 
         # Define our custom data properties and exchange hours
-        self.ticker = 'BTC'
-        properties = SymbolProperties("Bitcoin", "USD", 1, 0.01, 0.01, self.ticker)
+        ticker = 'BTC'
+        properties = SymbolProperties("Bitcoin", "USD", 1, 0.01, 0.01, ticker)
         exchange_hours = SecurityExchangeHours.always_open(TimeZones.NEW_YORK)
 
         # Add the custom data to our algorithm with our custom properties and exchange hours
-        self.bitcoin = self.add_data(Bitcoin, self.ticker, properties, exchange_hours, leverage=1, fill_forward=False)
+        self._bitcoin = self.add_data(Bitcoin, ticker, properties, exchange_hours, leverage=1, fill_forward=False)
 
         # Verify our symbol properties were changed and loaded into this security
-        if self.bitcoin.symbol_properties != properties :
+        if self._bitcoin.symbol_properties != properties :
             raise AssertionError("Failed to set and retrieve custom SymbolProperties for BTC")
 
         # Verify our exchange hours were changed and loaded into this security
-        if self.bitcoin.exchange.hours != exchange_hours :
+        if self._bitcoin.exchange.hours != exchange_hours :
             raise AssertionError("Failed to set and retrieve custom ExchangeHours for BTC")
 
         # For regression purposes on AddData overloads, this call is simply to ensure Lean can accept this
@@ -55,7 +56,7 @@ def on_data(self, data: Slice) -> None:
 
     def on_end_of_algorithm(self) -> None:
         #Reset our Symbol property value, for testing purposes.
-        self.symbol_properties_database.set_entry(Market.USA, self.market_hours_database.get_database_symbol_key(self.bitcoin.symbol), SecurityType.BASE,
+        self.symbol_properties_database.set_entry(Market.USA, self.market_hours_database.get_database_symbol_key(self._bitcoin.symbol), SecurityType.BASE,
             SymbolProperties.get_default("USD"))
 
 
@@ -84,7 +85,7 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
 
                 # If value is zero, return None
                 value = live_btc["last"]
-                if value == 0: return None
+                if value == 0: return coin
 
                 coin.time = datetime.now()
                 coin.value = value
@@ -99,17 +100,17 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
                 return coin
             except ValueError:
                 # Do nothing, possible error in json decoding
-                return None
+                return coin
 
         # Example Line Format:
         #code    date        high     low      mid      last     bid      ask      volume
         #BTCUSD  2024-10-08  63248.0  61940.0  62246.5  62245.0  62246.0  62247.0       5.929230648356
-        if not (line.strip() and line[7].isdigit()): return None
+        if not (line.strip() and line[7].isdigit()): return coin
 
         try:
             data = line.split(',')
             coin.time = datetime.strptime(data[1], "%Y-%m-%d")
-            coin.end_time = coin.time + timedelta(days=1)
+            coin.end_time = coin.time + timedelta(1)
             coin.value = float(data[5])
             coin["High"] = float(data[2])
             coin["Low"] = float(data[3])
@@ -122,4 +123,4 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
 
         except ValueError:
             # Do nothing, possible error in json decoding
-            return None
+            return coin

Algorithm.Python/CustomDataRegressionAlgorithm.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 from AlgorithmImports import *
 
 ### <summary>
@@ -75,9 +76,9 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
             try:
                 live_btc = json.loads(line)
 
-                # If value is zero, return None
+                # If value is zero, return coin
                 value = live_btc["last"]
-                if value == 0: return None
+                if value == 0: return coin
 
                 coin.time = datetime.now()
                 coin.value = value
@@ -92,12 +93,12 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
                 return coin
             except ValueError:
                 # Do nothing, possible error in json decoding
-                return None
+                return coin
 
         # Example Line Format:
         # code    date        high     low      mid      last     bid      ask      volume
         # BTCUSD  2024-10-08  63248.0  61940.0  62246.5  62245.0  62246.0  62247.0  477.91102114
-        if not (line.strip() and line[7].isdigit()): return None
+        if not (line.strip() and line[7].isdigit()): return coin
 
         try:
             data = line.split(',')
@@ -115,4 +116,4 @@ def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_l
 
         except ValueError:
             # Do nothing, possible error in json decoding
-            return None
+            return coin

Algorithm.Python/CustomIndicatorWithExtensionAlgorithm.py

@@ -21,54 +21,54 @@ def initialize(self):
         self.set_start_date(2013, 10, 9)
         self.set_end_date(2013, 10, 9)
 
-        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol
+        self._spy = self.add_equity("SPY", Resolution.MINUTE).symbol
 
-        self.sma_values = []
-        self.period = 10
+        self._sma_values = []
+        self._period = 10
 
-        self.sma = self.sma(self.spy, self.period, Resolution.MINUTE)
-        self.sma.updated += self.on_sma_updated
+        self._sma = self.sma(self._spy, self._period, Resolution.MINUTE)
+        self._sma.updated += self.on_sma_updated
 
-        self.custom_sma = CustomSimpleMovingAverage("My SMA", self.period)
-        self.ext = IndicatorExtensions.of(self.custom_sma, self.sma)
-        self.ext.updated += self.on_indicator_extension_updated
+        self._custom_sma = CustomSimpleMovingAverage("My SMA", self._period)
+        self._ext = IndicatorExtensions.of(self._custom_sma, self._sma)
+        self._ext.updated += self.on_indicator_extension_updated
 
-        self.sma_minus_custom = IndicatorExtensions.minus(self.sma, self.custom_sma)
-        self.sma_minus_custom.updated += self.on_minus_updated
+        self._sma_minus_custom = IndicatorExtensions.minus(self._sma, self._custom_sma)
+        self._sma_minus_custom.updated += self.on_minus_updated
 
-        self.sma_was_updated = False
-        self.custom_sma_was_updated = False
-        self.sma_minus_custom_was_updated = False
+        self._sma_was_updated = False
+        self._custom_sma_was_updated = False
+        self._sma_minus_custom_was_updated = False
 
     def on_sma_updated(self, sender, updated):
-        self.sma_was_updated = True
+        self._sma_was_updated = True
 
-        if self.sma.is_ready:
-            self.sma_values.append(self.sma.current.value)
+        if self._sma.is_ready:
+            self._sma_values.append(self._sma.current.value)
 
     def on_indicator_extension_updated(self, sender, updated):
-        self.custom_sma_was_updated = True
+        self._custom_sma_was_updated = True
 
-        sma_last_values = self.sma_values[-self.period:]
+        sma_last_values = self._sma_values[-self._period:]
         expected = sum(sma_last_values) / len(sma_last_values)
 
-        if not isclose(expected, self.custom_sma.value):
-            raise AssertionError(f"Expected the custom SMA to calculate the moving average of the last {self.period} values of the SMA. "
-                            f"Current expected: {expected}. Actual {self.custom_sma.value}.")
+        if not isclose(expected, self._custom_sma.value):
+            raise AssertionError(f"Expected the custom SMA to calculate the moving average of the last {self._period} values of the SMA. "
+                            f"Current expected: {expected}. Actual {self._custom_sma.value}.")
 
-        self.debug(f"{self.sma.current.value} :: {self.custom_sma.value} :: {updated}")
+        self.debug(f"{self._sma.current.value} :: {self._custom_sma.value} :: {updated}")
 
     def on_minus_updated(self, sender, updated):
-        self.sma_minus_custom_was_updated = True
+        self._sma_minus_custom_was_updated = True
 
-        expected = self.sma.current.value - self.custom_sma.value
+        expected = self._sma.current.value - self._custom_sma.value
 
-        if not isclose(expected, self.sma_minus_custom.current.value):
+        if not isclose(expected, self._sma_minus_custom.current.value):
             raise AssertionError(f"Expected the composite minus indicator to calculate the difference between the SMA and custom SMA indicators. "
-                            f"Expected: {expected}. Actual {self.sma_minus_custom.current.value}.")
+                            f"Expected: {expected}. Actual {self._sma_minus_custom.current.value}.")
 
     def on_end_of_algorithm(self):
-        if not (self.sma_was_updated and self.custom_sma_was_updated and self.sma_minus_custom_was_updated):
+        if not (self._sma_was_updated and self._custom_sma_was_updated and self._sma_minus_custom_was_updated):
             raise AssertionError("Expected all indicators to have been updated.")
 
 # Custom indicator
@@ -85,4 +85,3 @@ def update(self, input: BaseData) -> bool:
         self.value = sum(self.queue) / count
 
         return count == self.queue.maxlen
-