implemented function for LibreTranslator class

deep_translator/constants.py

@@ -11,7 +11,9 @@ BASE_URLS = {
     "DEEPL_FREE": "https://api-free.deepl.com/v2/",
     "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"
+    "PAPAGO_API": "https://openapi.naver.com/v1/papago/n2mt",
+    "LIBRE": "https://libretranslate.com/",
+    "LIBRE_FREE": "https://libretranslate.de/",
 }
 
 GOOGLE_CODES_TO_LANGUAGES = {
@@ -280,5 +282,5 @@ LIBRE_CODES_TO_LANGUAGES = {
 }
 
 LIBRE_LANGUAGES_TO_CODES = {
-    v: k for k, v in LIBRE_CODE_TO_LANGUAGE.items()
+    v: k for k, v in LIBRE_CODES_TO_LANGUAGES.items()
 }

deep_translator/exceptions.py

@@ -123,12 +123,15 @@ class ServerException(Exception):
     Default YandexTranslate exception from the official website
     """
     errors = {
+        400: "ERR_BAD_REQUEST",
         401: "ERR_KEY_INVALID",
         402: "ERR_KEY_BLOCKED",
         403: "ERR_DAILY_REQ_LIMIT_EXCEEDED",
         404: "ERR_DAILY_CHAR_LIMIT_EXCEEDED",
         413: "ERR_TEXT_TOO_LONG",
+        429: "ERR_TOO_MANY_REQUESTS",
         422: "ERR_UNPROCESSABLE_TEXT",
+        500: "ERR_INTERNAL_SERVER_ERROR",
         501: "ERR_LANG_NOT_SUPPORTED",
         503: "ERR_SERVICE_NOT_AVAIBLE",
     }

deep_translator/libre.py

@@ -2,27 +2,39 @@
 LibreTranslate API
 """
 
-from requests.models import Response
-from .parent import BaseTranslator
 import requests
 from bs4 import BeautifulSoup
-from .constants import LIBRE_LANGUAGES_TO_CODES, LIBRE_CODES_TO_LANGUAGES
+from requests.models import Response
+from .parent import BaseTranslator
+from .constants import BASE_URLS,LIBRE_LANGUAGES_TO_CODES, LIBRE_CODES_TO_LANGUAGES
+from .exceptions import (ServerException,
+                        TranslationNotFound,
+                        LanguageNotSupportedException,
+                        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, base_url, api_key, source="auto", target="en", proxies=None, **kwargs):
+    def __init__(self, base_url = BASE_URLS.get("LIBRE_FREE"), api_key="", source="auto", target="en", **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
         """
-        _languages = LIBRE_LANGUAGES_TO_CODES
-        supported_languages = list(_languages.keys())
-        return None
-    
+        if base_url == BASE_URLS.get("LIBRE") and not api_key:
+            raise ServerException(401)
+        self.__base_url = base_url
+        self.api_key = api_key
+        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):
         """
@@ -30,22 +42,27 @@ class LibreTranslator(BaseTranslator):
         @param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
         @return: list or dict
         """
-        return None
+        return [*LibreTranslator._languages.keys()] if not as_dict else LibreTranslator._languages
     
-    def _map_language_to_code(self, *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 languages: list of languages
+        @param language: a string for 1 language
         @return: mapped value of the language or raise an exception if the language is not supported
         """
-        return None
+        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):
+    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)
+        @param language: a string for 1 language
         @return: bool or raise an Exception
         """
+        return language == 'auto' or language in self._languages.keys() or language in self._languages.values()
     
     def translate(self, text, **kwargs):
         """
@@ -53,8 +70,29 @@ class LibreTranslator(BaseTranslator):
         @param text: desired text to translate
         @return: str: translated text
         """
-        return None
+         # Create the request parameters.
+        translate_endpoint = 'translate'
+        params = {
+            "q": text,
+            "source": self.source,
+            "target": self.target,
+            "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']
     
-response = requests.post("https://libretranslate.de/detect",data={'q': 'bonjour'})
-soup = BeautifulSoup(response.text, 'html.parser')
-print(soup)