Merge branch 'develop' into feat/short

freqtrade/rpc/api_server/api_backtest.py

@@ -20,6 +20,7 @@ router = APIRouter()
 
 
 @router.post('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
+# flake8: noqa: C901
 async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: BackgroundTasks,
                              config=Depends(get_config)):
     """Start backtesting if not done so already"""
@@ -32,6 +33,10 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
     for setting in settings.keys():
         if settings[setting] is not None:
             btconfig[setting] = settings[setting]
+    try:
+        btconfig['stake_amount'] = float(btconfig['stake_amount'])
+    except ValueError:
+        pass
 
     # Force dry-run for backtesting
     btconfig['dry_run'] = True
@@ -57,8 +62,7 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
             ):
                 from freqtrade.optimize.backtesting import Backtesting
                 ApiServer._bt = Backtesting(btconfig)
-                if ApiServer._bt.timeframe_detail:
-                    ApiServer._bt.load_bt_data_detail()
+                ApiServer._bt.load_bt_data_detail()
             else:
                 ApiServer._bt.config = btconfig
                 ApiServer._bt.init_backtest()

freqtrade/rpc/api_server/api_schemas.py

@@ -152,7 +152,7 @@ class ShowConfig(BaseModel):
     trading_mode: str
     short_allowed: bool
     stake_currency: str
-    stake_amount: Union[float, str]
+    stake_amount: str
     available_capital: Optional[float]
     stake_currency_decimals: int
     max_open_trades: int
@@ -291,6 +291,7 @@ class ForceEnterPayload(BaseModel):
     price: Optional[float]
     ordertype: Optional[OrderTypeValues]
     stakeamount: Optional[float]
+    entry_tag: Optional[str]
 
 
 class ForceExitPayload(BaseModel):
@@ -380,7 +381,7 @@ class BacktestRequest(BaseModel):
     timeframe_detail: Optional[str]
     timerange: Optional[str]
     max_open_trades: Optional[int]
-    stake_amount: Optional[Union[float, str]]
+    stake_amount: Optional[str]
     enable_protections: bool
     dry_run_wallet: Optional[float]
 

freqtrade/rpc/api_server/api_v1.py

@@ -141,9 +141,11 @@ def show_config(rpc: Optional[RPC] = Depends(get_rpc_optional), config=Depends(g
 def forceentry(payload: ForceEnterPayload, rpc: RPC = Depends(get_rpc)):
     ordertype = payload.ordertype.value if payload.ordertype else None
     stake_amount = payload.stakeamount if payload.stakeamount else None
+    entry_tag = payload.entry_tag if payload.entry_tag else None
 
     trade = rpc._rpc_force_entry(payload.pair, payload.price, order_side=payload.side,
-                                 order_type=ordertype, stake_amount=stake_amount)
+                                 order_type=ordertype, stake_amount=stake_amount,
+                                 enter_tag=entry_tag)
 
     if trade:
         return ForceEnterResponse.parse_obj(trade.to_json())

freqtrade/rpc/rpc.py

@@ -116,7 +116,7 @@ class RPC:
             'short_allowed': config.get('trading_mode', 'spot') != 'spot',
             'stake_currency': config['stake_currency'],
             'stake_currency_decimals': decimals_per_coin(config['stake_currency']),
-            'stake_amount': config['stake_amount'],
+            'stake_amount': str(config['stake_amount']),
             'available_capital': config.get('available_capital'),
             'max_open_trades': (config['max_open_trades']
                                 if config['max_open_trades'] != float('inf') else -1),
@@ -606,11 +606,6 @@ class RPC:
                 'est_stake': est_stake or 0,
                 'stake': stake_currency,
             })
-        if total == 0.0:
-            if self._freqtrade.config['dry_run']:
-                raise RPCException('Running in Dry Run, balances are not available.')
-            else:
-                raise RPCException('All balances are zero.')
 
         value = self._fiat_converter.convert_amount(
             total, stake_currency, fiat_display_currency) if self._fiat_converter else 0
@@ -727,7 +722,8 @@ class RPC:
     def _rpc_force_entry(self, pair: str, price: Optional[float], *,
                          order_type: Optional[str] = None,
                          order_side: SignalDirection = SignalDirection.LONG,
-                         stake_amount: Optional[float] = None) -> Optional[Trade]:
+                         stake_amount: Optional[float] = None,
+                         enter_tag: Optional[str] = None) -> Optional[Trade]:
         """
         Handler for forcebuy <asset> <price>
         Buys a pair trade at the given or current price
@@ -765,7 +761,8 @@ class RPC:
                 'forcebuy', self._freqtrade.strategy.order_types['buy'])
         if self._freqtrade.execute_entry(pair, stake_amount, price,
                                          ordertype=order_type, trade=trade,
-                                         is_short=(order_side == SignalDirection.SHORT)
+                                         is_short=(order_side == SignalDirection.SHORT),
+                                         enter_tag=enter_tag,
                                          ):
             Trade.commit()
             trade = Trade.get_trades([Trade.is_open.is_(True), Trade.pair == pair]).first()

freqtrade/rpc/telegram.py

@@ -813,12 +813,13 @@ class Telegram(RPCHandler):
             output = ''
             if self._config['dry_run']:
                 output += "*Warning:* Simulated balances in Dry Mode.\n"
-
-            output += ("Starting capital: "
-                       f"`{result['starting_capital']}` {self._config['stake_currency']}"
-                       )
-            output += (f" `{result['starting_capital_fiat']}` "
-                       f"{self._config['fiat_display_currency']}.\n"
+            starting_cap = round_coin_value(
+                result['starting_capital'], self._config['stake_currency'])
+            output += f"Starting capital: `{starting_cap}`"
+            starting_cap_fiat = round_coin_value(
+                result['starting_capital_fiat'], self._config['fiat_display_currency']
+            ) if result['starting_capital_fiat'] > 0 else ''
+            output += (f" `, {starting_cap_fiat}`.\n"
                        ) if result['starting_capital_fiat'] > 0 else '.\n'
 
             total_dust_balance = 0
@@ -937,10 +938,11 @@ class Telegram(RPCHandler):
             self._send_msg(str(e))
 
     def _forceenter_action(self, pair, price: Optional[float], order_side: SignalDirection):
-        try:
-            self._rpc._rpc_force_entry(pair, price, order_side=order_side)
-        except RPCException as e:
-            self._send_msg(str(e))
+        if pair != 'cancel':
+            try:
+                self._rpc._rpc_force_entry(pair, price, order_side=order_side)
+            except RPCException as e:
+                self._send_msg(str(e))
 
     def _forceenter_inline(self, update: Update, _: CallbackContext) -> None:
         if update.callback_query:
@@ -975,12 +977,13 @@ class Telegram(RPCHandler):
             whitelist = self._rpc._rpc_whitelist()['whitelist']
             pair_buttons = [
                 InlineKeyboardButton(text=pair, callback_data=f"{pair}_||_{order_side}")
-                for pair in whitelist
+                for pair in sorted(whitelist)
             ]
+            buttons_aligned = self._layout_inline_keyboard(pair_buttons)
 
+            buttons_aligned.append([InlineKeyboardButton(text='Cancel', callback_data='cancel')])
             self._send_msg(msg="Which pair?",
-                           keyboard=self._layout_inline_keyboard(pair_buttons),
-                           callback_path="update_forcelong",
+                           keyboard=buttons_aligned,
                            query=update.callback_query)
 
     @authorized_only