Merge pull request #136 from nidhaloff/features/engine

deep_translator/__init__.py

@@ -1,21 +1,20 @@
 """Top-level package for Deep Translator"""
 
-from .google_trans import GoogleTranslator
+from .google import GoogleTranslator
 from .pons import PonsTranslator
 from .linguee import LingueeTranslator
 from .mymemory import MyMemoryTranslator
 from .yandex import YandexTranslator
-from .qcri import QCRI
-from .deepl import DeepL
+from .qcri import QcriTranslator
+from .deepl import DeeplTranslator
 from .detection import single_detection, batch_detection
 from .microsoft import MicrosoftTranslator
 from .papago import PapagoTranslator
 from .libre import LibreTranslator
-from .engine import generate_engines_dict, engine
 
 __author__ = """Nidhal Baccouri"""
 __email__ = '[email protected]'
-__version__ = '1.6.1'
+__version__ = '1.7.1'
 
 __all__ = [
     "GoogleTranslator",
@@ -24,14 +23,10 @@ __all__ = [
     "MyMemoryTranslator",
     "YandexTranslator",
     "MicrosoftTranslator",
-    "QCRI",
-    "DeepL",
+    "QcriTranslator",
+    "DeeplTranslator",
     "LibreTranslator",
     "PapagoTranslator",
     "single_detection",
     "batch_detection"
 ]
-
-__engines__ = generate_engines_dict(__all__, locals())
-del generate_engines_dict
-engine.translation_engines = __engines__

deep_translator/__main__.py

@@ -1,5 +1,4 @@
 
-import argparse
 from .cli import CLI
 
 

deep_translator/base.py

@@ -0,0 +1,114 @@
+"""base translator class"""
+
+from .constants import GOOGLE_LANGUAGES_TO_CODES
+from .exceptions import InvalidSourceOrTargetLanguage
+from abc import ABC, abstractmethod
+
+
+class BaseTranslator(ABC):
+    """
+    Abstract class that serve as a base translator for other different translators
+    """
+    def __init__(self,
+                 base_url=None,
+                 source="auto",
+                 target="en",
+                 payload_key=None,
+                 element_tag=None,
+                 element_query=None,
+                 languages=None,
+                 **url_params):
+        """
+        @param source: source language to translate from
+        @param target: target language to translate to
+        """
+        self._base_url = base_url
+        self.languages: dict = GOOGLE_LANGUAGES_TO_CODES if not languages else languages
+        self.supported_languages: list = list(self.languages.keys())
+        if not source:
+            raise InvalidSourceOrTargetLanguage(source)
+        if not target:
+            raise InvalidSourceOrTargetLanguage(target)
+
+        self._source, self._target = self._map_language_to_code(source, target)
+        self._url_params = url_params
+        self._element_tag = element_tag
+        self._element_query = element_query
+        self.payload_key = payload_key
+        super().__init__()
+
+    def _type(self):
+        return self.__class__.__name__
+
+    def _map_language_to_code(self, *languages):
+        """
+        map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
+        @param languages: list of languages
+        @return: mapped value of the language or raise an exception if the language is not supported
+        """
+        for language in languages:
+            if language in self.languages.values() or language == 'auto':
+                yield language
+            elif language in self.languages.keys():
+                yield self.languages[language]
+
+    def _same_source_target(self):
+        return self._source == self._target
+
+    def get_supported_languages(self, as_dict=False, **kwargs):
+        """
+        return the supported languages by the google translator
+        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
+        @return: list or dict
+        """
+        return self.supported_languages if not as_dict else self.languages
+
+    def is_language_supported(self, language, **kwargs):
+        """
+        check if the language is supported by the translator
+        @param language: a string for 1 language
+        @return: bool or raise an Exception
+        """
+        if language == 'auto' or language in self.languages.keys() or language in self.languages.values():
+            return True
+        else:
+            return False
+
+    @abstractmethod
+    def translate(self, text, **kwargs):
+        """
+        translate a text using a translator under the hood and return the translated text
+        @param text: text to translate
+        @param kwargs: additional arguments
+        @return: str
+        """
+        return NotImplemented('You need to implement the translate method!')
+
+    def _translate_file(self, path, **kwargs):
+        """
+        translate directly from file
+        @param path: path to the target file
+        @type path: str
+        @param kwargs: additional args
+        @return: str
+        """
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                text = f.read().strip()
+            return self.translate(text)
+        except Exception as e:
+            raise e
+
+    def _translate_batch(self, batch=None, **kwargs):
+        """
+        translate a list of texts
+        @param batch: list of texts you want to translate
+        @return: list of translations
+        """
+        if not batch:
+            raise Exception("Enter your text list that you want to translate")
+        arr = []
+        for i, text in enumerate(batch):
+            translated = self.translate(text, **kwargs)
+            arr.append(translated)
+        return arr

deep_translator/cli.py

@@ -1,6 +1,6 @@
 """Console script for deep_translator."""
-from . import __engines__
 import argparse
+from .engines import __engines__
 
 
 class CLI(object):
@@ -10,7 +10,6 @@ class CLI(object):
     def __init__(self, custom_args=None):
         self.custom_args = custom_args
         self.args = self.parse_args()
-        # print(f'{__engines__}')
         translator_class = self.translators_dict.get(self.args.translator, None)
         if not translator_class:
             raise Exception(f"Translator {self.args.translator} is not supported."
@@ -24,7 +23,7 @@ class CLI(object):
         """
         res = self.translator.translate(self.args.text)
         print("Translation from {} to {}".format(self.args.source, self.args.target))
-        print("-"*50)
+        print("-" * 50)
         print("Translation result: {}".format(res))
 
     def get_supported_languages(self):
@@ -69,7 +68,6 @@ class CLI(object):
                             help="all the languages available with the translator"
                                  "Run the command deep_translator -trans <translator service> -lang")
         parsed_args = parser.parse_args(self.custom_args) if self.custom_args else parser.parse_args()
-        print(f"parsed args: {parsed_args}")
         return parsed_args
 
     def run(self):

deep_translator/constants.py

@@ -8,7 +8,7 @@ BASE_URLS = {
     "MYMEMORY": "http://api.mymemory.translated.net/get",
     "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",
@@ -197,16 +197,6 @@ LINGUEE_LANGUAGES_TO_CODES = {
 
 LINGUEE_CODE_TO_LANGUAGE = {v: k for k, v in LINGUEE_LANGUAGES_TO_CODES.items()}
 
-# "72e9e2cc7c992db4dcbdd6fb9f91a0d1"
-
-# obtaining the current list of supported Microsoft languages for translation
-
-microsoft_languages_api_url = "https://api.cognitive.microsofttranslator.com/languages?api-version=3.0&scope=translation"
-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",

deep_translator/deepl.py

@@ -1,21 +1,21 @@
 import requests
-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,
-                         LanguageNotSupportedException,
                          AuthorizationException)
-from .parent import BaseTranslator
+from deep_translator.base import BaseTranslator
 
 
-class DeepL(object):
+class DeeplTranslator(BaseTranslator):
     """
-    class that wraps functions, which use the DeepL translator under the hood to translate word(s)
+    class that wraps functions, which use the DeeplTranslator translator under the hood to translate word(s)
     """
-    _languages = DEEPL_LANGUAGE_TO_CODE
 
-    def __init__(self, api_key=None, source="en", target="en", use_free_api=True, **kwargs):
+    def __init__(self, api_key=None, source="de", target="en", use_free_api=True, **kwargs):
         """
-        @param api_key: your DeepL api key.
+        @param api_key: your DeeplTranslator api key.
         Get one here: https://www.deepl.com/docs-api/accessing-the-api/
         @param source: source language
         @param target: target language
@@ -24,73 +24,63 @@ class DeepL(object):
             raise ServerException(401)
         self.version = 'v2'
         self.api_key = api_key
-        self.source = self._map_language_to_code(source)
-        self.target = self._map_language_to_code(target)
-        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__(
+            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
         """
-        # 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']
+        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']
+
+    def translate_file(self, path, **kwargs):
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch, **kwargs):
         """
         @param batch: list of texts to translate
         @return: list of translations
         """
-        return [self.translate(text, **kwargs) for text in batch]
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        return [*DeepL._languages.keys()] if not as_dict else DeepL._languages
-
-    def _is_language_supported(self, lang, **kwargs):
-        # The language is supported when is in the dicionary.
-        return lang == 'auto' or lang in self._languages.keys() or lang in self._languages.values()
-
-    def _map_language_to_code(self, lang, **kwargs):
-        if lang in self._languages.keys():
-            return self._languages[lang]
-        elif lang in self._languages.values():
-            return lang
-        raise LanguageNotSupportedException(lang)
-
-
-BaseTranslator.register(DeepL)
+        return self._translate_batch(batch, **kwargs)
 
 
 if __name__ == '__main__':
-    d = DeepL(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/detection.py

@@ -7,6 +7,7 @@ from requests.exceptions import HTTPError
 # Module global config
 config = {"url": 'https://ws.detectlanguage.com/0.2/detect',"headers": {'User-Agent': 'Detect Language API Python Client 1.4.0','Authorization': 'Bearer {}',}}
 
+
 def get_request_body(text, api_key, *args, **kwargs):
     """
     send a request and return the response body parsed as dictionary

deep_translator/engine.py

@@ -1,45 +0,0 @@
-from .parent import BaseTranslator
-
-# BaseTranslator.register(YandexTranslator)
-# BaseTranslator.register(QCRI)
-# BaseTranslator.register(DeepL)
-# BaseTranslator.register(MicrosoftTranslator)
-# BaseTranslator.register(PapagoTranslator)
-
-
-def generate_engines_dict(_all: list, _locals: dict) -> dict:
-    base_translator_type = BaseTranslator
-
-    def is_translator(__object: object) -> bool:
-        try:
-            return issubclass(__object, base_translator_type)
-        except TypeError:
-            return False
-
-    translation_engines = {}
-    for _object in _all:
-        __object = _locals.get(_object, 'failed')
-        key_name = _object.replace('Translator', '').lower()
-        if is_translator(__object):
-            translation_engines.update({key_name: __object})
-    return translation_engines
-
-
-def engine(engine_name: str, *args, **kwargs) -> BaseTranslator:
-    """Return translation engine.
-
-    Free and keyless engines are 'google', 'pons', 'linguee', 'mymemory',
-    'libre'.
-
-    Args:
-        engine_name: the name of the engine
-        *args: positional argument to pass to the engine
-        **kwargs: named argument to pass to the engine
-    Return:
-        A translation engine
-    """
-    try:
-        return engine.translation_engines[engine_name.lower()](*args, **kwargs)
-    except KeyError:
-        keys = '\', \''.join(engine.translation_engines.keys())
-        raise(KeyError(f'Please provide a valid engine name (\'{keys}\')'))

deep_translator/engines.py

@@ -0,0 +1,7 @@
+
+from .base import BaseTranslator
+
+__engines__ = {
+        translator.__name__.replace('Translator', '').lower():
+        translator for translator in BaseTranslator.__subclasses__()
+}

deep_translator/exceptions.py

@@ -43,11 +43,10 @@ class InvalidSourceOrTargetLanguage(BaseError):
 
     def __init__(self,
                  val,
-                 message="source and target language can't be the same"):
+                 message="Invalid source or target language!"):
         super(InvalidSourceOrTargetLanguage, self).__init__(val, message)
 
 
-
 class TranslationNotFound(BaseError):
     """
     exception thrown if no translation was found for the text provided by the user

deep_translator/{google_trans.py → google.py}

@@ -2,118 +2,52 @@
 google translator API
 """
 
-from .constants import BASE_URLS, GOOGLE_LANGUAGES_TO_CODES, GOOGLE_LANGUAGES_SECONDARY_NAMES
-from .exceptions import TooManyRequests, LanguageNotSupportedException, TranslationNotFound, NotValidPayload, RequestError
-from .parent import BaseTranslator
+from deep_translator.constants import BASE_URLS
+from deep_translator.exceptions import TooManyRequests, TranslationNotFound, RequestError
+from deep_translator.base import BaseTranslator
+from deep_translator.validate import validate_input, is_empty
 from bs4 import BeautifulSoup
 import requests
-from time import sleep
-import warnings
-import logging
 
 
 class GoogleTranslator(BaseTranslator):
     """
     class that wraps functions, which use google translate under the hood to translate text(s)
     """
-    _languages = GOOGLE_LANGUAGES_TO_CODES
-    supported_languages = list(_languages.keys())
 
     def __init__(self, source="auto", target="en", proxies=None, **kwargs):
         """
         @param source: source language to translate from
         @param target: target language to translate to
         """
-        self.__base_url = BASE_URLS.get("GOOGLE_TRANSLATE")
         self.proxies = proxies
-
-        # code snipppet that converts the language into lower-case and skip lower-case conversion for abbreviations
-        # since abbreviations like zh-CN if converted to lower-case will result into error
-        #######################################
-        source_lower = source
-        target_lower = target
-        if not source in self._languages.values():
-            source_lower=source.lower()
-        if not target in self._languages.values():
-            target_lower=target.lower()
-        #######################################
-
-        if self.is_language_supported(source_lower, target_lower):
-            self._source, self._target = self._map_language_to_code(source_lower, target_lower)
-
-        super(GoogleTranslator, self).__init__(base_url=self.__base_url,
-                                               source=self._source,
-                                               target=self._target,
-                                               element_tag='div',
-                                               element_query={"class": "t0"},
-                                               payload_key='q',  # key of text in the url
-                                               tl=self._target,
-                                               sl=self._source,
-                                               **kwargs)
+        super().__init__(base_url=BASE_URLS.get("GOOGLE_TRANSLATE"),
+                         source=source,
+                         target=target,
+                         element_tag='div',
+                         element_query={"class": "t0"},
+                         payload_key='q',  # key of text in the url
+                         **kwargs)
 
         self._alt_element_query = {"class": "result-container"}
 
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-        return the supported languages by the google translator
-        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-        @return: list or dict
-        """
-        return GoogleTranslator.supported_languages if not as_dict else GoogleTranslator._languages
-
-    def is_secondary(self, lang):
-        """
-        Function to check if lang is a secondary name of any primary language
-        @param lang: language name
-        @return: primary name of a language if found otherwise False
-        """
-        for primary_name, secondary_names in GOOGLE_LANGUAGES_SECONDARY_NAMES.items():
-            if lang in secondary_names:
-                return primary_name
-        return False
-
-    def _map_language_to_code(self, *languages):
-        """
-        map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-        @param languages: list of languages
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        for language in languages:
-            if language in self._languages.values() or language == 'auto':
-                yield language
-            elif language in self._languages.keys():
-                yield self._languages[language]
-            else:
-                yield self._languages[self.is_secondary(language)]
-
-    def is_language_supported(self, *languages):
-        """
-        check if the language is supported by the translator
-        @param languages: list of languages
-        @return: bool or raise an Exception
-        """
-        for lang in languages:
-            if lang != 'auto' and lang not in self._languages.keys():
-                if lang != 'auto' and lang not in self._languages.values():
-                    if not self.is_secondary(lang):
-                        raise LanguageNotSupportedException(lang)
-        return True
-
     def translate(self, text, **kwargs):
         """
         function that uses google translate to translate a text
         @param text: desired text to translate
         @return: str: translated text
         """
-
-        if self._validate_payload(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
 
             if self.payload_key:
                 self._url_params[self.payload_key] = text
 
-            response = requests.get(self.__base_url,
+            response = requests.get(self._base_url,
                                     params=self._url_params,
                                     proxies=self.proxies)
             if response.status_code == 429:
@@ -151,37 +85,7 @@ class GoogleTranslator(BaseTranslator):
         @param kwargs: additional args
         @return: str
         """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read().strip()
-            return self.translate(text)
-        except Exception as e:
-            raise e
-
-    def translate_sentences(self, sentences=None, **kwargs):
-        """
-        translate many sentences together. This makes sense if you have sentences with different languages
-        and you want to translate all to unified language. This is handy because it detects
-        automatically the language of each sentence and then translate it.
-
-        @param sentences: list of sentences to translate
-        @return: list of all translated sentences
-        """
-        warnings.warn("deprecated. Use the translate_batch function instead", DeprecationWarning, stacklevel=2)
-        logging.warning("deprecated. Use the translate_batch function instead")
-        if not sentences:
-            raise NotValidPayload(sentences)
-
-        translated_sentences = []
-        try:
-            for sentence in sentences:
-                translated = self.translate(text=sentence)
-                translated_sentences.append(translated)
-
-            return translated_sentences
-
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch=None, **kwargs):
         """
@@ -189,12 +93,9 @@ class GoogleTranslator(BaseTranslator):
         @param batch: list of texts you want to translate
         @return: list of translations
         """
-        if not batch:
-            raise Exception("Enter your text list that you want to translate")
-        arr = []
-        for i, text in enumerate(batch):
+        return self._translate_batch(batch, **kwargs)
 
-            translated = self.translate(text, **kwargs)
-            arr.append(translated)
-        return arr
 
+if __name__ == '__main__':
+    t = GoogleTranslator().translate("hallo welt")
+    print("translation: ", t)

deep_translator/libre.py

@@ -3,71 +3,34 @@ LibreTranslate API
 """
 
 import requests
-from .parent import BaseTranslator
-from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES, LIBRE_CODES_TO_LANGUAGES
+
+from .validate import is_empty, validate_input
+from .base import BaseTranslator
+from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES
 from .exceptions import (ServerException,
-                        TranslationNotFound,
-                        LanguageNotSupportedException,
-                        AuthorizationException,
-                        NotValidPayload)
+                         TranslationNotFound,
+                         AuthorizationException)
 
 
 class LibreTranslator(BaseTranslator):
     """
     class that wraps functions, which use libre translator under the hood to translate text(s)
     """
-    _languages = LIBRE_LANGUAGES_TO_CODES
-    supported_languages = list(_languages.keys())
 
-    def __init__(self,source="auto", target="en", base_url = BASE_URLS.get("LIBRE_FREE"), api_key=None, **kwargs):
+    def __init__(self, source="auto", target="en", api_key=None, **kwargs):
         """
         @param source: source language to translate from
         List of LibreTranslate nedpoints can be found at : https://github.com/LibreTranslate/LibreTranslate#mirrors
         Some require an API key
         @param target: target language to translate to
         """
-        if base_url == BASE_URLS.get("LIBRE") and not api_key:
+        if not api_key:
             raise ServerException(401)
-        self.__base_url = base_url
         self.api_key = api_key
-        if source == "auto":
-            self.source = "auto"
-        else:
-            self.source = self._map_language_to_code(source)
-        self.target = self._map_language_to_code(target)
-
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-        return the supported languages by the libre translator
-        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-        @return: list or dict
-        """
-        return [*LibreTranslator._languages.keys()] if not as_dict else LibreTranslator._languages
-
-    def _map_language_to_code(self, language, **kwargs):
-        """
-        map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-        @param language: a string for 1 language
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        if language in self._languages.keys():
-            return self._languages[language]
-        elif language in self._languages.values():
-            return language
-        raise LanguageNotSupportedException(language)
-
-    def _is_language_supported(self, language, **kwargs):
-        """
-        check if the language is supported by the translator
-        @param language: a string for 1 language
-        @return: bool or raise an Exception
-        """
-        if language == 'auto' or language in self._languages.keys() or language in self._languages.values():
-            return True
-        else:
-            raise LanguageNotSupportedException(language)
+        super().__init__(base_url=BASE_URLS.get("LIBRE"),
+                         source=source,
+                         target=target,
+                         languages=LIBRE_LANGUAGES_TO_CODES)
 
     def translate(self, text, **kwargs):
         """
@@ -75,37 +38,37 @@ class LibreTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
-         # Create the request parameters.
-        if type(text) != str or text == "":
-            raise NotValidPayload(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):
         """
@@ -115,12 +78,7 @@ class LibreTranslator(BaseTranslator):
         @param kwargs: additional args
         @return: str
         """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read().strip()
-            return self.translate(text)
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch=None, **kwargs):
         """
@@ -128,10 +86,4 @@ class LibreTranslator(BaseTranslator):
         @param batch: list of texts you want to translate
         @return: list of translations
         """
-        if not batch:
-            raise Exception("Enter your text list that you want to translate")
-        arr = []
-        for i, text in enumerate(batch):
-            translated = self.translate(text, **kwargs)
-            arr.append(translated)
-        return arr
+        return self._translate_batch(batch, **kwargs)

deep_translator/linguee.py

@@ -1,15 +1,15 @@
 """
 linguee translator API
 """
-
-from .constants import BASE_URLS, LINGUEE_LANGUAGES_TO_CODES, LINGUEE_CODE_TO_LANGUAGE
-from .exceptions import (LanguageNotSupportedException,
+from .validate import validate_input, is_empty
+from .constants import BASE_URLS, LINGUEE_LANGUAGES_TO_CODES
+from .exceptions import (
                         TranslationNotFound,
                         NotValidPayload,
                         ElementNotFoundInGetRequest,
                         RequestError,
                         TooManyRequests)
-from .parent import BaseTranslator
+from .base import BaseTranslator
 from bs4 import BeautifulSoup
 import requests
 from requests.utils import requote_uri
@@ -19,63 +19,22 @@ class LingueeTranslator(BaseTranslator):
     """
     class that wraps functions, which use the linguee translator under the hood to translate word(s)
     """
-    _languages = LINGUEE_LANGUAGES_TO_CODES
-    supported_languages = list(_languages.keys())
 
     def __init__(self, source, target="en", proxies=None, **kwargs):
         """
         @param source: source language to translate from
         @param target: target language to translate to
         """
-        self.__base_url = BASE_URLS.get("LINGUEE")
         self.proxies = proxies
-
-        if self.is_language_supported(source, target):
-            self._source, self._target = self._map_language_to_code(source.lower(), target.lower())
-
-        super().__init__(base_url=self.__base_url,
-                         source=self._source,
-                         target=self._target,
+        super().__init__(base_url=BASE_URLS.get("LINGUEE"),
+                         source=source,
+                         target=target,
+                         languages=LINGUEE_LANGUAGES_TO_CODES,
                          element_tag='a',
                          element_query={'class': 'dictLink featured'},
                          payload_key=None,  # key of text in the url
                         )
 
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-        return the supported languages by the linguee translator
-        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-        @return: list or dict
-        """
-        return LingueeTranslator.supported_languages if not as_dict else LingueeTranslator._languages
-
-    def _map_language_to_code(self, *languages, **kwargs):
-        """
-         map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-         @param languages: list of languages
-         @return: mapped value of the language or raise an exception if the language is not supported
-         """
-        for language in languages:
-            if language in self._languages.values():
-                yield LINGUEE_CODE_TO_LANGUAGE[language]
-            elif language in self._languages.keys():
-                yield language
-            else:
-                raise LanguageNotSupportedException(language)
-
-    def is_language_supported(self, *languages, **kwargs):
-        """
-        check if the language is supported by the translator
-        @param languages: list of languages
-        @return: bool or raise an Exception
-        """
-        for lang in languages:
-            if lang not in self._languages.keys():
-                if lang not in self._languages.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
-
     def translate(self, word, return_all=False, **kwargs):
         """
         function that uses linguee to translate a word
@@ -85,9 +44,12 @@ class LingueeTranslator(BaseTranslator):
         @type return_all: bool
         @return: str: translated word
         """
-        if self._validate_payload(word, max_chars=50):
+        if self._same_source_target() or is_empty(word):
+            return word
+
+        if validate_input(word, max_chars=50):
             # %s-%s/translation/%s.html
-            url = "{}{}-{}/translation/{}.html".format(self.__base_url, self._source, self._target, word)
+            url = "{}{}-{}/translation/{}.html".format(self._base_url, self._source, self._target, word)
             url = requote_uri(url)
             response = requests.get(url, proxies=self.proxies)
 

deep_translator/microsoft.py

@@ -3,31 +3,30 @@
 import requests
 import logging
 import sys
+from .constants import BASE_URLS
+from .exceptions import ServerException, MicrosoftAPIerror
+from .base import BaseTranslator
+from .validate import validate_input
 
-from .constants import BASE_URLS, MICROSOFT_CODES_TO_LANGUAGES
-from .exceptions import LanguageNotSupportedException, ServerException, MicrosoftAPIerror
-from .parent import BaseTranslator
 
-
-class MicrosoftTranslator:
+class MicrosoftTranslator(BaseTranslator):
     """
     the class that wraps functions, which use the Microsoft translator under the hood to translate word(s)
     """
 
-    _languages = MICROSOFT_CODES_TO_LANGUAGES
-    supported_languages = list(_languages.values())
-
     def __init__(self, api_key=None, region=None, source=None, target=None, proxies=None, **kwargs):
         """
         @params api_key and target are the required params
         @param api_key: your Microsoft API key
         @param region: your Microsoft Location
         """
+
+        MICROSOFT_CODES_TO_LANGUAGES = self._get_supported_languages()
+
         if not api_key:
             raise ServerException(401)
-        else:
-            self.api_key = api_key
 
+        self.api_key = api_key
         self.proxies = proxies
         self.headers = {
             "Ocp-Apim-Subscription-Key": self.api_key,
@@ -37,65 +36,22 @@ class MicrosoftTranslator:
         if region:
             self.region = region
             self.headers["Ocp-Apim-Subscription-Region"] = self.region
+        super().__init__(
+            base_url=BASE_URLS.get("MICROSOFT_TRANSLATE"),
+            source=source,
+            target=target,
+            languages=MICROSOFT_CODES_TO_LANGUAGES,
+            **kwargs
+        )
 
-        if not target:
-            raise ServerException(401)
-        else:
-            if type(target) is str:
-                self.target = target.lower()
-            else:
-                self.target = [i.lower() for i in target]
-            if self.is_language_supported(self.target):
-                self.target = self._map_language_to_code(self.target)
-
-        self.url_params = {'to': self.target, **kwargs}
-
-        if source:
-            self.source = source.lower()
-            if self.is_language_supported(self.source):
-                self.source = self._map_language_to_code(self.source)
-            self.url_params['from'] = self.source
-
-        self.__base_url = BASE_URLS.get("MICROSOFT_TRANSLATE")
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-        return the languages supported by the microsoft translator
-        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-        @return: list or dict
-        """
-        return MicrosoftTranslator.supported_languages if not as_dict else MicrosoftTranslator._languages
+    def _get_supported_languages(self):
 
-    def _map_language_to_code(self, language, **kwargs):
-        """
-        map the language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-        @param language: a string (if 1 lang) or a list (if multiple langs)
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        if type(language) is str:
-            language = [language]
-        for lang in language:
-            if lang in self._languages.values():
-                yield lang
-            elif lang in self._languages.keys():
-                yield self._languages[lang]
-            else:
-                raise LanguageNotSupportedException(lang)
-
-    def is_language_supported(self, language, **kwargs):
-        """
-        check if the language is supported by the translator
-        @param language: a string (if 1 lang) or a list (if multiple langs)
-        @return: bool or raise an Exception
-        """
-        if type(language) is str:
-            language = [language]
-        for lang in language:
-            if lang not in self._languages.keys():
-                if lang not in self._languages.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
+        microsoft_languages_api_url = \
+            "https://api.cognitive.microsofttranslator.com/languages?api-version=3.0&scope=translation"
+        microsoft_languages_response = requests.get(microsoft_languages_api_url)
+        translation_dict = microsoft_languages_response.json()['translation']
+
+        return {translation_dict[k]['name'].lower(): k for k in translation_dict.keys()}
 
     def translate(self, text, **kwargs):
         """
@@ -105,26 +61,31 @@ class MicrosoftTranslator:
         """
         # 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
-        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):
         """
@@ -132,12 +93,7 @@ class MicrosoftTranslator:
         @param path: path to file
         @return: translated text
         """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read().strip()
-            return self.translate(text)
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch, **kwargs):
         """
@@ -145,7 +101,4 @@ class MicrosoftTranslator:
         @param batch: list of texts to translate
         @return: list of translations
         """
-        return [self.translate(text, **kwargs) for text in batch]
-
-
-BaseTranslator.register(MicrosoftTranslator)
+        return self._translate_batch(batch, **kwargs)

deep_translator/mymemory.py

@@ -1,79 +1,32 @@
 """
 mymemory translator API
 """
-import logging
-import warnings
-
-from .constants import BASE_URLS, GOOGLE_LANGUAGES_TO_CODES
-from .exceptions import (NotValidPayload,
+from .validate import is_empty, validate_input
+from .constants import BASE_URLS
+from .exceptions import (
                         TranslationNotFound,
-                        LanguageNotSupportedException,
                         RequestError,
                         TooManyRequests)
-from .parent import BaseTranslator
+from .base import BaseTranslator
 import requests
-from time import sleep
 
 
 class MyMemoryTranslator(BaseTranslator):
     """
     class that uses the mymemory translator to translate texts
     """
-    _languages = GOOGLE_LANGUAGES_TO_CODES
-    supported_languages = list(_languages.keys())
-
     def __init__(self, source="auto", target="en", proxies=None, **kwargs):
         """
         @param source: source language to translate from
         @param target: target language to translate to
         """
-        self.__base_url = BASE_URLS.get("MYMEMORY")
         self.proxies = proxies
-        if self.is_language_supported(source, target):
-            self._source, self._target = self._map_language_to_code(source.lower(), target.lower())
-            self._source = self._source if self._source != 'auto' else 'Lao'
-
         self.email = kwargs.get('email', None)
-        super(MyMemoryTranslator, self).__init__(base_url=self.__base_url,
-                                                 source=self._source,
-                                                 target=self._target,
-                                                 payload_key='q',
-                                                 langpair='{}|{}'.format(self._source, self._target))
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-         return the supported languages by the mymemory translator
-         @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-         @return: list or dict
-         """
-        return MyMemoryTranslator.supported_languages if not as_dict else MyMemoryTranslator._languages
-
-    def _map_language_to_code(self, *languages):
-        """
-          map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-          @param languages: list of languages
-          @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        for language in languages:
-            if language in self._languages.values() or language == 'auto':
-                yield language
-            elif language in self._languages.keys():
-                yield self._languages[language]
-            else:
-                raise LanguageNotSupportedException(language)
-
-    def is_language_supported(self, *languages):
-        """
-        check if the language is supported by the translator
-        @param languages: list of languages
-        @return: bool or raise an Exception
-        """
-        for lang in languages:
-            if lang != 'auto' and lang not in self._languages.keys():
-                if lang != 'auto' and lang not in self._languages.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
+        super().__init__(base_url=BASE_URLS.get("MYMEMORY"),
+                         source=source,
+                         target=target,
+                         payload_key='q',
+                        )
 
     def translate(self, text, return_all=False, **kwargs):
         """
@@ -83,18 +36,19 @@ class MyMemoryTranslator(BaseTranslator):
         @param return_all: set to True to return all synonym/similars of the translated text
         @return: str or list
         """
-
-        if self._validate_payload(text, max_chars=500):
+        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:
                 self._url_params['de'] = self.email
 
-            response = requests.get(self.__base_url,
+            response = requests.get(self._base_url,
                                     params=self._url_params,
-                                    headers=self.headers,
                                     proxies=self.proxies)
 
             if response.status_code == 429:
@@ -116,32 +70,6 @@ class MyMemoryTranslator(BaseTranslator):
                 next_match = next(matches)
                 return next_match if not return_all else list(all_matches)
 
-    def translate_sentences(self, sentences=None, **kwargs):
-        """
-        translate many sentences together. This makes sense if you have sentences with different languages
-        and you want to translate all to unified language. This is handy because it detects
-        automatically the language of each sentence and then translate it.
-
-        @param sentences: list of sentences to translate
-        @return: list of all translated sentences
-        """
-        warn_msg = "deprecated. Use the translate_batch function instead"
-        warnings.warn(warn_msg, DeprecationWarning, stacklevel=2)
-        logging.warning(warn_msg)
-        if not sentences:
-            raise NotValidPayload(sentences)
-
-        translated_sentences = []
-        try:
-            for sentence in sentences:
-                translated = self.translate(text=sentence, **kwargs)
-                translated_sentences.append(translated)
-
-            return translated_sentences
-
-        except Exception as e:
-            raise e
-
     def translate_file(self, path, **kwargs):
         """
          translate directly from file
@@ -150,13 +78,7 @@ class MyMemoryTranslator(BaseTranslator):
          @param kwargs: additional args
          @return: str
          """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read().strip()
-
-            return self.translate(text=text)
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch=None, **kwargs):
         """
@@ -164,13 +86,4 @@ class MyMemoryTranslator(BaseTranslator):
         @param batch: list of texts you want to translate
         @return: list of translations
         """
-        if not batch:
-            raise Exception("Enter your text list that you want to translate")
-
-        arr = []
-        for text in batch:
-            translated = self.translate(text, **kwargs)
-            arr.append(translated)
-            sleep(2)
-
-        return arr
+        return self._translate_batch(batch, **kwargs)

deep_translator/papago.py

@@ -3,19 +3,17 @@ google translator API
 """
 import json
 from .constants import BASE_URLS, PAPAGO_LANGUAGE_TO_CODE
-from .exceptions import LanguageNotSupportedException, TranslationNotFound, NotValidPayload
-from .parent import BaseTranslator
+from .exceptions import TranslationNotFound
+from .base import BaseTranslator
 import requests
-import warnings
-import logging
 
+from .validate import validate_input
 
-class PapagoTranslator(object):
+
+class PapagoTranslator(BaseTranslator):
     """
     class that wraps functions, which use google translate under the hood to translate text(s)
     """
-    _languages = PAPAGO_LANGUAGE_TO_CODE
-    supported_languages = list(_languages.keys())
 
     def __init__(self, client_id=None, secret_key=None, source="auto", target="en", **kwargs):
         """
@@ -26,47 +24,15 @@ class PapagoTranslator(object):
             raise Exception(
                 "Please pass your client id and secret key! visit the papago website for more infos")
 
-        self.__base_url = BASE_URLS.get("PAPAGO_API")
         self.client_id = client_id
         self.secret_key = secret_key
-        if self.is_language_supported(source, target):
-            self._source, self._target = self._map_language_to_code(
-                source.lower(), target.lower())
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-        return the supported languages by the google translator
-        @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-        @return: list or dict
-        """
-        return PapagoTranslator.supported_languages if not as_dict else PapagoTranslator._languages
-
-    def _map_language_to_code(self, *languages):
-        """
-        map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-        @param languages: list of languages
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        for language in languages:
-            if language in self._languages.values() or language == 'auto':
-                yield language
-            elif language in self._languages.keys():
-                yield self._languages[language]
-            else:
-                raise LanguageNotSupportedException(language)
-
-    def is_language_supported(self, *languages):
-        """
-        check if the language is supported by the translator
-        @param languages: list of languages
-        @return: bool or raise an Exception
-        """
-        for lang in languages:
-            if lang != 'auto' and lang not in self._languages.keys():
-                if lang != 'auto' and lang not in self._languages.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
+        super().__init__(
+            base_url=BASE_URLS.get("PAPAGO_API"),
+            source=source,
+            target=target,
+            languages=PAPAGO_LANGUAGE_TO_CODE,
+            **kwargs
+        )
 
     def translate(self, text, **kwargs):
         """
@@ -74,32 +40,32 @@ class PapagoTranslator(object):
         @param text: desired text to translate
         @return: str: translated 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
+        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)
+
+            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):
         """
@@ -109,38 +75,7 @@ class PapagoTranslator(object):
         @param kwargs: additional args
         @return: str
         """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read().strip()
-            return self.translate(text)
-        except Exception as e:
-            raise e
-
-    def translate_sentences(self, sentences=None, **kwargs):
-        """
-        translate many sentences together. This makes sense if you have sentences with different languages
-        and you want to translate all to unified language. This is handy because it detects
-        automatically the language of each sentence and then translate it.
-
-        @param sentences: list of sentences to translate
-        @return: list of all translated sentences
-        """
-        warnings.warn("deprecated. Use the translate_batch function instead",
-                      DeprecationWarning, stacklevel=2)
-        logging.warning("deprecated. Use the translate_batch function instead")
-        if not sentences:
-            raise NotValidPayload(sentences)
-
-        translated_sentences = []
-        try:
-            for sentence in sentences:
-                translated = self.translate(text=sentence)
-                translated_sentences.append(translated)
-
-            return translated_sentences
-
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch=None, **kwargs):
         """
@@ -148,14 +83,4 @@ class PapagoTranslator(object):
         @param batch: list of texts you want to translate
         @return: list of translations
         """
-        if not batch:
-            raise Exception("Enter your text list that you want to translate")
-        arr = []
-        for i, text in enumerate(batch):
-
-            translated = self.translate(text, **kwargs)
-            arr.append(translated)
-        return arr
-
-
-BaseTranslator.register(PapagoTranslator)
+        return self._translate_batch(batch, **kwargs)

deep_translator/parent.py

@@ -1,80 +0,0 @@
-"""parent translator class"""
-
-from .exceptions import NotValidPayload, NotValidLength, InvalidSourceOrTargetLanguage
-from abc import ABC, abstractmethod
-import string
-
-
-class BaseTranslator(ABC):
-    """
-    Abstract class that serve as a parent translator for other different translators
-    """
-    def __init__(self,
-                 base_url=None,
-                 source="auto",
-                 target="en",
-                 payload_key=None,
-                 element_tag=None,
-                 element_query=None,
-                 **url_params):
-        """
-        @param source: source language to translate from
-        @param target: target language to translate to
-        """
-        if source == target:
-            raise InvalidSourceOrTargetLanguage(source)
-
-        self.__base_url = base_url
-        self._source = source
-        self._target = target
-        self._url_params = url_params
-        self._element_tag = element_tag
-        self._element_query = element_query
-        self.payload_key = payload_key
-        self.headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) '
-                                      'AppleWebit/535.19'
-                                      '(KHTML, like Gecko) Chrome/18.0.1025.168 Safari/535.19'}
-        super(BaseTranslator, self).__init__()
-
-    @staticmethod
-    def _validate_payload(payload, min_chars=1, max_chars=5000):
-        """
-        validate the target text to translate
-        @param payload: text to translate
-        @return: bool
-        """
-
-        if not payload or not isinstance(payload, str) or not payload.strip() or payload.isdigit():
-            raise NotValidPayload(payload)
-
-        # check if payload contains only symbols
-        if all(i in string.punctuation for i in payload):
-            raise NotValidPayload(payload)
-
-        if not BaseTranslator.__check_length(payload, min_chars, max_chars):
-            raise NotValidLength(payload, min_chars, max_chars)
-        return True
-
-    @staticmethod
-    def __check_length(payload, min_chars, max_chars):
-        """
-        check length of the provided target text to translate
-        @param payload: text to translate
-        @param min_chars: minimum characters allowed
-        @param max_chars: maximum characters allowed
-        @return: bool
-        """
-        return True if min_chars <= len(payload) < max_chars else False
-
-    @abstractmethod
-    def translate(self, text, **kwargs):
-        """
-        translate a text using a translator under the hood and return the translated text
-        @param text: text to translate
-        @param kwargs: additional arguments
-        @return: str
-        """
-        return NotImplemented('You need to implement the translate method!')
-
-
-

deep_translator/pons.py

@@ -3,14 +3,16 @@ pons translator API
 """
 from bs4 import BeautifulSoup
 import requests
-from .constants import BASE_URLS, PONS_LANGUAGES_TO_CODES, PONS_CODES_TO_LANGUAGES
-from .exceptions import (LanguageNotSupportedException,
+
+from .validate import validate_input, is_empty
+from .constants import BASE_URLS, PONS_CODES_TO_LANGUAGES
+from .exceptions import (
                         TranslationNotFound,
                         NotValidPayload,
                         ElementNotFoundInGetRequest,
                         RequestError,
                         TooManyRequests)
-from .parent import BaseTranslator
+from .base import BaseTranslator
 from requests.utils import requote_uri
 
 
@@ -18,62 +20,23 @@ class PonsTranslator(BaseTranslator):
     """
     class that uses PONS translator to translate words
     """
-    _languages = PONS_LANGUAGES_TO_CODES
-    supported_languages = list(_languages.keys())
 
     def __init__(self, source, target="en", proxies=None, **kwargs):
         """
         @param source: source language to translate from
         @param target: target language to translate to
         """
-        self.__base_url = BASE_URLS.get("PONS")
         self.proxies = proxies
-        if self.is_language_supported(source, target):
-            self._source, self._target = self._map_language_to_code(source, target)
-
-        super().__init__(base_url=self.__base_url,
-                         source=self._source,
-                         target=self._target,
+        super().__init__(base_url=BASE_URLS.get("PONS"),
+                         languages=PONS_CODES_TO_LANGUAGES,
+                         source=source,
+                         target=target,
                          payload_key=None,
                          element_tag='div',
-                         element_query={"class": "target"}
+                         element_query={"class": "target"},
+                         **kwargs
                          )
 
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """
-          return the supported languages by the linguee translator
-          @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
-          @return: list or dict
-          """
-        return PonsTranslator.supported_languages if not as_dict else PonsTranslator._languages
-
-    def _map_language_to_code(self, *languages, **kwargs):
-        """
-           map language to its corresponding code (abbreviation) if the language was passed by its full name by the user
-           @param languages: list of languages
-           @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        for language in languages:
-            if language in self._languages.values():
-                yield PONS_CODES_TO_LANGUAGES[language]
-            elif language in self._languages.keys():
-                yield language
-            else:
-                raise LanguageNotSupportedException(language)
-
-    def is_language_supported(self, *languages, **kwargs):
-        """
-         check if the language is supported by the translator
-         @param languages: list of languages
-         @return: bool or raise an Exception
-         """
-        for lang in languages:
-            if lang not in self._languages.keys():
-                if lang not in self._languages.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
-
     def translate(self, word, return_all=False, **kwargs):
         """
         function that uses PONS to translate a word
@@ -83,8 +46,10 @@ class PonsTranslator(BaseTranslator):
         @type return_all: bool
         @return: str: translated word
         """
-        if self._validate_payload(word, max_chars=50):
-            url = "{}{}-{}/{}".format(self.__base_url, self._source, self._target, 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)
 
@@ -104,9 +69,7 @@ class PonsTranslator(BaseTranslator):
             for el in elements:
                 temp = ''
                 for e in el.findAll('a'):
-                    if e.parent.name == 'div':
-                        if e and "/translate/{}-{}/".format(self._target, self._source) in e.get('href'):
-                            temp += e.get_text() + ' '
+                    temp += e.get_text() + ' '
                 filtered_elements.append(temp)
 
             if not filtered_elements:

deep_translator/qcri.py

@@ -2,10 +2,10 @@
 import requests
 from .constants import BASE_URLS, QCRI_LANGUAGE_TO_CODE
 from .exceptions import (ServerException, TranslationNotFound)
-from .parent import BaseTranslator
+from .base import BaseTranslator
 
 
-class QCRI(object):
+class QcriTranslator(BaseTranslator):
     """
     class that wraps functions, which use the QRCI translator under the hood to translate word(s)
     """
@@ -17,9 +17,6 @@ class QCRI(object):
 
         if not api_key:
             raise ServerException(401)
-        self.__base_url = BASE_URLS.get("QCRI")
-        self.source = source
-        self.target = target
         self.api_key = api_key
         self.api_endpoints = {
             "get_languages": "getLanguagePairs",
@@ -30,25 +27,24 @@ class QCRI(object):
         self.params = {
             "key": self.api_key
         }
+        super().__init__(
+            base_url=BASE_URLS.get("QcriTranslator"),
+            source=source,
+            target=target,
+            languages=QCRI_LANGUAGE_TO_CODE,
+            **kwargs
+        )
 
     def _get(self, endpoint, params=None, return_text=True):
         if not params:
             params = self.params
         try:
-            res = requests.get(self.__base_url.format(
+            res = requests.get(self._base_url.format(
                 endpoint=self.api_endpoints[endpoint]), params=params)
             return res.text if return_text else res
         except Exception as e:
             raise e
 
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        # Have no use for this as the format is not what we need
-        # Save this for whenever
-        # pairs = self._get("get_languages")
-        # Using a this one instead
-        return [*QCRI_LANGUAGE_TO_CODE.keys()] if not as_dict else QCRI_LANGUAGE_TO_CODE
-
     @property
     def languages(self):
         return self.get_supported_languages()
@@ -61,11 +57,11 @@ class QCRI(object):
     def domains(self):
         return self.get_domains()
 
-    def translate(self, text, domain, **kwargs):
+    def translate(self, text, **kwargs):
         params = {
             "key": self.api_key,
-            "langpair": "{}-{}".format(self.source, self.target),
-            "domain": domain,
+            "langpair": "{}-{}".format(self._source, self._target),
+            "domain": kwargs["domain"],
             "text": text
         }
         try:
@@ -83,14 +79,14 @@ class QCRI(object):
                     raise TranslationNotFound(text)
                 return translation
 
-    def translate_batch(self, batch, domain, **kwargs):
+    def translate_file(self, path, **kwargs):
+        return self._translate_file(path, **kwargs)
+
+    def translate_batch(self, batch, **kwargs):
         """
         translate a batch of texts
         @domain: domain
         @param batch: list of texts to translate
         @return: list of translations
         """
-        return [self.translate(domain, text, **kwargs) for text in batch]
-
-
-BaseTranslator.register(QCRI)
+        return self._translate_batch(batch, **kwargs)

deep_translator/validate.py

@@ -0,0 +1,24 @@
+
+from .exceptions import NotValidPayload, NotValidLength
+import string
+
+
+def is_empty(text: str):
+    return text == ""
+
+
+def validate_input(text: str, min_chars: int = 0, max_chars: int = 5000):
+    """
+    validate the target text to translate
+    @param min_chars: min characters
+    @param max_chars: max characters
+    @param text: text to translate
+    @return: bool
+    """
+
+    if not isinstance(text, str) or text.isdigit():
+        raise NotValidPayload(text)
+    if not min_chars <= len(text) < max_chars:
+        raise NotValidLength(text, min_chars, max_chars)
+
+    return True

deep_translator/yandex.py

@@ -5,10 +5,10 @@ import requests
 from .constants import BASE_URLS
 from .exceptions import (RequestError, ServerException,
                          TranslationNotFound, TooManyRequests)
-from .parent import BaseTranslator
+from .base import BaseTranslator
 
 
-class YandexTranslator(object):
+class YandexTranslator(BaseTranslator):
     """
     class that wraps functions, which use the yandex translator under the hood to translate word(s)
     """
@@ -19,10 +19,6 @@ class YandexTranslator(object):
         """
         if not api_key:
             raise ServerException(401)
-        self.__base_url = BASE_URLS.get("YANDEX")
-        self.source = source
-        self.target = target
-
         self.api_key = api_key
         self.api_version = "v1.5"
         self.api_endpoints = {
@@ -30,13 +26,12 @@ class YandexTranslator(object):
             "detect": "detect",
             "translate": "translate",
         }
-
-    @staticmethod
-    def get_supported_languages(as_dict=False, **kwargs):
-        """ this method is just for consistency."""
-        return """ this method is just for consistency. You need to create an instance of yandex and access
-                    supported languages using the languages property or call _get_supported_languages
-                """
+        super().__init__(
+            base_url=BASE_URLS.get("YANDEX"),
+            source=source,
+            target=target,
+            **kwargs
+        )
 
     def _get_supported_languages(self):
         return set(x.split("-")[0] for x in self.dirs)
@@ -49,7 +44,7 @@ class YandexTranslator(object):
     def dirs(self, proxies=None):
 
         try:
-            url = self.__base_url.format(
+            url = self._base_url.format(
                 version=self.api_version, endpoint="getLangs")
             print("url: ", url)
             response = requests.get(
@@ -71,7 +66,7 @@ class YandexTranslator(object):
             "key": self.api_key,
         }
         try:
-            url = self.__base_url.format(
+            url = self._base_url.format(
                 version=self.api_version, endpoint="detect")
             response = requests.post(url, data=params, proxies=proxies)
 
@@ -92,31 +87,32 @@ class YandexTranslator(object):
         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):
         """
@@ -124,13 +120,7 @@ class YandexTranslator(object):
         @param path: path to file
         @return: translated text
         """
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                text = f.read()
-
-            return self.translate(text)
-        except Exception as e:
-            raise e
+        return self._translate_file(path, **kwargs)
 
     def translate_batch(self, batch, **kwargs):
         """
@@ -138,7 +128,5 @@ class YandexTranslator(object):
         @param batch: list of texts to translate
         @return: list of translations
         """
-        return [self.translate(text, **kwargs) for text in batch]
-
+        return self._translate_batch(batch, **kwargs)
 
-BaseTranslator.register(YandexTranslator)

docs/README.rst

@@ -106,8 +106,8 @@ Features
 * 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)
-* Support for the `QCRI translator <https://mt.qcri.org/api/>`_ (version >= 1.2.4)
-* Support for the `DeepL translator <https://www.deepl.com/en/translator/>`_ (version >= 1.2.5)
+* Support for the `QcriTranslator translator <https://mt.qcri.org/api/>`_ (version >= 1.2.4)
+* Support for the `DeeplTranslator translator <https://www.deepl.com/en/translator/>`_ (version >= 1.2.5)
 * Support for the `Papago translator <https://papago.naver.com/>`_ (version >= 1.4.4)
 * Support for the `Libre translator <https://libretranslate.com/>`_
 * Support for proxy usage
@@ -187,8 +187,8 @@ Imports
                                  MyMemoryTranslator,
                                  YandexTranslator,
                                  PapagoTranslator,
-                                 DeepL,
-                                 QCRI,
+                                 DeeplTranslator,
+                                 QcriTranslator,
                                  single_detection,
                                  batch_detection)
 
@@ -306,12 +306,12 @@ Mymemory Translator
     translated = MyMemoryTranslator(source='en', target='fr').translate_file(path)
 
 
-DeepL Translator
+DeeplTranslator Translator
 -----------------
 
 .. note::
 
-    In order to use the DeepL translator, you need to generate an api key. Deepl offers a Pro and a free API.
+    In order to use the DeeplTranslator translator, you need to generate an api key. Deepl offers a Pro and a free API.
     deep-translator supports both Pro and free APIs. Just check the examples below.
     Visit https://www.deepl.com/en/docs-api/ for more information on how to generate your Deepl api key
 
@@ -321,7 +321,7 @@ DeepL Translator
 
     text = 'Keep it up. You are awesome'
 
-    translated = DeepL(api_key="your_api_key", source="en", target="en", use_free_api=True).translate(text)
+    translated = DeeplTranslator(api_key="your_api_key", source="en", target="en", use_free_api=True).translate(text)
 
 .. note::
         deep-translator uses free deepl api by default. If you have the pro version then simply set the use_free_api to false.
@@ -334,14 +334,14 @@ DeepL Translator
     texts = ["hallo welt", "guten morgen"]
 
     # the translate_sentences function is deprecated, use the translate_batch function instead
-    translated = DeepL("your_api_key").translate_batch(texts)
+    translated = DeeplTranslator("your_api_key").translate_batch(texts)
 
-QCRI Translator
+QcriTranslator Translator
 --------------------
 
 .. note::
 
-    In order to use the QCRI translator, you need to generate a free api key. Visit https://mt.qcri.org/api/
+    In order to use the QcriTranslator translator, you need to generate a free api key. Visit https://mt.qcri.org/api/
     for more information
 
 - Check languages
@@ -349,14 +349,14 @@ QCRI Translator
 .. code-block:: python
 
     # as a property
-    print("language pairs: ", QCRI("your_api_key").languages)
+    print("language pairs: ", QcriTranslator("your_api_key").languages)
 
 - Check domains
 
 .. code-block:: python
 
     # as a property
-    print("domains: ", QCRI("your_api_key").domains)
+    print("domains: ", QcriTranslator("your_api_key").domains)
 
 - Text translation
 
@@ -364,7 +364,7 @@ QCRI Translator
 
     text = 'Education is great'
 
-    translated = QCRI("your_api_key").translate(source='en', target='ar', domain="news", text=text)
+    translated = QcriTranslator("your_api_key").translate(source='en', target='ar', domain="news", text=text)
     # output -> التعليم هو عظيم
 
     # see docs for batch translation and more.

docs/history.rst

@@ -11,8 +11,8 @@ Important History
 - 1.3.4 bug fixes for the dutch language
 - 1.3.3 fixed bug in google translate
 
-- 1.2.5: added support for the DeepL translator
-- 1.2.4: added support for the QCRI translator
+- 1.2.5: added support for the DeeplTranslator translator
+- 1.2.4: added support for the QcriTranslator translator
 - 1.2.1: added support for the yandex translator
 - 1.1.9: fixed bug in requests
 - 1.1.5: added language detection

docs/modules.rst

@@ -20,7 +20,7 @@ Exceptions
     :undoc-members:
     :show-inheritance:
 
-    
+
 Language Detection Library
 ----------------------------------
 
@@ -40,7 +40,7 @@ Google Translator
     :undoc-members:
     :show-inheritance:
 
-DeepL
+DeeplTranslator
 ----------------------------------
 
 .. automodule:: deep_translator.deepl
@@ -88,7 +88,7 @@ Pons
     :undoc-members:
     :show-inheritance:
 
-QCRI
+QcriTranslator
 ----------------------------------
 
 .. automodule:: deep_translator.qcri
@@ -102,4 +102,4 @@ Yandex
 .. automodule:: deep_translator.yandex
     :members:
     :undoc-members:
-    :show-inheritance:
+    :show-inheritance:

docs/usage.rst

@@ -22,8 +22,8 @@ Imports
                                  LingueeTranslator,
                                  MyMemoryTranslator,
                                  YandexTranslator,
-                                 DeepL,
-                                 QCRI,
+                                 DeeplTranslator,
+                                 QcriTranslator,
                                  single_detection,
                                  batch_detection)
 
@@ -140,12 +140,12 @@ Mymemory Translator
     translated = MyMemoryTranslator(source='en', target='fr').translate_file(path)
 
 
-DeepL Translator
+DeeplTranslator Translator
 -----------------
 
 .. note::
 
-    In order to use the DeepL translator, you need to generate an api key. Visit https://www.deepl.com/en/docs-api/
+    In order to use the DeeplTranslator translator, you need to generate an api key. Visit https://www.deepl.com/en/docs-api/
     for more information
 
 - Simple translation
@@ -154,7 +154,7 @@ DeepL Translator
 
     text = 'Keep it up. You are awesome'
 
-    translated = DeepL("your_api_key").translate(text)
+    translated = DeeplTranslator("your_api_key").translate(text)
 
 - Translate batch of texts
 
@@ -163,14 +163,14 @@ DeepL Translator
     texts = ["hallo welt", "guten morgen"]
 
     # the translate_sentences function is deprecated, use the translate_batch function instead
-    translated = DeepL("your_api_key").translate_batch(texts)
+    translated = DeeplTranslator("your_api_key").translate_batch(texts)
 
-QCRI Translator
+QcriTranslator Translator
 --------------------
 
 .. note::
 
-    In order to use the QCRI translator, you need to generate a free api key. Visit https://mt.qcri.org/api/
+    In order to use the QcriTranslator translator, you need to generate a free api key. Visit https://mt.qcri.org/api/
     for more information
 
 - Check languages
@@ -178,14 +178,14 @@ QCRI Translator
 .. code-block:: python
 
     # as a property
-    print("language pairs: ", QCRI("your_api_key").languages)
+    print("language pairs: ", QcriTranslator("your_api_key").languages)
 
 - Check domains
 
 .. code-block:: python
 
     # as a property
-    print("domains: ", QCRI("your_api_key").domains)
+    print("domains: ", QcriTranslator("your_api_key").domains)
 
 - Text translation
 
@@ -193,7 +193,7 @@ QCRI Translator
 
     text = 'Education is great'
 
-    translated = QCRI("your_api_key").translate(source='en', target='ar', domain="news", text=text)
+    translated = QcriTranslator("your_api_key").translate(source='en', target='ar', domain="news", text=text)
     # output -> التعليم هو عظيم
 
     # see docs for batch translation and more.
@@ -306,7 +306,7 @@ Libre Translator
 .. note::
 
     Libre translate has multiple  `mirrors <https://github.com/LibreTranslate/LibreTranslate#mirrors>`_ which can be used for the API endpoint.
-    Some require an API key to be used. By default the base url is set to `libretranslate.de <https://libretranslate.de/>`_ . 
+    Some require an API key to be used. By default the base url is set to `libretranslate.de <https://libretranslate.de/>`_ .
     This can be set using the "base_url" input parameter.
 
 .. code-block:: python

examples/trans.py

@@ -5,12 +5,16 @@ from deep_translator import GoogleTranslator, PonsTranslator, LingueeTranslator
 
 english_text = 'happy coding'
 chinese_text = '這很好'
+translator = GoogleTranslator(source='auto', target='german')
+result1 = translator.translate(text=english_text)
+result2 = translator.translate(text=chinese_text)
 
-result_german = GoogleTranslator(source='english', target='german').translate(text=english_text)
-result_french = GoogleTranslator(source='auto', target='french').translate(text=chinese_text)
+print(f"original english text: {english_text} | translated text: {result1}")
+print(f"original chinese text: {chinese_text} | translated text: {result2}")
 
-print(f"original english text: {english_text} | translated text: {result_german}")  # result: fröhliche Codierung
-print(f"original chinese text: {chinese_text} | translated text: {result_french}")  # result: C' est bon
+# file translation
+result_file = translator.translate_file('./test.txt')
+print("file translation: ", result_file)
 
 # examples using linguee:
 text = 'cute'
@@ -19,5 +23,6 @@ print("Using Linguee ==> the translated text: ", translated)
 
 # examples using pons:
 text = 'good'
-translated = PonsTranslator(source='english', target='arabic').translate(word=text)
+translated = PonsTranslator(source='en', target='ar').translate(word=text)
 print("using Pons ==> the translated text: ", translated)
+

pyproject.toml

@@ -9,7 +9,7 @@ readme = "docs/README.rst"
 homepage = "https://github.com/nidhaloff/deep_translator"
 repository = "https://github.com/nidhaloff/deep_translator"
 documentation = "https://deep-translator.readthedocs.io/en/latest/"
-keywords = ["deep_translator", "deepL", "DeepL", "translator", "translation", "automation", "web scraping", "google translator", "google translation", "google trans", "PONS", "YANDEX", "MyMemory translator", "Linguee", "QCRI", "Language", "Language detection", "detect language", "free translation", "unlimited translation", "translate for free"]
+keywords = ["deep_translator", "deepL", "DeeplTranslator", "translator", "translation", "automation", "web scraping", "google translator", "google translation", "google trans", "PONS", "YANDEX", "MyMemory translator", "Linguee", "QcriTranslator", "Language", "Language detection", "detect language", "free translation", "unlimited translation", "translate for free"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",

tests/test_deepl.py

@@ -1,12 +1,12 @@
 import pytest
 from unittest.mock import Mock, PropertyMock, patch
-from deep_translator.deepl import DeepL
+from deep_translator.deepl import DeeplTranslator
 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', source='en', target='es')
+    translator = DeeplTranslator(api_key='imagine-this-is-an-valid-api-key', source='en', target='es')
     # Set the request response mock.
     mock_response = Mock()
     mock_response.status_code = 200
@@ -22,7 +22,7 @@ def test_simple_translation(mock_requests):
 
 @patch('deep_translator.deepl.requests.get')
 def test_wrong_api_key(mock_requests):
-    translator = DeepL(api_key='this-is-a-wrong-api-key!', source="en", target="es")
+    translator = DeeplTranslator(api_key='this-is-a-wrong-api-key!', source="en", target="es")
     # Set the response status_code only.
     mock_requests.return_value = Mock(status_code=403)
     with pytest.raises(AuthorizationException):

tests/test_google.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+"""Tests for `deep_translator` package."""
+
+import pytest
+from deep_translator import exceptions, GoogleTranslator
+from deep_translator.constants import GOOGLE_CODES_TO_LANGUAGES
+
+
+@pytest.fixture
+def google_translator():
+    """Sample pytest fixture.
+    See more at: http://doc.pytest.org/en/latest/fixture.html
+    """
+    return GoogleTranslator(target='en')
+
+
+def test_content(google_translator):
+    """Sample pytest test function with the pytest fixture as an argument."""
+    assert google_translator.translate(text='좋은') == "good"
+
+
+def test_abbreviations_and_languages_mapping():
+    for abb, lang in GOOGLE_CODES_TO_LANGUAGES.items():
+        g1 = GoogleTranslator(abb)
+        g2 = GoogleTranslator(lang)
+        assert g1._source == g2._source
+
+
+def test_inputs():
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        GoogleTranslator(source="", target="")
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        GoogleTranslator(source="auto", target="")
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        GoogleTranslator(source="", target="en")
+
+
+def test_empty_text(google_translator):
+    empty_txt = ""
+    res = google_translator.translate(text=empty_txt)
+    assert res == empty_txt
+
+
+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={})
+
+    with pytest.raises(exceptions.NotValidPayload):
+        google_translator.translate(text=[])
+
+    with pytest.raises(exceptions.NotValidLength):
+        google_translator.translate("a"*5001)
+
+
+def test_one_character_words():
+    assert GoogleTranslator(source='es', target='en').translate('o') == 'or'

tests/test_google_trans.py

@@ -1,175 +0,0 @@
-#!/usr/bin/env python
-
-"""Tests for `deep_translator` package."""
-
-import pytest
-from deep_translator import exceptions, GoogleTranslator
-from deep_translator.constants import GOOGLE_CODES_TO_LANGUAGES
-
-
-test_text_standard = 'Hello world.'
-
-TRANSLATED_RESULTS = {
-    "afrikaans": "Hello Wêreld.",
-    "albanian": "Përshendetje Botë.",
-    "amharic": "ሰላም ልዑል.",
-    "arabic": "مرحبا بالعالم.",
-    "armenian": "Բարեւ աշխարհ.",
-    "azerbaijani": "Salam dünya.",
-    "basque": "Kaixo Mundua.",
-    "belarusian": "Прывітанне Сусвет.",
-    "bengali": "ওহে বিশ্ব.",
-    "bosnian": "Zdravo svijete.",
-    "bulgarian": "Здравей свят.",
-    "catalan": "Hola món.",
-    "cebuano": "Kumusta kalibutan.",
-    "chichewa": "Moni Dziko Lapansi.",
-    "chinese (simplified)": "你好，世界。",
-    "chinese (traditional)": "你好，世界。",
-    "corsican": "Bonghjornu mondu.",
-    "croatian": "Pozdrav svijete.",
-    "czech": "Ahoj světe.",
-    "danish": "Hej Verden.",
-    "dutch": "Hallo Wereld.",
-    "esperanto": "Saluton mondo.",
-    "estonian": "Tere, Maailm.",
-    "filipino": "Kamusta mundo",
-    "finnish": "Hei maailma.",
-    "french": "Bonjour le monde.",
-    "frisian": "Hallo wrâld.",
-    "galician": "Ola mundo.",
-    "georgian": "Გამარჯობა მსოფლიო.",
-    "german": "Hallo Welt.",
-    "greek": "Γειά σου Κόσμε.",
-    "gujarati": "હેલો વર્લ્ડ.",
-    "haitian creole": "Bonjou mond.",
-    "hausa": "Sannu Duniya.",
-    "hawaiian": "Aloha honua.",
-    "hebrew": "שלום עולם.",
-    "hindi": "नमस्ते दुनिया।",
-    "hmong": "Nyob zoo ntiaj teb.",
-    "hungarian": "Helló Világ.",
-    "icelandic": "Halló heimur.",
-    "igbo": "Ndewo Ụwa.",
-    "indonesian": "Halo Dunia.",
-    "irish": "Dia duit ar domhan.",
-    "italian": "Ciao mondo.",
-    "japanese": "こんにちは世界。",
-    "javanese": "Halo jagad.",
-    "kannada": "ಹಲೋ ವಿಶ್ವ.",
-    "kazakh": "Сәлем Әлем.",
-    "khmer": "សួស្តី​ពិភពលោក។",
-    "kinyarwanda": "Mwaramutse isi.",
-    "korean": "안녕하세요 세계입니다.",
-    "kurdish": "Hello cîhanê.",
-    "kyrgyz": "Салам дүйнө.",
-    "lao": "ສະ​ບາຍ​ດີ​ຊາວ​ໂລກ.",
-    "latin": "Salve mundi.",
-    "latvian": "Sveika pasaule.",
-    "lithuanian": "Labas pasauli.",
-    "luxembourgish": "Moien Welt.",
-    "macedonian": "Здраво свету.",
-    "malagasy": "Hello World.",
-    "malay": "Hai dunia.",
-    "malayalam": "ഹലോ വേൾഡ്.",
-    "maltese": "Hello dinja.",
-    "maori": "Kia ora te ao.",
-    "marathi": "नमस्कार जग.",
-    "mongolian": "Сайн уу ертөнц.",
-    "myanmar": "မင်္ဂလာပါကမ္ဘာလောက။",
-    "nepali": "नमस्कार संसार।",
-    "norwegian": "Hei Verden.",
-    "odia": "ନମସ୍କାର ବିଶ୍ୱବାସି।",
-    "pashto": "سلام نړی.",
-    "persian": "سلام دنیا.",
-    "polish": "Witaj świecie.",
-    "portuguese": "Olá Mundo.",
-    "punjabi": "ਸਤਿ ਸ੍ਰੀ ਅਕਾਲ ਦੁਨਿਆ.",
-    "romanian": "Salut Lume.",
-    "russian": "Привет, мир.",
-    "samoan": "Talofa lalolagi.",
-    "scots gaelic": "Hàlo a Shaoghail.",
-    "serbian": "Здраво Свете.",
-    "sesotho": "Lefatše Lumela.",
-    "shona": "Mhoro nyika.",
-    "sindhi": "هيلو دنيا.",
-    "sinhala": "හෙලෝ වර්ල්ඩ්.",
-    "slovak": "Ahoj svet.",
-    "slovenian": "Pozdravljen, svet.",
-    "somali": "Salaamu calaykum.",
-    "spanish": "Hola Mundo.",
-    "sundanese": "Halo Dunya.",
-    "swahili": "Salamu, Dunia.",
-    "swedish": "Hej världen.",
-    "tajik": "Салом Ҷаҳон.",
-    "tamil": "வணக்கம் உலகம்.",
-    "tatar": "Сәлам, Дөнья.",
-    "telugu": "హలో వరల్డ్.",
-    "thai": "สวัสดีชาวโลก.",
-    "turkish": "Selam Dünya.",
-    "turkmen": "Salam dünýä.",
-    "ukrainian": "Привіт Світ.",
-    "urdu": "سلام دنیا۔",
-    "uyghur": "ياخشىمۇسىز دۇنيا.",
-    "uzbek": "Salom Dunyo.",
-    "vietnamese": "Chào thế giới.",
-    "welsh": "Helo Byd.",
-    "xhosa": "Molo Lizwe.",
-    "yiddish": "העלא וועלט.",
-    "yoruba": "Mo ki O Ile Aiye.",
-    "zulu": "Sawubona Mhlaba."
-}
-
-
-@pytest.fixture
-def google_translator():
-    """Sample pytest fixture.
-    See more at: http://doc.pytest.org/en/latest/fixture.html
-    """
-    return GoogleTranslator(target='en')
-
-
-def test_content(google_translator):
-    """Sample pytest test function with the pytest fixture as an argument."""
-    # from bs4 import BeautifulSoup
-    # assert 'GitHub' in BeautifulSoup(response.content).title.string
-    assert google_translator.translate(text='좋은') == "good"
-
-
-def test_abbreviations_and_languages_mapping():
-    for abb, lang in GOOGLE_CODES_TO_LANGUAGES.items():
-        if abb != 'en':
-            g1 = GoogleTranslator(abb)
-            g2 = GoogleTranslator(lang)
-            assert g1._source == g2._source
-
-
-def test_inputs():
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        GoogleTranslator(source="", target="")
-
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        GoogleTranslator(source="auto", target="nothing")
-
-def test_payload(google_translator):
-
-    with pytest.raises(exceptions.NotValidPayload):
-        google_translator.translate(text="")
-        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={})
-
-    with pytest.raises(exceptions.NotValidPayload):
-        google_translator.translate(text=[])
-
-    with pytest.raises(exceptions.NotValidLength):
-        google_translator.translate("a"*5001)
-
-def test_one_character_words():
-    assert GoogleTranslator(source='es', target='en').translate('o') == 'or'

tests/test_libre.py

@@ -6,60 +6,31 @@ import pytest
 from deep_translator import exceptions, LibreTranslator
 from deep_translator.constants import LIBRE_CODES_TO_LANGUAGES
 
-test_text_standard = 'Hello world.'
-TRANSLATED_RESULTS = {
-    'English': 'Hello world.',
-    'Arabic': 'مرحبا العالم.',
-    'Chinese': '霍洛美世界。',
-    'French': 'Bonjour.',
-    'German': 'Hallo Welt.',
-    'Hindi': 'नमस्ते दुनिया।',
-    'Indonesian': 'Halo dunia.',
-    'Irish': 'Dia duit domhan.',
-    'Italian': 'Ciao mondo.',
-    'Japanese': 'こんにちは。',
-    'Korean': '안녕하세요.',
-    'Polish': 'Hello world (ang.).',
-    'Portuguese': 'Olá, mundo.',
-    'Russian': 'Привет мир.',
-    'Spanish': 'Hola mundo.',
-    'Turkish': 'Merhaba dünya.',
-    'Vietnamese': 'Xin chào.'
-}
-
 
 @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."""
-    # from bs4 import BeautifulSoup
-    # assert 'GitHub' in BeautifulSoup(response.content).title.string
-    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.LanguageNotSupportedException):
-        LibreTranslator(source="", target="")
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        LibreTranslator(source="", target="", api_key='some_key')
 
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        LibreTranslator(source="auto", target="nothing")
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        LibreTranslator(source="auto", target="", api_key='some_key')
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        LibreTranslator(source="", target="en", api_key='some_key')
 
 
 def test_abbreviations_and_languages_mapping():
     for abb, lang in LIBRE_CODES_TO_LANGUAGES.items():
-        if abb != 'en':
-            l1 = LibreTranslator(abb)
-            l2 = LibreTranslator(lang)
-            assert l1.source == l2.source
+        l1 = LibreTranslator(abb, api_key='some_key')
+        l2 = LibreTranslator(lang, api_key='some_key')
+        assert l1._source == l2._source
 
 
 def test_payload(libre):
-    with pytest.raises(exceptions.NotValidPayload):
-        libre.translate("")
-
     with pytest.raises(exceptions.NotValidPayload):
         libre.translate(123)
 
@@ -68,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):
@@ -19,11 +19,14 @@ def test_content(linguee):
 
 
 def test_inputs():
-    with pytest.raises(exceptions.LanguageNotSupportedException):
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
         LingueeTranslator(source="", target="")
 
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        LingueeTranslator(source="auto", target="nothing")
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        LingueeTranslator(source="auto", target="")
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        LingueeTranslator(source="", target="en")
 
     l1 = LingueeTranslator("en", "fr")
     l2 = LingueeTranslator("english", "french")
@@ -33,9 +36,6 @@ def test_inputs():
 
 def test_payload(linguee):
 
-    with pytest.raises(exceptions.NotValidPayload):
-        linguee.translate("")
-
     with pytest.raises(exceptions.NotValidPayload):
         linguee.translate(123)
 
@@ -47,12 +47,3 @@ def test_payload(linguee):
 
     with pytest.raises(exceptions.NotValidLength):
         linguee.translate("a"*51)
-
-
-
-def test_translate_words(linguee):
-    words = ['hello', 'world']
-    translated_words = linguee.translate_words(words)
-
-def test_one_character_words():
-    assert LingueeTranslator(source='es', target='en').translate('y') == 'and'

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
@@ -58,5 +58,5 @@ def test_incorrect_target_attributes():
 def test_abbreviations():
     m1 = MicrosoftTranslator(api_key=APIkey, source="en", target="fr")
     m2 = MicrosoftTranslator(api_key=APIkey, source="English", target="French")
-    assert ''.join(m1.source) == ''.join(m2.source)
-    assert ''.join(m1.target) == ''.join(m2.target)
+    assert ''.join(m1._source) == ''.join(m2._source)
+    assert ''.join(m1._target) == ''.join(m2._target)

tests/test_mymemory.py

@@ -19,11 +19,15 @@ def test_content(mymemory):
 
 
 def test_inputs():
-    with pytest.raises(exceptions.LanguageNotSupportedException):
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
         MyMemoryTranslator(source="", target="")
 
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        MyMemoryTranslator(source="auto", target="nothing")
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        MyMemoryTranslator(source="auto", target="")
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        MyMemoryTranslator(source="", target="en")
+
     m1 = MyMemoryTranslator("en", "fr")
     m2 = MyMemoryTranslator("english", "french")
     assert m1._source == m2._source
@@ -32,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)
 
@@ -48,6 +49,3 @@ def test_payload(mymemory):
         mymemory.translate(text="a"*501)
 
 
-def test_one_character_words(mymemory):
-    assert mymemory.translate('I')
-

tests/test_pons.py

@@ -19,11 +19,15 @@ def test_content(pons):
 
 
 def test_inputs():
-    with pytest.raises(exceptions.LanguageNotSupportedException):
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
         PonsTranslator(source="", target="")
 
-    with pytest.raises(exceptions.LanguageNotSupportedException):
-        PonsTranslator(source="auto", target="nothing")
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        PonsTranslator(source="auto", target="")
+
+    with pytest.raises(exceptions.InvalidSourceOrTargetLanguage):
+        PonsTranslator(source="", target="en")
+
     l1 = PonsTranslator("en", "fr")
     l2 = PonsTranslator("english", "french")
     assert l1._source == l2._source
@@ -31,10 +35,6 @@ def test_inputs():
 
 
 def test_payload(pons):
-
-    with pytest.raises(exceptions.NotValidPayload):
-        pons.translate("")
-
     with pytest.raises(exceptions.NotValidPayload):
         pons.translate(123)
 
@@ -47,11 +47,3 @@ def test_payload(pons):
     with pytest.raises(exceptions.NotValidLength):
         pons.translate("a" * 51)
 
-
-
-def test_translate_words(pons):
-    words = ['hello', 'world']
-    translated_words = pons.translate_words(words)
-
-def test_one_character_words(pons):
-    assert pons.translate('I')