Persist pairlocks

closes #3034

freqtrade/freqtradebot.py

@@ -937,8 +937,8 @@ class FreqtradeBot:
             self.update_trade_state(trade, trade.stoploss_order_id, stoploss_order,
                                     stoploss_order=True)
             # Lock pair for one candle to prevent immediate rebuys
-            self.strategy.lock_pair(trade.pair,
-                                    timeframe_to_next_date(self.config['timeframe']))
+            self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']),
+                                    reason='auto_lock_1_candle')
             self._notify_sell(trade, "stoploss")
             return True
 
@@ -1264,7 +1264,8 @@ class FreqtradeBot:
         Trade.session.flush()
 
         # Lock pair for one candle to prevent immediate rebuys
-        self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']))
+        self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']),
+                                reason='auto_lock_1_candle')
 
         self._notify_sell(trade, order_type)
 

freqtrade/persistence/__init__.py

@@ -1,3 +1,4 @@
 # flake8: noqa: F401
 
-from freqtrade.persistence.models import Order, Trade, clean_dry_run_db, cleanup_db, init_db
+from freqtrade.persistence.models import (Order, PairLock, Trade, clean_dry_run_db, cleanup_db,
+                                          init_db)

freqtrade/persistence/models.py

@@ -64,6 +64,9 @@ def init_db(db_url: str, clean_open_orders: bool = False) -> None:
     # Copy session attributes to order object too
     Order.session = Trade.session
     Order.query = Order.session.query_property()
+    PairLock.session = Trade.session
+    PairLock.query = PairLock.session.query_property()
+
     previous_tables = inspect(engine).get_table_names()
     _DECL_BASE.metadata.create_all(engine)
     check_migrate(engine, decl_base=_DECL_BASE, previous_tables=previous_tables)
@@ -655,3 +658,76 @@ class Trade(_DECL_BASE):
                 trade.stop_loss = None
                 trade.adjust_stop_loss(trade.open_rate, desired_stoploss)
                 logger.info(f"New stoploss: {trade.stop_loss}.")
+
+
+class PairLock(_DECL_BASE):
+    """
+    Pair Locks database model.
+    """
+    __tablename__ = 'pair_lock'
+
+    id = Column(Integer, primary_key=True)
+
+    pair = Column(String, nullable=False)
+    reason = Column(String, nullable=True)
+    # Time the pair was locked (start time)
+    lock_time = Column(DateTime, nullable=False)
+    # Time until the pair is locked (end time)
+    lock_end_time = Column(DateTime, nullable=False)
+
+    active = Column(Boolean, nullable=False, default=True)
+
+    def __repr__(self):
+        lock_time = self.open_date.strftime(DATETIME_PRINT_FORMAT)
+        lock_end_time = self.open_date.strftime(DATETIME_PRINT_FORMAT)
+        return (f'PairLock(id={self.id}, pair={self.pair}, lock_time={lock_time}, '
+                f'lock_end_time={lock_end_time})')
+
+    @staticmethod
+    def get_pair_locks(pair: str, now: Optional[datetime] = None) -> List['PairLock']:
+        """
+        Get all locks for this pair
+        :param pair: Pair to check for
+        :param now: Datetime object (generated via datetime.utcnow()). defaults to datetime.utcnow()
+        """
+        if not now:
+            now = datetime.now(timezone.utc)
+
+        return PairLock.query.filter(
+            PairLock.pair == pair,
+            func.datetime(PairLock.lock_time) <= now,
+            func.datetime(PairLock.lock_end_time) >= now,
+            # Only active locks
+            PairLock.active.is_(True),
+        ).all()
+
+    @staticmethod
+    def unlock_pair(pair: str, now: Optional[datetime] = None) -> None:
+        """
+        Release all locks for this pair.
+        """
+        if not now:
+            now = datetime.now(timezone.utc)
+
+        logger.info(f"Releasing all locks for {pair}.")
+        locks = PairLock.get_pair_locks(pair, now)
+        for lock in locks:
+            lock.active = False
+        PairLock.session.flush()
+
+    @staticmethod
+    def is_pair_locked(pair: str, now: Optional[datetime] = None) -> bool:
+        """
+        :param pair: Pair to check for
+        :param now: Datetime object (generated via datetime.utcnow()). defaults to datetime.utcnow()
+        """
+        if not now:
+            now = datetime.now(timezone.utc)
+
+        return PairLock.query.filter(
+            PairLock.pair == pair,
+            func.datetime(PairLock.lock_time) <= now,
+            func.datetime(PairLock.lock_end_time) >= now,
+            # Only active locks
+            PairLock.active.is_(True),
+        ).scalar() is not None

freqtrade/strategy/interface.py

@@ -17,7 +17,7 @@ from freqtrade.data.dataprovider import DataProvider
 from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.exchange.exchange import timeframe_to_next_date
-from freqtrade.persistence import Trade
+from freqtrade.persistence import PairLock, Trade
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from freqtrade.wallets import Wallets
 
@@ -133,7 +133,6 @@ class IStrategy(ABC):
         self.config = config
         # Dict to determine if analysis is necessary
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}
-        self._pair_locked_until: Dict[str, datetime] = {}
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@@ -278,7 +277,7 @@ class IStrategy(ABC):
         """
         return self.__class__.__name__
 
-    def lock_pair(self, pair: str, until: datetime) -> None:
+    def lock_pair(self, pair: str, until: datetime, reason: str = None) -> None:
         """
         Locks pair until a given timestamp happens.
         Locked pairs are not analyzed, and are prevented from opening new trades.
@@ -288,8 +287,15 @@ class IStrategy(ABC):
         :param until: datetime in UTC until the pair should be blocked from opening new trades.
                 Needs to be timezone aware `datetime.now(timezone.utc)`
         """
-        if pair not in self._pair_locked_until or self._pair_locked_until[pair] < until:
-            self._pair_locked_until[pair] = until
+        lock = PairLock(
+            pair=pair,
+            lock_time=datetime.now(timezone.utc),
+            lock_end_time=until,
+            reason=reason,
+            active=True
+        )
+        PairLock.session.add(lock)
+        PairLock.session.flush()
 
     def unlock_pair(self, pair: str) -> None:
         """
@@ -298,8 +304,7 @@ class IStrategy(ABC):
         manually from within the strategy, to allow an easy way to unlock pairs.
         :param pair: Unlock pair to allow trading again
         """
-        if pair in self._pair_locked_until:
-            del self._pair_locked_until[pair]
+        PairLock.unlock_pair(pair, datetime.now(timezone.utc))
 
     def is_pair_locked(self, pair: str, candle_date: datetime = None) -> bool:
         """
@@ -311,15 +316,13 @@ class IStrategy(ABC):
         :param candle_date: Date of the last candle. Optional, defaults to current date
         :returns: locking state of the pair in question.
         """
-        if pair not in self._pair_locked_until:
-            return False
+
         if not candle_date:
-            return self._pair_locked_until[pair] >= datetime.now(timezone.utc)
+            # Simple call ...
+            return PairLock.is_pair_locked(pair, candle_date)
         else:
-            # Locking should happen until a new candle arrives
             lock_time = timeframe_to_next_date(self.timeframe, candle_date)
-            # lock_time = candle_date + timedelta(minutes=timeframe_to_minutes(self.timeframe))
-            return self._pair_locked_until[pair] > lock_time
+            return PairLock.is_pair_locked(pair, lock_time)
 
     def analyze_ticker(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """