diff --git a/docs/strategy-advanced.md b/docs/strategy-advanced.md index 0704473fb..8c99f1d2e 100644 --- a/docs/strategy-advanced.md +++ b/docs/strategy-advanced.md @@ -357,6 +357,33 @@ See [Dataframe access](#dataframe-access) for more information about dataframe u --- +## Custom order entry price rules + +By default, freqtrade use the orderbook to automatically set an order price, you also have the option to create custom order prices based on your strategy. + +You can use this feature by setting the `use_custom_entry_price` option to `true` in config and creating a custom_entry_price function. + +### Custom order entry price exemple +``` python +from datetime import datetime, timedelta, timezone +from freqtrade.persistence import Trade + +class AwesomeStrategy(IStrategy): + + # ... populate_* methods + + def custom_entry_price(self, pair: str, current_time: datetime, + current_rate, **kwargs) -> float: + + dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair, + timeframe=self.timeframe) + entryprice = dataframe['bollinger_10_lowerband'].iat[-1] + + return entryprice + +``` + + ## Custom order timeout rules Simple, time-based order-timeouts can be configured either via strategy or in the configuration in the `unfilledtimeout` section. @@ -366,7 +393,7 @@ However, freqtrade also offers a custom callback for both order types, which all !!! Note Unfilled order timeouts are not relevant during backtesting or hyperopt, and are only relevant during real (live) trading. Therefore these methods are only called in these circumstances. -### Custom order timeout example +## Custom order timeout example A simple example, which applies different unfilled-timeouts depending on the price of the asset can be seen below. It applies a tight timeout for higher priced assets, while allowing more time to fill on cheap coins. diff --git a/freqtrade/constants.py b/freqtrade/constants.py index b48644c58..f118ac700 100644 --- a/freqtrade/constants.py +++ b/freqtrade/constants.py @@ -433,6 +433,8 @@ SCHEMA_MINIMAL_REQUIRED = [ CANCEL_REASON = { "TIMEOUT": "cancelled due to timeout", + "ENTRYPRICECHANGED": "Custom entry price changed", + "EXITPRICECHANGED": "Custom exit price changed", "PARTIALLY_FILLED_KEEP_OPEN": "partially filled - keeping order open", "PARTIALLY_FILLED": "partially filled", "FULLY_CANCELLED": "fully cancelled", diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py index 09aa06adf..4abc7e508 100644 --- a/freqtrade/freqtradebot.py +++ b/freqtrade/freqtradebot.py @@ -169,6 +169,7 @@ class FreqtradeBot(LoggingMixin): with self._sell_lock: # Check and handle any timed out open orders self.check_handle_timedout() + self.check_handle_custom_entryprice_outdated() # Protect from collisions with forcesell. # Without this, freqtrade my try to recreate stoploss_on_exchange orders @@ -480,6 +481,14 @@ class FreqtradeBot(LoggingMixin): else: # Calculate price buy_limit_requested = self.exchange.get_rate(pair, refresh=True, side="buy") + if self.config.get('use_custom_entry_price', False): + buy_rate = self.exchange.get_rate(pair, refresh=True, side="buy") + custom_entry_price = strategy_safe_wrapper(self.strategy.custom_entry_price, + default_retval=stake_amount)( + pair=pair, current_time=datetime.now(timezone.utc), + current_rate=buy_rate) + + buy_limit_requested = custom_entry_price if not buy_limit_requested: raise PricingError('Could not determine buy price.') @@ -911,6 +920,70 @@ class FreqtradeBot(LoggingMixin): order=order))): self.handle_cancel_sell(trade, order, constants.CANCEL_REASON['TIMEOUT']) + def _check_entryprice_outdated(self, side: str, order: dict) -> bool: + """ + Check if entry price is outdated by comparing it to the new prefered entry price + , and if the order is still open and price outdated + """ + #print("check_entryprice_outdated") + if self.config.get('use_custom_entry_price', False): + order_prefered_entry_price = order['price'] # order['trade'] + + #print(order) + #order_open_rate_requested = order.trade['open_rate_requested'] + #print("order_trade_object : {}".format(order['trade'])) + + # get pep from strategy data provider + pair = order['symbol'] + old_prefered_entry_price = order_prefered_entry_price + #new_prefered_entry_price = self.strategy.custom_info[pair]['pep_long'].iloc[-1] #buy_limit_requested + new_prefered_entry_price = self.strategy.entryprice + + old_prefered_entry_price_rounded = self.exchange.price_to_precision(pair, order_prefered_entry_price) + new_prefered_entry_price_rounded = self.exchange.price_to_precision(pair, new_prefered_entry_price) + + if old_prefered_entry_price_rounded != new_prefered_entry_price_rounded: + print("order['symbol']: {}".format(order['symbol'])) + print("new_prefered_entry_price: {}, old_prefered_entry_price: {}".format(new_prefered_entry_price, old_prefered_entry_price)) + print("rounded new pep: {}, rounded old pep: {}".format(new_prefered_entry_price_rounded, old_prefered_entry_price_rounded)) + print("Delta in prefered entry price, order to cancel") + return True + else: + return False + else: + return False + + def check_handle_custom_entryprice_outdated(self) -> None: + """ + Check if any orders prefered entryprice change and cancel if necessary + :return: None + """ + + for trade in Trade.get_open_order_trades(): + try: + if not trade.open_order_id: + continue + order = self.exchange.fetch_order(trade.open_order_id, trade.pair) + except (ExchangeError): + logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc()) + continue + + fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order) + + # Refresh entryprice value if order is open + if (order['status'] == 'open'): + self.strategy.entryprice = strategy_safe_wrapper(self.strategy.custom_entry_price)( + pair=trade.pair, current_time=datetime.now(timezone.utc), + current_rate=trade.open_rate_requested) + + if (order['side'] == 'buy' and (order['status'] == 'open') and ( + self._check_entryprice_outdated('buy', order))): + self.handle_cancel_buy(trade, order, constants.CANCEL_REASON['ENTRYPRICECHANGED']) + + elif (order['side'] == 'sell' and (order['status'] == 'open') and ( + self._check_entryprice_outdated('sell', order))): + self.handle_cancel_sell(trade, order, constants.CANCEL_REASON['EXITPRICECHANGED']) + def cancel_all_open_orders(self) -> None: """ Cancel all orders that are currently open diff --git a/freqtrade/resolvers/strategy_resolver.py b/freqtrade/resolvers/strategy_resolver.py index 1239b78b3..3248ed385 100644 --- a/freqtrade/resolvers/strategy_resolver.py +++ b/freqtrade/resolvers/strategy_resolver.py @@ -79,6 +79,7 @@ class StrategyResolver(IResolver): ("trailing_stop_positive_offset", 0.0), ("trailing_only_offset_is_reached", None), ("use_custom_stoploss", None), + ("use_custom_entry_price", None), ("process_only_new_candles", None), ("order_types", None), ("order_time_in_force", None), diff --git a/freqtrade/rpc/api_server/api_schemas.py b/freqtrade/rpc/api_server/api_schemas.py index 318762136..c66a01490 100644 --- a/freqtrade/rpc/api_server/api_schemas.py +++ b/freqtrade/rpc/api_server/api_schemas.py @@ -129,6 +129,7 @@ class ShowConfig(BaseModel): trailing_stop_positive_offset: Optional[float] trailing_only_offset_is_reached: Optional[bool] use_custom_stoploss: Optional[bool] + use_custom_entry_price: Optional[bool] timeframe: Optional[str] timeframe_ms: int timeframe_min: int diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py index 902975fde..2983c1dfa 100644 --- a/freqtrade/rpc/rpc.py +++ b/freqtrade/rpc/rpc.py @@ -116,6 +116,7 @@ class RPC: 'trailing_stop_positive_offset': config.get('trailing_stop_positive_offset'), 'trailing_only_offset_is_reached': config.get('trailing_only_offset_is_reached'), 'use_custom_stoploss': config.get('use_custom_stoploss'), + 'use_custom_entry_price': config.get('use_custom_entry_price'), 'bot_name': config.get('bot_name', 'freqtrade'), 'timeframe': config.get('timeframe'), 'timeframe_ms': timeframe_to_msecs(config['timeframe'] diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py index 6f3e047eb..af5be2711 100644 --- a/freqtrade/strategy/interface.py +++ b/freqtrade/strategy/interface.py @@ -69,6 +69,10 @@ class IStrategy(ABC, HyperStrategyMixin): # associated stoploss stoploss: float + # custom order price + entryprice: Optional[float] = None + exitprice: Optional[float] = None + # trailing stoploss trailing_stop: bool = False trailing_stop_positive: Optional[float] = None @@ -280,6 +284,24 @@ class IStrategy(ABC, HyperStrategyMixin): """ return self.stoploss + def custom_entry_price(self, pair: str, current_time: datetime, current_rate: float, + **kwargs) -> float: + """ + Custom entry price logic, returning the new entry price. + + For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/ + + When not implemented by a strategy, returns None, orderbook is used to set entry price + Only called when use_custom_entry_price is set to True. + + :param pair: Pair that's currently analyzed + :param current_time: datetime object, containing the current datetime + :param current_rate: Rate, calculated based on pricing settings in ask_strategy. + :param **kwargs: Ensure to keep this here so updates to this won't break your strategy. + :return float: New entry price value if provided + """ + return self.entryprice + def custom_sell(self, pair: str, trade: Trade, current_time: datetime, current_rate: float, current_profit: float, **kwargs) -> Optional[Union[str, bool]]: """ @@ -635,6 +657,42 @@ class IStrategy(ABC, HyperStrategyMixin): # logger.debug(f"{trade.pair} - No sell signal.") return SellCheckTuple(sell_type=SellType.NONE) + def entry_price_reached(self, pair: str, current_rate: float, + current_time: datetime, low: float = None, + high: float = None, side: str = "long") -> bool: + """ + Based on current candle low ,decides if entry price was reached + :param current_rate: current rate + :param low: Low value of this candle, only set in backtesting + :param high: High value of this candle, only set in backtesting + """ + + if self.use_custom_entry_price: + entry_price_value = strategy_safe_wrapper(self.custom_entry_price, default_retval=None + )(pair=pair, + current_time=current_time, + current_rate=current_rate) + # Sanity check - error cases will return None + if side == "long": + if entry_price_value > low: + return True + else: + logger.info(f"Entry failed because entry price {entry_price_value} \ + higher than candle low in long side") + return False + + elif side == "short": + if entry_price_value < high: + return True + else: + logger.info(f"Entry failed because entry price {entry_price_value} \ + higher than candle high in short side") + return False + + else: + logger.warning("CustomEntryPrice function did not return valid entry price") + return False + def stop_loss_reached(self, current_rate: float, trade: Trade, current_time: datetime, current_profit: float, force_stoploss: float, low: float = None, diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py index d8c87506c..7102c1a49 100644 --- a/tests/strategy/test_interface.py +++ b/tests/strategy/test_interface.py @@ -431,6 +431,34 @@ def test_stop_loss_reached(default_conf, fee, profit, adjusted, expected, traili strategy.custom_stoploss = original_stopvalue +@pytest.mark.parametrize( + 'current_rate, exp_custom_entry', 'expected_result', 'use_custom_entry_price', 'custom_entry' [ + # Profit, adjusted stoploss(absolute), profit for 2nd call, enable trailing, + # enable custom stoploss, expected after 1st call, expected after 2nd call + (99, 98, False, True, lambda current_rate, **kwargs: current_rate - (current_rate * 0.01)), # custom_entry_price pice - (price * 0.01) + (97.8, 98, True, True, lambda current_rate, **kwargs: current_rate - (current_rate * 0.01)), # price stayed under entry price + (97.8, 98, True, True, lambda current_rate, **kwargs: current_rate + (current_rate * 0.01)), # entry price over current price + (99.9, 98, True, False, None), # feature not activated + ]) +def test_entry_price_reached(default_conf, current_rate, exp_custom_entry, candle_ohlc, + expected_result, use_custom_entry_price, custom_entry) -> None: + + default_conf.update({'strategy': 'DefaultStrategy'}) + + + strategy = StrategyResolver.load_strategy(default_conf) + + strategy.use_custom_entry_price = use_custom_entry_price + custom_entry_price = custom_entry + if use_custom_entry_price: + strategy.custom_entry_price = custom_entry(current_rate) + + now = arrow.utcnow().datetime + entry_flag = strategy.entry_price_reached(current_rate=current_rate, low= None, high=None) + + + pass + def test_custom_sell(default_conf, fee, caplog) -> None: default_conf.update({'strategy': 'DefaultStrategy'}) diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py index b1e02a99b..f6b8f5544 100644 --- a/tests/test_freqtradebot.py +++ b/tests/test_freqtradebot.py @@ -904,6 +904,36 @@ def test_execute_buy(mocker, default_conf, fee, limit_buy_order, limit_buy_order with pytest.raises(PricingError, match="Could not determine buy price."): freqtrade.execute_buy(pair, stake_amount) +def test_execute_buy_custom_entry_price(mocker, default_conf, fee, limit_buy_order, limit_buy_order_open) -> None: + patch_RPCManager(mocker) + patch_exchange(mocker) + default_conf.update({'use_custom_entry_price': True}) + freqtrade = FreqtradeBot(default_conf) + freqtrade.strategy.confirm_trade_entry = MagicMock(return_value=False) + stake_amount = 3 + bid = 2304 + buy_rate_mock = MagicMock(return_value=bid) + buy_mm = MagicMock(return_value=limit_buy_order_open) + mocker.patch.multiple( + 'freqtrade.exchange.Exchange', + get_rate=buy_rate_mock, + fetch_ticker=MagicMock(return_value={ + 'bid': 2304, + 'ask': 0.00001173, + 'last': 2304 + }), + buy=buy_mm, + get_min_pair_stake_amount=MagicMock(return_value=1), + get_fee=fee, + ) + pair = 'ETH/USDT' + + # Test calling with custom entry price option activated + limit_buy_order_open['id'] = '55' + assert freqtrade.execute_buy(pair, stake_amount) + # Make sure get_rate called to provide current_rate param to custom_entry_price + assert buy_rate_mock.call_count == 1 + def test_execute_buy_confirm_error(mocker, default_conf, fee, limit_buy_order) -> None: freqtrade = get_patched_freqtradebot(mocker, default_conf)