Merge branch 'master' into feature/tencent

deep_translator/__init__.py

@@ -2,6 +2,7 @@
 
 __copyright__ = "Copyright (C) 2020 Nidhal Baccouri"
 
+from deep_translator.baidu import BaiduTranslator
 from deep_translator.chatgpt import ChatGptTranslator
 from deep_translator.deepl import DeeplTranslator
 from deep_translator.detection import batch_detection, single_detection
@@ -33,6 +34,7 @@ __all__ = [
     "PapagoTranslator",
     "ChatGptTranslator",
     "TencentTranslator",
+    "BaiduTranslator",
     "single_detection",
     "batch_detection",
 ]

deep_translator/baidu.py

@@ -0,0 +1,120 @@
+"""
+baidu translator API
+"""
+
+__copyright__ = "Copyright (C) 2020 Nidhal Baccouri"
+
+import hashlib
+import os
+import random
+from typing import List, Optional
+
+import requests
+
+from deep_translator.base import BaseTranslator
+from deep_translator.constants import (
+    BAIDU_APPID_ENV_VAR,
+    BAIDU_APPKEY_ENV_VAR,
+    BAIDU_LANGUAGE_TO_CODE,
+    BASE_URLS,
+)
+from deep_translator.exceptions import (
+    ApiKeyException,
+    BaiduAPIerror,
+    ServerException,
+    TranslationNotFound,
+)
+from deep_translator.validate import is_empty, is_input_valid
+
+
+class BaiduTranslator(BaseTranslator):
+    """
+    class that wraps functions, which use the BaiduTranslator translator
+    under the hood to translate word(s)
+    """
+
+    def __init__(
+        self,
+        source: str = "en",
+        target: str = "zh",
+        appid: Optional[str] = os.getenv(BAIDU_APPID_ENV_VAR, None),
+        appkey: Optional[str] = os.getenv(BAIDU_APPKEY_ENV_VAR, None),
+        **kwargs
+    ):
+        """
+        @param appid: your baidu cloud api appid.
+        Get one here: https://fanyi-api.baidu.com/choose
+        @param appkey: your baidu cloud api appkey.
+        @param source: source language
+        @param target: target language
+        """
+        if not appid:
+            raise ApiKeyException(env_var=BAIDU_APPID_ENV_VAR)
+
+        if not appkey:
+            raise ApiKeyException(env_var=BAIDU_APPKEY_ENV_VAR)
+
+        self.appid = appid
+        self.appkey = appkey
+        super().__init__(
+            base_url=BASE_URLS.get("BAIDU"),
+            source=source,
+            target=target,
+            languages=BAIDU_LANGUAGE_TO_CODE,
+            **kwargs
+        )
+
+    def translate(self, text: str, **kwargs) -> str:
+        """
+        @param text: text to translate
+        @return: translated text
+        """
+        if is_input_valid(text):
+            if self._same_source_target() or is_empty(text):
+                return text
+
+            # Create the request parameters.
+            salt = random.randint(32768, 65536)
+            sign = hashlib.md5(
+                (self.appid + text + str(salt) + self.appkey).encode("utf-8")
+            ).hexdigest()
+            headers = {"Content-Type": "application/x-www-form-urlencoded"}
+            payload = {
+                "appid": self.appid,
+                "q": text,
+                "from": self.source,
+                "to": self.target,
+                "salt": salt,
+                "sign": sign,
+            }
+
+            # Do the request and check the connection.
+            try:
+                response = requests.post(
+                    self._base_url, params=payload, headers=headers
+                )
+            except ConnectionError:
+                raise ServerException(503)
+            if response.status_code != 200:
+                raise ServerException(response.status_code)
+            # Get the response and check is not empty.
+            res = response.json()
+            if not res:
+                raise TranslationNotFound(text)
+            # Process and return the response.
+            if "error_code" in res:
+                raise BaiduAPIerror(res["error_msg"])
+            if "trans_result" in res:
+                return "\n".join([s["dst"] for s in res["trans_result"]])
+            else:
+                raise TranslationNotFound(text)
+
+    def translate_file(self, path: str, **kwargs) -> str:
+        return self._translate_file(path, **kwargs)
+
+    def translate_batch(self, batch: List[str], **kwargs) -> List[str]:
+        """
+        @param batch: list of texts to translate
+        @return: list of translations
+        """
+        return self._translate_batch(batch, **kwargs)

deep_translator/constants.py

@@ -9,6 +9,8 @@ QCRI_ENV_VAR = "QCRI_API_KEY"
 YANDEX_ENV_VAR = "YANDEX_API_KEY"
 TENCENT_SECRET_ID_ENV_VAR = "TENCENT_SECRET_ID"
 TENCENT_SECRET_KEY_ENV_VAR = "TENCENT_SECRET_KEY"
+BAIDU_APPID_ENV_VAR = "BAIDU_APPID"
+BAIDU_APPKEY_ENV_VAR = "BAIDU_APPKEY"
 
 
 BASE_URLS = {
@@ -26,6 +28,7 @@ BASE_URLS = {
     "LIBRE": "https://libretranslate.com/",
     "LIBRE_FREE": "https://libretranslate.de/",
     "TENENT": "https://tmt.tencentcloudapi.com",
+    "BAIDU": "https://fanyi-api.baidu.com/api/trans/vip/translate",
 }
 
 GOOGLE_LANGUAGES_TO_CODES = {
@@ -219,6 +222,331 @@ LINGUEE_LANGUAGES_TO_CODES = {
     "japanese": "japanese",
 }
 
+MY_MEMORY_LANGUAGES_TO_CODES = {
+    "acehnese": "ace-ID",
+    "afrikaans": "af-ZA",
+    "akan": "ak-GH",
+    "albanian": "sq-AL",
+    "amharic": "am-ET",
+    "antigua and barbuda creole english": "aig-AG",
+    "arabic": "ar-SA",
+    "arabic egyptian": "ar-EG",
+    "aragonese": "an-ES",
+    "armenian": "hy-AM",
+    "assamese": "as-IN",
+    "asturian": "ast-ES",
+    "austrian german": "de-AT",
+    "awadhi": "awa-IN",
+    "ayacucho quechua": "quy-PE",
+    "azerbaijani": "az-AZ",
+    "bahamas creole english": "bah-BS",
+    "bajan": "bjs-BB",
+    "balinese": "ban-ID",
+    "balkan gipsy": "rm-RO",
+    "bambara": "bm-ML",
+    "banjar": "bjn-ID",
+    "bashkir": "ba-RU",
+    "basque": "eu-ES",
+    "belarusian": "be-BY",
+    "belgian french": "fr-BE",
+    "bemba": "bem-ZM",
+    "bengali": "bn-IN",
+    "bhojpuri": "bho-IN",
+    "bihari": "bh-IN",
+    "bislama": "bi-VU",
+    "borana": "gax-KE",
+    "bosnian": "bs-BA",
+    "bosnian (cyrillic)": "bs-Cyrl-BA",
+    "breton": "br-FR",
+    "buginese": "bug-ID",
+    "bulgarian": "bg-BG",
+    "burmese": "my-MM",
+    "catalan": "ca-ES",
+    "catalan valencian": "cav-ES",
+    "cebuano": "ceb-PH",
+    "central atlas tamazight": "tzm-MA",
+    "central aymara": "ayr-BO",
+    "central kanuri (latin script)": "knc-NG",
+    "chadian arabic": "shu-TD",
+    "chamorro": "ch-GU",
+    "cherokee": "chr-US",
+    "chhattisgarhi": "hne-IN",
+    "chinese simplified": "zh-CN",
+    "chinese trad. (hong kong)": "zh-HK",
+    "chinese traditional": "zh-TW",
+    "chinese traditional macau": "zh-MO",
+    "chittagonian": "ctg-BD",
+    "chokwe": "cjk-AO",
+    "classical greek": "grc-GR",
+    "comorian ngazidja": "zdj-KM",
+    "coptic": "cop-EG",
+    "crimean tatar": "crh-RU",
+    "crioulo upper guinea": "pov-GW",
+    "croatian": "hr-HR",
+    "czech": "cs-CZ",
+    "danish": "da-DK",
+    "dari": "prs-AF",
+    "dimli": "diq-TR",
+    "dutch": "nl-NL",
+    "dyula": "dyu-CI",
+    "dzongkha": "dz-BT",
+    "eastern yiddish": "ydd-US",
+    "emakhuwa": "vmw-MZ",
+    "english": "en-GB",
+    "english australia": "en-AU",
+    "english canada": "en-CA",
+    "english india": "en-IN",
+    "english ireland": "en-IE",
+    "english new zealand": "en-NZ",
+    "english singapore": "en-SG",
+    "english south africa": "en-ZA",
+    "english us": "en-US",
+    "esperanto": "eo-EU",
+    "estonian": "et-EE",
+    "ewe": "ee-GH",
+    "fanagalo": "fn-FNG",
+    "faroese": "fo-FO",
+    "fijian": "fj-FJ",
+    "filipino": "fil-PH",
+    "finnish": "fi-FI",
+    "flemish": "nl-BE",
+    "fon": "fon-BJ",
+    "french": "fr-FR",
+    "french canada": "fr-CA",
+    "french swiss": "fr-CH",
+    "friulian": "fur-IT",
+    "fula": "ff-FUL",
+    "galician": "gl-ES",
+    "gamargu": "mfi-NG",
+    "garo": "grt-IN",
+    "georgian": "ka-GE",
+    "german": "de-DE",
+    "gilbertese": "gil-KI",
+    "glavda": "glw-NG",
+    "greek": "el-GR",
+    "grenadian creole english": "gcl-GD",
+    "guarani": "gn-PY",
+    "gujarati": "gu-IN",
+    "guyanese creole english": "gyn-GY",
+    "haitian creole french": "ht-HT",
+    "halh mongolian": "khk-MN",
+    "hausa": "ha-NE",
+    "hawaiian": "haw-US",
+    "hebrew": "he-IL",
+    "higi": "hig-NG",
+    "hiligaynon": "hil-PH",
+    "hill mari": "mrj-RU",
+    "hindi": "hi-IN",
+    "hmong": "hmn-CN",
+    "hungarian": "hu-HU",
+    "icelandic": "is-IS",
+    "igbo ibo": "ibo-NG",
+    "igbo ig": "ig-NG",
+    "ilocano": "ilo-PH",
+    "indonesian": "id-ID",
+    "inuktitut greenlandic": "kl-GL",
+    "irish gaelic": "ga-IE",
+    "italian": "it-IT",
+    "italian swiss": "it-CH",
+    "jamaican creole english": "jam-JM",
+    "japanese": "ja-JP",
+    "javanese": "jv-ID",
+    "jingpho": "kac-MM",
+    "k'iche'": "quc-GT",
+    "kabiyè": "kbp-TG",
+    "kabuverdianu": "kea-CV",
+    "kabylian": "kab-DZ",
+    "kalenjin": "kln-KE",
+    "kamba": "kam-KE",
+    "kannada": "kn-IN",
+    "kanuri": "kr-KAU",
+    "karen": "kar-MM",
+    "kashmiri (devanagari script)": "ks-IN",
+    "kashmiri (arabic script)": "kas-IN",
+    "kazakh": "kk-KZ",
+    "khasi": "kha-IN",
+    "khmer": "km-KH",
+    "kikuyu kik": "kik-KE",
+    "kikuyu ki": "ki-KE",
+    "kimbundu": "kmb-AO",
+    "kinyarwanda": "rw-RW",
+    "kirundi": "rn-BI",
+    "kisii": "guz-KE",
+    "kongo": "kg-CG",
+    "konkani": "kok-IN",
+    "korean": "ko-KR",
+    "northern kurdish": "kmr-TR",
+    "kurdish sorani": "ckb-IQ",
+    "kyrgyz": "ky-KG",
+    "lao": "lo-LA",
+    "latgalian": "ltg-LV",
+    "latin": "la-XN",
+    "latvian": "lv-LV",
+    "ligurian": "lij-IT",
+    "limburgish": "li-NL",
+    "lingala": "ln-LIN",
+    "lithuanian": "lt-LT",
+    "lombard": "lmo-IT",
+    "luba-kasai": "lua-CD",
+    "luganda": "lg-UG",
+    "luhya": "luy-KE",
+    "luo": "luo-KE",
+    "luxembourgish": "lb-LU",
+    "maa": "mas-KE",
+    "macedonian": "mk-MK",
+    "magahi": "mag-IN",
+    "maithili": "mai-IN",
+    "malagasy": "mg-MG",
+    "malay": "ms-MY",
+    "malayalam": "ml-IN",
+    "maldivian": "dv-MV",
+    "maltese": "mt-MT",
+    "mandara": "mfi-CM",
+    "manipuri": "mni-IN",
+    "manx gaelic": "gv-IM",
+    "maori": "mi-NZ",
+    "marathi": "mr-IN",
+    "margi": "mrt-NG",
+    "mari": "mhr-RU",
+    "marshallese": "mh-MH",
+    "mende": "men-SL",
+    "meru": "mer-KE",
+    "mijikenda": "nyf-KE",
+    "minangkabau": "min-ID",
+    "mizo": "lus-IN",
+    "mongolian": "mn-MN",
+    "montenegrin": "sr-ME",
+    "morisyen": "mfe-MU",
+    "moroccan arabic": "ar-MA",
+    "mossi": "mos-BF",
+    "ndau": "ndc-MZ",
+    "ndebele": "nr-ZA",
+    "nepali": "ne-NP",
+    "nigerian fulfulde": "fuv-NG",
+    "niuean": "niu-NU",
+    "north azerbaijani": "azj-AZ",
+    "sesotho": "nso-ZA",
+    "northern uzbek": "uzn-UZ",
+    "norwegian bokmål": "nb-NO",
+    "norwegian nynorsk": "nn-NO",
+    "nuer": "nus-SS",
+    "nyanja": "ny-MW",
+    "occitan": "oc-FR",
+    "occitan aran": "oc-ES",
+    "odia": "or-IN",
+    "oriya": "ory-IN",
+    "urdu": "ur-PK",
+    "palauan": "pau-PW",
+    "pali": "pi-IN",
+    "pangasinan": "pag-PH",
+    "papiamentu": "pap-CW",
+    "pashto": "ps-PK",
+    "persian": "fa-IR",
+    "pijin": "pis-SB",
+    "plateau malagasy": "plt-MG",
+    "polish": "pl-PL",
+    "portuguese": "pt-PT",
+    "portuguese brazil": "pt-BR",
+    "potawatomi": "pot-US",
+    "punjabi": "pa-IN",
+    "punjabi (pakistan)": "pnb-PK",
+    "quechua": "qu-PE",
+    "rohingya": "rhg-MM",
+    "rohingyalish": "rhl-MM",
+    "romanian": "ro-RO",
+    "romansh": "roh-CH",
+    "rundi": "run-BI",
+    "russian": "ru-RU",
+    "saint lucian creole french": "acf-LC",
+    "samoan": "sm-WS",
+    "sango": "sg-CF",
+    "sanskrit": "sa-IN",
+    "santali": "sat-IN",
+    "sardinian": "sc-IT",
+    "scots gaelic": "gd-GB",
+    "sena": "seh-ZW",
+    "serbian cyrillic": "sr-Cyrl-RS",
+    "serbian latin": "sr-Latn-RS",
+    "seselwa creole french": "crs-SC",
+    "setswana (south africa)": "tn-ZA",
+    "shan": "shn-MM",
+    "shona": "sn-ZW",
+    "sicilian": "scn-IT",
+    "silesian": "szl-PL",
+    "sindhi snd": "snd-PK",
+    "sindhi sd": "sd-PK",
+    "sinhala": "si-LK",
+    "slovak": "sk-SK",
+    "slovenian": "sl-SI",
+    "somali": "so-SO",
+    "sotho southern": "st-LS",
+    "south azerbaijani": "azb-AZ",
+    "southern pashto": "pbt-PK",
+    "southwestern dinka": "dik-SS",
+    "spanish": "es-ES",
+    "spanish argentina": "es-AR",
+    "spanish colombia": "es-CO",
+    "spanish latin america": "es-419",
+    "spanish mexico": "es-MX",
+    "spanish united states": "es-US",
+    "sranan tongo": "srn-SR",
+    "standard latvian": "lvs-LV",
+    "standard malay": "zsm-MY",
+    "sundanese": "su-ID",
+    "swahili": "sw-KE",
+    "swati": "ss-SZ",
+    "swedish": "sv-SE",
+    "swiss german": "de-CH",
+    "syriac (aramaic)": "syc-TR",
+    "tagalog": "tl-PH",
+    "tahitian": "ty-PF",
+    "tajik": "tg-TJ",
+    "tamashek (tuareg)": "tmh-DZ",
+    "tamasheq": "taq-ML",
+    "tamil india": "ta-IN",
+    "tamil sri lanka": "ta-LK",
+    "taroko": "trv-TW",
+    "tatar": "tt-RU",
+    "telugu": "te-IN",
+    "tetum": "tet-TL",
+    "thai": "th-TH",
+    "tibetan": "bo-CN",
+    "tigrinya": "ti-ET",
+    "tok pisin": "tpi-PG",
+    "tokelauan": "tkl-TK",
+    "tongan": "to-TO",
+    "tosk albanian": "als-AL",
+    "tsonga": "ts-ZA",
+    "tswa": "tsc-MZ",
+    "tswana": "tn-BW",
+    "tumbuka": "tum-MW",
+    "turkish": "tr-TR",
+    "turkmen": "tk-TM",
+    "tuvaluan": "tvl-TV",
+    "twi": "tw-GH",
+    "udmurt": "udm-RU",
+    "ukrainian": "uk-UA",
+    "uma": "ppk-ID",
+    "umbundu": "umb-AO",
+    "uyghur uig": "uig-CN",
+    "uyghur ug": "ug-CN",
+    "uzbek": "uz-UZ",
+    "venetian": "vec-IT",
+    "vietnamese": "vi-VN",
+    "vincentian creole english": "svc-VC",
+    "virgin islands creole english": "vic-US",
+    "wallisian": "wls-WF",
+    "waray (philippines)": "war-PH",
+    "welsh": "cy-GB",
+    "west central oromo": "gaz-ET",
+    "western persian": "pes-IR",
+    "wolof": "wo-SN",
+    "xhosa": "xh-ZA",
+    "yiddish": "yi-YD",
+    "yoruba": "yo-NG",
+    "zulu": "zu-ZA",
+}
+
 DEEPL_LANGUAGE_TO_CODE = {
     "bulgarian": "bg",
     "czech": "cs",
@@ -303,3 +631,34 @@ TENCENT_LANGUAGE_TO_CODE = {
     "turkish": "tr",
     "vietnamese": "vi",
 }
+
+BAIDU_LANGUAGE_TO_CODE = {
+    "arabic": "ara",
+    "bulgarian": "bul",
+    "chinese (classical)": "wyw",
+    "chinese (simplified)": "zh",
+    "chinese (traditional)": "cht",
+    "czech": "cs",
+    "danish": "dan",
+    "dutch": "nl",
+    "english": "en",
+    "estonian": "est",
+    "finnish": "fin",
+    "french": "fra",
+    "german": "de",
+    "greek": "el",
+    "hungarian": "hu",
+    "italian": "it",
+    "japanese": "jp",
+    "korean": "kor",
+    "polish": "pl",
+    "portuguese": "pt",
+    "romanian": "ro",
+    "russian": "ru",
+    "slovenian": "slo",
+    "spanish": "spa",
+    "swedish": "swe",
+    "thai": "th",
+    "vietnamese": "vie",
+    "yueyu": "yue",
+}

deep_translator/deepl.py

@@ -17,7 +17,7 @@ from deep_translator.exceptions import (
     ServerException,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class DeeplTranslator(BaseTranslator):
@@ -85,7 +85,7 @@ class DeeplTranslator(BaseTranslator):
             # If the answer is not success, raise server exception.
             if response.status_code == 403:
                 raise AuthorizationException(self.api_key)
-            elif response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise ServerException(response.status_code)
             # Get the response and check is not empty.
             res = response.json()

deep_translator/exceptions.py

@@ -193,3 +193,16 @@ class TencentAPIerror(Exception):
 
     def __str__(self):
         return "{}: {}".format(self.message, self.api_message)
+
+
+class BaiduAPIerror(Exception):
+    """
+    exception thrown if Baidu API returns one of its errors
+    """
+
+    def __init__(self, api_message):
+        self.api_message = str(api_message)
+        self.message = "Baidu API returned the following error"
+
+    def __str__(self):
+        return "{}: {}".format(self.message, self.api_message)

deep_translator/google.py

@@ -16,7 +16,7 @@ from deep_translator.exceptions import (
     TooManyRequests,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class GoogleTranslator(BaseTranslator):
@@ -54,7 +54,7 @@ class GoogleTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
-        if is_input_valid(text):
+        if is_input_valid(text, max_chars=5000):
             text = text.strip()
             if self._same_source_target() or is_empty(text):
                 return text
@@ -70,7 +70,7 @@ class GoogleTranslator(BaseTranslator):
             if response.status_code == 429:
                 raise TooManyRequests()
 
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise RequestError()
 
             soup = BeautifulSoup(response.text, "html.parser")

deep_translator/libre.py

@@ -20,7 +20,7 @@ from deep_translator.exceptions import (
     ServerException,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class LibreTranslator(BaseTranslator):
@@ -95,7 +95,7 @@ class LibreTranslator(BaseTranslator):
 
             if response.status_code == 403:
                 raise AuthorizationException(self.api_key)
-            elif response.status_code != 200:
+            elif request_failed(status_code=response.status_code):
                 raise ServerException(response.status_code)
             # Get the response and check is not empty.
             res = response.json()

deep_translator/linguee.py

@@ -19,7 +19,7 @@ from deep_translator.exceptions import (
     TooManyRequests,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class LingueeTranslator(BaseTranslator):
@@ -72,8 +72,9 @@ class LingueeTranslator(BaseTranslator):
             if response.status_code == 429:
                 raise TooManyRequests()
 
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise RequestError()
+
             soup = BeautifulSoup(response.text, "html.parser")
             elements = soup.find_all(self._element_tag, self._element_query)
             response.close()

deep_translator/mymemory.py

@@ -9,13 +9,13 @@ from typing import List, Optional, Union
 import requests
 
 from deep_translator.base import BaseTranslator
-from deep_translator.constants import BASE_URLS
+from deep_translator.constants import BASE_URLS, MY_MEMORY_LANGUAGES_TO_CODES
 from deep_translator.exceptions import (
     RequestError,
     TooManyRequests,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class MyMemoryTranslator(BaseTranslator):
@@ -41,6 +41,7 @@ class MyMemoryTranslator(BaseTranslator):
             source=source,
             target=target,
             payload_key="q",
+            languages=MY_MEMORY_LANGUAGES_TO_CODES,
         )
 
     def translate(
@@ -70,7 +71,7 @@ class MyMemoryTranslator(BaseTranslator):
 
             if response.status_code == 429:
                 raise TooManyRequests()
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise RequestError()
 
             data = response.json()

deep_translator/papago.py

@@ -12,7 +12,7 @@ import requests
 from deep_translator.base import BaseTranslator
 from deep_translator.constants import BASE_URLS, PAPAGO_LANGUAGE_TO_CODE
 from deep_translator.exceptions import TranslationNotFound
-from deep_translator.validate import is_input_valid
+from deep_translator.validate import is_input_valid, request_failed
 
 
 class PapagoTranslator(BaseTranslator):
@@ -67,7 +67,7 @@ class PapagoTranslator(BaseTranslator):
             response = requests.post(
                 self._base_url, headers=headers, data=payload
             )
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise Exception(
                     f"Translation error! -> status code: {response.status_code}"
                 )

deep_translator/pons.py

@@ -19,7 +19,7 @@ from deep_translator.exceptions import (
     TooManyRequests,
     TranslationNotFound,
 )
-from deep_translator.validate import is_empty, is_input_valid
+from deep_translator.validate import is_empty, is_input_valid, request_failed
 
 
 class PonsTranslator(BaseTranslator):
@@ -71,7 +71,7 @@ class PonsTranslator(BaseTranslator):
             if response.status_code == 429:
                 raise TooManyRequests()
 
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 raise RequestError()
 
             soup = BeautifulSoup(response.text, "html.parser")

deep_translator/qcri.py

@@ -16,6 +16,7 @@ from deep_translator.exceptions import (
     ServerException,
     TranslationNotFound,
 )
+from deep_translator.validate import request_failed
 
 
 class QcriTranslator(BaseTranslator):
@@ -96,7 +97,7 @@ class QcriTranslator(BaseTranslator):
             raise ServerException(503)
 
         else:
-            if response.status_code != 200:
+            if request_failed(status_code=response.status_code):
                 ServerException(response.status_code)
             else:
                 res = response.json()

deep_translator/validate.py

@@ -1,5 +1,7 @@
 __copyright__ = "Copyright (C) 2020 Nidhal Baccouri"
 
+from typing import Optional
+
 from deep_translator.exceptions import NotValidLength, NotValidPayload
 
 
@@ -7,8 +9,23 @@ def is_empty(text: str) -> bool:
     return text == ""
 
 
+def request_failed(status_code: int) -> bool:
+    """Check if a request has failed or not.
+    A request is considered successfull if the status code is in the 2** range.
+
+    Args:
+        status_code (int): status code of the request
+
+    Returns:
+        bool: indicates request failure
+    """
+    if status_code > 299 or status_code < 200:
+        return True
+    return False
+
+
 def is_input_valid(
-    text: str, min_chars: int = 0, max_chars: int = 5000
+    text: str, min_chars: int = 0, max_chars: Optional[int] = None
 ) -> bool:
     """
     validate the target text to translate
@@ -18,9 +35,9 @@ def is_input_valid(
     @return: bool
     """
 
-    if not isinstance(text, str) or text.isdigit():
+    if not isinstance(text, str):
         raise NotValidPayload(text)
-    if not min_chars <= len(text) < max_chars:
+    if max_chars and (not min_chars <= len(text) < max_chars):
         raise NotValidLength(text, min_chars, max_chars)
 
     return True

deep_translator/yandex.py

@@ -18,7 +18,7 @@ from deep_translator.exceptions import (
     TooManyRequests,
     TranslationNotFound,
 )
-from deep_translator.validate import is_input_valid
+from deep_translator.validate import is_input_valid, request_failed
 
 
 class YandexTranslator(BaseTranslator):
@@ -75,7 +75,7 @@ class YandexTranslator(BaseTranslator):
         else:
             data = response.json()
 
-        if response.status_code != 200:
+        if request_failed(status_code=response.status_code):
             raise ServerException(response.status_code)
         return data.get("dirs")
 

docs/README.rst

@@ -694,6 +694,66 @@ TencentTranslator
 
     translated = TencentTranslator(secret_id="your-secret_id", secret_key="your-secret_key" source="en", target="zh").translate_file('path/to/file')
 
+BaiduTranslator
+-----------------
+
+.. note::
+
+    In order to use the BaiduTranslator translator, you need to generate a secret_id and a secret_key.
+    deep-translator supports both Pro and free APIs. Just check the examples below.
+    Visit http://api.fanyi.baidu.com/product/113 for more information on how to generate your Baidu appid
+    and appkey.
+
+- Simple translation
+
+.. code-block:: python
+
+    text = 'Hello world'
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate(text)
+
+- Translate batch of texts
+
+.. code-block:: python
+
+    texts = ["Hello world", "How are you?"]
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate_batch(texts)
+
+- Translate from a file:
+
+.. code-block:: python
+
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate_file('path/to/file')
+
+BaiduTranslator
+-----------------
+
+.. note::
+
+    In order to use the BaiduTranslator translator, you need to generate a secret_id and a secret_key.
+    deep-translator supports both Pro and free APIs. Just check the examples below.
+    Visit http://api.fanyi.baidu.com/product/113 for more information on how to generate your Baidu appid
+    and appkey.
+
+- Simple translation
+
+.. code-block:: python
+
+    text = 'Hello world'
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate(text)
+
+- Translate batch of texts
+
+.. code-block:: python
+
+    texts = ["Hello world", "How are you?"]
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate_batch(texts)
+
+- Translate from a file:
+
+.. code-block:: python
+
+    translated = BaiduTranslator(appid="your-appid", appkey="your-appkey" source="en", target="zh").translate_file('path/to/file')
+
 
 Proxy usage
 -------------

pyproject.toml

@@ -25,7 +25,7 @@ ensure_newline_before_comments = true
 
 [tool.poetry]
 name = "deep-translator"
-version = "1.11.0"
+version = "1.11.4"
 description = "A flexible free and unlimited python tool to translate between different languages in a simple way using multiple translators"
 license = "MIT"
 authors = ["Nidhal Baccouri <[email protected]>"]

tests/test_baidu.py

@@ -0,0 +1,65 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from deep_translator import BaiduTranslator
+from deep_translator.exceptions import BaiduAPIerror
+
+
+@patch("deep_translator.baidu.requests")
+def test_simple_translation(mock_requests):
+    translator = BaiduTranslator(
+        appid="this-is-an-valid-appid",
+        appkey="this-is-an-valid-appkey",
+        source="en",
+        target="zh",
+    )
+    # Set the request response mock.
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "from": "en",
+        "to": "zh",
+        "trans_result": [{"src": "hello", "dst": "你好"}],
+    }
+    mock_requests.post.return_value = mock_response
+    translation = translator.translate("hello")
+    assert translation == "你好"
+
+
+@patch("deep_translator.baidu.requests.get")
+def test_wrong_api_key(mock_requests):
+    translator = BaiduTranslator(
+        appid="this-is-a-wrong-appid",
+        appkey="this-is-a-wrong-appkey",
+        source="en",
+        target="zh",
+    )
+    # Set the response status_code only.
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "error_code": "54001",
+        "error_msg": "Invalid Sign",
+    }
+    mock_requests.post.return_value = mock_response
+    with pytest.raises(BaiduAPIerror):
+        translator.translate("Hello")
+
+
+# the remaining tests are actual requests to Baidu translator API and use appid and appkey
+# if appid and appkey variable is None, they are skipped
+
+appid = None
+appkey = None
+
+
+@pytest.mark.skipif(
+    appid is None or appkey is None,
+    reason="appid or appkey is not provided",
+)
+def test_baidu_successful_post_onetarget():
+    posted = BaiduTranslator(
+        appid=appid, appkey=appkey, source="en", target="zh"
+    ).translate("Hello! How are you?")
+    assert isinstance(posted, str)

tests/test_google.py

@@ -46,14 +46,6 @@ def test_empty_text(google_translator):
 
 
 def test_payload(google_translator):
-    with pytest.raises(exceptions.NotValidPayload):
-        google_translator.translate(text="1234")
-        google_translator.translate(text="{}")
-        google_translator.translate(text="%@")
-
-    with pytest.raises(exceptions.NotValidPayload):
-        google_translator.translate(text=123)
-
     with pytest.raises(exceptions.NotValidPayload):
         google_translator.translate(text={})
 

tests/test_libre.py

@@ -32,9 +32,6 @@ def test_abbreviations_and_languages_mapping():
 
 
 def test_payload(libre):
-    with pytest.raises(exceptions.NotValidPayload):
-        libre.translate(123)
-
     with pytest.raises(exceptions.NotValidPayload):
         libre.translate({})
 

tests/test_linguee.py

@@ -38,9 +38,6 @@ def test_inputs():
 
 
 def test_payload(linguee):
-    with pytest.raises(exceptions.NotValidPayload):
-        linguee.translate(123)
-
     with pytest.raises(exceptions.NotValidPayload):
         linguee.translate({})
 

tests/test_mymemory.py

@@ -9,7 +9,7 @@ from deep_translator import MyMemoryTranslator, exceptions
 
 @pytest.fixture
 def mymemory():
-    return MyMemoryTranslator(source="en", target="fr")
+    return MyMemoryTranslator(source="en-GB", target="fr-FR")
 
 
 def test_content(mymemory):
@@ -27,18 +27,15 @@ def test_inputs():
         MyMemoryTranslator(source="auto", target="")
 
     with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
-        MyMemoryTranslator(source="", target="en")
+        MyMemoryTranslator(source="", target="en-GB")
 
-    m1 = MyMemoryTranslator("en", "fr")
+    m1 = MyMemoryTranslator("en-GB", "fr-FR")
     m2 = MyMemoryTranslator("english", "french")
     assert m1._source == m2._source
     assert m1._target == m2._target
 
 
 def test_payload(mymemory):
-    with pytest.raises(exceptions.NotValidPayload):
-        mymemory.translate(text=123)
-
     with pytest.raises(exceptions.NotValidPayload):
         mymemory.translate(text={})
 

tests/test_pons.py

@@ -36,9 +36,6 @@ def test_inputs():
 
 
 def test_payload(pons):
-    with pytest.raises(exceptions.NotValidPayload):
-        pons.translate(123)
-
     with pytest.raises(exceptions.NotValidPayload):
         pons.translate({})