ms-components 0.3.1__tar.gz → 0.3.2__tar.gz

{ms_components-0.3.1/src/ms_components.egg-info → ms_components-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.1
+Version: 0.3.2
 Summary: PySide6 UI components for MolSuite: smart table, project browser, job monitor, PyMOL dock, steppers.
 Author: Mario S. Valdés-Tresanco, Mario E. Valdés-Tresanco
 License-Expression: MIT

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/base.qss

@@ -64,6 +64,19 @@ QProgressBar#ToolProgress::chunk {
     background: palette(highlight);
 }
 
+/* ms_table: a PROGRESS cell, a filled bar with its text on top. The fill color is
+   the `tone` property, from the theme accents (theme.tone_qss). The track is the
+   header tone: it keeps text contrast and stands out from the rows. */
+QProgressBar#CellProgress {
+    border: none;
+    border-radius: 3px;
+    background: palette(dark);
+}
+
+QProgressBar#CellProgress::chunk {
+    border-radius: 3px;
+}
+
 
 /* Left gap for the first tab: `tab-bar { left }` shifts the whole bar.
    Do NOT use margins on ::tab -- Qt places the close button flush to the full
@@ -154,6 +167,14 @@ QToolButton[popupMode="MenuButtonPopup"]::menu-button {
     width: 18px;
 }
 
+/* Qt's own tooltip colours are a pale grey that dark themes leave unreadable. */
+QToolTip {
+    background: palette(window);
+    color: palette(text);
+    border: 1px solid palette(highlight);
+    padding: 4px;
+}
+
 /* Card = content surface. Nav trees/lists stay flat unless opted in. */
 QTableView,
 QTreeView[card="true"],

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/ms_dockwidget/widget.py

@@ -734,7 +734,10 @@ class VerticalToolbar(QWidget):
                 yield w
 
     def _layout_has_buttons(self, layout: QVBoxLayout) -> bool:
-        return any(True for _ in self._iter_buttons(layout))
+        # Action buttons (no dock_id) count too: a section holding only those is not empty.
+        return any(
+            isinstance(layout.itemAt(i).widget(), QToolButton) for i in range(layout.count())
+        )
 
     def _update_separator_visibility(self):
         self._separator.setVisible(

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/ms_table/cell_delegate.py

@@ -58,10 +58,10 @@ from __future__ import annotations
 
 from typing import Any, Callable, Optional
 
-from PySide6.QtCore import QModelIndex, QRect, QRectF, QSize, Qt
-from PySide6.QtGui import QImage, QPainter, QPalette, QPixmap
+from PySide6.QtCore import QModelIndex, QPoint, QRect, QRectF, QSize, Qt
+from PySide6.QtGui import QImage, QPainter, QPixmap, QRegion
 from PySide6.QtWidgets import (
-    QApplication, QStyle, QStyledItemDelegate, QStyleOptionViewItem,
+    QApplication, QProgressBar, QStyle, QStyledItemDelegate, QStyleOptionViewItem,
     QWidget,
 )
 
@@ -159,6 +159,8 @@ class CellWidgetDelegate(QStyledItemDelegate):
         # Persistent widget cache: row → QWidget
         # Invalidated when the page changes (load_data)
         self._persistent_widgets: dict[int, QWidget] = {}
+        # PROGRESS cells: one hidden bar per tone, so the tone property is set once.
+        self._progress_bars: dict[str, QProgressBar] = {}
 
     # ── Invalidate the cache on page change ───────────────────────────────
 
@@ -185,30 +187,40 @@ class CellWidgetDelegate(QStyledItemDelegate):
 
         row_data = self._get_row_data(index)
 
-        # ── progress mode: a fraction 0..1 as the style's own progress bar ──
+        # ── progress mode: a fraction 0..1 (or value/max) as the style's own progress bar ──
         if col_def.kind == ColumnKind.PROGRESS:
             try:
-                fraction = min(max(float(row_data.get(col_def.display_key) or 0.0), 0.0), 1.0)
+                value = float(row_data.get(col_def.display_key) or 0.0)
+                maximum = float(row_data.get(col_def.progress_max) or 0.0) if col_def.progress_max else 1.0
+                fraction = min(max(value / maximum, 0.0), 1.0) if maximum > 0 else 0.0
             except (TypeError, ValueError):
-                fraction = 0.0
-            # ponytail: painted by hand: CE_ProgressBar under an app stylesheet draws the
-            # table's rules, not QProgressBar's, and a partial chunk came out as a line.
-            rect, pal = QRectF(option.rect.adjusted(4, 5, -4, -5)), option.palette
-            painter.save()
-            painter.setRenderHint(QPainter.Antialiasing)
-            # A selected row is Highlight already: the track goes Base so the fill still shows.
-            track = pal.color(QPalette.Base) if option.state & QStyle.State_Selected else pal.color(QPalette.Text)
-            if not option.state & QStyle.State_Selected:
-                track.setAlpha(40)
-            painter.setPen(Qt.NoPen)
-            painter.setBrush(track)
-            painter.drawRoundedRect(rect, 3, 3)
-            if fraction > 0:
-                painter.setBrush(pal.color(QPalette.Highlight))
-                painter.drawRoundedRect(QRectF(rect.x(), rect.y(), rect.width() * fraction, rect.height()), 3, 3)
-            painter.setPen(pal.color(QPalette.Text))
-            painter.drawText(rect, Qt.AlignCenter, f"{int(fraction * 100)}%")  # floored: 99.9% is not "100%"
-            painter.restore()
+                value, maximum, fraction = 0.0, 0.0, 0.0
+            text = f"{int(fraction * 100)}%"  # floored: 99.9% is not "100%"
+            if col_def.progress_max:
+                text = f"{int(value):,}/{int(maximum):,} ({text})"
+            tone = col_def.progress_tone(row_data) if col_def.progress_tone else "green"
+            # A hidden QProgressBar paints the cell, so the bar is the native one and its look is
+            # QSS (`QProgressBar#CellProgress`, `[tone=...]`). render(), not drawControl(): under a
+            # stylesheet drawControl lays the chunk out from the widget, not from the option. Into a
+            # pixmap: rendered on the view's painter it ignores the viewport offset and lands under
+            # the headers.
+            bar = self._progress_bars.get(tone)
+            if bar is None:
+                bar = self._progress_bars[tone] = QProgressBar()
+                bar.setObjectName("CellProgress")
+                bar.setProperty("tone", tone)
+                bar.setRange(0, 1000)
+                bar.setAlignment(Qt.AlignCenter)
+            bar.setValue(int(fraction * 1000))
+            bar.setFormat(text)
+            rect = option.rect.adjusted(4, 5, -4, -5)
+            bar.resize(rect.size())
+            ratio = painter.device().devicePixelRatioF()
+            pixmap = QPixmap(rect.size() * ratio)
+            pixmap.setDevicePixelRatio(ratio)
+            pixmap.fill(Qt.transparent)
+            bar.render(pixmap, QPoint(), QRegion(), QWidget.DrawChildren)
+            painter.drawPixmap(rect.topLeft(), pixmap)
             return
 
         # ── paint_factory mode (SVG / image) ───────────────────────────────

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/ms_table/query_builder.py

@@ -234,11 +234,13 @@ class QueryBuilder:
         attr = self._resolve_attr(sort.field)
         if attr is None:
             return pk > pk_value
+        # SQLite puts NULLs first ascending and last descending.
+        rest_of_nulls = and_(attr.is_(None), pk > pk_value)
         if sort_value is None:
-            # NULLs come first in ascending SQLite: past the null block, anything goes.
-            return attr.is_not(None) if not sort.descending else and_(attr.is_(None), pk > pk_value)
-        ahead = attr < sort_value if sort.descending else attr > sort_value
-        return or_(ahead, and_(attr == sort_value, pk > pk_value))
+            return or_(attr.is_not(None), rest_of_nulls) if not sort.descending else rest_of_nulls
+        if sort.descending:
+            return or_(attr < sort_value, and_(attr == sort_value, pk > pk_value), attr.is_(None))
+        return or_(attr > sort_value, and_(attr == sort_value, pk > pk_value))
 
     def fetch(self) -> tuple[list[dict], int]:
         """Run the query and return (rows_as_dicts, total_count)."""

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/ms_table/smart_table_view.py

@@ -154,6 +154,15 @@ class SmartTableView(QWidget):
             self._infinite_total_hint = total
             self._infinite_total_exact = True
             self._infinite_has_more = self._infinite_loaded_end < total
+            tail = self._infinite_pages.get(self._infinite_frontier_page)
+            if tail is not None and len(tail) < self._builder.page_size and self._infinite_has_more:
+                # The last page came back short and rows were added since: forget it, so the
+                # autofill set_total() triggers fetches it again once it is in view. Kept, its
+                # rows past the old end would stay blank forever.
+                del self._infinite_pages[self._infinite_frontier_page]
+                # The next page's cursor is the short page's last row: wrong now, so it is
+                # found by offset instead.
+                self._infinite_page_cursors.pop(self._infinite_frontier_page + 1, None)
         self._model.set_total(total)
         return True
 
@@ -749,8 +758,9 @@ class SmartTableView(QWidget):
         self.load_next_page()
 
     def _on_refresh_clicked(self):
-        # Reload this table, then let the host (e.g. DockingStudio) refresh surrounding state.
-        self.refresh()
+        # Reload this table where the user is looking (scroll and selection kept), then let
+        # the host (e.g. DockingStudio) refresh surrounding state.
+        self.refresh_preserving_view()
         self.refresh_clicked.emit()
 
     # ──────────────────────────────────────────

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/ms_table/table_config.py

@@ -70,7 +70,7 @@ class ColumnKind(str, Enum):
     NUMBER  = "number"
     INTEGER = "integer"
     CHOICE  = "choice"
-    # A fraction 0..1 drawn as a progress bar with its percentage (no formatter: the bar needs the number).
+    # A fraction 0..1 (or a count, with `progress_max`) drawn as a progress bar with its percentage.
     PROGRESS = "progress"
 
 
@@ -109,6 +109,11 @@ class ColumnDef:
         expr:       SQLAlchemy expression producing the column value, for anything
                     that is not a model attribute (JSON_EXTRACT, CASE, func.*).
                     When set, `field` is only the key/label.
+        progress_max: PROGRESS columns only: the row key holding the maximum. Set, the
+                    value is a count and the bar reads "value/max (pct%)", as
+                    QProgressBar's "%v/%m (%p%)"; unset, the value is a 0..1 fraction.
+        progress_tone: PROGRESS columns only: callable(row_data) → a theme accent
+                    ("green", "red"), the bar's `tone` property. Unset, "green".
     """
     field:      str
     label:      Optional[str]          = None
@@ -130,6 +135,8 @@ class ColumnDef:
     tooltip:    Any                    = None   # str | Callable
     db_column:  Optional[str]          = None
     expr:       Any                    = None   # SQLAlchemy ColumnElement
+    progress_max: Optional[str]        = None
+    progress_tone: Optional[Callable]  = None
 
     # ── Fields for rendering widgets inside a cell ──────────────────────
     #

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components/theme.py

@@ -276,6 +276,25 @@ def resolve(name: str) -> str:
     return DEFAULT_DARK if scheme == Qt.ColorScheme.Dark else DEFAULT_LIGHT
 
 
+#: The accents a widget can wear through `setProperty("tone", name)`.
+TONES = ("green", "red")
+
+
+def tone_qss(theme: dict[str, str] | None = None) -> str:
+    """`QProgressBar[tone="green"]` and siblings, from the live theme.
+
+    QSS has no palette role for the accents, so these rules are written per theme.
+    Translucent, so the bar's text stays readable on dark and light themes alike.
+    """
+    theme = theme or _current
+    rules = []
+    for tone in TONES:
+        accent = QColor(theme[tone])
+        rgba = f"rgba({accent.red()}, {accent.green()}, {accent.blue()}, 150)"
+        rules.append(f'QProgressBar[tone="{tone}"]::chunk {{ background: {rgba}; }}')
+    return "\n".join(rules) + "\n"
+
+
 def base_qss() -> str:
     """The shared geometry stylesheet (colors resolved from the live palette)."""
     return files(__package__).joinpath("base.qss").read_text(encoding="utf-8")
@@ -297,7 +316,7 @@ def apply_theme(name: str, app: QApplication | None = None, *,
         set_base_font(base_font_pt, app=app)
     app.setStyle("Fusion")  # Fusion honors QPalette ColorRoles most faithfully
     app.setPalette(build_palette(_current))
-    app.setStyleSheet(base_qss())
+    app.setStyleSheet(base_qss() + tone_qss())
 
 
 if __name__ == "__main__":

{ms_components-0.3.1 → ms_components-0.3.2/src/ms_components.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.1
+Version: 0.3.2
 Summary: PySide6 UI components for MolSuite: smart table, project browser, job monitor, PyMOL dock, steppers.
 Author: Mario S. Valdés-Tresanco, Mario E. Valdés-Tresanco
 License-Expression: MIT

{ms_components-0.3.1 → ms_components-0.3.2}/src/ms_components.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.3.1",
+  "tag": "0.3.2",
   "distance": 0,
-  "node": "g7e2c3d4e709ddabdcf4c8915ba010410c3014634",
+  "node": "gca390289c6a1cb6d4a8c445570bbc0eb87ebd291",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-21"

ms_components-0.3.2/tests/test_progress_column.py

@@ -0,0 +1,48 @@
+"""A PROGRESS column fills the share of the cell its fraction says, clamped to 0..1,
+in the tone its row asks for."""
+from __future__ import annotations
+
+import sqlmodel  # noqa: F401  (pydantic before PySide6, or its lazy import breaks)
+from PySide6.QtGui import QColor, QImage, QPainter, QStandardItemModel
+from PySide6.QtWidgets import QApplication, QStyleOptionViewItem, QTableView
+
+from ms_components import theme
+from ms_components.ms_table.cell_delegate import CellWidgetDelegate
+from ms_components.ms_table.table_config import ColumnDef, ColumnKind
+
+
+class _Model(QStandardItemModel):
+    rows = [{"done": 0.5}, {"done": None}, {"done": 3.0, "state": "failed"}]
+
+    def get_row_data(self, row):
+        return self.rows[row]
+
+
+def _tone(pixel: QColor) -> str:
+    if pixel.green() - pixel.red() > 40:
+        return "green"
+    return "red" if pixel.red() - pixel.green() > 40 else "track"
+
+
+def test_a_progress_column_fills_its_fraction_of_the_cell():
+    app = QApplication.instance() or QApplication([])
+    app.setStyleSheet(theme.base_qss() + theme.tone_qss(theme.THEMES["dracula"]))
+    try:
+        view, model = QTableView(), _Model(3, 1)
+        view.setModel(model)
+        column = ColumnDef("done", kind=ColumnKind.PROGRESS,
+                           progress_tone=lambda row: "red" if row.get("state") else "green")
+        delegate = CellWidgetDelegate(0, column, view)
+        filled = []
+        for row in range(3):
+            image = QImage(200, 30, QImage.Format_ARGB32)
+            image.fill(QColor("black"))
+            option = QStyleOptionViewItem()
+            option.widget, option.rect = view, image.rect()
+            painter = QPainter(image)
+            delegate.paint(painter, option, model.index(row, 0))
+            painter.end()
+            filled.append([_tone(image.pixelColor(x, 8)) for x in (20, 180)])
+        assert filled == [["green", "track"], ["track", "track"], ["red", "red"]]
+    finally:
+        app.setStyleSheet("")

{ms_components-0.3.1 → ms_components-0.3.2}/tests/test_query_builder_keyset.py

@@ -169,3 +169,57 @@ def test_refresh_while_scrolled_loads_the_rows_on_screen(db):
         # and the right row, not a neighbouring page's: the window is one contiguous run
         assert view._model.get_raw_object(row).id == row + 1
     view.close()
+
+
+def test_rows_added_after_a_short_last_page_get_fetched_not_left_blank():
+    """A running job: the first load brought 3 rows, refresh_counts() then says 30. The
+    short page must be fetched again, or rows 3..29 show as blank rows forever."""
+    app = QApplication.instance() or QApplication(["ms-table-tail-test"])
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=None)
+    SQLModel.metadata.create_all(engine, tables=[Hit.__table__])
+    add = lambda ids: (lambda s: (s.add_all([Hit(id=i, name=f"l{i}") for i in ids]), s.commit()))(Session(engine))
+    add(range(1, 4))
+    view = SmartTableView(_Db(engine), _config())
+    view.resize(600, 900)
+    view.show()
+    app.processEvents()
+    assert view._model.loaded_count == 3
+
+    for end in (11, 31):  # the job keeps going: every tick, more rows
+        add(range(view._model.rowCount() + 1, end))
+        assert view.refresh_counts()
+        for _ in range(5):
+            app.processEvents()
+        assert view._model.rowCount() == end - 1
+        assert [view._model.get_raw_object(row).id for row in range(end - 1)] == list(range(1, end))
+    view.close()
+
+
+
+class Gap(SQLModel, table=True):
+    __tablename__ = "gap"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    score: Optional[float] = None
+
+
+@pytest.mark.parametrize("descending", [False, True])
+def test_keyset_walks_a_null_block_longer_than_a_page(descending):
+    """A ΔΔG column is NULL for every ligand without that off-target: the walk must keep
+    the whole null block (ascending: first; descending: last), not drop it after page 1."""
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=None)
+    SQLModel.metadata.create_all(engine, tables=[Gap.__table__])
+    with Session(engine) as session:
+        session.add_all([Gap(id=i, score=None if i % 3 else float(i)) for i in range(1, 351)])
+        session.commit()
+    config = TableConfig(model_class=Gap, columns=[ColumnDef("score")], page_size=PAGE,
+                         load_mode=TableLoadMode.INFINITE,
+                         default_sort=[SortSpec("score", descending=descending)])
+    builder = QueryBuilder(_Db(engine), config)
+    seen, cursor = [], None
+    while True:
+        rows, has_more = builder.fetch_window_after(cursor)
+        seen += [row["__raw__"].id for row in rows]
+        if not has_more:
+            break
+        cursor = builder.cursor_of(rows[-1])
+    assert sorted(seen) == list(range(1, 351))

ms_components-0.3.1/tests/test_progress_column.py

@@ -1,36 +0,0 @@
-"""A PROGRESS column fills the share of the cell its fraction says, clamped to 0..1."""
-from __future__ import annotations
-
-import sqlmodel  # noqa: F401  (pydantic before PySide6, or its lazy import breaks)
-from PySide6.QtGui import QColor, QImage, QPainter, QPalette, QStandardItemModel
-from PySide6.QtWidgets import QApplication, QStyleOptionViewItem, QTableView
-
-from ms_components.ms_table.cell_delegate import CellWidgetDelegate
-from ms_components.ms_table.table_config import ColumnDef, ColumnKind
-
-
-class _Model(QStandardItemModel):
-    rows = [{"done": 0.5}, {"done": None}, {"done": 3.0}]
-
-    def get_row_data(self, row):
-        return self.rows[row]
-
-
-def test_a_progress_column_fills_its_fraction_of_the_cell():
-    app = QApplication.instance() or QApplication([])
-    view, model = QTableView(), _Model(3, 1)
-    view.setModel(model)
-    delegate = CellWidgetDelegate(0, ColumnDef("done", kind=ColumnKind.PROGRESS), view)
-    filled = []
-    for row in range(3):
-        image = QImage(200, 30, QImage.Format_ARGB32)
-        image.fill(QColor("black"))
-        option = QStyleOptionViewItem()
-        option.widget, option.rect = view, image.rect()
-        option.palette.setColor(QPalette.Highlight, QColor("red"))
-        painter = QPainter(image)
-        delegate.paint(painter, option, model.index(row, 0))
-        painter.end()
-        filled.append([image.pixelColor(x, 8) == QColor("red") for x in (20, 180)])
-    assert filled == [[True, False], [False, False], [True, True]]
-    assert app