""" title: WebUI Auto Translator description: Automatically translates both messages and UI elements version: 1.0.0 requirements: deep-translator,beautifulsoup4 """ import json import hashlib from typing import Optional, Dict, Any, Union from deep_translator import GoogleTranslator from bs4 import BeautifulSoup class TranslationError(Exception): """Custom exception for translation errors""" pass class Tools: def __init__(self): self.translation_cache = {} self.translator = GoogleTranslator(source="auto", target="fr") self.cache_timeout = 3600 # 1 hour def _get_cache_key(self, text: str, target_language: str, prefix: str = "") -> str: """Generate a unique cache key""" cache_key = f"{prefix}:{text}:{target_language}" return hashlib.md5(cache_key.encode()).hexdigest() def safe_translate(self, text: str) -> str: """Safely translate text with error handling""" if not text or not isinstance(text, str): return text if len(text) > 5000: # Split text into smaller chunks if needed chunks = [text[i : i + 5000] for i in range(0, len(text), 5000)] return " ".join(self.safe_translate(chunk) for chunk in chunks) try: result = self.translator.translate(text) if not result: raise TranslationError("Empty translation result") return result except Exception as e: print(f"Translation error: {str(e)}") return text def translate_message(self, text: str, target_language: str = "fr") -> str: """Translate chat message""" if not text: return text cache_key = self._get_cache_key(text, target_language, "msg") if cache_key in self.translation_cache: return self.translation_cache[cache_key] try: self.translator.target = target_language result = self.safe_translate(text) self.translation_cache[cache_key] = result return result except Exception as e: print(f"Message translation error: {str(e)}") return text def process_chat_message(self, message: dict) -> dict: """Process and translate chat messages""" try: if isinstance(message, dict): if "content" in message: message["content"] = self.translate_message(message["content"]) return message except Exception as e: print(f"Chat message processing error: {str(e)}") return message def process_stream(self, message: str) -> str: """Process streaming messages""" try: return self.translate_message(message) except Exception as e: print(f"Stream processing error: {str(e)}") return message def translate_ui_element( self, element_text: str, target_language: str = "fr" ) -> str: """Translate UI element text""" if not element_text or not isinstance(element_text, str): return element_text text = element_text.strip() if not text: return element_text cache_key = self._get_cache_key(text, target_language, "ui") if cache_key in self.translation_cache: return self.translation_cache[cache_key] try: self.translator.target = target_language result = self.safe_translate(text) self.translation_cache[cache_key] = result return result except Exception as e: print(f"UI element translation error: {str(e)}") return element_text def translate_ui(self, html_content: str, target_language: str = "fr") -> str: """Translate entire UI content""" if not html_content: return html_content try: soup = BeautifulSoup(html_content, "html.parser") skip_tags = Valves.excluded_elements translatable_attrs = ["placeholder", "title", "aria-label"] for text_node in soup.find_all(text=True): if text_node.parent.name not in skip_tags: text = text_node.strip() if text: translated_text = self.translate_ui_element( text, target_language ) if translated_text and translated_text != text: text_node.replace_with(translated_text) for element in soup.find_all(): if element.name not in skip_tags: for attr in translatable_attrs: if element.get(attr): translated_attr = self.translate_ui_element( element[attr], target_language ) if translated_attr: element[attr] = translated_attr return str(soup) except Exception as e: print(f"UI translation error: {str(e)}") return html_content def translate_json_content( self, json_content: Dict[str, Any], target_language: str = "fr" ) -> Dict[str, Any]: """Translate JSON content""" if not json_content: return json_content def translate_value(value): if isinstance(value, str): return self.translate_ui_element(value, target_language) elif isinstance(value, dict): return {k: translate_value(v) for k, v in value.items()} elif isinstance(value, list): return [translate_value(item) for item in value] return value try: return translate_value(json_content) except Exception as e: print(f"JSON translation error: {str(e)}") return json_content class Valves: cache_duration: int = 3600 translate_ui: bool = True excluded_elements: list = ["code", "pre", "script", "style"] class UserValves: default_target_language: str = "fr" auto_translate: bool = True translate_ui: bool = True cache_enabled: bool = True custom_translations: Dict[str, str] = {} def file_handler(file): """Handle translation of uploaded files""" if not file or not hasattr(file, "content_type"): return None try: if file.content_type == "application/json": content = json.loads(file.read()) tools = Tools() translated_content = tools.translate_json_content(content) return json.dumps(translated_content, ensure_ascii=False, indent=2) except Exception as e: print(f"File handler error: {str(e)}") return None def before_request(request): """Hook executed before each request""" if not UserValves.translate_ui or not request or request.method != "GET": return request try: tools = Tools() content_type = request.headers.get("content-type", "").lower() if "text/html" in content_type: response_content = request.get_data(as_text=True) return tools.translate_ui(response_content) elif "application/json" in content_type: response_json = request.get_json() return tools.translate_json_content(response_json) except Exception as e: print(f"Before request error: {str(e)}") return request def after_response(response): """Hook executed after each response""" if not UserValves.translate_ui or not response: return response try: tools = Tools() content_type = response.headers.get("content-type", "").lower() if "text/html" in content_type: response.headers["Content-Type"] = "text/html; charset=utf-8" response.data = tools.translate_ui(response.get_data(as_text=True)).encode( "utf-8" ) elif "application/json" in content_type: response.headers["Content-Type"] = "application/json; charset=utf-8" response_json = json.loads(response.get_data(as_text=True)) response.data = json.dumps( tools.translate_json_content(response_json), ensure_ascii=False ).encode("utf-8") except Exception as e: print(f"After response error: {str(e)}") return response def process_websocket_message(message: Union[str, dict]) -> Union[str, dict]: """Process WebSocket messages""" try: tools = Tools() if isinstance(message, str): return tools.translate_message(message) elif isinstance(message, dict): return tools.process_chat_message(message) except Exception as e: print(f"WebSocket message processing error: {str(e)}") return message def process_stream_chunk(chunk: str) -> str: """Process streaming response chunks""" try: tools = Tools() return tools.process_stream(chunk) except Exception as e: print(f"Stream chunk processing error: {str(e)}") return chunk def citation(): return { "name": "Deep Translator", "url": "https://github.com/nidhaloff/deep-translator", "license": "MIT", "version": "1.0.0", }