py10x-universe 0.1.3__py3-none-any.whl

ui_10x/py_data_browser.py

@@ -0,0 +1,249 @@
+from datetime import date, datetime
+
+from core_10x.rc import RC, RC_TRUE
+from core_10x.xnone import XNone
+
+from ui_10x.utils import UxDialog, ux
+
+
+class PyDataBrowser:
+    class Item(ux.TreeItem):
+        def __init__(self, parent_node, key, value):
+            super().__init__(parent_node)
+            self.key = key
+            self.value = value
+            self.new_value = value
+
+        def path(self) -> list:
+            res = []
+            node = self
+            while node:
+                res.insert(0, node.key)
+                node = node.parent()
+
+            return res
+
+        def accept_edit(self, results):
+            n = self.child_count()
+            if not n:
+                if self.value != self.new_value:
+                    path = self.path()
+                    x = results
+                    for key in path[:-1]:
+                        x = x[key]
+                    x[path[-1]] = self.new_value
+            else:
+                for i in range(n):
+                    child = self.child(i)
+                    child.accept_edit(results)
+
+    def __init__(
+            self,
+            data,
+            on_select = None,
+            edit = False,
+            custom_editor = None,
+            max_label_len = 50,
+            max_value_len = 70
+    ):
+        """
+        Browse any python data.
+        :param data:
+        :param on_select: a callable on item selection. If given, will call on_select( the_browser, path_to_item: list, item_value )
+        :param edit: allow editing if True
+        :param custom_editor: if given, is used for editing - fn( the_browser, item: PyDataBrowser: Item )
+        :param max_label_len: max label width (if exceeds, gets truncated showing '...' and the end)
+        :param max_value_len: max value width (if exceeds, gets truncated showing '...' and the end)
+        Tooltip (full label/value, if possible) is shown as usual
+        """
+        self.data = data
+        self.edit = edit
+        self.custom_editor = custom_editor
+        self.select_cb = on_select
+        self.max_label_len = max_label_len
+        self.max_value_len = max_value_len
+
+    def fill(self, value, node: ux.TreeItem, label = True):
+        if label:
+            i = 0
+            n = self.max_label_len
+            tip = True
+        else:
+            i = 1
+            n = self.max_value_len
+            tip = isinstance(value, str)
+        text = str(value)
+        if len(text) > n:
+            show = text[: n] + '...'
+        else:
+            show = text
+        node.set_text(i, show)
+        if tip:
+            node.set_tool_tip(i, text)
+
+    s_bool_vmap = {
+        'True':     True,
+        'False':    False,
+        '1':        True,
+        '0':        False
+    }
+
+    s_use_as_is = {
+        type:           None,
+        type(None):     None,
+        type(XNone):    None,
+        bool:           lambda x:   PyDataBrowser.s_bool_vmap.get(x, bool(x)),
+        str:            lambda x:   x,
+        int:            lambda x:   int(x),
+        float:          lambda x:   float(x),
+        datetime:       lambda x:   datetime.strptime(x, '%Y-%m-%d %H:%M:%S'),
+        date:           lambda x:   datetime.strptime(x, '%Y-%m-%d').date(),
+    }
+
+    s_dict_handler  = lambda data: data.items()
+    s_list_handler  = lambda data: enumerate(data)
+    s_type_handlers = {
+        tuple:      s_list_handler,
+        list:       s_list_handler,
+        dict:       s_dict_handler,
+    }
+    def create_tree(self, key, item, parent_node):
+        node = self.Item(parent_node, key, item)
+        self.fill(key, node, label = True)
+        self.fill(item, node, label = False)
+
+        dtype = type(item)
+        if dtype in self.s_use_as_is:
+            pass
+        else:
+            handler = self.s_type_handlers.get(dtype)
+            if not handler:
+                try:
+                    text = item.__repr__()
+                    node.set_text(1, text)
+                except Exception:
+                    node.set_text(1, '???')
+                    return
+
+                try:
+                    item = item.to_dict()
+                    handler = self.__class__.s_dict_handler
+                except Exception:
+                    return
+
+            for key, value in handler(item):
+                self.create_tree(key, value, node)
+
+    def widget(self) -> ux.TreeWidget:
+        self.tree = tree = ux.TreeWidget()
+        tree.set_column_count(2)
+        tree.set_header_labels(['Key', 'Value'])
+
+        data = self.data
+        dtype = type(data)
+        handler = self.s_type_handlers.get(dtype)
+        if not handler:
+            data = { str(dtype): data }
+            handler = self.s_dict_handler
+
+        for key, item in handler(data):
+            self.create_tree(key, item, tree)
+
+        if len(data) == 1:
+            tree.top_level_item(0).set_expanded(True)
+
+        tree.resize_column_to_contents(0)
+        tree.resize_column_to_contents(1)
+
+        tree.item_expanded_connect(lambda item: tree.resize_column_to_contents(0))
+        tree.item_pressed_connect(self.on_item_pressed)
+        tree.item_changed_connect(self.on_item_changed)
+
+        return tree
+
+    def on_item_pressed(self, item: Item, col: int):
+        if item:
+            if col == 0 or not self.edit:
+                if self.select_cb:
+                    self.select_cb(self, item.path(), item.value)
+                return
+
+            if self.custom_editor:
+                self.custom_editor(self, item)
+            else:
+                if not item.child_count():
+                    self.generic_editor(item)
+
+    def on_item_changed(self, item: Item, col: int):
+        if col != 1:
+            return
+
+        dtype = type(item.value)
+        from_str_handler = self.s_use_as_is.get(dtype)
+        if from_str_handler:
+            text = item.text(col)
+            try:
+                item.new_value = from_str_handler(text)
+            except Exception:
+                pass
+
+    def generic_editor(self, item: Item):
+        self.tree.open_persistent_editor(item, 1)
+        self.tree.edit_item(item, 1)
+
+    def accept_edit(self) -> RC:
+        for i in range(self.tree.top_level_item_count()):
+            item = self.tree.top_level_item(i)
+            item.accept_edit(self.data)
+        return RC_TRUE
+
+    @classmethod
+    def show(cls, data, on_select = None, title = '', w = 1000, h = 800):
+        if not title:
+            title = 'Python Data Browser'
+
+        br = cls(data, on_select = on_select)
+        d = UxDialog(
+            br.widget(),
+            title       = title,
+            ok          = '',
+            cancel      = 'Close',
+            min_width   = w,
+            min_height  = h
+        )
+        d.exec()
+
+    @classmethod
+    def edit(cls, data, on_select = None, custom_editor = None, title = '', w = 1000, h = 800) -> bool:
+        if not title:
+            title = 'Python Data Editor'
+
+        br = cls(data, on_select = on_select, edit = True, custom_editor = custom_editor)
+        d = UxDialog(
+            br.widget(),
+            accept_callback = br.accept_edit,
+            title           = title,
+            min_width       = w,
+            min_height      = h
+        )
+        rc = d.exec()
+        return bool(rc)
+
+    @classmethod
+    def path_to_str(cls, path: list, delims = ('/', '/')) -> str:
+        res = []
+        for i, key in enumerate(path):
+            delim = delims[ isinstance(key, int) ]
+            n = len(delim)
+            if n == 0:
+                continue
+
+            if n == 1:
+                key = f'{delim}{key}' if i > 0 else str(key)
+            else:
+                key = f'{delim[0]}{key}{delim[1]}'
+
+            res.append(key)
+
+        return ''.join(res)
+

ui_10x/qt6/conftest.py

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

ui_10x/qt6/manual_tests/basic_test.py

@@ -0,0 +1,35 @@
+# from PyQt6.QtWidgets import QWidget, QLayout, QBoxLayout, QVBoxLayout, QHBoxLayout, QFormLayout, QApplication
+# from PyQt6.QtWidgets import QLabel, QCalendarWidget, QMessageBox, QGroupBox, QButtonGroup, QRadioButton
+# from PyQt6.QtWidgets import QListWidgetItem, QListWidget, QLineEdit, QPlainTextEdit, QTreeWidgetItem, QTreeWidget, QCheckBox, QComboBox
+# from PyQt6.QtWidgets import QFrame, QSplitter, QDialog, QScrollArea, QPushButton, QStyle, QSizePolicy
+# from PyQt6.QtCore import Qt, QObject, QThread, pyqtSignal, QBuffer, QIODevice, QPoint    #, QByteArray
+# from PyQt6.QtGui import QColor, QGuiApplication, QPixmap, QMouseEvent
+#
+# import platform
+#
+#
+# Object = QObject
+#
+# signal_decl = pyqtSignal
+#
+# class MouseEvent(QMouseEvent):
+#     def is_left_button(self) -> bool:   return self.button() == Qt.MouseButton.LeftButton
+#     def is_right_button(self) -> bool:  return self.button() == Qt.MouseButton.RightButton
+
+from ui_10x.platform import ux
+
+if __name__ == '__main__':
+    app = ux.init()
+
+    w = ux.Label('a')
+    w = ux.PushButton('b')
+    w = ux.LineEdit()
+    w = ux.RadioButton()
+    w = ux.CheckBox('Check')
+    w = ux.ListWidget()
+    w = ux.TreeWidget()
+
+
+
+
+

ui_10x/qt6/platform_implementation.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+from typing import Callable, Any
+
+from PyQt6.QtWidgets import QWidget, QLayout, QBoxLayout, QVBoxLayout, QHBoxLayout, QFormLayout, QApplication
+from PyQt6.QtWidgets import QLabel, QCalendarWidget, QMessageBox, QGroupBox, QButtonGroup, QRadioButton
+from PyQt6.QtWidgets import QListWidgetItem, QListWidget, QLineEdit, QPlainTextEdit, QTreeWidgetItem, QTreeWidget, QCheckBox, QComboBox
+from PyQt6.QtWidgets import QFrame, QSplitter, QDialog, QScrollArea, QPushButton, QStyle, QSizePolicy, QStyleOptionHeader
+from PyQt6.QtCore import Qt, QObject, QThread, pyqtSignal, QBuffer, QIODevice, QPoint    #, QByteArray
+from PyQt6.QtGui import QColor, QGuiApplication, QPixmap, QMouseEvent, QFontMetrics, QPalette, QPainter
+
+import platform
+
+from core_10x.global_cache import cache
+
+def missing_attr(self, item):
+    t = item.title()
+    item = t[0].lower() + t[1:].replace('_', '')
+    return QObject.__getattribute__(self, item)
+
+Object = QObject
+
+QueuedConnection                = Qt.ConnectionType.QueuedConnection
+AutoConnection                  = Qt.ConnectionType.AutoConnection
+DirectConnection                = Qt.ConnectionType.DirectConnection
+UniqueConnection                = Qt.ConnectionType.UniqueConnection
+BlockingQueuedConnection        = Qt.ConnectionType.BlockingQueuedConnection
+
+signal_decl = pyqtSignal
+
+MouseEvent                      = QMouseEvent
+MouseEvent.is_left_button       = lambda self: self.button() == Qt.MouseButton.LeftButton
+MouseEvent.is_right_button      = lambda self: self.button() == Qt.MouseButton.RightButton
+
+Point                           = QPoint
+
+SizePolicy                      = QSizePolicy
+SizePolicy.MINIMUM_EXPANDING    = QSizePolicy.Policy.MinimumExpanding
+SizePolicy.PREFERRED            = QSizePolicy.Policy.Preferred
+
+Color                           = QColor
+
+FontMetrics                     = QFontMetrics
+FontMetrics.__getattr__         = missing_attr
+
+Widget                          = QWidget
+Widget.__getattr__              = missing_attr
+
+Horizontal                      = Qt.Orientation.Horizontal
+Vertical                        = Qt.Orientation.Vertical
+
+Layout                          = QLayout
+
+BoxLayout                       = QBoxLayout
+BoxLayout.__getattr__           = missing_attr
+
+HBoxLayout                      = QHBoxLayout
+VBoxLayout                      = QVBoxLayout
+
+FormLayout                      = QFormLayout
+FormLayout.__getattr__          = missing_attr
+
+Label                           = QLabel
+Label.set_text                  = QLabel.setText
+
+Splitter                        = QSplitter
+
+Style                           = QStyle
+Style.State_Active              = QStyle.StateFlag.State_Active
+
+Style.__getattr__               = missing_attr
+
+PushButton                      = QPushButton
+PushButton.clicked_connect      = lambda self, bound_method:    self.clicked.connect(bound_method)
+
+LineEdit                        = QLineEdit
+LineEdit.text_edited_connect    = lambda self, bound_method:    self.textEdited.connect(bound_method)
+LineEdit.editing_finished_connect = lambda self, bound_method:  self.editingFinished.connect(bound_method)
+LineEdit.set_password_mode      = lambda self:                  self.setEchoMode(QLineEdit.EchoMode.Password)
+
+TextEdit                        = QPlainTextEdit
+
+CheckBox                        = QCheckBox
+CheckBox.state_changed_connect  = lambda self, bound_method:    self.stateChanged.connect(bound_method)
+
+ComboBox                        = QComboBox
+
+GroupBox                        = QGroupBox
+
+RadioButton                     = QRadioButton
+
+ButtonGroup                     = QButtonGroup
+ButtonGroup.__getattr__         = missing_attr
+
+ListItem                        = QListWidgetItem
+ListItem.__getattr__            = missing_attr
+
+MatchExactly                    = Qt.MatchFlag.MatchExactly
+
+ListWidget                      = QListWidget
+ListWidget.clicked_connect      = lambda self, bound_method:    self.clicked.connect(bound_method)
+
+TreeItem                        = QTreeWidgetItem
+TreeItem.__getattr__            = missing_attr
+
+TreeWidget                      = QTreeWidget
+TreeWidget.item_clicked_connect = lambda self, bound_method:    self.itemClicked.connect(bound_method)
+TreeWidget.item_expanded_connect = lambda self, bound_method:   self.itemExpanded.connect(bound_method)
+TreeWidget.item_pressed_connect = lambda self, bound_method:    self.itemPressed.connect(bound_method)
+TreeWidget.item_changed_connect = lambda self, bound_method:    self.itemChanged.connect(bound_method)
+
+CalendarWidget                  = QCalendarWidget
+CalendarWidget.selected_date    = lambda self:                  self.selectedDate().toPyDate()
+
+class Dialog(QDialog):
+    s_open_dialogs = set()
+    def __init__(self,parent=None,*args,**kwargs):
+        super().__init__(parent or init().activeModalWidget(),*args,**kwargs)
+
+    def _on_finished(self):
+        open_dialogs = self.s_open_dialogs
+        in_open_dialogs = self in open_dialogs
+        print(f'finishing {self}: {in_open_dialogs}')
+
+        if in_open_dialogs:
+            self.s_open_dialogs.remove(self)
+
+    def show(self):
+        print(f'showing {self}')
+        self.s_open_dialogs.add(self)
+        self.finished.connect(self._on_finished)
+        super().show()
+        self.raise_()
+        self.activateWindow()
+        self.s_open_dialogs.add(self)
+
+
+class MessageBox(QMessageBox):
+    s_boxes_by_parent = {}
+    def __init__(self, on_close: Callable[[Any],None] = None, parent: Widget = None):
+        super().__init__(parent)
+        self._on_close = on_close
+        self.finished.connect(self._handle_finished)
+
+        # Set the default values for the message box
+        self.setWindowFlags(Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint|Qt.WindowType.WindowStaysOnTopHint)
+        self.setStandardButtons(QMessageBox.StandardButton.Ok)
+        self.setDefaultButton(QMessageBox.StandardButton.Ok)
+        self.setEscapeButton(QMessageBox.StandardButton.Ok)
+
+        self.setModal(True)
+        self.s_boxes_by_parent[self.parent()] = self
+
+    def _handle_finished(self, result):
+        if self._on_close:
+            self._on_close(result)
+        self.s_boxes_by_parent.pop(self.parent())
+        self.deleteLater()
+
+    @classmethod
+    def _create_message_box(cls, parent: Widget, title, message, on_close: Callable[[Any],None], icon) -> MessageBox:
+        msg_box = cls(on_close,parent)
+        msg_box.setWindowTitle(title)
+        msg_box.setText(message)
+        msg_box.setIcon(icon)
+        return msg_box
+
+    @classmethod
+    def question(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any],None]) -> MessageBox.StandardButton:
+        msg_box = cls._create_message_box(
+            parent=parent,
+            title=title,
+            message=message,
+            on_close=on_close,
+            icon=QMessageBox.Icon.Question,
+        )
+
+        msg_box.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        msg_box.setDefaultButton(QMessageBox.StandardButton.No)
+        msg_box.setEscapeButton(QMessageBox.StandardButton.No)
+
+        if on_close:
+            msg_box.show()
+        else:
+            return msg_box.exec()
+
+    @classmethod
+    def warning(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any],None]) -> MessageBox.StandardButton:
+        msg_box = cls._create_message_box(
+                parent=parent,
+                title=title,
+                message=message,
+                on_close=on_close,
+                icon=QMessageBox.Icon.Warning,
+          )
+
+        if on_close:
+            msg_box.show()
+        else:
+            return msg_box.exec()
+
+    @classmethod
+    def information(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any],None]) -> MessageBox.StandardButton:
+        msg_box = cls._create_message_box(
+                parent=parent,
+                title=title,
+                message=message,
+                on_close=on_close,
+                icon=QMessageBox.Icon.Information,
+          )
+
+        if on_close:
+            msg_box.show()
+        else:
+            return msg_box.exec()
+
+    @classmethod
+    def is_yes_button(cls, sb: QMessageBox.StandardButton) -> bool:
+        return sb == QMessageBox.StandardButton.Yes
+
+
+Application                     = QApplication
+
+class TEXT_ALIGN:
+    TOP       = Qt.AlignmentFlag.AlignTop
+    V_CENTER  = Qt.AlignmentFlag.AlignVCenter
+    BOTTOM    = Qt.AlignmentFlag.AlignBottom
+    LEFT      = Qt.AlignmentFlag.AlignLeft
+    CENTER    = Qt.AlignmentFlag.AlignCenter
+    RIGHT     = Qt.AlignmentFlag.AlignRight
+
+class SCROLL:
+    OFF         = Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+    ON          = Qt.ScrollBarPolicy.ScrollBarAlwaysOn
+    AS_NEEDED   = Qt.ScrollBarPolicy.ScrollBarAsNeeded
+
+ScrollArea                      = QScrollArea
+
+ForegroundRole                  = Qt.ItemDataRole.ForegroundRole
+BackroundRole                   = Qt.ItemDataRole.BackgroundRole
+
+Palette                         = QPalette
+Palette.ButtonText              = QPalette.ColorRole.ButtonText
+Palette.Button                  = QPalette.ColorRole.Button
+Palette.Window                  = QPalette.ColorRole.Window
+
+StyleOptionHeader               = QStyleOptionHeader
+Separator                       = QLabel
+
+@cache
+def init(style = '') -> QApplication:
+    if not style:
+        style = platform.system()
+
+    app = QApplication([])
+    app.setStyle(style)
+    return app
+
+def to_clipboard(text: str, **kwargs):
+    cp = QGuiApplication.clipboard()
+    cp.setText(text)
+
+def from_clipboard(**kwargs) -> str:
+    cp = QGuiApplication.clipboard()
+    return cp.text()
+
+def separator(horizontal = True) -> Separator:
+    direction = QFrame.Shape.HLine if horizontal else QFrame.Shape.VLine
+    sep = QLabel()
+    sep.setFrameStyle(direction | QFrame.Shadow.Sunken)
+    return sep
+
+def is_ui_thread() -> bool:
+    return QThread.currentThread() is QGuiApplication.instance().thread()
+
+