huge refactoring

deep_translator/__init__.py

@@ -11,7 +11,6 @@ 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__ = 'nidhalbacc@gmail.com'
@@ -31,7 +30,3 @@ __all__ = [
     "single_detection",
     "batch_detection"
 ]
-
-__engines__ = generate_engines_dict(__all__, locals())
-del generate_engines_dict
-engine.translation_engines = __engines__

deep_translator/base.py

@@ -1,8 +1,7 @@
 """base translator class"""
 
-from .exceptions import NotValidPayload, NotValidLength, InvalidSourceOrTargetLanguage
+from .constants import GOOGLE_LANGUAGES_TO_CODES
 from abc import ABC, abstractmethod
-import string
 
 
 class BaseTranslator(ABC):
@@ -16,55 +15,55 @@ class BaseTranslator(ABC):
                  payload_key=None,
                  element_tag=None,
                  element_query=None,
+                 languages=GOOGLE_LANGUAGES_TO_CODES,
                  **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._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
-        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__()
+        self.languages: dict = languages
+        self.supported_languages: list = list(self.languages.keys())
+        super().__init__()
 
-    @staticmethod
-    def _validate_payload(payload, min_chars=1, max_chars=5000):
+    def _map_language_to_code(self, *languages):
         """
-        validate the target text to translate
-        @param payload: text to translate
-        @return: bool
+        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]
 
-        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)
+    def _same_source_target(self):
+        return self._source == self._target
 
-        if not BaseTranslator.__check_length(payload, min_chars, max_chars):
-            raise NotValidLength(payload, min_chars, max_chars)
-        return True
+    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
 
-    @staticmethod
-    def __check_length(payload, min_chars, max_chars):
+    def is_language_supported(self, language, **kwargs):
         """
-        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
+        check if the language is supported by the translator
+        @param language: a string for 1 language
+        @return: bool or raise an Exception
         """
-        return True if min_chars <= len(payload) < max_chars else False
+        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):
@@ -76,5 +75,31 @@ class BaseTranslator(ABC):
         """
         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,16 +1,17 @@
 """Console script for deep_translator."""
-from . import __engines__
 import argparse
+from .base import BaseTranslator
 
 
 class CLI(object):
-    translators_dict = __engines__
+    translators_dict = BaseTranslator.__subclasses__()
     translator = None
 
     def __init__(self, custom_args=None):
         self.custom_args = custom_args
         self.args = self.parse_args()
-        # print(f'{__engines__}')
+        print(f'translators_dict: {self.translators_dict}')
+        exit()
         translator_class = self.translators_dict.get(self.args.translator, None)
         if not translator_class:
             raise Exception(f"Translator {self.args.translator} is not supported."

deep_translator/constants.py

@@ -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,19 +1,19 @@
 import requests
+
+from validate import is_empty
 from .constants import BASE_URLS, DEEPL_LANGUAGE_TO_CODE
 from .exceptions import (ServerException,
                          TranslationNotFound,
-                         LanguageNotSupportedException,
                          AuthorizationException)
 from .base import BaseTranslator
 
 
-class DeepL(object):
+class DeepL(BaseTranslator):
     """
     class that wraps functions, which use the DeepL translator under the hood to translate word(s)
     """
-    _languages = DEEPL_LANGUAGE_TO_CODE
 
-    def __init__(self, api_key=None, 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.
         Get one here: https://www.deepl.com/docs-api/accessing-the-api/
@@ -24,26 +24,30 @@ 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(
                 "DEEPL").format(version=self.version)
+        super().__init__(source=source,
+                         target=target,
+                         languages=DEEPL_LANGUAGE_TO_CODE)
 
     def translate(self, text, **kwargs):
         """
         @param text: text to translate
         @return: translated 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,
+            "source_lang": self._source,
+            "target_lang": self._target,
             "text": text
         }
         # Do the request and check the connection.
@@ -64,30 +68,15 @@ class DeepL(object):
         # 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__':

deep_translator/engine.py

@@ -1,39 +0,0 @@
-from .base import BaseTranslator
-
-
-def generate_engines_dict(_all: list, _locals: dict) -> dict:
-    base_translator_type = BaseTranslator
-
-    def is_translator(__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/google_trans.py

@@ -2,22 +2,18 @@
 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 .constants import BASE_URLS
+from .exceptions import TooManyRequests, TranslationNotFound, RequestError
 from .base import BaseTranslator
+from .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):
         """
@@ -26,88 +22,28 @@ class GoogleTranslator(BaseTranslator):
         """
         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=self.__base_url,
+                         source=source,
+                         target=target,
+                         element_tag='div',
+                         element_query={"class": "t0"},
+                         payload_key='q',  # key of text in the url
+                         tl=self._target,
+                         sl=self._source,
+                         **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._same_source_target() or is_empty(text):
+            return text
 
-        if self._validate_payload(text):
+        if validate_input(text):
             text = text.strip()
 
             if self.payload_key:
@@ -151,37 +87,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 +95,4 @@ 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):
-
-            translated = self.translate(text, **kwargs)
-            arr.append(translated)
-        return arr
-
+        return self._translate_batch(batch, **kwargs)

deep_translator/libre.py

@@ -3,71 +3,34 @@ LibreTranslate API
 """
 
 import requests
+
+from validate import is_empty
 from .base import BaseTranslator
-from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES, LIBRE_CODES_TO_LANGUAGES
+from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES
 from .exceptions import (ServerException,
                         TranslationNotFound,
-                        LanguageNotSupportedException,
-                        AuthorizationException,
-                        NotValidPayload)
+                        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.__base_url = BASE_URLS.get("LIBRE")
         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__(source=source,
+                         target=target,
+                         languages=LIBRE_LANGUAGES_TO_CODES)
 
     def translate(self, text, **kwargs):
         """
@@ -75,15 +38,14 @@ 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 self._same_source_target() or is_empty(text):
+            return text
 
         translate_endpoint = 'translate'
         params = {
             "q": text,
-            "source": self.source,
-            "target": self.target,
+            "source": self._source,
+            "target": self._target,
             "format": 'text'
         }
         # Add API Key if required
@@ -115,12 +77,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 +85,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,9 +1,9 @@
 """
 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,
@@ -19,8 +19,6 @@ 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):
         """
@@ -29,53 +27,15 @@ class LingueeTranslator(BaseTranslator):
         """
         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,
+                         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,7 +45,10 @@ 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 = requote_uri(url)

deep_translator/microsoft.py

@@ -3,31 +3,29 @@
 import requests
 import logging
 import sys
-
-from .constants import BASE_URLS, MICROSOFT_CODES_TO_LANGUAGES
-from .exceptions import LanguageNotSupportedException, ServerException, MicrosoftAPIerror
+from .constants import BASE_URLS
+from .exceptions import ServerException, MicrosoftAPIerror
 from .base 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 +35,22 @@ class MicrosoftTranslator:
         if region:
             self.region = region
             self.headers["Ocp-Apim-Subscription-Region"] = self.region
-
-        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")
+        super().__init__(
+            source=source,
+            target=target,
+            languages=MICROSOFT_CODES_TO_LANGUAGES,
+            **kwargs
+        )
 
-    @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,10 +60,14 @@ 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
+
+        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,
+                                      params=self._url_params,
                                       headers=self.headers,
                                       json=valid_microsoft_json,
                                       proxies=self.proxies)
@@ -132,12 +91,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 +99,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,27 +1,20 @@
 """
 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 .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
@@ -29,10 +22,6 @@ class MyMemoryTranslator(BaseTranslator):
         """
         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,
@@ -40,41 +29,6 @@ class MyMemoryTranslator(BaseTranslator):
                                                  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
-
     def translate(self, text, return_all=False, **kwargs):
         """
         function that uses the mymemory translator to translate a text
@@ -84,7 +38,10 @@ class MyMemoryTranslator(BaseTranslator):
         @return: str or list
         """
 
-        if self._validate_payload(text, max_chars=500):
+        if self._same_source_target() or is_empty(text):
+            return text
+
+        if validate_input(text, max_chars=500):
             text = text.strip()
 
             if self.payload_key:
@@ -94,7 +51,6 @@ class MyMemoryTranslator(BaseTranslator):
 
             response = requests.get(self.__base_url,
                                     params=self._url_params,
-                                    headers=self.headers,
                                     proxies=self.proxies)
 
             if response.status_code == 429:
@@ -116,32 +72,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 +80,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 +88,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

@@ -10,12 +10,10 @@ import warnings
 import logging
 
 
-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):
         """
@@ -29,44 +27,12 @@ class PapagoTranslator(object):
         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__(
+            source=source,
+            target=target,
+            languages=PAPAGO_LANGUAGE_TO_CODE,
+            **kwargs
+        )
 
     def translate(self, text, **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/pons.py

@@ -3,6 +3,8 @@ pons translator API
 """
 from bs4 import BeautifulSoup
 import requests
+
+from validate import validate_input, is_empty
 from .constants import BASE_URLS, PONS_LANGUAGES_TO_CODES, PONS_CODES_TO_LANGUAGES
 from .exceptions import (LanguageNotSupportedException,
                         TranslationNotFound,
@@ -18,8 +20,6 @@ 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):
         """
@@ -28,10 +28,8 @@ class PonsTranslator(BaseTranslator):
         """
         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,
+                         languages=PONS_LANGUAGES_TO_CODES,
                          source=self._source,
                          target=self._target,
                          payload_key=None,
@@ -39,41 +37,6 @@ class PonsTranslator(BaseTranslator):
                          element_query={"class": "target"}
                          )
 
-    @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,7 +46,10 @@ class PonsTranslator(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):
             url = "{}{}-{}/{}".format(self.__base_url, self._source, self._target, word)
             url = requote_uri(url)
             response = requests.get(url, proxies=self.proxies)

deep_translator/qcri.py

@@ -5,7 +5,7 @@ from .exceptions import (ServerException, TranslationNotFound)
 from .base import BaseTranslator
 
 
-class QCRI(object):
+class QCRI(BaseTranslator):
     """
     class that wraps functions, which use the QRCI translator under the hood to translate word(s)
     """
@@ -18,8 +18,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,6 +28,12 @@ class QCRI(object):
         self.params = {
             "key": self.api_key
         }
+        super().__init__(
+            source=source,
+            target=target,
+            languages=QCRI_LANGUAGE_TO_CODE,
+            **kwargs
+        )
 
     def _get(self, endpoint, params=None, return_text=True):
         if not params:
@@ -41,14 +45,6 @@ class QCRI(object):
         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,29 @@
+
+from .exceptions import NotValidPayload, NotValidLength
+import string
+
+
+def is_empty(text: str):
+    return text.strip() == ""
+
+
+def validate_input(text: str, min_chars: int = 1, 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 not text.strip() or text.isdigit():
+        raise NotValidPayload(text)
+
+    # check if payload contains only symbols
+    if all(i in string.punctuation for i in text):
+        raise NotValidPayload(text)
+
+    if not min_chars <= len(text) < max_chars:
+        raise NotValidLength(text, min_chars, max_chars)
+
+    return True

deep_translator/yandex.py

@@ -8,7 +8,7 @@ from .exceptions import (RequestError, ServerException,
 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)
     """
@@ -20,9 +20,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 +27,11 @@ 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__(
+            source=source,
+            target=target,
+            **kwargs
+        )
 
     def _get_supported_languages(self):
         return set(x.split("-")[0] for x in self.dirs)
@@ -95,7 +90,7 @@ class YandexTranslator(object):
         params = {
             "text": text,
             "format": "plain",
-            "lang": self.target if self.source == "auto" else "{}-{}".format(self.source, self.target),
+            "lang": self._target if self._source == "auto" else "{}-{}".format(self._source, self._target),
             "key": self.api_key
         }
         try:
@@ -124,13 +119,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 +127,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)