cengal.parallel_execution.coroutines.integrations.nicegui.versions.v_0.text_translation

Module Docstring Docstrings: http://www.python.org/dev/peps/pep-0257/

View Source

  1#!/usr/bin/env python
  2# coding=utf-8
  3
  4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>
  5# 
  6# Licensed under the Apache License, Version 2.0 (the "License");
  7# you may not use this file except in compliance with the License.
  8# You may obtain a copy of the License at
  9# 
 10#     http://www.apache.org/licenses/LICENSE-2.0
 11# 
 12# Unless required by applicable law or agreed to in writing, software
 13# distributed under the License is distributed on an "AS IS" BASIS,
 14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15# See the License for the specific language governing permissions and
 16# limitations under the License.
 17
 18
 19"""
 20Module Docstring
 21Docstrings: http://www.python.org/dev/peps/pep-0257/
 22"""
 23
 24
 25__author__ = "ButenkoMS <gtalk@butenkoms.space>"
 26__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
 27__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
 28__license__ = "Apache License, Version 2.0"
 29__version__ = "4.4.1"
 30__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
 31__email__ = "gtalk@butenkoms.space"
 32# __status__ = "Prototype"
 33__status__ = "Development"
 34# __status__ = "Production"
 35
 36
 37from cengal.parallel_execution.coroutines.coro_scheduler import Interface, current_interface, CoroID
 38from nicegui.elements.mixins.text_element import TextElement
 39from nicegui.elements.select import Select
 40from nicegui.elements.tabs import Tab
 41from cengal.text_processing.text_translator import TranslationLanguageId, TextEntityId, TextTranslator, TranslationLanguageChooser, \
 42    TranslationLanguageMapper, TranslatableText, tt, TranslateMe, TMe, tme, TranslatableTextElement, TTE
 43from cengal.introspection.inspect import is_callable
 44from cengal.file_system.path_manager import path_relative_to_src
 45from typing import Optional, Tuple, Dict, Any, List, Union, Callable, Hashable, Set
 46from cengal.parallel_execution.coroutines.coro_standard_services.put_coro import PutCoro, put_coro
 47from cengal.parallel_execution.coroutines.coro_standard_services.wait_coro import WaitCoroRequest, CoroutineNotFoundError
 48from cengal.parallel_execution.coroutines.coro_standard_services.async_event_bus import AsyncEventBusRequest
 49from cengal.text_processing.text_translator.versions.v_1.text_translator import TranslationLanguageChooser
 50
 51
 52class NiceguiTranslatableTextElement(TranslatableTextElement[TextElement]):
 53    def __init__(self, text_translation_language_chooser: TranslationLanguageChooser) -> None:
 54        super().__init__(text_translation_language_chooser)
 55    
 56    def __call__(self, text_element: TextElement) -> TextElement:
 57        if text_element is None:
 58            return None
 59        
 60        if isinstance(text_element, TextElement):
 61            if isinstance(text_element.text, TranslateMe):
 62                if text_element.text:
 63                    self.elements_and_their_translatable_text[text_element] = text_element.text
 64                
 65                text_element.text = text_element.text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 66        elif isinstance(text_element, Select):
 67            if 'label' in text_element._props:
 68                text: TranslateMe = text_element._props['label']
 69                if isinstance(text, TranslateMe):
 70                    if text:
 71                        self.elements_and_their_translatable_text[text_element] = text
 72                    
 73                    text_element._props['label'] = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 74        elif isinstance(text_element, Tab):
 75            text: TranslateMe = text_element._props['label']
 76            if isinstance(text, TranslateMe):
 77                if text:
 78                    self.elements_and_their_translatable_text[text_element] = text
 79                
 80                text_element._props['label'] = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 81        
 82        return text_element
 83
 84    def set_text(self, text_element: TextElement, text: Union[TranslateMe, str]) -> TextElement:
 85        if text_element is None:
 86            return None
 87        
 88        need_to_remove = False
 89        if isinstance(text, TranslateMe):
 90            if text:
 91                self.elements_and_their_translatable_text[text_element] = text
 92                text_element.text = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 93            else:
 94                need_to_remove = True
 95        else:
 96            need_to_remove = True
 97        
 98        if need_to_remove:
 99            del self.elements_and_their_translatable_text[text_element]
100            text_element.text = text
101        
102        return text_element
103
104
105NTTE = NiceguiTranslatableTextElement
106
107
108def setup_translation(text_dictionary_path: str):
109    # with open(path_relative_to_src('./text_dictionary.json'), 'rb') as f:
110    with open(text_dictionary_path, 'rb') as f:
111        text_dictionary_data = f.read()
112
113    text_translator: TextTranslator = TextTranslator.from_json(text_dictionary_data)
114    translation_language_mapper: TranslationLanguageMapper = TranslationLanguageMapper(text_translator.decoded_data['translation_language_map'],
115                                                                                    text_translator.decoded_data['default_language'])
116    return text_translator, translation_language_mapper
117
118
119def create_translatable_text_element(text_translator, translation_language_mapper):
120    translation_language_chooser: TranslationLanguageChooser = TranslationLanguageChooser(text_translator, translation_language_mapper)
121    # translation_language_chooser.lang = text_translator.decoded_data['original_text_language']
122    return NiceguiTranslatableTextElement(translation_language_chooser)
123
124
125async def acreate_translatable_text_element(text_translator, translation_language_mapper):
126    translation_language_chooser: TranslationLanguageChooser = TranslationLanguageChooser(text_translator, translation_language_mapper)
127    # translation_language_chooser.lang = text_translator.decoded_data['original_text_language']
128
129    translatable_text_element = NiceguiTranslatableTextElement(translation_language_chooser)
130    await translatable_text_element.aregister_on_lang_changed_handler()
131    return translatable_text_element

class NiceguiTranslatableTextElement(cengal.text_processing.text_translator.versions.v_1.text_translator.TranslatableTextElement[nicegui.elements.mixins.text_element.TextElement]): View Source

 53class NiceguiTranslatableTextElement(TranslatableTextElement[TextElement]):
 54    def __init__(self, text_translation_language_chooser: TranslationLanguageChooser) -> None:
 55        super().__init__(text_translation_language_chooser)
 56    
 57    def __call__(self, text_element: TextElement) -> TextElement:
 58        if text_element is None:
 59            return None
 60        
 61        if isinstance(text_element, TextElement):
 62            if isinstance(text_element.text, TranslateMe):
 63                if text_element.text:
 64                    self.elements_and_their_translatable_text[text_element] = text_element.text
 65                
 66                text_element.text = text_element.text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 67        elif isinstance(text_element, Select):
 68            if 'label' in text_element._props:
 69                text: TranslateMe = text_element._props['label']
 70                if isinstance(text, TranslateMe):
 71                    if text:
 72                        self.elements_and_their_translatable_text[text_element] = text
 73                    
 74                    text_element._props['label'] = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 75        elif isinstance(text_element, Tab):
 76            text: TranslateMe = text_element._props['label']
 77            if isinstance(text, TranslateMe):
 78                if text:
 79                    self.elements_and_their_translatable_text[text_element] = text
 80                
 81                text_element._props['label'] = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 82        
 83        return text_element
 84
 85    def set_text(self, text_element: TextElement, text: Union[TranslateMe, str]) -> TextElement:
 86        if text_element is None:
 87            return None
 88        
 89        need_to_remove = False
 90        if isinstance(text, TranslateMe):
 91            if text:
 92                self.elements_and_their_translatable_text[text_element] = text
 93                text_element.text = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 94            else:
 95                need_to_remove = True
 96        else:
 97            need_to_remove = True
 98        
 99        if need_to_remove:
100            del self.elements_and_their_translatable_text[text_element]
101            text_element.text = text
102        
103        return text_element

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

NiceguiTranslatableTextElement( text_translation_language_chooser: cengal.text_processing.text_translator.versions.v_1.text_translator.TranslationLanguageChooser) View Source

54    def __init__(self, text_translation_language_chooser: TranslationLanguageChooser) -> None:
55        super().__init__(text_translation_language_chooser)

def set_text( self, text_element: nicegui.elements.mixins.text_element.TextElement, text: typing.Union[cengal.text_processing.text_translator.versions.v_1.text_translator.TranslateMe, str]) -> nicegui.elements.mixins.text_element.TextElement: View Source

 85    def set_text(self, text_element: TextElement, text: Union[TranslateMe, str]) -> TextElement:
 86        if text_element is None:
 87            return None
 88        
 89        need_to_remove = False
 90        if isinstance(text, TranslateMe):
 91            if text:
 92                self.elements_and_their_translatable_text[text_element] = text
 93                text_element.text = text.to_str(self.text_translator, self.text_translation_language_chooser.end_lang)
 94            else:
 95                need_to_remove = True
 96        else:
 97            need_to_remove = True
 98        
 99        if need_to_remove:
100            del self.elements_and_their_translatable_text[text_element]
101            text_element.text = text
102        
103        return text_element

Inherited Members

cengal.text_processing.text_translator.versions.v_1.text_translator.TranslatableTextElement

text_translation_language_chooser

text_translator

elements_and_their_translatable_text

current_translation_reapplier_coros_ids

lang_changing_queue

translate_me

start_translation_reapplier

translation_reapplier

register_on_lang_changed_handler

aregister_on_lang_changed_handler

remove_on_lang_changed_handler

aremove_on_lang_changed_handler

on_lang_changed

NTTE = <class 'NiceguiTranslatableTextElement'>

def setup_translation(text_dictionary_path: str): View Source

109def setup_translation(text_dictionary_path: str):
110    # with open(path_relative_to_src('./text_dictionary.json'), 'rb') as f:
111    with open(text_dictionary_path, 'rb') as f:
112        text_dictionary_data = f.read()
113
114    text_translator: TextTranslator = TextTranslator.from_json(text_dictionary_data)
115    translation_language_mapper: TranslationLanguageMapper = TranslationLanguageMapper(text_translator.decoded_data['translation_language_map'],
116                                                                                    text_translator.decoded_data['default_language'])
117    return text_translator, translation_language_mapper

def create_translatable_text_element(text_translator, translation_language_mapper): View Source

120def create_translatable_text_element(text_translator, translation_language_mapper):
121    translation_language_chooser: TranslationLanguageChooser = TranslationLanguageChooser(text_translator, translation_language_mapper)
122    # translation_language_chooser.lang = text_translator.decoded_data['original_text_language']
123    return NiceguiTranslatableTextElement(translation_language_chooser)

async def acreate_translatable_text_element(text_translator, translation_language_mapper): View Source

126async def acreate_translatable_text_element(text_translator, translation_language_mapper):
127    translation_language_chooser: TranslationLanguageChooser = TranslationLanguageChooser(text_translator, translation_language_mapper)
128    # translation_language_chooser.lang = text_translator.decoded_data['original_text_language']
129
130    translatable_text_element = NiceguiTranslatableTextElement(translation_language_chooser)
131    await translatable_text_element.aregister_on_lang_changed_handler()
132    return translatable_text_element