made parent abstract and added pons support

deep_translator/constants.py

@@ -4,7 +4,7 @@ BASE_URLS = {
     "PONS": "https://en.pons.com/translate/"
 }
 
-CODES_TO_LANGUAGES = {
+GOOGLE_CODES_TO_LANGUAGES = {
     'af': 'afrikaans',
     'sq': 'albanian',
     'am': 'amharic',
@@ -113,4 +113,32 @@ CODES_TO_LANGUAGES = {
     'he': 'Hebrew'
 }
 
-LANGUAGES_TO_CODES = {v: k for k, v in CODES_TO_LANGUAGES.items()}
+GOOGLE_LANGUAGES_TO_CODES = {v: k for k, v in GOOGLE_CODES_TO_LANGUAGES.items()}
+
+
+PONS_CODES_TO_LANGUAGES = {
+    'ar': 'arabic',
+    'bg': 'bulgarian',
+    'zh-cn': 'chinese',
+    'cs': 'czech',
+    'da': 'danish',
+    'nl': 'dutch',
+    'en': 'english',
+    'fr': 'french',
+    'de': 'german',
+    'el': 'greek',
+    'hu': 'hungarian',
+    'it': 'italian',
+    'la': 'latin',
+    'no': 'norwegian',
+    'pl': 'polish',
+    'pt': 'portuguese',
+    'ru': 'russian',
+    'sl': 'slovenian',
+    'es': 'spanish',
+    'sv': 'swedish',
+    'tr': 'turkish',
+    'elv': 'elvish'
+}
+
+PONS_LANGUAGES_TO_CODES = {v: k for k, v in PONS_CODES_TO_LANGUAGES.items()}

deep_translator/deep_translator.py

@@ -1,129 +1,7 @@
 """Main module."""
 
+from .google_trans import GoogleTranslator
+from .pons import PonsTranslator
 
-from bs4 import BeautifulSoup
-import requests
-from models import BaseTranslator
-from constants import BASE_URLS, LANGUAGES_TO_CODES, CODES_TO_LANGUAGES
-from exceptions import LanguageNotSupportedException, NotValidPayload, ElementNotFoundInGetRequest, NotValidLength
-from parent import ParentTranslator
-import string
 
-
-class GoogleTranslator(ParentTranslator):
-    """
-    class that uses google translate to translate texts
-    """
-    def __init__(self, source="auto", target="en"):
-        """
-        @param source: source language to translate from
-        @param target: target language to translate to
-        """
-        self.__base_url = BASE_URLS.get("GOOGLE_TRANSLATE")
-
-        if self._validate_languages([source.lower(), target.lower()]):
-            self._source = self._map_language_to_code(source.lower())
-            self._target = self._map_language_to_code(target.lower())
-
-        super(GoogleTranslator, self).__init__(base_url=self.__base_url,
-                                               source=self._source,
-                                               target=self._target,
-                                               element_tag='div',
-                                               element_query={"class": "t0"},
-                                               hl=self._target,
-                                               sl=self._source,
-                                               q=None)
-
-    def _map_language_to_code(self, language):
-        """
-
-        @param language: type of language
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        if language in LANGUAGES_TO_CODES.values() or language == 'auto':
-            return language
-        elif language in LANGUAGES_TO_CODES.keys():
-            return LANGUAGES_TO_CODES[language]
-        else:
-            raise LanguageNotSupportedException(language)
-
-    def translate(self, payload, payload_tag='q', **kwargs):
-        return super().translate(payload, payload_tag)
-
-
-class PonsTranslator(ParentTranslator):
-    """
-    class that uses PONS translator to translate words
-    """
-    def __init__(self, source="french", target="english"):
-        """
-        @param source: source language to translate from
-        @param target: target language to translate to
-        """
-        self.__base_url = BASE_URLS.get("PONS")
-
-        if self._validate_languages([source.lower(), target.lower()]):
-            self._source = self._map_language_to_code(source.lower())
-            self._target = self._map_language_to_code(target.lower())
-
-        super().__init__(base_url=self.__base_url,
-                         source=self._source,
-                         target=self._target,
-                         element_tag='div',
-                         element_query={"class": "target"}
-                         )
-
-    def _map_language_to_code(self, language):
-        """
-
-        @param language: type of language
-        @return: mapped value of the language or raise an exception if the language is not supported
-        """
-        if language in LANGUAGES_TO_CODES.values():
-            return CODES_TO_LANGUAGES[language]
-        elif language in LANGUAGES_TO_CODES.keys():
-            return language
-        else:
-            raise LanguageNotSupportedException(language)
-
-    def _validate_languages(self, languages):
-        """
-
-        @param languages: languages to validate
-        @return: True or raise an exception
-        """
-        for lang in languages:
-            if lang not in LANGUAGES_TO_CODES.keys():
-                if lang not in LANGUAGES_TO_CODES.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
-
-    def translate(self, payload, payload_tag=None, **kwargs):
-        from requests.utils import quote
-        url = "{}{}-{}/{}".format(self.__base_url, self._source, self._target, quote(payload))
-        response = requests.get(url)
-        soup = BeautifulSoup(response.text, 'html.parser')
-        elements = soup.findAll(self._element_tag, self._element_query)
-        # elements = soup.body.find_all('a')
-        eof = []
-        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() + ' '
-            eof.append(temp)
-
-        return [word for word in eof if word and len(word) > 1]
-
-
-if __name__ == '__main__':
-    # res = GoogleTranslator(source='auto', target='french').translate(payload="A paragraph is a series of related sentences developing a central idea, called the topic. Try to think about paragraphs in terms of thematic unity: a paragraph is a sentence or a group of sentences that supports one central, unified idea. Paragraphs add one idea at a time to your broader argument.")
-    # res = GoogleTranslator(source='auto', target='french').translate_text(path='../examples/test.txt')
-    # res = GoogleTranslator(source='auto', target='french').translate_sentences([
-    #     "this is good",
-    #     "das Wetter ist schön",
-    #     "un verme verde in un bicchiere verde"
-    # ])
-    res = PonsTranslator(source="english", target="arabic").translate(payload='good')
-    print(res)
+__all__ = [GoogleTranslator, PonsTranslator]

deep_translator/google_trans.py

@@ -0,0 +1,88 @@
+from abc import ABC
+
+from constants import BASE_URLS, GOOGLE_LANGUAGES_TO_CODES
+from exceptions import LanguageNotSupportedException, ElementNotFoundInGetRequest, NotValidPayload, NotValidLength
+from parent import BaseTranslator
+from bs4 import BeautifulSoup
+import requests
+
+
+class GoogleTranslator(BaseTranslator, ABC):
+    """
+    class that uses google translate to translate texts
+    """
+
+    def __init__(self, source="auto", target="en"):
+        """
+        @param source: source language to translate from
+        @param target: target language to translate to
+        """
+        self.__base_url = BASE_URLS.get("GOOGLE_TRANSLATE")
+
+        if self.is_language_supported(source, target):
+            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 payload in the url
+                                               hl=self._target,
+                                               sl=self._source)
+
+    def _map_language_to_code(self, *languages, **kwargs):
+        """
+
+        @param language: type of language
+        @return: mapped value of the language or raise an exception if the language is not supported
+        """
+        for language in languages:
+            if language in GOOGLE_LANGUAGES_TO_CODES.values() or language == 'auto':
+                yield language
+            elif language in GOOGLE_LANGUAGES_TO_CODES.keys():
+                yield GOOGLE_LANGUAGES_TO_CODES[language]
+            else:
+                raise LanguageNotSupportedException(language)
+
+    def is_language_supported(self, *languages, **kwargs):
+        for lang in languages:
+            if lang != 'auto' and lang not in GOOGLE_LANGUAGES_TO_CODES.keys():
+                if lang != 'auto' and lang not in GOOGLE_LANGUAGES_TO_CODES.values():
+                    raise LanguageNotSupportedException(lang)
+        return True
+
+    def translate(self, payload, **kwargs):
+        """
+        main function that uses google translate to translate a text
+        @param payload: desired text to translate
+        @return: str: translated text
+        """
+
+        if not self.validate_payload(payload):
+            raise NotValidPayload(payload)
+
+        if not self._check_length(payload):
+            raise NotValidLength(payload)
+
+        try:
+            payload = payload.strip()
+
+            if self.payload_key:
+                self._url_params[self.payload_key] = payload
+
+            res = requests.get(self.__base_url, params=self._url_params)
+            soup = BeautifulSoup(res.text, 'html.parser')
+            element = soup.find(self._element_tag, self._element_query)
+            if not element:
+                raise ElementNotFoundInGetRequest(element)
+
+            return element.get_text(strip=True)
+
+        except Exception as e:
+            raise Exception(str(e.args))
+
+
+if __name__ == '__main__':
+    res = GoogleTranslator(source="auto", target="de").translate(payload='this is a good day')
+    print(res)

deep_translator/models.py

@@ -1,17 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class BaseTranslator(ABC):
-    def __init__(self):
-        super(BaseTranslator, self).__init__()
-
-    @abstractmethod
-    def _validate_payload(self, payload):
-        pass
-
-    @abstractmethod
-    def translate(self, payload, payload_tag):
-        pass
-
-
-

deep_translator/parent.py

@@ -1,14 +1,10 @@
 """Main module."""
 
+from exceptions import NotValidPayload
+from abc import ABC, abstractmethod
 
-from bs4 import BeautifulSoup
-import requests
-from .models import BaseTranslator
-from .constants import  LANGUAGES_TO_CODES
-from .exceptions import LanguageNotSupportedException, NotValidPayload, ElementNotFoundInGetRequest, NotValidLength
 
-
-class ParentTranslator(BaseTranslator):
+class BaseTranslator(ABC):
     """
     class that serve as a parent translator class for other different translators
     """
@@ -16,6 +12,7 @@ class ParentTranslator(BaseTranslator):
                  base_url=None,
                  source="auto",
                  target="en",
+                 payload_key=None,
                  element_tag=None,
                  element_query=None,
                  **url_params):
@@ -29,9 +26,10 @@ class ParentTranslator(BaseTranslator):
         self._url_params = url_params
         self._element_tag = element_tag
         self._element_query = element_query
-        super(ParentTranslator, self).__init__()
+        self.payload_key = payload_key
+        super(BaseTranslator, self).__init__()
 
-    def _validate_payload(self, payload):
+    def validate_payload(self, payload):
         """
         validate the payload text to translate
         @param payload: text to translate
@@ -45,49 +43,9 @@ class ParentTranslator(BaseTranslator):
     def _check_length(self, payload, min_chars=0, max_chars=5000):
         return True if min_chars < len(payload) < max_chars else False
 
-    def _validate_languages(self, languages):
-        """
-
-        @param languages: languages to validate
-        @return: True or raise an exception
-        """
-        for lang in languages:
-            if lang != 'auto' and lang not in LANGUAGES_TO_CODES.keys():
-                if lang != 'auto' and lang not in LANGUAGES_TO_CODES.values():
-                    raise LanguageNotSupportedException(lang)
-        return True
-
-    def translate(self, payload, payload_tag, **kwargs):
-        """
-        main function that uses google translate to translate a text
-        @param payload: desired text to translate
-        @param payload_tag: tag of the payload in the url parameters
-        @return: str: translated text
-        """
-
-        if not self._validate_payload(payload):
-            raise NotValidPayload(payload)
-
-        if not self._check_length(payload):
-            raise NotValidLength(payload)
-
-        try:
-            payload = payload.strip()
-
-            if payload_tag in self._url_params.keys():
-                self._url_params[payload_tag] = payload
-
-            res = requests.get(self.__base_url, params=self._url_params)
-            soup = BeautifulSoup(res.text, 'html.parser')
-            element = soup.find(self._element_tag, self._element_query)
-            if not element:
-                raise ElementNotFoundInGetRequest(element)
-
-            return element.get_text(strip=True)
-
-        except Exception as e:
-            print(e.args)
-            raise
+    @abstractmethod
+    def translate(self, payload, **kwargs):
+        pass
 
     def translate_file(self, path, **kwargs):
         try:

deep_translator/pons.py

@@ -0,0 +1,84 @@
+from abc import ABC
+
+from bs4 import BeautifulSoup
+import requests
+from constants import BASE_URLS, PONS_LANGUAGES_TO_CODES, PONS_CODES_TO_LANGUAGES
+from exceptions import LanguageNotSupportedException, ElementNotFoundInGetRequest
+from parent import BaseTranslator
+from requests.utils import quote
+
+
+class PonsTranslator(BaseTranslator):
+    """
+    class that uses PONS translator to translate words
+    """
+    def __init__(self, source="french", target="english"):
+        """
+        @param source: source language to translate from
+        @param target: target language to translate to
+        """
+        self.__base_url = BASE_URLS.get("PONS")
+
+        if self.is_language_supported(source, target, translator='pons'):
+            self._source, self._target = self._map_language_to_code(source, target)
+
+        super().__init__(base_url=self.__base_url,
+                         source=self._source,
+                         target=self._target,
+                         payload_key=None,
+                         element_tag='div',
+                         element_query={"class": "target"}
+                         )
+
+    def _map_language_to_code(self, *languages, **kwargs):
+        """
+
+        @param language: type of language
+        @return: mapped value of the language or raise an exception if the language is not supported
+        """
+        for language in languages:
+            if language in PONS_LANGUAGES_TO_CODES.values() or language == 'auto':
+                yield PONS_CODES_TO_LANGUAGES[language]
+            elif language in PONS_LANGUAGES_TO_CODES.keys():
+                yield language
+            else:
+                raise LanguageNotSupportedException(language)
+
+    def is_language_supported(self, *languages, **kwargs):
+        for lang in languages:
+            if lang not in PONS_LANGUAGES_TO_CODES.keys():
+                if lang not in PONS_LANGUAGES_TO_CODES.values():
+                    raise LanguageNotSupportedException(lang)
+        return True
+
+    def translate(self, payload, **kwargs):
+
+        url = "{}{}-{}/{}".format(self.__base_url, self._source, self._target, quote(payload))
+        response = requests.get(url)
+        soup = BeautifulSoup(response.text, 'html.parser')
+        elements = soup.findAll(self._element_tag, self._element_query)
+        if not elements:
+            raise ElementNotFoundInGetRequest(elements)
+
+        eof = []
+        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() + ' '
+            eof.append(temp)
+
+        return [word for word in eof if word and len(word) > 1]
+
+
+if __name__ == '__main__':
+    # res = GoogleTranslator(source='auto', target='french').translate(payload="A paragraph is a series of related sentences developing a central idea, called the topic. Try to think about paragraphs in terms of thematic unity: a paragraph is a sentence or a group of sentences that supports one central, unified idea. Paragraphs add one idea at a time to your broader argument.")
+    # res = GoogleTranslator(source='auto', target='french').translate_text(path='../examples/test.txt')
+    # res = GoogleTranslator(source='auto', target='french').translate_sentences([
+    #     "this is good",
+    #     "das Wetter ist schön",
+    #     "un verme verde in un bicchiere verde"
+    # ])
+    res = PonsTranslator(source="english", target="arabic").translate(payload='good')
+    print(res)