Merge pull request #48 from RubenEu/topic-deepl

deep_translator/constants.py

@@ -191,3 +191,32 @@ microsoft_languages_response = requests.get(microsoft_languages_api_url)
 translation_dict = microsoft_languages_response.json()['translation']
 
 MICROSOFT_CODES_TO_LANGUAGES = {translation_dict[k]['name'].lower(): k for k in translation_dict.keys()}
+
+DEEPL_LANGUAGE_TO_CODE = {
+    "bulgarian": "bg",
+    "czech": "cs",
+    "danish": "da",
+    "german": "de",
+    "greek": "el",
+    "english": "en",
+    "spanish": "es",
+    "estonian": "et",
+    "finnish": "fi",
+    "french": "fr",
+    "hungarian": "hu",
+    "italian": "it",
+    "japanese": "ja",
+    "lithuanian": "lt",
+    "latvian": "lv",
+    "dutch": "nl",
+    "polish": "pl",
+    "portuguese": "pt",
+    "romanian": "ro",
+    "russian": "ru",
+    "slovak": "sk",
+    "slovenian": "sl",
+    "swedish": "sv",
+    "chinese": "zh"
+}
+
+DEEPL_CODE_TO_LANGUAGE = {v: k for k, v in DEEPL_LANGUAGE_TO_CODE.items()}

deep_translator/deepl.py

@@ -1,21 +1,22 @@
-
 import requests
-from requests.utils import requote_uri
-from deep_translator.constants import BASE_URLS
-from deep_translator.exceptions import (RequestError,
-                                        ServerException, TranslationNotFound, TooManyRequests)
+from deep_translator.constants import BASE_URLS, DEEPL_LANGUAGE_TO_CODE
+from deep_translator.exceptions import (ServerException,
+                                        TranslationNotFound,
+                                        LanguageNotSupportedException,
+                                        AuthorizationException)
 
 
 class DeepL(object):
     """
     class that wraps functions, which use the DeepL translator under the hood to translate word(s)
     """
+    _languages = DEEPL_LANGUAGE_TO_CODE
 
     def __init__(self, api_key=None):
         """
-        @param api_key: your DeepL api key. Get one here: https://www.deepl.com/docs-api/accessing-the-api/
+        @param api_key: your DeepL api key.
+        Get one here: https://www.deepl.com/docs-api/accessing-the-api/
         """
-
         if not api_key:
             raise ServerException(401)
         self.version = 'v2'
@@ -23,25 +24,30 @@ class DeepL(object):
         self.__base_url = BASE_URLS.get("DEEPL").format(version=self.version)
 
     def translate(self, source, target, text):
+        # Create the request parameters.
+        translate_endpoint = 'translate'
         params = {
             "auth_key": self.api_key,
-            "target_lang": target,
-            "source_lang": source,
+            "target_lang": self._map_language_to_code(target),
+            "source_lang": self._map_language_to_code(source),
             "text": text
         }
+        # Do the request and check the connection.
         try:
-            response = requests.get(self.__base_url, params=params)
+            response = requests.get(self.__base_url + translate_endpoint, params=params)
         except ConnectionError:
             raise ServerException(503)
-
-        else:
-            if response.status_code != 200:
-                ServerException(response.status_code)
-            else:
-                res = response.json()
-                if not res:
-                    raise TranslationNotFound(text)
-                return res
+        # If the answer is not success, raise server exception.
+        if response.status_code == 403:
+            raise AuthorizationException(self.api_key)
+        elif 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.
+        return res['translations'][0]['text']
 
     def translate_batch(self, source, target, batch):
         """
@@ -53,7 +59,13 @@ class DeepL(object):
         """
         return [self.translate(source, target, text) for text in batch]
 
+    def _is_language_supported(self, lang):
+        # The language is supported when is in the dicionary.
+        return lang == 'auto' or lang in self._languages.keys() or lang in self._languages.values()
 
-if __name__ == '__main__':
-    d = DeepL(api_key="key")
-    print(d)
+    def _map_language_to_code(self, lang):
+        if lang in self._languages.keys():
+            return self._languages[lang]
+        elif lang in self._languages.values():
+            return lang
+        raise LanguageNotSupportedException(lang)

deep_translator/exceptions.py

@@ -136,3 +136,9 @@ class ServerException(Exception):
     def __init__(self, status_code, *args):
         message = self.errors.get(status_code, "API server error")
         super(ServerException, self).__init__(message, *args)
+
+
+class AuthorizationException(Exception):
+    def __init__(self, api_key, *args):
+        msg = 'Unauthorized access with the api key ' + api_key
+        super().__init__(msg, *args)

deep_translator/tests/test_deepl.py

@@ -0,0 +1,29 @@
+import pytest
+from unittest.mock import Mock, PropertyMock, patch
+from deep_translator.deepl import DeepL
+from deep_translator.exceptions import AuthorizationException
+
+
+@patch('deep_translator.deepl.requests')
+def test_simple_translation(mock_requests):
+    translator = DeepL(api_key='imagine-this-is-an-valid-api-key')
+    # Set the request response mock.
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "translations": [{
+            "text": "hola"
+        }]
+    }
+    mock_requests.get.return_value = mock_response
+    translation = translator.translate('en', 'es', 'hello')
+    assert translation == 'hola'
+
+
+@patch('deep_translator.deepl.requests.get')
+def test_wrong_api_key(mock_requests):
+    translator = DeepL(api_key='this-is-a-wrong-api-key!')
+    # Set the response status_code only.
+    mock_requests.return_value = Mock(status_code=403)
+    with pytest.raises(AuthorizationException):
+        translator.translate('en', 'es', 'Hello')