py10x-universe 0.1.3__py3-none-any.whl

ui_10x/examples/collection_editor.py

@@ -0,0 +1,17 @@
+if __name__ == '__main__':
+    from core_10x.code_samples.person import Person
+    from core_10x.exec_control import INTERACTIVE
+    from infra_10x.mongodb_store import MongoStore
+
+    from ui_10x.collection_editor import Collection, CollectionEditor
+    from ui_10x.utils import UxDialog, ux
+
+    ux.init()
+
+    with MongoStore.instance(hostname = 'localhost', dbname = 'test', username = '', password = ''):
+        with INTERACTIVE():
+            coll = Collection(cls = Person)
+            ce = CollectionEditor(coll = coll)
+            w = ce.main_widget()
+            d = UxDialog(w)
+            d.exec()

ui_10x/examples/date_selector.py

@@ -0,0 +1,14 @@
+from core_10x.rc import RC
+
+if __name__ == '__main__':
+    #import os;assert os.environ.setdefault('UI_PLATFORM', 'Rio') == os.getenv('UI_PLATFORM')
+
+    from ui_10x.utils import ux, ux_pick_date
+
+
+    app = ux.init()
+
+    ux_pick_date(on_accept=lambda value: print(value) or RC(True))
+
+    print(ux_pick_date())
+

ui_10x/examples/entity_stocker.py

@@ -0,0 +1,18 @@
+if __name__ == '__main__':
+    from core_10x.code_samples.person import Person
+    from core_10x.exec_control import INTERACTIVE
+    from infra_10x.mongodb_store import MongoStore
+
+    from ui_10x.entity_stocker import EntityStocker, StockerPlug
+    from ui_10x.utils import UxDialog, ux
+
+    ux.init()
+
+    with MongoStore.instance(hostname = 'localhost', dbname = 'test', username = '', password = ''):
+        plug = StockerPlug(current_class = Person)
+        se = EntityStocker(plug = plug)
+
+        with INTERACTIVE() as graph:
+            w = se.main_widget()
+            d = UxDialog(w)
+            rc = d.exec()

ui_10x/examples/guess_word.py

@@ -0,0 +1,392 @@
+from __future__ import annotations
+
+import os
+import random
+from typing import TYPE_CHECKING
+
+import core_10x.trait_definition as trait_definition
+from core_10x.global_cache import cache
+from core_10x.traitable import RC, RC_TRUE, RT, T, Traitable, Ui
+
+from ui_10x.platform_interface import HBoxLayout, PushButton, VBoxLayout, Widget
+from ui_10x.utils import ux
+
+# from ui_10x.table_view import TableView
+# from ui_10x.traitable_editor import TraitableEditor
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+class CHAR_STATE:
+    # fmt: off
+    NONE        = ( 'lightgray',    'black' )
+    WRONG_POS   = ( 'white',        'black' )
+    BINGO       = ( 'darkgreen',    'white' )
+    # fmt: on
+
+
+class GuessResult(Traitable):
+    # fmt: off
+    the_word: str    = RT()
+    guess: str       = RT()
+    num_chars: int   = RT()
+
+    demo_class: type = RT()
+
+    char_state: list = RT()
+
+    guessed_chars: list = RT()
+    current_char: int = RT(0)
+    # fmt: on
+
+    def guessed_chars_get(self) -> list:
+        return list(self.num_chars * ' ')
+
+    def set_current_char(self, c: str):
+        i = self.current_char
+        guessed_chars = self.guessed_chars
+        guessed_chars[i] = c
+        self.current_char = i + 1
+
+    def delete_char(self):
+        i = self.current_char
+        if i:
+            i -= 1
+            guessed_chars = self.guessed_chars
+            guessed_chars[i] = ' '
+            self.current_char = i
+
+    def accept_guess(self):
+        self.guess = ''.join(self.guessed_chars)
+
+    def num_chars_get(self) -> int:
+        return len(self.the_word)
+
+    def char_state_get(self) -> list:
+        num_chars = self.num_chars
+        res = [CHAR_STATE.NONE] * num_chars
+        word = list(self.the_word)
+        for i, c in enumerate(self.guess):
+            try:
+                pos = word.index(c)
+                res[i] = CHAR_STATE.BINGO if pos == i else CHAR_STATE.WRONG_POS
+                word[pos] = ''
+            except ValueError:
+                pass
+
+        return res
+
+    def guess_get(self) -> str:
+        return self.num_chars * ' '
+
+    @classmethod
+    def _create_char_trait(cls, i: int):
+        name = f'char_{i}'
+        getter_name = f'{name}_get'
+        sh_name = f'{name}_style_sheet'
+        getter = lambda self: self.guess[i]
+        getter.__name__ = getter_name
+        sh_getter = lambda self: T.colors(*self.char_state[i])
+        sh_getter.__name__ = sh_name
+        setattr(cls, getter_name, getter)
+        setattr(cls, sh_name, sh_getter)
+        # return ( name, T( str, f'{i+1}' ) )
+        # fmt: off
+        return (
+            name,
+            trait_definition.TraitDefinition(
+                **{
+                    trait_definition.NAME_TAG:      name,
+                    trait_definition.DATATYPE_TAG:  str,
+                    trait_definition.FLAGS_TAG:     T.RUNTIME,
+                }
+            )
+        )
+        # fmt: on
+
+    def keyboard(self):
+        w = Widget()
+        lay = VBoxLayout()
+        w.set_layout(lay)
+
+        for i, keys in enumerate(self.s_keys):
+            hlay = HBoxLayout()
+            for j, c in enumerate(keys):
+                b = PushButton(c)
+                styles = self.s_style.get(i)
+                if styles:
+                    sh = styles.get(j)
+                    if sh:
+                        b.set_style_sheet(sh)
+
+                avg_char_width = w.font_metrics().average_char_width()
+                b.setMaximumWidth(3 * avg_char_width)
+
+                hlay.add_widget(b)
+            lay.add_layout(hlay)
+
+        return w
+
+
+class Key:
+    def __init__(self, guess: GuessResult, c: str, stylesheet: str, callback):
+        self.guess = guess
+        self.c = c
+        self.stylesheet = stylesheet
+        self.callback = callback
+        self.w: PushButton = None
+
+    def widget(self, parent_w: Widget) -> PushButton:
+        if not self.w:
+            self.w = b = PushButton(self.c)
+            b.clicked_connect(lambda w: self.callback(w))
+            b.set_style_sheet(self.stylesheet)
+            avg_char_width = parent_w.font_metrics().average_char_width()
+            b.setMaximumWidth(3 * avg_char_width)
+
+        return self.w
+
+
+class Keyboard:
+    # fmt: off
+    s_keys = [
+        'qwertyuiop',
+        'asdfghjkl',
+        '*zxcvbnm<',
+    ]
+    s_special_chars = {
+        2:  {
+            0:                      ( 'background-color: green; color: white',  GuessResult.accept_guess ),
+            len(s_keys[2]) - 1:     ( 'background-color: red; color: white',    GuessResult.delete_char ),
+        }
+    }
+    # fmt: on
+
+    def __init__(self, guess: GuessResult):
+        self.guess = guess
+        special_chars = self.s_special_chars
+        num_rows = len(self.s_keys)
+        self.keys = keys = [[]] * num_rows
+        for i, symbols in enumerate(self.s_keys):
+            for j, c in enumerate(symbols):
+                sh = ''
+                cb = GuessResult.set_current_char
+                exc = special_chars.get(i)
+                if exc:
+                    spec = exc.get(j)
+                    if spec:
+                        sh, cb = spec
+
+                key = Key(guess, c, sh, cb)
+                keys[i].append(key)
+
+    def widget(self) -> Widget: ...
+
+
+class Game(Traitable):
+    # fmt: off
+    num_chars: int  = RT(5)
+
+    the_word: str   = RT()
+    guess: str      = RT( ui_hint = Ui('>'))
+    push: bool      = RT( ui_hint = Ui('*', widget_type = Ui.WIDGET_TYPE.PUSH, right_label = True, max_width = 3))
+
+    count: int      = RT(6)
+    current: int    = RT(0)
+
+    guess_res_class: type   = RT()
+    attempts: list          = RT()
+    #table: TableView        = RT()
+    # fmt: on
+
+    def the_word_get(self) -> str:
+        return _GuessWordData.new_word(self.num_chars).upper()
+
+    def guess_set(self, trait, value: str) -> RC:
+        self.raw_set_value(trait, value.upper())
+        return RC_TRUE
+
+    def guess_res_class_get(self):
+        num_chars = self.num_chars
+
+        class Demo(GuessResult):
+            @classmethod
+            def own_trait_definitions(cls) -> Generator[tuple[str, trait_definition.TraitDefinition]]:
+                yield from (tri for i in range(num_chars) if (tri := GuessResult._create_char_trait(i)))
+
+        Demo.traits()
+        return Demo
+
+    def guess_result(self, guess: str):
+        demo_class = self.guess_res_class
+        return demo_class(the_word=self.the_word, guess=guess)
+
+    def push_get(self) -> bool:
+        return self.current < self.count
+
+    def attempts_get(self) -> list:
+        num_chars = self.num_chars
+        return [self.guess_result(num_chars * ' ') for _ in range(self.count)]
+
+    def push_action(self, editor):
+        current = self.current()
+        guess = self.guess()
+        if len(guess) != self.num_chars():
+            ux.warning(f'The word is {self.num_chars()} characters long.')
+            return
+
+        gr = self.guess_result(self.guess())
+        attempts = self.attempts()
+        attempts[current] = gr
+        self.table().renderEntity(current, None)
+
+        if all(s == CHAR_STATE.BINGO for s in gr.char_state()):
+            ux.success('Great job - you got it!')
+
+        current += 1
+        if current >= self.count():
+            ux.warning('Unfortunately you have failed this time')
+
+        self.current = current
+
+
+    # def table_get( self ) -> TableView:
+    #     table = TableView( self.attempts() )
+    #     hv = table.horizontalHeader()
+    #     hv.setStretchLastSection( False )
+    #
+    #     return table
+
+    # fmt: off
+    s_keys = [
+        'qwertyuiop',
+        'asdfghjkl',
+        '*zxcvbnm<'
+    ]
+    s_style = {
+        2:  {
+            0:                          'background-color: green; color: white',
+            len( s_keys[ 2 ] ) - 1:     'background-color: red; color: white'
+        }
+    }
+    # fmt: on
+
+    def keyboard(self):
+        w = Widget()
+        lay = VBoxLayout()
+        w.set_layout(lay)
+
+        for i, keys in enumerate(self.s_keys):
+            hlay = HBoxLayout()
+            for j, c in enumerate(keys):
+                b = PushButton(c)
+                styles = self.s_style.get(i)
+                if styles:
+                    sh = styles.get(j)
+                    if sh:
+                        b.set_style_sheet(sh)
+
+                avg_char_width = w.font_metrics().average_char_width()
+                b.setMaximumWidth(3 * avg_char_width)
+
+                hlay.add_widget(b)
+            lay.add_layout(hlay)
+
+        return w
+
+    def widget(self):
+        ux.init()
+        w = Widget()
+        lay = VBoxLayout()
+        w.set_layout(lay)
+
+        self.m_top_editor = top_editor = self
+        top = top_editor.row()
+        lay.add_layout(top)
+        lay.add_widget(ux.separator())
+
+        table = self.table()
+        lay.add_widget(table)
+
+        lay.add_widget(ux.separator())
+        lay.add_widget(self.keyboard())
+
+        return w
+
+
+class _GuessWordData:
+    # fmt: off
+    MODULE_NAME = '_guess_word_data'
+    NUM_CHARS   = (5, 6)
+    # fmt: on
+
+    @classmethod
+    def download_nouns(cls, filename: str):
+        import nltk
+        from nltk.corpus import wordnet as wn
+
+        if os.path.exists(filename):
+            return
+
+        nltk.download('wordnet')
+        noun_pool = [
+            w.name() for s in wn.all_synsets('n') for w in s.lemmas() if len(w.name()) in cls.NUM_CHARS and w.name().isalpha() and w.name().islower()
+        ]
+
+        with open(filename, 'w') as f:
+            print('noun_pool = {', file=f)
+            for n in cls.NUM_CHARS:
+                print(f'\t{n}: [', file=f)
+                pool = [w for w in noun_pool if len(w) == n]
+                for w in pool:
+                    print(f'\t\t{w!r},', file=f)
+                print('\t],', file=f)
+            print('}', file=f)
+
+    @classmethod
+    @cache
+    def noun_pool(cls) -> dict:
+        import importlib
+        import importlib.util
+        from pathlib import Path
+
+        package_name = cls.__module__.rsplit('.', 1)[0]
+        spec = importlib.util.find_spec(package_name)
+        assert spec.submodule_search_locations
+        package_dir = Path(spec.submodule_search_locations[0])
+        file_name = package_dir / f'{cls.MODULE_NAME}.py'
+        cls.download_nouns(file_name)
+
+        module_name = f'{package_name}.{cls.MODULE_NAME}'
+        m = importlib.import_module(module_name)
+        noun_pool = getattr(m, 'noun_pool', None)
+        assert noun_pool and type(noun_pool) is dict, 'noun_pool must be a non-empty dict by num chars'
+        return noun_pool
+
+    @classmethod
+    def word_exists(cls, w: str) -> bool:
+        noun_pool = cls.noun_pool()
+        n = len(w)
+        words = noun_pool.get(n)
+        return words and w in words
+
+    @classmethod
+    def new_word(cls, n: int) -> str:
+        noun_pool = cls.noun_pool()
+        words = noun_pool.get(n)
+        if words is None:
+            raise AssertionError(f'There are no {n}-letter words available')
+        return random.choice(words)
+
+
+if __name__ == '__main__':
+    from ui_10x.examples.guess_word import Game, _GuessWordData
+
+    game = Game()
+    # w = game.widget()
+
+    w = game.the_word
+
+    # d = UxDialog( w, title = f'You have {game.count()} attempts to guess a word' )
+    # d.exec()

ui_10x/examples/message_box.py

@@ -0,0 +1,20 @@
+
+
+if __name__ == '__main__':
+    #import os;assert os.environ.setdefault('UI_PLATFORM', 'Rio') == os.getenv('UI_PLATFORM')
+
+    from ui_10x.utils import ux, ux_answer, ux_success, ux_warning
+
+    app = ux.init()
+
+    ret = ux_answer('This is a message box. '*50+'Ok?', title='Message Box Title')
+
+    print(ret)
+
+
+    ret = ux_success('This is a success message box. '*50+'Ok?', title='Success Message Box Title')
+    print(ret)
+
+    ret = ux_warning('This is a warning message box. '*50+'Ok?', title='Warning Message Box Title')
+    print(ret)
+

ui_10x/examples/multi_choice.py

@@ -0,0 +1,17 @@
+if __name__ == '__main__':
+    from core_10x.code_samples.directories import ANIMALS
+
+    from ui_10x.choice import MultiChoice
+    from ui_10x.utils import UxDialog, ux
+
+    ux.init()
+
+    choice1 = MultiChoice(choices = ANIMALS)
+
+    d = UxDialog(choice1.widget())
+    d.exec()
+
+    choice2 = MultiChoice(choices = ANIMALS.choices())
+
+    d = UxDialog(choice2.widget())
+    d.exec()

ui_10x/examples/py_data_browser.py

@@ -0,0 +1,66 @@
+from datetime import date
+
+from core_10x.py_class import PyClass
+
+from ui_10x.py_data_browser import PyDataBrowser
+from ui_10x.utils import ux
+
+
+class A:
+    pass
+
+
+class B:
+    def __repr__(self):
+        return f'class {self.__class__.__name__} stub'
+
+data = {
+    'Plain int': 33,
+    'Boolean': True,
+    'All': (False, True),
+    'Just None': None,
+    'Now': date.today(),
+    'A simple list': [ 100, 'abracadabra', 375.89 ],
+    'A simple dict': dict(_a = 10, _b = None, _c = 'Atlantic Ocean'),
+    'Unknown': A(),
+    'Unknown, but': B(),
+
+    'Nested Dict': dict(
+        person = dict(
+            first_name = 'Mike',
+            last_name = 'Fellows',
+            age = 50,
+            countries = ('USA', 'Japan', 'Korea'),
+        ),
+        regions = [
+            'Europe',
+            dict(
+                North = [ 'Canada', 'USA', 'Mexico' ],
+                Central = [ 'Nicaragua', 'Costa Rica', 'Equador' ],
+                South = [ 'Brasil', 'Argentina' ],
+            ),
+            'Asia',
+        ],
+    ),
+    # 'People':           Person.generateList( _cache_only = True )
+}
+
+def on_select(browser: PyDataBrowser, path: list, value, delims = ('/', '/')):
+    path_text = PyDataBrowser.path_to_str(path, delims)
+    return print(f"'{path_text}' -> {value}")
+
+
+if __name__ == '__main__':
+    ux.init()
+
+    PyDataBrowser.show([10, 'a'], on_select = on_select)
+
+    PyDataBrowser.edit(
+        data,
+        on_select = lambda browser, path, value: on_select(browser, path, value, delims = ('[]', '[]'))
+    )
+
+    PyDataBrowser.show(
+        PyClass.class_names_by_module('core_10x'),
+        on_select = lambda browser, path, value: on_select(browser, path, value, delims = ('.', ''))
+    )

ui_10x/examples/radiobox.py

@@ -0,0 +1,29 @@
+from core_10x.rc import RC_TRUE
+
+if __name__ == '__main__':
+    #import os;assert os.environ.setdefault('UI_PLATFORM', 'Rio') == os.getenv('UI_PLATFORM')
+
+    from core_10x.named_constant import NamedConstant
+
+    from ui_10x.utils import UxDialog, UxRadioBox, ux
+
+    class COLOR(NamedConstant, lowercase_values = True):
+        BLACK   = ()
+        WHITE   = ()
+        GREEN   = ()
+        RED     = ()
+        BROWN   = ()
+
+    app = ux.init()
+
+    w = UxRadioBox(COLOR, 'Choose a Color', default_value = COLOR.GREEN)
+    def cb():
+        print('accept:', w.choice() )
+        return RC_TRUE
+    d = UxDialog(w, accept_callback=cb)
+
+    rc = d.exec()
+
+    print(w.choice(),rc)
+
+

ui_10x/examples/single_choice.py

@@ -0,0 +1,31 @@
+if __name__ == '__main__':
+    #import os;assert os.environ.setdefault('UI_PLATFORM', 'Rio') == os.getenv('UI_PLATFORM')
+
+    from core_10x.code_samples.directories import ANIMALS, FISH
+
+    from ui_10x.choice import Choice
+    from ui_10x.utils import UxDialog, ux
+
+    ux.init()
+
+    choice1 = Choice(choices = ANIMALS)
+    d = UxDialog(choice1.widget())
+    d.exec()
+
+    print(choice1.values_selected)
+
+    choice2 = Choice(choices = FISH)
+    d = UxDialog(choice2.widget())
+    d.exec()
+
+    print(choice2.values_selected)
+
+    choice3 = Choice(choices = FISH.choices())
+
+    d = UxDialog(choice3.widget())
+    d.exec()
+
+    print(choice3.values_selected)
+
+    choice3.popup()
+    print(choice3.values_selected)

ui_10x/examples/style_sheet.py

@@ -0,0 +1,47 @@
+from core_10x.exec_control import CACHE_ONLY
+from core_10x.traitable import T, Traitable, Ui
+
+COLORS = ('black', 'white', 'green', 'lightgreen', 'red', 'blue', 'grey')
+
+class StyleSheet(Traitable):
+    foreground: str     = T('black',        ui_hint = Ui(widget_type = Ui.WIDGET_TYPE.CHOICE))
+    background: str     = T('white',        ui_hint = Ui(widget_type = Ui.WIDGET_TYPE.CHOICE, flags = Ui.SEPARATOR))
+
+    font: str           = T('Helvetica',    ui_hint = Ui(widget_type = Ui.WIDGET_TYPE.CHOICE))
+    font_style: bool    = T(False,          ui_hint = Ui('italic', right_label = True))
+    font_weight: bool   = T(False,          ui_hint = Ui('bold', flags = Ui.SEPARATOR, right_label = True))
+
+    border_style: bool  = T(False)
+    border_color: str   = T('blue',         ui_hint = Ui(widget_type = Ui.WIDGET_TYPE.CHOICE))
+    border_width: int   = T(2,              ui_hint = Ui(flags = Ui.SEPARATOR))
+
+    show_me: str        = T('This is how it will look...',  ui_hint = Ui('WYSIWYG', min_width = 50))
+
+    def foreground_choices(self, t):    return COLORS
+    def background_choices(self, t):    return COLORS
+    def border_color_choices(self, t):  return COLORS
+    def font_choices(self, t):          return ('Times New Roman', 'Helvetica', 'Courier New')
+
+    def show_me_style_sheet(self) -> dict:
+        ss = {
+            Ui.FG_COLOR:        self.foreground,
+            Ui.BG_COLOR:        self.background,
+            Ui.FONT:            self.font,
+            Ui.FONT_STYLE:      'italic'   if self.font_style    else 'normal',
+            Ui.FONT_WEIGHT:     'bold'     if self.font_weight   else 'normal',
+            Ui.BORDER_WIDTH:    f'{self.border_width}px',
+            Ui.BORDER_STYLE:    'solid'    if self.border_style  else '',
+            Ui.BORDER_COLOR:    self.border_color,
+        }
+        print(ss)
+        return ss
+
+if __name__ == '__main__':
+    from ui_10x.traitable_editor import TraitableEditor
+
+    with CACHE_ONLY():
+        sheet = StyleSheet()
+        e = TraitableEditor(sheet, _confirm = True)
+        e.dialog().exec()
+
+

ui_10x/examples/trivial_entity_editor.py

@@ -0,0 +1,18 @@
+from core_10x.code_samples.person import Person
+from infra_10x.mongodb_store import MongoStore
+
+from ui_10x.traitable_editor import TraitableEditor, TraitableView
+
+if __name__ == '__main__':
+    db = MongoStore.instance(hostname='localhost', dbname='test')
+    db.begin_using()
+
+    p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+    view = TraitableView.modify(Person,
+        #weight_qu   = UiMod(flags = Ui.HIDDEN),
+    )
+    e = TraitableEditor.editor(p, view = view)
+    rc = e.dialog(save=True).exec()
+
+
+

ui_10x/platform.py

@@ -0,0 +1,20 @@
+import os
+import sys
+import typing
+
+if typing.TYPE_CHECKING:
+    import platform_interface as ux
+else:
+    pname = os.getenv('UI_PLATFORM')
+    if pname is None:
+        pname = 'Qt6' if 'rio' not in sys.modules else 'Rio'
+
+    if pname == 'Qt6':
+        import ui_10x.qt6.platform_implementation as ux
+    elif pname == 'Rio':
+        import ui_10x.rio.platform_implementation as ux
+    else:
+        raise ImportError(f'UI implementation for `{pname}` is not available')
+
+
+__all__ = ['ux']