def totranslate(bot: Bot, update: Update):
    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)
    try:
        if msg.reply_to_message and msg.reply_to_message.text:

            args = update.effective_message.text.split(None, 1)
            text = msg.reply_to_message.text
            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count("-") == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count("-") == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang == None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, "")

            trl = Translator()
            if source_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    f"Diterjemahkan dari `{detection.lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN,
                )
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    f"Diterjemahkan dari `{source_lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN,
                )
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, "")
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count("-") == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count("-") == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            trl = Translator()
            if dest_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Diterjemahkan dari `{}` to `{}`:\n`{}`".format(
                        detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN,
                )
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Diterjemahkan dari `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN,
                )

    except IndexError:
        update.effective_message.reply_text(
            "Membalas pesan atau menulis pesan dari bahasa lain •• untuk menerjemahkan ke dalam bahasa yang dimaksudkan\n\n"
            "Contoh: `/tr en id` untuk menerjemahkan dari bahasa Inggris ke bahasa Indonesia\n"
            "Atau gunakan: `/tr id` untuk deteksi otomatis dan menerjemahkannya ke dalam bahasa Indonesia.\n"
            "Lihat [Daftar Kode Bahasa](t.me/OnePunchSupport/12823) untuk daftar kode bahasa.",
            parse_mode="markdown",
            disable_web_page_preview=True,
        )
    except ValueError:
        update.effective_message.reply_text(
            "Bahasa yang dimaksudkan tidak ditemukan!")
    else:
        return
Example #2
0
def totranslate(update: Update, context: CallbackContext):
    message = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)

    try:
        if message.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if message.reply_to_message.text:
                text = message.reply_to_message.text
            elif message.reply_to_message.caption:
                text = message.reply_to_message.caption

            try:
                source_lang = args[1].split(None, 1)[0]
            except (IndexError, AttributeError):
                source_lang = "es"

        else:
            args = update.effective_message.text.split(None, 2)
            text = args[2]
            source_lang = args[1]

        if source_lang.count("-") == 2:
            for lang in problem_lang_code:
                if lang in source_lang:
                    if source_lang.startswith(lang):
                        dest_lang = source_lang.rsplit("-", 1)[1]
                        source_lang = source_lang.rsplit("-", 1)[0]
                    else:
                        dest_lang = source_lang.split("-", 1)[1]
                        source_lang = source_lang.split("-", 1)[0]
        elif source_lang.count("-") == 1:
            for lang in problem_lang_code:
                if lang in source_lang:
                    dest_lang = source_lang
                    source_lang = None
                    break
            if dest_lang is None:
                dest_lang = source_lang.split("-")[1]
                source_lang = source_lang.split("-")[0]
        else:
            dest_lang = source_lang
            source_lang = None

        exclude_list = UNICODE_EMOJI.keys()
        for emoji in exclude_list:
            if emoji in text:
                text = text.replace(emoji, "")

        trl = google_translator()
        if source_lang is None:
            detection = trl.detect(text)
            trans_str = trl.translate(text, lang_tgt=dest_lang)
            return message.reply_text(
                f"Traducido del `{detection[0]}` al `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN,
            )
        else:
            trans_str = trl.translate(text,
                                      lang_tgt=dest_lang,
                                      lang_src=source_lang)
            message.reply_text(
                f"Traducido del `{source_lang}` al `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN,
            )

    except IndexError:
        update.effective_message.reply_text(
            "Responde a mensajes o escribe en otros idiomas para traducirlos al idioma deseado\n\n"
            "*Ejemplo:* `/tr en-es` Para traducir del inglés al español\n\n"
            f"Para ver la lista de códigos de idioma puedes hacer click [aquí](http://t.me/{context.bot.username}?start=ghelp_traductor).",
            parse_mode="markdown",
            disable_web_page_preview=True,
        )
    except ValueError:
        update.effective_message.reply_text(
            "No se encontró el idioma deseado!")
    else:
        return
def totranslate(bot: Bot, update: Update):
    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)
    try:
        if msg.reply_to_message and msg.reply_to_message.text:

            args = update.effective_message.text.split(None, 1)
            text = msg.reply_to_message.text
            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang == None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')

            if source_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    f"Translated from `{detection.lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(f"Translated from `{source_lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                                   parse_mode=ParseMode.MARKDOWN)
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            if dest_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(source_lang, dest_lang, tekstr.text),
                                   parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        pass
    except ValueError:
        update.effective_message.reply_text("The intended language is not found!")
    else:
        return
Example #4
0
def totranslate(update: Update, context: CallbackContext):
    message = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)

    try:
        if message.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if message.reply_to_message.text:
                text = message.reply_to_message.text
            elif message.reply_to_message.caption:
                text = message.reply_to_message.caption

            try:
                source_lang = args[1].split(None, 1)[0]
            except (IndexError, AttributeError):
                source_lang = "az"

        else:
            args = update.effective_message.text.split(None, 2)
            text = args[2]
            source_lang = args[1]

        if source_lang.count('-') == 2:
            for lang in problem_lang_code:
                if lang in source_lang:
                    if source_lang.startswith(lang):
                        dest_lang = source_lang.rsplit("-", 1)[1]
                        source_lang = source_lang.rsplit("-", 1)[0]
                    else:
                        dest_lang = source_lang.split("-", 1)[1]
                        source_lang = source_lang.split("-", 1)[0]
        elif source_lang.count('-') == 1:
            for lang in problem_lang_code:
                if lang in source_lang:
                    dest_lang = source_lang
                    source_lang = None
                    break
            if dest_lang is None:
                dest_lang = source_lang.split("-")[1]
                source_lang = source_lang.split("-")[0]
        else:
            dest_lang = source_lang
            source_lang = None

        exclude_list = UNICODE_EMOJI.keys()
        for emoji in exclude_list:
            if emoji in text:
                text = text.replace(emoji, '')

        trl = google_translator()
        if source_lang is None:
            detection = trl.detect(text)
            trans_str = trl.translate(text, lang_tgt=dest_lang)
            return message.reply_text(
                f"`{detection[0]}` dilindən `{dest_lang}` dilinə tərcümə edildi:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN)
        else:
            trans_str = trl.translate(
                text, lang_tgt=dest_lang, lang_src=source_lang)
            message.reply_text(
                f"`{source_lang}` dilindən `{dest_lang}` dilinə tərcümə edildi:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Tərcümə ediləcək mətnə yanıt ver.\n\n"
            "Məsələn: `/tr en-ru` İngilis dilindən Rus dilinə tərcümə edir\n"
            "Və ya: `/tr en` İstənilən mətni İngilis dilinə tərcümə edir.\n"
            "[Dil kodları](t.me/OnePunchSupport/12823)",
            parse_mode="markdown",
            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text(
            "Dil tapılmadı!")
    else:
        return
Example #5
0
def totranslate(update: Update, _):
    msg = update.effective_message
    problem_lang_code = [key for key in languages if "-" in key]
    try:
        if msg.reply_to_message and msg.reply_to_message.text:

            args = update.effective_message.text.split(None, 1)
            text = msg.reply_to_message.text
            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except Exception:
                source_lang = "en"

            if source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang is None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')

            trl = translator()
            if source_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    f"Translated from `{detection.lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    f"Translated from `{source_lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN)
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            trl = Translator()
            if dest_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Reply to messages or write messages from other languages ​​for translating into the intended language\n\n"
            "Example: `/tr en ml` to translate from English to Malayalam\n"
            "Or use: `/tr ml` for automatic detection and translating it into Malayalam.\n"
            "See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.",
            parse_mode="markdown",
            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text(
            "The intended language is not found!")
    else:
        return
Example #6
0
def totranslate(bot: Bot, update: Update):
    msg = update.effective_message
    chat_id = update.effective_chat.id
    """
	lang = str("af,am,ar,az,be,bg,bn,bs,ca,ceb,co,cs,cy,da,de,el,en,eo,es,et,eu,fa,fi,fr,fy,ga,gd,gl,gu,ha,haw,hi,hmn,hr,ht,hu,hy,id,ig,is,it,iw,ja,jw,ka,kk,km,kn,ko,ku,ky,la,lb,lo,lt,lv,mg,mi,mk,ml,mn,mr,ms,mt,my,ne,nl,no,ny,pa,pl,ps,pt,ro,ru,sd,si,sk,sl,sm,sn,so,sq,sr,st,su,sv,sw,ta,te,tg,th,tl,tr,uk,ur,uz,vi,xh,yi,yo,zh,zh_CN,zh_TW,zu".split(","))
	try:
		if msg.reply_to_message and msg.reply_to_message.text:
			args = update.effective_message.text.split(None, 1)
			try:
				target = args[1].split(None, 1)[0]
			except:
				target = args[1]
			try:
				target2 = args[1].split(None, 2)[1]
				if target2 not in lang:
					target2 = None
				else:
					target = args[1].split(None, 2)[0]
					target2 = args[1].split(None, 2)[1]
			except:
				target2 = None
			text = msg.reply_to_message.text
			message = update.effective_message
			trl = Translator()
			if target2 == None:
				detection = trl.detect(text)
				tekstr = trl.translate(text, dest=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Translated from `{}` to `{}`:\n*Characters:*\n`{}`\n*Text:*\n`{}`".format(detection.lang, target, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			else:
				tekstr = trl.translate(text, dest=target2, src=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Translated from `{}` to `{}`:\n*Characters:*\n`{}`\n*Text:*\n`{}`".format(target, target2, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			
		else:
			args = update.effective_message.text.split(None, 2)
			target = args[1]
			try:
				target2 = args[2].split(None, 1)[0]
				if target2 not in lang:
					target2 = None
					text = args[2]
				else:
					target2 = args[2].split(None, 1)[0]
					text = args[2].split(None, 1)[1]
			except:
				target2 = None
				text = args[2]
			message = update.effective_message
			trl = Translator()
			if target2 == None:
				detection = trl.detect(text)
				tekstr = trl.translate(text, dest=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Translated from `{}` to `{}`:\n*Characters:*\n`{}`\n*Text:*\n`{}`".format(detection.lang, target, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			else:
				tekstr = trl.translate(text, dest=target2, src=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Translated from `{}` to `{}`:\n*Characters:*\n`{}`\n*Text:*\n`{}`".format(target, target2, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
	"""
    try:
        if msg.reply_to_message and msg.reply_to_message.text:
            args = update.effective_message.text.split(None, 1)
            target2 = None
            try:
                target = args[1].split(None, 1)[0]
            except:
                target = args[1]
            if "-" in target:
                target2 = target.split("-")[1]
                target = target.split("-")[0]
            text = msg.reply_to_message.text
            #text = deEmojify(text)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=target)
                if tekstr.pronunciation == None:
                    return message.reply_text(
                        "Translated from `{}` to `{}`:\n`{}`".format(
                            detection.lang, target, tekstr.text),
                        parse_mode=ParseMode.MARKDOWN)
                else:
                    return message.reply_text(
                        "Translated from `{}` to `{}`:\n`{}`".format(
                            detection.lang, target, tekstr.pronunciation),
                        parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=target2, src=target)
                if tekstr.pronunciation == None:
                    return message.reply_text(
                        "Translated from `{}` to `{}`:\n`{}`".format(
                            target, target2, tekstr.text),
                        parse_mode=ParseMode.MARKDOWN)
                else:
                    return message.reply_text(
                        "Translated from `{}` to `{}`:\n`{}`".format(
                            target, target2, tekstr.pronunciation),
                        parse_mode=ParseMode.MARKDOWN)

        else:
            args = update.effective_message.text.split(None, 2)
            target = args[1]
            text = args[2]
            #text = deEmojify(text)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            target2 = None
            if "-" in target:
                target2 = target.split("-")[1]
                target = target.split("-")[0]
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=target)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        detection.lang, target, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
                #if tekstr.pronunciation == None:
                #	return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
                #else:
                #	return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=target2, src=target)
                message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        target, target2, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
                #if tekstr.pronunciation == None:
                #	return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
                #else:
                #	return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Reply to messages or write messages from other languages ​​for translating into the intended language\n\nExample: `/tl en-ja` to translate from English to Japanese\nOr use: `/tl ja` for automatic detection and translating it into Japanese.",
            parse_mode="markdown")
    except ValueError:
        update.effective_message.reply_text(
            "The intended language is not found!")
    else:
        return
Example #7
0
def do_translate(bot: Bot, update: Update, args: List[str]):
    chat = update.effective_chat
    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)

    if msg.reply_to_message and (msg.reply_to_message.audio
                                 or msg.reply_to_message.voice) or (
                                     args and args[0] == 'animal'):
        reply = random.choice(tld_list(chat.id, 'translator_animal_lang'))

        if args:
            translation_type = "text"
        else:
            translation_type = "audio"

        msg.reply_text(tld(chat.id, 'translator_animal_translated').format(
            translation_type, reply),
                       parse_mode=ParseMode.MARKDOWN)
        return

    try:
        if msg.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if msg.reply_to_message.text:
                text = msg.reply_to_message.text
            elif msg.reply_to_message.caption:
                text = msg.reply_to_message.caption

            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang is None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')

            if source_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(tld(chat.id,
                                              "translator_translated").format(
                                                  detection.lang, dest_lang,
                                                  tekstr.text),
                                          parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(tld(chat.id,
                                       "translator_translated").format(
                                           source_lang, dest_lang,
                                           tekstr.text),
                                   parse_mode=ParseMode.MARKDOWN)
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]

            if dest_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(tld(chat.id,
                                              "translator_translated").format(
                                                  detection.lang, dest_lang,
                                                  tekstr.text),
                                          parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(tld(chat.id,
                                       "translator_translated").format(
                                           source_lang, dest_lang,
                                           tekstr.text),
                                   parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(tld(chat.id, "translator_no_args"),
                                            parse_mode="markdown",
                                            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text(tld(chat.id, "translator_err"))
    else:
        return
Example #8
0
def totranslate(bot: Bot, update: Update):

    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)
    try:
        if msg.reply_to_message and msg.reply_to_message.text:

            args = update.effective_message.text.split(None, 1)
            text = msg.reply_to_message.text
            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang == None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')

            trl = Translator()
            if source_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        detection.lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            trl = Translator()
            if dest_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Reply to messages or write messages from other languages ​​for translating into the intended language\n\nExample: `/tr en ml` to translate from English to Malayalam\nOr use: `/tr ml` for automatic detection and translating it into Malayalam.\nSee [List of Language Codes](https://telegra.ph/%C5%9E%E0%B8%AA%E2%84%9D%E0%B8%AA%D1%92-06-28) for a list of language codes.",
            parse_mode="markdown",
            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text(
            "The intended language is not found!")
    else:
        return
Example #9
0
def totranslate(update: Update, context: CallbackContext):
    message = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)

    try:
        if message.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if message.reply_to_message.text:
                text = message.reply_to_message.text
            elif message.reply_to_message.caption:
                text = message.reply_to_message.caption

            try:
                source_lang = args[1].split(None, 1)[0]
            except (IndexError, AttributeError):
                source_lang = "en"

        else:
            args = update.effective_message.text.split(None, 2)
            text = args[2]
            source_lang = args[1]

        if source_lang.count('-') == 2:
            for lang in problem_lang_code:
                if lang in source_lang:
                    if source_lang.startswith(lang):
                        dest_lang = source_lang.rsplit("-", 1)[1]
                        source_lang = source_lang.rsplit("-", 1)[0]
                    else:
                        dest_lang = source_lang.split("-", 1)[1]
                        source_lang = source_lang.split("-", 1)[0]
        elif source_lang.count('-') == 1:
            for lang in problem_lang_code:
                if lang in source_lang:
                    dest_lang = source_lang
                    source_lang = None
                    break
            if dest_lang is None:
                dest_lang = source_lang.split("-")[1]
                source_lang = source_lang.split("-")[0]
        else:
            dest_lang = source_lang
            source_lang = None

        exclude_list = UNICODE_EMOJI.keys()
        for emoji in exclude_list:
            if emoji in text:
                text = text.replace(emoji, '')

        trl = google_translator()
        if source_lang is None:
            detection = trl.detect(text)
            trans_str = trl.translate(text, lang_tgt=dest_lang)
            return message.reply_text(
                f"Translated from `{detection[0]}` to `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN)
        else:
            trans_str = trl.translate(text,
                                      lang_tgt=dest_lang,
                                      lang_src=source_lang)
            message.reply_text(
                f"Translated from `{source_lang}` to `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "İstədiyiniz dilə tərcümə etmək üçün mesajlara cavab verin və ya başqa dillərdən mesaj yazın\n\n"
            "Misal: `/ tr en-ml` İngilis dilindən Malayalam dilinə tərcümə etmək\n"
            "Və ya avtomatik aşkarlamaq və Malayalam dilinə tərcümə etmək üçün: /ml /ml istifadə edin.\n"
            "See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.",
            parse_mode="markdown",
            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text("İstədiyiniz dil tapılmadı!")
    else:
        return
Example #10
0
def terjemah(update, context):
    msg = update.effective_message
    chat_id = update.effective_chat.id
    getlang = langsql.get_lang(update.effective_message.from_user.id)
    try:
        if msg.reply_to_message and msg.reply_to_message.text:
            args = update.effective_message.text.split()
            if len(args) >= 2:
                target = args[1]
                if "-" in target:
                    target2 = target.split("-")[1]
                    target = target.split("-")[0]
                else:
                    target2 = None
            else:
                if getlang:
                    target = getlang
                    target2 = None
                else:
                    raise IndexError
            teks = msg.reply_to_message.text
            #teks = deEmojify(teks)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in teks:
                    teks = teks.replace(emoji, '')
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                deteksibahasa = trl.detect(teks)
                tekstr = trl.translate(teks, dest=target)
                send_message(
                    update.effective_message,
                    tl(update.effective_message,
                       "Diterjemahkan dari `{}` ke `{}`:\n`{}`").format(
                           deteksibahasa.lang, target, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(teks, dest=target2, src=target)
                send_message(
                    update.effective_message,
                    tl(update.effective_message,
                       "Diterjemahkan dari `{}` ke `{}`:\n`{}`").format(
                           target, target2, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)

        else:
            args = update.effective_message.text.split(None, 2)
            if len(args) != 1:
                target = args[1]
                teks = args[2]
                target2 = None
                if "-" in target:
                    target2 = target.split("-")[1]
                    target = target.split("-")[0]
            else:
                target = getlang
                teks = args[1]
            #teks = deEmojify(teks)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in teks:
                    teks = teks.replace(emoji, '')
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                deteksibahasa = trl.detect(teks)
                tekstr = trl.translate(teks, dest=target)
                return send_message(
                    update.effective_message,
                    tl(update.effective_message,
                       "Diterjemahkan dari `{}` ke `{}`:\n`{}`").format(
                           deteksibahasa.lang, target, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(teks, dest=target2, src=target)
                send_message(
                    update.effective_message,
                    tl(update.effective_message,
                       "Diterjemahkan dari `{}` ke `{}`:\n`{}`").format(
                           target, target2, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
    except IndexError:
        send_message(
            update.effective_message,
            tl(
                update.effective_message,
                "Balas pesan atau tulis pesan dari bahasa lain untuk "
                "diterjemahkan kedalam bahasa yang di dituju\n\n"
                "Contoh: `/tr en-id` untuk menerjemahkan dari Bahasa inggris ke Bahasa Indonesia\n"
                "Atau gunakan: `/tr id` untuk deteksi otomatis dan menerjemahkannya kedalam bahasa indonesia"
            ),
            parse_mode="markdown")
    except ValueError:
        send_message(
            update.effective_message,
            tl(update.effective_message,
               "Bahasa yang di tuju tidak ditemukan!"))
    else:
        return
HTML_RE = re.compile(r'<.*?>')

URLS_STRING = r"""(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))"""
URLS_STRING = r"((?<=[^a-zA-Z0-9])(?:https?\:\/\/|[a-zA-Z0-9]{1,}\.{1}|\b)(?:\w{1,}\.{1}){1,5}(?:com|org|edu|gov|uk|net|ca|de|jp|fr|au|us|ru|ch|it|nl|se|no|es|mil|iq|io|ac|ly|sm){1}(?:\/[a-zA-Z0-9]{1,})*)"
PHONE_NUMBER_STRING = "[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-\s\./0-9]*$"
MENTION_STRING = r"""\B\@[A-Za-z0-9_.](?:(?:[A-Za-z0-9_.]|(?:\\.(?!\\.))){0,28}(?:[A-Za-z0-9_.]))?"""
HASHTAG_STRING = r"""(?:\#+[\w_]+[\w\'_\-]*[\w_]+)"""
EMAIL_STRING = r"""[\w.+-]+@[\w-]+\.(?:[\w-]\.?)+[\w-]"""
# Remaining string : includes instagram username with this pattern : toto._.toto
ACCENTED_CHARACTERS = 'ÀàÁáÂâÃãÄäÇçÈèÉéÊêËëÌìÍíÎîÏïÑñÒòÓóÔôÕõÖöŠšÚùÛúÜûÙüÝýŸÿŽž'
REMAINING_STRING = r"""([A-Za-z0-9%s_](?:(?:[A-Za-z0-9%s_]|(?:\.(?!\.))){0,28}(?:[A-Za-z0-9%s_]))?)|(?:[^\W\d_](?:[^\W\d_]|['\-_])+[^\W\d_])|(?:[+\-]?\d+[,/.:-]\d+[+\-]?)|(?:[\w_]+)|(?:\.(?:\s*\.){1,})|(?:\S)""" % (
    ACCENTED_CHARACTERS, ACCENTED_CHARACTERS, ACCENTED_CHARACTERS)
PUNCTUATION = '!"$%&\'()*+,-./:;<=>?[\\]^_`{|}~•’@...”“'
MERGE_FIELD_STRING = r"""{{.*?}}"""
EMOJI_STRING = '[(' + '|'.join(
    list(UNICODE_EMOJI.keys())[:1035] +
    list(UNICODE_EMOJI.keys())[1037:]) + ')]+'

tokens_types = [
    'token', 'hashtag', 'mention', 'url', 'mail', 'merge_field', 'emoji'
]

REGEXP_STRINGS = {
    'hashtag': HASHTAG_STRING,
    'mention': MENTION_STRING,
    'url': URLS_STRING,
    'mail': EMAIL_STRING,
    'merge_field': MERGE_FIELD_STRING,
    'emoji': EMOJI_STRING,
    'token': REMAINING_STRING
}
Example #12
0
async def send_username_result(bot, event):
    try:
        start = datetime.now()
        userid = await get_id_from_forward(event)

        if userid == 0:
            return

        result = search_id(userid)

        if result is None:
            await event.reply("اطلاعات کاربر در دیتابیس سامانه شکار وجود ندارد ☹️")
            return

        end = datetime.now()


        total_search_time = end - start

        body = f"""
👤result: {result}
⏰search time: {total_search_time.total_seconds():.3f}s
"""

        await event.reply(body)        

    except:
        start_point = datetime.now()
        text = event.message.message

        string = list(text)

        for char in string:
            if char in UNICODE_EMOJI.keys():
                raise Exception("emoji in string")
        
        if "@" in text:
            text = str(text).split("@")[-1]

        await user_search_t(bot, event)
        is_id = text.isdigit()

        if is_id:
            result = search_id(text)

            if result is None:
                await event.reply("اطلاعات کاربر در دیتابیس سامانه شکار وجود ندارد ☹️")
                return

        else:
            result = search_username(text)

            if result is None:
                await event.reply(user_may_not_exists_text)
                return

        end_point = datetime.now()
        total_search_time = end_point - start_point

        body = f"""
👤result: {result}
⏰search time: {total_search_time.total_seconds():.3f}s
"""

        await event.reply(body)
Example #13
0
def totranslate(bot: Bot, update: Update):
    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)
    try:
        if msg.reply_to_message and msg.reply_to_message.text:

            args = update.effective_message.text.split(None, 1)
            text = msg.reply_to_message.text
            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang == None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')

            trl = Translator()
            if source_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    f"Translated from `{detection.lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    f"Translated from `{source_lang}` to `{dest_lang}`:\n`{tekstr.text}`",
                    parse_mode=ParseMode.MARKDOWN)
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, '')
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count('-') == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count('-') == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            trl = Translator()
            if dest_lang == None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Tarafından çevrildi `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Mesajları yanıtlayın veya istenen dile tercüme etmek için diğer dillerden mesajlar yazın\n\n"
            "Örnek: `/trtr ml` İngilizceden Malayalam diline çevirmek için\n"
            "Veya kullan: `/tr Otomatik algılama ve Malayalam'a tercüme için ml`.\n"
            "Gör [Dil Kodlarının Listesi](t.me/OnePunchSupport/12823) dil kodlarının listesi için.",
            parse_mode="markdown",
            disable_web_page_preview=True)
    except ValueError:
        update.effective_message.reply_text("Amaçlanan dil bulunamadı!")
    else:
        return
Example #14
0
from discord import Color, Embed
from discord.message import Message
from os import environ
from requests import get
from base64 import b64encode
from subprocess import run, PIPE
from datetime import datetime as t
from urllib.parse import quote_plus
from configparser import ConfigParser


class send_error_message(Exception):
    pass


emoji_unicodes = UNICODE_EMOJI.keys()
main_cfg = ConfigParser()
main_cfg.read('config.ini')


class emojiutils:
    def __init__(self):
        pass


def import_emoji_function(func):
    setattr(emojiutils, "emoji_to_url", func)


async def wait_for_message(ctx,
                           message,
Example #15
0
def totranslate(update: Update, context: CallbackContext):
    msg = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)
    try:
        if msg.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if msg.reply_to_message.text:
                text = msg.reply_to_message.text
            elif msg.reply_to_message.caption:
                text = msg.reply_to_message.caption

            message = update.effective_message
            dest_lang = None

            try:
                source_lang = args[1].split(None, 1)[0]
            except:
                source_lang = "en"

            if source_lang.count("-") == 2:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        if source_lang.startswith(lang):
                            dest_lang = source_lang.rsplit("-", 1)[1]
                            source_lang = source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = source_lang.split("-", 1)[1]
                            source_lang = source_lang.split("-", 1)[0]
            elif source_lang.count("-") == 1:
                for lang in problem_lang_code:
                    if lang in source_lang:
                        dest_lang = source_lang
                        source_lang = None
                        break
                if dest_lang is None:
                    dest_lang = source_lang.split("-")[1]
                    source_lang = source_lang.split("-")[0]
            else:
                dest_lang = source_lang
                source_lang = None

            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, "")

            trl = Translator()
            if source_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=dest_lang)
                return message.reply_text(
                    f"Translated from `{detection.lang}` to `{dest_lang}`:\n{tekstr.text}",
                    parse_mode=ParseMode.MARKDOWN,
                )
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    f"Translated from `{source_lang}` to `{dest_lang}`:\n{tekstr.text}",
                    parse_mode=ParseMode.MARKDOWN,
                )
        else:
            args = update.effective_message.text.split(None, 2)
            message = update.effective_message
            source_lang = args[1]
            text = args[2]
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in text:
                    text = text.replace(emoji, "")
            dest_lang = None
            temp_source_lang = source_lang
            if temp_source_lang.count("-") == 2:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        if temp_source_lang.startswith(lang):
                            dest_lang = temp_source_lang.rsplit("-", 1)[1]
                            source_lang = temp_source_lang.rsplit("-", 1)[0]
                        else:
                            dest_lang = temp_source_lang.split("-", 1)[1]
                            source_lang = temp_source_lang.split("-", 1)[0]
            elif temp_source_lang.count("-") == 1:
                for lang in problem_lang_code:
                    if lang in temp_source_lang:
                        dest_lang = None
                        break
                    else:
                        dest_lang = temp_source_lang.split("-")[1]
                        source_lang = temp_source_lang.split("-")[0]
            trl = Translator()
            if dest_lang is None:
                detection = trl.detect(text)
                tekstr = trl.translate(text, dest=source_lang)
                return message.reply_text(
                    "Translated from `{}` to `{}`:\n{}".format(
                        detection.lang, source_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN,
                )
            else:
                tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
                message.reply_text(
                    "Translated from `{}` to `{}`:\n`{}`".format(
                        source_lang, dest_lang, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN,
                )

    except IndexError:
        update.effective_message.reply_text(
            "Reply to messages or write messages from other languages ​​for translating into the intended language\n\n"
            "Example: `/tr en-si` to translate from English to Sinhala\n"
            "Or use: `/tr si` for automatic detection and translating it into Sinhala.\n"
            "See [List of Language Codes](t.me/HiTechRockets/5) for a list of language codes.",
            parse_mode="markdown",
            disable_web_page_preview=True,
        )
    except ValueError:
        update.effective_message.reply_text(
            "The intended language is not found!")
    else:
        return
Example #16
0
def terjemah(bot: Bot, update: Update):
    spam = spamfilters(update.effective_message.text,
                       update.effective_message.from_user.id,
                       update.effective_chat.id)
    if spam == True:
        return update.effective_message.reply_text(
            "Saya kecewa dengan anda, saya tidak akan mendengar kata-kata anda sekarang!"
        )
    msg = update.effective_message
    chat_id = update.effective_chat.id
    """
	lang = str("af,am,ar,az,be,bg,bn,bs,ca,ceb,co,cs,cy,da,de,el,en,eo,es,et,eu,fa,fi,fr,fy,ga,gd,gl,gu,ha,haw,hi,hmn,hr,ht,hu,hy,id,ig,is,it,iw,ja,jw,ka,kk,km,kn,ko,ku,ky,la,lb,lo,lt,lv,mg,mi,mk,ml,mn,mr,ms,mt,my,ne,nl,no,ny,pa,pl,ps,pt,ro,ru,sd,si,sk,sl,sm,sn,so,sq,sr,st,su,sv,sw,ta,te,tg,th,tl,tr,uk,ur,uz,vi,xh,yi,yo,zh,zh_CN,zh_TW,zu".split(","))
	try:
		if msg.reply_to_message and msg.reply_to_message.text:
			args = update.effective_message.text.split(None, 1)
			try:
				target = args[1].split(None, 1)[0]
			except:
				target = args[1]
			try:
				target2 = args[1].split(None, 2)[1]
				if target2 not in lang:
					target2 = None
				else:
					target = args[1].split(None, 2)[0]
					target2 = args[1].split(None, 2)[1]
			except:
				target2 = None
			teks = msg.reply_to_message.text
			message = update.effective_message
			trl = Translator()
			if target2 == None:
				deteksibahasa = trl.detect(teks)
				tekstr = trl.translate(teks, dest=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(deteksibahasa.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n*Aksara:*\n`{}`\n*Teks:*\n`{}`".format(deteksibahasa.lang, target, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			else:
				tekstr = trl.translate(teks, dest=target2, src=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n*Aksara:*\n`{}`\n*Teks:*\n`{}`".format(target, target2, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			
		else:
			args = update.effective_message.text.split(None, 2)
			target = args[1]
			try:
				target2 = args[2].split(None, 1)[0]
				if target2 not in lang:
					target2 = None
					teks = args[2]
				else:
					target2 = args[2].split(None, 1)[0]
					teks = args[2].split(None, 1)[1]
			except:
				target2 = None
				teks = args[2]
			message = update.effective_message
			trl = Translator()
			if target2 == None:
				deteksibahasa = trl.detect(teks)
				tekstr = trl.translate(teks, dest=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(deteksibahasa.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n*Aksara:*\n`{}`\n*Teks:*\n`{}`".format(deteksibahasa.lang, target, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
			else:
				tekstr = trl.translate(teks, dest=target2, src=target)
				if tekstr.pronunciation == None:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
				else:
					return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n*Aksara:*\n`{}`\n*Teks:*\n`{}`".format(target, target2, tekstr.text, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
	"""
    try:
        if msg.reply_to_message and msg.reply_to_message.text:
            args = update.effective_message.text.split(None, 1)
            target2 = None
            try:
                target = args[1].split(None, 1)[0]
            except:
                target = args[1]
            if "-" in target:
                target2 = target.split("-")[1]
                target = target.split("-")[0]
            teks = msg.reply_to_message.text
            #teks = deEmojify(teks)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in teks:
                    teks = teks.replace(emoji, '')
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                deteksibahasa = trl.detect(teks)
                tekstr = trl.translate(teks, dest=target)
                if tekstr.pronunciation == None:
                    return message.reply_text(
                        "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                            deteksibahasa.lang, target, tekstr.text),
                        parse_mode=ParseMode.MARKDOWN)
                else:
                    return message.reply_text(
                        "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                            deteksibahasa.lang, target, tekstr.pronunciation),
                        parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(teks, dest=target2, src=target)
                if tekstr.pronunciation == None:
                    return message.reply_text(
                        "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                            target, target2, tekstr.text),
                        parse_mode=ParseMode.MARKDOWN)
                else:
                    return message.reply_text(
                        "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                            target, target2, tekstr.pronunciation),
                        parse_mode=ParseMode.MARKDOWN)

        else:
            args = update.effective_message.text.split(None, 2)
            target = args[1]
            teks = args[2]
            #teks = deEmojify(teks)
            exclude_list = UNICODE_EMOJI.keys()
            for emoji in exclude_list:
                if emoji in teks:
                    teks = teks.replace(emoji, '')
            target2 = None
            if "-" in target:
                target2 = target.split("-")[1]
                target = target.split("-")[0]
            message = update.effective_message
            trl = Translator()
            if target2 == None:
                deteksibahasa = trl.detect(teks)
                tekstr = trl.translate(teks, dest=target)
                return message.reply_text(
                    "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                        deteksibahasa.lang, target, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
                #if tekstr.pronunciation == None:
                #	return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(deteksibahasa.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
                #else:
                #	return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(deteksibahasa.lang, target, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
            else:
                tekstr = trl.translate(teks, dest=target2, src=target)
                message.reply_text(
                    "Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(
                        target, target2, tekstr.text),
                    parse_mode=ParseMode.MARKDOWN)
                #if tekstr.pronunciation == None:
                #	return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
                #else:
                #	return message.reply_text("Diterjemahkan dari `{}` ke `{}`:\n`{}`".format(target, target2, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)

    except IndexError:
        update.effective_message.reply_text(
            "Balas pesan atau tulis pesan dari bahasa lain untuk "
            "diterjemahkan kedalam bahasa yang di dituju\n\n"
            "Contoh: `/tr en-id` untuk menerjemahkan dari Bahasa inggris ke Bahasa Indonesia\n"
            "Atau gunakan: `/tr id` untuk deteksi otomatis dan menerjemahkannya kedalam bahasa indonesia",
            parse_mode="markdown")
    except ValueError:
        update.effective_message.reply_text(
            "Bahasa yang di tuju tidak ditemukan!")
    else:
        return
class TwitterIQ(dict):
    """
	This class creates an inverted index of a .csv file
	that contains information and content from a number of tweets.

	This class inherits from the default dictionary class in Python.
	This was done primarily to utilize the __missing__ function,
	which serves to make the code a bit more Pythonic. The class loads
	each token individually and uses the __missing__ method to determine
	whether it is already in the dictionary (self). In the case the it
	is, the id of the particular tweet/doc is added to the relevant
	postings list.

	Query methods are detailed in their respective methods' docstrings.

	Attributes:
		all_postings: List containing ALL postings lists
		tweet_content_dict: Dictionary whose keys are twitter_ids
			pointing to the content of the tokenized tweets.
		__current_tweet_id: ID of the doc/tweet that is currently
			being iterated over. This is used by the __missing__ method
			to propery organize the dictionary
	"""

    STOP_WORDS = stopwords.words('english') + stopwords.words('german')
    EXCLUSION_LIST = list(punctuation) + list(
        UNICODE_EMOJI.keys()) + ['...', 'de', 'com']

    def __init__(self, path: str = None, strip_handles: bool = True, **kwargs):
        """
		Initializes by walking through each token and creating an
		inverted index as detailed above.

		:param str path: the path to the string
		"""
        super().__init__(**kwargs)
        self.all_postings = []
        self.tweet_content_dict = {}
        self.tokenizer = TweetTokenizer(strip_handles=strip_handles)
        self.__indexing = False
        self.length = 0

        if path:
            self.index(path)

    def __missing__(self, token: str):
        """
		If entry is missing, add posting to all_postings, then creates
		a PostingNode and sets the entry to equal that value.

		:param str token: The token to be added to the dictionary
		:return: posting
		"""
        if self.__indexing:
            self.all_postings.append([self.length])
            self[token] = PostingNode(self.all_postings[-1])
            return self[token]
        else:
            return PostingNode([])

    def __index_tokens(self, tweet_content: list) -> None:
        """
		Walks the the list of tokens from each tweet. If a token
		is not clean, it exits without adding an entry. It then
		adds to (or uses the __missing__ method to create) the
		dictionary (self) entry for each token. It then adds to the
		posting list of each token.

		:param list tweet_content: a list of tokens from tweet
		:returns: None
		"""
        for token in tweet_content:
            token = self.__clean(token)
            if not token:
                return

            # creates entry or assigns posting_node to existing one
            posting_node = self[token]
            if self.length not in posting_node.postings_list:
                # adds to end of posting list and increments freq
                posting_node.postings_list.append(self.length)
                posting_node.freq += 1

    def __clean(self, token: str) -> Union[str, None]:
        """
		Removes stop words for English and German and makes
		all tokens lowercase.

		:param str token: the token to be cleaned
		:return: The token if it can be cleaned, None if not
		:rtype: str
		"""

        if token in TwitterIQ.EXCLUSION_LIST or token.startswith(('http')):
            return

        if token.startswith('#'):
            token = token[1:]

        token = token.lower()

        if token in TwitterIQ.STOP_WORDS:
            return

        return token

    def get_tokens_from_tweet(self, tweet_id: int) -> str:
        """
		Returns the tokens from a specific tweet/doc ID

		:param int tweet_id: the tweet to be returned
		:return: a list of tokens from a tweet
		:rtype: List[str]
		"""
        return self.tweet_content_dict[tweet_id]

    def get_most_freq_words(self, n: int = 10) -> List[str]:
        """
		Returns the words with the three largest frequencies.

		:param int n: the optional n number of words to return
		:return: the most frequently used words in the corpus
		:rtype: list
		"""
        return heapq.nlargest(n, self, key=lambda x: self[x])

    def index(self, path: str) -> None:
        self.__indexing = True

        with open(path, 'r') as corpus:
            # combs through each doc/tweet individually

            for doc in corpus:
                raw_tweet = doc.split('\t')[4]
                self.tweet_content_dict[self.length] = raw_tweet
                tokenized_doc = self.tokenizer.tokenize(raw_tweet)

                self.__index_tokens(tokenized_doc)
                self.length += 1

        self.__indexing = False

    def query(self, term1: str, term2: str = None) -> List[int]:
        """
		Gets the postings list for a term or the intersection or the
		posting lists of two different terms.

		:param str term1: the first (or only) string to query
		:param str term2: the optione 2nd string to intersect with
		:return: the positings list or intersection of two
		"""
        if term2 is None:
            return self[term1].postings_list
        else:
            return list(set(self.query(term1)) & set(self.query(term2)))

    def print_query(self, term1: str, term2: str = None) -> None:
        """
		Pretty prints the query method.

		:param str term1: the first term to query
		:param str term2: the optional second term to intersect with
		"""
        for tweet_id in self.query(term1, term2):
            print(f'{tweet_id}:', self.tweet_content_dict[tweet_id])

    def __len__(self):
        return self.length
Example #18
0
def totranslate(update: Update, context: CallbackContext):
    message = update.effective_message
    problem_lang_code = []
    for key in LANGUAGES:
        if "-" in key:
            problem_lang_code.append(key)

    try:
        if message.reply_to_message:
            args = update.effective_message.text.split(None, 1)
            if message.reply_to_message.text:
                text = message.reply_to_message.text
            elif message.reply_to_message.caption:
                text = message.reply_to_message.caption

            try:
                source_lang = args[1].split(None, 1)[0]
            except (IndexError, AttributeError):
                source_lang = "en"

        else:
            args = update.effective_message.text.split(None, 2)
            text = args[2]
            source_lang = args[1]

        if source_lang.count("-") == 2:
            for lang in problem_lang_code:
                if lang in source_lang:
                    if source_lang.startswith(lang):
                        dest_lang = source_lang.rsplit("-", 1)[1]
                        source_lang = source_lang.rsplit("-", 1)[0]
                    else:
                        dest_lang = source_lang.split("-", 1)[1]
                        source_lang = source_lang.split("-", 1)[0]
        elif source_lang.count("-") == 1:
            for lang in problem_lang_code:
                if lang in source_lang:
                    dest_lang = source_lang
                    source_lang = None
                    break
            if dest_lang is None:
                dest_lang = source_lang.split("-")[1]
                source_lang = source_lang.split("-")[0]
        else:
            dest_lang = source_lang
            source_lang = None

        exclude_list = UNICODE_EMOJI.keys()
        for emoji in exclude_list:
            if emoji in text:
                text = text.replace(emoji, "")

        trl = google_translator()
        if source_lang is None:
            detection = trl.detect(text)
            trans_str = trl.translate(text, lang_tgt=dest_lang)
            return message.reply_text(
                f"Translated from `{detection[0]}` to `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN,
            )
        else:
            trans_str = trl.translate(text, lang_tgt=dest_lang, lang_src=source_lang)
            message.reply_text(
                f"Translated from `{source_lang}` to `{dest_lang}`:\n`{trans_str}`",
                parse_mode=ParseMode.MARKDOWN,
            )

    except IndexError:
        update.effective_message.reply_text(
            "Reply to messages or write messages from other languages ​​for translating into the intended language\n\n"
            "Example: `/tr en-ml` to translate from English to Malayalam\n"
            "Or use: `/tr ml` for automatic detection and translating it into Malayalam.\n"
            "See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.",
            parse_mode="markdown",
            disable_web_page_preview=True,
        )
    except ValueError:
        update.effective_message.reply_text("The intended language is not found!")
    else:
        return
Example #19
0
def contains_emoji(text):
    for e in UNICODE_EMOJI.keys():
        if e in text:
            return True
    return False