Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
0
def create_candles_data(symbol, time_frame, new_data, bot, list_arrays,
                        in_backtesting):
    candles_key = "candles"
    real_trades_key = "real_trades"
    simulated_trades_key = "simulated_trades"
    result_dict = {
        candles_key: [],
        real_trades_key: [],
        simulated_trades_key: [],
    }

    if not in_backtesting:
        add_to_symbol_data_history(symbol, new_data, time_frame, False)
        data = get_symbol_data_history(symbol, time_frame)
    else:
        data = new_data

    data_x = convert_timestamps_to_datetime(
        data[PriceIndexes.IND_PRICE_TIME.value],
        time_format="%y-%m-%d %H:%M:%S",
        force_timezone=False)

    real_trades_history, simulated_trades_history = get_trades_history(
        bot, symbol)

    if real_trades_history:
        result_dict[real_trades_key] = _format_trades(real_trades_history)

    if real_trades_history:
        result_dict[simulated_trades_key] = _format_trades(
            simulated_trades_history)

    if list_arrays:
        result_dict[candles_key] = {
            PriceStrings.STR_PRICE_TIME.value:
            data_x,
            PriceStrings.STR_PRICE_CLOSE.value:
            data[PriceIndexes.IND_PRICE_CLOSE.value].tolist(),
            PriceStrings.STR_PRICE_LOW.value:
            data[PriceIndexes.IND_PRICE_LOW.value].tolist(),
            PriceStrings.STR_PRICE_OPEN.value:
            data[PriceIndexes.IND_PRICE_OPEN.value].tolist(),
            PriceStrings.STR_PRICE_HIGH.value:
            data[PriceIndexes.IND_PRICE_HIGH.value].tolist()
        }
    else:
        result_dict[candles_key] = {
            PriceStrings.STR_PRICE_TIME.value:
            data_x,
            PriceStrings.STR_PRICE_CLOSE.value:
            data[PriceIndexes.IND_PRICE_CLOSE.value],
            PriceStrings.STR_PRICE_LOW.value:
            data[PriceIndexes.IND_PRICE_LOW.value],
            PriceStrings.STR_PRICE_OPEN.value:
            data[PriceIndexes.IND_PRICE_OPEN.value],
            PriceStrings.STR_PRICE_HIGH.value:
            data[PriceIndexes.IND_PRICE_HIGH.value]
        }
    return result_dict
Ejemplo n.º 3
0
    def get_command_trades_history(markdown=False):
        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 += InterfaceBot._print_trades(real_trades_history, REAL_TRADER_STR, markdown)

        if has_simulated_trader:
            trades_history_string += \
                f"{EOL}{InterfaceBot._print_trades(simulated_trades_history, SIMULATOR_TRADER_STR, markdown)}"

        if not trades_history_string:
            trades_history_string = NO_TRADER_MESSAGE

        return trades_history_string
Ejemplo n.º 4
0
    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
Ejemplo n.º 5
0
def trades():
    real_trades_history, simulated_trades_history = get_trades_history()
    return render_template('trades.html',
                           real_trades_history=real_trades_history,
                           simulated_trades_history=simulated_trades_history)
Ejemplo n.º 6
0
def get_currency_price_graph_update(exchange_name,
                                    symbol,
                                    time_frame,
                                    list_arrays=True,
                                    backtesting=False):
    bot = get_bot()
    if backtesting and bot.get_tools() and bot.get_tools(
    )[BOT_TOOLS_BACKTESTING]:
        bot = bot.get_tools()[BOT_TOOLS_BACKTESTING].get_bot()
    symbol = parse_get_symbol(symbol)
    symbol_evaluator_list = bot.get_symbol_evaluator_list()
    in_backtesting = Backtesting.enabled(get_global_config()) or backtesting

    exchange = exchange_name
    exchange_list = bot.get_exchanges_list()
    if backtesting:
        exchanges = [key for key in exchange_list if exchange_name in key]
        if exchanges:
            exchange = exchanges[0]

    if time_frame is not None:
        if symbol_evaluator_list:
            evaluator_thread_managers = symbol_evaluator_list[
                symbol].get_evaluator_thread_managers(exchange_list[exchange])

            if time_frame in evaluator_thread_managers:
                evaluator_thread_manager = evaluator_thread_managers[
                    time_frame]
                data = evaluator_thread_manager.get_evaluator().get_data()

                if data is not None:

                    candles_key = "candles"
                    real_trades_key = "real_trades"
                    simulated_trades_key = "simulated_trades"
                    result_dict = {
                        candles_key: [],
                        real_trades_key: [],
                        simulated_trades_key: [],
                    }

                    _, pair_tag = split_symbol(symbol)
                    add_to_symbol_data_history(symbol, data, time_frame,
                                               in_backtesting)
                    data = get_symbol_data_history(symbol, time_frame)

                    data_x = convert_timestamps_to_datetime(
                        data[PriceIndexes.IND_PRICE_TIME.value],
                        time_format="%y-%m-%d %H:%M:%S",
                        force_timezone=False)

                    real_trades_history, simulated_trades_history = get_trades_history(
                        bot, symbol)

                    if real_trades_history:
                        result_dict[real_trades_key] = _format_trades(
                            real_trades_history)

                    if real_trades_history:
                        result_dict[simulated_trades_key] = _format_trades(
                            simulated_trades_history)

                    if list_arrays:
                        result_dict[candles_key] = {
                            PriceStrings.STR_PRICE_TIME.value:
                            data_x,
                            PriceStrings.STR_PRICE_CLOSE.value:
                            data[PriceIndexes.IND_PRICE_CLOSE.value].tolist(),
                            PriceStrings.STR_PRICE_LOW.value:
                            data[PriceIndexes.IND_PRICE_LOW.value].tolist(),
                            PriceStrings.STR_PRICE_OPEN.value:
                            data[PriceIndexes.IND_PRICE_OPEN.value].tolist(),
                            PriceStrings.STR_PRICE_HIGH.value:
                            data[PriceIndexes.IND_PRICE_HIGH.value].tolist()
                        }
                    else:
                        result_dict[candles_key] = {
                            PriceStrings.STR_PRICE_TIME.value:
                            data_x,
                            PriceStrings.STR_PRICE_CLOSE.value:
                            data[PriceIndexes.IND_PRICE_CLOSE.value],
                            PriceStrings.STR_PRICE_LOW.value:
                            data[PriceIndexes.IND_PRICE_LOW.value],
                            PriceStrings.STR_PRICE_OPEN.value:
                            data[PriceIndexes.IND_PRICE_OPEN.value],
                            PriceStrings.STR_PRICE_HIGH.value:
                            data[PriceIndexes.IND_PRICE_HIGH.value]
                        }
                    return result_dict
    return None