Removed 'read' property and '_managed_indicator' method that just got…

… from dict

hexital/core/indicator.py

@@ -109,11 +109,6 @@ def name(self) -> str:
         """The indicator name that will be saved into the Candles"""
         return self._output_name
 
-    @property
-    def read(self) -> float | dict | None:
-        """Get's this newest reading of this indicator"""
-        return self.reading()
-
     @property
     def as_list(self) -> List[float | dict | None]:
         """Gathers the indicator for all candles as a list"""
@@ -218,9 +213,6 @@ def _add_managed_indicator(self, name: str, indicator: Managed | Indicator):
         indicator.candle_manager = self._candles
         self._managed_indicators[name] = indicator
 
-    def _managed_indictor(self, name: str) -> Managed | Indicator | None:
-        return self._managed_indicators.get(name)
-
     def prev_exists(self) -> bool:
         return self.prev_reading(self.name) is not None
 

hexital/indicators/adx.py

@@ -96,10 +96,10 @@ def _calculate_reading(self, index: int) -> float | dict | None:
             positive = up if up > down and up > 0 else 0
             negative = down if down > up and down > 0 else 0
 
-            self._managed_indictor("plain_positive").set_reading(positive)
-            self._managed_indictor("plain_negative").set_reading(negative)
-            self._managed_indictor("positive").calculate_index(index)
-            self._managed_indictor("negative").calculate_index(index)
+            self._managed_indicators["plain_positive"].set_reading(positive)
+            self._managed_indicators["plain_negative"].set_reading(negative)
+            self._managed_indicators["positive"].calculate_index(index)
+            self._managed_indicators["negative"].calculate_index(index)
 
             if self.reading(f"{self._name}_atr") and self.reading(f"{self._name}_pos"):
                 mod = 100 / self.reading(f"{self._name}_atr")
@@ -109,8 +109,8 @@ def _calculate_reading(self, index: int) -> float | dict | None:
 
                 dx = 100 * abs(adx_positive - adx_negative) / (adx_positive + adx_negative)
 
-                self._managed_indictor("plain_dx").set_reading(dx)
-                self._managed_indictor("dx").calculate_index(index)
+                self._managed_indicators["plain_dx"].set_reading(dx)
+                self._managed_indicators["dx"].calculate_index(index)
 
                 if self.reading(f"{self._name}_dx"):
                     adx_final = self.reading(f"{self._name}_dx")

hexital/indicators/macd.py

@@ -73,7 +73,7 @@ def _calculate_reading(self, index: int) -> float | dict | None:
 
             # Temp manually inserting MACD to be used by signal EMA calc
             self.candles[index].indicators[self.name] = {"MACD": macd}
-            self._managed_indictor("signal").calculate_index(index)
+            self._managed_indicators["signal"].calculate_index(index)
 
             signal = self.reading("signal")
 

hexital/indicators/rsi.py

@@ -44,21 +44,21 @@ def _calculate_reading(self, index: int) -> float | dict | None:
             change_gain = -1 * change if change < 0 else 0.0
             change_loss = change if change > 0 else 0.0
 
-            self._managed_indictor("RSI_gain").set_reading(
+            self._managed_indicators["RSI_gain"].set_reading(
                 ((self.prev_reading("RSI_gain") * (self.period - 1)) + change_gain) / self.period,
             )
-            self._managed_indictor("RSI_loss").set_reading(
+            self._managed_indicators["RSI_loss"].set_reading(
                 ((self.prev_reading("RSI_loss") * (self.period - 1)) + change_loss) / self.period,
             )
         elif self.reading_period(self.period + 1, self.input_value):
             changes = [
                 self.reading(self.input_value, i) - self.reading(self.input_value, i - 1)
                 for i in range(index - (self.period - 1), index + 1)
             ]
-            self._managed_indictor("RSI_gain").set_reading(
+            self._managed_indicators["RSI_gain"].set_reading(
                 sum(chng for chng in changes if chng > 0) / self.period,
             )
-            self._managed_indictor("RSI_loss").set_reading(
+            self._managed_indicators["RSI_loss"].set_reading(
                 sum(abs(chng) for chng in changes if chng < 0) / self.period,
             )
 
@@ -67,6 +67,6 @@ def _calculate_reading(self, index: int) -> float | dict | None:
             rsi = 100.0 - (100.0 / (1.0 + rs))
             return rsi
 
-        self._managed_indictor("RSI_gain").set_reading(None)
-        self._managed_indictor("RSI_loss").set_reading(None)
+        self._managed_indicators["RSI_gain"].set_reading(None)
+        self._managed_indicators["RSI_loss"].set_reading(None)
         return None

hexital/indicators/stoch.py

@@ -72,11 +72,11 @@ def _calculate_reading(self, index: int) -> float | dict | None:
             stoch = ((self.reading(self.input_value) - lowest) / (highest - lowest)) * 100
 
             self.candles[index].indicators[self.name] = {"stoch": stoch}
-            self._managed_indictor("k").calculate_index(index)
+            self._managed_indicators["k"].calculate_index(index)
             k = self.reading(f"{self._name}_k")
 
             self.candles[index].indicators[self.name] = {"stoch": stoch, "k": k}
-            self._managed_indictor("d").calculate_index(index)
+            self._managed_indicators["d"].calculate_index(index)
             d = self.reading(f"{self._name}_d")
 
             return {"stoch": stoch, "k": k, "d": d}

hexital/indicators/supertrend.py

@@ -63,8 +63,8 @@ def _calculate_reading(self, index: int) -> float | dict | None:
                     if direction == -1 and upper > self.prev_reading("ST_Upper"):
                         upper = self.prev_reading("ST_Upper")
 
-            self._managed_indictor("st_upper").set_reading(upper)
-            self._managed_indictor("st_lower").set_reading(lower)
+            self._managed_indicators["st_upper"].set_reading(upper)
+            self._managed_indicators["st_lower"].set_reading(lower)
 
             return {
                 "trend": lower if direction == 1 else upper,

hexital/indicators/vwap.py

@@ -37,10 +37,10 @@ def _calculate_reading(self, index: int) -> float | dict | None:
             prev_pv = self.prev_reading("VWAP_PV")
             prev_vol = self.prev_reading("VWAP_Vol")
 
-        self._managed_indictor("VWAP_PV").set_reading(
+        self._managed_indicators["VWAP_PV"].set_reading(
             prev_pv + self.reading("volume") * typical_price
         )
-        self._managed_indictor("VWAP_Vol").set_reading(prev_vol + self.reading("volume"))
+        self._managed_indicators["VWAP_Vol"].set_reading(prev_vol + self.reading("volume"))
 
         if self.reading("VWAP_Vol") == 0:
             return self.reading("VWAP_PV")

tests/core/test_indicator.py

@@ -85,9 +85,9 @@ def test_name_timeframe_suffix(minimal_candles: List[Candle]):
 @pytest.mark.usefixtures("minimal_candles")
 def test_read(minimal_candles: List[Candle]):
     test = FakeIndicator(candles=minimal_candles)
-    assert test.read is None
+    assert test.reading() is None
     test.calculate()
-    assert test.read == 100.0
+    assert test.reading() == 100.0
 
 
 @pytest.mark.usefixtures("minimal_candles")
@@ -102,9 +102,9 @@ def test_has_reading(minimal_candles: List[Candle]):
 def test_set_reading(minimal_candles: List[Candle]):
     test = FakeIndicator(candles=minimal_candles)
     test.calculate()
-    assert test.read == 100
+    assert test.reading() == 100
     test._set_reading(420)
-    assert test.read == 420
+    assert test.reading() == 420
 
 
 @pytest.mark.usefixtures("minimal_candles")