Exemplo n.º 1
0
def post(bot, update):
    chat_id = get_chat_id(update)
    text = update.message.text[6:]

    def __post():
        chats = TBDB.get_chats()
        sent = 0

        for chat in chats:
            try:
                bot.send_message(chat_id=chat['chat_id'],
                                 text=text,
                                 parse_mode='html',
                                 is_group=int(chat['chat_id']) < 0)
                sent += 1
                time.sleep(0.1)
            except Exception as e:
                logger.error("Exception sending broadcast to %d: (%s) %s",
                             chat['chat_id'], e, traceback.format_exc())

        bot.send_message(chat_id=chat_id,
                         text='Broadcast sent to {}/{} chats'.format(
                             sent, len(chats)),
                         is_group=chat_id < 0)
        TranscriberBot.get().command_handlers['users'](bot, update)

    TranscriberBot.get().misc_thread_pool.submit(__post)
def photo(bot, update):
    chat_id = get_chat_id(update)
    chat = TBDB.get_chat_entry(chat_id)
    if chat["qr_enabled"] == 0 and chat["photos_enabled"] == 0:
        return

    message = update.message or update.channel_post

    if message.photo:
        TranscriberBot.get().photos_thread_pool.submit(process_media_photo,
                                                       bot, update,
                                                       message.photo, chat)
def voice(bot, update):
    chat_id = get_chat_id(update)
    voice_enabled = TBDB.get_chat_voice_enabled(chat_id)
    if voice_enabled == 0:
        return

    message = update.message or update.channel_post
    v = message.voice

    if voice_enabled == 2:
        pass
    else:
        TranscriberBot.get().voice_thread_pool.submit(process_media_voice, bot,
                                                      update, v, "voice")
Exemplo n.º 4
0
def stop(bot, update):
    query = update.callback_query

    TranscriberBot.get().stop_thread(query.data)
    logger.debug("Stopping thread %s", query.data)
    logger.debug("Thread %s running: %r", query.data,
                 TranscriberBot.get().thread_running(query.data))

    string_stopped = R.get_string_resource(
        "transcription_stopped", TBDB.get_chat_lang(query.message.chat_id))

    bot.edit_message_text(text=query.message.text + " " + string_stopped,
                          chat_id=query.message.chat_id,
                          message_id=query.message.message_id,
                          parse_mode="html",
                          is_group=query.message.chat_id < 0)
def document(bot, update):
    chat_id = get_chat_id(update)
    voice_enabled = TBDB.get_chat_voice_enabled(chat_id)

    m = update.message or update.channel_post
    file_name = m.document.file_name
    _, file_ext = os.path.splitext(file_name)

    if file_ext[1:] not in config.get_config_prop("app")["audio_ext"]:
        logger.info('extension %s not recognized', file_ext)
        return

    if voice_enabled == 0:
        return

    if voice_enabled == 2:
        pass
    else:
        TranscriberBot.get().voice_thread_pool.submit(process_media_voice, bot,
                                                      update, m.document,
                                                      'audio_document')
def transcribe_audio_file(bot, update, path):
    chat_id = get_chat_id(update)
    lang = TBDB.get_chat_lang(chat_id)
    message_id = get_message_id(update)
    is_group = chat_id < 0

    api_key = config.get_config_prop("wit").get(lang, None)
    if api_key is None:
        logger.error("Language not found in wit.json %s", lang)
        message = bot.send_message(
            chat_id=chat_id,
            text=R.get_string_resource("unknown_api_key",
                                       lang).format(language=lang) + "\n",
            reply_to_message_id=message_id,
            parse_mode="html",
            is_group=is_group).result()
        return
    logger.debug("Using key %s for lang %s", api_key, lang)

    message = bot.send_message(
        chat_id=chat_id,
        text=R.get_string_resource("transcribing", lang) + "\n",
        reply_to_message_id=message_id,
        parse_mode="html",
        is_group=is_group).result()

    TranscriberBot.get().start_thread(message_id)
    logger.debug("Starting thread %d", message_id)

    keyboard = InlineKeyboardMarkup(
        [[InlineKeyboardButton("Stop", callback_data=message_id)]])

    text = ""
    if is_group:
        text = R.get_string_resource("transcription_text", lang) + "\n"
    success = False

    for speech in audiotools.transcribe(path, api_key):
        logger.debug("Thread %d running: %r", message_id,
                     TranscriberBot.get().thread_running(message_id))
        if TranscriberBot.get().thread_running(message_id) is False:
            TranscriberBot.get().del_thread(message_id)
            return

        retry = True
        retry_num = 0

        while retry and TranscriberBot.get().thread_running(message_id):
            try:
                if len(text + " " + speech) >= 4000:
                    text = R.get_string_resource("transcription_continues",
                                                 lang) + "\n"
                    message = bot.send_message(
                        chat_id=chat_id,
                        text=text + " " + speech + " <b>[...]</b>",
                        reply_to_message_id=message.message_id,
                        parse_mode="html",
                        is_group=is_group,
                        reply_markup=keyboard).result()
                else:
                    message = bot.edit_message_text(
                        text=text + " " + speech + " <b>[...]</b>",
                        chat_id=chat_id,
                        message_id=message.message_id,
                        parse_mode="html",
                        is_group=is_group,
                        reply_markup=keyboard).result()

                text += " " + speech
                retry = False
                success = True

            except telegram.error.TimedOut as t:
                logger.error("Timeout error %s", traceback.format_exc())
                retry_num += 1
                if retry_num >= 3:
                    retry = False

            except telegram.error.RetryAfter as r:
                logger.warning("Retrying after %d", r.retry_after)
                time.sleep(r.retry_after)

            except telegram.error.TelegramError as te:
                logger.error("Telegram error %s", traceback.format_exc())
                retry = False

            except Exception as e:
                logger.error("Exception %s", traceback.format_exc())
                retry = False

    retry = True
    retry_num = 0
    while retry and TranscriberBot.get().thread_running(message_id):
        try:
            if success:
                bot.edit_message_text(text=text,
                                      chat_id=chat_id,
                                      message_id=message.message_id,
                                      parse_mode="html",
                                      is_group=is_group)
            else:
                bot.edit_message_text(R.get_string_resource(
                    "transcription_failed", lang),
                                      chat_id=chat_id,
                                      message_id=message.message_id,
                                      parse_mode="html",
                                      is_group=is_group)
            retry = False
        except telegram.error.TimedOut as t:
            logger.error("Timeout error %s", traceback.format_exc())
            retry_num += 1
            if retry_num >= 3:
                retry = False

        except telegram.error.RetryAfter as r:
            logger.warning("Retrying after %d", r.retry_after)
            time.sleep(r.retry_after)

        except telegram.error.TelegramError as te:
            logger.error("Telegram error %s", traceback.format_exc())
            retry = False

        except Exception as e:
            logger.error("Exception %s", traceback.format_exc())
            retry = False

    TranscriberBot.get().del_thread(message_id)