Merge pull request #18 from nidhaloff/dev

deep_translator/google_trans.py

@@ -43,17 +43,17 @@ class GoogleTranslator(BaseTranslator):
         @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':
+            if language in self._languages.values() or language == 'auto':
                 yield language
-            elif language in GOOGLE_LANGUAGES_TO_CODES.keys():
-                yield GOOGLE_LANGUAGES_TO_CODES[language]
+            elif language in self._languages.keys():
+                yield self._languages[language]
             else:
                 raise LanguageNotSupportedException(language)
 
     def is_language_supported(self, *languages):
         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():
+            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
 

deep_translator/linguee.py

@@ -38,17 +38,17 @@ class LingueeTranslator(BaseTranslator):
         @return: mapped value of the language or raise an exception if the language is not supported
         """
         for language in languages:
-            if language in LINGUEE_LANGUAGES_TO_CODES.values():
+            if language in self._languages.values():
                 yield LINGUEE_CODE_TO_LANGUAGE[language]
-            elif language in LINGUEE_LANGUAGES_TO_CODES.keys():
+            elif language in self._languages.keys():
                 yield language
             else:
                 raise LanguageNotSupportedException(language)
 
     def is_language_supported(self, *languages, **kwargs):
         for lang in languages:
-            if lang not in LINGUEE_LANGUAGES_TO_CODES.keys():
-                if lang not in LINGUEE_LANGUAGES_TO_CODES.values():
+            if lang not in self._languages.keys():
+                if lang not in self._languages.values():
                     raise LanguageNotSupportedException(lang)
         return True
 
@@ -86,4 +86,3 @@ class LingueeTranslator(BaseTranslator):
             translated_words.append(self.translate(payload=word))
         return translated_words
 
-

deep_translator/mymemory.py

@@ -1,6 +1,6 @@
 
 from deep_translator.constants import BASE_URLS, GOOGLE_LANGUAGES_TO_CODES
-from deep_translator.exceptions import NotValidPayload, TranslationNotFound
+from deep_translator.exceptions import NotValidPayload, TranslationNotFound, LanguageNotSupportedException
 from deep_translator.parent import BaseTranslator
 import requests
 
@@ -18,9 +18,11 @@ class MyMemoryTranslator(BaseTranslator):
         @param target: target language to translate to
         """
         self.__base_url = BASE_URLS.get("MYMEMORY")
-        self._source = source if source != 'auto' else 'Lao'
-        self._target = target
+        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'
 
+        print(self._source, self._target)
         self.email = kwargs.get('email', None)
         super(MyMemoryTranslator, self).__init__(base_url=self.__base_url,
                                                  source=self._source,
@@ -32,10 +34,32 @@ class MyMemoryTranslator(BaseTranslator):
     def get_supported_languages(as_dict=False):
         return MyMemoryTranslator.supported_languages if not as_dict else MyMemoryTranslator._languages
 
-    def translate(self, text, **kwargs):
+    def _map_language_to_code(self, *languages):
+        """
+
+        @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 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):
+        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):
         """
         main function that uses google translate to translate a text
         @param text: desired text to translate
+        @param return_all: set True to return all synonyms
         @return: str: translated text
         """
 
@@ -62,7 +86,7 @@ class MyMemoryTranslator(BaseTranslator):
                 all_matches = data.get('matches')
                 matches = (match['translation'] for match in all_matches)
                 next_match = next(matches)
-                return next_match if not kwargs.get('return_all') else list(all_matches)
+                return next_match if not return_all else list(all_matches)
 
     def translate_sentences(self, sentences=None, **kwargs):
         """
@@ -86,3 +110,4 @@ class MyMemoryTranslator(BaseTranslator):
 
         except Exception as e:
             raise e
+

deep_translator/pons.py

@@ -38,22 +38,21 @@ class PonsTranslator(BaseTranslator):
 
     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():
+            if language in self._languages.values():
                 yield PONS_CODES_TO_LANGUAGES[language]
-            elif language in PONS_LANGUAGES_TO_CODES.keys():
+            elif language in self._languages.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():
+            if lang not in self._languages.keys():
+                if lang not in self._languages.values():
                     raise LanguageNotSupportedException(lang)
         return True
 

deep_translator/tests/{test_deep_translator.py → test_google_trans.py}

@@ -29,11 +29,22 @@ def test_inputs():
     with pytest.raises(exceptions.LanguageNotSupportedException):
         GoogleTranslator(source="auto", target="nothing")
 
+    g1 = GoogleTranslator("en", "fr")
+    g2 = GoogleTranslator("english", "french")
+    assert g1._source == g2._source
+    assert g1._target == g2._target
+
 
 def test_payload(google_translator):
+
     with pytest.raises(exceptions.NotValidPayload):
         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=[])

deep_translator/tests/test_linguee.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+
+"""Tests for `deep_translator` package."""
+
+import pytest
+from deep_translator import exceptions, LingueeTranslator
+
+
+@pytest.fixture
+def linguee():
+    return LingueeTranslator(source="english", target='french')
+
+
+def test_content(linguee):
+    """Sample pytest test function with the pytest fixture as an argument."""
+    # from bs4 import BeautifulSoup
+    # assert 'GitHub' in BeautifulSoup(response.content).title.string
+    assert linguee.translate(word='good') is not None
+
+
+def test_inputs():
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        LingueeTranslator(source="", target="")
+
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        LingueeTranslator(source="auto", target="nothing")
+
+    l1 = LingueeTranslator("en", "fr")
+    l2 = LingueeTranslator("english", "french")
+    assert l1._source == l2._source
+    assert l1._target == l2._target
+
+
+def test_payload(linguee):
+
+    with pytest.raises(exceptions.NotValidPayload):
+        linguee.translate("")
+
+    with pytest.raises(exceptions.NotValidPayload):
+        linguee.translate(123)
+
+    with pytest.raises(exceptions.NotValidPayload):
+        linguee.translate({})
+
+    with pytest.raises(exceptions.NotValidPayload):
+        linguee.translate([])

deep_translator/tests/test_mymemory.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+"""Tests for `deep_translator` package."""
+
+import pytest
+from deep_translator import exceptions, MyMemoryTranslator
+
+
+@pytest.fixture
+def mymemory():
+    return MyMemoryTranslator(source="en", target='fr')
+
+
+def test_content(mymemory):
+    """Sample pytest test function with the pytest fixture as an argument."""
+    # from bs4 import BeautifulSoup
+    # assert 'GitHub' in BeautifulSoup(response.content).title.string
+    assert mymemory.translate(text='good') is not None
+
+
+def test_inputs():
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        MyMemoryTranslator(source="", target="")
+
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        MyMemoryTranslator(source="auto", target="nothing")
+    m1 = MyMemoryTranslator("en", "fr")
+    m2 = MyMemoryTranslator("english", "french")
+    assert m1._source == m2._source
+    assert m1._target == m2._target
+
+def test_payload(mymemory):
+
+    with pytest.raises(exceptions.NotValidPayload):
+        mymemory.translate(text="")
+
+    with pytest.raises(exceptions.NotValidPayload):
+        mymemory.translate(text=123)
+
+    with pytest.raises(exceptions.NotValidPayload):
+        mymemory.translate(text={})
+
+    with pytest.raises(exceptions.NotValidPayload):
+        mymemory.translate(text=[])

deep_translator/tests/test_pons.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+"""Tests for `deep_translator` package."""
+
+import pytest
+from deep_translator import exceptions, PonsTranslator
+
+
+@pytest.fixture
+def pons():
+    return PonsTranslator(source="english", target='french')
+
+
+def test_content(pons):
+    """Sample pytest test function with the pytest fixture as an argument."""
+    # from bs4 import BeautifulSoup
+    # assert 'GitHub' in BeautifulSoup(response.content).title.string
+    assert pons.translate(word='good') is not None
+
+
+def test_inputs():
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        PonsTranslator(source="", target="")
+
+    with pytest.raises(exceptions.LanguageNotSupportedException):
+        PonsTranslator(source="auto", target="nothing")
+    l1 = PonsTranslator("en", "fr")
+    l2 = PonsTranslator("english", "french")
+    assert l1._source == l2._source
+    assert l1._target == l2._target
+
+def test_payload(pons):
+
+    with pytest.raises(exceptions.NotValidPayload):
+        pons.translate("")
+
+    with pytest.raises(exceptions.NotValidPayload):
+        pons.translate(123)
+
+    with pytest.raises(exceptions.NotValidPayload):
+        pons.translate({})
+
+    with pytest.raises(exceptions.NotValidPayload):
+        pons.translate([])