py10x-universe 0.1.3__py3-none-any.whl

ui_10x/trait_widget.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from core_10x.rc import RC, RC_TRUE
+from core_10x.trait import T, Ui
+
+from ui_10x.utils import UxStyleSheet, ux
+
+if TYPE_CHECKING:
+    from core_10x.trait import Trait
+
+
+class TraitWidget:
+    # __slots__ = ('program_edit', 'refresh_context', 'style_sheet', 'trait', 'trait_editor')
+    s_hinted_widgets = {}
+
+    def __init_subclass__(cls, widget_type: Ui.WIDGET_TYPE = None, **kwargs):
+        if widget_type:
+            TraitWidget.s_hinted_widgets[widget_type] = cls
+
+    @staticmethod
+    def widget_class(widget_type: Ui.WIDGET_TYPE):
+        w_cls = TraitWidget.s_hinted_widgets.get(widget_type)
+        assert w_cls, f'Unknown trait widget type: {widget_type}'
+        return w_cls
+
+    @staticmethod
+    def instance(trait_editor) -> TraitWidget | None:
+        w_type = trait_editor.ui_hint.widget_type
+        if w_type is not Ui.WIDGET_TYPE.NONE:
+            w_cls = TraitWidget.widget_class(w_type)
+            return w_cls(trait_editor)
+        return None
+
+    def __init__(self, trait_editor):
+        self.trait_editor = trait_editor
+        self.trait: Trait = trait_editor.trait
+        self.program_edit = False
+
+        self._create()
+
+        if self.trait_editor.is_read_only():
+            self._set_read_only(True)
+
+        self.set_tool_tip(self.trait.ui_hint.tip)
+
+        entity = self.trait_editor.entity
+
+        self.style_sheet = sheet = UxStyleSheet(self)
+        sh = entity.get_style_sheet(self.trait)
+        sheet.update(sh)
+
+        value = entity.get_value(self.trait)
+        self.set_widget_value(value)
+
+        self.refresh_context = ctx = RefreshContext(self)
+        entity.create_ui_node(self.trait, ctx.emit_signal)
+
+    def refresh(self):
+        entity = self.trait_editor.entity
+        trait = self.trait
+        entity.update_ui_node(self.trait)
+
+        if not trait.flags_on(T.EXPENSIVE):
+            value = entity.get_value(trait)
+            self.set_widget_value(value)
+        else:
+            sh = entity.get_style_sheet(trait)
+            self.style_sheet.update(sh)
+
+            if not entity.is_valid(trait):
+                self.style_sheet.update({Ui.BG_COLOR: 'lightblue'}, _system=True)
+
+    def widget_value(self):
+        return self._value()
+
+    def set_widget_value(self, value) -> bool:
+        self.program_edit = True
+        try:
+            self._set_value(value)
+        except Exception:  # -- the real widget is gone (so far, has encountered this only in Qt on Mac OS)
+            # self.clean()   #-- TODO: fix!
+            self.program_edit = False
+            return False
+
+        sh = self.trait_editor.entity.get_style_sheet(self.trait)
+        self.style_sheet.update(sh)
+        self.program_edit = False
+        return True
+
+    def update_trait_value(self, value: Any = None, invalidate: bool = False):
+        if not self.program_edit:
+            entity = self.trait_editor.entity
+            if invalidate:
+                entity.invalidate_value(self.trait)
+                rc = RC_TRUE
+            else:
+                if value is None:
+                    value = self.widget_value()
+
+                try:
+                    rc = entity.set_value(self.trait, value)
+                except Exception as e:
+                    rc = RC(False, str(e))
+
+            if not rc:
+                self.set_tool_tip(rc.error())
+                self.style_sheet.update({Ui.BG_COLOR: 'orange'}, _system=True)
+            else:
+                self.set_tool_tip(self.trait.ui_hint.tip)
+                self.style_sheet.restore()
+
+    # fmt: off
+    def _create(self):              raise NotImplementedError
+    def _set_read_only(self, flag): raise NotImplementedError
+    def _value(self):               raise NotImplementedError
+    def _set_value(self, value):    raise NotImplementedError
+    # fmt: on
+
+
+class RefreshContext(ux.Object):
+    REFRESH = ux.signal_decl(object)
+
+    def __init__(self, trait_widget: TraitWidget):
+        super().__init__()
+        self.trait_widget = trait_widget
+        self.REFRESH.connect(TraitWidget.refresh, type=ux.QueuedConnection)
+
+    def emit_signal(self):
+        self.REFRESH.emit(self.trait_widget)

ui_10x/traitable_editor.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from core_10x.exec_control import INTERACTIVE
+from core_10x.global_cache import cache
+from core_10x.py_class import PyClass
+from core_10x.rc import RC_TRUE
+from core_10x.trait import Ui
+from core_10x.traitable import Traitable
+
+from ui_10x.trait_editor import TraitEditor
+from ui_10x.traitable_view import TraitableView
+from ui_10x.utils import UxDialog, ux, ux_warning
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from core_10x.rc import RC
+
+
+class TraitableEditor:
+    """
+    For many Traitables, a default Editor is sufficient.
+    A custom Editor, if needed, should be in a particular class, module and package.
+    Suppose your traitable class is abc.zyz.messages.TextMessage
+    - the custom editor class must be TextMessageEditor
+    - its module name must be messages_ui
+    - the module may be in either abc.xyz, abc.xyz.ui or alternative packages
+    - an editor class is searched first in alternative packages, if any; then in abc.xyz and abc.xyz.ui
+    - if a custom class is not found, the default TraitableEditor is used.
+    """
+
+    @staticmethod
+    @cache
+    def find_editor_class(
+        traitable_class: type[Traitable], *alternative_packages, traitable_class_parent: type[Traitable] = None, verify_custom_class: bool = True
+    ):
+        assert issubclass(traitable_class, Traitable), f'{traitable_class} is not a subclass of Traitable'
+        assert not traitable_class_parent or issubclass(traitable_class, traitable_class_parent), (
+            f'{traitable_class} is not a subclass of {traitable_class_parent}'
+        )
+
+        found = PyClass.find_related_class(traitable_class, 'ui', 'Editor', *alternative_packages, alternative_parent_class=traitable_class_parent)
+        if found:
+            if verify_custom_class:
+                assert issubclass(found, TraitableEditor), (
+                    f'{traitable_class} has a custom editor class {found} which is not a subclass of TraitableEditor'
+                )
+
+            return found
+
+        return TraitableEditor
+
+    # fmt: off
+    @staticmethod
+    def editor(
+        entity: Traitable,
+        *alternative_packages,                  #-- if custom editor class should be looked up somewhere else
+        traitable_class_parent      = None,     #-- if a custom editor of entity's parent class could be used if it's missing for the entity.__class__
+        verify_custom_class: bool   = True,     #-- if a custom editor class should be verified if exists
+        view: TraitableView         = None,     #-- if a specific view for the entity should be used
+        read_only: bool             = False     #-- browser if True
+    ) -> TraitableEditor:
+        # fmt: on
+        editor_class = TraitableEditor.find_editor_class(
+            entity.__class__,
+            *alternative_packages,
+            traitable_class_parent  = traitable_class_parent,
+            verify_custom_class     = verify_custom_class
+        )
+        return editor_class(entity, view = view, read_only = read_only, _confirm = True)
+
+    def __init__(self, entity: Traitable, view: TraitableView = None, read_only = False, _confirm = False):
+        assert _confirm, 'Do not call TraitableEditor() directly, use TraitableEditor.editor() instead'
+        assert isinstance(entity, Traitable), 'entity must be an instance of Traitable'
+
+        entity_class = entity.__class__
+        if view is None:
+            view = TraitableView.default(entity_class, read_only = read_only)
+        else:
+            assert issubclass(entity_class, view.cls), f'Given view is not for {entity_class}'
+
+        self.entity = entity
+        self.traitable_processor = None
+
+        trait_dir = entity_class.s_dir
+        self.trait_hints = trait_hints = {trait_dir[trait_name]: ui_hint for trait_name, ui_hint in view.ui_hints.items() if not ui_hint.flags_on(Ui.HIDDEN)}
+
+        self.main_w: ux.Widget|None = None
+        self.callbacks_for_traits = {}
+        self.init()
+
+        callbacks = self.callbacks_for_traits
+        self.trait_editors = {
+            trait.name: TraitEditor(entity, trait, ui_hint, custom_callback = callbacks.get(trait.name), traitable_processor = lambda : self.traitable_processor)
+            for trait, ui_hint in trait_hints.items()
+        }
+
+    def init(self):
+        ...
+
+    def set_callback_for_trait(self, trait_name: str, bound_method):
+        self.callbacks_for_traits[trait_name] = bound_method
+
+    def callback_for_trait(self, trait_name: str):
+        return self.callbacks_for_traits.get(trait_name)
+
+    def main_layout(self) -> ux.Layout:
+        lay = ux.FormLayout()
+
+        te: TraitEditor
+        for te in self.trait_editors.values():
+            label = te.new_label()
+            w = te.new_widget()
+            lay.add_row(label, w)
+            if te.ui_hint.flags_on(Ui.SEPARATOR):
+                lay.add_row(ux.separator())
+
+        return lay
+
+    def row_layout(self) -> ux.Layout:
+        row = ux.HBoxLayout()
+
+        stretched_trait_found = False
+        for te in self.trait_editors.values():
+            stretch = te.ui_hint.param('stretch', 0)
+            if stretch:
+                stretched_trait_found = True
+
+            row.add_widget(te.new_label())
+            row.add_widget(te.new_widget(), stretch=stretch)
+
+            if te.ui_hint.flags_on(Ui.SEPARATOR):
+                row.add_widget(ux.separator(horizontal = False))
+
+        if stretched_trait_found:
+            row.add_widget(ux.Label(), stretch = 1)
+
+        return row
+
+    def main_widget(self) -> ux.Widget:
+        self.main_w = w = ux.Widget()
+        lay = self.main_layout()
+        w.set_layout(lay)
+        return w
+
+    def _cleanup_tp(self, apply: bool):
+        self.main_w = None
+        if self.traitable_processor:
+            if apply:
+                self.traitable_processor.export_nodes()
+            self.traitable_processor=None
+
+    def _dialog(self, layout: ux.Layout, title: str, ok: str, min_width: int, on_accept: Callable[[], RC]) -> UxDialog:
+        ux.init()
+        if layout is not None:
+            w = self.main_w = ux.Widget()
+            w.set_layout(layout)
+        else:
+            w = self.main_widget()
+
+        def accept_callback():
+            self._cleanup_tp(True)
+            rc = self.entity.verify()
+            if rc:
+                return on_accept()
+            return rc
+
+        def cancel_callback():
+            self._cleanup_tp(False)
+
+        return UxDialog(w, title = title, accept_callback = accept_callback, cancel_callback = cancel_callback, ok = ok, min_width = min_width)
+
+    def dialog(self, layout: ux.Layout = None, copy_entity: bool = True, title: str = '', save: bool = False, accept_hook: Callable[[RC],None]  = None, min_width: int = 0) -> UxDialog:
+        if title is None:
+            title = ''
+        elif not title:
+            title = self.entity.__class__.__name__
+
+        ok = 'Save' if save else 'Ok'
+
+        def on_accept():
+            rc = self.entity.save() if save else RC_TRUE
+            if not rc:
+                self.warning(rc.error())
+            if accept_hook:
+                accept_hook(rc)
+            return rc
+
+        if copy_entity:
+            self.traitable_processor = INTERACTIVE()
+
+        return self._dialog(layout, title, ok, min_width, on_accept=on_accept)
+
+    def popup(self, layout: ux.Layout = None, copy_entity = True, title: str = '', save: bool = False, accept_hook: Callable[[RC],None] = None, min_width: int = 0) -> None:
+        self.dialog(layout = layout, copy_entity = copy_entity, title = title, save = save, accept_hook = accept_hook, min_width = min_width).exec()
+
+    def warning(self, msg: str, title: str = ''):
+        ux_warning(msg, parent = self.main_w, title = title, on_close=lambda ctx: None)

ui_10x/traitable_view.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import copy
+import inspect
+from typing import TYPE_CHECKING
+
+from core_10x.global_cache import cache
+from core_10x.trait import T
+from core_10x.traitable import Traitable
+from core_10x.ui_hint import Ui, UiMod
+
+if TYPE_CHECKING:
+    from core_10x.trait import Trait
+
+
+class TraitableView:
+    """
+    To create an instance of TraitableView you need to pass the following args:
+    1) entity_or_class: a subclass of Entity or an instance of it
+    2) _header_data: a dictionary with each item as follows:
+        either
+            <trait-name>:   <label>     (if label is empty, the trait's label will be used)
+        or
+            <group-label>:  <header>    (_header like dict)
+    3) named_traits_to_use: (kwargs) with each item as follows:
+            <trait-name>:   Ui(...)
+
+        Such named_traits specify either traits to use (slice) or the ones to modify (modify)
+    """
+
+    @classmethod
+    def _check(cls, hint_mod, trait_name: str) -> bool:
+        assert isinstance(hint_mod, UiMod), f'{trait_name} = {hint_mod} - UiMod is expected'
+        return True
+
+    @classmethod
+    def suitable_record(cls, trait: Trait = None, trait_dir: dict = None, trait_name: str = None, _skip_reserved: bool = True) -> Trait | None:
+        if not trait:
+            assert trait_dir and trait_name, 'trait is None, so both trait_dir and trait_name must be provided'
+            trait = trait_dir.get(trait_name)
+            if not trait:
+                return None
+
+        flags = T.HIDDEN | T.RESERVED if _skip_reserved else T.HIDDEN
+        return None if trait.flags_on(flags) or trait.getter_params or trait.s_ui_hint.widget_type == Ui.WIDGET_TYPE.NONE else trait
+
+    @classmethod
+    def slice(cls, traitable_class, _header_data: dict = None, **named_ui_hint_changes) -> TraitableView:
+        assert inspect.isclass(traitable_class) and issubclass(traitable_class, Traitable), f'{traitable_class} is not a Traitable'
+
+        trait_dir = traitable_class.s_dir
+        trait: Trait
+        ui_hints = {
+            name: hint_change.apply(trait.ui_hint) if cls._check(hint_change, trait.name) else None
+            for name, hint_change in named_ui_hint_changes.items()
+            if (trait := cls.suitable_record(trait_dir=trait_dir, trait_name=name))
+        }
+        return TraitableView(traitable_class, ui_hints, _header_data)
+
+    @classmethod
+    def modify(
+        cls, traitable_class: type[Traitable], _header_data: dict = None, _skip_reserved: bool = True, **named_ui_hint_changes
+    ) -> TraitableView:
+        assert inspect.isclass(traitable_class) and issubclass(traitable_class, Traitable), f'{traitable_class} is not a Traitable'
+
+        ui_hints = {
+            trait_name: trait.ui_hint
+            for trait_name, trait in traitable_class.s_dir.items()
+            if TraitableView.suitable_record(trait=trait, _skip_reserved=_skip_reserved)
+        }
+
+        for name, hint_change in named_ui_hint_changes.items():
+            cls._check(hint_change, name)
+            hint = ui_hints.get(name)
+            if hint is not None:
+                ui_hints[name] = hint_change.apply(hint)
+
+        return TraitableView(traitable_class, ui_hints, _header_data)
+
+    @staticmethod
+    @cache
+    def default(traitable_class: type[Traitable], read_only: bool = False) -> TraitableView:
+        return TraitableView.modify(traitable_class).make_read_only(read_only, clone=True)
+
+    def make_read_only(self, flag: bool, clone=False) -> TraitableView:
+        view = self if not clone else copy.deepcopy(self)
+
+        to_set = Ui.READ_ONLY if flag else 0x0
+        to_reset = 0x0 if flag else Ui.READ_ONLY
+        for ui_hint in view.ui_hints.values():
+            ui_hint.set_reset_flags(to_set, to_reset)
+        return view
+
+    def __init__(self, traitable_class, ui_hints: dict, header_data: dict):
+        self.cls = traitable_class
+        self.ui_hints = ui_hints
+        self.header = self.create_header(ui_hints, header_data)
+
+    def all_hints(self) -> dict:
+        return self.ui_hints
+
+    def ui_hint(self, trait_name: str) -> Ui:
+        return self.ui_hints[trait_name]
+
+    @staticmethod
+    def _process_tree(ui_hints: dict, tree: dict) -> dict:
+        header = {}
+        for subtree_name, subtree in tree.items():
+            if isinstance(subtree, str):  # -- must be a trait name
+                label = subtree
+                hint = ui_hints.get(subtree_name)
+                if not hint:  # -- ignore an unknown or unused trait
+                    continue
+                if not label:  # -- no label overwrite
+                    label = hint.label
+                header[subtree_name] = label
+
+            elif isinstance(subtree, dict):  # -- must be a real subtree
+                header[subtree_name] = TraitableView._process_tree(ui_hints, subtree)
+
+            else:
+                continue  # -- ignore anything else
+
+        return header
+
+    @staticmethod
+    def create_header(ui_hints: dict, header_data: dict) -> dict:
+        if not header_data:
+            return {trait_name: ui.label for trait_name, ui in ui_hints.items()}
+
+        return TraitableView._process_tree(ui_hints, header_data)

ui_10x/unit_tests/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()

ui_10x/unit_tests/test_platform.py

@@ -0,0 +1,9 @@
+import sys
+
+import pytest
+
+
+def test_platform_import_raises(monkeypatch):
+    monkeypatch.delitem(sys.modules, 'ui_10x.platform', raising=False)
+    with pytest.raises(ImportError):  # raises due to incorrect UI_PLATFORM from conftest
+        import ui_10x.platform