Function calculate_reward has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

        def calculate_reward(self, action: int) -> float:
            """
            An example reward function. This is the one function that users will likely
            wish to inject their own creativity into.

• Read up
  Read up

Function start_list_exchanges has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

def start_list_exchanges(args: Dict[str, Any]) -> None:
    """
    Print available exchanges
    :param args: Cli args from Arguments()
    :return: None

• Read up
  Read up

Function _search_all_objects has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def _search_all_objects(
            cls, directory: Path, enum_failed: bool, recursive: bool = False,
            basedir: Optional[Path] = None) -> List[Dict[str, Any]]:
        """
        Searches a directory for valid objects

• Read up
  Read up

File entryexitanalysis.py has 252 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import logging
from pathlib import Path
from typing import List

import joblib

File build_config_commands.py has 251 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import logging
import secrets
from pathlib import Path
from typing import Any, Dict, List

Function __init__ has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def __init__(self, config: Config, *, exchange_config: Optional[ExchangeConfig] = None,
                 validate: bool = True, load_leverage_tiers: bool = False) -> None:
        """
        Initializes this module with the given config,
        it does basic validation whether the specified exchange and pairs are valid.

Function __exec_force_exit has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def __exec_force_exit(self, trade: Trade, ordertype: Optional[str],
                          amount: Optional[float] = None) -> bool:
        # Check if there is there are open orders
        trade_entry_cancelation_registry = []
        for oo in trade.open_orders:

• Read up
  Read up

Function generate_optimizer has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def generate_optimizer(self, raw_params: List[Any]) -> Dict[str, Any]:
        """
        Used Optimize function.
        Called once per epoch to optimize whatever is configured.
        Keep this function as optimized as possible!

• Read up
  Read up

Function is_tradesignal has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def is_tradesignal(self, action: int) -> bool:
        """
        Determine if the signal is a trade signal
        e.g.: agent wants a Actions.Long_exit while it is in a Positions.short
        """

• Read up
  Read up

Function setup_analyze_configuration has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

def setup_analyze_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
    """
    Prepare the configuration for the entry/exit reason analysis module
    :param args: Cli args from Arguments()
    :param method: Bot running mode

• Read up
  Read up

Function _load_cached_data_for_updating has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

def _load_cached_data_for_updating(
    pair: str,
    timeframe: str,
    timerange: Optional[TimeRange],
    data_handler: IDataHandler,

• Read up
  Read up

Function get_trades_for_order has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def get_trades_for_order(self, order_id: str, pair: str, since: datetime,
                             params: Optional[Dict] = None) -> List:
        trades = super().get_trades_for_order(order_id, pair, since, params)

        if self.trading_mode == TradingMode.FUTURES:

• Read up
  Read up

Function retrier_async has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

def retrier_async(f):
    async def wrapper(*args, **kwargs):
        count = kwargs.pop('count', API_RETRY_COUNT)
        kucoin = args[0].name == "KuCoin"  # Check if the exchange is KuCoin.
        try:

• Read up
  Read up

Function get_liquidation_price has 15 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def get_liquidation_price(

Function __init__ has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def __init__(self, config: Config) -> None:

        self.config = config
        self.assert_config(self.config)
        self.freqai_info: Dict[str, Any] = config["freqai"]

Function _rpc_trade_statistics has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def _rpc_trade_statistics(
            self, stake_currency: str, fiat_display_currency: str,
            start_date: Optional[datetime] = None) -> Dict[str, Any]:
        """ Returns cumulative profit statistics """

Function migrate_trades_and_orders_table has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def migrate_trades_and_orders_table(
        decl_base, inspector, engine,
        trade_back_name: str, cols: List,
        order_back_name: str, cols_order: List):
    base_currency = get_column_def(cols, 'base_currency', 'null')

Function __init__ has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def __init__(self, config: Config, exchange: Optional[Exchange] = None) -> None:

        LoggingMixin.show_output = False
        self.config = config
        self.results: BacktestResultType = get_BacktestResultType_default()

Function _send_msg has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def _send_msg(self, payload: dict) -> None:
        """do the actual call to the webhook"""

        success = False
        attempts = 0

• Read up
  Read up

Function check_order_replace has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def check_order_replace(self, trade: LocalTrade, order: Order, current_time,
                            row: Tuple) -> bool:
        """
        Check if current analyzed entry order has to be replaced and do so.
        If user requested cancellation and there are no filled orders in the trade will

• Read up
  Read up