Update app.py

app.py

@@ -3,7 +3,6 @@ from bs4 import BeautifulSoup
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import List, Optional, Union
-from langdetect import detect as get_language
 from collections import namedtuple
 from inspect import signature
 import os
@@ -659,6 +658,7 @@ def all_pipes(pos,neg,artist,song):
 
     return imgs
 
+google_translate_endpoint = "https://translate.google.com/m"
 language_codes = {
     "afrikaans": "af",
     "albanian": "sq",
@@ -963,28 +963,121 @@ class BaseTranslator(ABC):
             translated = self.translate(text, **kwargs)
             arr.append(translated)
         return arr
-    
-def translate(txt,to_lang="en",from_lang=False):
-    log(f'CALL translate')
-    if not from_lang:
-        from_lang = get_language(txt)
-    if(from_lang == to_lang):
-        log(f'RET translate with txt as {txt}')
-        return txt
 
+class GoogleTranslator(BaseTranslator):
+    """
+    class that wraps functions, which use Google Translate under the hood to translate text(s)
+    """
 
-    translator_endpoint = "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0"
-    
-    translator = Translator(from_lang=from_lang,to_lang=to_lang)
+    def __init__(
+        self,
+        source: str = "auto",
+        target: str = "en",
+        proxies: Optional[dict] = None,
+        **kwargs
+    ):
+        """
+        @param source: source language to translate from
+        @param target: target language to translate to
+        """
+        self.proxies = proxies
+        super().__init__(
+            base_url=google_translate_endpoint,
+            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"}
+
+    def translate(self, text: str, **kwargs) -> str:
+        """
+        function to translate a text
+        @param text: desired text to translate
+        @return: str: translated text
+        """
+        if is_input_valid(text, max_chars=1000):
+            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, params=self._url_params, proxies=self.proxies
+            )
+            if response.status_code == 429:
+                raise TooManyRequests()
+
+            if request_failed(status_code=response.status_code):
+                raise RequestError()
+
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            element = soup.find(self._element_tag, self._element_query)
+            response.close()
+
+            if not element:
+                element = soup.find(self._element_tag, self._alt_element_query)
+                if not element:
+                    raise TranslationNotFound(text)
+            if element.get_text(strip=True) == text.strip():
+                to_translate_alpha = "".join(
+                    ch for ch in text.strip() if ch.isalnum()
+                )
+                translated_alpha = "".join(
+                    ch for ch in element.get_text(strip=True) if ch.isalnum()
+                )
+                if (
+                    to_translate_alpha
+                    and translated_alpha
+                    and to_translate_alpha == translated_alpha
+                ):
+                    self._url_params["tl"] = self._target
+                    if "hl" not in self._url_params:
+                        return text.strip()
+                    del self._url_params["hl"]
+                    return self.translate(text)
+
+            else:
+                return element.get_text(strip=True)
+
+    def translate_file(self, path: str, **kwargs) -> str:
+        """
+        translate directly from file
+        @param path: path to the target file
+        @type path: str
+        @param kwargs: additional args
+        @return: str
+        """
+        return self._translate_file(path, **kwargs)
+
+    def translate_batch(self, batch: List[str], **kwargs) -> List[str]:
+        """
+        translate a list of texts
+        @param batch: list of texts you want to translate
+        @return: list of translations
+        """
+        return self._translate_batch(batch, **kwargs)
+
+def translate(txt,to_lang="en",from_lang="auto"):
+    log(f'CALL translate')
+    translator = GoogleTranslator(from_lang=from_lang,to_lang=to_lang)
     translation = ""
-    if len(txt) > 490:
+    if len(txt) > 1000:
         words = txt.split()
         while len(words) > 0:
             chunk = ""
-            while len(words) > 0 and len(chunk) < 490:
+            while len(words) > 0 and len(chunk) < 1000:
                 chunk = chunk + " " + words[0]
                 words = words[1:]
-            if len(chunk) > 490:
+            if len(chunk) > 1000:
                 _words = chunk.split()
                 words = [_words[-1], *words]
                 chunk = " ".join(_words[:-1])