added support for yandex

README.rst

@@ -91,6 +91,7 @@ Features
 * Support for `Pons translator <https://de.pons.com//>`_
 * Support for the `Linguee translator <https://www.linguee.com//>`_
 * Support for the `Mymemory translator <https://mymemory.translated.net//>`_
+* Support for the `Yandex translator <https://yandex.com/>`_ (version >= 1.2.1)
 * Automatic single language detection
 * Batch language detection
 * Translate directly from a text file
@@ -149,6 +150,7 @@ Imports
                                  PonsTranslator,
                                  LingueeTranslator,
                                  MyMemoryTranslator,
+                                 YandexTranslator
                                  single_detection,
                                  batch_detection)
 
@@ -331,6 +333,33 @@ PONS Translator
 
     translated_words = LingueeTranslator(source='english', target='french').translate_words(["good", "awesome"])
 
+Yandex Translator
+----------------
+
+.. note::
+
+    You need to require an private api key if you want to use the yandex translator.
+    visit the official website for more information about how to get one
+
+- Language detection
+
+.. code-block:: python
+
+    lang = YandexTranslator('your_api_key').detect('Hallo, Welt')
+    print(f"language detected: {lang}")  # output -> language detected: 'de'
+
+- Text translation
+
+.. code-block:: python
+
+    # with auto detection | meaning provide only the target language and let yandex detect the source
+    translated = YandexTranslator('your_api_key').translate('Hallo, Welt', 'en')
+    print(f"translated text: {translated}")  # output -> translated text: Hello world
+
+    # provide source and target language explicitly
+    translated = YandexTranslator('your_api_key').translate('Hallo, Welt', 'de-en')
+    print(f"translated text: {translated}")  # output -> translated text: Hello world
+
 Usage from Terminal
 --------------------
 

deep_translator/__init__.py

@@ -4,6 +4,7 @@ from .google_trans import GoogleTranslator
 from .pons import PonsTranslator
 from .linguee import LingueeTranslator
 from .mymemory import MyMemoryTranslator
+from .yandex import YandexTranslator
 from .detection import single_detection, batch_detection
 
 
@@ -15,5 +16,6 @@ __all__ = [GoogleTranslator,
            PonsTranslator,
            LingueeTranslator,
            MyMemoryTranslator,
+           YandexTranslator,
            single_detection,
            batch_detection]

deep_translator/constants.py

@@ -3,7 +3,7 @@
 BASE_URLS = {
     "GOOGLE_TRANSLATE": "https://translate.google.com/m",
     "PONS": "https://en.pons.com/translate/",
-    "YANDEX": "https://translate.yandex.com/",
+    "YANDEX": "https://translate.yandex.net/api/{version}/tr.json/{endpoint}",
     "LINGUEE": "https://www.linguee.com/",
     "MYMEMORY": "http://api.mymemory.translated.net/get"
 }

deep_translator/exceptions.py

@@ -1,9 +1,8 @@
-
-
 class BaseError(Exception):
     """
     base error structure class
     """
+
     def __init__(self, val, message):
         """
         @param val: actual value
@@ -21,6 +20,7 @@ class LanguageNotSupportedException(BaseError):
     """
     exception thrown if the user uses a language that is not supported by the deep_translator
     """
+
     def __init__(self, val, message="There is no support for the chosen language"):
         super().__init__(val, message)
 
@@ -29,6 +29,7 @@ class NotValidPayload(BaseError):
     """
     exception thrown if the user enters an invalid payload
     """
+
     def __init__(self,
                  val,
                  message='text must be a valid text with maximum 5000 character, otherwise it cannot be translated'):
@@ -39,6 +40,7 @@ class TranslationNotFound(BaseError):
     """
     exception thrown if no translation was found for the text provided by the user
     """
+
     def __init__(self,
                  val,
                  message='No translation was found using the current translator. Try another translator?'):
@@ -49,6 +51,7 @@ class ElementNotFoundInGetRequest(BaseError):
     """
     exception thrown if the html element was not found in the body parsed by beautifulsoup
     """
+
     def __init__(self,
                  val,
                  message='Required element was not found in the API response'):
@@ -59,6 +62,7 @@ class NotValidLength(BaseError):
     """
     exception thrown if the provided text exceed the length limit of the translator
     """
+
     def __init__(self, val, min_chars, max_chars):
         message = "Text length need to be between {} and {} characters".format(min_chars, max_chars)
         super(NotValidLength, self).__init__(val, message)
@@ -68,9 +72,30 @@ class RequestError(Exception):
     """
     exception thrown if an error occured during the request call, e.g a connection problem.
     """
+
     def __init__(self, message="Request exception can happen due to an api connection error. "
                                "Please check your connection and try again"):
         self.message = message
 
     def __str__(self):
         return self.message
+
+
+class YandexDefaultException(Exception):
+    """
+    Default YandexTranslate exception from the official website
+    """
+    errors = {
+        401: "ERR_KEY_INVALID",
+        402: "ERR_KEY_BLOCKED",
+        403: "ERR_DAILY_REQ_LIMIT_EXCEEDED",
+        404: "ERR_DAILY_CHAR_LIMIT_EXCEEDED",
+        413: "ERR_TEXT_TOO_LONG",
+        422: "ERR_UNPROCESSABLE_TEXT",
+        501: "ERR_LANG_NOT_SUPPORTED",
+        503: "ERR_SERVICE_NOT_AVAIBLE",
+    }
+
+    def __init__(self, status_code, *args):
+        message = self.errors.get(status_code)
+        super(YandexDefaultException, self).__init__(message, *args)

deep_translator/yandex.py

@@ -0,0 +1,103 @@
+"""
+Yandex translator API
+"""
+import requests
+from requests import exceptions
+from deep_translator.constants import BASE_URLS
+from deep_translator.exceptions import (RequestError,
+                                        YandexDefaultException, TranslationNotFound)
+
+
+class YandexTranslator(object):
+    """
+    class that wraps functions, which use the yandex translator under the hood to translate word(s)
+    """
+
+    def __init__(self, api_key=None):
+        """
+        @param api_key: your yandex api key
+        """
+        if not api_key:
+            raise YandexDefaultException(401)
+        self.__base_url = BASE_URLS.get("YANDEX")
+
+        self.api_key = api_key
+        self.api_version = "v1.5"
+        self.api_endpoints = {
+            "langs": "getLangs",
+            "detect": "detect",
+            "translate": "translate",
+        }
+
+    def get_supported_languages(self):
+        return set(x.split("-")[0] for x in self.dirs)
+
+    @property
+    def languages(self):
+        return self.get_supported_languages()
+
+    @property
+    def dirs(self, proxies=None):
+
+        try:
+            url = self.__base_url.format(version=self.api_version, endpoint="getLangs")
+            print("url: ", url)
+            response = requests.get(url, params={"key": self.api_key}, proxies=proxies)
+        except requests.exceptions.ConnectionError:
+            raise YandexDefaultException(503)
+        else:
+            data = response.json()
+
+        if response.status_code != 200:
+            raise YandexDefaultException(response.status_code)
+        return data.get("dirs")
+
+
+def detect(self, text, proxies=None):
+    response = None
+    params = {
+        "text": text,
+        "format": "plain",
+        "key": self.api_key,
+    }
+    try:
+        url = self.__base_url.format(version=self.api_version, endpoint="detect")
+        response = requests.post(url, data=params, proxies=proxies)
+
+    except RequestError:
+        raise
+    except ConnectionError:
+        raise YandexDefaultException(503)
+    except ValueError:
+        raise YandexDefaultException(response.status_code)
+    else:
+        response = response.json()
+    language = response['lang']
+    status_code = response['code']
+    if status_code != 200:
+        raise RequestError()
+    elif not language:
+        raise YandexDefaultException(501)
+    return language
+
+
+def translate(self, text, lang, proxies=None):
+    params = {
+        "text": text,
+        "format": "plain",
+        "lang": lang,
+        "key": self.api_key
+    }
+    try:
+        url = self.__base_url.format(version=self.api_version, endpoint="translate")
+        response = requests.post(url, data=params, proxies=proxies)
+    except ConnectionError:
+        raise YandexDefaultException(503)
+    else:
+        response = response.json()
+    if response['code'] != 200:
+        raise YandexDefaultException(response['code'])
+    if not response['text']:
+        raise TranslationNotFound()
+
+    return response['text']

docs/usage.rst

@@ -204,6 +204,33 @@ PONS Translator
 
     translated_words = LingueeTranslator(source='english', target='french').translate_words(["good", "awesome"])
 
+Yandex Translator
+----------------
+
+.. note::
+
+    You need to require an private api key if you want to use the yandex translator.
+    visit the official website for more information about how to get one
+
+- Language detection
+
+.. code-block:: python
+
+    lang = YandexTranslator('your_api_key').detect('Hallo, Welt')
+    print(f"language detected: {lang}")  # output -> language detected: 'de'
+
+- Text translation
+
+.. code-block:: python
+
+    # with auto detection | meaning provide only the target language and let yandex detect the source
+    translated = YandexTranslator('your_api_key').translate('Hallo, Welt', 'en')
+    print(f"translated text: {translated}")  # output -> translated text: Hello world
+
+    # provide source and target language explicitly
+    translated = YandexTranslator('your_api_key').translate('Hallo, Welt', 'de-en')
+    print(f"translated text: {translated}")  # output -> translated text: Hello world
+
 Usage from Terminal
 --------------------