remove pass-through methods from Analyze

freqtrade/analyze.py

@@ -64,46 +64,6 @@ class Analyze(object):
         frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
         return frame
 
-    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Adds several different TA indicators to the given DataFrame
-
-        Performance Note: For the best performance be frugal on the number of indicators
-        you are using. Let uncomment only the indicator you are using in your strategies
-        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
-        """
-        return self.strategy.populate_indicators(dataframe=dataframe)
-
-    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Based on TA indicators, populates the buy signal for the given dataframe
-        :param dataframe: DataFrame
-        :return: DataFrame with buy column
-        """
-        return self.strategy.populate_buy_trend(dataframe=dataframe)
-
-    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Based on TA indicators, populates the sell signal for the given dataframe
-        :param dataframe: DataFrame
-        :return: DataFrame with buy column
-        """
-        return self.strategy.populate_sell_trend(dataframe=dataframe)
-
-    def get_ticker_interval(self) -> str:
-        """
-        Return ticker interval to use
-        :return: Ticker interval value to use
-        """
-        return self.strategy.ticker_interval
-
-    def get_stoploss(self) -> float:
-        """
-        Return stoploss to use
-        :return: Strategy stoploss value to use
-        """
-        return self.strategy.stoploss
-
     def analyze_ticker(self, ticker_history: List[Dict]) -> DataFrame:
         """
         Parses the given ticker history and returns a populated DataFrame
@@ -111,9 +71,9 @@ class Analyze(object):
         :return DataFrame with ticker data and indicator data
         """
         dataframe = self.parse_ticker_dataframe(ticker_history)
-        dataframe = self.populate_indicators(dataframe)
+        dataframe = self.strategy.populate_indicators(dataframe)
-        dataframe = self.populate_buy_trend(dataframe)
+        dataframe = self.strategy.populate_buy_trend(dataframe)
-        dataframe = self.populate_sell_trend(dataframe)
+        dataframe = self.strategy.populate_sell_trend(dataframe)
         return dataframe
 
     def get_signal(self, exchange: Exchange, pair: str, interval: str) -> Tuple[bool, bool]:
@@ -267,5 +227,5 @@ class Analyze(object):
         """
         Creates a dataframe and populates indicators for given ticker data
         """
-        return {pair: self.populate_indicators(self.parse_ticker_dataframe(pair_data))
+        return {pair: self.strategy.populate_indicators(self.parse_ticker_dataframe(pair_data))
                 for pair, pair_data in tickerdata.items()}

freqtrade/optimize/backtesting.py

@@ -57,8 +57,8 @@ class Backtesting(object):
         self.analyze = Analyze(self.config, self.strategy)
         self.ticker_interval = self.analyze.strategy.ticker_interval
         self.tickerdata_to_dataframe = self.analyze.tickerdata_to_dataframe
-        self.populate_buy_trend = self.analyze.populate_buy_trend
+        self.populate_buy_trend = self.strategy.populate_buy_trend
-        self.populate_sell_trend = self.analyze.populate_sell_trend
+        self.populate_sell_trend = self.strategy.populate_sell_trend
 
         # Reset keys for backtesting
         self.config['exchange']['key'] = ''

freqtrade/tests/test_analyze.py

@@ -10,7 +10,7 @@ from unittest.mock import MagicMock
 import arrow
 from pandas import DataFrame
 
-from freqtrade.analyze import Analyze, SignalType
+from freqtrade.analyze import Analyze
 from freqtrade.arguments import TimeRange
 from freqtrade.optimize.__init__ import load_tickerdata_file
 from freqtrade.tests.conftest import get_patched_exchange, log_has
@@ -20,31 +20,6 @@ from freqtrade.strategy.default_strategy import DefaultStrategy
 _ANALYZE = Analyze({}, DefaultStrategy())
 
 
-def test_signaltype_object() -> None:
-    """
-    Test the SignalType object has the mandatory Constants
-    :return: None
-    """
-    assert hasattr(SignalType, 'BUY')
-    assert hasattr(SignalType, 'SELL')
-
-
-def test_analyze_object() -> None:
-    """
-    Test the Analyze object has the mandatory methods
-    :return: None
-    """
-    assert hasattr(Analyze, 'parse_ticker_dataframe')
-    assert hasattr(Analyze, 'populate_indicators')
-    assert hasattr(Analyze, 'populate_buy_trend')
-    assert hasattr(Analyze, 'populate_sell_trend')
-    assert hasattr(Analyze, 'analyze_ticker')
-    assert hasattr(Analyze, 'get_signal')
-    assert hasattr(Analyze, 'should_sell')
-    assert hasattr(Analyze, 'min_roi_reached')
-    assert hasattr(Analyze, 'stop_loss_reached')
-
-
 def test_dataframe_correct_length(result):
     dataframe = Analyze.parse_ticker_dataframe(result)
     assert len(result.index) - 1 == len(dataframe.index)    # last partial candle removed
@@ -55,18 +30,6 @@ def test_dataframe_correct_columns(result):
         ['date', 'open', 'high', 'low', 'close', 'volume']
 
 
-def test_populates_buy_trend(result):
-    # Load the default strategy for the unit test, because this logic is done in main.py
-    dataframe = _ANALYZE.populate_buy_trend(_ANALYZE.populate_indicators(result))
-    assert 'buy' in dataframe.columns
-
-
-def test_populates_sell_trend(result):
-    # Load the default strategy for the unit test, because this logic is done in main.py
-    dataframe = _ANALYZE.populate_sell_trend(_ANALYZE.populate_indicators(result))
-    assert 'sell' in dataframe.columns
-
-
 def test_returns_latest_buy_signal(mocker, default_conf):
     mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=MagicMock())
     exchange = get_patched_exchange(mocker, default_conf)