stable/freqtrade/rpc/telegram.py

1580 lines
67 KiB
Python
Raw Normal View History

2018-03-02 15:22:00 +00:00
# pragma pylint: disable=unused-argument, unused-variable, protected-access, invalid-name
2018-02-13 03:45:59 +00:00
"""
This module manage Telegram communication
"""
2020-06-07 08:09:39 +00:00
import json
2018-03-25 19:37:14 +00:00
import logging
import re
from datetime import date, datetime, timedelta
2022-01-26 18:53:46 +00:00
from functools import partial
2021-03-01 19:08:49 +00:00
from html import escape
2020-12-20 16:22:23 +00:00
from itertools import chain
from math import isnan
from typing import Any, Callable, Dict, List, Optional, Union
2021-07-04 15:04:39 +00:00
2020-09-28 17:39:41 +00:00
import arrow
2017-11-20 21:26:32 +00:00
from tabulate import tabulate
2021-06-13 18:21:43 +00:00
from telegram import (CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, KeyboardButton,
ParseMode, ReplyKeyboardMarkup, Update)
from telegram.error import BadRequest, NetworkError, TelegramError
2021-04-14 21:20:10 +00:00
from telegram.ext import CallbackContext, CallbackQueryHandler, CommandHandler, Updater
from telegram.utils.helpers import escape_markdown
2018-03-17 21:44:47 +00:00
2018-02-13 03:45:59 +00:00
from freqtrade.__init__ import __version__
from freqtrade.constants import DUST_PER_COIN
2022-03-03 06:07:33 +00:00
from freqtrade.enums import RPCMessageType, SignalDirection, TradingMode
2020-12-22 11:34:21 +00:00
from freqtrade.exceptions import OperationalException
2021-07-04 15:04:39 +00:00
from freqtrade.misc import chunks, plural, round_coin_value
from freqtrade.persistence import Trade
2021-06-09 17:51:44 +00:00
from freqtrade.rpc import RPC, RPCException, RPCHandler
2020-09-28 17:39:41 +00:00
2018-03-25 19:37:14 +00:00
logger = logging.getLogger(__name__)
logger.debug('Included module rpc.telegram ...')
2019-04-10 04:59:10 +00:00
MAX_TELEGRAM_MESSAGE_LENGTH = 4096
2019-04-08 17:59:30 +00:00
2019-03-24 18:44:52 +00:00
def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
2017-05-14 12:14:16 +00:00
"""
Decorator to check if the message comes from the correct chat_id
:param command_handler: Telegram CommandHandler
:return: decorated function
"""
2018-02-13 03:45:59 +00:00
def wrapper(self, *args, **kwargs):
""" Decorator logic """
update = kwargs.get('update') or args[0]
2017-09-08 17:25:39 +00:00
2017-11-07 21:27:16 +00:00
# Reject unauthorized messages
if update.callback_query:
cchat_id = int(update.callback_query.message.chat.id)
else:
cchat_id = int(update.message.chat_id)
2018-02-13 03:45:59 +00:00
chat_id = int(self._config['telegram']['chat_id'])
if cchat_id != chat_id:
2018-03-25 19:37:14 +00:00
logger.info(
2018-02-13 03:45:59 +00:00
'Rejected unauthorized message from: %s',
update.message.chat_id
)
2017-11-07 21:27:16 +00:00
return wrapper
# Rollback session to avoid getting data stored in a transaction.
Trade.query.session.rollback()
logger.debug(
2018-02-13 03:45:59 +00:00
'Executing handler: %s for chat_id: %s',
command_handler.__name__,
chat_id
)
2017-11-07 21:27:16 +00:00
try:
2018-02-13 03:45:59 +00:00
return command_handler(self, *args, **kwargs)
2017-11-07 21:27:16 +00:00
except BaseException:
2018-03-25 19:37:14 +00:00
logger.exception('Exception occurred within Telegram module')
2018-02-13 03:45:59 +00:00
return wrapper
2018-03-02 15:22:00 +00:00
class Telegram(RPCHandler):
""" This class handles all telegram communication """
def __init__(self, rpc: RPC, config: Dict[str, Any]) -> None:
2018-02-13 03:45:59 +00:00
"""
Init the Telegram call, and init the super class RPCHandler
:param rpc: instance of RPC Helper class
:param config: Configuration object
2018-02-13 03:45:59 +00:00
:return: None
"""
super().__init__(rpc, config)
2018-02-13 03:45:59 +00:00
2020-12-01 18:55:20 +00:00
self._updater: Updater
2020-12-22 11:34:21 +00:00
self._init_keyboard()
2018-02-13 03:45:59 +00:00
self._init()
2020-12-22 11:34:21 +00:00
def _init_keyboard(self) -> None:
"""
Validates the keyboard configuration from telegram config
section.
"""
2021-06-17 17:50:49 +00:00
self._keyboard: List[List[Union[str, KeyboardButton]]] = [
['/daily', '/profit', '/balance'],
['/status', '/status table', '/performance'],
['/count', '/start', '/stop', '/help']
]
# do not allow commands with mandatory arguments and critical cmds
# like /forcesell and /forcebuy
# TODO: DRY! - its not good to list all valid cmds here. But otherwise
2021-06-25 13:45:49 +00:00
# this needs refactoring of the whole telegram module (same
# problem in _help()).
valid_keys: List[str] = [r'/start$', r'/stop$', r'/status$', r'/status table$',
2021-10-21 14:25:38 +00:00
r'/trades$', r'/performance$', r'/buys', r'/sells', r'/mix_tags',
r'/daily$', r'/daily \d+$', r'/profit$', r'/profit \d+',
r'/stats$', r'/count$', r'/locks$', r'/balance$',
r'/stopbuy$', r'/reload_config$', r'/show_config$',
2021-12-11 15:09:20 +00:00
r'/logs$', r'/whitelist$', r'/blacklist$', r'/bl_delete$',
2021-11-27 23:23:02 +00:00
r'/weekly$', r'/weekly \d+$', r'/monthly$', r'/monthly \d+$',
2022-01-26 19:17:00 +00:00
r'/forcebuy$', r'/forcelong$', r'/forceshort$',
2022-02-11 16:02:04 +00:00
r'/edge$', r'/health$', r'/help$', r'/version$']
# Create keys for generation
valid_keys_print = [k.replace('$', '') for k in valid_keys]
2020-12-22 11:34:21 +00:00
# custom keyboard specified in config.json
cust_keyboard = self._config['telegram'].get('keyboard', [])
if cust_keyboard:
combined = "(" + ")|(".join(valid_keys) + ")"
# check for valid shortcuts
invalid_keys = [b for b in chain.from_iterable(cust_keyboard)
if not re.match(combined, b)]
if len(invalid_keys):
2020-12-23 15:00:01 +00:00
err_msg = ('config.telegram.keyboard: Invalid commands for '
f'custom Telegram keyboard: {invalid_keys}'
f'\nvalid commands are: {valid_keys_print}')
2020-12-22 11:34:21 +00:00
raise OperationalException(err_msg)
else:
self._keyboard = cust_keyboard
2020-12-22 11:34:21 +00:00
logger.info('using custom keyboard from '
f'config.json: {self._keyboard}')
2018-02-13 03:45:59 +00:00
def _init(self) -> None:
"""
Initializes this module with the given config,
registers all known command handlers
and starts polling for message updates
"""
self._updater = Updater(token=self._config['telegram']['token'], workers=0,
use_context=True)
2018-02-13 03:45:59 +00:00
# Register command handler and start telegram message polling
handles = [
CommandHandler('status', self._status),
CommandHandler('profit', self._profit),
CommandHandler('balance', self._balance),
CommandHandler('start', self._start),
CommandHandler('stop', self._stop),
2022-01-26 19:17:00 +00:00
CommandHandler(['forcesell', 'forceexit'], self._forceexit),
2022-01-27 05:40:41 +00:00
CommandHandler(['forcebuy', 'forcelong'], partial(
self._forceenter, order_side=SignalDirection.LONG)),
CommandHandler('forceshort', partial(
self._forceenter, order_side=SignalDirection.SHORT)),
CommandHandler('trades', self._trades),
2020-08-04 12:49:59 +00:00
CommandHandler('delete', self._delete_trade),
2018-02-13 03:45:59 +00:00
CommandHandler('performance', self._performance),
2021-11-21 08:51:16 +00:00
CommandHandler(['buys', 'entries'], self._enter_tag_performance),
CommandHandler('sells', self._sell_reason_performance),
CommandHandler('mix_tags', self._mix_tag_performance),
2020-12-09 19:26:11 +00:00
CommandHandler('stats', self._stats),
2018-02-13 03:45:59 +00:00
CommandHandler('daily', self._daily),
CommandHandler('weekly', self._weekly),
CommandHandler('monthly', self._monthly),
2018-02-13 03:45:59 +00:00
CommandHandler('count', self._count),
2020-10-17 13:15:35 +00:00
CommandHandler('locks', self._locks),
2021-03-01 19:08:49 +00:00
CommandHandler(['unlock', 'delete_locks'], self._delete_locks),
CommandHandler(['reload_config', 'reload_conf'], self._reload_config),
CommandHandler(['show_config', 'show_conf'], self._show_config),
CommandHandler('stopbuy', self._stopbuy),
2018-11-10 19:15:06 +00:00
CommandHandler('whitelist', self._whitelist),
2019-09-02 18:17:23 +00:00
CommandHandler('blacklist', self._blacklist),
2021-12-11 15:09:20 +00:00
CommandHandler(['blacklist_delete', 'bl_delete'], self._blacklist_delete),
CommandHandler('logs', self._logs),
CommandHandler('edge', self._edge),
CommandHandler('health', self._health),
2018-02-13 03:45:59 +00:00
CommandHandler('help', self._help),
2021-02-13 18:40:04 +00:00
CommandHandler('version', self._version),
]
callbacks = [
CallbackQueryHandler(self._status_table, pattern='update_status_table'),
CallbackQueryHandler(self._daily, pattern='update_daily'),
CallbackQueryHandler(self._weekly, pattern='update_weekly'),
CallbackQueryHandler(self._monthly, pattern='update_monthly'),
CallbackQueryHandler(self._profit, pattern='update_profit'),
2021-02-03 18:16:27 +00:00
CallbackQueryHandler(self._balance, pattern='update_balance'),
CallbackQueryHandler(self._performance, pattern='update_performance'),
2021-11-21 08:51:16 +00:00
CallbackQueryHandler(self._enter_tag_performance,
pattern='update_enter_tag_performance'),
2021-10-24 07:15:05 +00:00
CallbackQueryHandler(self._sell_reason_performance,
pattern='update_sell_reason_performance'),
2021-10-21 14:25:38 +00:00
CallbackQueryHandler(self._mix_tag_performance, pattern='update_mix_tag_performance'),
CallbackQueryHandler(self._count, pattern='update_count'),
2022-01-27 05:40:41 +00:00
CallbackQueryHandler(self._forceenter_inline),
2018-02-13 03:45:59 +00:00
]
for handle in handles:
self._updater.dispatcher.add_handler(handle)
2021-06-13 18:21:43 +00:00
for callback in callbacks:
self._updater.dispatcher.add_handler(callback)
2018-02-13 03:45:59 +00:00
self._updater.start_polling(
bootstrap_retries=-1,
2021-12-31 11:52:32 +00:00
timeout=20,
read_latency=60, # Assumed transmission latency
drop_pending_updates=True,
2018-02-13 03:45:59 +00:00
)
2018-03-25 19:37:14 +00:00
logger.info(
2018-02-13 03:45:59 +00:00
'rpc.telegram is listening for following commands: %s',
[h.command for h in handles]
)
def cleanup(self) -> None:
"""
Stops all running telegram threads.
:return: None
"""
2021-12-31 11:52:32 +00:00
# This can take up to `timeout` from the call to `start_polling`.
2018-02-13 03:45:59 +00:00
self._updater.stop()
2021-04-20 04:41:58 +00:00
def _format_buy_msg(self, msg: Dict[str, Any]) -> str:
if self._rpc._fiat_converter:
msg['stake_amount_fiat'] = self._rpc._fiat_converter.convert_amount(
msg['stake_amount'], msg['stake_currency'], msg['fiat_currency'])
else:
msg['stake_amount_fiat'] = 0
2021-12-29 13:24:12 +00:00
is_fill = msg['type'] in [RPCMessageType.BUY_FILL, RPCMessageType.SHORT_FILL]
2021-11-14 08:19:21 +00:00
emoji = '\N{CHECK MARK}' if is_fill else '\N{LARGE BLUE CIRCLE}'
2021-04-20 04:41:58 +00:00
2021-12-30 16:18:46 +00:00
enter_side = ({'enter': 'Long', 'entered': 'Longed'} if msg['type']
in [RPCMessageType.BUY_FILL, RPCMessageType.BUY]
else {'enter': 'Short', 'entered': 'Shorted'})
2021-11-14 08:19:21 +00:00
message = (
2021-12-29 13:24:12 +00:00
f"{emoji} *{msg['exchange']}:*"
f" {enter_side['entered'] if is_fill else enter_side['enter']} {msg['pair']}"
2021-07-21 18:53:15 +00:00
f" (#{msg['trade_id']})\n"
)
2021-11-21 08:24:20 +00:00
message += f"*Enter Tag:* `{msg['enter_tag']}`\n" if msg.get('enter_tag', None) else ""
2021-11-14 08:19:21 +00:00
message += f"*Amount:* `{msg['amount']:.8f}`\n"
if msg.get('leverage') and msg.get('leverage', 1.0) != 1.0:
message += f"*Leverage:* `{msg['leverage']}`\n"
2021-11-13 20:46:00 +00:00
2021-12-29 13:24:12 +00:00
if msg['type'] in [RPCMessageType.BUY_FILL, RPCMessageType.SHORT_FILL]:
2021-11-13 20:46:00 +00:00
message += f"*Open Rate:* `{msg['open_rate']:.8f}`\n"
2021-12-29 13:24:12 +00:00
elif msg['type'] in [RPCMessageType.BUY, RPCMessageType.SHORT]:
2021-11-13 20:46:00 +00:00
message += f"*Open Rate:* `{msg['limit']:.8f}`\n"\
f"*Current Rate:* `{msg['current_rate']:.8f}`\n"
message += f"*Total:* `({round_coin_value(msg['stake_amount'], msg['stake_currency'])}"
2021-11-13 20:46:00 +00:00
if msg.get('fiat_currency', None):
message += f", {round_coin_value(msg['stake_amount_fiat'], msg['fiat_currency'])}"
2021-07-21 18:53:15 +00:00
2021-04-20 04:41:58 +00:00
message += ")`"
return message
def _format_sell_msg(self, msg: Dict[str, Any]) -> str:
msg['amount'] = round(msg['amount'], 8)
msg['profit_percent'] = round(msg['profit_ratio'] * 100, 2)
msg['duration'] = msg['close_date'].replace(
microsecond=0) - msg['open_date'].replace(microsecond=0)
msg['duration_min'] = msg['duration'].total_seconds() / 60
2021-11-21 08:24:20 +00:00
msg['enter_tag'] = msg['enter_tag'] if "enter_tag" in msg.keys() else None
2021-04-20 04:41:58 +00:00
msg['emoji'] = self._get_sell_emoji(msg)
2021-12-30 16:18:46 +00:00
msg['leverage_text'] = (f"*Leverage:* `{msg['leverage']:.1f}`\n"
2021-12-30 16:34:45 +00:00
if msg.get('leverage', None) and msg.get('leverage', 1.0) != 1.0
else "")
2021-04-20 04:41:58 +00:00
# Check if all sell properties are available.
# This might not be the case if the message origin is triggered by /forcesell
if (all(prop in msg for prop in ['gain', 'fiat_currency', 'stake_currency'])
and self._rpc._fiat_converter):
msg['profit_fiat'] = self._rpc._fiat_converter.convert_amount(
msg['profit_amount'], msg['stake_currency'], msg['fiat_currency'])
2021-11-14 08:19:21 +00:00
msg['profit_extra'] = (
f" ({msg['gain']}: {msg['profit_amount']:.8f} {msg['stake_currency']}"
f" / {msg['profit_fiat']:.3f} {msg['fiat_currency']})")
else:
msg['profit_extra'] = ''
2021-11-14 08:19:21 +00:00
is_fill = msg['type'] == RPCMessageType.SELL_FILL
2021-12-30 16:18:46 +00:00
message = (
f"{msg['emoji']} *{msg['exchange']}:* "
f"{'Exited' if is_fill else 'Exiting'} {msg['pair']} (#{msg['trade_id']})\n"
f"*{'Profit' if is_fill else 'Unrealized Profit'}:* "
f"`{msg['profit_ratio']:.2%}{msg['profit_extra']}`\n"
f"*Enter Tag:* `{msg['enter_tag']}`\n"
f"*Exit Reason:* `{msg['sell_reason']}`\n"
f"*Duration:* `{msg['duration']} ({msg['duration_min']:.1f} min)`\n"
f"*Direction:* `{msg['direction']}`\n"
f"{msg['leverage_text']}"
f"*Amount:* `{msg['amount']:.8f}`\n"
2021-12-29 13:24:12 +00:00
f"*Open Rate:* `{msg['open_rate']:.8f}`\n"
2021-12-30 16:18:46 +00:00
)
2021-11-13 19:52:59 +00:00
if msg['type'] == RPCMessageType.SELL:
2021-11-22 06:13:22 +00:00
message += (f"*Current Rate:* `{msg['current_rate']:.8f}`\n"
2021-11-14 08:19:21 +00:00
f"*Close Rate:* `{msg['limit']:.8f}`")
2021-11-13 19:52:59 +00:00
elif msg['type'] == RPCMessageType.SELL_FILL:
2021-11-14 08:19:21 +00:00
message += f"*Close Rate:* `{msg['close_rate']:.8f}`"
2021-04-20 04:41:58 +00:00
return message
def compose_message(self, msg: Dict[str, Any], msg_type: RPCMessageType) -> str:
2021-12-29 13:24:12 +00:00
if msg_type in [RPCMessageType.BUY, RPCMessageType.BUY_FILL, RPCMessageType.SHORT,
RPCMessageType.SHORT_FILL]:
2021-04-20 04:41:58 +00:00
message = self._format_buy_msg(msg)
elif msg_type in [RPCMessageType.SELL, RPCMessageType.SELL_FILL]:
message = self._format_sell_msg(msg)
2021-12-29 13:24:12 +00:00
elif msg_type in (RPCMessageType.BUY_CANCEL, RPCMessageType.SHORT_CANCEL,
RPCMessageType.SELL_CANCEL):
msg['message_side'] = 'enter' if msg_type in [RPCMessageType.BUY_CANCEL,
RPCMessageType.SHORT_CANCEL] else 'exit'
2020-06-06 15:28:00 +00:00
message = ("\N{WARNING SIGN} *{exchange}:* "
2021-12-29 13:24:12 +00:00
"Cancelling {message_side} Order for {pair} (#{trade_id}). "
"Reason: {reason}.".format(**msg))
2020-02-08 20:02:52 +00:00
2021-09-20 17:12:59 +00:00
elif msg_type == RPCMessageType.PROTECTION_TRIGGER:
message = (
"*Protection* triggered due to {reason}. "
2021-09-20 17:49:18 +00:00
"`{pair}` will be locked until `{lock_end_time}`."
2021-09-20 17:12:59 +00:00
).format(**msg)
elif msg_type == RPCMessageType.PROTECTION_TRIGGER_GLOBAL:
message = (
"*Protection* triggered due to {reason}. "
2021-09-20 17:49:18 +00:00
"*All pairs* will be locked until `{lock_end_time}`."
).format(**msg)
elif msg_type == RPCMessageType.STATUS:
message = '*Status:* `{status}`'.format(**msg)
elif msg_type == RPCMessageType.WARNING:
message = '\N{WARNING SIGN} *Warning:* `{status}`'.format(**msg)
2018-08-15 02:39:32 +00:00
elif msg_type == RPCMessageType.STARTUP:
2018-08-15 02:39:32 +00:00
message = '{status}'.format(**msg)
else:
raise NotImplementedError('Unknown message type: {}'.format(msg_type))
return message
def send_msg(self, msg: Dict[str, Any]) -> None:
""" Send a message to telegram channel """
default_noti = 'on'
msg_type = msg['type']
noti = ''
if msg_type == RPCMessageType.SELL:
sell_noti = self._config['telegram'] \
.get('notification_settings', {}).get(str(msg_type), {})
# For backward compatibility sell still can be string
if isinstance(sell_noti, str):
noti = sell_noti
else:
noti = sell_noti.get(str(msg['sell_reason']), default_noti)
else:
noti = self._config['telegram'] \
.get('notification_settings', {}).get(str(msg_type), default_noti)
if noti == 'off':
logger.info(f"Notification '{msg_type}' not sent.")
# Notification disabled
return
message = self.compose_message(msg, msg_type)
self._send_msg(message, disable_notification=(noti == 'silent'))
2020-06-06 13:38:42 +00:00
def _get_sell_emoji(self, msg):
"""
Get emoji for sell-side
"""
if float(msg['profit_percent']) >= 5.0:
return "\N{ROCKET}"
elif float(msg['profit_percent']) >= 0.0:
return "\N{EIGHT SPOKED ASTERISK}"
elif msg['sell_reason'] == "stop_loss":
return "\N{WARNING SIGN}"
else:
return "\N{CROSS MARK}"
def _prepare_entry_details(self, filled_orders, base_currency, is_open):
2022-01-22 06:54:49 +00:00
"""
Prepare details of trade with entry adjustment enabled
2022-01-22 06:54:49 +00:00
"""
lines = []
2022-02-03 18:47:03 +00:00
for x, order in enumerate(filled_orders):
2022-02-07 01:52:59 +00:00
cur_entry_datetime = arrow.get(order["order_filled_date"])
cur_entry_amount = order["amount"]
cur_entry_average = order["average"]
2022-01-22 06:54:49 +00:00
lines.append(" ")
if x == 0:
lines.append("*Entry #{}:*".format(x+1))
lines.append("*Entry Amount:* {} ({:.8f} {})"
.format(cur_entry_amount, order["cost"], base_currency))
lines.append("*Average Entry Price:* {}".format(cur_entry_average))
2022-01-22 06:54:49 +00:00
else:
sumA = 0
sumB = 0
for y in range(x):
2022-02-03 18:47:03 +00:00
sumA += (filled_orders[y]["amount"] * filled_orders[y]["average"])
sumB += filled_orders[y]["amount"]
2022-01-22 06:54:49 +00:00
prev_avg_price = sumA/sumB
price_to_1st_entry = ((cur_entry_average - filled_orders[0]["average"])
2022-02-07 01:52:59 +00:00
/ filled_orders[0]["average"])
minus_on_entry = (cur_entry_average - prev_avg_price)/prev_avg_price
2022-02-07 01:52:59 +00:00
dur_entry = cur_entry_datetime - arrow.get(filled_orders[x-1]["order_filled_date"])
days = dur_entry.days
hours, remainder = divmod(dur_entry.seconds, 3600)
2022-01-22 06:54:49 +00:00
minutes, seconds = divmod(remainder, 60)
lines.append("*Entry #{}:* at {:.2%} avg profit".format(x+1, minus_on_entry))
2022-02-06 07:08:27 +00:00
if is_open:
2022-02-07 01:52:59 +00:00
lines.append("({})".format(cur_entry_datetime
2022-02-06 07:08:27 +00:00
.humanize(granularity=["day", "hour", "minute"])))
lines.append("*Entry Amount:* {} ({:.8f} {})"
.format(cur_entry_amount, order["cost"], base_currency))
lines.append("*Average Entry Price:* {} ({:.2%} from 1st entry rate)"
.format(cur_entry_average, price_to_1st_entry))
2022-02-03 18:47:03 +00:00
lines.append("*Order filled at:* {}".format(order["order_filled_date"]))
lines.append("({}d {}h {}m {}s from previous entry)"
2022-01-22 06:54:49 +00:00
.format(days, hours, minutes, seconds))
return lines
2018-02-13 03:45:59 +00:00
@authorized_only
def _status(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /status.
Returns the current TradeThread status
:param bot: telegram bot
:param update: message update
:return: None
"""
2020-12-01 18:55:20 +00:00
if context.args and 'table' in context.args:
2019-09-02 18:17:23 +00:00
self._status_table(update, context)
2018-02-13 03:45:59 +00:00
return
2018-06-08 02:52:50 +00:00
try:
2021-01-17 20:26:55 +00:00
# Check if there's at least one numerical ID provided.
# If so, try to get only these trades.
trade_ids = []
if context.args and len(context.args) > 0:
trade_ids = [int(i) for i in context.args if i.isnumeric()]
results = self._rpc._rpc_trade_status(trade_ids=trade_ids)
position_adjust = self._config.get('position_adjustment_enable', False)
2022-02-06 02:21:16 +00:00
max_entries = self._config.get('max_entry_position_adjustment', -1)
messages = []
for r in results:
r['open_date_hum'] = arrow.get(r['open_date']).humanize()
2022-02-03 18:11:35 +00:00
r['num_entries'] = len(r['filled_entry_orders'])
2022-01-22 06:54:49 +00:00
r['sell_reason'] = r.get('sell_reason', "")
lines = [
2022-02-06 03:16:56 +00:00
"*Trade ID:* `{trade_id}`" +
("` (since {open_date_hum})`" if r['is_open'] else ""),
"*Current Pair:* {pair}",
2021-12-29 13:24:12 +00:00
"*Direction:* " + ("`Short`" if r.get('is_short') else "`Long`"),
"*Leverage:* `{leverage}`" if r.get('leverage') else "",
"*Amount:* `{amount} ({stake_amount} {base_currency})`",
2021-11-21 08:24:20 +00:00
"*Enter Tag:* `{enter_tag}`" if r['enter_tag'] else "",
"*Exit Reason:* `{sell_reason}`" if r['sell_reason'] else "",
2022-01-22 06:54:49 +00:00
]
if position_adjust:
2022-02-06 03:04:23 +00:00
max_buy_str = (f"/{max_entries + 1}" if (max_entries > 0) else "")
lines.append("*Number of Entries:* `{num_entries}`" + max_buy_str)
2022-01-22 06:54:49 +00:00
lines.extend([
"*Open Rate:* `{open_rate:.8f}`",
2022-01-22 06:54:49 +00:00
"*Close Rate:* `{close_rate:.8f}`" if r['close_rate'] else "",
"*Open Date:* `{open_date}`",
"*Close Date:* `{close_date}`" if r['close_date'] else "",
2022-02-06 02:49:02 +00:00
"*Current Rate:* `{current_rate:.8f}`" if r['is_open'] else "",
2020-11-03 07:34:12 +00:00
("*Current Profit:* " if r['is_open'] else "*Close Profit: *")
+ "`{profit_ratio:.2%}`",
2022-01-22 06:54:49 +00:00
])
2022-02-06 02:49:02 +00:00
if r['is_open']:
if (r['stop_loss_abs'] != r['initial_stop_loss_abs']
and r['initial_stop_loss_ratio'] is not None):
# Adding initial stoploss only if it is different from stoploss
lines.append("*Initial Stoploss:* `{initial_stop_loss_abs:.8f}` "
2022-02-06 03:16:56 +00:00
"`({initial_stop_loss_ratio:.2%})`")
2022-02-06 02:49:02 +00:00
# Adding stoploss and stoploss percentage only if it is not None
lines.append("*Stoploss:* `{stop_loss_abs:.8f}` " +
2022-02-06 03:16:56 +00:00
("`({stop_loss_ratio:.2%})`" if r['stop_loss_ratio'] else ""))
2022-02-06 02:49:02 +00:00
lines.append("*Stoploss distance:* `{stoploss_current_dist:.8f}` "
2022-02-06 03:16:56 +00:00
"`({stoploss_current_dist_ratio:.2%})`")
2022-02-06 02:49:02 +00:00
if r['open_order']:
if r['sell_order_status']:
lines.append("*Open Order:* `{open_order}` - `{sell_order_status}`")
else:
lines.append("*Open Order:* `{open_order}`")
lines_detail = self._prepare_entry_details(
2022-02-06 07:08:27 +00:00
r['filled_entry_orders'], r['base_currency'], r['is_open'])
2022-02-06 03:16:56 +00:00
lines.extend((lines_detail if (len(r['filled_entry_orders']) > 1) else ""))
2019-07-14 18:14:35 +00:00
# Filter empty lines using list-comprehension
messages.append("\n".join([line for line in lines if line]).format(**r))
for msg in messages:
self._send_msg(msg)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _status_table(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /status table.
Returns the current TradeThread status in table format
:param bot: telegram bot
:param update: message update
:return: None
"""
2018-06-08 02:52:50 +00:00
try:
fiat_currency = self._config.get('fiat_display_currency', '')
statlist, head, fiat_profit_sum = self._rpc._rpc_status_table(
self._config['stake_currency'], fiat_currency)
show_total = not isnan(fiat_profit_sum) and len(statlist) > 1
max_trades_per_msg = 50
"""
Calculate the number of messages of 50 trades per message
0.99 is used to make sure that there are no extra (empty) messages
As an example with 50 trades, there will be int(50/50 + 0.99) = 1 message
"""
messages_count = max(int(len(statlist) / max_trades_per_msg + 0.99), 1)
for i in range(0, messages_count):
trades = statlist[i * max_trades_per_msg:(i + 1) * max_trades_per_msg]
if show_total and i == messages_count - 1:
# append total line
trades.append(["Total", "", "", f"{fiat_profit_sum:.2f} {fiat_currency}"])
message = tabulate(trades,
headers=head,
tablefmt='simple')
if show_total and i == messages_count - 1:
# insert separators line between Total
lines = message.split("\n")
message = "\n".join(lines[:-1] + [lines[1]] + [lines[-1]])
2021-06-13 18:39:25 +00:00
self._send_msg(f"<pre>{message}</pre>", parse_mode=ParseMode.HTML,
reload_able=True, callback_path="update_status_table",
query=update.callback_query)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _daily(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /daily <n>
Returns a daily profit (in BTC) over the last n days.
:param bot: telegram bot
:param update: message update
:return: None
"""
2018-06-23 22:17:10 +00:00
stake_cur = self._config['stake_currency']
fiat_disp_cur = self._config.get('fiat_display_currency', '')
2018-02-13 03:45:59 +00:00
try:
timescale = int(context.args[0]) if context.args else 7
2019-09-02 18:17:23 +00:00
except (TypeError, ValueError, IndexError):
2018-02-13 03:45:59 +00:00
timescale = 7
2018-06-08 02:52:50 +00:00
try:
stats = self._rpc._rpc_daily_profit(
2018-06-08 02:52:50 +00:00
timescale,
2018-06-23 22:17:10 +00:00
stake_cur,
fiat_disp_cur
2018-06-08 02:52:50 +00:00
)
2020-05-17 18:12:01 +00:00
stats_tab = tabulate(
[[day['date'],
f"{round_coin_value(day['abs_profit'], stats['stake_currency'])}",
f"{day['fiat_value']:.3f} {stats['fiat_display_currency']}",
2020-05-17 18:12:01 +00:00
f"{day['trade_count']} trades"] for day in stats['data']],
headers=[
'Day',
2020-05-17 18:12:01 +00:00
f'Profit {stake_cur}',
f'Profit {fiat_disp_cur}',
'Trades',
2020-05-17 18:12:01 +00:00
],
tablefmt='simple')
message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats_tab}</pre>'
2021-06-13 18:39:25 +00:00
self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
callback_path="update_daily", query=update.callback_query)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _weekly(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /weekly <n>
Returns a weekly profit (in BTC) over the last n weeks.
:param bot: telegram bot
:param update: message update
:return: None
"""
stake_cur = self._config['stake_currency']
fiat_disp_cur = self._config.get('fiat_display_currency', '')
try:
timescale = int(context.args[0]) if context.args else 8
except (TypeError, ValueError, IndexError):
timescale = 8
try:
stats = self._rpc._rpc_weekly_profit(
timescale,
stake_cur,
fiat_disp_cur
)
stats_tab = tabulate(
[[week['date'],
f"{round_coin_value(week['abs_profit'], stats['stake_currency'])}",
f"{week['fiat_value']:.3f} {stats['fiat_display_currency']}",
f"{week['trade_count']} trades"] for week in stats['data']],
headers=[
'Monday',
f'Profit {stake_cur}',
f'Profit {fiat_disp_cur}',
'Trades',
],
tablefmt='simple')
message = f'<b>Weekly Profit over the last {timescale} weeks ' \
f'(starting from Monday)</b>:\n<pre>{stats_tab}</pre> '
self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
callback_path="update_weekly", query=update.callback_query)
except RPCException as e:
self._send_msg(str(e))
@authorized_only
def _monthly(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /monthly <n>
Returns a monthly profit (in BTC) over the last n months.
:param bot: telegram bot
:param update: message update
:return: None
"""
stake_cur = self._config['stake_currency']
fiat_disp_cur = self._config.get('fiat_display_currency', '')
try:
timescale = int(context.args[0]) if context.args else 6
except (TypeError, ValueError, IndexError):
timescale = 6
try:
stats = self._rpc._rpc_monthly_profit(
timescale,
stake_cur,
fiat_disp_cur
)
stats_tab = tabulate(
[[month['date'],
f"{round_coin_value(month['abs_profit'], stats['stake_currency'])}",
f"{month['fiat_value']:.3f} {stats['fiat_display_currency']}",
f"{month['trade_count']} trades"] for month in stats['data']],
headers=[
'Month',
f'Profit {stake_cur}',
f'Profit {fiat_disp_cur}',
'Trades',
],
tablefmt='simple')
message = f'<b>Monthly Profit over the last {timescale} months' \
f'</b>:\n<pre>{stats_tab}</pre> '
self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
callback_path="update_monthly", query=update.callback_query)
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _profit(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /profit.
Returns a cumulative profit statistics.
:param bot: telegram bot
:param update: message update
:return: None
"""
2018-06-23 22:17:10 +00:00
stake_cur = self._config['stake_currency']
fiat_disp_cur = self._config.get('fiat_display_currency', '')
2018-06-23 22:17:10 +00:00
start_date = datetime.fromtimestamp(0)
timescale = None
try:
if context.args:
timescale = int(context.args[0]) - 1
today_start = datetime.combine(date.today(), datetime.min.time())
start_date = today_start - timedelta(days=timescale)
except (TypeError, ValueError, IndexError):
pass
stats = self._rpc._rpc_trade_statistics(
2020-05-29 08:10:45 +00:00
stake_cur,
fiat_disp_cur,
start_date)
2020-05-29 08:10:45 +00:00
profit_closed_coin = stats['profit_closed_coin']
profit_closed_ratio_mean = stats['profit_closed_ratio_mean']
profit_closed_percent = stats['profit_closed_percent']
2020-05-29 08:10:45 +00:00
profit_closed_fiat = stats['profit_closed_fiat']
profit_all_coin = stats['profit_all_coin']
profit_all_ratio_mean = stats['profit_all_ratio_mean']
profit_all_percent = stats['profit_all_percent']
2020-05-29 08:10:45 +00:00
profit_all_fiat = stats['profit_all_fiat']
trade_count = stats['trade_count']
first_trade_date = stats['first_trade_date']
latest_trade_date = stats['latest_trade_date']
avg_duration = stats['avg_duration']
best_pair = stats['best_pair']
best_pair_profit_ratio = stats['best_pair_profit_ratio']
if stats['trade_count'] == 0:
markdown_msg = 'No trades yet.'
2020-05-29 08:10:45 +00:00
else:
# Message to display
if stats['closed_trade_count'] > 0:
markdown_msg = ("*ROI:* Closed trades\n"
f"∙ `{round_coin_value(profit_closed_coin, stake_cur)} "
f"({profit_closed_ratio_mean:.2%}) "
f"({profit_closed_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
f"∙ `{round_coin_value(profit_closed_fiat, fiat_disp_cur)}`\n")
else:
markdown_msg = "`No closed trade` \n"
markdown_msg += (
f"*ROI:* All trades\n"
f"∙ `{round_coin_value(profit_all_coin, stake_cur)} "
f"({profit_all_ratio_mean:.2%}) "
f"({profit_all_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
f"∙ `{round_coin_value(profit_all_fiat, fiat_disp_cur)}`\n"
f"*Total Trade Count:* `{trade_count}`\n"
f"*{'First Trade opened' if not timescale else 'Showing Profit since'}:* "
f"`{first_trade_date}`\n"
f"*Latest Trade opened:* `{latest_trade_date}\n`"
f"*Win / Loss:* `{stats['winning_trades']} / {stats['losing_trades']}`"
2021-08-06 22:19:36 +00:00
)
if stats['closed_trade_count'] > 0:
markdown_msg += (f"\n*Avg. Duration:* `{avg_duration}`\n"
f"*Best Performing:* `{best_pair}: {best_pair_profit_ratio:.2%}`")
2021-06-13 18:39:25 +00:00
self._send_msg(markdown_msg, reload_able=True, callback_path="update_profit",
query=update.callback_query)
2018-02-13 03:45:59 +00:00
@authorized_only
def _stats(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /stats
Show stats of recent trades
"""
stats = self._rpc._rpc_stats()
reason_map = {
'roi': 'ROI',
'stop_loss': 'Stoploss',
'trailing_stop_loss': 'Trail. Stop',
'stoploss_on_exchange': 'Stoploss',
'sell_signal': 'Sell Signal',
'force_sell': 'Forcesell',
'emergency_sell': 'Emergency Sell',
}
2020-12-10 06:39:50 +00:00
sell_reasons_tabulate = [
[
reason_map.get(reason, reason),
sum(count.values()),
2020-12-07 13:54:39 +00:00
count['wins'],
count['losses']
2020-12-10 06:39:50 +00:00
] for reason, count in stats['sell_reasons'].items()
]
2021-11-14 09:20:04 +00:00
sell_reasons_msg = 'No trades yet.'
for reason in chunks(sell_reasons_tabulate, 25):
sell_reasons_msg = tabulate(
reason,
headers=['Sell Reason', 'Sells', 'Wins', 'Losses']
)
if len(sell_reasons_tabulate) > 25:
self._send_msg(sell_reasons_msg, ParseMode.MARKDOWN)
sell_reasons_msg = ''
2020-12-07 13:54:39 +00:00
durations = stats['durations']
2021-08-06 22:19:36 +00:00
duration_msg = tabulate(
[
['Wins', str(timedelta(seconds=durations['wins']))
if durations['wins'] is not None else 'N/A'],
2021-08-06 22:19:36 +00:00
['Losses', str(timedelta(seconds=durations['losses']))
if durations['losses'] is not None else 'N/A']
2020-12-07 13:54:39 +00:00
],
headers=['', 'Avg. Duration']
)
msg = (f"""```\n{sell_reasons_msg}```\n```\n{duration_msg}```""")
self._send_msg(msg, ParseMode.MARKDOWN)
2018-02-13 03:45:59 +00:00
@authorized_only
def _balance(self, update: Update, context: CallbackContext) -> None:
""" Handler for /balance """
2018-06-08 02:52:50 +00:00
try:
result = self._rpc._rpc_balance(self._config['stake_currency'],
self._config.get('fiat_display_currency', ''))
balance_dust_level = self._config['telegram'].get('balance_dust_level', 0.0)
if not balance_dust_level:
balance_dust_level = DUST_PER_COIN.get(self._config['stake_currency'], 1.0)
2018-06-08 02:52:50 +00:00
output = ''
if self._config['dry_run']:
output += "*Warning:* Simulated balances in Dry Mode.\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'
2021-07-03 19:44:48 +00:00
total_dust_balance = 0
total_dust_currencies = 0
for curr in result['currencies']:
curr_output = ''
if curr['est_stake'] > balance_dust_level:
if curr['is_position']:
curr_output = (
f"*{curr['currency']}:*\n"
f"\t`{curr['side']}: {curr['position']:.8f}`\n"
f"\t`Leverage: {curr['leverage']:.1f}`\n"
f"\t`Est. {curr['stake']}: "
f"{round_coin_value(curr['est_stake'], curr['stake'], False)}`\n")
else:
curr_output = (
f"*{curr['currency']}:*\n"
f"\t`Available: {curr['free']:.8f}`\n"
f"\t`Balance: {curr['balance']:.8f}`\n"
f"\t`Pending: {curr['used']:.8f}`\n"
f"\t`Est. {curr['stake']}: "
f"{round_coin_value(curr['est_stake'], curr['stake'], False)}`\n")
2021-07-03 19:44:48 +00:00
elif curr['est_stake'] <= balance_dust_level:
total_dust_balance += curr['est_stake']
total_dust_currencies += 1
2019-04-08 17:59:30 +00:00
2021-06-25 13:45:49 +00:00
# Handle overflowing message length
2019-04-10 04:59:10 +00:00
if len(output + curr_output) >= MAX_TELEGRAM_MESSAGE_LENGTH:
self._send_msg(output)
2019-04-08 17:59:30 +00:00
output = curr_output
else:
output += curr_output
2018-06-08 02:52:50 +00:00
2021-07-03 19:44:48 +00:00
if total_dust_balance > 0:
output += (
2021-07-03 19:56:05 +00:00
f"*{total_dust_currencies} Other "
2021-07-03 20:08:29 +00:00
f"{plural(total_dust_currencies, 'Currency', 'Currencies')} "
f"(< {balance_dust_level} {result['stake']}):*\n"
2021-07-03 19:44:48 +00:00
f"\t`Est. {result['stake']}: "
f"{round_coin_value(total_dust_balance, result['stake'], False)}`\n")
tc = result['trade_count'] > 0
stake_improve = f" `({result['starting_capital_ratio']:.2%})`" if tc else ''
fiat_val = f" `({result['starting_capital_fiat_ratio']:.2%})`" if tc else ''
2021-07-03 19:44:48 +00:00
2020-06-06 15:28:00 +00:00
output += ("\n*Estimated Value*:\n"
f"\t`{result['stake']}: "
f"{round_coin_value(result['total'], result['stake'], False)}`"
f"{stake_improve}\n"
f"\t`{result['symbol']}: "
f"{round_coin_value(result['value'], result['symbol'], False)}`"
f"{fiat_val}\n")
2021-06-13 18:39:25 +00:00
self._send_msg(output, reload_able=True, callback_path="update_balance",
query=update.callback_query)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _start(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /start.
Starts TradeThread
:param bot: telegram bot
:param update: message update
:return: None
"""
msg = self._rpc._rpc_start()
self._send_msg('Status: `{status}`'.format(**msg))
2018-02-13 03:45:59 +00:00
@authorized_only
def _stop(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /stop.
Stops TradeThread
:param bot: telegram bot
:param update: message update
:return: None
"""
msg = self._rpc._rpc_stop()
self._send_msg('Status: `{status}`'.format(**msg))
2018-02-13 03:45:59 +00:00
@authorized_only
def _reload_config(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /reload_config.
Triggers a config file reload
:param bot: telegram bot
:param update: message update
:return: None
"""
msg = self._rpc._rpc_reload_config()
self._send_msg('Status: `{status}`'.format(**msg))
@authorized_only
def _stopbuy(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /stop_buy.
Sets max_open_trades to 0 and gracefully sells all open trades
:param bot: telegram bot
:param update: message update
:return: None
"""
msg = self._rpc._rpc_stopbuy()
self._send_msg('Status: `{status}`'.format(**msg))
2018-02-13 03:45:59 +00:00
@authorized_only
2022-01-26 19:17:00 +00:00
def _forceexit(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /forcesell <id>.
Sells the given trade at current price
:param bot: telegram bot
:param update: message update
:return: None
"""
2020-12-01 18:55:20 +00:00
trade_id = context.args[0] if context.args and len(context.args) > 0 else None
if not trade_id:
self._send_msg("You must specify a trade-id or 'all'.")
return
2018-06-08 02:52:50 +00:00
try:
2022-01-26 19:17:00 +00:00
msg = self._rpc._rpc_forceexit(trade_id)
self._send_msg('Forcesell Result: `{result}`'.format(**msg))
2019-04-30 04:23:14 +00:00
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
2022-01-26 18:53:46 +00:00
def _forceenter_action(self, pair, price: Optional[float], order_side: SignalDirection):
if pair != 'cancel':
try:
2022-02-23 05:27:56 +00:00
self._rpc._rpc_force_entry(pair, price, order_side=order_side)
except RPCException as e:
self._send_msg(str(e))
2022-01-27 05:40:41 +00:00
def _forceenter_inline(self, update: Update, _: CallbackContext) -> None:
2021-04-15 12:31:20 +00:00
if update.callback_query:
query = update.callback_query
2022-01-27 05:40:41 +00:00
if query.data and '_||_' in query.data:
pair, side = query.data.split('_||_')
order_side = SignalDirection(side)
query.answer()
query.edit_message_text(text=f"Manually entering {order_side} for {pair}")
self._forceenter_action(pair, None, order_side)
@staticmethod
def _layout_inline_keyboard(buttons: List[InlineKeyboardButton],
cols=3) -> List[List[InlineKeyboardButton]]:
return [buttons[i:i + cols] for i in range(0, len(buttons), cols)]
2018-10-09 17:25:43 +00:00
@authorized_only
2022-01-27 05:31:45 +00:00
def _forceenter(
2022-01-26 18:53:46 +00:00
self, update: Update, context: CallbackContext, order_side: SignalDirection) -> None:
2018-10-09 17:25:43 +00:00
"""
2022-01-27 05:31:45 +00:00
Handler for /forcelong <asset> <price> and `/forceshort <asset> <price>
2018-10-09 17:25:43 +00:00
Buys a pair trade at the given or current price
:param bot: telegram bot
:param update: message update
:return: None
"""
2020-12-01 18:55:20 +00:00
if context.args:
pair = context.args[0]
price = float(context.args[1]) if len(context.args) > 1 else None
2022-01-26 18:53:46 +00:00
self._forceenter_action(pair, price, order_side)
else:
whitelist = self._rpc._rpc_whitelist()['whitelist']
2022-01-26 18:53:46 +00:00
pair_buttons = [
InlineKeyboardButton(text=pair, callback_data=f"{pair}_||_{order_side}")
2022-02-23 05:27:56 +00:00
for pair in sorted(whitelist)
2022-01-26 18:53:46 +00:00
]
buttons_aligned = self._layout_inline_keyboard(pair_buttons)
buttons_aligned.append([InlineKeyboardButton(text='Cancel', callback_data='cancel')])
self._send_msg(msg="Which pair?",
2022-02-23 05:27:56 +00:00
keyboard=buttons_aligned,
2022-01-26 18:53:46 +00:00
query=update.callback_query)
2018-10-09 17:25:43 +00:00
@authorized_only
def _trades(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /trades <n>
Returns last n recent trades.
:param bot: telegram bot
:param update: message update
:return: None
"""
stake_cur = self._config['stake_currency']
try:
2020-12-01 18:55:20 +00:00
nrecent = int(context.args[0]) if context.args else 10
except (TypeError, ValueError, IndexError):
nrecent = 10
try:
trades = self._rpc._rpc_trade_history(
nrecent
)
trades_tab = tabulate(
2021-03-08 21:21:56 +00:00
[[arrow.get(trade['close_date']).humanize(),
trade['pair'] + " (#" + str(trade['trade_id']) + ")",
f"{(trade['close_profit']):.2%} ({trade['close_profit_abs']})"]
for trade in trades['trades']],
headers=[
2021-03-08 21:21:56 +00:00
'Close Date',
'Pair (ID)',
f'Profit ({stake_cur})',
],
tablefmt='simple')
message = (f"<b>{min(trades['trades_count'], nrecent)} recent trades</b>:\n"
+ (f"<pre>{trades_tab}</pre>" if trades['trades_count'] > 0 else ''))
self._send_msg(message, parse_mode=ParseMode.HTML)
except RPCException as e:
self._send_msg(str(e))
2020-07-20 04:08:18 +00:00
@authorized_only
2020-08-04 12:49:59 +00:00
def _delete_trade(self, update: Update, context: CallbackContext) -> None:
2020-07-20 04:08:18 +00:00
"""
Handler for /delete <id>.
Delete the given trade
:param bot: telegram bot
:param update: message update
:return: None
"""
try:
2020-12-01 18:55:20 +00:00
if not context.args or len(context.args) == 0:
raise RPCException("Trade-id not set.")
trade_id = int(context.args[0])
msg = self._rpc._rpc_delete(trade_id)
2020-08-04 17:56:49 +00:00
self._send_msg((
2020-08-04 17:57:28 +00:00
'`{result_msg}`\n'
2020-08-04 17:56:49 +00:00
'Please make sure to take care of this asset on the exchange manually.'
).format(**msg))
2020-07-20 04:08:18 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _performance(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /performance.
Shows a performance statistic from finished trades
:param bot: telegram bot
:param update: message update
:return: None
"""
2018-06-08 02:52:50 +00:00
try:
trades = self._rpc._rpc_performance()
output = "<b>Performance:</b>\n"
for i, trade in enumerate(trades):
stat_line = (
f"{i+1}.\t <code>{trade['pair']}\t"
f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
f"({trade['profit_ratio']:.2%}) "
f"({trade['count']})</code>\n")
if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
self._send_msg(output, parse_mode=ParseMode.HTML)
output = stat_line
else:
output += stat_line
self._send_msg(output, parse_mode=ParseMode.HTML,
2021-06-13 18:39:25 +00:00
reload_able=True, callback_path="update_performance",
query=update.callback_query)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
2021-11-21 08:51:16 +00:00
def _enter_tag_performance(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /buys PAIR .
Shows a performance statistic from finished trades
:param bot: telegram bot
:param update: message update
:return: None
"""
try:
pair = None
if context.args and isinstance(context.args[0], str):
pair = context.args[0]
2021-11-21 08:51:16 +00:00
trades = self._rpc._rpc_enter_tag_performance(pair)
output = "<b>Buy Tag Performance:</b>\n"
for i, trade in enumerate(trades):
stat_line = (
2021-11-21 08:24:20 +00:00
f"{i+1}.\t <code>{trade['enter_tag']}\t"
f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
f"({trade['profit_ratio']:.2%}) "
f"({trade['count']})</code>\n")
if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
self._send_msg(output, parse_mode=ParseMode.HTML)
output = stat_line
else:
output += stat_line
self._send_msg(output, parse_mode=ParseMode.HTML,
2021-11-21 08:51:16 +00:00
reload_able=True, callback_path="update_enter_tag_performance",
query=update.callback_query)
except RPCException as e:
self._send_msg(str(e))
@authorized_only
def _sell_reason_performance(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /sells.
Shows a performance statistic from finished trades
:param bot: telegram bot
:param update: message update
:return: None
"""
try:
pair = None
if context.args and isinstance(context.args[0], str):
pair = context.args[0]
trades = self._rpc._rpc_sell_reason_performance(pair)
output = "<b>Sell Reason Performance:</b>\n"
for i, trade in enumerate(trades):
stat_line = (
f"{i+1}.\t <code>{trade['sell_reason']}\t"
f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
f"({trade['profit_ratio']:.2%}) "
f"({trade['count']})</code>\n")
if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
self._send_msg(output, parse_mode=ParseMode.HTML)
output = stat_line
else:
output += stat_line
self._send_msg(output, parse_mode=ParseMode.HTML,
reload_able=True, callback_path="update_sell_reason_performance",
query=update.callback_query)
except RPCException as e:
self._send_msg(str(e))
@authorized_only
def _mix_tag_performance(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /mix_tags.
Shows a performance statistic from finished trades
:param bot: telegram bot
:param update: message update
:return: None
"""
try:
pair = None
if context.args and isinstance(context.args[0], str):
pair = context.args[0]
trades = self._rpc._rpc_mix_tag_performance(pair)
output = "<b>Mix Tag Performance:</b>\n"
for i, trade in enumerate(trades):
stat_line = (
f"{i+1}.\t <code>{trade['mix_tag']}\t"
f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
f"({trade['profit']:.2%}) "
f"({trade['count']})</code>\n")
if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
self._send_msg(output, parse_mode=ParseMode.HTML)
output = stat_line
else:
output += stat_line
self._send_msg(output, parse_mode=ParseMode.HTML,
reload_able=True, callback_path="update_mix_tag_performance",
query=update.callback_query)
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _count(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /count.
Returns the number of trades running
:param bot: telegram bot
:param update: message update
:return: None
"""
2018-06-08 02:52:50 +00:00
try:
counts = self._rpc._rpc_count()
message = tabulate({k: [v] for k, v in counts.items()},
headers=['current', 'max', 'total stake'],
tablefmt='simple')
2018-06-08 02:52:50 +00:00
message = "<pre>{}</pre>".format(message)
logger.debug(message)
self._send_msg(message, parse_mode=ParseMode.HTML,
2021-06-13 18:39:25 +00:00
reload_able=True, callback_path="update_count",
query=update.callback_query)
2018-06-08 02:52:50 +00:00
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
2020-10-17 13:15:35 +00:00
@authorized_only
def _locks(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /locks.
2020-10-20 17:39:38 +00:00
Returns the currently active locks
2020-10-17 13:15:35 +00:00
"""
rpc_locks = self._rpc._rpc_locks()
if not rpc_locks['locks']:
self._send_msg('No active locks.', parse_mode=ParseMode.HTML)
for locks in chunks(rpc_locks['locks'], 25):
2020-10-17 13:15:35 +00:00
message = tabulate([[
lock['id'],
2020-10-17 13:15:35 +00:00
lock['pair'],
2020-10-17 18:32:23 +00:00
lock['lock_end_time'],
lock['reason']] for lock in locks],
headers=['ID', 'Pair', 'Until', 'Reason'],
2020-10-17 13:15:35 +00:00
tablefmt='simple')
message = f"<pre>{escape(message)}</pre>"
2020-10-17 13:15:35 +00:00
logger.debug(message)
self._send_msg(message, parse_mode=ParseMode.HTML)
2021-03-01 19:08:49 +00:00
@authorized_only
def _delete_locks(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /delete_locks.
Returns the currently active locks
"""
2021-03-02 05:59:58 +00:00
arg = context.args[0] if context.args and len(context.args) > 0 else None
lockid = None
pair = None
if arg:
try:
lockid = int(arg)
except ValueError:
pair = arg
self._rpc._rpc_delete_lock(lockid=lockid, pair=pair)
self._locks(update, context)
2020-10-17 13:15:35 +00:00
2018-11-10 19:15:06 +00:00
@authorized_only
def _whitelist(self, update: Update, context: CallbackContext) -> None:
2018-11-10 19:15:06 +00:00
"""
Handler for /whitelist
Shows the currently active whitelist
"""
try:
whitelist = self._rpc._rpc_whitelist()
2018-12-03 19:31:25 +00:00
message = f"Using whitelist `{whitelist['method']}` with {whitelist['length']} pairs\n"
2018-11-10 19:15:06 +00:00
message += f"`{', '.join(whitelist['whitelist'])}`"
logger.debug(message)
self._send_msg(message)
except RPCException as e:
self._send_msg(str(e))
2018-11-10 19:15:06 +00:00
2019-03-24 15:08:48 +00:00
@authorized_only
def _blacklist(self, update: Update, context: CallbackContext) -> None:
2019-03-24 15:08:48 +00:00
"""
Handler for /blacklist
Shows the currently active blacklist
"""
self.send_blacklist_msg(self._rpc._rpc_blacklist(context.args))
2019-03-24 15:08:48 +00:00
2021-12-11 15:09:20 +00:00
def send_blacklist_msg(self, blacklist: Dict):
errmsgs = []
for pair, error in blacklist['errors'].items():
errmsgs.append(f"Error adding `{pair}` to blacklist: `{error['error_msg']}`")
if errmsgs:
self._send_msg('\n'.join(errmsgs))
2019-03-24 15:28:14 +00:00
message = f"Blacklist contains {blacklist['length']} pairs\n"
message += f"`{', '.join(blacklist['blacklist'])}`"
2019-03-24 15:08:48 +00:00
logger.debug(message)
self._send_msg(message)
2019-03-24 15:08:48 +00:00
2021-12-11 15:09:20 +00:00
@authorized_only
def _blacklist_delete(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /bl_delete
Deletes pair(s) from current blacklist
"""
2021-12-11 19:08:03 +00:00
self.send_blacklist_msg(self._rpc._rpc_blacklist_delete(context.args or []))
2019-03-24 15:08:48 +00:00
@authorized_only
def _logs(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /logs
Shows the latest logs
"""
try:
try:
2020-12-01 18:55:20 +00:00
limit = int(context.args[0]) if context.args else 10
except (TypeError, ValueError, IndexError):
limit = 10
2020-12-06 18:57:48 +00:00
logs = RPC._rpc_get_logs(limit)['logs']
2020-08-15 06:31:36 +00:00
msgs = ''
msg_template = "*{}* {}: {} \\- `{}`"
for logrec in logs:
msg = msg_template.format(escape_markdown(logrec[0], version=2),
escape_markdown(logrec[2], version=2),
escape_markdown(logrec[3], version=2),
escape_markdown(logrec[4], version=2))
2020-08-15 06:31:36 +00:00
if len(msgs + msg) + 10 >= MAX_TELEGRAM_MESSAGE_LENGTH:
# Send message immediately if it would become too long
self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
2020-08-15 06:31:36 +00:00
msgs = msg + '\n'
else:
# Append message to messages to send
2020-08-15 06:31:36 +00:00
msgs += msg + '\n'
2020-08-15 06:31:36 +00:00
if msgs:
self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
except RPCException as e:
self._send_msg(str(e))
2019-03-24 21:36:33 +00:00
@authorized_only
def _edge(self, update: Update, context: CallbackContext) -> None:
2019-03-24 21:36:33 +00:00
"""
Handler for /edge
2019-03-27 20:22:25 +00:00
Shows information related to Edge
2019-03-24 21:36:33 +00:00
"""
try:
edge_pairs = self._rpc._rpc_edge()
if not edge_pairs:
message = '<b>Edge only validated following pairs:</b>'
self._send_msg(message, parse_mode=ParseMode.HTML)
for chunk in chunks(edge_pairs, 25):
edge_pairs_tab = tabulate(chunk, headers='keys', tablefmt='simple')
message = (f'<b>Edge only validated following pairs:</b>\n'
f'<pre>{edge_pairs_tab}</pre>')
self._send_msg(message, parse_mode=ParseMode.HTML)
2019-03-24 21:36:33 +00:00
except RPCException as e:
self._send_msg(str(e))
2019-03-24 21:36:33 +00:00
2018-02-13 03:45:59 +00:00
@authorized_only
def _help(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /help.
Show commands of the bot
:param bot: telegram bot
:param update: message update
:return: None
"""
2022-01-27 05:40:41 +00:00
forceenter_text = ("*/forcelong <pair> [<rate>]:* `Instantly buys the given pair. "
"Optionally takes a rate at which to buy "
"(only applies to limit orders).` \n"
)
2022-01-27 05:31:45 +00:00
if self._rpc._freqtrade.trading_mode != TradingMode.SPOT:
2022-01-27 05:40:41 +00:00
forceenter_text += ("*/forceshort <pair> [<rate>]:* `Instantly shorts the given pair. "
"Optionally takes a rate at which to sell "
"(only applies to limit orders).` \n")
2021-11-13 07:46:06 +00:00
message = (
"_BotControl_\n"
"------------\n"
"*/start:* `Starts the trader`\n"
"*/stop:* Stops the trader\n"
"*/stopbuy:* `Stops buying, but handles open trades gracefully` \n"
2022-01-26 19:17:00 +00:00
"*/forceexit <trade_id>|all:* `Instantly exits the given trade or all trades, "
2021-11-13 07:46:06 +00:00
"regardless of profit`\n"
2022-01-27 05:40:41 +00:00
f"{forceenter_text if self._config.get('forcebuy_enable', False) else ''}"
2021-11-13 07:46:06 +00:00
"*/delete <trade_id>:* `Instantly delete the given trade in the database`\n"
"*/whitelist:* `Show current whitelist` \n"
"*/blacklist [pair]:* `Show current blacklist, or adds one or more pairs "
"to the blacklist.` \n"
2021-12-11 19:08:03 +00:00
"*/blacklist_delete [pairs]| /bl_delete [pairs]:* "
"`Delete pair / pattern from blacklist. Will reset on reload_conf.` \n"
2021-11-13 07:46:06 +00:00
"*/reload_config:* `Reload configuration file` \n"
"*/unlock <pair|id>:* `Unlock this Pair (or this lock id if it's numeric)`\n"
"_Current state_\n"
"------------\n"
"*/show_config:* `Show running configuration` \n"
"*/locks:* `Show currently locked pairs`\n"
"*/balance:* `Show account balance per currency`\n"
"*/logs [limit]:* `Show latest logs - defaults to 10` \n"
"*/count:* `Show number of active trades compared to allowed number of trades`\n"
"*/edge:* `Shows validated pairs by Edge if it is enabled` \n"
"*/health* `Show latest process timestamp - defaults to 1970-01-01 00:00:00` \n"
2021-11-13 07:46:06 +00:00
"_Statistics_\n"
"------------\n"
"*/status <trade_id>|[table]:* `Lists all open trades`\n"
" *<trade_id> :* `Lists one or more specific trades.`\n"
" `Separate multiple <trade_id> with a blank space.`\n"
" *table :* `will display trades in a table`\n"
" `pending buy orders are marked with an asterisk (*)`\n"
" `pending sell orders are marked with a double asterisk (**)`\n"
2021-11-21 08:51:16 +00:00
"*/buys <pair|none>:* `Shows the enter_tag performance`\n"
2021-11-13 07:46:06 +00:00
"*/sells <pair|none>:* `Shows the sell reason performance`\n"
"*/mix_tags <pair|none>:* `Shows combined buy tag + sell reason performance`\n"
"*/trades [limit]:* `Lists last closed trades (limited to 10 by default)`\n"
"*/profit [<n>]:* `Lists cumulative profit from all finished trades, "
"over the last n days`\n"
"*/performance:* `Show performance of each finished trade grouped by pair`\n"
"*/daily <n>:* `Shows profit or loss per day, over the last n days`\n"
"*/weekly <n>:* `Shows statistics per week, over the last n weeks`\n"
"*/monthly <n>:* `Shows statistics per month, over the last n months`\n"
"*/stats:* `Shows Wins / losses by Sell reason as well as "
"Avg. holding durationsfor buys and sells.`\n"
"*/help:* `This help message`\n"
"*/version:* `Show version`"
)
self._send_msg(message, parse_mode=ParseMode.MARKDOWN)
2018-02-13 03:45:59 +00:00
@authorized_only
def _health(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /health
Shows the last process timestamp
"""
try:
health = self._rpc._health()
message = f"Last process: `{health['last_process_loc']}`"
self._send_msg(message)
except RPCException as e:
self._send_msg(str(e))
2018-02-13 03:45:59 +00:00
@authorized_only
def _version(self, update: Update, context: CallbackContext) -> None:
2018-02-13 03:45:59 +00:00
"""
Handler for /version.
Show version information
:param bot: telegram bot
:param update: message update
:return: None
"""
strategy_version = self._rpc._freqtrade.strategy.version()
version_string = f'*Version:* `{__version__}`'
if strategy_version is not None:
version_string += f', *Strategy version: * `{strategy_version}`'
self._send_msg(version_string)
2018-02-13 03:45:59 +00:00
2019-11-17 14:03:45 +00:00
@authorized_only
def _show_config(self, update: Update, context: CallbackContext) -> None:
"""
Handler for /show_config.
Show config information information
:param bot: telegram bot
:param update: message update
:return: None
"""
val = RPC._rpc_show_config(self._config, self._rpc._freqtrade.state)
if val['trailing_stop']:
sl_info = (
f"*Initial Stoploss:* `{val['stoploss']}`\n"
f"*Trailing stop positive:* `{val['trailing_stop_positive']}`\n"
f"*Trailing stop offset:* `{val['trailing_stop_positive_offset']}`\n"
f"*Only trail above offset:* `{val['trailing_only_offset_is_reached']}`\n"
)
else:
sl_info = f"*Stoploss:* `{val['stoploss']}`\n"
2022-01-20 01:03:26 +00:00
if val['position_adjustment_enable']:
pa_info = (
f"*Position adjustment:* On\n"
f"*Max enter position adjustment:* `{val['max_entry_position_adjustment']}`\n"
2022-01-20 01:03:26 +00:00
)
else:
2022-01-21 00:35:22 +00:00
pa_info = "*Position adjustment:* Off\n"
2022-01-20 01:03:26 +00:00
2019-11-17 14:03:45 +00:00
self._send_msg(
f"*Mode:* `{'Dry-run' if val['dry_run'] else 'Live'}`\n"
f"*Exchange:* `{val['exchange']}`\n"
2022-01-26 18:49:15 +00:00
f"*Market: * `{val['trading_mode']}`\n"
2019-11-17 14:03:45 +00:00
f"*Stake per trade:* `{val['stake_amount']} {val['stake_currency']}`\n"
2020-05-05 19:21:05 +00:00
f"*Max open Trades:* `{val['max_open_trades']}`\n"
2019-11-17 14:03:45 +00:00
f"*Minimum ROI:* `{val['minimal_roi']}`\n"
2020-06-07 08:09:39 +00:00
f"*Ask strategy:* ```\n{json.dumps(val['ask_strategy'])}```\n"
f"*Bid strategy:* ```\n{json.dumps(val['bid_strategy'])}```\n"
f"{sl_info}"
2022-01-20 01:03:26 +00:00
f"{pa_info}"
f"*Timeframe:* `{val['timeframe']}`\n"
2020-05-05 19:28:59 +00:00
f"*Strategy:* `{val['strategy']}`\n"
2020-05-05 19:21:05 +00:00
f"*Current state:* `{val['state']}`"
2019-11-17 14:03:45 +00:00
)
2021-06-13 18:21:43 +00:00
def _update_msg(self, query: CallbackQuery, msg: str, callback_path: str = "",
reload_able: bool = False, parse_mode: str = ParseMode.MARKDOWN) -> None:
if reload_able:
reply_markup = InlineKeyboardMarkup([
[InlineKeyboardButton("Refresh", callback_data=callback_path)],
2021-08-06 22:19:36 +00:00
])
else:
reply_markup = InlineKeyboardMarkup([[]])
msg += "\nUpdated: {}".format(datetime.now().ctime())
2021-06-13 18:21:43 +00:00
if not query.message:
return
chat_id = query.message.chat_id
message_id = query.message.message_id
try:
2021-06-19 07:31:34 +00:00
self._updater.bot.edit_message_text(
chat_id=chat_id,
message_id=message_id,
text=msg,
parse_mode=parse_mode,
reply_markup=reply_markup
)
2021-06-19 07:31:34 +00:00
except BadRequest as e:
if 'not modified' in e.message.lower():
pass
else:
logger.warning('TelegramError: %s', e.message)
except TelegramError as telegram_err:
logger.warning('TelegramError: %s! Giving up on that message.', telegram_err.message)
2020-12-01 18:55:20 +00:00
def _send_msg(self, msg: str, parse_mode: str = ParseMode.MARKDOWN,
disable_notification: bool = False,
2021-06-17 17:50:49 +00:00
keyboard: List[List[InlineKeyboardButton]] = None,
callback_path: str = "",
reload_able: bool = False,
query: Optional[CallbackQuery] = None) -> None:
2018-02-13 03:45:59 +00:00
"""
Send given markdown message
:param msg: message
:param bot: alternative bot
:param parse_mode: telegram parse mode
:return: None
"""
2021-06-17 17:50:49 +00:00
reply_markup: Union[InlineKeyboardMarkup, ReplyKeyboardMarkup]
if query:
self._update_msg(query=query, msg=msg, parse_mode=parse_mode,
callback_path=callback_path, reload_able=reload_able)
return
if reload_able and self._config['telegram'].get('reload', True):
reply_markup = InlineKeyboardMarkup([
[InlineKeyboardButton("Refresh", callback_data=callback_path)]])
else:
if keyboard is not None:
reply_markup = InlineKeyboardMarkup(keyboard, resize_keyboard=True)
else:
reply_markup = ReplyKeyboardMarkup(self._keyboard, resize_keyboard=True)
2017-11-17 18:47:29 +00:00
try:
2018-02-13 03:45:59 +00:00
try:
self._updater.bot.send_message(
2018-02-13 03:45:59 +00:00
self._config['telegram']['chat_id'],
text=msg,
parse_mode=parse_mode,
reply_markup=reply_markup,
disable_notification=disable_notification,
2018-02-13 03:45:59 +00:00
)
except NetworkError as network_err:
# Sometimes the telegram server resets the current connection,
# if this is the case we send the message again.
2018-03-25 19:37:14 +00:00
logger.warning(
'Telegram NetworkError: %s! Trying one more time.',
2018-02-13 03:45:59 +00:00
network_err.message
)
self._updater.bot.send_message(
2018-02-13 03:45:59 +00:00
self._config['telegram']['chat_id'],
text=msg,
parse_mode=parse_mode,
reply_markup=reply_markup,
disable_notification=disable_notification,
2018-02-13 03:45:59 +00:00
)
except TelegramError as telegram_err:
2018-03-25 19:37:14 +00:00
logger.warning(
'TelegramError: %s! Giving up on that message.',
2018-02-13 03:45:59 +00:00
telegram_err.message
2017-12-16 02:39:47 +00:00
)