QT-PyQt-PySide-Custom-Widgets-Pro 1.1.0__py3-none-any.whl

custom_widgets_pro/datatable/datatable_pro.py

@@ -0,0 +1,319 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""QCustomDataTablePro - the commercial data grid.
+
+Extends the free-core ``QCustomDataTable`` through its stable Pro contract:
+the ``_createModel`` / ``_createView`` factory seams and the model's
+``Qt.UserRole`` raw-value seam. Free examples/tutorials transfer directly -
+"swap the class, gain the features".
+
+SCAFFOLD: this currently inherits the free table's behaviour. The Pro
+capabilities (virtualization, frozen columns, grouping/pivot, inline editing,
+server-side loading, CSV/XLSX export) are implemented on the seams below. See
+the free-core repo: docs/design/datatable-pro-spec.md.
+
+Contains ONLY original code - no bundled third-party assets. Export uses the
+Python stdlib (csv, zipfile+xml for XLSX); indicators are painted, not shipped.
+"""
+from qtpy.QtCore import Qt, Signal
+from qtpy.QtGui import QColor, QPalette
+
+from Custom_Widgets.QCustomDataTable import QCustomDataTable
+from qtpy.QtWidgets import QAbstractItemView
+
+from .._catalog import register
+from .virtual_model import VirtualDataTableModel, GroupRole
+from .provider import DataProvider, ListDataProvider, CallableDataProvider
+from .frozen_view import FrozenHostView
+
+
+@register
+class QCustomDataTablePro(QCustomDataTable):
+    cellEdited = Signal(int, str, object, object)          # row, key, old, new
+    validationFailed = Signal(int, str, object, str)       # row, key, value, message
+    groupToggled = Signal(object, bool)                    # group path, expanded
+
+    __catalog__ = {
+        "name": "QCustomDataTablePro",
+        "extends": "QCustomDataTable",
+        "edition": "pro",
+        "props": {
+            "virtualized": {"type": "bool", "default": True},
+            "editable": {"type": "bool", "default": False},
+            "pinnedColumns": {"type": "list", "default": []},
+            "groupBy": {"type": "list", "default": []},
+        },
+        "signals": ["cellEdited", "groupToggled"],
+        "capabilities": ["virtualization", "frozen-columns", "grouping",
+                         "pivot", "inline-edit", "server-side", "export-csv",
+                         "export-xlsx"],
+    }
+
+    def __init__(self, parent=None, chunkSize=200):
+        self._chunkSize = int(chunkSize)
+        self._sortCol = -1
+        self._sortAsc = True
+        self._groupKeys = []
+        self._aggregates = {}
+        self._prePivot = None          # (columns, provider) snapshot before pivot
+        self._pivotActive = False
+        super().__init__(parent)
+        # Virtualization: disable pagination so the view fetches lazily from the
+        # model (the sort/filter proxy forwards canFetchMore/fetchMore).
+        self.showPagination = False
+        # The view's built-in (client-side) sort stays OFF - it would only order
+        # the loaded window. Sort/filter are pushed DOWN to the provider instead;
+        # we drive the header ourselves so the arrow still works.
+        self.sortable = False
+        header = self._view.horizontalHeader()
+        header.setSectionsClickable(True)
+        header.setSortIndicatorShown(True)
+        header.sectionClicked.connect(self._onHeaderSortPushdown)
+
+        # inline editing: enable triggers on the view and re-emit model edits
+        self._view.setEditTriggers(QAbstractItemView.DoubleClicked
+                                   | QAbstractItemView.EditKeyPressed
+                                   | QAbstractItemView.AnyKeyPressed)
+        self._model.cellEdited.connect(self.cellEdited)
+        self._model.validationFailed.connect(self.validationFailed)
+
+        # grouping: clicking a group-header row toggles expand/collapse
+        self._view.clicked.connect(self._onProClicked)
+
+    # -- Server-side sort / filter (push-down) ------------------------------
+    def _onHeaderSortPushdown(self, column):
+        if column == self._sortCol:
+            self._sortAsc = not self._sortAsc
+        else:
+            self._sortCol, self._sortAsc = column, True
+        self.sortBy(column, Qt.AscendingOrder if self._sortAsc else Qt.DescendingOrder)
+
+    def sortBy(self, column, order=Qt.AscendingOrder):
+        """Push a sort down to the provider (overrides the free client-side sort)."""
+        self._sortCol = column
+        self._sortAsc = (order == Qt.AscendingOrder)
+        self._view.horizontalHeader().setSortIndicator(column, order)
+        self._model.setSort(column, order)
+        self._reapplyGrouping()
+        self.sortChanged.emit(column, order)
+
+    def setFilterText(self, text):
+        """Push a free-text filter down to the provider (overrides the free
+        client-side proxy filter)."""
+        self._model.setFilter(text)
+        self._reapplyGrouping()
+
+    def _reapplyGrouping(self):
+        """After a sort/filter reload, re-materialise and re-group so the
+        outline reflects the new result set."""
+        if self._groupKeys:
+            self._model.fetchAll()
+            self._model.setGrouping(self._groupKeys, self._aggregates)
+
+    # -- Pro extension seams (override the free factories) ------------------
+    def _createModel(self):
+        return VirtualDataTableModel(chunkSize=getattr(self, "_chunkSize", 200),
+                                     parent=self)
+
+    def _createView(self):
+        return FrozenHostView(self)
+
+    # -- Data API (virtualized) --------------------------------------------
+    def setDataProvider(self, provider):
+        """Attach a lazy DataProvider (row windows + optional total). Primes the
+        first window so the view shows content immediately; scrolling loads the
+        rest."""
+        if not isinstance(provider, DataProvider):
+            raise TypeError("expected a DataProvider, got %r" % type(provider))
+        self._model.setProvider(provider)
+        if self._model.canFetchMore():
+            self._model.fetchMore()
+
+    def setData(self, rows):
+        """Feed an in-memory list through the virtualized path."""
+        self.setDataProvider(ListDataProvider(rows))
+
+    setRows = setData
+
+    def setFetchCallback(self, fetch_fn, total=None):
+        """Convenience: virtualize over ``fetch_fn(offset, limit) -> list``."""
+        self.setDataProvider(CallableDataProvider(fetch_fn, total=total))
+
+    def loadedRowCount(self):
+        return self._model.loadedRowCount()
+
+    def totalRowCount(self):
+        return self._model.totalRowCount()
+
+    # -- Pro API surface (further stubs; per datatable-pro-spec.md) ---------
+    def setFrozenColumnCount(self, count):
+        """Freeze (pin) the leftmost `count` columns so they stay visible while
+        the rest scroll horizontally."""
+        self._view.setFrozenColumnCount(count)
+
+    def frozenColumnCount(self):
+        return self._view.frozenColumnCount()
+
+    def pinColumns(self, keys):
+        """Pin the columns for `keys`. Pinned columns are the leftmost ones, so
+        this freezes every column up to (and including) the right-most key."""
+        cols = self._model.columns()
+        index = {c.key: i for i, c in enumerate(cols)}
+        indices = [index[k] for k in keys if k in index]
+        self.setFrozenColumnCount(max(indices) + 1 if indices else 0)
+
+    # -- Grouping / aggregation --------------------------------------------
+    def groupBy(self, keys, aggregates=None):
+        """Group rows by one or more column ``keys`` (outer -> inner), with an
+        optional ``aggregates`` spec ({column_key: reducer}) shown on each group
+        header. ``reducer`` is a name (sum/avg/count/min/max/first/last) or a
+        callable ``fn(values) -> result``.
+
+        Grouping aggregates over the whole current result, so this materialises
+        the current sorted/filtered rows (leaving virtualization only while
+        grouped); ``groupBy([])`` clears grouping and restores lazy loading."""
+        keys = list(keys or [])
+        if self._pivotActive:
+            self.clearPivot()                # grouping and pivot are exclusive
+        # aggregate spec may also be declared on the columns (col.aggregate).
+        agg = dict(aggregates or {})
+        for col in self._model.columns():
+            spec = getattr(col, "aggregate", None)
+            if spec is not None and col.key not in agg:
+                agg[col.key] = spec
+        self._groupKeys = keys
+        self._aggregates = agg
+        if keys:
+            self._model.fetchAll()
+            self._applyGroupColors()
+        self._model.setGrouping(keys, agg)
+
+    def clearGrouping(self):
+        """Remove grouping and return to the flat, virtualized view."""
+        self.groupBy([])
+
+    def groupKeys(self):
+        return list(self._groupKeys)
+
+    def isGrouped(self):
+        return self._model.isGrouped()
+
+    def expandAllGroups(self):
+        self._model.setAllGroupsExpanded(True)
+
+    def collapseAllGroups(self):
+        self._model.setAllGroupsExpanded(False)
+
+    def toggleGroup(self, row):
+        """Toggle the group header at source ``row`` (as returned by GroupRole).
+        Prefer clicking; this is the programmatic hook."""
+        result = self._model.toggleGroupRow(row)
+        if result is not None:
+            self.groupToggled.emit(*result)
+        return result
+
+    def _onProClicked(self, viewIndex):
+        if not self._model.isGrouped():
+            return
+        src = self._sortFilter.mapToSource(viewIndex)
+        header = self._model.data(self._model.index(src.row(), 0), GroupRole)
+        if header is not None:
+            self.toggleGroup(src.row())
+
+    def _applyGroupColors(self):
+        """Derive group-header colours from the design tokens, following the
+        widget's light/dark palette."""
+        try:
+            from Custom_Widgets.JSonStyles.tokens import DesignTokens
+        except Exception:
+            return
+        base = self.palette().color(QPalette.Base)
+        theme = "dark" if base.lightness() < 128 else "light"
+        tokens = DesignTokens(theme=theme)
+        self._model.setGroupColors(QColor(tokens.role("surface-muted")),
+                                   QColor(tokens.role("on-surface")))
+
+    # -- Pivot (cross-tab) -------------------------------------------------
+    def pivot(self, index, columns, values, aggfunc="sum", totals=True,
+              fill=None):
+        """Reshape the current result into a pivot (cross-tab) table.
+
+        index    row-dimension key (or list of keys) - one output row per
+                 distinct combination.
+        columns  a single key whose distinct values become output columns.
+        values   the key aggregated into each cell.
+        aggfunc  reducer name (sum/avg/count/min/max/first/last) or a callable.
+        totals   add a trailing per-row total column.
+
+        Snapshots the pre-pivot table so clearPivot() restores it. Pivot and
+        grouping are exclusive."""
+        from .pivot import pivot_table
+        if self._pivotActive:
+            self.clearPivot()                # always pivot from the flat source
+        if self._groupKeys:
+            self.groupBy([])                 # drop grouping first
+        self._model.fetchAll()               # materialise current sort/filter
+        source_rows = self._model.rows()
+        self._prePivot = (self._model.columns(), self._model.provider())
+
+        col_defs, result = pivot_table(source_rows, index, columns, values,
+                                       agg=aggfunc, totals=totals, fill=fill)
+        # keep the index columns' original titles / types
+        original = {c.key: c for c in self._prePivot[0]}
+        for cd in col_defs:
+            src = original.get(cd["key"])
+            if src is not None:
+                cd["title"] = src.title
+                cd["type"] = src.type
+        self._pivotActive = True
+        self.setColumns(col_defs)
+        self.setData(result)
+
+    def clearPivot(self):
+        """Restore the table to its pre-pivot columns and data source."""
+        if self._prePivot is None:
+            return
+        columns, provider = self._prePivot
+        self._prePivot = None
+        self._pivotActive = False
+        self.setColumns(columns)
+        if provider is not None:
+            self.setDataProvider(provider)
+        else:
+            self.setData([])
+
+    def isPivoted(self):
+        return self._pivotActive
+
+    def setEditableColumns(self, keys):
+        """Make the given column keys editable (others stay read-only)."""
+        self._model.setEditableColumns(keys)
+
+    def setEditable(self, editable=True):
+        """Convenience: True -> all columns editable, False -> none, or pass a
+        list of column keys."""
+        if editable is True:
+            keys = [c.key for c in self._model.columns()]
+        elif editable is False:
+            keys = []
+        else:
+            keys = list(editable)
+        self._model.setEditableColumns(keys)
+
+    def setColumnValidator(self, key, fn):
+        """Set a validator ``fn(value) -> True | error_message`` for a column;
+        rejected edits emit validationFailed and are not written."""
+        self._model.setValidator(key, fn)
+
+    def editableColumns(self):
+        return self._model.editableColumns()
+
+    def exportTo(self, path, fmt=None, sheetName="Sheet1"):
+        """Export the current result (respecting the active sort + filter) to
+        .csv or .xlsx using the pure-stdlib writer. Rows stream from the
+        provider, so a large export is not held in memory."""
+        from .export import export_table
+        return export_table(path, self._model.columns(),
+                            self._model.iterAllRows(), fmt=fmt, sheet_name=sheetName)

custom_widgets_pro/datatable/export.py

@@ -0,0 +1,143 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""CSV / XLSX export for DataTable Pro - pure standard library.
+
+CSV uses the stdlib ``csv`` module. XLSX is written directly: an .xlsx file is
+just a ZIP of XML parts, so we emit the minimal Office Open XML package with
+``zipfile`` + string XML. No third-party dependency (no openpyxl), matching the
+Pro rule that this package bundles only original code.
+
+Rows are streamed - the worksheet is written straight into the zip entry, so a
+large export never materialises the whole sheet in memory.
+"""
+import csv
+import zipfile
+from xml.sax.saxutils import escape
+
+
+def _cell_value(column, row):
+    """Raw value for a column key in a row (preserves numeric types)."""
+    return row.get(column.key)
+
+
+# ---------------------------------------------------------------------- #
+## CSV
+# ---------------------------------------------------------------------- #
+def export_csv(path, columns, rows):
+    with open(path, "w", newline="", encoding="utf-8") as fh:
+        writer = csv.writer(fh)
+        writer.writerow([c.title for c in columns])
+        for row in rows:
+            writer.writerow([_csv_cell(_cell_value(c, row)) for c in columns])
+
+
+def _csv_cell(value):
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    return value
+
+
+# ---------------------------------------------------------------------- #
+## XLSX (minimal Office Open XML, streamed)
+# ---------------------------------------------------------------------- #
+_CONTENT_TYPES = (
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+    '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+    '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+    '<Default Extension="xml" ContentType="application/xml"/>'
+    '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>'
+    '<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>'
+    '</Types>')
+
+_ROOT_RELS = (
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+    '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+    '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>'
+    '</Relationships>')
+
+_WORKBOOK_RELS = (
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+    '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+    '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>'
+    '</Relationships>')
+
+_SHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+
+
+def _sanitize_sheet_name(name):
+    for ch in "\\/?*[]:":
+        name = name.replace(ch, " ")
+    return (name.strip() or "Sheet1")[:31]
+
+
+def _workbook_xml(sheet_name):
+    return (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<workbook xmlns="%s" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">'
+        '<sheets><sheet name="%s" sheetId="1" r:id="rId1"/></sheets>'
+        '</workbook>' % (_SHEET_NS, escape(sheet_name)))
+
+
+def _col_letter(index):
+    """0-based column index -> A, B, ... Z, AA, ..."""
+    letters = ""
+    index += 1
+    while index:
+        index, rem = divmod(index - 1, 26)
+        letters = chr(65 + rem) + letters
+    return letters
+
+
+def _cell_xml(ref, value):
+    if value is None or value == "":
+        return '<c r="%s"/>' % ref
+    if isinstance(value, bool):
+        return '<c r="%s" t="b"><v>%d</v></c>' % (ref, 1 if value else 0)
+    if isinstance(value, (int, float)):
+        return '<c r="%s"><v>%s</v></c>' % (ref, value)
+    return ('<c r="%s" t="inlineStr"><is><t xml:space="preserve">%s</t></is></c>'
+            % (ref, escape(str(value))))
+
+
+def _row_xml(rownum, values):
+    cells = "".join(_cell_xml("%s%d" % (_col_letter(i), rownum), v)
+                    for i, v in enumerate(values))
+    return '<row r="%d">%s</row>' % (rownum, cells)
+
+
+def export_xlsx(path, columns, rows, sheet_name="Sheet1"):
+    sheet_name = _sanitize_sheet_name(sheet_name)
+    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr("[Content_Types].xml", _CONTENT_TYPES)
+        zf.writestr("_rels/.rels", _ROOT_RELS)
+        zf.writestr("xl/workbook.xml", _workbook_xml(sheet_name))
+        zf.writestr("xl/_rels/workbook.xml.rels", _WORKBOOK_RELS)
+        with zf.open("xl/worksheets/sheet1.xml", "w") as sheet:
+            def w(text):
+                sheet.write(text.encode("utf-8"))
+            w('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>')
+            w('<worksheet xmlns="%s"><sheetData>' % _SHEET_NS)
+            w(_row_xml(1, [c.title for c in columns]))          # header
+            rownum = 2
+            for row in rows:
+                w(_row_xml(rownum, [_cell_value(c, row) for c in columns]))
+                rownum += 1
+            w("</sheetData></worksheet>")
+
+
+# ---------------------------------------------------------------------- #
+## Dispatch
+# ---------------------------------------------------------------------- #
+def export_table(path, columns, rows, fmt=None, sheet_name="Sheet1"):
+    fmt = (fmt or path.rsplit(".", 1)[-1]).lower()
+    if fmt == "csv":
+        export_csv(path, columns, rows)
+    elif fmt in ("xlsx", "xls"):
+        export_xlsx(path, columns, rows, sheet_name=sheet_name)
+    else:
+        raise ValueError("unsupported export format: %r (use .csv or .xlsx)" % fmt)
+    return fmt

custom_widgets_pro/datatable/frozen_view.py

@@ -0,0 +1,112 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""Frozen (pinned) leftmost columns for DataTable Pro.
+
+Classic Qt technique: a second QTableView overlays the left of the main view,
+shares the same model and selection model, shows only the frozen columns, and
+is kept in sync on vertical scroll, column resize and geometry changes. The
+main view scrolls horizontally underneath while the frozen overlay stays put.
+"""
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QTableView, QFrame, QHeaderView
+
+
+class FrozenHostView(QTableView):
+    """The main table view; hosts a frozen overlay for the first N columns.
+
+    QCustomDataTablePro uses this as its view (via _createView). Call
+    setFrozenColumnCount(n) to pin the leftmost n columns.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._frozen = None
+        self._count = 0
+
+    # ------------------------------------------------------------------ #
+    ## Public
+    # ------------------------------------------------------------------ #
+    def frozenColumnCount(self):
+        return self._count
+
+    def setFrozenColumnCount(self, n):
+        n = max(0, int(n))
+        self._count = n
+        if n <= 0:
+            if self._frozen is not None:
+                self._frozen.setParent(None)
+                self._frozen.deleteLater()
+                self._frozen = None
+            return
+        if self._frozen is None:
+            self._frozen = QTableView(self)
+            self._setupFrozen()
+        self._applyFrozen()
+
+    def frozenView(self):
+        return self._frozen
+
+    # ------------------------------------------------------------------ #
+    ## Overlay setup / sync
+    # ------------------------------------------------------------------ #
+    def _setupFrozen(self):
+        f = self._frozen
+        f.setObjectName("dataTableView")            # inherit the token QSS
+        if self.model() is not None:
+            f.setModel(self.model())
+            f.setSelectionModel(self.selectionModel())
+        f.setFocusPolicy(Qt.NoFocus)
+        f.setFrameShape(QFrame.NoFrame)
+        f.verticalHeader().setVisible(False)
+        f.horizontalHeader().setStretchLastSection(False)
+        f.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        f.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        f.setEditTriggers(self.editTriggers())
+        f.setSelectionBehavior(self.selectionBehavior())
+        f.setSelectionMode(self.selectionMode())
+        f.setShowGrid(self.showGrid())
+        f.setAlternatingRowColors(self.alternatingRowColors())
+        # keep the two views vertically in lock-step
+        self.verticalScrollBar().valueChanged.connect(f.verticalScrollBar().setValue)
+        f.verticalScrollBar().valueChanged.connect(self.verticalScrollBar().setValue)
+        self.horizontalHeader().sectionResized.connect(self._onSectionResized)
+        f.show()
+
+    def _applyFrozen(self):
+        f = self._frozen
+        model = self.model()
+        cols = model.columnCount() if model is not None else 0
+        for c in range(cols):
+            f.setColumnHidden(c, c >= self._count)
+            if c < self._count:
+                f.setColumnWidth(c, self.columnWidth(c))
+        self._updateFrozenGeometry()
+
+    def _onSectionResized(self, index, _old, new):
+        if self._frozen is not None and index < self._count:
+            self._frozen.setColumnWidth(index, new)
+            self._updateFrozenGeometry()
+
+    def _updateFrozenGeometry(self):
+        if self._frozen is None:
+            return
+        width = sum(self.columnWidth(c) for c in range(self._count))
+        height = self.viewport().height() + self.horizontalHeader().height()
+        fw = self.frameWidth()
+        self._frozen.setGeometry(fw, fw, width, height)
+
+    # ------------------------------------------------------------------ #
+    ## Keep the overlay valid across model/geometry changes
+    # ------------------------------------------------------------------ #
+    def setModel(self, model):
+        super().setModel(model)
+        if self._frozen is not None:
+            self._frozen.setModel(model)
+            self._frozen.setSelectionModel(self.selectionModel())
+            self._applyFrozen()
+
+    def resizeEvent(self, e):
+        super().resizeEvent(e)
+        self._updateFrozenGeometry()