Only call stop methods when they actually support this method

freqtrade/plugins/protectionmanager.py

@@ -50,22 +50,24 @@ class ProtectionManager():
         now = datetime.now(timezone.utc)
         result = False
         for protection_handler in self._protection_handlers:
-            result, until, reason = protection_handler.global_stop(now)
+            if protection_handler.has_global_stop:
+                result, until, reason = protection_handler.global_stop(now)
 
-            # Early stopping - first positive result blocks further trades
+                # Early stopping - first positive result blocks further trades
-            if result and until:
+                if result and until:
-                if not PairLocks.is_global_lock(until):
+                    if not PairLocks.is_global_lock(until):
-                    PairLocks.lock_pair('*', until, reason, now=now)
+                        PairLocks.lock_pair('*', until, reason, now=now)
-                result = True
+                    result = True
         return result
 
     def stop_per_pair(self, pair) -> bool:
         now = datetime.now(timezone.utc)
         result = False
         for protection_handler in self._protection_handlers:
-            result, until, reason = protection_handler.stop_per_pair(pair, now)
+            if protection_handler.has_local_stop:
-            if result and until:
+                result, until, reason = protection_handler.stop_per_pair(pair, now)
-                if not PairLocks.is_pair_locked(pair, until):
+                if result and until:
-                    PairLocks.lock_pair(pair, until, reason, now=now)
+                    if not PairLocks.is_pair_locked(pair, until):
-                result = True
+                        PairLocks.lock_pair(pair, until, reason, now=now)
+                    result = True
         return result

freqtrade/plugins/protections/cooldown_period.py

@@ -12,6 +12,11 @@ logger = logging.getLogger(__name__)
 
 class CooldownPeriod(IProtection):
 
+    # Can globally stop the bot
+    has_global_stop: bool = False
+    # Can stop trading for one pair
+    has_local_stop: bool = True
+
     def __init__(self, config: Dict[str, Any], protection_config: Dict[str, Any]) -> None:
         super().__init__(config, protection_config)
 

freqtrade/plugins/protections/iprotection.py

@@ -1,6 +1,6 @@
 
 import logging
-from abc import ABC, abstractmethod
+from abc import ABC, abstractmethod, abstractproperty
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -15,6 +15,11 @@ ProtectionReturn = Tuple[bool, Optional[datetime], Optional[str]]
 
 class IProtection(LoggingMixin, ABC):
 
+    # Can globally stop the bot
+    has_global_stop: bool = False
+    # Can stop trading for one pair
+    has_local_stop: bool = False
+
     def __init__(self, config: Dict[str, Any], protection_config: Dict[str, Any]) -> None:
         self._config = config
         self._protection_config = protection_config

freqtrade/plugins/protections/low_profit_pairs.py

@@ -12,6 +12,11 @@ logger = logging.getLogger(__name__)
 
 class LowProfitPairs(IProtection):
 
+    # Can globally stop the bot
+    has_global_stop: bool = False
+    # Can stop trading for one pair
+    has_local_stop: bool = True
+
     def __init__(self, config: Dict[str, Any], protection_config: Dict[str, Any]) -> None:
         super().__init__(config, protection_config)
 

freqtrade/plugins/protections/stoploss_guard.py

@@ -15,6 +15,11 @@ logger = logging.getLogger(__name__)
 
 class StoplossGuard(IProtection):
 
+    # Can globally stop the bot
+    has_global_stop: bool = True
+    # Can stop trading for one pair
+    has_local_stop: bool = True
+
     def __init__(self, config: Dict[str, Any], protection_config: Dict[str, Any]) -> None:
         super().__init__(config, protection_config)
 
@@ -67,7 +72,7 @@ class StoplossGuard(IProtection):
         :return: Tuple of [bool, until, reason].
             If true, all pairs will be locked with <reason> until <until>
         """
-        return self._stoploss_guard(date_now, pair=None)
+        return self._stoploss_guard(date_now, None)
 
     def stop_per_pair(self, pair: str, date_now: datetime) -> ProtectionReturn:
         """
@@ -76,4 +81,4 @@ class StoplossGuard(IProtection):
         :return: Tuple of [bool, until, reason].
             If true, this pair will be locked with <reason> until <until>
         """
-        return False, None, None
+        return self._stoploss_guard(date_now, pair)