py10x-universe 0.1.3__py3-none-any.whl

ui_10x/apps/collection_editor_app.py

@@ -0,0 +1,100 @@
+from core_10x.directory import Directory
+from core_10x.environment_variables import EnvVars
+from core_10x.exec_control import INTERACTIVE
+from core_10x.py_class import PyClass
+from core_10x.traitable import RC, RC_TRUE, RT, AnonymousTraitable, Traitable, XNone
+
+from ui_10x.collection_editor import Collection, CollectionEditor
+from ui_10x.traitable_editor import TraitableEditor
+from ui_10x.traitable_view import Ui
+from ui_10x.utils import UxDialog, ux
+
+
+class CEApp(Traitable):
+    s_exclude_packages = ('manual_tests', 'unit_tests')
+
+    # fmt: off
+    main_store_uri: str     = RT()
+    top_package: str        = RT()
+    exclude_packages: list  = RT(Ui(flags = Ui.HIDDEN))
+    current_class: type     = RT(Ui.choice(stretch = 1))
+
+    my_editor: TraitableEditor  = RT()
+    col_editor: CollectionEditor = RT()
+    main_w: ux.Splitter         = RT()
+    # fmt: on
+
+    def main_store_uri_get(self) -> str:
+        return EnvVars.main_ts_store_uri
+
+    def main_store_uri_set(self, trait, value) -> RC:
+        self.raw_set_value(trait, value)
+        EnvVars.main_ts_store_uri = value
+        return RC_TRUE
+
+    def exclude_packages_get(self) -> list:
+        root_name = self.top_package
+        return [f'{root_name}.{name}' for name in self.s_exclude_packages]
+
+    def current_class_set(self, trait, value) -> RC:
+        self.raw_set_value(trait, value)
+        coll = Collection(cls=value)
+        ce = CollectionEditor(coll=coll)
+        self.col_editor = ce
+        w = ce.main_widget()
+        self.main_w.replace_widget(0, w)
+
+        return RC_TRUE
+
+    def current_class_choices(self, trait) -> Directory:
+        top_package = self.top_package
+        if not top_package:
+            return XNone
+
+        all_traitables = PyClass.all_classes(self.top_package, exclude_packages=self.exclude_packages, parent_classes=(Traitable,))
+        all_storables = tuple(cls for cls in all_traitables if cls.is_storable() and not issubclass(cls, AnonymousTraitable))
+        dir = Directory(name='Classes')
+        for cls in all_storables:
+            path = cls.__module__.split('.')
+            dir.insert(PyClass.name(cls), *path)
+
+        return dir
+
+    def my_editor_get(self) -> TraitableEditor:
+        return TraitableEditor(self, _confirm=True)
+
+    def main_widget(self) -> ux.Widget:
+        w = ux.Widget()
+        lay = ux.VBoxLayout()
+        w.set_layout(lay)
+
+        lay.add_layout(self.my_editor.row_layout())
+        lay.add_widget(ux.separator())
+
+        sp = ux.Splitter(ux.Horizontal)
+        lay.add_widget(sp)
+
+        sp.set_style_sheet('QSplitter::handle { background-color: darkgrey; }')
+        sp.set_handle_width(1)
+
+        sp.add_widget(ux.Widget())
+        sp.set_stretch_factor(0, 1)
+        sp.set_stretch_factor(1, 2)  # -- TODO: set it for extra panes as needed
+
+        self.main_w = sp
+
+        return w
+
+
+if __name__ == '__main__':
+    from ui_10x.apps.collection_editor_app import CEApp
+
+    ux.init()
+
+    top_package = input('Top level package:')
+    ce_app = CEApp(top_package=top_package)
+
+    with INTERACTIVE():
+        w = ce_app.main_widget()
+        d = UxDialog(w)
+        d.exec()

ui_10x/choice.py

@@ -0,0 +1,212 @@
+from core_10x.directory import Directory
+from core_10x.named_constant import Enum
+from core_10x.xnone import XNone
+
+from ui_10x.utils import UxDialog, UxRadioBox, UxSearchableList, UxTreeViewer, ux
+
+
+class Choice:
+    """
+    choices     - a dict of labels to tags values or Directory; if given, f_choices is ignored
+    f_choices   - a fully bound function that must return choices (see above)
+
+    Q1: do we want to allow setting tags_selected with tags outside of all_choices? If so, what about updating all_choices
+        and potentially saving such Choice instance?
+    """
+    def __init__(self, choices = XNone, f_choices = None, f_selection_callback = None, **kwargs):
+        self.choices: dict = XNone
+        self.inverted_choices: dict = XNone
+        self.f_choices = None
+        self.f_selection_cb = None
+        self.directory: Directory = None
+        self.kwargs = {}
+
+        self.values_selected = []
+
+        self.set(choices = choices, f_choices = f_choices, f_selection_callback = f_selection_callback, **kwargs)
+
+    def set(self, choices = XNone, f_choices = None, f_selection_callback = None, **kwargs):
+        assert choices or f_choices, 'Either choices or f_choices must be given'
+
+        self.f_selection_cb = f_selection_callback
+
+        if (choices):
+            self.f_choices = None
+        else:
+            self.f_choices = f_choices
+            choices = f_choices()       #-- TODO: we may want to wrap it in try - except
+
+        self.kwargs.update(kwargs)
+
+        if isinstance(choices, Directory):
+            self.directory = choices
+            self.choices = choices.choices()
+
+        elif isinstance(choices, dict):
+            self.directory = None
+            self.choices = choices
+
+        else:   #-- must be an iterable then!
+            self.directory = None
+            try:
+                self.choices = {hint: hint for hint in choices}
+            except Exception:
+                self.choices = {}
+
+        self.inverted_choices = {value: label for label, value in self.choices.items()}
+
+    def widget(self) -> ux.Widget:
+        if self.directory:
+            return UxTreeViewer(
+                self.directory,
+                select_hook = lambda dir: self.on_item_selected(dir, dir.value, False),
+                **self.kwargs
+            )
+
+        return UxSearchableList(
+            choices     = list(self.choices.keys()),
+            select_hook = lambda item_value: self.on_item_selected(None, item_value, True),
+            **self.kwargs
+        )
+
+    def on_item_selected(self, dir: Directory, item, convert_choice: bool):
+        item_value = self.choices.get(item) if convert_choice else item
+        if item_value is not None:
+            self.on_value_selected(dir, item_value, convert_value = convert_choice)
+            if self.f_selection_cb:
+                self.f_selection_cb(item)
+
+    def on_value_selected(self, dir: Directory, item_value, convert_value: bool = False):
+        self.values_selected = [item_value]
+
+    def _on_selection_in_dialog(self, d: UxDialog, current_selection_cb, item_value):
+        if current_selection_cb:
+            current_selection_cb(item_value)
+        d.done(1)
+        self.f_selection_cb = current_selection_cb
+
+    def popup(self, parent: ux.Widget = None, _open = True) -> UxDialog:
+        _d = UxDialog(
+            self.widget(),
+            parent = parent,
+            title = 'Pick your choice',
+            ok = '', cancel = '',
+            #window_flags = Qt.FramelessWindowHint | Qt.Window | Qt.CustomizeWindowHint
+        )
+
+        current_selection_cb = self.f_selection_cb
+        self.f_selection_cb = lambda item_value: self._on_selection_in_dialog(_d, current_selection_cb, item_value)
+
+        if _open:
+            _d.show()
+
+        return _d
+
+
+class MultiChoice(Choice):
+    class SELECT_MODE(Enum):
+        ANY     = ()
+        LEAF    = ()
+        SUBDIR  = ()
+
+    def __init__(self, *choices_selected, choices = XNone, f_choices = None, **kwargs):
+        super().__init__(choices = choices, f_choices = f_choices, **kwargs)
+        self._set_choices_selected(choices_selected)
+
+    def set(self, *choices_selected, choices = XNone, f_choices = None, **kwargs):
+        super().set(choices = choices, f_choices = f_choices, **kwargs)
+        self._set_choices_selected(choices_selected)
+
+    def _set_choices_selected(self, choices_selected: tuple):
+        all_choices = self.choices
+        self.values_selected.extend(tuple(value for choice in choices_selected if (value := all_choices.get(choice) )))
+
+    def select_mode(self):
+        return self.rb.choice() if self.rb else self.SELECT_MODE.ANY
+
+    def widget(self) -> ux.Widget:
+        self.sw = sw = super().widget()
+        if not sw:
+            return None
+
+        w = ux.Splitter(ux.Horizontal)
+
+        if isinstance(sw, UxTreeViewer):
+            left = ux.Widget()
+            left_lay = ux.VBoxLayout()
+            left.set_layout(left_lay)
+
+            self.rb = rb = UxRadioBox(self.SELECT_MODE, horizontal = True, title = 'Selection Mode')
+            left_lay.add_widget(rb)
+            left_lay.add_widget(sw)
+        else:
+            left = sw
+            self.rb = None
+
+        w.add_widget(left)
+
+        self.selection_list = selection_list = ux.ListWidget()
+        labels = self.values_selected
+        if not self.directory:
+            map = self.inverted_choices
+            labels = [map.get(v) for v in labels if map.get(v)]
+
+        selection_list.add_items(labels)
+        selection_list.clicked_connect(self.on_selection_list_selection)
+        w.add_widget(selection_list)
+
+        return w
+
+    def on_selection_list_selection(self, item: ux.ListItem):
+        label = item.text()
+        if not self.directory:
+            value = self.choices.get(label)
+        else:
+            value = label
+
+        assert value, f"Value for '{label}' must exist"
+
+        self.values_selected.remove(value)
+        row = self.selection_list.row(item)
+        self.selection_list.take_item(row)
+
+    def on_value_selected(self, subdir: Directory, item_value, convert_value = False):
+        values_selected = self.values_selected
+        if item_value not in values_selected:
+            mode = self.select_mode()
+            handler = self.s_select_table.get(mode)
+            if handler(self, subdir, values_selected, item_value):
+                values_selected.append(item_value)
+                if convert_value:
+                    item_value = self.inverted_choices.get( item_value )
+                self.selection_list.add_item(item_value)
+
+    def _select_leaf(self, subdir: Directory, values_selected: list, item_value) -> bool:
+        return subdir.is_leaf()
+
+    def _select_subdir(self, subdir: Directory, values_selected: list, item_value) -> bool:
+        dir = self.directory
+        assert dir, 'This is not a Directory'
+
+        n = len(values_selected)
+        for value in list(values_selected):
+            if dir.is_value_contained(item_value, value):
+                return False    #-- it's a subdir of something already selected
+
+            if subdir.contains(value):
+                values_selected.remove(value)
+
+        if n > len(values_selected):    #-- one or more subdirs contained by the subdir got removed
+            self.selection_list.clear()
+            self.selection_list.add_items(values_selected)
+
+        return True
+
+    # fmt: off
+    s_select_table = {
+        SELECT_MODE.ANY:       lambda self, x,y,z: True,
+        SELECT_MODE.LEAF:      _select_leaf,
+        SELECT_MODE.SUBDIR:    _select_subdir
+    }
+    # fmt: on
+

ui_10x/collection_editor.py

@@ -0,0 +1,135 @@
+from typing import Any
+
+from core_10x.trait_filter import f
+from core_10x.traitable import RC, RT, T, Traitable
+from core_10x.traitable_id import ID
+
+from ui_10x.entity_stocker import EntityStocker, StockerPlug
+from ui_10x.traitable_editor import TraitableEditor
+from ui_10x.utils import (
+    UxSearchableList,
+    ux,
+    ux_make_scrollable,
+    ux_push_button,
+    ux_warning,
+)
+
+
+class Collection(Traitable):
+    cls: type[Traitable]
+    filter: f = RT(T.HIDDEN)
+
+    entity_ids: list[str]
+
+    def cls_set(self, t, cls) -> RC:
+        assert issubclass(cls, Traitable), f'{cls} is not a Traitable class'
+        return self.raw_set_value(t, cls)
+
+    def entity_ids_get(self) -> list[str]:
+        return [entity_id.value for entity_id in self.cls.load_ids()]
+
+    def refresh(self):
+        self.invalidate_value('entity_ids')
+
+
+class CollectionEditor(Traitable):
+    coll: Collection
+    current_class: Any
+    coll_title: str
+    num_panes: int = RT(1)
+
+    main_w: ux.Splitter
+    searchable_list: UxSearchableList
+    stocker: EntityStocker
+
+    current_editor: Any
+    current_entity: Traitable
+
+    def current_class_get(self):
+        return self.coll.cls
+
+    def stocker_get(self):
+        return EntityStocker(plug=StockerPlug(master=self))
+
+    def main_widget(self) -> ux.Widget:
+        sp = ux.Splitter(ux.Horizontal)
+
+        left_w = ux.Widget()
+        left_lay = ux.VBoxLayout()
+        left_w.set_layout(left_lay)
+
+        left_top_lay = ux.HBoxLayout()
+        line_w = ux.LineEdit()
+        line_w.set_minimum_width(100)
+        button_w = ux_push_button('New', callback=self.on_new_entity, style_icon='FileIcon')
+        left_top_lay.add_widget(line_w)
+        left_top_lay.add_widget(button_w)
+
+        left_lay.add_layout(left_top_lay)
+
+        # fmt: off
+        self.searchable_list = list_w = UxSearchableList(
+            text_widget = line_w,
+            title       = f'Instances of {self.coll.cls.__name__}',
+            choices     = self.coll.entity_ids,
+            select_hook = self.on_entity_id_selection,
+            sort        = True,
+        )
+        # fmt: on
+
+        slw = ux_make_scrollable(list_w, h=ux.SCROLL.OFF)
+
+        left_lay.add_widget(slw)
+
+        sp.set_style_sheet('QSplitter::handle { background-color: darkgrey; }')
+        sp.set_handle_width(1)
+        sp.add_widget(left_w)
+        sp.add_widget(ux.Widget())
+        sp.set_stretch_factor(0, 1)
+        sp.set_stretch_factor(1, 2)  # -- TODO: set it for extra panes as needed
+
+        self.main_w = sp
+        return sp
+
+    def set_pane(self, index: int, w: ux.Widget):
+        main_w = self.main_w
+        assert main_w, f'{self.__class__} - no widget has been created yet'
+
+        num_panes = self.num_panes
+        if num_panes and 0 <= index < num_panes:
+            if index < num_panes:
+                main_w.replace_widget(index + 1, w)
+            else:
+                main_w.add_widget(w)
+                self.num_panes = num_panes + 1
+
+    def on_entity_id_selection(self, id_value: str):
+        if self.num_panes:
+            obj: Traitable = self.coll.cls(_id=ID(id_value))
+            se = self.stocker
+            ed = se or TraitableEditor.editor(obj)
+            self.current_entity = obj
+            self.current_editor = ed
+            w = ed.main_widget()
+            self.set_pane(0, w)
+
+    def on_new_entity(self, flag):
+        cls = self.current_class
+        if cls:
+            new_entity = cls()
+            ed = TraitableEditor.editor(new_entity)
+
+            def accept_hook(rc: RC):
+                if not rc:
+                    ux_warning(rc.error(), parent=self.main_w, on_close=lambda ctx: None)
+                    # -- TODO: should we "merge" values from the existing instance?
+
+                else:
+                    self.searchable_list.add_choice(new_entity.id().value)
+
+            ed.popup(copy_entity=False, title=f'New Entity of {cls.__name__}', save=True, accept_hook=accept_hook)
+
+    def on_deleted_entity(self, deleted_entity: Traitable):
+        self.searchable_list.remove_choice(deleted_entity.id().value)
+        if self.current_entity is deleted_entity:
+            self.set_pane(0, ux.Widget())

ui_10x/concrete_trait_widgets.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from core_10x.concrete_traits import list_trait
+from core_10x.trait import Ui
+
+from ui_10x.choice import Choice
+from ui_10x.trait_widget import TraitWidget
+from ui_10x.utils import UxClipBoard, ux, ux_push_button
+
+if TYPE_CHECKING:
+    from core_10x.trait import Trait
+
+
+class LineEditWidget(TraitWidget, ux.LineEdit, widget_type=Ui.WIDGET_TYPE.LINE):
+    def _create(self):
+        ux.LineEdit.__init__(self)
+
+        self.text_edited_connect(self.on_editing)
+        self.editing_finished_connect(self.on_editing_finished)
+        self.was_edited = False
+
+    def on_editing(self, text):
+        self.was_edited = True
+
+    def on_editing_finished(self):
+        if self.was_edited:
+            self.was_edited = False
+            str_value = self.text()
+            if not str_value:  # -- user cleared the field, let's get the value back!
+                self.update_trait_value(invalidate=True)
+            else:
+                ##value = self.trait.from_str(str_value)
+                self.update_trait_value(value=str_value, invalidate=False)
+
+    def mouse_press_event(self, event: ux.MouseEvent):
+        if event.is_right_button():
+            if not self.trait_editor.is_read_only():
+                cb = UxClipBoard()
+                cb.popup(self, self.entity, self.trait.name)
+            else:
+                ux.LineEdit.mouse_press_event(self, event)
+
+    def _set_read_only(self, flag):
+        self.set_read_only(flag)
+
+    def _value(self):
+        str_value = self.text()
+        return self.trait.from_str(str_value)
+
+    def _set_value(self, value):
+        str_value = self.trait.to_str(value)
+        self.set_text(str_value)
+
+
+def create_text_widget(editor, trait: Trait):
+    if isinstance(trait, list_trait):
+        return TextEditForListWidget(editor, trait)
+
+    return TextEditWidget(editor, trait)
+
+
+TraitWidget.s_hinted_widgets[Ui.WIDGET_TYPE.TEXT] = create_text_widget
+
+
+class TextEditWidget(TraitWidget, ux.TextEdit):
+    def _create(self):
+        ux.TextEdit.__init__(self)
+
+    def focus_out_event(self, event):
+        value = self._value()
+        self.update_trait_value(value=value) if value else self.update_trait_value(invalidate=True)
+
+    def _set_read_only(self, flag):
+        self.set_read_only(flag)
+
+    def _value(self):
+        return self.to_plain_text()
+
+    def _set_value(self, value):
+        if not isinstance(value, str):
+            value = ''
+        self.set_plain_text(value)
+
+
+class TextEditForListWidget(TextEditWidget):
+    def _value(self) -> list:
+        text = self.to_plain_text()
+        return text.split('\n')
+
+    def _set_value(self, value):
+        if value:
+            if not isinstance(value, list):
+                raise AssertionError('list is expected')
+
+            value = '\n'.join(value)
+            self.set_plain_text(value)
+
+
+class PasswordWidget(LineEditWidget, widget_type=Ui.WIDGET_TYPE.PASSWORD):
+    def _create(self):
+        super()._create()
+        self.set_password_mode()
+        self.set_text('')
+
+
+class CheckBoxWidget(TraitWidget, ux.CheckBox, widget_type=Ui.WIDGET_TYPE.CHECK):
+    def _create(self):
+        ux.CheckBox.__init__(self)
+        if self.trait.ui_hint.param('right_label', False):
+            self.set_text(self.trait.ui_hint.label)
+
+        self.state_changed_connect(self.on_state_changed)
+
+    def on_state_changed(self, flag):
+        self.update_trait_value(value=bool(flag))
+
+    def _set_read_only(self, flag):
+        self.set_enabled(flag)
+
+    def _value(self):
+        return bool(self.is_checked())
+
+    def _set_value(self, value):
+        self.set_checked(bool(value))
+
+
+class ChoiceWidget(TraitWidget, ux.Widget, widget_type=Ui.WIDGET_TYPE.CHOICE):
+    def _create(self):
+        ux.Widget.__init__(self)
+
+        lay = ux.HBoxLayout()
+        lay.set_spacing(0)
+        lay.set_contents_margins(0, 0, 0, 0)
+        self.set_layout(lay)
+
+        # -- Line edit
+        self.line_edit = le = ux.LineEdit()
+        if self.trait_editor.is_read_only():
+            le.set_read_only(True)
+
+        le.editing_finished_connect(self.on_editing_finished)
+        lay.add_widget(le)
+
+        # -- Arrow down button
+        self.button = ux_push_button('', callback=self.show_popup, style_icon='ArrowDown')
+        lay.add_widget(self.button)
+
+        entity = self.trait_editor.entity
+        trait = self.trait
+        self.choice = Choice(f_choices=lambda: entity.get_choices(trait), f_selection_callback=lambda item: self.on_selection(item))
+
+    def _value(self):
+        selection = self.choice.values_selected
+        return selection[0] if selection else None
+
+    def _set_value(self, value):
+        if not self.choice.directory:
+            value = self.choice.inverted_choices.get(value)
+
+        if not value:
+            value = ''
+        self.line_edit.set_text(value)
+
+    def _set_read_only(self, flag):
+        self.line_edit.set_read_only(flag)
+        self.button.set_enabled(not flag)
+
+    # def on_current_index_changed(self, index):
+    #     self.update_trait_value()
+
+    def show_popup(self):
+        self.popup = d = self.choice.popup(parent=self, _open=False)
+        w = self.width()
+        h = self.height()
+        xy = self.map_to_global(ux.Point(0, 0))
+
+        d.set_modal(True)
+        d.show()
+        d.set_geometry(xy.x(), xy.y(), max(w, d.width()), h)
+
+    def on_selection(self, item):
+        self.line_edit.set_text(item)
+        self.update_trait_value(value=self.choice.values_selected[0], invalidate=False)
+
+    def on_editing_finished(self):
+        str_value = self.line_edit.text()
+        if not str_value:
+            self.update_trait_value(invalidate=True)
+        else:
+            value = self.choice.choices.get(str_value, str_value)
+            self.update_trait_value(value=value, invalidate=False)
+
+
+class PixmapLabelWidget(TraitWidget, ux.Label, widget_type=Ui.WIDGET_TYPE.PIXMAP):
+    def _create(self):
+        ux.Label.__init__(self)
+        # self.pixmap = UxPixmap()
+
+    ...
+
+
+class PushButtonWidget(TraitWidget, ux.PushButton, widget_type=Ui.WIDGET_TYPE.PUSH):
+    def _create(self):
+        ux.PushButton.__init__(self)
+        self.set_text(self.trait.ui_hint.label)
+
+    ...
+
+    def _set_read_only(self, flag):
+        pass
+
+    def _value(self):
+        pass
+
+    def _set_value(self, value):
+        if value is None:
+            value = True
+        self.set_enabled(value)

ui_10x/conftest.py

@@ -0,0 +1,8 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def setup_ui_platform(monkeypatch):
+    monkeypatch.setenv('UI_PLATFORM', 'Unknown')
+    yield
+    monkeypatch.undo()