Merge pull request #2804 from freqtrade/utils_commands

Utils commands

freqtrade/commands/__init__.py

@@ -0,0 +1,25 @@
+# flake8: noqa: F401
+"""
+Commands module.
+Contains all start-commands, subcommands and CLI Interface creation.
+
+Note: Be careful with file-scoped imports in these subfiles.
+    as they are parsed on startup, nothing containing optional modules should be loaded.
+"""
+from freqtrade.commands.arguments import Arguments
+from freqtrade.commands.data_commands import start_download_data
+from freqtrade.commands.deploy_commands import (start_create_userdir,
+                                                start_new_hyperopt,
+                                                start_new_strategy)
+from freqtrade.commands.hyperopt_commands import (start_hyperopt_list,
+                                                  start_hyperopt_show)
+from freqtrade.commands.list_commands import (start_list_exchanges,
+                                              start_list_markets,
+                                              start_list_strategies,
+                                              start_list_timeframes)
+from freqtrade.commands.optimize_commands import (start_backtesting,
+                                                  start_edge, start_hyperopt)
+from freqtrade.commands.pairlist_commands import start_test_pairlist
+from freqtrade.commands.plot_commands import (start_plot_dataframe,
+                                              start_plot_profit)
+from freqtrade.commands.trade_commands import start_trading

freqtrade/commands/arguments.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from freqtrade import constants
-from freqtrade.configuration.cli_options import AVAILABLE_CLI_OPTIONS
+from freqtrade.commands.cli_options import AVAILABLE_CLI_OPTIONS
 
 ARGS_COMMON = ["verbosity", "logfile", "version", "config", "datadir", "user_data_dir"]
 
@@ -130,14 +130,14 @@ class Arguments:
         self.parser = argparse.ArgumentParser(description='Free, open source crypto trading bot')
         self._build_args(optionlist=['version'], parser=self.parser)
 
-        from freqtrade.optimize import start_backtesting, start_hyperopt, start_edge
+        from freqtrade.commands import (start_create_userdir, start_download_data,
-        from freqtrade.utils import (start_create_userdir, start_download_data,
+                                        start_hyperopt_list, start_hyperopt_show,
-                                     start_hyperopt_list, start_hyperopt_show,
+                                        start_list_exchanges, start_list_markets,
-                                     start_list_exchanges, start_list_markets,
+                                        start_list_strategies, start_new_hyperopt,
-                                     start_list_strategies, start_new_hyperopt,
+                                        start_new_strategy, start_list_timeframes,
-                                     start_new_strategy, start_list_timeframes,
+                                        start_plot_dataframe, start_plot_profit,
-                                     start_test_pairlist, start_trading)
+                                        start_backtesting, start_hyperopt, start_edge,
-        from freqtrade.plot.plot_utils import start_plot_dataframe, start_plot_profit
+                                        start_test_pairlist, start_trading)
 
         subparsers = self.parser.add_subparsers(dest='command',
                                                 # Use custom message when no subhandler is added

freqtrade/commands/cli_options.py

@@ -1,7 +1,7 @@
 """
 Definition of cli arguments used in arguments.py
 """
-import argparse
+from argparse import ArgumentTypeError
 
 from freqtrade import __version__, constants
 
@@ -12,7 +12,7 @@ def check_int_positive(value: str) -> int:
         if uint <= 0:
             raise ValueError
     except ValueError:
-        raise argparse.ArgumentTypeError(
+        raise ArgumentTypeError(
             f"{value} is invalid for this parameter, should be a positive integer value"
         )
     return uint
@@ -24,7 +24,7 @@ def check_int_nonzero(value: str) -> int:
         if uint == 0:
             raise ValueError
     except ValueError:
-        raise argparse.ArgumentTypeError(
+        raise ArgumentTypeError(
             f"{value} is invalid for this parameter, should be a non-zero integer value"
         )
     return uint

freqtrade/commands/data_commands.py

@@ -0,0 +1,63 @@
+import logging
+import sys
+from typing import Any, Dict, List
+
+import arrow
+
+from freqtrade.configuration import TimeRange, setup_utils_configuration
+from freqtrade.data.history import (convert_trades_to_ohlcv,
+                                    refresh_backtest_ohlcv_data,
+                                    refresh_backtest_trades_data)
+from freqtrade.exceptions import OperationalException
+from freqtrade.resolvers import ExchangeResolver
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def start_download_data(args: Dict[str, Any]) -> None:
+    """
+    Download data (former download_backtest_data.py script)
+    """
+    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
+
+    timerange = TimeRange()
+    if 'days' in config:
+        time_since = arrow.utcnow().shift(days=-config['days']).strftime("%Y%m%d")
+        timerange = TimeRange.parse_timerange(f'{time_since}-')
+
+    if 'pairs' not in config:
+        raise OperationalException(
+            "Downloading data requires a list of pairs. "
+            "Please check the documentation on how to configure this.")
+
+    logger.info(f'About to download pairs: {config["pairs"]}, '
+                f'intervals: {config["timeframes"]} to {config["datadir"]}')
+
+    pairs_not_available: List[str] = []
+
+    # Init exchange
+    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config)
+    try:
+
+        if config.get('download_trades'):
+            pairs_not_available = refresh_backtest_trades_data(
+                exchange, pairs=config["pairs"], datadir=config['datadir'],
+                timerange=timerange, erase=config.get("erase"))
+
+            # Convert downloaded trade data to different timeframes
+            convert_trades_to_ohlcv(
+                pairs=config["pairs"], timeframes=config["timeframes"],
+                datadir=config['datadir'], timerange=timerange, erase=config.get("erase"))
+        else:
+            pairs_not_available = refresh_backtest_ohlcv_data(
+                exchange, pairs=config["pairs"], timeframes=config["timeframes"],
+                datadir=config['datadir'], timerange=timerange, erase=config.get("erase"))
+
+    except KeyboardInterrupt:
+        sys.exit("SIGINT received, aborting ...")
+
+    finally:
+        if pairs_not_available:
+            logger.info(f"Pairs [{','.join(pairs_not_available)}] not available "
+                        f"on exchange {exchange.name}.")

freqtrade/commands/deploy_commands.py

@@ -0,0 +1,112 @@
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.configuration.directory_operations import (copy_sample_files,
+                                                          create_userdata_dir)
+from freqtrade.constants import USERPATH_HYPEROPTS, USERPATH_STRATEGY
+from freqtrade.exceptions import OperationalException
+from freqtrade.misc import render_template
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def start_create_userdir(args: Dict[str, Any]) -> None:
+    """
+    Create "user_data" directory to contain user data strategies, hyperopt, ...)
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    if "user_data_dir" in args and args["user_data_dir"]:
+        userdir = create_userdata_dir(args["user_data_dir"], create_dir=True)
+        copy_sample_files(userdir, overwrite=args["reset"])
+    else:
+        logger.warning("`create-userdir` requires --userdir to be set.")
+        sys.exit(1)
+
+
+def deploy_new_strategy(strategy_name, strategy_path: Path, subtemplate: str):
+    """
+    Deploy new strategy from template to strategy_path
+    """
+    indicators = render_template(templatefile=f"subtemplates/indicators_{subtemplate}.j2",)
+    buy_trend = render_template(templatefile=f"subtemplates/buy_trend_{subtemplate}.j2",)
+    sell_trend = render_template(templatefile=f"subtemplates/sell_trend_{subtemplate}.j2",)
+    plot_config = render_template(templatefile=f"subtemplates/plot_config_{subtemplate}.j2",)
+
+    strategy_text = render_template(templatefile='base_strategy.py.j2',
+                                    arguments={"strategy": strategy_name,
+                                               "indicators": indicators,
+                                               "buy_trend": buy_trend,
+                                               "sell_trend": sell_trend,
+                                               "plot_config": plot_config,
+                                               })
+
+    logger.info(f"Writing strategy to `{strategy_path}`.")
+    strategy_path.write_text(strategy_text)
+
+
+def start_new_strategy(args: Dict[str, Any]) -> None:
+
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    if "strategy" in args and args["strategy"]:
+        if args["strategy"] == "DefaultStrategy":
+            raise OperationalException("DefaultStrategy is not allowed as name.")
+
+        new_path = config['user_data_dir'] / USERPATH_STRATEGY / (args["strategy"] + ".py")
+
+        if new_path.exists():
+            raise OperationalException(f"`{new_path}` already exists. "
+                                       "Please choose another Strategy Name.")
+
+        deploy_new_strategy(args['strategy'], new_path, args['template'])
+
+    else:
+        raise OperationalException("`new-strategy` requires --strategy to be set.")
+
+
+def deploy_new_hyperopt(hyperopt_name, hyperopt_path: Path, subtemplate: str):
+    """
+    Deploys a new hyperopt template to hyperopt_path
+    """
+    buy_guards = render_template(
+        templatefile=f"subtemplates/hyperopt_buy_guards_{subtemplate}.j2",)
+    sell_guards = render_template(
+        templatefile=f"subtemplates/hyperopt_sell_guards_{subtemplate}.j2",)
+    buy_space = render_template(
+        templatefile=f"subtemplates/hyperopt_buy_space_{subtemplate}.j2",)
+    sell_space = render_template(
+        templatefile=f"subtemplates/hyperopt_sell_space_{subtemplate}.j2",)
+
+    strategy_text = render_template(templatefile='base_hyperopt.py.j2',
+                                    arguments={"hyperopt": hyperopt_name,
+                                               "buy_guards": buy_guards,
+                                               "sell_guards": sell_guards,
+                                               "buy_space": buy_space,
+                                               "sell_space": sell_space,
+                                               })
+
+    logger.info(f"Writing hyperopt to `{hyperopt_path}`.")
+    hyperopt_path.write_text(strategy_text)
+
+
+def start_new_hyperopt(args: Dict[str, Any]) -> None:
+
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    if "hyperopt" in args and args["hyperopt"]:
+        if args["hyperopt"] == "DefaultHyperopt":
+            raise OperationalException("DefaultHyperopt is not allowed as name.")
+
+        new_path = config['user_data_dir'] / USERPATH_HYPEROPTS / (args["hyperopt"] + ".py")
+
+        if new_path.exists():
+            raise OperationalException(f"`{new_path}` already exists. "
+                                       "Please choose another Strategy Name.")
+        deploy_new_hyperopt(args['hyperopt'], new_path, args['template'])
+    else:
+        raise OperationalException("`new-hyperopt` requires --hyperopt to be set.")

freqtrade/commands/hyperopt_commands.py

@@ -0,0 +1,114 @@
+import logging
+from operator import itemgetter
+from typing import Any, Dict, List
+
+from colorama import init as colorama_init
+
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.exceptions import OperationalException
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def start_hyperopt_list(args: Dict[str, Any]) -> None:
+    """
+    List hyperopt epochs previously evaluated
+    """
+    from freqtrade.optimize.hyperopt import Hyperopt
+
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    only_best = config.get('hyperopt_list_best', False)
+    only_profitable = config.get('hyperopt_list_profitable', False)
+    print_colorized = config.get('print_colorized', False)
+    print_json = config.get('print_json', False)
+    no_details = config.get('hyperopt_list_no_details', False)
+    no_header = False
+
+    trials_file = (config['user_data_dir'] /
+                   'hyperopt_results' / 'hyperopt_results.pickle')
+
+    # Previous evaluations
+    trials = Hyperopt.load_previous_results(trials_file)
+    total_epochs = len(trials)
+
+    trials = _hyperopt_filter_trials(trials, only_best, only_profitable)
+
+    # TODO: fetch the interval for epochs to print from the cli option
+    epoch_start, epoch_stop = 0, None
+
+    if print_colorized:
+        colorama_init(autoreset=True)
+
+    try:
+        # Human-friendly indexes used here (starting from 1)
+        for val in trials[epoch_start:epoch_stop]:
+            Hyperopt.print_results_explanation(val, total_epochs, not only_best, print_colorized)
+
+    except KeyboardInterrupt:
+        print('User interrupted..')
+
+    if trials and not no_details:
+        sorted_trials = sorted(trials, key=itemgetter('loss'))
+        results = sorted_trials[0]
+        Hyperopt.print_epoch_details(results, total_epochs, print_json, no_header)
+
+
+def start_hyperopt_show(args: Dict[str, Any]) -> None:
+    """
+    Show details of a hyperopt epoch previously evaluated
+    """
+    from freqtrade.optimize.hyperopt import Hyperopt
+
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    only_best = config.get('hyperopt_list_best', False)
+    only_profitable = config.get('hyperopt_list_profitable', False)
+    no_header = config.get('hyperopt_show_no_header', False)
+
+    trials_file = (config['user_data_dir'] /
+                   'hyperopt_results' / 'hyperopt_results.pickle')
+
+    # Previous evaluations
+    trials = Hyperopt.load_previous_results(trials_file)
+    total_epochs = len(trials)
+
+    trials = _hyperopt_filter_trials(trials, only_best, only_profitable)
+    trials_epochs = len(trials)
+
+    n = config.get('hyperopt_show_index', -1)
+    if n > trials_epochs:
+        raise OperationalException(
+                f"The index of the epoch to show should be less than {trials_epochs + 1}.")
+    if n < -trials_epochs:
+        raise OperationalException(
+                f"The index of the epoch to show should be greater than {-trials_epochs - 1}.")
+
+    # Translate epoch index from human-readable format to pythonic
+    if n > 0:
+        n -= 1
+
+    print_json = config.get('print_json', False)
+
+    if trials:
+        val = trials[n]
+        Hyperopt.print_epoch_details(val, total_epochs, print_json, no_header,
+                                     header_str="Epoch details")
+
+
+def _hyperopt_filter_trials(trials: List, only_best: bool, only_profitable: bool) -> List:
+    """
+    Filter our items from the list of hyperopt results
+    """
+    if only_best:
+        trials = [x for x in trials if x['is_best']]
+    if only_profitable:
+        trials = [x for x in trials if x['results_metrics']['profit'] > 0]
+
+    logger.info(f"{len(trials)} " +
+                ("best " if only_best else "") +
+                ("profitable " if only_profitable else "") +
+                "epochs found.")
+
+    return trials

freqtrade/commands/list_commands.py

@@ -0,0 +1,156 @@
+import csv
+import logging
+import sys
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any, Dict
+
+import rapidjson
+from tabulate import tabulate
+
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.constants import USERPATH_STRATEGY
+from freqtrade.exceptions import OperationalException
+from freqtrade.exchange import (available_exchanges, ccxt_exchanges,
+                                market_is_active, symbol_is_pair)
+from freqtrade.misc import plural
+from freqtrade.resolvers import ExchangeResolver, StrategyResolver
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def start_list_exchanges(args: Dict[str, Any]) -> None:
+    """
+    Print available exchanges
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    exchanges = ccxt_exchanges() if args['list_exchanges_all'] else available_exchanges()
+    if args['print_one_column']:
+        print('\n'.join(exchanges))
+    else:
+        if args['list_exchanges_all']:
+            print(f"All exchanges supported by the ccxt library: {', '.join(exchanges)}")
+        else:
+            print(f"Exchanges available for Freqtrade: {', '.join(exchanges)}")
+
+
+def start_list_strategies(args: Dict[str, Any]) -> None:
+    """
+    Print Strategies available in a directory
+    """
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    directory = Path(config.get('strategy_path', config['user_data_dir'] / USERPATH_STRATEGY))
+    strategies = StrategyResolver.search_all_objects(directory)
+    # Sort alphabetically
+    strategies = sorted(strategies, key=lambda x: x['name'])
+    strats_to_print = [{'name': s['name'], 'location': s['location'].name} for s in strategies]
+
+    if args['print_one_column']:
+        print('\n'.join([s['name'] for s in strategies]))
+    else:
+        print(tabulate(strats_to_print, headers='keys', tablefmt='pipe'))
+
+
+def start_list_timeframes(args: Dict[str, Any]) -> None:
+    """
+    Print ticker intervals (timeframes) available on Exchange
+    """
+    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
+    # Do not use ticker_interval set in the config
+    config['ticker_interval'] = None
+
+    # Init exchange
+    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+
+    if args['print_one_column']:
+        print('\n'.join(exchange.timeframes))
+    else:
+        print(f"Timeframes available for the exchange `{exchange.name}`: "
+              f"{', '.join(exchange.timeframes)}")
+
+
+def start_list_markets(args: Dict[str, Any], pairs_only: bool = False) -> None:
+    """
+    Print pairs/markets on the exchange
+    :param args: Cli args from Arguments()
+    :param pairs_only: if True print only pairs, otherwise print all instruments (markets)
+    :return: None
+    """
+    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
+
+    # Init exchange
+    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+
+    # By default only active pairs/markets are to be shown
+    active_only = not args.get('list_pairs_all', False)
+
+    base_currencies = args.get('base_currencies', [])
+    quote_currencies = args.get('quote_currencies', [])
+
+    try:
+        pairs = exchange.get_markets(base_currencies=base_currencies,
+                                     quote_currencies=quote_currencies,
+                                     pairs_only=pairs_only,
+                                     active_only=active_only)
+        # Sort the pairs/markets by symbol
+        pairs = OrderedDict(sorted(pairs.items()))
+    except Exception as e:
+        raise OperationalException(f"Cannot get markets. Reason: {e}") from e
+
+    else:
+        summary_str = ((f"Exchange {exchange.name} has {len(pairs)} ") +
+                       ("active " if active_only else "") +
+                       (plural(len(pairs), "pair" if pairs_only else "market")) +
+                       (f" with {', '.join(base_currencies)} as base "
+                        f"{plural(len(base_currencies), 'currency', 'currencies')}"
+                        if base_currencies else "") +
+                       (" and" if base_currencies and quote_currencies else "") +
+                       (f" with {', '.join(quote_currencies)} as quote "
+                        f"{plural(len(quote_currencies), 'currency', 'currencies')}"
+                        if quote_currencies else ""))
+
+        headers = ["Id", "Symbol", "Base", "Quote", "Active",
+                   *(['Is pair'] if not pairs_only else [])]
+
+        tabular_data = []
+        for _, v in pairs.items():
+            tabular_data.append({'Id': v['id'], 'Symbol': v['symbol'],
+                                 'Base': v['base'], 'Quote': v['quote'],
+                                 'Active': market_is_active(v),
+                                 **({'Is pair': symbol_is_pair(v['symbol'])}
+                                    if not pairs_only else {})})
+
+        if (args.get('print_one_column', False) or
+                args.get('list_pairs_print_json', False) or
+                args.get('print_csv', False)):
+            # Print summary string in the log in case of machine-readable
+            # regular formats.
+            logger.info(f"{summary_str}.")
+        else:
+            # Print empty string separating leading logs and output in case of
+            # human-readable formats.
+            print()
+
+        if len(pairs):
+            if args.get('print_list', False):
+                # print data as a list, with human-readable summary
+                print(f"{summary_str}: {', '.join(pairs.keys())}.")
+            elif args.get('print_one_column', False):
+                print('\n'.join(pairs.keys()))
+            elif args.get('list_pairs_print_json', False):
+                print(rapidjson.dumps(list(pairs.keys()), default=str))
+            elif args.get('print_csv', False):
+                writer = csv.DictWriter(sys.stdout, fieldnames=headers)
+                writer.writeheader()
+                writer.writerows(tabular_data)
+            else:
+                # print data as a table, with the human-readable summary
+                print(f"{summary_str}:")
+                print(tabulate(tabular_data, headers='keys', tablefmt='pipe'))
+        elif not (args.get('print_one_column', False) or
+                  args.get('list_pairs_print_json', False) or
+                  args.get('print_csv', False)):
+            print(f"{summary_str}.")

freqtrade/commands/optimize_commands.py

@@ -0,0 +1,102 @@
+import logging
+from typing import Any, Dict
+
+from freqtrade import constants
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.exceptions import DependencyException, OperationalException
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def setup_optimize_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
+    """
+    Prepare the configuration for the Hyperopt module
+    :param args: Cli args from Arguments()
+    :return: Configuration
+    """
+    config = setup_utils_configuration(args, method)
+
+    if method == RunMode.BACKTEST:
+        if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
+            raise DependencyException('stake amount could not be "%s" for backtesting' %
+                                      constants.UNLIMITED_STAKE_AMOUNT)
+
+    return config
+
+
+def start_backtesting(args: Dict[str, Any]) -> None:
+    """
+    Start Backtesting script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    # Import here to avoid loading backtesting module when it's not used
+    from freqtrade.optimize.backtesting import Backtesting
+
+    # Initialize configuration
+    config = setup_optimize_configuration(args, RunMode.BACKTEST)
+
+    logger.info('Starting freqtrade in Backtesting mode')
+
+    # Initialize backtesting object
+    backtesting = Backtesting(config)
+    backtesting.start()
+
+
+def start_hyperopt(args: Dict[str, Any]) -> None:
+    """
+    Start hyperopt script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    # Import here to avoid loading hyperopt module when it's not used
+    try:
+        from filelock import FileLock, Timeout
+        from freqtrade.optimize.hyperopt import Hyperopt
+    except ImportError as e:
+        raise OperationalException(
+            f"{e}. Please ensure that the hyperopt dependencies are installed.") from e
+    # Initialize configuration
+    config = setup_optimize_configuration(args, RunMode.HYPEROPT)
+
+    logger.info('Starting freqtrade in Hyperopt mode')
+
+    lock = FileLock(Hyperopt.get_lock_filename(config))
+
+    try:
+        with lock.acquire(timeout=1):
+
+            # Remove noisy log messages
+            logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
+            logging.getLogger('filelock').setLevel(logging.WARNING)
+
+            # Initialize backtesting object
+            hyperopt = Hyperopt(config)
+            hyperopt.start()
+
+    except Timeout:
+        logger.info("Another running instance of freqtrade Hyperopt detected.")
+        logger.info("Simultaneous execution of multiple Hyperopt commands is not supported. "
+                    "Hyperopt module is resource hungry. Please run your Hyperopt sequentially "
+                    "or on separate machines.")
+        logger.info("Quitting now.")
+        # TODO: return False here in order to help freqtrade to exit
+        # with non-zero exit code...
+        # Same in Edge and Backtesting start() functions.
+
+
+def start_edge(args: Dict[str, Any]) -> None:
+    """
+    Start Edge script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    from freqtrade.optimize.edge_cli import EdgeCli
+    # Initialize configuration
+    config = setup_optimize_configuration(args, RunMode.EDGE)
+    logger.info('Starting freqtrade in Edge mode')
+
+    # Initialize Edge object
+    edge_cli = EdgeCli(config)
+    edge_cli.start()

freqtrade/commands/pairlist_commands.py

@@ -0,0 +1,42 @@
+import logging
+from typing import Any, Dict
+
+import rapidjson
+
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.resolvers import ExchangeResolver
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def start_test_pairlist(args: Dict[str, Any]) -> None:
+    """
+    Test Pairlist configuration
+    """
+    from freqtrade.pairlist.pairlistmanager import PairListManager
+    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
+
+    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+
+    quote_currencies = args.get('quote_currencies')
+    if not quote_currencies:
+        quote_currencies = [config.get('stake_currency')]
+    results = {}
+    for curr in quote_currencies:
+        config['stake_currency'] = curr
+        # Do not use ticker_interval set in the config
+        pairlists = PairListManager(exchange, config)
+        pairlists.refresh_pairlist()
+        results[curr] = pairlists.whitelist
+
+    for curr, pairlist in results.items():
+        if not args.get('print_one_column', False):
+            print(f"Pairs for {curr}: ")
+
+        if args.get('print_one_column', False):
+            print('\n'.join(pairlist))
+        elif args.get('list_pairs_print_json', False):
+            print(rapidjson.dumps(list(pairlist), default=str))
+        else:
+            print(pairlist)

freqtrade/commands/plot_commands.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict
 
+from freqtrade.configuration import setup_utils_configuration
 from freqtrade.exceptions import OperationalException
 from freqtrade.state import RunMode
-from freqtrade.utils import setup_utils_configuration
 
 
 def validate_plot_args(args: Dict[str, Any]):

freqtrade/commands/trade_commands.py

@@ -0,0 +1,25 @@
+import logging
+
+from typing import Any, Dict
+
+
+logger = logging.getLogger(__name__)
+
+
+def start_trading(args: Dict[str, Any]) -> int:
+    """
+    Main entry point for trading mode
+    """
+    from freqtrade.worker import Worker
+    # Load and run worker
+    worker = None
+    try:
+        worker = Worker(args)
+        worker.run()
+    except KeyboardInterrupt:
+        logger.info('SIGINT received, aborting ...')
+    finally:
+        if worker:
+            logger.info("worker found ... calling exit")
+            worker.exit()
+    return 0

freqtrade/configuration/__init__.py

@@ -1,5 +1,7 @@
-from freqtrade.configuration.arguments import Arguments  # noqa: F401
+# flake8: noqa: F401
-from freqtrade.configuration.check_exchange import check_exchange, remove_credentials  # noqa: F401
+
-from freqtrade.configuration.timerange import TimeRange  # noqa: F401
+from freqtrade.configuration.config_setup import setup_utils_configuration
-from freqtrade.configuration.configuration import Configuration  # noqa: F401
+from freqtrade.configuration.check_exchange import check_exchange, remove_credentials
-from freqtrade.configuration.config_validation import validate_config_consistency  # noqa: F401
+from freqtrade.configuration.timerange import TimeRange
+from freqtrade.configuration.configuration import Configuration
+from freqtrade.configuration.config_validation import validate_config_consistency

freqtrade/configuration/config_setup.py

@@ -0,0 +1,25 @@
+import logging
+from typing import Any, Dict
+
+from .config_validation import validate_config_consistency
+from .configuration import Configuration
+from .check_exchange import remove_credentials
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def setup_utils_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
+    """
+    Prepare the configuration for utils subcommands
+    :param args: Cli args from Arguments()
+    :return: Configuration
+    """
+    configuration = Configuration(args, method)
+    config = configuration.get_config()
+
+    # Ensure we do not use Exchange credentials
+    remove_credentials(config)
+    validate_config_consistency(config)
+
+    return config

freqtrade/main.py

@@ -14,7 +14,7 @@ if sys.version_info < (3, 6):
 import logging
 from typing import Any, List
 
-from freqtrade.configuration import Arguments
+from freqtrade.commands import Arguments
 
 
 logger = logging.getLogger('freqtrade')

freqtrade/optimize/__init__.py

@@ -1,102 +0,0 @@
-import logging
-from typing import Any, Dict
-
-from freqtrade import constants
-from freqtrade.exceptions import DependencyException, OperationalException
-from freqtrade.state import RunMode
-from freqtrade.utils import setup_utils_configuration
-
-logger = logging.getLogger(__name__)
-
-
-def setup_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
-    """
-    Prepare the configuration for the Hyperopt module
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    config = setup_utils_configuration(args, method)
-
-    if method == RunMode.BACKTEST:
-        if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
-            raise DependencyException('stake amount could not be "%s" for backtesting' %
-                                      constants.UNLIMITED_STAKE_AMOUNT)
-
-    return config
-
-
-def start_backtesting(args: Dict[str, Any]) -> None:
-    """
-    Start Backtesting script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Import here to avoid loading backtesting module when it's not used
-    from freqtrade.optimize.backtesting import Backtesting
-
-    # Initialize configuration
-    config = setup_configuration(args, RunMode.BACKTEST)
-
-    logger.info('Starting freqtrade in Backtesting mode')
-
-    # Initialize backtesting object
-    backtesting = Backtesting(config)
-    backtesting.start()
-
-
-def start_hyperopt(args: Dict[str, Any]) -> None:
-    """
-    Start hyperopt script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Import here to avoid loading hyperopt module when it's not used
-    try:
-        from filelock import FileLock, Timeout
-        from freqtrade.optimize.hyperopt import Hyperopt
-    except ImportError as e:
-        raise OperationalException(
-            f"{e}. Please ensure that the hyperopt dependencies are installed.") from e
-    # Initialize configuration
-    config = setup_configuration(args, RunMode.HYPEROPT)
-
-    logger.info('Starting freqtrade in Hyperopt mode')
-
-    lock = FileLock(Hyperopt.get_lock_filename(config))
-
-    try:
-        with lock.acquire(timeout=1):
-
-            # Remove noisy log messages
-            logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
-            logging.getLogger('filelock').setLevel(logging.WARNING)
-
-            # Initialize backtesting object
-            hyperopt = Hyperopt(config)
-            hyperopt.start()
-
-    except Timeout:
-        logger.info("Another running instance of freqtrade Hyperopt detected.")
-        logger.info("Simultaneous execution of multiple Hyperopt commands is not supported. "
-                    "Hyperopt module is resource hungry. Please run your Hyperopt sequentially "
-                    "or on separate machines.")
-        logger.info("Quitting now.")
-        # TODO: return False here in order to help freqtrade to exit
-        # with non-zero exit code...
-        # Same in Edge and Backtesting start() functions.
-
-
-def start_edge(args: Dict[str, Any]) -> None:
-    """
-    Start Edge script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    from freqtrade.optimize.edge_cli import EdgeCli
-    # Initialize configuration
-    config = setup_configuration(args, RunMode.EDGE)
-    logger.info('Starting freqtrade in Edge mode')
-
-    # Initialize Edge object
-    edge_cli = EdgeCli(config)
-    edge_cli.start()

freqtrade/utils.py

@@ -1,482 +0,0 @@
-import csv
-import logging
-import sys
-from collections import OrderedDict
-from operator import itemgetter
-from pathlib import Path
-from typing import Any, Dict, List
-
-import arrow
-import rapidjson
-from colorama import init as colorama_init
-from tabulate import tabulate
-
-from freqtrade.configuration import (Configuration, TimeRange,
-                                     remove_credentials,
-                                     validate_config_consistency)
-from freqtrade.configuration.directory_operations import (copy_sample_files,
-                                                          create_userdata_dir)
-from freqtrade.constants import USERPATH_HYPEROPTS, USERPATH_STRATEGY
-from freqtrade.data.history import (convert_trades_to_ohlcv,
-                                    refresh_backtest_ohlcv_data,
-                                    refresh_backtest_trades_data)
-from freqtrade.exceptions import OperationalException
-from freqtrade.exchange import (available_exchanges, ccxt_exchanges,
-                                market_is_active, symbol_is_pair)
-from freqtrade.misc import plural, render_template
-from freqtrade.resolvers import ExchangeResolver, StrategyResolver
-from freqtrade.state import RunMode
-
-logger = logging.getLogger(__name__)
-
-
-def setup_utils_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
-    """
-    Prepare the configuration for utils subcommands
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    configuration = Configuration(args, method)
-    config = configuration.get_config()
-
-    # Ensure we do not use Exchange credentials
-    remove_credentials(config)
-    validate_config_consistency(config)
-
-    return config
-
-
-def start_trading(args: Dict[str, Any]) -> int:
-    """
-    Main entry point for trading mode
-    """
-    from freqtrade.worker import Worker
-    # Load and run worker
-    worker = None
-    try:
-        worker = Worker(args)
-        worker.run()
-    except KeyboardInterrupt:
-        logger.info('SIGINT received, aborting ...')
-    finally:
-        if worker:
-            logger.info("worker found ... calling exit")
-            worker.exit()
-    return 0
-
-
-def start_list_exchanges(args: Dict[str, Any]) -> None:
-    """
-    Print available exchanges
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    exchanges = ccxt_exchanges() if args['list_exchanges_all'] else available_exchanges()
-    if args['print_one_column']:
-        print('\n'.join(exchanges))
-    else:
-        if args['list_exchanges_all']:
-            print(f"All exchanges supported by the ccxt library: {', '.join(exchanges)}")
-        else:
-            print(f"Exchanges available for Freqtrade: {', '.join(exchanges)}")
-
-
-def start_create_userdir(args: Dict[str, Any]) -> None:
-    """
-    Create "user_data" directory to contain user data strategies, hyperopt, ...)
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    if "user_data_dir" in args and args["user_data_dir"]:
-        userdir = create_userdata_dir(args["user_data_dir"], create_dir=True)
-        copy_sample_files(userdir, overwrite=args["reset"])
-    else:
-        logger.warning("`create-userdir` requires --userdir to be set.")
-        sys.exit(1)
-
-
-def deploy_new_strategy(strategy_name, strategy_path: Path, subtemplate: str):
-    """
-    Deploy new strategy from template to strategy_path
-    """
-    indicators = render_template(templatefile=f"subtemplates/indicators_{subtemplate}.j2",)
-    buy_trend = render_template(templatefile=f"subtemplates/buy_trend_{subtemplate}.j2",)
-    sell_trend = render_template(templatefile=f"subtemplates/sell_trend_{subtemplate}.j2",)
-    plot_config = render_template(templatefile=f"subtemplates/plot_config_{subtemplate}.j2",)
-
-    strategy_text = render_template(templatefile='base_strategy.py.j2',
-                                    arguments={"strategy": strategy_name,
-                                               "indicators": indicators,
-                                               "buy_trend": buy_trend,
-                                               "sell_trend": sell_trend,
-                                               "plot_config": plot_config,
-                                               })
-
-    logger.info(f"Writing strategy to `{strategy_path}`.")
-    strategy_path.write_text(strategy_text)
-
-
-def start_new_strategy(args: Dict[str, Any]) -> None:
-
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    if "strategy" in args and args["strategy"]:
-        if args["strategy"] == "DefaultStrategy":
-            raise OperationalException("DefaultStrategy is not allowed as name.")
-
-        new_path = config['user_data_dir'] / USERPATH_STRATEGY / (args["strategy"] + ".py")
-
-        if new_path.exists():
-            raise OperationalException(f"`{new_path}` already exists. "
-                                       "Please choose another Strategy Name.")
-
-        deploy_new_strategy(args['strategy'], new_path, args['template'])
-
-    else:
-        raise OperationalException("`new-strategy` requires --strategy to be set.")
-
-
-def deploy_new_hyperopt(hyperopt_name, hyperopt_path: Path, subtemplate: str):
-    """
-    Deploys a new hyperopt template to hyperopt_path
-    """
-    buy_guards = render_template(
-        templatefile=f"subtemplates/hyperopt_buy_guards_{subtemplate}.j2",)
-    sell_guards = render_template(
-        templatefile=f"subtemplates/hyperopt_sell_guards_{subtemplate}.j2",)
-    buy_space = render_template(
-        templatefile=f"subtemplates/hyperopt_buy_space_{subtemplate}.j2",)
-    sell_space = render_template(
-        templatefile=f"subtemplates/hyperopt_sell_space_{subtemplate}.j2",)
-
-    strategy_text = render_template(templatefile='base_hyperopt.py.j2',
-                                    arguments={"hyperopt": hyperopt_name,
-                                               "buy_guards": buy_guards,
-                                               "sell_guards": sell_guards,
-                                               "buy_space": buy_space,
-                                               "sell_space": sell_space,
-                                               })
-
-    logger.info(f"Writing hyperopt to `{hyperopt_path}`.")
-    hyperopt_path.write_text(strategy_text)
-
-
-def start_new_hyperopt(args: Dict[str, Any]) -> None:
-
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    if "hyperopt" in args and args["hyperopt"]:
-        if args["hyperopt"] == "DefaultHyperopt":
-            raise OperationalException("DefaultHyperopt is not allowed as name.")
-
-        new_path = config['user_data_dir'] / USERPATH_HYPEROPTS / (args["hyperopt"] + ".py")
-
-        if new_path.exists():
-            raise OperationalException(f"`{new_path}` already exists. "
-                                       "Please choose another Strategy Name.")
-        deploy_new_hyperopt(args['hyperopt'], new_path, args['template'])
-    else:
-        raise OperationalException("`new-hyperopt` requires --hyperopt to be set.")
-
-
-def start_download_data(args: Dict[str, Any]) -> None:
-    """
-    Download data (former download_backtest_data.py script)
-    """
-    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
-
-    timerange = TimeRange()
-    if 'days' in config:
-        time_since = arrow.utcnow().shift(days=-config['days']).strftime("%Y%m%d")
-        timerange = TimeRange.parse_timerange(f'{time_since}-')
-
-    if 'pairs' not in config:
-        raise OperationalException(
-            "Downloading data requires a list of pairs. "
-            "Please check the documentation on how to configure this.")
-
-    logger.info(f'About to download pairs: {config["pairs"]}, '
-                f'intervals: {config["timeframes"]} to {config["datadir"]}')
-
-    pairs_not_available: List[str] = []
-
-    # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config)
-    try:
-
-        if config.get('download_trades'):
-            pairs_not_available = refresh_backtest_trades_data(
-                exchange, pairs=config["pairs"], datadir=config['datadir'],
-                timerange=timerange, erase=config.get("erase"))
-
-            # Convert downloaded trade data to different timeframes
-            convert_trades_to_ohlcv(
-                pairs=config["pairs"], timeframes=config["timeframes"],
-                datadir=config['datadir'], timerange=timerange, erase=config.get("erase"))
-        else:
-            pairs_not_available = refresh_backtest_ohlcv_data(
-                exchange, pairs=config["pairs"], timeframes=config["timeframes"],
-                datadir=config['datadir'], timerange=timerange, erase=config.get("erase"))
-
-    except KeyboardInterrupt:
-        sys.exit("SIGINT received, aborting ...")
-
-    finally:
-        if pairs_not_available:
-            logger.info(f"Pairs [{','.join(pairs_not_available)}] not available "
-                        f"on exchange {exchange.name}.")
-
-
-def start_list_strategies(args: Dict[str, Any]) -> None:
-    """
-    Print Strategies available in a directory
-    """
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    directory = Path(config.get('strategy_path', config['user_data_dir'] / USERPATH_STRATEGY))
-    strategies = StrategyResolver.search_all_objects(directory)
-    # Sort alphabetically
-    strategies = sorted(strategies, key=lambda x: x['name'])
-    strats_to_print = [{'name': s['name'], 'location': s['location'].name} for s in strategies]
-
-    if args['print_one_column']:
-        print('\n'.join([s['name'] for s in strategies]))
-    else:
-        print(tabulate(strats_to_print, headers='keys', tablefmt='pipe'))
-
-
-def start_list_timeframes(args: Dict[str, Any]) -> None:
-    """
-    Print ticker intervals (timeframes) available on Exchange
-    """
-    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
-    # Do not use ticker_interval set in the config
-    config['ticker_interval'] = None
-
-    # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
-
-    if args['print_one_column']:
-        print('\n'.join(exchange.timeframes))
-    else:
-        print(f"Timeframes available for the exchange `{exchange.name}`: "
-              f"{', '.join(exchange.timeframes)}")
-
-
-def start_list_markets(args: Dict[str, Any], pairs_only: bool = False) -> None:
-    """
-    Print pairs/markets on the exchange
-    :param args: Cli args from Arguments()
-    :param pairs_only: if True print only pairs, otherwise print all instruments (markets)
-    :return: None
-    """
-    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
-
-    # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
-
-    # By default only active pairs/markets are to be shown
-    active_only = not args.get('list_pairs_all', False)
-
-    base_currencies = args.get('base_currencies', [])
-    quote_currencies = args.get('quote_currencies', [])
-
-    try:
-        pairs = exchange.get_markets(base_currencies=base_currencies,
-                                     quote_currencies=quote_currencies,
-                                     pairs_only=pairs_only,
-                                     active_only=active_only)
-        # Sort the pairs/markets by symbol
-        pairs = OrderedDict(sorted(pairs.items()))
-    except Exception as e:
-        raise OperationalException(f"Cannot get markets. Reason: {e}") from e
-
-    else:
-        summary_str = ((f"Exchange {exchange.name} has {len(pairs)} ") +
-                       ("active " if active_only else "") +
-                       (plural(len(pairs), "pair" if pairs_only else "market")) +
-                       (f" with {', '.join(base_currencies)} as base "
-                        f"{plural(len(base_currencies), 'currency', 'currencies')}"
-                        if base_currencies else "") +
-                       (" and" if base_currencies and quote_currencies else "") +
-                       (f" with {', '.join(quote_currencies)} as quote "
-                        f"{plural(len(quote_currencies), 'currency', 'currencies')}"
-                        if quote_currencies else ""))
-
-        headers = ["Id", "Symbol", "Base", "Quote", "Active",
-                   *(['Is pair'] if not pairs_only else [])]
-
-        tabular_data = []
-        for _, v in pairs.items():
-            tabular_data.append({'Id': v['id'], 'Symbol': v['symbol'],
-                                 'Base': v['base'], 'Quote': v['quote'],
-                                 'Active': market_is_active(v),
-                                 **({'Is pair': symbol_is_pair(v['symbol'])}
-                                    if not pairs_only else {})})
-
-        if (args.get('print_one_column', False) or
-                args.get('list_pairs_print_json', False) or
-                args.get('print_csv', False)):
-            # Print summary string in the log in case of machine-readable
-            # regular formats.
-            logger.info(f"{summary_str}.")
-        else:
-            # Print empty string separating leading logs and output in case of
-            # human-readable formats.
-            print()
-
-        if len(pairs):
-            if args.get('print_list', False):
-                # print data as a list, with human-readable summary
-                print(f"{summary_str}: {', '.join(pairs.keys())}.")
-            elif args.get('print_one_column', False):
-                print('\n'.join(pairs.keys()))
-            elif args.get('list_pairs_print_json', False):
-                print(rapidjson.dumps(list(pairs.keys()), default=str))
-            elif args.get('print_csv', False):
-                writer = csv.DictWriter(sys.stdout, fieldnames=headers)
-                writer.writeheader()
-                writer.writerows(tabular_data)
-            else:
-                # print data as a table, with the human-readable summary
-                print(f"{summary_str}:")
-                print(tabulate(tabular_data, headers='keys', tablefmt='pipe'))
-        elif not (args.get('print_one_column', False) or
-                  args.get('list_pairs_print_json', False) or
-                  args.get('print_csv', False)):
-            print(f"{summary_str}.")
-
-
-def start_test_pairlist(args: Dict[str, Any]) -> None:
-    """
-    Test Pairlist configuration
-    """
-    from freqtrade.pairlist.pairlistmanager import PairListManager
-    config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
-
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
-
-    quote_currencies = args.get('quote_currencies')
-    if not quote_currencies:
-        quote_currencies = [config.get('stake_currency')]
-    results = {}
-    for curr in quote_currencies:
-        config['stake_currency'] = curr
-        # Do not use ticker_interval set in the config
-        pairlists = PairListManager(exchange, config)
-        pairlists.refresh_pairlist()
-        results[curr] = pairlists.whitelist
-
-    for curr, pairlist in results.items():
-        if not args.get('print_one_column', False):
-            print(f"Pairs for {curr}: ")
-
-        if args.get('print_one_column', False):
-            print('\n'.join(pairlist))
-        elif args.get('list_pairs_print_json', False):
-            print(rapidjson.dumps(list(pairlist), default=str))
-        else:
-            print(pairlist)
-
-
-def start_hyperopt_list(args: Dict[str, Any]) -> None:
-    """
-    List hyperopt epochs previously evaluated
-    """
-    from freqtrade.optimize.hyperopt import Hyperopt
-
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    only_best = config.get('hyperopt_list_best', False)
-    only_profitable = config.get('hyperopt_list_profitable', False)
-    print_colorized = config.get('print_colorized', False)
-    print_json = config.get('print_json', False)
-    no_details = config.get('hyperopt_list_no_details', False)
-    no_header = False
-
-    trials_file = (config['user_data_dir'] /
-                   'hyperopt_results' / 'hyperopt_results.pickle')
-
-    # Previous evaluations
-    trials = Hyperopt.load_previous_results(trials_file)
-    total_epochs = len(trials)
-
-    trials = _hyperopt_filter_trials(trials, only_best, only_profitable)
-
-    # TODO: fetch the interval for epochs to print from the cli option
-    epoch_start, epoch_stop = 0, None
-
-    if print_colorized:
-        colorama_init(autoreset=True)
-
-    try:
-        # Human-friendly indexes used here (starting from 1)
-        for val in trials[epoch_start:epoch_stop]:
-            Hyperopt.print_results_explanation(val, total_epochs, not only_best, print_colorized)
-
-    except KeyboardInterrupt:
-        print('User interrupted..')
-
-    if trials and not no_details:
-        sorted_trials = sorted(trials, key=itemgetter('loss'))
-        results = sorted_trials[0]
-        Hyperopt.print_epoch_details(results, total_epochs, print_json, no_header)
-
-
-def start_hyperopt_show(args: Dict[str, Any]) -> None:
-    """
-    Show details of a hyperopt epoch previously evaluated
-    """
-    from freqtrade.optimize.hyperopt import Hyperopt
-
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    only_best = config.get('hyperopt_list_best', False)
-    only_profitable = config.get('hyperopt_list_profitable', False)
-    no_header = config.get('hyperopt_show_no_header', False)
-
-    trials_file = (config['user_data_dir'] /
-                   'hyperopt_results' / 'hyperopt_results.pickle')
-
-    # Previous evaluations
-    trials = Hyperopt.load_previous_results(trials_file)
-    total_epochs = len(trials)
-
-    trials = _hyperopt_filter_trials(trials, only_best, only_profitable)
-    trials_epochs = len(trials)
-
-    n = config.get('hyperopt_show_index', -1)
-    if n > trials_epochs:
-        raise OperationalException(
-                f"The index of the epoch to show should be less than {trials_epochs + 1}.")
-    if n < -trials_epochs:
-        raise OperationalException(
-                f"The index of the epoch to show should be greater than {-trials_epochs - 1}.")
-
-    # Translate epoch index from human-readable format to pythonic
-    if n > 0:
-        n -= 1
-
-    print_json = config.get('print_json', False)
-
-    if trials:
-        val = trials[n]
-        Hyperopt.print_epoch_details(val, total_epochs, print_json, no_header,
-                                     header_str="Epoch details")
-
-
-def _hyperopt_filter_trials(trials: List, only_best: bool, only_profitable: bool) -> List:
-    """
-    Filter our items from the list of hyperopt results
-    """
-    if only_best:
-        trials = [x for x in trials if x['is_best']]
-    if only_profitable:
-        trials = [x for x in trials if x['results_metrics']['profit'] > 0]
-
-    logger.info(f"{len(trials)} " +
-                ("best " if only_best else "") +
-                ("profitable " if only_profitable else "") +
-                "epochs found.")
-
-    return trials

tests/commands/test_commands.py

@@ -4,15 +4,15 @@ from unittest.mock import MagicMock, PropertyMock
 
 import pytest
 
+from freqtrade.commands import (start_create_userdir, start_download_data,
+                                start_hyperopt_list, start_hyperopt_show,
+                                start_list_exchanges, start_list_markets,
+                                start_list_strategies, start_list_timeframes,
+                                start_new_hyperopt, start_new_strategy,
+                                start_test_pairlist, start_trading)
+from freqtrade.configuration import setup_utils_configuration
 from freqtrade.exceptions import OperationalException
 from freqtrade.state import RunMode
-from freqtrade.utils import (setup_utils_configuration, start_create_userdir,
-                             start_download_data, start_hyperopt_list,
-                             start_hyperopt_show, start_list_exchanges,
-                             start_list_markets, start_list_strategies,
-                             start_list_timeframes, start_new_hyperopt,
-                             start_new_strategy, start_test_pairlist,
-                             start_trading)
 from tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
                             patched_configuration_load_config_file)
 
@@ -451,8 +451,8 @@ def test_create_datadir(caplog, mocker):
     # Added assert here to analyze random test-failures ...
     assert len(caplog.record_tuples) == 0
 
-    cud = mocker.patch("freqtrade.utils.create_userdata_dir", MagicMock())
+    cud = mocker.patch("freqtrade.commands.deploy_commands.create_userdata_dir", MagicMock())
-    csf = mocker.patch("freqtrade.utils.copy_sample_files", MagicMock())
+    csf = mocker.patch("freqtrade.commands.deploy_commands.copy_sample_files", MagicMock())
     args = [
         "create-userdir",
         "--userdir",
@@ -538,7 +538,7 @@ def test_start_new_hyperopt_no_arg(mocker, caplog):
 
 
 def test_download_data_keyboardInterrupt(mocker, caplog, markets):
-    dl_mock = mocker.patch('freqtrade.utils.refresh_backtest_ohlcv_data',
+    dl_mock = mocker.patch('freqtrade.commands.data_commands.refresh_backtest_ohlcv_data',
                            MagicMock(side_effect=KeyboardInterrupt))
     patch_exchange(mocker)
     mocker.patch(
@@ -556,7 +556,7 @@ def test_download_data_keyboardInterrupt(mocker, caplog, markets):
 
 
 def test_download_data_no_markets(mocker, caplog):
-    dl_mock = mocker.patch('freqtrade.utils.refresh_backtest_ohlcv_data',
+    dl_mock = mocker.patch('freqtrade.commands.data_commands.refresh_backtest_ohlcv_data',
                            MagicMock(return_value=["ETH/BTC", "XRP/BTC"]))
     patch_exchange(mocker, id='binance')
     mocker.patch(
@@ -574,7 +574,7 @@ def test_download_data_no_markets(mocker, caplog):
 
 
 def test_download_data_no_exchange(mocker, caplog):
-    mocker.patch('freqtrade.utils.refresh_backtest_ohlcv_data',
+    mocker.patch('freqtrade.commands.data_commands.refresh_backtest_ohlcv_data',
                  MagicMock(return_value=["ETH/BTC", "XRP/BTC"]))
     patch_exchange(mocker)
     mocker.patch(
@@ -594,7 +594,7 @@ def test_download_data_no_pairs(mocker, caplog):
 
     mocker.patch.object(Path, "exists", MagicMock(return_value=False))
 
-    mocker.patch('freqtrade.utils.refresh_backtest_ohlcv_data',
+    mocker.patch('freqtrade.commands.data_commands.refresh_backtest_ohlcv_data',
                  MagicMock(return_value=["ETH/BTC", "XRP/BTC"]))
     patch_exchange(mocker)
     mocker.patch(
@@ -613,9 +613,9 @@ def test_download_data_no_pairs(mocker, caplog):
 
 
 def test_download_data_trades(mocker, caplog):
-    dl_mock = mocker.patch('freqtrade.utils.refresh_backtest_trades_data',
+    dl_mock = mocker.patch('freqtrade.commands.data_commands.refresh_backtest_trades_data',
                            MagicMock(return_value=[]))
-    convert_mock = mocker.patch('freqtrade.utils.convert_trades_to_ohlcv',
+    convert_mock = mocker.patch('freqtrade.commands.data_commands.convert_trades_to_ohlcv',
                                 MagicMock(return_value=[]))
     patch_exchange(mocker)
     mocker.patch(
@@ -639,7 +639,7 @@ def test_start_list_strategies(mocker, caplog, capsys):
     args = [
         "list-strategies",
         "--strategy-path",
-        str(Path(__file__).parent / "strategy"),
+        str(Path(__file__).parent.parent / "strategy"),
         "-1"
     ]
     pargs = get_args(args)
@@ -654,7 +654,7 @@ def test_start_list_strategies(mocker, caplog, capsys):
     args = [
         "list-strategies",
         "--strategy-path",
-        str(Path(__file__).parent / "strategy"),
+        str(Path(__file__).parent.parent / "strategy"),
     ]
     pargs = get_args(args)
     # pargs['config'] = None

tests/conftest.py

@@ -14,7 +14,7 @@ import pytest
 from telegram import Chat, Message, Update
 
 from freqtrade import constants, persistence
-from freqtrade.configuration import Arguments
+from freqtrade.commands import Arguments
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.edge import Edge, PairInfo
 from freqtrade.exchange import Exchange

tests/optimize/test_backtesting.py

@@ -12,13 +12,13 @@ from arrow import Arrow
 
 from freqtrade import constants
 from freqtrade.configuration import TimeRange
+from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_backtesting
 from freqtrade.data import history
 from freqtrade.data.btanalysis import evaluate_result_multi
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.data.history import get_timerange
 from freqtrade.exceptions import DependencyException, OperationalException
-from freqtrade.optimize import setup_configuration, start_backtesting
 from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.state import RunMode
 from freqtrade.strategy.default_strategy import DefaultStrategy
@@ -177,7 +177,7 @@ def _trend_alternate(dataframe=None, metadata=None):
 
 
 # Unit tests
-def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
+def test_setup_optimize_configuration_without_arguments(mocker, default_conf, caplog) -> None:
     patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
@@ -186,7 +186,7 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
         '--strategy', 'DefaultStrategy',
     ]
 
-    config = setup_configuration(get_args(args), RunMode.BACKTEST)
+    config = setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
@@ -227,7 +227,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
         '--fee', '0',
     ]
 
-    config = setup_configuration(get_args(args), RunMode.BACKTEST)
+    config = setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
@@ -260,7 +260,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
     assert log_has('Parameter --fee detected, setting fee to: {} ...'.format(config['fee']), caplog)
 
 
-def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
+def test_setup_optimize_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
     default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
 
     patched_configuration_load_config_file(mocker, default_conf)
@@ -272,7 +272,7 @@ def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog
     ]
 
     with pytest.raises(DependencyException, match=r'.*stake amount.*'):
-        setup_configuration(get_args(args), RunMode.BACKTEST)
+        setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
 
 
 def test_start(mocker, fee, default_conf, caplog) -> None:

tests/optimize/test_edge_cli.py

@@ -3,14 +3,14 @@
 
 from unittest.mock import MagicMock
 
-from freqtrade.optimize import setup_configuration, start_edge
+from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_edge
 from freqtrade.optimize.edge_cli import EdgeCli
 from freqtrade.state import RunMode
 from tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
                             patched_configuration_load_config_file)
 
 
-def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
+def test_setup_optimize_configuration_without_arguments(mocker, default_conf, caplog) -> None:
     patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
@@ -19,7 +19,7 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
         '--strategy', 'DefaultStrategy',
     ]
 
-    config = setup_configuration(get_args(args), RunMode.EDGE)
+    config = setup_optimize_configuration(get_args(args), RunMode.EDGE)
     assert config['runmode'] == RunMode.EDGE
 
     assert 'max_open_trades' in config
@@ -53,7 +53,7 @@ def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> N
         '--stoplosses=-0.01,-0.10,-0.001'
     ]
 
-    config = setup_configuration(get_args(args), RunMode.EDGE)
+    config = setup_optimize_configuration(get_args(args), RunMode.EDGE)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config

tests/optimize/test_hyperopt.py

@@ -9,10 +9,10 @@ import pytest
 from arrow import Arrow
 from filelock import Timeout
 
-from freqtrade.exceptions import OperationalException
+from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_hyperopt
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.data.history import load_tickerdata_file
-from freqtrade.optimize import setup_configuration, start_hyperopt
+from freqtrade.exceptions import OperationalException
 from freqtrade.optimize.default_hyperopt import DefaultHyperOpt
 from freqtrade.optimize.default_hyperopt_loss import DefaultHyperOptLoss
 from freqtrade.optimize.hyperopt import Hyperopt
@@ -77,7 +77,7 @@ def test_setup_hyperopt_configuration_without_arguments(mocker, default_conf, ca
         '--hyperopt', 'DefaultHyperOpt',
     ]
 
-    config = setup_configuration(get_args(args), RunMode.HYPEROPT)
+    config = setup_optimize_configuration(get_args(args), RunMode.HYPEROPT)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
@@ -117,7 +117,7 @@ def test_setup_hyperopt_configuration_with_arguments(mocker, default_conf, caplo
         '--print-all'
     ]
 
-    config = setup_configuration(get_args(args), RunMode.HYPEROPT)
+    config = setup_optimize_configuration(get_args(args), RunMode.HYPEROPT)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config

tests/test_arguments.py

@@ -5,8 +5,8 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from freqtrade.configuration import Arguments
+from freqtrade.commands import Arguments
-from freqtrade.configuration.cli_options import check_int_positive
+from freqtrade.commands.cli_options import check_int_positive
 
 
 # Parse common command-line-arguments. Used for all tools

tests/test_configuration.py

@@ -10,7 +10,8 @@ from unittest.mock import MagicMock
 import pytest
 from jsonschema import ValidationError
 
-from freqtrade.configuration import (Arguments, Configuration, check_exchange,
+from freqtrade.commands import Arguments
+from freqtrade.configuration import (Configuration, check_exchange,
                                      remove_credentials,
                                      validate_config_consistency)
 from freqtrade.configuration.config_validation import validate_config_schema

tests/test_main.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock, PropertyMock
 
 import pytest
 
-from freqtrade.configuration import Arguments
+from freqtrade.commands import Arguments
 from freqtrade.exceptions import OperationalException, FreqtradeException
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.main import main
@@ -26,7 +26,7 @@ def test_parse_args_backtesting(mocker) -> None:
     Test that main() can start backtesting and also ensure we can pass some specific arguments
     further argument parsing is done in test_arguments.py
     """
-    backtesting_mock = mocker.patch('freqtrade.optimize.start_backtesting', MagicMock())
+    backtesting_mock = mocker.patch('freqtrade.commands.start_backtesting')
     backtesting_mock.__name__ = PropertyMock("start_backtesting")
     # it's sys.exit(0) at the end of backtesting
     with pytest.raises(SystemExit):
@@ -42,7 +42,7 @@ def test_parse_args_backtesting(mocker) -> None:
 
 
 def test_main_start_hyperopt(mocker) -> None:
-    hyperopt_mock = mocker.patch('freqtrade.optimize.start_hyperopt', MagicMock())
+    hyperopt_mock = mocker.patch('freqtrade.commands.start_hyperopt', MagicMock())
     hyperopt_mock.__name__ = PropertyMock("start_hyperopt")
     # it's sys.exit(0) at the end of hyperopt
     with pytest.raises(SystemExit):

tests/test_plotting.py

@@ -11,7 +11,7 @@ from freqtrade.configuration import TimeRange
 from freqtrade.data import history
 from freqtrade.data.btanalysis import create_cum_profit, load_backtest_data
 from freqtrade.exceptions import OperationalException
-from freqtrade.plot.plot_utils import start_plot_dataframe, start_plot_profit
+from freqtrade.commands import start_plot_dataframe, start_plot_profit
 from freqtrade.plot.plotting import (add_indicators, add_profit,
                                      create_plotconfig,
                                      generate_candlestick_graph,