def get_command_profitability(): has_real_trader, has_simulated_trader, \ real_global_profitability, simulated_global_profitability, \ real_percent_profitability, simulated_percent_profitability, \ real_no_trade_profitability, simulated_no_trade_profitability, \ market_average_profitability = get_global_profitability() profitability_string = "" if has_real_trader: real_profitability_pretty = PrettyPrinter.portfolio_profitability_pretty_print( real_global_profitability, None, get_reference_market()) profitability_string = f"{REAL_TRADER_STR}Global profitability : {real_profitability_pretty} " \ f"({PrettyPrinter.get_min_string_from_number(real_percent_profitability, 2)}%), " \ f"market: {PrettyPrinter.get_min_string_from_number(market_average_profitability, 2)}%, " \ f"initial portfolio: {PrettyPrinter.get_min_string_from_number(real_no_trade_profitability, 2)}%{EOL}" if has_simulated_trader: simulated_profitability_pretty = \ PrettyPrinter.portfolio_profitability_pretty_print(simulated_global_profitability, None, get_reference_market()) profitability_string += f"{SIMULATOR_TRADER_STR}Global profitability : {simulated_profitability_pretty} " \ f"({PrettyPrinter.get_min_string_from_number(simulated_percent_profitability, 2)}%), " \ f"market: {PrettyPrinter.get_min_string_from_number(market_average_profitability, 2)}%, " \ f"initial portfolio: {PrettyPrinter.get_min_string_from_number(simulated_no_trade_profitability, 2)}%" if not profitability_string: profitability_string = NO_TRADER_MESSAGE return profitability_string
def get_command_profitability(markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) has_real_trader, has_simulated_trader, \ real_global_profitability, simulated_global_profitability, \ real_percent_profitability, simulated_percent_profitability, \ real_no_trade_profitability, simulated_no_trade_profitability, \ market_average_profitability = get_global_profitability() profitability_string = "" if has_real_trader: real_profitability_pretty = PrettyPrinter.portfolio_profitability_pretty_print(real_global_profitability, None, get_reference_market()) profitability_string = \ f"{b}{REAL_TRADER_STR}{b}Global profitability : {c}{real_profitability_pretty}" \ f"({PrettyPrinter.get_min_string_from_number(real_percent_profitability, 2)}%){c}, market: {c}" \ f"{PrettyPrinter.get_min_string_from_number(market_average_profitability, 2)}%{c}, initial portfolio:" \ f" {c}{PrettyPrinter.get_min_string_from_number(real_no_trade_profitability, 2)}%{c}{EOL}" if has_simulated_trader: simulated_profitability_pretty = \ PrettyPrinter.portfolio_profitability_pretty_print(simulated_global_profitability, None, get_reference_market()) profitability_string += \ f"{b}{SIMULATOR_TRADER_STR}{b}Global profitability : {c}{simulated_profitability_pretty}" \ f"({PrettyPrinter.get_min_string_from_number(simulated_percent_profitability, 2)}%){c}, " \ f"market: {c}{PrettyPrinter.get_min_string_from_number(market_average_profitability, 2)}%{c}, " \ f"initial portfolio: {c}" \ f"{PrettyPrinter.get_min_string_from_number(simulated_no_trade_profitability, 2)}%{c}" if not profitability_string: profitability_string = NO_TRADER_MESSAGE return profitability_string
def get_command_open_orders(): has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders( ) portfolio_real_open_orders, portfolio_simulated_open_orders = get_open_orders( ) orders_string = "" if has_real_trader: orders_string += f"{REAL_TRADER_STR}Open orders :{EOL}" for orders in portfolio_real_open_orders: for order in orders: orders_string += PrettyPrinter.open_order_pretty_printer( order) + EOL if has_simulated_trader: orders_string += EOL + f"{SIMULATOR_TRADER_STR}Open orders :{EOL}" for orders in portfolio_simulated_open_orders: for order in orders: orders_string += PrettyPrinter.open_order_pretty_printer( order) + EOL if not orders_string: orders_string = NO_TRADER_MESSAGE return orders_string
def command_portfolio(_, update): has_real_trader, has_simulated_trader, \ portfolio_real_current_value, portfolio_simulated_current_value = get_portfolio_current_value() reference_market = get_reference_market() real_global_portfolio, simulated_global_portfolio = get_global_portfolio_currencies_amounts( ) portfolios_string = "" if has_real_trader: portfolios_string += "{0}Portfolio value : {1} {2}{3}".format( REAL_TRADER_STR, PrettyPrinter.get_min_string_from_number( portfolio_real_current_value), reference_market, TelegramApp.EOL) portfolios_string += "{0}Portfolio : {2}{1}{2}{2}".format( REAL_TRADER_STR, PrettyPrinter.global_portfolio_pretty_print( real_global_portfolio), TelegramApp.EOL) if has_simulated_trader: portfolios_string += "{0}Portfolio value : {1} {2}{3}".format( SIMULATOR_TRADER_STR, PrettyPrinter.get_min_string_from_number( portfolio_simulated_current_value), reference_market, TelegramApp.EOL) portfolios_string += "{0}Portfolio : {2}{1}".format( SIMULATOR_TRADER_STR, PrettyPrinter.global_portfolio_pretty_print( simulated_global_portfolio), TelegramApp.EOL) if not portfolios_string: portfolios_string = TelegramApp.NO_TRADER_MESSAGE update.message.reply_text(portfolios_string)
def command_trades_history(_, update): has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders( ) real_trades_history, simulated_trades_history = get_trades_history() trades_history_string = "" if has_real_trader: trades_history_string += "{0}Trades :{1}".format( REAL_TRADER_STR, TelegramApp.EOL) for trades in real_trades_history: for trade in trades: trades_history_string += PrettyPrinter.trade_pretty_printer( trade) + TelegramApp.EOL if has_simulated_trader: for trades in simulated_trades_history: trades_history_string += TelegramApp.EOL + "{0}Trades :{1}".format( SIMULATOR_TRADER_STR, TelegramApp.EOL) for trade in trades: trades_history_string += PrettyPrinter.trade_pretty_printer( trade) + TelegramApp.EOL if not trades_history_string: trades_history_string = TelegramApp.NO_TRADER_MESSAGE update.message.reply_text(trades_history_string)
def command_open_orders(_, update): has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders( ) portfolio_real_open_orders, portfolio_simulated_open_orders = get_open_orders( ) orders_string = "" if has_real_trader: orders_string += "{0}Open orders :{1}".format( REAL_TRADER_STR, TelegramApp.EOL) for orders in portfolio_real_open_orders: for order in orders: orders_string += PrettyPrinter.open_order_pretty_printer( order) + TelegramApp.EOL if has_simulated_trader: orders_string += TelegramApp.EOL + "{0}Open orders :{1}".format( SIMULATOR_TRADER_STR, TelegramApp.EOL) for orders in portfolio_simulated_open_orders: for order in orders: orders_string += PrettyPrinter.open_order_pretty_printer( order) + TelegramApp.EOL if not orders_string: orders_string = TelegramApp.NO_TRADER_MESSAGE update.message.reply_text(orders_string)
def _print_open_orders(open_orders, trader_str, markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) orders_string = f"{b}{trader_str}{b}{c}Open orders :{c}{EOL}" for orders in open_orders: if orders: for order in orders: orders_string += PrettyPrinter.open_order_pretty_printer(order, markdown=markdown) + EOL else: orders_string += f"{c}No open order yet.{c}" return orders_string
def _print_portfolio(current_val, ref_market, portfolio, trader_str, markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) portfolios_string = f"{b}{trader_str}{b}Portfolio value : " \ f"{b}{PrettyPrinter.get_min_string_from_number(current_val)} {ref_market}{b}" \ f"{EOL}" portfolio_str = PrettyPrinter.global_portfolio_pretty_print(portfolio, markdown=markdown) if not portfolio_str: portfolio_str = "Nothing there." portfolios_string += f"{b}{trader_str}{b}Portfolio : {EOL}{c}{portfolio_str}{c}" return portfolios_string
def command_profitability(_, update): real_global_profitability, simulated_global_profitability = get_global_profitability() update.message.reply_text("Real global profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print(real_global_profitability, None, get_reference_market()))) update.message.reply_text("Simulated global profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print(simulated_global_profitability, None, get_reference_market())))
def command_profitability(_, update): real_global_profitability, simulated_global_profitability = get_global_profitability( ) update.message.reply_text("Real global profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print( real_global_profitability, None, get_reference_market()))) update.message.reply_text( "Simulated global profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print( simulated_global_profitability, None, get_reference_market())))
def command_portfolio(_, update): portfolio_real_current_value, portfolio_simulated_current_value = get_portfolio_current_value() reference_market = get_reference_market() real_global_portfolio, simulated_global_portfolio = get_global_portfolio_currencies_amounts() update.message.reply_text("Portfolio real value : {0} {1}".format(portfolio_real_current_value, reference_market)) update.message.reply_text("Global real portfolio : \n{0}" .format(PrettyPrinter.global_portfolio_pretty_print(real_global_portfolio))) update.message.reply_text("Portfolio simulated value : {0} {1}".format(portfolio_simulated_current_value, reference_market)) update.message.reply_text("Global simulated portfolio : \n{0}" .format(PrettyPrinter.global_portfolio_pretty_print(simulated_global_portfolio)))
def notify_state_changed(self, final_eval, crypto_currency_evaluator, symbol, trader, result, matrix): if self.gmail_notification_available(): profitability, profitability_percent, _ = trader.get_trades_manager().get_profitability() self.gmail_notification_factory( "CRYPTO BOT ALERT : {0} / {1}".format(crypto_currency_evaluator.crypto_currency, result), "CRYPTO BOT ALERT : {0} / {1} \n {2} \n Current portfolio " "profitability : {3} " "{4} ({5}%)".format( crypto_currency_evaluator.crypto_currency, result, pprint.pformat(matrix), round(profitability, 2), TradesManager.get_reference_market(self.config), round(profitability_percent, 2))) alert_content = PrettyPrinter.cryptocurrency_alert( crypto_currency_evaluator.crypto_currency, symbol, result, final_eval) if self.twitter_notification_available(): self.tweet_instance = self.twitter_notification_factory(alert_content) if self.telegram_notification_available(): self.telegram_notification_factory(alert_content) return self
def notify_order_close(self, order, cancel=False, cancel_linked_only=False): # Cancel linked orders for linked_order in order.get_linked_orders(): self.cancel_order(linked_order) # If need to cancel the order call the method and no need to update the portfolio (only availability) if cancel: order_closed = None orders_canceled = order.get_linked_orders() + [order] self.cancel_order(order) _, profitability_percent, profitability_diff = self.get_trades_manager( ).get_profitability_without_update() elif cancel_linked_only: order_closed = None orders_canceled = order.get_linked_orders() _, profitability_percent, profitability_diff = self.get_trades_manager( ).get_profitability_without_update() else: order_closed = order orders_canceled = order.get_linked_orders() # update portfolio with ended order with self.get_order_portfolio(order) as pf: pf.update_portfolio(order) # debug purpose profitability, profitability_percent, profitability_diff = self.get_trades_manager( ).get_profitability() self.logger.info("Current portfolio profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print( profitability, profitability_percent, self.get_trades_manager().get_reference()))) # add to trade history self.trades_manager.add_new_trade_in_history( Trade(self.exchange, order)) # remove order to open_orders self.order_manager.remove_order_from_list(order) profitability_activated = order_closed is not None # update current order list with exchange if not self.simulate: self.update_open_orders(order.get_order_symbol()) # notification order.get_order_notifier().end(order_closed, orders_canceled, order.get_profitability(), profitability_percent, profitability_diff, profitability_activated)
def notify_create(self, evaluator_notification, orders): if orders: content = orders[0].trader.trader_type_str if evaluator_notification is not None: self.evaluator_notification = evaluator_notification title = "Order(s) creation " content += title for order in orders: content += "\n- {0}".format( PrettyPrinter.open_order_pretty_printer(order)) if self.twitter_notification_available(CONFIG_NOTIFICATION_TRADES) \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance( ) self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available( CONFIG_NOTIFICATION_TRADES): self.telegram_notification_factory(content) if self.web_interface_notification_available( CONFIG_NOTIFICATION_TRADES): self.web_interface_notification_factory( InterfaceLevel.INFO, title, content)
def notify_state_changed(self, final_eval, crypto_currency_evaluator, symbol, trader, result, matrix): if self.gmail_notification_available(): profitability, profitability_percent, _ = trader.get_trades_manager( ).get_profitability() self.gmail_notification_factory( "CRYPTO BOT ALERT : {0} / {1}".format( crypto_currency_evaluator.crypto_currency, result), "CRYPTO BOT ALERT : {0} / {1} \n {2} \n Current portfolio " "profitability : {3} " "{4} ({5}%)".format( crypto_currency_evaluator.crypto_currency, result, pprint.pformat(matrix), round(profitability, 2), TradesManager.get_reference_market(self.config), round(profitability_percent, 2))) alert_content = PrettyPrinter.cryptocurrency_alert( crypto_currency_evaluator.crypto_currency, symbol, result, final_eval) if self.twitter_notification_available(): self.tweet_instance = self.twitter_notification_factory( alert_content) if self.telegram_notification_available(): self.telegram_notification_factory(alert_content) return self
def get_command_configuration(markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) message = f"{b}My configuration:{b}{EOL}{EOL}" message += f"{b}Traders: {b}{EOL}" has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders() if has_real_trader: message += f"{c}- Real trader{c}{EOL}" if has_simulated_trader: message += f"{c}- Simulated trader{c}{EOL}" message += f"{EOL}{b}Exchanges:{b}{EOL}" for exchange in get_bot().get_exchanges_list().values(): message += f"{c}- {exchange.get_name()}{c}{EOL}" message += f"{EOL}{b}Evaluators:{b}{EOL}" first_evaluator = next(iter(get_bot().get_symbols_tasks_manager().values())).get_evaluator() evaluators = copy.copy(first_evaluator.get_social_eval_list()) evaluators += first_evaluator.get_ta_eval_list() evaluators += first_evaluator.get_real_time_eval_list() for evaluator in evaluators: message += f"{c}- {evaluator.get_name()}{c}{EOL}" first_symbol_evaluator = next(iter(get_bot().get_symbol_evaluator_list().values())) first_exchange = next(iter(get_bot().get_exchanges_list().values())) message += f"{EOL}{b}Strategies:{b}{EOL}" for strategy in first_symbol_evaluator.get_strategies_eval_list(first_exchange): message += f"{c}- {strategy.get_name()}{c}{EOL}" message += f"{EOL}{b}Trading mode:{b}{EOL}" message += f"{c}- {next(iter(get_bot().get_exchange_trading_modes().values())).get_name()}{c}" return message
def notify_alert(self, final_eval, crypto_currency_evaluator, symbol, trader, result, matrix): title = f"OCTOBOT ALERT : {crypto_currency_evaluator.crypto_currency} / {result}" if self.gmail_notification_available(CONFIG_NOTIFICATION_PRICE_ALERTS): profitability, profitability_percent, _, _ = trader.get_trades_manager().get_profitability() self.gmail_notification_factory( title, "OCTOBOT ALERT : {0} / {1} \n {2} \n Current portfolio " "profitability : {3} " "{4} ({5}%)".format( crypto_currency_evaluator.crypto_currency, result, pprint.pformat(matrix), round(profitability, 2), TradesManager.get_reference_market(self.config), round(profitability_percent, 2))) alert_content = PrettyPrinter.cryptocurrency_alert( crypto_currency_evaluator.crypto_currency, symbol, result, final_eval) self.tweet_instance = self.send_twitter_notification_if_necessary(alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) self.send_telegram_notification_if_necessary(alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) self.send_web_notification_if_necessary(InterfaceLevel.INFO, title, alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) return self
async def notify_alert(self, final_eval, crypto_currency_evaluator, symbol, trader, result, matrix): title = f"OCTOBOT ALERT : {crypto_currency_evaluator.crypto_currency} / {result}" try: alert_content, alert_content_markdown = PrettyPrinter.cryptocurrency_alert( crypto_currency_evaluator.crypto_currency, symbol, result, final_eval) self.tweet_instance = await self.send_twitter_notification_if_necessary( alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) await self.send_telegram_notification_if_necessary( alert_content_markdown, CONFIG_NOTIFICATION_PRICE_ALERTS, markdown=True) await self.send_web_notification_if_necessary( InterfaceLevel.INFO, title, alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) except Exception as e: self.logger.error(f"Error when sending alert [{title}] error: {e}") self.logger.exception(e) return self
def notify_end(self, order_filled, orders_canceled, trade_profitability, portfolio_profitability, portfolio_diff, profitability=False): title = "Order status updated" content = "" if order_filled is not None: content += "\n{0}Order(s) filled : \n- {1}".format( order_filled.trader.trader_type_str, PrettyPrinter.open_order_pretty_printer(order_filled)) if orders_canceled is not None and len(orders_canceled) > 0: content += "\n{0}Order(s) canceled :".format( orders_canceled[0].trader.trader_type_str) for order in orders_canceled: content += "\n- {0}".format( PrettyPrinter.open_order_pretty_printer(order)) if trade_profitability is not None and profitability: content += "\n\nTrade profitability : {0}{1}%".format( "+" if trade_profitability >= 0 else "", round(trade_profitability * 100, 7)) if portfolio_profitability is not None and profitability: content += "\nGlobal Portfolio profitability : {0}% {1}{2}%".format( round(portfolio_profitability, 5), "+" if portfolio_diff >= 0 else "", round(portfolio_diff, 7)) if self.twitter_notification_available(CONFIG_NOTIFICATION_TRADES) \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance() self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available(CONFIG_NOTIFICATION_TRADES): self.telegram_notification_factory(content) if self.web_interface_notification_available( CONFIG_NOTIFICATION_TRADES): self.web_interface_notification_factory(InterfaceLevel.INFO, title, content)
def print_trades_history(self): trader = self.get_trader() trades_history = trader.get_trades_manager().get_trade_history() trades_history_string = "" for trade in trades_history: trades_history_string += PrettyPrinter.trade_pretty_printer( trade) + "\n" self.logger.info(trades_history_string.strip())
def command_open_orders(_, update): portfolio_real_open_orders, portfolio_simulated_open_orders = get_open_orders() portfolio_real_current_value_string = TelegramApp.EOL for orders in portfolio_real_open_orders: for order in orders: portfolio_real_current_value_string += PrettyPrinter.open_order_pretty_printer(order) + \ TelegramApp.EOL portfolio_simulated_current_value_string = TelegramApp.EOL for orders in portfolio_simulated_open_orders: for order in orders: portfolio_simulated_current_value_string += PrettyPrinter.open_order_pretty_printer(order) + \ TelegramApp.EOL update.message.reply_text("Real open orders : {0}".format(portfolio_real_current_value_string)) update.message.reply_text("Simulated open orders : {0}".format(portfolio_simulated_current_value_string))
def command_portfolio(_, update): portfolio_real_current_value, portfolio_simulated_current_value = get_portfolio_current_value( ) reference_market = get_reference_market() real_global_portfolio, simulated_global_portfolio = get_global_portfolio_currencies_amounts( ) update.message.reply_text("Portfolio real value : {0} {1}".format( portfolio_real_current_value, reference_market)) update.message.reply_text("Global real portfolio : \n{0}".format( PrettyPrinter.global_portfolio_pretty_print( real_global_portfolio))) update.message.reply_text("Portfolio simulated value : {0} {1}".format( portfolio_simulated_current_value, reference_market)) update.message.reply_text("Global simulated portfolio : \n{0}".format( PrettyPrinter.global_portfolio_pretty_print( simulated_global_portfolio)))
def _print_trades(trades_history, trader_str, markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) trades_history_string = f"{b}{trader_str}{b}{c}Trades :{EOL}{c}" if trades_history: for trade in trades_history: trades_history_string += f"{PrettyPrinter.trade_pretty_printer(trade, markdown=markdown)}{EOL}" else: trades_history_string += f"{c}No trade yet.{c}" return trades_history_string
def notify_order_close(self, order, cancel=False): # Cancel linked orders for linked_order in order.get_linked_orders(): self.cancel_order(linked_order) # If need to cancel the order call the method and no need to update the portfolio (only availability) if cancel: order_closed = None orders_canceled = order.get_linked_orders() + [order] self.cancel_order(order) _, profitability_percent, profitability_diff = self.get_trades_manager().get_profitability_without_update() with self.portfolio as pf: # ensure availability reset pf.reset_portfolio_available() else: order_closed = order orders_canceled = order.get_linked_orders() # update portfolio with ended order with self.portfolio as pf: pf.update_portfolio(order) # debug purpose profitability, profitability_percent, profitability_diff = self.get_trades_manager().get_profitability() self.logger.info("Current portfolio profitability : {0}".format( PrettyPrinter.portfolio_profitability_pretty_print(profitability, profitability_percent, self.get_trades_manager().get_reference()))) # add to trade history self.trades_manager.add_new_trade_in_history(Trade(self.exchange, order)) # remove order to open_orders self.order_manager.remove_order_from_list(order) if order_closed is not None: profitability_activated = True else: profitability_activated = False # update current order list with exchange if not self.simulate: self.update_open_orders() # notification order.get_order_notifier().end(order_closed, orders_canceled, order.get_profitability(), profitability_percent, profitability_diff, profitability_activated)
def command_open_orders(_, update): portfolio_real_open_orders, portfolio_simulated_open_orders = get_open_orders( ) portfolio_real_current_value_string = TelegramApp.EOL for orders in portfolio_real_open_orders: for order in orders: portfolio_real_current_value_string += PrettyPrinter.open_order_pretty_printer(order) + \ TelegramApp.EOL portfolio_simulated_current_value_string = TelegramApp.EOL for orders in portfolio_simulated_open_orders: for order in orders: portfolio_simulated_current_value_string += PrettyPrinter.open_order_pretty_printer(order) + \ TelegramApp.EOL update.message.reply_text("Real open orders : {0}".format( portfolio_real_current_value_string)) update.message.reply_text("Simulated open orders : {0}".format( portfolio_simulated_current_value_string))
def profitability(): profitability_digits = 4 has_real_trader, has_simulated_trader, \ _, _, \ real_percent_profitability, simulated_percent_profitability, \ real_no_trade_profitability, simulated_no_trade_profitability, \ market_average_profitability = get_global_profitability() profitability_data = \ {"market_average_profitability": PrettyPrinter.round_with_decimal_count(market_average_profitability, profitability_digits)} if has_real_trader: profitability_data["bot_real_profitability"] = \ PrettyPrinter.round_with_decimal_count(real_percent_profitability, profitability_digits) profitability_data["real_no_trade_profitability"] = \ PrettyPrinter.round_with_decimal_count(real_no_trade_profitability, profitability_digits) if has_simulated_trader: profitability_data["bot_simulated_profitability"] = \ PrettyPrinter.round_with_decimal_count(simulated_percent_profitability, profitability_digits) profitability_data["simulated_no_trade_profitability"] = \ PrettyPrinter.round_with_decimal_count(simulated_no_trade_profitability, profitability_digits) return jsonify(profitability_data)
def command_profitability(_, update): has_real_trader, has_simulated_trader, \ real_global_profitability, simulated_global_profitability, \ real_percent_profitability, simulated_percent_profitability, \ market_average_profitability = get_global_profitability() profitability_string = "" if has_real_trader: profitability_string = "{0}Global profitability : {1} ({2}%), market: {3}%{4}".format( REAL_TRADER_STR, PrettyPrinter.portfolio_profitability_pretty_print( real_global_profitability, None, get_reference_market()), PrettyPrinter.get_min_string_from_number( real_percent_profitability, 2), PrettyPrinter.get_min_string_from_number( market_average_profitability, 2), TelegramApp.EOL) if has_simulated_trader: profitability_string += "{0}Global profitability : {1} ({2}%), market: {3}%".format( SIMULATOR_TRADER_STR, PrettyPrinter.portfolio_profitability_pretty_print( simulated_global_profitability, None, get_reference_market()), PrettyPrinter.get_min_string_from_number( simulated_percent_profitability, 2), PrettyPrinter.get_min_string_from_number( market_average_profitability, 2)) if not profitability_string: profitability_string = TelegramApp.NO_TRADER_MESSAGE update.message.reply_text(profitability_string)
def notify_end(self, order_filled, orders_canceled, trade_profitability, portfolio_profitability, portfolio_diff, profitability=False): content = "" if order_filled is not None: content += "\nOrder(s) filled : \n- {0}".format( PrettyPrinter.open_order_pretty_printer(order_filled)) if orders_canceled is not None and len(orders_canceled) > 0: content += "\nOrder(s) canceled :" for order in orders_canceled: content += "\n- {0}".format( PrettyPrinter.open_order_pretty_printer(order)) if trade_profitability is not None and profitability: content += "\n\nTrade profitability : {0}{1}%".format( "+" if trade_profitability >= 0 else "", round(trade_profitability * 100, 7)) if portfolio_profitability is not None and profitability: content += "\nGlobal Portfolio profitability : {0}% {1}{2}%".format( round(portfolio_profitability, 5), "+" if portfolio_diff >= 0 else "", round(portfolio_diff, 7)) if self.twitter_notification_available() \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance() self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available(): self.telegram_notification_factory(content)
def get_command_fees(markdown=False): _, b, _ = PrettyPrinter.get_markets(markdown) real_trader_fees, simulated_trader_fees = get_total_paid_fees() result_str = "" if real_trader_fees is not None: result_str = f"{b}{REAL_TRADER_STR}{b}{PAID_FEES_STR}: " \ f"{PrettyPrinter.pretty_print_dict(real_trader_fees, markdown=markdown)}" if simulated_trader_fees is not None: result_str = f"{result_str}\n{b}{SIMULATOR_TRADER_STR}{b}{PAID_FEES_STR}: " \ f"{PrettyPrinter.pretty_print_dict(simulated_trader_fees, markdown=markdown)}" if not result_str: result_str = NO_TRADER_MESSAGE return result_str
def get_command_market_status(markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) message = f"{b}My cryptocurrencies evaluations are:{b} {EOL}{EOL}" at_least_one_currency = False for currency_pair, currency_info in get_currencies_with_status().items(): at_least_one_currency = True message += f"{c}{currency_pair}:{c}{EOL}" for exchange_name, evaluation in currency_info.items(): message += f"{c}- {exchange_name}: {evaluation[0]}{c}{EOL}" if not at_least_one_currency: message += f"{c}{NO_CURRENCIES_MESSAGE}{c}{EOL}" message += f"{EOL}{c}My current risk is: {get_risk()}{c}" return message
def notify_end(self, order_filled, orders_canceled, trade_profitability, portfolio_profitability, portfolio_diff, profitability=False): content = "" if order_filled is not None: content += "\nOrder(s) filled : \n- {0}".format(PrettyPrinter.open_order_pretty_printer(order_filled)) if orders_canceled is not None and len(orders_canceled) > 0: content += "\nOrder(s) canceled :" for order in orders_canceled: content += "\n- {0}".format(PrettyPrinter.open_order_pretty_printer(order)) if trade_profitability is not None and profitability: content += "\n\nTrade profitability : {0}{1}%".format("+" if trade_profitability >= 0 else "", round(trade_profitability * 100, 7)) if portfolio_profitability is not None and profitability: content += "\nGlobal Portfolio profitability : {0}% {1}{2}%".format(round(portfolio_profitability, 5), "+" if portfolio_diff >= 0 else "", round(portfolio_diff, 7)) if self.twitter_notification_available() \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance() self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available(): self.telegram_notification_factory(content)
def get_command_trades_history(): has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders( ) real_trades_history, simulated_trades_history = get_trades_history() trades_history_string = "" if has_real_trader: trades_history_string += f"{REAL_TRADER_STR}Trades :{EOL}" for trades in real_trades_history: for trade in trades: trades_history_string += PrettyPrinter.trade_pretty_printer( trade) + EOL if has_simulated_trader: for trades in simulated_trades_history: trades_history_string += EOL + f"{SIMULATOR_TRADER_STR}Trades :{EOL}" for trade in trades: trades_history_string += PrettyPrinter.trade_pretty_printer( trade) + EOL if not trades_history_string: trades_history_string = NO_TRADER_MESSAGE return trades_history_string
def notify_create(self, evaluator_notification, orders): if evaluator_notification is not None: self.evaluator_notification = evaluator_notification content = "Order(s) creation " for order in orders: content += "\n- {0}".format(PrettyPrinter.open_order_pretty_printer(order)) if self.twitter_notification_available() \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance() self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available(): self.telegram_notification_factory(content)
def notify_create(self, evaluator_notification, orders): if evaluator_notification is not None: self.evaluator_notification = evaluator_notification content = "Order(s) creation " for order in orders: content += "\n- {0}".format( PrettyPrinter.open_order_pretty_printer(order)) if self.twitter_notification_available() \ and self.evaluator_notification is not None \ and self.evaluator_notification.get_tweet_instance() is not None: tweet_instance = self.evaluator_notification.get_tweet_instance() self.twitter_response_factory(tweet_instance, content) if self.telegram_notification_available(): self.telegram_notification_factory(content)
def get_command_open_orders(markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) has_real_trader, has_simulated_trader = has_real_and_or_simulated_traders() portfolio_real_open_orders, portfolio_simulated_open_orders = get_open_orders() orders_string = "" if has_real_trader: orders_string += InterfaceBot._print_open_orders(portfolio_real_open_orders, REAL_TRADER_STR, markdown) if has_simulated_trader: orders_string += f"{EOL}" \ f"{InterfaceBot._print_open_orders(portfolio_simulated_open_orders, SIMULATOR_TRADER_STR, markdown)}" if not orders_string: orders_string = NO_TRADER_MESSAGE return orders_string
def get_command_portfolio(markdown=False): _, b, c = PrettyPrinter.get_markets(markdown) has_real_trader, has_simulated_trader, \ portfolio_real_current_value, portfolio_simulated_current_value = get_portfolio_current_value() reference_market = get_reference_market() real_global_portfolio, simulated_global_portfolio = get_global_portfolio_currencies_amounts() portfolios_string = "" if has_real_trader: portfolios_string += InterfaceBot._print_portfolio(portfolio_real_current_value, reference_market, real_global_portfolio, REAL_TRADER_STR, markdown) if has_simulated_trader: portfolio_str = InterfaceBot._print_portfolio(portfolio_simulated_current_value, reference_market, simulated_global_portfolio, SIMULATOR_TRADER_STR, markdown) portfolios_string += f"{EOL}{portfolio_str}" if not portfolios_string: portfolios_string = NO_TRADER_MESSAGE return portfolios_string
async def notify_alert(self, final_eval, crypto_currency_evaluator, symbol, trader, result, matrix): title = f"OCTOBOT ALERT : {crypto_currency_evaluator.crypto_currency} / {result}" alert_content = PrettyPrinter.cryptocurrency_alert( crypto_currency_evaluator.crypto_currency, symbol, result, final_eval) self.tweet_instance = await self.send_twitter_notification_if_necessary( alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) await self.send_telegram_notification_if_necessary( alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) await self.send_web_notification_if_necessary( InterfaceLevel.INFO, title, alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) await self.send_notifier_notification_if_necessary( alert_content, CONFIG_NOTIFICATION_PRICE_ALERTS) return self