py10x-universe 0.1.3__py3-none-any.whl

ui_10x/table_header_view.py

@@ -0,0 +1,305 @@
+from PyQt5.QtCore import QModelIndex, QPointF, QRect, QSize, Qt, QVariant
+from PyQt5.QtGui import QFont, QFontMetrics, QPainter, QPaintEvent
+from PyQt5.QtWidgets import QStyle, QStyleOptionHeader
+
+from ui_10x.platform import ux
+from ui_10x.traitable_view import TraitableView
+
+
+# ruff: noqa: N802 # Function name should be lowercase
+class HeaderModel(ux.StandardItemModel):
+    def _create_subtree(self, traits: dict, root: ux.StandardItem, tree: dict):
+        col = 0
+        for subtree_name, subtree in tree.items():
+            if isinstance(subtree, str):
+                trait = traits.get(subtree_name)
+                if not trait:
+                    continue
+                label = subtree
+                subtree = None
+            elif isinstance(subtree, dict):
+                label = subtree_name
+            else:
+                continue
+
+            item = ux.StandardItem(label)
+            if subtree:
+                self._create_subtree(traits, item, subtree)
+
+            if root:
+                root.append_column((item, ))
+            else:
+                self.set_item(0, col, item)
+
+            col += 1
+
+    def __init__(self, traits: dict, header_structure: dict):
+        super().__init__()
+        self.traits = traits
+        self.create(header_structure)
+
+    def create(self, header_structure: dict):
+        self._create_subtree(self.traits, None, header_structure)
+
+    def leaf_index(self, section_index: int) -> ux.ModelIndex:
+        current_leaf_index = -1
+        for i in range(self.column_count()):
+            res, current_leaf_index = self.find_leaf(self.index( 0, i), section_index, current_leaf_index)
+            if res.is_valid():
+                return res
+
+        return ux.ModelIndex()
+
+    @staticmethod
+    def leftmost_leaf(index: ux.ModelIndex) -> ux.ModelIndex:
+        prev_index = index
+        while index.is_valid():
+            prev_index = index
+            index = index.child(0, 0)
+        return prev_index
+
+    @staticmethod
+    def find_leaf(current_index: ux.ModelIndex, section_index: int, current_leaf_index: int) -> tuple:  #-- ( index, current_leaf_index )
+        if current_index.is_valid():
+            child_count = current_index.model().column_count(current_index)
+            if child_count:
+                for i in range(child_count):
+                    res, current_leaf_index = HeaderModel.find_leaf(current_index.child(0, i), section_index, current_leaf_index)
+                    if res.is_valid():
+                        return (res, current_leaf_index)
+            else:
+                current_leaf_index += 1
+                if current_leaf_index == section_index:
+                    return (current_index, current_leaf_index)
+
+        return (ux.ModelIndex(), current_leaf_index)
+
+    @staticmethod
+    def search_leaves(current_index: ux.ModelIndex) -> list:
+        res = []
+        if current_index.is_valid():
+            if not current_index.child(0, 0).is_valid():
+                res.append(current_index)
+            else:
+                c = 0
+                child = current_index.child(0, c)
+                while child.is_valid():
+                    found = HeaderModel.search_leaves(child)
+                    res.extend(found)
+                    c += 1
+                    child = current_index.child(0, c)
+
+        return res
+
+    @staticmethod
+    def leaves(search_index: ux.ModelIndex ) -> list:
+        leaves = []
+        if search_index.is_valid():
+            child_count = search_index.model().column_count(search_index)
+            for i in range(child_count):
+                found = HeaderModel.search_leaves(search_index.child(0, i))
+                leaves.extend(found)
+
+        return leaves
+
+    @staticmethod
+    def find_root_index(index: ux.ModelIndex) -> ux.ModelIndex:
+        while index.parent().is_valid():
+            index = index.parent()
+        return index
+
+    @staticmethod
+    def parent_indexes(index: ux.ModelIndex) -> list:
+        indexes = []
+        while index.is_valid():
+            indexes.insert(0, index)
+            index = index.parent()
+        return indexes
+
+
+class HeaderView(ux.HeaderView):
+    def __init__(self, view: TraitableView, parent: ux.Widget = None):
+        super().__init__(ux.Horizontal, parent = parent)
+        self.model = HeaderModel(view.ui_hints, view.header)
+        self.set_model(self.model)
+
+        self.painted_cells = set()
+        self.section_resized_connect(self.on_section_resized)
+
+    def set_foreground_brush(self, opt: ux.StyleOptionHeader, index: ux.ModelIndex ):
+        fgb = index.data(ux.ForegroundRole)
+        if fgb:
+            opt.palette.set_brush(ux.Palette.ButtonText, fgb)
+
+    def set_background_brush(self, opt: ux.StyleOptionHeader, index: ux.ModelIndex ):
+        bgb = index.data(ux.BackgroundRole)
+        if bgb:
+            opt.palette.set_brush(ux.Palette.Button, bgb)
+            opt.palette.set_brush(ux.Palette.Window, bgb)
+
+
+    # s_selected_position = (
+    #     ux.StyleOptionHeader.NotAdjacent,                     # prev - 0, next 0
+    #     ux.StyleOptionHeader.NextIsSelected,                  # prev - 0, next 1
+    #     ux.StyleOptionHeader.PreviousIsSelected,              # prev - 1, next 0
+    #     ux.StyleOptionHeader.NextAndPreviousAreSelected       # prev - 1, next 1
+    # )
+    def style_option_for_cell(self, logical_index: int) -> ux.StyleOptionHeader:
+        opt = ux.StyleOptionHeader()
+        # self.init_style_option(opt)
+        # if self.window().is_active_window():
+        #     opt.state |= ux.Style.State_Active
+        # opt.text_alignment = ux.AlignCenter
+        # opt.icon_alignment = ux.AlignVCenter
+        # opt.section = logical_index
+        #
+        # visual = self.visual_index(logical_index)
+        #
+        # if self.count() == 1:
+        #     opt.position = ux.StyleOptionHeader.OnlyOneSection
+        # else:
+        #     if visual == 0:
+        #         opt.position = QStyleOptionHeader.Beginning
+        #     else:
+        #         opt.position = QStyleOptionHeader.End if visual == ( self.count() - 1 ) else QStyleOptionHeader.Middle
+        #
+        # if self.sectionsClickable():
+        #     if self.highlightSections() and self.selectionMode():
+        #         if self.selectionModel().columnIntersectsSelection( logical_index, self.rootIndex() ):
+        #             opt.state |= QStyle.State_On
+        #         if self.selectionModel().isColumnSelected( logical_index, self.rootIndex() ):
+        #             opt.state |= QStyle.State_Sunken
+        #
+        # if self.selectionModel():
+        #     prev_selected = self.selectionModel().isColumnSelected( self.logicalIndex( visual - 1 ), self.rootIndex() )
+        #     next_selected = self.selectionModel().isColumnSelected( self.logicalIndex( visual + 1 ), self.rootIndex() )
+        #     code = 2 * prev_selected + next_selected
+        #     opt.selectedPosition = self.s_selectedPosition[ code ]
+
+        return opt
+
+    def cell_size(self, leaf_index: ux.ModelIndex, style_options: ux.StyleOptionHeader) -> ux.Size:
+        res = ux.Size()
+        variant = QVariant(leaf_index.data(Qt.SizeHintRole))
+        if variant.isValid():
+            res = variant   # TODO: cast?
+        fnt = QFont(self.font())
+        var = QVariant(leaf_index.data(Qt.FontRole))
+        if var.isValid():
+            fnt = var
+        fnt.setBold(True)
+        fm = QFontMetrics(fnt)
+        size = QSize(fm.size(0, leaf_index.data(Qt.DisplayRole)))
+        if leaf_index.data(Qt.UserRole):      # isValid()
+            size.transpose()
+        decoration_size = self.style().sizeFromContents(QStyle.CT_HeaderSection, style_options, QSize(), self)
+        empty_text_size = QSize(fm.size( 0, '' ))
+        return res.expandedTo(size + decoration_size - empty_text_size)
+
+    def current_cell_width(self, searched_index: QModelIndex, leaf_index: QModelIndex, section_index: int) -> int:
+        leaves = HeaderModel.leaves(searched_index)
+        if not leaves:
+            return self.section_size(section_index)
+
+        first_leaf_section_index = section_index - leaves.index(leaf_index)
+        return sum(self.section_size(first_leaf_section_index + i) for i in range(len(leaves)))
+
+    def current_cell_left(self, searched_index: QModelIndex, leaf_index: QModelIndex, section_index: int, left: int) -> int:
+        leaves = HeaderModel.leaves(searched_index)
+        if leaves:
+            n = leaves.index(leaf_index)
+            first_leaf_section_index = section_index - n
+            n -= 1
+            left -= sum(self.section_size(first_leaf_section_index + i) for i in range(n))
+        return left
+
+    def paint_horizontal_cell(self, painter: QPainter, cell_index: QModelIndex, leaf_index: QModelIndex, logical_index: int, style_options: QStyleOptionHeader, section_rect: QRect, top: int) -> int:
+        uniopt = QStyleOptionHeader(style_options)
+        self.set_foreground_brush(uniopt, cell_index)
+        self.set_background_brush(uniopt, cell_index)   # TODO!
+
+        height = self.cell_size(cell_index, uniopt).height()
+
+        if cell_index == leaf_index:
+            height = section_rect.height() - top
+
+        left    = self.current_cell_left(cell_index, leaf_index, logical_index, section_rect.left())
+        width   = self.current_cell_width(cell_index, leaf_index, logical_index)
+
+        if cell_index not in self.painted_cells:
+            self.painted_cells.add(cell_index)
+            r = QRect(left, top, width, height)
+
+            uniopt.text = cell_index.data(Qt.DisplayRole)
+            painter.save()
+            uniopt.rect = r
+            self.style().drawControl(QStyle.CE_Header, uniopt, painter, self)
+
+            painter.restore()
+
+        return top + height
+
+    def paintEvent(self, event: QPaintEvent):
+        self.painted_cells = set()
+        super().paintEvent(event)
+
+    def paintSection(self, painter: QPainter, rect: QRect, logical_index: int):
+        if rect.isValid():
+            leaf_index = self.model.leaf_index(logical_index)
+            if leaf_index.is_valid():
+                old_bo = QPointF(painter.brushOrigin())
+                top = rect.y()
+                indexes = HeaderModel.parent_indexes(leaf_index)
+                style_options = self.style_option_for_cell(logical_index)
+                for i in range(len(indexes)):
+                    real_style_options = QStyleOptionHeader(style_options)
+                    state = int(real_style_options.state)
+                    if i < (len(indexes) - 1) and (bool(state & QStyle.State_Sunken) or bool(state & QStyle.State_On)):
+                        real_style_options.state &= ~(QStyle.State_Sunken | QStyle.State_On)
+
+                    cell = indexes[i]
+                    top = self.paint_horizontal_cell(painter, cell, leaf_index, logical_index, real_style_options, rect, top)
+
+                painter.setBrushOrigin(old_bo)
+                return
+
+        super().paintSection(painter, rect, logical_index)
+
+    def sectionSizeFromContents(self, logical_index: int ) -> QSize:
+        cur_leaf_index = QModelIndex(self.model.leaf_index(logical_index))
+        if not cur_leaf_index.is_valid():
+            return super().sectionSizeFromContents(logical_index)
+
+        style_option = QStyleOptionHeader(self.style_option_for_cell(logical_index ))
+        s = QSize(self.cell_size(cur_leaf_index, style_option))
+        cur_leaf_index = cur_leaf_index.parent()
+        while cur_leaf_index.is_valid():
+            s.setHeight(s.height() + self.cell_size(cur_leaf_index, style_option).height())
+            cur_leaf_index = cur_leaf_index.parent()
+
+        return s
+
+    def on_section_resized(self, logical_index: int, i2, i3 ):
+        if self.is_section_hidden(logical_index):
+            return
+
+        leaf_index = QModelIndex(self.model.leaf_index(logical_index))
+        if leaf_index.is_valid():
+            root_index = HeaderModel.find_root_index(leaf_index)
+            leaves = HeaderModel.leaves(root_index)
+            try:
+                n = leaves.index(leaf_index)
+                while n > 0:
+                    logical_index -= 1
+
+                    w = self.viewport().width()
+                    h = self.viewport().height()
+                    pos = self.sectionViewportPosition(logical_index)
+                    r = QRect(pos, 0, w - pos, h)
+                    if self.isRightToLeft():
+                        r.setRect(0, 0, pos + self.sectionSize(logical_index), h)
+
+                    self.viewport().update( r.normalized() )
+                    n -= 1
+            except Exception:
+                pass

ui_10x/table_view.py

@@ -0,0 +1,174 @@
+import inspect
+
+from core_10x.traitable import Trait, Traitable
+from PyQt5.QtCore import QAbstractTableModel, QModelIndex, Qt, QVariant
+from PyQt5.QtWidgets import QAbstractScrollArea, QTableView
+
+from ui_10x.table_header_view import HeaderModel, HeaderView
+from ui_10x.traitable_editor import TraitableEditor
+from ui_10x.traitable_view import TraitableView
+from ui_10x.utils import UxStyleSheet, ux_text_alignment
+
+
+# ruff: noqa: N802 # Function name should be lowercase
+class Model(QAbstractTableModel):
+    def __init__(self, model: HeaderModel, data, parent = None):
+        super().__init__(parent = parent)
+        self.model = model
+        self.data = data
+        self.col2name = { i: name for i, name in enumerate( model.traits ) }
+        self.name2col = { name: i for i, name in self.col2name.items() }
+
+    def trait_name(self, col: int) -> str:
+        return self.col2name.get(col)
+
+    def rowCount(self, parent = None, *args, **kwargs):
+        return len(self.data)
+
+    def columnCount( self, parent = None, *args, **kwargs ):
+        if not self.data:
+            return 0
+        return len(self.col2name)
+
+    def data(self, index: QModelIndex, role: int = None):
+        if role == Qt.UserRole:
+            return self.model
+
+        entity: Traitable = self.data[index.row()]
+        trait_name = self.col2name.get(index.column())
+
+        cls = entity.__class__
+        trait: Trait = cls.trait(trait_name)
+        if role == Qt.DisplayRole and index.isValid():
+            if trait:
+                value = entity.get_value(trait)
+                text = trait.to_str(value)
+            else:
+                text = ''
+            return text
+
+        if role == Qt.ForegroundRole:
+            sh = entity.get_style_sheet(trait)
+            return UxStyleSheet.fg_color(sh)
+
+        if role == Qt.BackgroundRole:
+            sh = entity.get_style_sheet(trait)
+            return UxStyleSheet.bg_color(sh)
+
+        if role == Qt.TextAlignmentRole:
+            return ux_text_alignment(trait.ui_hint.param('align_h', 0), horizontal = True)
+
+        return QVariant()
+
+    def set_data(self, i: QModelIndex, dummy, role = None) -> bool:
+        self.dataChanged.emit(i, i)
+        return True
+
+    def change_data(self, row: int, trait_name: str):
+        col = self.name2col.get(trait_name)
+        i = QModelIndex(row, col)
+        self.set_data(i, None, role = None)
+
+    def insertRows(self, row: int, num_rows: int, parent = None, *args, **kwargs) -> bool:
+        #self.beginInsertRows( QModelIndex(), row, row + num_rows )
+        return True
+
+    def extendData(self, data) -> bool:
+        """
+        :param data: an iterable of entities
+        :return: True if model reset happened as well
+        """
+        if data:
+            the_data = self.data
+            is_empty = not bool(the_data)
+            if is_empty:
+                self.beginResetModel()
+
+            first = len(the_data)
+            last = first + len(data) - 1
+            self.beginInsertRows(QModelIndex(), first, last)
+            the_data.extend(data)
+            self.insertRows(first, len( data))
+            self.endInsertRows()
+
+            if is_empty:
+                self.endResetModel()
+            return is_empty
+
+    def entity(self, row: int) -> Traitable:
+        return self.data[row]
+
+class TableView(QTableView):
+    def __init__(self, entities_or_class, view: TraitableView = None):
+        assert entities_or_class, 'first arg must not be empty'
+
+        if inspect.isclass(entities_or_class):
+            assert issubclass(entities_or_class, Traitable), 'first arg is a class, but not a subclass of Traitable'
+            proto = entities_or_class
+            entities = []
+        else:
+            entities = entities_or_class
+            proto = entities[0]
+
+        if not view:
+            view = TraitableView.default(proto)
+
+        super().__init__()
+        self.wheel_enabled = True
+
+        hv = HeaderView(view, parent = self)
+        hv.setStretchLastSection(True)
+
+        self.setHorizontalHeader(hv)
+        model = Model(hv.model(), entities, self)
+        self.setModel(model)
+
+        self.setAlternatingRowColors(True)
+        self.resizeColumnsToContents()
+
+        self.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
+
+    def wheelEvent(self, *args, **kwargs):
+        if self.wheel_enabled:
+            QTableView.wheelEvent(self, args[0])
+
+    def keyPressEvent(self, *args, **kwargs):
+        if self.wheel_enabled:
+            QTableView.keyPressEvent(self, args[0])
+
+    def mousePressEvent(self, *args, **kwargs):
+        mouse_event = args[0]
+        row = self.rowAt(mouse_event.y())
+        col = self.columnAt(mouse_event.x())
+        if row == -1 or col == -1:
+            return
+
+        entity = self.model().entity(row)
+        trait_name = self.model().trait_name(col)
+        if not trait_name:
+            return
+
+        editor_class = TraitableEditor.findEditorClass(entity.__class__)     #-- no alternative packages, look under ui subdir only
+        mouse_btn = mouse_event.button()
+        if mouse_btn == Qt.LeftButton:
+            cb = editor_class.leftMouseCallback(trait_name)
+        elif mouse_btn == Qt.RightButton:
+            cb = editor_class.rightMouseCallback(trait_name)
+        else:
+            return
+
+        if cb:
+            cb(self, entity)
+        else:
+            super().mousePressEvent(*args, **kwargs)
+
+    def render_entity(self, row: int, entity: Traitable):
+        last_col = len(self.model().col2name) - 1
+        first_index = self.model().create_index(row, 0)
+        last_index = self.model().create_index(row, last_col)
+        self.model().dataChanged.emit(first_index, last_index)
+
+    def extendData( self, data ):
+        if self.model().extendData(data):
+            self.resizeColumnsToContents()
+            #self.resizeRowsToContents()

ui_10x/trait_editor.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from contextlib import nullcontext
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from core_10x.concrete_traits import date_trait, dict_trait, flags_trait, list_trait
+from core_10x.trait import T, Ui
+from core_10x.traitable import traitable_trait
+
+import ui_10x.concrete_trait_widgets  # do not remove -- this registers trait widgets
+from ui_10x.choice import MultiChoice
+from ui_10x.py_data_browser import PyDataBrowser
+from ui_10x.trait_widget import TraitWidget
+from ui_10x.utils import UxDialog, UxStyleSheet, ux, ux_pick_date
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from core_10x.entity import Entity
+    from core_10x.exec_control import BTP
+    from core_10x.rc import RC
+    from core_10x.trait import Trait
+
+
+@dataclass
+class EntityWrapper:
+    entity: Entity
+    traitable_processor: Callable[[], BTP]
+
+    def set_value(self, trait: Trait, value) -> RC:
+        with self.traitable_processor() or nullcontext():
+            return self.entity.set_value(trait, value)
+
+    def get_value(self, trait: Trait):
+        with self.traitable_processor() or nullcontext():
+            value = self.entity.get_value(trait)
+            return value
+
+    def is_valid(self, trait: Trait) -> bool:
+        with self.traitable_processor() or nullcontext():
+            return self.entity.is_valid(trait)
+
+    def invalidate_value(self, trait: Trait) -> None:
+        with self.traitable_processor() or nullcontext():
+            return self.entity.invalidate_value(trait)
+
+    def get_style_sheet(self, trait: Trait):
+        with self.traitable_processor() or nullcontext():
+            return self.entity.get_style_sheet(trait)
+
+    def get_choices(self, trait: Trait):
+        with self.traitable_processor() or nullcontext():
+            return self.entity.get_choices(trait)
+
+    def create_ui_node(self, trait: Trait, callback):
+        with self.traitable_processor() or nullcontext():
+            return self.entity.bui_class().create_ui_node(self.entity, trait, callback)
+
+    def update_ui_node(self, trait: Trait):
+        with self.traitable_processor() or nullcontext():
+            return self.entity.bui_class().update_ui_node(self.entity, trait)
+
+
+class TraitEditor:
+    def __init__(self, entity, trait: Trait, ui_hint: Ui, custom_callback: Callable[[], None] = None, traitable_processor: Callable[[], BTP] = None):
+        self.entity = EntityWrapper(entity, traitable_processor)
+        self.trait = trait
+        self.widget: TraitWidget | None = None
+        self.ui_hint = ui_hint
+        self.trait_callback = self._establish_callback(custom_callback)
+
+    def is_read_only(self) -> bool:
+        return self.ui_hint.flags_on(Ui.READ_ONLY)
+
+    def _establish_callback(self, custom_callback: Callable[[], None]):
+        if custom_callback:
+            return custom_callback
+
+        if self.is_read_only():
+            return None
+
+        return self.builtin_callback()
+
+    def new_label(self) -> ux.Widget:
+        if self.ui_hint.param('right_label', False):
+            return ux.Label(' ')
+
+        if self.trait_callback:
+            label = ux.PushButton()
+            label.set_flat(True)
+            label.set_style_sheet('text-align: left')
+            label.set_text(self.ui_hint.label + '...')
+            label.clicked_connect(lambda v: self.trait_callback(self))
+            if self.trait.flags_on(T.EXPENSIVE):
+                UxStyleSheet.modify(label, {Ui.FG_COLOR: 'purple', Ui.FONT_STYLE: 'italic'})
+                label.set_tool_tip('Reaction on clicking this button may take considerable time...')
+        else:
+            label = ux.Label(self.ui_hint.label)
+
+        return label
+
+    def new_widget(self, update_self=True) -> TraitWidget:
+        tw: TraitWidget = TraitWidget.instance(self)
+        assert tw, f'{self.entity.entity.__class__}.{self.trait.name} - unknown trait widget class'
+
+        avg_char_width = tw.font_metrics().average_char_width()
+        min_width = self.ui_hint.param('min_width', 0)
+        if min_width > 0:
+            tw.set_minimum_width(min_width * avg_char_width)
+
+        max_width = self.ui_hint.param('max_width', 0)
+        if max_width > 0:
+            tw.set_maximum_width(max_width * avg_char_width)
+
+        if update_self:
+            self.widget = tw
+
+        return tw
+
+    # ---- Built-in Callbacks
+
+    def date_cb(self):
+        ux_pick_date(
+            title=f'Pick a date for {self.ui_hint.label}',
+            show_date=self.entity.get_value(self.trait),
+            on_accept=lambda value: self.entity.set_value(self.trait, value),
+        )
+
+    def list_cb(self):
+        choices = self.entity.get_value(self.trait)
+        mc = MultiChoice(choices=choices)
+        w = mc.widget()
+        if not w:
+            return
+
+        UxDialog(
+            w,
+            title=f'Choose one or more values for {self.ui_hint.label}',
+            accept_callback=lambda ctx: self.entity.set_value(self.trait, mc.values_selected),
+        ).show()
+
+    def dict_cb(self):
+        data = dict(self.entity.get_value(self.trait))
+        rc = PyDataBrowser.edit(data, title=f'Edit {self.trait.ui_hint.label}')  # TODO: callback
+        if rc:
+            self.entity.set_value(self.trait, data)
+
+    def flags_cb(self):
+        flags = self.entity.get_value(self.trait)
+        bits_class = self.trait.data_type
+        tags_selected = bits_class.data_type.names_from_value(flags)
+        mc = MultiChoice(*tags_selected, choices=bits_class.choose_from())
+        w = mc.widget()
+        if not w:
+            return
+
+        UxDialog(
+            w,
+            title=f'Choose one or more flags for {self.ui_hint.label}',
+            accept_callback=lambda ctx: self.entity.set_value(self.trait, mc.values_selected),
+        ).show()
+
+    def traitable_cb(self):
+        # -- EntityEditor - popup
+        ...
+
+    def expensive_cb(self):
+        value = self.entity.get_value(self.trait)
+        self.widget.set_widget_value(value)
+        self.widget.style_sheet.restore()
+
+    def builtin_callback(self):
+        cb = self.s_builtin_callbacks.get(self.trait.__class__)
+        if not cb:
+            if self.trait.flags_on(T.EXPENSIVE):
+                cb = self.__class__.expensive_cb
+
+        return cb
+
+    # fmt: off
+    s_builtin_callbacks = {
+        date_trait:         date_cb,
+        list_trait:         list_cb,
+        dict_trait:         dict_cb,
+        flags_trait:        flags_cb,
+        traitable_trait:    traitable_cb,
+    }
+    # fmt: on