global refactoring

deep_translator/constants.py

@@ -6,9 +6,9 @@ BASE_URLS = {
     "YANDEX": "https://translate.yandex.net/api/{version}/tr.json/{endpoint}",
     "LINGUEE": "https://www.linguee.com/",
     "MYMEMORY": "http://api.mymemory.translated.net/get",
-    "QcriTranslator": "https://mt.qcri.org/api/v1/{endpoint}?",
+    "QCRI": "https://mt.qcri.org/api/v1/{endpoint}?",
     "DEEPL": "https://api.deepl.com/{version}/",
-    "DEEPL_FREE": "https://api-free.deepl.com/v2/",
+    "DEEPL_FREE": "https://api-free.deepl.com/{version}/",
     "MICROSOFT_TRANSLATE": "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0",
     "PAPAGO": "https://papago.naver.com/",
     "PAPAGO_API": "https://openapi.naver.com/v1/papago/n2mt",

deep_translator/deepl.py

@@ -1,11 +1,11 @@
 import requests
 
-from .validate import is_empty
-from .constants import BASE_URLS, DEEPL_LANGUAGE_TO_CODE
-from .exceptions import (ServerException,
+from deep_translator.validate import is_empty, validate_input
+from deep_translator.constants import BASE_URLS, DEEPL_LANGUAGE_TO_CODE
+from deep_translator.exceptions import (ServerException,
                          TranslationNotFound,
                          AuthorizationException)
-from .base import BaseTranslator
+from deep_translator.base import BaseTranslator
 
 
 class DeeplTranslator(BaseTranslator):
@@ -24,49 +24,50 @@ class DeeplTranslator(BaseTranslator):
             raise ServerException(401)
         self.version = 'v2'
         self.api_key = api_key
-        if use_free_api:
-            self._base_url = BASE_URLS.get(
-                "DEEPL_FREE").format(version=self.version)
-        else:
-            self._base_url = BASE_URLS.get(
+        url = BASE_URLS.get(
+                "DEEPL_FREE").format(version=self.version) if use_free_api else BASE_URLS.get(
                 "DEEPL").format(version=self.version)
-        super().__init__(source=source,
-                         target=target,
-                         languages=DEEPL_LANGUAGE_TO_CODE)
+        super().__init__(
+            base_url=url,
+            source=source,
+            target=target,
+            languages=DEEPL_LANGUAGE_TO_CODE,
+            **kwargs)
 
     def translate(self, text, **kwargs):
         """
         @param text: text to translate
         @return: translated text
         """
-        if self._same_source_target() or is_empty(text):
-            return text
+        if validate_input(text):
+            if self._same_source_target() or is_empty(text):
+                return text
 
-        # Create the request parameters.
-        translate_endpoint = 'translate'
-        params = {
-            "auth_key": self.api_key,
-            "source_lang": self._source,
-            "target_lang": self._target,
-            "text": text
-        }
-        # Do the request and check the connection.
-        try:
-            response = requests.get(
-                self._base_url + translate_endpoint, params=params)
-        except ConnectionError:
-            raise ServerException(503)
-        # 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']
+            # Create the request parameters.
+            translate_endpoint = 'translate'
+            params = {
+                "auth_key": self.api_key,
+                "source_lang": self._source,
+                "target_lang": self._target,
+                "text": text
+            }
+            # Do the request and check the connection.
+            try:
+                response = requests.get(
+                    self._base_url + translate_endpoint, params=params)
+            except ConnectionError:
+                raise ServerException(503)
+            # 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_file(self, path, **kwargs):
         return self._translate_file(path, **kwargs)
@@ -80,6 +81,6 @@ class DeeplTranslator(BaseTranslator):
 
 
 if __name__ == '__main__':
-    d = DeeplTranslator(target="de")
-    t = d.translate("I have no idea")
+    d = DeeplTranslator(target="en", api_key="some-key")
+    t = d.translate("Ich habe keine ahnung")
     print("text: ", t)

deep_translator/google.py

@@ -37,11 +37,10 @@ class GoogleTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
-        if self._same_source_target() or is_empty(text):
-            return text
-
         if validate_input(text):
             text = text.strip()
+            if self._same_source_target() or is_empty(text):
+                return text
             self._url_params['tl'] = self._target
             self._url_params['sl'] = self._source
 

deep_translator/libre.py

@@ -4,7 +4,7 @@ LibreTranslate API
 
 import requests
 
-from .validate import is_empty
+from .validate import is_empty, validate_input
 from .base import BaseTranslator
 from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES
 from .exceptions import (ServerException,
@@ -38,36 +38,37 @@ class LibreTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
-        if self._same_source_target() or is_empty(text):
-            return text
+        if validate_input(text):
+            if self._same_source_target() or is_empty(text):
+                return text
 
-        translate_endpoint = 'translate'
-        params = {
-            "q": text,
-            "source": self._source,
-            "target": self._target,
-            "format": 'text'
-        }
-        # Add API Key if required
-        if self.api_key:
-            params["api_key"] = self.api_key
-        # Do the request and check the connection.
-        try:
-            response = requests.post(self._base_url + translate_endpoint, params=params)
-        except ConnectionError:
-            raise ServerException(503)
-        # If the answer is not success, raise server exception.
+            translate_endpoint = 'translate'
+            params = {
+                "q": text,
+                "source": self._source,
+                "target": self._target,
+                "format": 'text'
+            }
+            # Add API Key if required
+            if self.api_key:
+                params["api_key"] = self.api_key
+            # Do the request and check the connection.
+            try:
+                response = requests.post(self._base_url + translate_endpoint, params=params)
+            except ConnectionError:
+                raise ServerException(503)
+            # 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['translatedText']
+            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['translatedText']
 
     def translate_file(self, path, **kwargs):
         """

deep_translator/microsoft.py

@@ -6,6 +6,7 @@ import sys
 from .constants import BASE_URLS
 from .exceptions import ServerException, MicrosoftAPIerror
 from .base import BaseTranslator
+from .validate import validate_input
 
 
 class MicrosoftTranslator(BaseTranslator):
@@ -61,29 +62,30 @@ class MicrosoftTranslator(BaseTranslator):
         # a body must be a list of dicts to process multiple texts;
         # I have not added multiple text processing here since it is covered by the translate_batch method
 
-        self._url_params['from'] = self._source
-        self._url_params['to'] = self._target
-
-        valid_microsoft_json = [{'text': text}]
-        try:
-            requested = requests.post(self._base_url,
-                                      params=self._url_params,
-                                      headers=self.headers,
-                                      json=valid_microsoft_json,
-                                      proxies=self.proxies)
-        except requests.exceptions.RequestException:
-            exc_type, value, traceback = sys.exc_info()
-            logging.warning(f"Returned error: {exc_type.__name__}")
-
-        # Where Microsoft API responds with an api error, it returns a dict in response.json()
-        if type(requested.json()) is dict:
-            error_message = requested.json()['error']
-            raise MicrosoftAPIerror(error_message)
-        # Where it responds with a translation, its response.json() is a list e.g. [{'translations': [{'text': 'Hello world!', 'to': 'en'}]}]
-        elif type(requested.json()) is list:
-            all_translations = [i['text']
-                                for i in requested.json()[0]['translations']]
-            return "\n".join(all_translations)
+        if validate_input(text):
+            self._url_params['from'] = self._source
+            self._url_params['to'] = self._target
+
+            valid_microsoft_json = [{'text': text}]
+            try:
+                requested = requests.post(self._base_url,
+                                          params=self._url_params,
+                                          headers=self.headers,
+                                          json=valid_microsoft_json,
+                                          proxies=self.proxies)
+            except requests.exceptions.RequestException:
+                exc_type, value, traceback = sys.exc_info()
+                logging.warning(f"Returned error: {exc_type.__name__}")
+
+            # Where Microsoft API responds with an api error, it returns a dict in response.json()
+            if type(requested.json()) is dict:
+                error_message = requested.json()['error']
+                raise MicrosoftAPIerror(error_message)
+            # Where it responds with a translation, its response.json() is a list e.g. [{'translations': [{'text': 'Hello world!', 'to': 'en'}]}]
+            elif type(requested.json()) is list:
+                all_translations = [i['text']
+                                    for i in requested.json()[0]['translations']]
+                return "\n".join(all_translations)
 
     def translate_file(self, path, **kwargs):
         """

deep_translator/mymemory.py

@@ -22,11 +22,11 @@ class MyMemoryTranslator(BaseTranslator):
         """
         self.proxies = proxies
         self.email = kwargs.get('email', None)
-        super(MyMemoryTranslator, self).__init__(base_url=BASE_URLS.get("MYMEMORY"),
-                                                 source=self._source,
-                                                 target=self._target,
-                                                 payload_key='q',
-                                                 langpair='{}|{}'.format(self._source, self._target))
+        super().__init__(base_url=BASE_URLS.get("MYMEMORY"),
+                         source=source,
+                         target=target,
+                         payload_key='q',
+                        )
 
     def translate(self, text, return_all=False, **kwargs):
         """
@@ -36,13 +36,12 @@ class MyMemoryTranslator(BaseTranslator):
         @param return_all: set to True to return all synonym/similars of the translated text
         @return: str or list
         """
-
-        if self._same_source_target() or is_empty(text):
-            return text
-
         if validate_input(text, max_chars=500):
             text = text.strip()
+            if self._same_source_target() or is_empty(text):
+                return text
 
+            self._url_params['langpair'] = '{}|{}'.format(self._source, self._target)
             if self.payload_key:
                 self._url_params[self.payload_key] = text
             if self.email:

deep_translator/papago.py

@@ -7,6 +7,8 @@ from .exceptions import TranslationNotFound
 from .base import BaseTranslator
 import requests
 
+from .validate import validate_input
+
 
 class PapagoTranslator(BaseTranslator):
     """
@@ -38,32 +40,32 @@ class PapagoTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
+        if validate_input(text):
+            payload = {
+                "source": self._source,
+                "target": self._target,
+                "text": text
+            }
+            headers = {
+                'X-Naver-Client-Id': self.client_id,
+                'X-Naver-Client-Secret': self.secret_key,
+                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
+            }
+            response = requests.post(
+                self._base_url, headers=headers, data=payload)
+            if response.status_code != 200:
+                raise Exception(
+                    f'Translation error! -> status code: {response.status_code}')
+            res_body = json.loads(response.text)
+            if "message" not in res_body:
+                raise TranslationNotFound(text)
 
-        payload = {
-            "source": self._source,
-            "target": self._target,
-            "text": text
-        }
-        headers = {
-            'X-Naver-Client-Id': self.client_id,
-            'X-Naver-Client-Secret': self.secret_key,
-            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
-        }
-        response = requests.post(
-            self._base_url, headers=headers, data=payload)
-        if response.status_code != 200:
-            raise Exception(
-                f'Translation error! -> status code: {response.status_code}')
-        res_body = json.loads(response.text)
-        if "message" not in res_body:
-            raise TranslationNotFound(text)
-
-        msg = res_body.get("message")
-        result = msg.get("result", None)
-        if not result:
-            raise TranslationNotFound(text)
-        translated_text = result.get("translatedText")
-        return translated_text
+            msg = res_body.get("message")
+            result = msg.get("result", None)
+            if not result:
+                raise TranslationNotFound(text)
+            translated_text = result.get("translatedText")
+            return translated_text
 
     def translate_file(self, path, **kwargs):
         """

deep_translator/pons.py

@@ -46,10 +46,9 @@ class PonsTranslator(BaseTranslator):
         @type return_all: bool
         @return: str: translated word
         """
-        if self._same_source_target() or is_empty(word):
-            return word
-
         if validate_input(word, max_chars=50):
+            if self._same_source_target() or is_empty(word):
+                return word
             url = "{}{}-{}/{}".format(self._base_url, self._source, self._target, word)
             url = requote_uri(url)
             response = requests.get(url, proxies=self.proxies)

deep_translator/validate.py

@@ -4,10 +4,10 @@ import string
 
 
 def is_empty(text: str):
-    return text.strip() == ""
+    return text == ""
 
 
-def validate_input(text: str, min_chars: int = 1, max_chars: int = 5000):
+def validate_input(text: str, min_chars: int = 0, max_chars: int = 5000):
     """
     validate the target text to translate
     @param min_chars: min characters
@@ -16,13 +16,8 @@ def validate_input(text: str, min_chars: int = 1, max_chars: int = 5000):
     @return: bool
     """
 
-    if not isinstance(text, str) or not text.strip() or text.isdigit():
+    if not isinstance(text, str) or text.isdigit():
         raise NotValidPayload(text)
-
-    # check if payload contains only symbols
-    if all(i in string.punctuation for i in text):
-        raise NotValidPayload(text)
-
     if not min_chars <= len(text) < max_chars:
         raise NotValidLength(text, min_chars, max_chars)
 

deep_translator/yandex.py

@@ -87,31 +87,32 @@ class YandexTranslator(BaseTranslator):
         return language
 
     def translate(self, text, proxies=None, **kwargs):
-        params = {
-            "text": text,
-            "format": "plain",
-            "lang": self._target if self._source == "auto" else "{}-{}".format(self._source, self._target),
-            "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 ServerException(503)
-        else:
-            response = response.json()
-
-        if response['code'] == 429:
-            raise TooManyRequests()
-
-        if response['code'] != 200:
-            raise ServerException(response['code'])
-
-        if not response['text']:
-            raise TranslationNotFound()
-
-        return response['text']
+        if validate_input(text):
+            params = {
+                "text": text,
+                "format": "plain",
+                "lang": self._target if self._source == "auto" else "{}-{}".format(self._source, self._target),
+                "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 ServerException(503)
+            else:
+                response = response.json()
+
+            if response['code'] == 429:
+                raise TooManyRequests()
+
+            if response['code'] != 200:
+                raise ServerException(response['code'])
+
+            if not response['text']:
+                raise TranslationNotFound()
+
+            return response['text']
 
     def translate_file(self, path, **kwargs):
         """

tests/test_libre.py

@@ -9,29 +9,24 @@ from deep_translator.constants import LIBRE_CODES_TO_LANGUAGES
 
 @pytest.fixture
 def libre():
-    return LibreTranslator(source="en", target='fr')
-
-
-def test_content(libre):
-    """Sample pytest test function with the pytest fixture as an argument."""
-    assert libre.translate(text='good') is not None
+    return LibreTranslator(source="en", target='fr', api_key='some_key')
 
 
 def test_inputs():
     with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
-        LibreTranslator(source="", target="")
+        LibreTranslator(source="", target="", api_key='some_key')
 
     with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
-        LibreTranslator(source="auto", target="")
+        LibreTranslator(source="auto", target="", api_key='some_key')
 
     with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
-        LibreTranslator(source="", target="en")
+        LibreTranslator(source="", target="en", api_key='some_key')
 
 
 def test_abbreviations_and_languages_mapping():
     for abb, lang in LIBRE_CODES_TO_LANGUAGES.items():
-        l1 = LibreTranslator(abb)
-        l2 = LibreTranslator(lang)
+        l1 = LibreTranslator(abb, api_key='some_key')
+        l2 = LibreTranslator(lang, api_key='some_key')
         assert l1._source == l2._source
 
 
@@ -44,19 +39,3 @@ def test_payload(libre):
 
     with pytest.raises(exceptions.NotValidPayload):
         libre.translate([])
-
-
-def test_one_character_words():
-    assert LibreTranslator(source='es', target='en').translate('y') == 'and'
-
-
-def test_translate_batch():
-    words_to_translate = ['How are you', 'Good', 'Thank You']
-    translated_words = ['¿Cómo estás?', 'Bien.', 'Gracias.']
-    assert LibreTranslator(source='en', target='es').translate_batch((words_to_translate)) == translated_words
-
-
-def test_translate_file():
-    filePath = 'examples/test.txt'
-    translatedText = 'Un párrafo es una serie de frases relacionadas que desarrollan una idea central, llamada el tema. Trate de pensar en los párrafos en términos de unidad temática: un párrafo es una frase o un grupo de oraciones que apoya una idea central y unificada. Los párrafos añaden una idea a la vez a su argumento más amplio.'
-    assert LibreTranslator(source='en', target='es').translate_file(filePath) == translatedText

tests/test_linguee.py

@@ -8,7 +8,7 @@ from deep_translator import exceptions, LingueeTranslator
 
 @pytest.fixture
 def linguee():
-    return LingueeTranslator(source="english", target='french')
+    return LingueeTranslator(source="english", target='german')
 
 
 def test_content(linguee):

tests/test_microsoft_trans.py

@@ -20,12 +20,12 @@ def test_microsoft_successful_post_mock(mock_request_post):
         r.json = json_func
         return r
     mock_request_post.return_value = res()
-    assert MicrosoftTranslator(api_key="an_api_key", target="en").translate("auf wiedersehen!") == "See you later!"
+    assert MicrosoftTranslator(api_key="an_api_key", source='de', target="en").translate("auf wiedersehen!") == "See you later!"
 
 
 def test_MicrosoftAPIerror():
     with pytest.raises(exceptions.MicrosoftAPIerror):
-        MicrosoftTranslator(api_key="empty", target="en").translate("text")
+        MicrosoftTranslator(api_key="empty", source='de', target="en").translate("text")
 
 
 # the remaining tests are actual requests to Microsoft API and use an api key

tests/test_mymemory.py

@@ -36,9 +36,6 @@ def test_inputs():
 
 def test_payload(mymemory):
 
-    with pytest.raises(exceptions.NotValidPayload):
-        mymemory.translate(text="")
-
     with pytest.raises(exceptions.NotValidPayload):
         mymemory.translate(text=123)