stable/freqtrade/strategy/strategy.py

import os
import sys
import logging
import importlib

from pandas import DataFrame
from typing import Dict
from freqtrade.strategy.interface import IStrategy


sys.path.insert(0, r'../../user_data/strategies')


class Strategy(object):
    __instance = None

    DEFAULT_STRATEGY = 'default_strategy'

    def __new__(cls):
        if Strategy.__instance is None:
            Strategy.__instance = object.__new__(cls)
        return Strategy.__instance

    def init(self, config):
        self.logger = logging.getLogger(__name__)

        # Verify the strategy is in the configuration, otherwise fallback to the default strategy
        if 'strategy' in config:
            strategy = config['strategy']
        else:
            strategy = self.DEFAULT_STRATEGY

        # Load the strategy
        self._load_strategy(strategy)

        # Set attributes
        # Check if we need to override configuration
        if 'minimal_roi' in config:
            self.custom_strategy.minimal_roi = config['minimal_roi']
            self.logger.info("Override strategy \'minimal_roi\' with value in config file.")

        if 'stoploss' in config:
            self.custom_strategy.stoploss = config['stoploss']
            self.logger.info("Override strategy \'stoploss\' with value in config file.")

        self.minimal_roi = self.custom_strategy.minimal_roi
        self.stoploss = self.custom_strategy.stoploss

    def _load_strategy(self, strategy_name: str) -> None:
        """
        Search and load the custom strategy. If no strategy found, fallback on the default strategy
        Set the object into self.custom_strategy
        :param strategy_name: name of the module to import
        :return: None
        """

        try:
            # Start by sanitizing the file name (remove any extensions)
            strategy_name = self._sanitize_module_name(filename=strategy_name)

            # Search where can be the strategy file
            path = self._search_strategy(filename=strategy_name)

            # Load the strategy
            self.custom_strategy = self._load_class(path + strategy_name)

        # Fallback to the default strategy
        except (ImportError, TypeError):
            self.custom_strategy = self._load_class('.' + self.DEFAULT_STRATEGY)

    def _load_class(self, filename: str) -> IStrategy:
        """
        Import a strategy as a module
        :param filename: path to the strategy (path from freqtrade/strategy/)
        :return: return the strategy class
        """
        module = importlib.import_module(filename, __package__)
        custom_strategy = getattr(module, module.class_name)

        self.logger.info("Load strategy class: {} ({}.py)".format(module.class_name, filename))
        return custom_strategy()

    @staticmethod
    def _sanitize_module_name(filename: str) -> str:
        """
        Remove any extension from filename
        :param filename: filename to sanatize
        :return: return the filename without extensions
        """
        filename = os.path.basename(filename)
        filename = os.path.splitext(filename)[0]
        return filename

    @staticmethod
    def _search_strategy(filename: str) -> str:
        """
        Search for the Strategy file in different folder
        1. search into the user_data/strategies folder
        2. search into the freqtrade/strategy folder
        3. if nothing found, return None
        :param strategy_name: module name to search
        :return: module path where is the strategy
        """
        pwd = os.path.dirname(os.path.realpath(__file__)) + '/'
        user_data = os.path.join(pwd, '..', '..', 'user_data', 'strategies', filename + '.py')
        strategy_folder = os.path.join(pwd, filename + '.py')

        path = None
        if os.path.isfile(user_data):
            path = 'user_data.strategies.'
        elif os.path.isfile(strategy_folder):
            path = '.'

        return path

    def minimal_roi(self) -> Dict:
        """
        Minimal ROI designed for the strategy
        :return: Dict: Value for the Minimal ROI
        """
        return

    def stoploss(self) -> float:
        """
        Optimal stoploss designed for the strategy
        :return: float | return None to disable it
        """
        return self.custom_strategy.stoploss

    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
        """
        Populate indicators that will be used in the Buy and Sell strategy
        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
        :return: a Dataframe with all mandatory indicators for the strategies
        """
        return self.custom_strategy.populate_indicators(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:
        """
        return self.custom_strategy.populate_buy_trend(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.custom_strategy.populate_sell_trend(dataframe)

    def hyperopt_space(self) -> Dict:
        """
        Define your Hyperopt space for the strategy
        """
        return self.custom_strategy.hyperopt_space()

    def buy_strategy_generator(self, params) -> None:
        """
        Define the buy strategy parameters to be used by hyperopt
        """
        return self.custom_strategy.buy_strategy_generator(params)