Move validate_backtest_data and get_timeframe to histoyr

freqtrade/data/history.py

@@ -5,19 +5,21 @@ Includes:
 * load data for a pair (or a list of pairs) from disk
 * download data from exchange and store to disk
 """
+
 import logging
+import operator
+from datetime import datetime
 from pathlib import Path
-from typing import Optional, List, Dict, Tuple, Any
+from typing import Any, Dict, List, Optional, Tuple
 
 import arrow
 from pandas import DataFrame
 
-from freqtrade import misc, OperationalException
+from freqtrade import OperationalException, misc
 from freqtrade.arguments import TimeRange
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.exchange import Exchange, timeframe_to_minutes
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -243,3 +245,39 @@ def download_pair_history(datadir: Optional[Path],
             f'Error: {e}'
         )
         return False
+
+
+def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
+    """
+    Get the maximum timeframe for the given backtest data
+    :param data: dictionary with preprocessed backtesting data
+    :return: tuple containing min_date, max_date
+    """
+    timeframe = [
+        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
+        for frame in data.values()
+    ]
+    return min(timeframe, key=operator.itemgetter(0))[0], \
+        max(timeframe, key=operator.itemgetter(1))[1]
+
+
+def validate_backtest_data(data: Dict[str, DataFrame], min_date: datetime,
+                           max_date: datetime, ticker_interval_mins: int) -> bool:
+    """
+    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+
+    :param data: dictionary with preprocessed backtesting data
+    :param min_date: start-date of the data
+    :param max_date: end-date of the data
+    :param ticker_interval_mins: ticker interval in minutes
+    """
+    # total difference in minutes / interval-minutes
+    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    found_missing = False
+    for pair, df in data.items():
+        dflen = len(df)
+        if dflen < expected_frames:
+            found_missing = True
+            logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
+                           pair, expected_frames, dflen, expected_frames - dflen)
+    return found_missing

freqtrade/edge/__init__.py

@@ -13,7 +13,6 @@ from freqtrade import constants, OperationalException
 from freqtrade.arguments import Arguments
 from freqtrade.arguments import TimeRange
 from freqtrade.data import history
-from freqtrade.optimize import get_timeframe
 from freqtrade.strategy.interface import SellType
 
 
@@ -49,7 +48,6 @@ class Edge():
         self.strategy = strategy
         self.ticker_interval = self.strategy.ticker_interval
         self.tickerdata_to_dataframe = self.strategy.tickerdata_to_dataframe
-        self.get_timeframe = get_timeframe
         self.advise_sell = self.strategy.advise_sell
         self.advise_buy = self.strategy.advise_buy
 
@@ -117,7 +115,7 @@ class Edge():
         preprocessed = self.tickerdata_to_dataframe(data)
 
         # Print timeframe
-        min_date, max_date = self.get_timeframe(preprocessed)
+        min_date, max_date = history.get_timeframe(preprocessed)
         logger.info(
             'Measuring data from %s up to %s (%s days) ...',
             min_date.isoformat(),

freqtrade/optimize/__init__.py

@@ -1,49 +1 @@
-# pragma pylint: disable=missing-docstring
-
-import logging
-from datetime import datetime
-from typing import Dict, Tuple
-import operator
-
-import arrow
-from pandas import DataFrame
-
 from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
-
-logger = logging.getLogger(__name__)
-
-
-def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
-    """
-    Get the maximum timeframe for the given backtest data
-    :param data: dictionary with preprocessed backtesting data
-    :return: tuple containing min_date, max_date
-    """
-    timeframe = [
-        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
-        for frame in data.values()
-    ]
-    return min(timeframe, key=operator.itemgetter(0))[0], \
-        max(timeframe, key=operator.itemgetter(1))[1]
-
-
-def validate_backtest_data(data: Dict[str, DataFrame], min_date: datetime,
-                           max_date: datetime, ticker_interval_mins: int) -> bool:
-    """
-    Validates preprocessed backtesting data for missing values and shows warnings about it that.
-
-    :param data: dictionary with preprocessed backtesting data
-    :param min_date: start-date of the data
-    :param max_date: end-date of the data
-    :param ticker_interval_mins: ticker interval in minutes
-    """
-    # total difference in minutes / interval-minutes
-    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
-    found_missing = False
-    for pair, df in data.items():
-        dflen = len(df)
-        if dflen < expected_frames:
-            found_missing = True
-            logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
-                           pair, expected_frames, dflen, expected_frames - dflen)
-    return found_missing