use Config typing in more places

docs/advanced-hyperopt.md

@@ -17,6 +17,7 @@ from typing import Any, Dict
 
 from pandas import DataFrame
 
+from freqtrade.constants import Config
 from freqtrade.optimize.hyperopt import IHyperOptLoss
 
 TARGET_TRADES = 600
@@ -31,7 +32,7 @@ class SuperDuperHyperOptLoss(IHyperOptLoss):
     @staticmethod
     def hyperopt_loss_function(results: DataFrame, trade_count: int,
                                min_date: datetime, max_date: datetime,
-                               config: Dict, processed: Dict[str, DataFrame],
+                               config: Config, processed: Dict[str, DataFrame],
                                backtest_stats: Dict[str, Any],
                                *args, **kwargs) -> float:
         """

freqtrade/data/converter.py

@@ -5,7 +5,7 @@ import itertools
 import logging
 from datetime import datetime, timezone
 from operator import itemgetter
-from typing import Any, Dict, List
+from typing import Dict, List
 
 import pandas as pd
 from pandas import DataFrame, to_datetime
@@ -237,7 +237,7 @@ def trades_to_ohlcv(trades: TradeList, timeframe: str) -> DataFrame:
     return df_new.loc[:, DEFAULT_DATAFRAME_COLUMNS]
 
 
-def convert_trades_format(config: Dict[str, Any], convert_from: str, convert_to: str, erase: bool):
+def convert_trades_format(config: Config, convert_from: str, convert_to: str, erase: bool):
     """
     Convert trades from one format to another format.
     :param config: Config dictionary

freqtrade/optimize/hyperopt_loss/hyperopt_loss_calmar.py

@@ -10,6 +10,7 @@ from typing import Any, Dict
 
 from pandas import DataFrame
 
+from freqtrade.constants import Config
 from freqtrade.data.metrics import calculate_max_drawdown
 from freqtrade.optimize.hyperopt import IHyperOptLoss
 
@@ -27,7 +28,7 @@ class CalmarHyperOptLoss(IHyperOptLoss):
         trade_count: int,
         min_date: datetime,
         max_date: datetime,
-        config: Dict,
+        config: Config,
         processed: Dict[str, DataFrame],
         backtest_stats: Dict[str, Any],
         *args,

freqtrade/optimize/hyperopt_loss/hyperopt_loss_max_drawdown_relative.py

@@ -4,10 +4,9 @@ MaxDrawDownRelativeHyperOptLoss
 This module defines the alternative HyperOptLoss class which can be used for
 Hyperoptimization.
 """
-from typing import Dict
-
 from pandas import DataFrame
 
+from freqtrade.constants import Config
 from freqtrade.data.metrics import calculate_underwater
 from freqtrade.optimize.hyperopt import IHyperOptLoss
 
@@ -22,7 +21,7 @@ class MaxDrawDownRelativeHyperOptLoss(IHyperOptLoss):
     """
 
     @staticmethod
-    def hyperopt_loss_function(results: DataFrame, config: Dict,
+    def hyperopt_loss_function(results: DataFrame, config: Config,
                                *args, **kwargs) -> float:
 
         """

freqtrade/optimize/hyperopt_loss_interface.py

@@ -9,6 +9,8 @@ from typing import Any, Dict
 
 from pandas import DataFrame
 
+from freqtrade.constants import Config
+
 
 class IHyperOptLoss(ABC):
     """
@@ -21,7 +23,7 @@ class IHyperOptLoss(ABC):
     @abstractmethod
     def hyperopt_loss_function(*, results: DataFrame, trade_count: int,
                                min_date: datetime, max_date: datetime,
-                               config: Dict, processed: Dict[str, DataFrame],
+                               config: Config, processed: Dict[str, DataFrame],
                                backtest_stats: Dict[str, Any],
                                **kwargs) -> float:
         """

freqtrade/optimize/hyperopt_tools.py

@@ -81,7 +81,7 @@ class HyperoptTools():
                            )
 
     @staticmethod
-    def try_export_params(config: Dict[str, Any], strategy_name: str, params: Dict):
+    def try_export_params(config: Config, strategy_name: str, params: Dict):
         if params.get(FTHYPT_FILEVERSION, 1) >= 2 and not config.get('disableparamexport', False):
             # Export parameters ...
             fn = HyperoptTools.get_strategy_filename(config, strategy_name)
@@ -91,7 +91,7 @@ class HyperoptTools():
                 logger.warning("Strategy not found, not exporting parameter file.")
 
     @staticmethod
-    def has_space(config: Dict[str, Any], space: str) -> bool:
+    def has_space(config: Config, space: str) -> bool:
         """
         Tell if the space value is contained in the configuration
         """
@@ -131,7 +131,7 @@ class HyperoptTools():
             return False
 
     @staticmethod
-    def load_filtered_results(results_file: Path, config: Dict[str, Any]) -> Tuple[List, int]:
+    def load_filtered_results(results_file: Path, config: Config) -> Tuple[List, int]:
         filteroptions = {
             'only_best': config.get('hyperopt_list_best', False),
             'only_profitable': config.get('hyperopt_list_profitable', False),
@@ -346,7 +346,7 @@ class HyperoptTools():
         return trials
 
     @staticmethod
-    def get_result_table(config: dict, results: list, total_epochs: int, highlight_best: bool,
+    def get_result_table(config: Config, results: list, total_epochs: int, highlight_best: bool,
                          print_colorized: bool, remove_header: int) -> str:
         """
         Log result table
@@ -444,7 +444,7 @@ class HyperoptTools():
         return table
 
     @staticmethod
-    def export_csv_file(config: dict, results: list, csv_file: str) -> None:
+    def export_csv_file(config: Config, results: list, csv_file: str) -> None:
         """
         Log result to csv-file
         """

freqtrade/optimize/optimize_reports.py

@@ -7,7 +7,8 @@ from typing import Any, Dict, List, Union
 from pandas import DataFrame, to_datetime
 from tabulate import tabulate
 
-from freqtrade.constants import DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN, UNLIMITED_STAKE_AMOUNT
+from freqtrade.constants import (DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN, UNLIMITED_STAKE_AMOUNT,
+                                 Config)
 from freqtrade.data.metrics import (calculate_cagr, calculate_csum, calculate_market_change,
                                     calculate_max_drawdown)
 from freqtrade.misc import decimals_per_coin, file_dump_joblib, file_dump_json, round_coin_value
@@ -898,7 +899,7 @@ def show_backtest_result(strategy: str, results: Dict[str, Any], stake_currency:
     print()
 
 
-def show_backtest_results(config: Dict, backtest_stats: Dict):
+def show_backtest_results(config: Config, backtest_stats: Dict):
     stake_currency = config['stake_currency']
 
     for strategy, results in backtest_stats['strategy'].items():
@@ -918,7 +919,7 @@ def show_backtest_results(config: Dict, backtest_stats: Dict):
         print('\nFor more details, please look at the detail tables above')
 
 
-def show_sorted_pairlist(config: Dict, backtest_stats: Dict):
+def show_sorted_pairlist(config: Config, backtest_stats: Dict):
     if config.get('backtest_show_pair_list', False):
         for strategy, results in backtest_stats['strategy'].items():
             print(f"Pairs for Strategy {strategy}: \n[")

freqtrade/plot/plotting.py

@@ -1,10 +1,11 @@
 import logging
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 import pandas as pd
 
 from freqtrade.configuration import TimeRange
+from freqtrade.constants import Config
 from freqtrade.data.btanalysis import (analyze_trade_parallelism, extract_trades_of_period,
                                        load_trades)
 from freqtrade.data.converter import trim_dataframe
@@ -618,7 +619,7 @@ def store_plot_file(fig, filename: str, directory: Path, auto_open: bool = False
     logger.info(f"Stored plot as {_filename}")
 
 
-def load_and_plot_trades(config: Dict[str, Any]):
+def load_and_plot_trades(config: Config):
     """
     From configuration provided
     - Initializes plot-script
@@ -666,7 +667,7 @@ def load_and_plot_trades(config: Dict[str, Any]):
     logger.info('End of plotting process. %s plots generated', pair_counter)
 
 
-def plot_profit(config: Dict[str, Any]) -> None:
+def plot_profit(config: Config) -> None:
     """
     Plots the total profit for all pairs.
     Note, the profit calculation isn't realistic.

freqtrade/plugins/pairlist/AgeFilter.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional
 import arrow
 from pandas import DataFrame
 
-from freqtrade.constants import ListPairsWithTimeframes
+from freqtrade.constants import Config, ListPairsWithTimeframes
 from freqtrade.exceptions import OperationalException
 from freqtrade.misc import plural
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -21,7 +21,7 @@ logger = logging.getLogger(__name__)
 class AgeFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/IPairList.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod, abstractproperty
 from copy import deepcopy
 from typing import Any, Dict, List
 
+from freqtrade.constants import Config
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import Exchange, market_is_active
 from freqtrade.mixins import LoggingMixin
@@ -17,7 +18,7 @@ logger = logging.getLogger(__name__)
 class IPairList(LoggingMixin, ABC):
 
     def __init__(self, exchange: Exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         """
         :param exchange: Exchange instance

freqtrade/plugins/pairlist/OffsetFilter.py

@@ -3,6 +3,7 @@ Offset pair list filter
 """
 import logging
 from typing import Any, Dict, List
+from freqtrade.constants import Config
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 class OffsetFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/PerformanceFilter.py

@@ -5,6 +5,7 @@ import logging
 from typing import Any, Dict, List
 
 import pandas as pd
+from freqtrade.constants import Config
 
 from freqtrade.persistence import Trade
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -16,7 +17,7 @@ logger = logging.getLogger(__name__)
 class PerformanceFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/PrecisionFilter.py

@@ -3,6 +3,7 @@ Precision pair list filter
 """
 import logging
 from typing import Any, Dict
+from freqtrade.constants import Config
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 class PrecisionFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/PriceFilter.py

@@ -3,6 +3,7 @@ Price pair list filter
 """
 import logging
 from typing import Any, Dict
+from freqtrade.constants import Config
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 class PriceFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/ShuffleFilter.py

@@ -4,6 +4,7 @@ Shuffle pair list filter
 import logging
 import random
 from typing import Any, Dict, List
+from freqtrade.constants import Config
 
 from freqtrade.enums import RunMode
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -15,7 +16,7 @@ logger = logging.getLogger(__name__)
 class ShuffleFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlist/pairlist_helpers.py

@@ -1,5 +1,7 @@
 import re
-from typing import Any, Dict, List
+from typing import List
+
+from freqtrade.constants import Config
 
 
 def expand_pairlist(wildcardpl: List[str], available_pairs: List[str],
@@ -42,7 +44,7 @@ def expand_pairlist(wildcardpl: List[str], available_pairs: List[str],
     return result
 
 
-def dynamic_expand_pairlist(config: Dict[str, Any], markets: List[str]) -> List[str]:
+def dynamic_expand_pairlist(config: Config, markets: List[str]) -> List[str]:
     expanded_pairs = expand_pairlist(config['pairs'], markets)
     if config.get('freqai', {}).get('enabled', False):
         corr_pairlist = config['freqai']['feature_parameters']['include_corr_pairlist']

freqtrade/plugins/pairlist/rangestabilityfilter.py

@@ -9,7 +9,7 @@ import arrow
 from cachetools import TTLCache
 from pandas import DataFrame
 
-from freqtrade.constants import ListPairsWithTimeframes
+from freqtrade.constants import Config, ListPairsWithTimeframes
 from freqtrade.exceptions import OperationalException
 from freqtrade.misc import plural
 from freqtrade.plugins.pairlist.IPairList import IPairList
@@ -21,7 +21,7 @@ logger = logging.getLogger(__name__)
 class RangeStabilityFilter(IPairList):
 
     def __init__(self, exchange, pairlistmanager,
-                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 config: Config, pairlistconfig: Dict[str, Any],
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 

freqtrade/plugins/pairlistmanager.py

@@ -7,7 +7,7 @@ from typing import Dict, List
 
 from cachetools import TTLCache, cached
 
-from freqtrade.constants import ListPairsWithTimeframes
+from freqtrade.constants import Config, ListPairsWithTimeframes
 from freqtrade.enums import CandleType
 from freqtrade.exceptions import OperationalException
 from freqtrade.mixins import LoggingMixin
@@ -21,7 +21,7 @@ logger = logging.getLogger(__name__)
 
 class PairListManager(LoggingMixin):
 
-    def __init__(self, exchange, config: dict) -> None:
+    def __init__(self, exchange, config: Config) -> None:
         self._exchange = exchange
         self._config = config
         self._whitelist = self._config['exchange'].get('pair_whitelist')

freqtrade/plugins/protectionmanager.py

@@ -5,7 +5,7 @@ import logging
 from datetime import datetime, timezone
 from typing import Dict, List, Optional
 
-from freqtrade.constants import LongShort
+from freqtrade.constants import Config, LongShort
 from freqtrade.persistence import PairLocks
 from freqtrade.persistence.models import PairLock
 from freqtrade.plugins.protections import IProtection
@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 class ProtectionManager():
 
-    def __init__(self, config: Dict, protections: List) -> None:
+    def __init__(self, config: Config, protections: List) -> None:
         self._config = config
 
         self._protection_handlers: List[IProtection] = []

freqtrade/resolvers/exchange_resolver.py

@@ -2,6 +2,7 @@
 This module loads custom exchanges
 """
 import logging
+from freqtrade.constants import Config
 
 import freqtrade.exchange as exchanges
 from freqtrade.exchange import MAP_EXCHANGE_CHILDCLASS, Exchange
@@ -18,7 +19,7 @@ class ExchangeResolver(IResolver):
     object_type = Exchange
 
     @staticmethod
-    def load_exchange(exchange_name: str, config: dict, validate: bool = True,
+    def load_exchange(exchange_name: str, config: Config, validate: bool = True,
                       load_leverage_tiers: bool = False) -> Exchange:
         """
         Load the custom class from config parameter

freqtrade/resolvers/freqaimodel_resolver.py

@@ -5,9 +5,8 @@ This module load a custom model for freqai
 """
 import logging
 from pathlib import Path
-from typing import Dict
 
-from freqtrade.constants import USERPATH_FREQAIMODELS
+from freqtrade.constants import USERPATH_FREQAIMODELS, Config
 from freqtrade.exceptions import OperationalException
 from freqtrade.freqai.freqai_interface import IFreqaiModel
 from freqtrade.resolvers import IResolver
@@ -29,7 +28,7 @@ class FreqaiModelResolver(IResolver):
     )
 
     @staticmethod
-    def load_freqaimodel(config: Dict) -> IFreqaiModel:
+    def load_freqaimodel(config: Config) -> IFreqaiModel:
         """
         Load the custom class from config parameter
         :param config: configuration dictionary

freqtrade/resolvers/hyperopt_resolver.py

@@ -5,9 +5,8 @@ This module load custom hyperopt
 """
 import logging
 from pathlib import Path
-from typing import Dict
 
-from freqtrade.constants import HYPEROPT_LOSS_BUILTIN, USERPATH_HYPEROPTS
+from freqtrade.constants import HYPEROPT_LOSS_BUILTIN, USERPATH_HYPEROPTS, Config
 from freqtrade.exceptions import OperationalException
 from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss
 from freqtrade.resolvers import IResolver
@@ -26,7 +25,7 @@ class HyperOptLossResolver(IResolver):
     initial_search_path = Path(__file__).parent.parent.joinpath('optimize/hyperopt_loss').resolve()
 
     @staticmethod
-    def load_hyperoptloss(config: Dict) -> IHyperOptLoss:
+    def load_hyperoptloss(config: Config) -> IHyperOptLoss:
         """
         Load the custom class from config parameter
         :param config: configuration dictionary

freqtrade/resolvers/iresolver.py

@@ -10,6 +10,7 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
 
+from freqtrade.constants import Config
 from freqtrade.exceptions import OperationalException
 
 
@@ -43,7 +44,7 @@ class IResolver:
     initial_search_path: Optional[Path]
 
     @classmethod
-    def build_search_paths(cls, config: Dict[str, Any], user_subdir: Optional[str] = None,
+    def build_search_paths(cls, config: Config, user_subdir: Optional[str] = None,
                            extra_dirs: List[str] = []) -> List[Path]:
 
         abs_paths: List[Path] = []
@@ -153,7 +154,7 @@ class IResolver:
         return None
 
     @classmethod
-    def load_object(cls, object_name: str, config: dict, *, kwargs: dict,
+    def load_object(cls, object_name: str, config: Config, *, kwargs: dict,
                     extra_dir: Optional[str] = None) -> Any:
         """
         Search and loads the specified object as configured in hte child class.

freqtrade/resolvers/pairlist_resolver.py

@@ -6,6 +6,7 @@ This module load custom pairlists
 import logging
 from pathlib import Path
 
+from freqtrade.constants import Config
 from freqtrade.plugins.pairlist.IPairList import IPairList
 from freqtrade.resolvers import IResolver
 
@@ -24,7 +25,7 @@ class PairListResolver(IResolver):
 
     @staticmethod
     def load_pairlist(pairlist_name: str, exchange, pairlistmanager,
-                      config: dict, pairlistconfig: dict, pairlist_pos: int) -> IPairList:
+                      config: Config, pairlistconfig: dict, pairlist_pos: int) -> IPairList:
         """
         Load the pairlist with pairlist_name
         :param pairlist_name: Classname of the pairlist

freqtrade/resolvers/protection_resolver.py

@@ -5,6 +5,7 @@ import logging
 from pathlib import Path
 from typing import Dict
 
+from freqtrade.constants import Config
 from freqtrade.plugins.protections import IProtection
 from freqtrade.resolvers import IResolver
 
@@ -22,7 +23,8 @@ class ProtectionResolver(IResolver):
     initial_search_path = Path(__file__).parent.parent.joinpath('plugins/protections').resolve()
 
     @staticmethod
-    def load_protection(protection_name: str, config: Dict, protection_config: Dict) -> IProtection:
+    def load_protection(protection_name: str, config: Config,
+                        protection_config: Dict) -> IProtection:
         """
         Load the protection with protection_name
         :param protection_name: Classname of the pairlist

freqtrade/resolvers/strategy_resolver.py

@@ -9,10 +9,10 @@ from base64 import urlsafe_b64decode
 from inspect import getfullargspec
 from os import walk
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 
 from freqtrade.configuration.config_validation import validate_migrated_strategy_settings
-from freqtrade.constants import REQUIRED_ORDERTIF, REQUIRED_ORDERTYPES, USERPATH_STRATEGIES
+from freqtrade.constants import REQUIRED_ORDERTIF, REQUIRED_ORDERTYPES, USERPATH_STRATEGIES, Config
 from freqtrade.enums import TradingMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.resolvers import IResolver
@@ -32,7 +32,7 @@ class StrategyResolver(IResolver):
     initial_search_path = None
 
     @staticmethod
-    def load_strategy(config: Dict[str, Any] = None) -> IStrategy:
+    def load_strategy(config: Config = None) -> IStrategy:
         """
         Load the custom class from config parameter
         :param config: configuration dictionary or None
@@ -91,8 +91,7 @@ class StrategyResolver(IResolver):
         return strategy
 
     @staticmethod
-    def _override_attribute_helper(strategy, config: Dict[str, Any],
+    def _override_attribute_helper(strategy, config: Config, attribute: str, default: Any):
-                                   attribute: str, default: Any):
         """
         Override attributes in the strategy.
         Prevalence:
@@ -215,7 +214,7 @@ class StrategyResolver(IResolver):
 
     @staticmethod
     def _load_strategy(strategy_name: str,
-                       config: dict, extra_dir: Optional[str] = None) -> IStrategy:
+                       config: Config, extra_dir: Optional[str] = None) -> IStrategy:
         """
         Search and loads the specified strategy.
         :param strategy_name: name of the module to import

freqtrade/rpc/discord.py

@@ -1,6 +1,6 @@
 import logging
-from typing import Any, Dict
 
+from freqtrade.constants import Config
 from freqtrade.enums import RPCMessageType
 from freqtrade.rpc import RPC
 from freqtrade.rpc.webhook import Webhook
@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 
 
 class Discord(Webhook):
-    def __init__(self, rpc: 'RPC', config: Dict[str, Any]):
+    def __init__(self, rpc: 'RPC', config: Config):
         # super().__init__(rpc, config)
         self.rpc = rpc
         self.config = config

freqtrade/rpc/rpc_manager.py

@@ -5,6 +5,7 @@ import logging
 from collections import deque
 from typing import Any, Dict, List
 
+from freqtrade.constants import Config
 from freqtrade.enums import RPCMessageType
 from freqtrade.rpc import RPC, RPCHandler
 
@@ -89,7 +90,7 @@ class RPCManager:
                 'msg': msg,
             })
 
-    def startup_messages(self, config: Dict[str, Any], pairlist, protections) -> None:
+    def startup_messages(self, config: Config, pairlist, protections) -> None:
         if config['dry_run']:
             self.send_msg({
                 'type': RPCMessageType.WARNING,

freqtrade/rpc/telegram.py

@@ -24,7 +24,7 @@ from telegram.ext import CallbackContext, CallbackQueryHandler, CommandHandler,
 from telegram.utils.helpers import escape_markdown
 
 from freqtrade.__init__ import __version__
-from freqtrade.constants import DUST_PER_COIN
+from freqtrade.constants import DUST_PER_COIN, Config
 from freqtrade.enums import RPCMessageType, SignalDirection, TradingMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.misc import chunks, plural, round_coin_value
@@ -88,7 +88,7 @@ def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
 class Telegram(RPCHandler):
     """  This class handles all telegram communication """
 
-    def __init__(self, rpc: RPC, config: Dict[str, Any]) -> None:
+    def __init__(self, rpc: RPC, config: Config) -> None:
         """
         Init the Telegram call, and init the super class RPCHandler
         :param rpc: instance of RPC Helper class

freqtrade/rpc/webhook.py

@@ -7,6 +7,7 @@ from typing import Any, Dict
 
 from requests import RequestException, post
 
+from freqtrade.constants import Config
 from freqtrade.enums import RPCMessageType
 from freqtrade.rpc import RPC, RPCHandler
 
@@ -19,7 +20,7 @@ logger.debug('Included module rpc.webhook ...')
 class Webhook(RPCHandler):
     """  This class handles all webhook communication """
 
-    def __init__(self, rpc: RPC, config: Dict[str, Any]) -> None:
+    def __init__(self, rpc: RPC, config: Config) -> None:
         """
         Init the Webhook class, and init the super class RPCHandler
         :param rpc: instance of RPC Helper class

freqtrade/strategy/interface.py

@@ -10,7 +10,7 @@ from typing import Dict, List, Optional, Tuple, Union
 import arrow
 from pandas import DataFrame
 
-from freqtrade.constants import ListPairsWithTimeframes
+from freqtrade.constants import Config, ListPairsWithTimeframes
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.enums import (CandleType, ExitCheckTuple, ExitType, RunMode, SignalDirection,
                              SignalTagType, SignalType, TradingMode)
@@ -118,7 +118,7 @@ class IStrategy(ABC, HyperStrategyMixin):
     # Definition of plot_config. See plotting documentation for more details.
     plot_config: Dict = {}
 
-    def __init__(self, config: dict) -> None:
+    def __init__(self, config: Config) -> None:
         self.config = config
         # Dict to determine if analysis is necessary
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}

freqtrade/templates/sample_hyperopt_loss.py

@@ -4,6 +4,7 @@ from typing import Dict
 
 from pandas import DataFrame
 
+from freqtrade.constants import Config
 from freqtrade.optimize.hyperopt import IHyperOptLoss
 
 
@@ -36,7 +37,7 @@ class SampleHyperOptLoss(IHyperOptLoss):
     @staticmethod
     def hyperopt_loss_function(results: DataFrame, trade_count: int,
                                min_date: datetime, max_date: datetime,
-                               config: Dict, processed: Dict[str, DataFrame],
+                               config: Config, processed: Dict[str, DataFrame],
                                *args, **kwargs) -> float:
         """
         Objective function, returns smaller number for better results