Polyglot-Interlayer/googlefreeapi.py at main · Allnorm/Polyglot-Interlayer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import sys
import time
import traceback
import logging

import httpcore
from googletrans import Translator, LANGUAGES


class Interlayer:

    translator: Translator
    lang_list = {}

    class BadTrgLangException(Exception):
        pass

    class TooManyRequestException(Exception):
        pass

    class EqualLangsException(Exception):
        pass

    class BadSrcLangException(Exception):
        pass

    class TooLongMsg(Exception):
        pass

    class UnkTransException(Exception):
        pass

    class LangDetectException(Exception):
        pass

    class UnknownLang(Exception):
        pass

    @staticmethod
    def init_dialog_api(config):
        return config

    @staticmethod
    def api_init(config):

        version = "1.3 for py-googletrans 4.0.0rc1 (freeapi)"
        build_date = "04.12.2022"
        version_polyglot = "1.4.4"
        logging.info("Interlayer version {} build date {}".format(version, build_date))
        logging.info("Compatible with version of Polyglot {}".format(version_polyglot))

        return config

    def translate_init(self):

        try:
            self.translator = Translator()
        except Exception as e:
            logging.error("translator object wasn't created successful! Bot will close!")
            logging.error(str(e) + "\n" + traceback.format_exc())
            sys.exit(1)

    def extract_lang(self, text):
        try:
            return self.translator.detect(text).lang.lower()
        except (AttributeError, httpcore._exceptions.ReadError):
            logging.error("GOOGLE_API_REJECT (in lang extract)")
            raise self.LangDetectException
        except Exception as e:
            logging.error(str(e) + "\n" + traceback.format_exc())
            raise self.LangDetectException

    def list_of_langs(self):

        self.lang_list = LANGUAGES

    def get_translate(self, input_text: str, target_lang: str, distorting=False, src_lang=None):

        if src_lang is None:
            src_lang = "auto"
        if target_lang is None:
            raise self.BadTrgLangException

        try:
            trans_result = self.translator.translate(input_text, target_lang, src_lang).text
        except (AttributeError, httpcore._exceptions.ReadError):
            if distorting:
                time.sleep(10)
                try:
                    trans_result = self.translator.translate(input_text, target_lang, src_lang).text
                except (AttributeError, httpcore._exceptions.ReadError):
                    logging.error("GOOGLE_API_REJECT")
                    raise self.TooManyRequestException
            else:
                logging.error("GOOGLE_API_REJECT")
                raise self.TooManyRequestException
        except Exception as e:
            if str(e) in "invalid destination language":
                raise self.BadTrgLangException
            if str(e) in "invalid source language":
                raise self.BadSrcLangException
            else:
                logging.error(str(e) + "\n" + traceback.format_exc())
                raise self.UnkTransException

        if len(trans_result) > 4096 and distorting is False:
            logging.warning("too long message for sending.")
            raise self.TooLongMsg

        return trans_result