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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.2
+Version: 0.3.4
 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.4/src/ms_components/backdrop.py

@@ -0,0 +1,34 @@
+"""A faint, centred icon painted under a widget's own children (welcome pages, empty states)."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QRect, QSize
+from PySide6.QtGui import QIcon, QPainter
+from PySide6.QtWidgets import QWidget
+
+
+class Backdrop(QWidget):
+    """``icon`` drawn at ``opacity``, scaled to 80 % of the shorter side; ``None`` draws nothing."""
+
+    # One fixed-size render, scaled: asking the icon for each widget size would cache a
+    # multi-MB pixmap per size (~1 GB after a long window resize with a caching icon engine).
+    RENDER_PX = 512
+
+    def __init__(self, icon: QIcon | None = None, parent: QWidget | None = None, *, opacity: float = 0.06):
+        super().__init__(parent)
+        self._icon = icon
+        self._opacity = opacity
+
+    def paintEvent(self, event) -> None:
+        if self._icon is not None:
+            side = int(min(self.width(), self.height()) * 0.8)
+            painter = QPainter(self)
+            painter.setOpacity(self._opacity)
+            painter.setRenderHint(QPainter.SmoothPixmapTransform)
+            painter.drawPixmap(QRect((self.width() - side) // 2, (self.height() - side) // 2, side, side),
+                               self._icon.pixmap(QSize(self.RENDER_PX, self.RENDER_PX)))
+            painter.end()
+        super().paintEvent(event)
+
+
+__all__ = ["Backdrop"]

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

@@ -111,7 +111,8 @@ QTextEdit,
 QSpinBox,
 QDoubleSpinBox,
 QComboBox {
-    border: 1px solid palette(mid);
+    /* shadow = the control edge (3:1 on every surface); mid stays for hairlines */
+    border: 1px solid palette(shadow);
     border-radius: 4px;
     padding: 3px 6px;
 }
@@ -136,7 +137,7 @@ QComboBox:focus {
 }
 
 QPushButton {
-    border: 1px solid palette(mid);
+    border: 1px solid palette(shadow);
     border-radius: 4px;
     padding: 5px 14px;
 }
@@ -154,16 +155,27 @@ QPushButton:default {
     border-color: palette(highlight);
 }
 
+QLineEdit:disabled,
+QPlainTextEdit:disabled,
+QTextEdit:disabled,
+QSpinBox:disabled,
+QDoubleSpinBox:disabled,
+QComboBox:disabled,
+QPushButton:disabled,
+QToolButton[popupMode="MenuButtonPopup"]:disabled {
+    border-color: palette(mid);
+}
+
 /* A split button (QToolButton with a menu arrow) is an action button, not a toolbar icon:
    framed like QPushButton, the arrow in its own segment. */
 QToolButton[popupMode="MenuButtonPopup"] {
-    border: 1px solid palette(mid);
+    border: 1px solid palette(shadow);
     padding: 5px 14px;
     padding-right: 24px;
 }
 
 QToolButton[popupMode="MenuButtonPopup"]::menu-button {
-    border-left: 1px solid palette(mid);
+    border-left: 1px solid palette(shadow);
     width: 18px;
 }
 

{ms_components-0.3.2 → ms_components-0.3.4}/src/ms_components/ms_pymol/__init__.py

@@ -1,5 +1,6 @@
 from .widget import (
     COMPARISON_COLORS,
+    associate_scene_objects,
     PymolControlBar,
     PymolDockWidget,
     PymolPresetSpec,
@@ -8,6 +9,7 @@ from .widget import (
 
 __all__ = [
     "COMPARISON_COLORS",
+    "associate_scene_objects",
     "PymolControlBar",
     "PymolDockWidget",
     "PymolPresetSpec",

ms_components-0.3.4/src/ms_components/ms_pymol/icons/hydrogens-polar.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="2" y="2" width="20" height="20" rx="5"/>
+  <path d="M7 7v10M13 7v10M7 12h6"/>
+  <path d="M16 12V7h1.5a1.5 1.5 0 0 1 0 3H16" stroke-width="1.2"/>
+</svg>

ms_components-0.3.4/src/ms_components/ms_pymol/icons/hydrogens.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="2" y="2" width="20" height="20" rx="5"/>
+  <path d="M8 7v10M16 7v10M8 12h8"/>
+</svg>

{ms_components-0.3.2 → ms_components-0.3.4}/src/ms_components/ms_pymol/widget.py

@@ -39,6 +39,8 @@ from . import plugins as _pymol_plugins  # noqa: F401
 
 
 class _PymolGLWidget(PyMOLGLWidget):
+    before_render = Signal()
+
     def __init__(self, parent):
         super().__init__(parent)
         self._opengl_error: str | None = None
@@ -69,6 +71,7 @@ class _PymolGLWidget(PyMOLGLWidget):
 
     def paintGL(self):
         if self._opengl_error is None:
+            self.before_render.emit()
             super().paintGL()
 
     def resizeGL(self, width, height):
@@ -123,6 +126,7 @@ class PymolPresetSpec:
     callback: Callable[[Any, PymolSceneContext], None]
     contexts: frozenset[str] = field(default_factory=frozenset)
     tooltip: str = ""
+    per_grid_slot: bool = False
 
     def supports(self, context_kind: str) -> bool:
         return not self.contexts or str(context_kind) in self.contexts
@@ -138,6 +142,14 @@ def _builtin_preset(method_name: str):
     return apply
 
 
+def associate_scene_objects(cmd, objects, *, reference: str) -> None:
+    """Keep generated interactions/geometry in their structure's comparison panel."""
+    slot = cmd.get_setting_int("grid_slot", reference)
+    for obj in objects:
+        if cmd.get_type(obj) != "object:group":
+            cmd.set("grid_slot", slot, obj)
+
+
 class PymolControlBar(QFrame):
     """Compact, reusable controls for an embedded PyMOL scene."""
 
@@ -150,7 +162,9 @@ class PymolControlBar(QFrame):
         self._cmd = cmd
         self._context = PymolSceneContext()
         self._grid_label_objects: set[str] = set()
+        self._preset_objects: set[str] = set()
         self._comparison_layout = "grid"
+        self._hydrogen_mode = "none"
         self._presets: dict[str, PymolPresetSpec] = {}
         self.setObjectName("PymolControlBar")
 
@@ -246,6 +260,14 @@ class PymolControlBar(QFrame):
             menu=hide_menu,
         )
 
+        self.hydrogens_action = self._add_toolbar_action(
+            "Hydrogens", "hydrogens.svg",
+            "Hydrogens: hidden. Click to show all H in this PyMOL session.",
+            self.toggle_hydrogens,
+            checkable=True,
+        )
+        self.hydrogens_action.setData("none")
+
         self.preset_menu = QMenu("Presets", bar)
         self.preset_action = self._add_toolbar_action(
             "Presets", "presets.svg",
@@ -264,6 +286,7 @@ class PymolControlBar(QFrame):
         self._sync_selection_mode()
         self.refresh_context_label()
         self._refresh_preset_menu()
+        self.apply_hydrogen_visibility()
         self._configure_overflow_button()
         if self._cmd is None:
             self.setEnabled(False)
@@ -443,6 +466,7 @@ class PymolControlBar(QFrame):
         self.comparison_menu.menuAction().setVisible(normalized.is_comparison)
         if was_comparison or normalized.is_comparison:
             self._run_command("Grid labels", self._sync_grid_labels)
+        self.apply_hydrogen_visibility()
         self.refresh_context_label()
         self._refresh_preset_menu()
 
@@ -473,7 +497,7 @@ class PymolControlBar(QFrame):
             self._cmd.set("grid_mode", int(self._comparison_layout == "grid"))
             slot_names: dict[int, list[str]] = {}
             for obj in self._cmd.get_object_list(self._context.target):
-                if obj in self._grid_label_objects:
+                if obj in self._grid_label_objects or obj in self._preset_objects:
                     continue
                 slot = self._cmd.get_setting_int("grid_slot", obj)
                 if slot > 0:
@@ -555,6 +579,10 @@ class PymolControlBar(QFrame):
                 self._cmd.color(color, f"({temporary}) and elem C")
                 self._cmd.delete(name)
                 self._cmd.set_name(temporary, name)
+                for obj in self._preset_objects & set(self._cmd.get_names("objects")):
+                    if self._cmd.get_setting_int("grid_slot", obj) == slot:
+                        self._cmd.delete(obj)
+                        self._preset_objects.discard(obj)
                 self._context = replace(
                     self._context, grid_labels={**self._context.grid_labels, slot: label},
                 )
@@ -623,6 +651,7 @@ class PymolControlBar(QFrame):
         def apply() -> None:
             self._cmd.hide("everything", target)
             self._cmd.show(normalized, target)
+            self.apply_hydrogen_visibility()
 
         self._run_command(f"Display {normalized}", apply)
 
@@ -636,6 +665,41 @@ class PymolControlBar(QFrame):
             lambda: self._cmd.hide(normalized, self.active_target()),
         )
 
+    def toggle_hydrogens(self) -> None:
+        previous = self._hydrogen_mode
+        modes = ("none", "all", "polar")
+        self._hydrogen_mode = modes[(modes.index(previous) + 1) % len(modes)]
+        if not self.apply_hydrogen_visibility():
+            self._hydrogen_mode = previous
+        mode = self._hydrogen_mode
+        icon = "hydrogens-polar.svg" if mode == "polar" else "hydrogens.svg"
+        self._toolbar_action_icons[self.hydrogens_action] = icon
+        self.hydrogens_action.setIcon(self._toolbar_icon(icon))
+        self.hydrogens_action.setChecked(mode != "none")
+        self.hydrogens_action.setData(mode)
+        state, next_state = {
+            "none": ("hidden", "show all H"),
+            "all": ("all H", "show only polar H"),
+            "polar": ("polar H only (bonded to N, O or S)", "hide all H"),
+        }[mode]
+        self.hydrogens_action.setToolTip(
+            f"Hydrogens: {state}. Click to {next_state} in this PyMOL session."
+        )
+
+    def apply_hydrogen_visibility(self) -> bool:
+        # Enforce the session policy before drawing, including externally loaded objects.
+        polar = "hydro and neighbor (elem N+O+S)"
+        shown = {"none": "", "all": "hydro", "polar": polar}[self._hydrogen_mode]
+        hidden = {"none": "hydro", "all": "", "polar": f"hydro and not ({polar})"}[self._hydrogen_mode]
+
+        def apply() -> None:
+            if hidden and self._cmd.count_atoms(f"({hidden}) and visible"):
+                self._cmd.hide("everything", hidden)
+            if shown and self._cmd.count_atoms(f"({shown}) and not rep sticks"):
+                self._cmd.show("sticks", shown)
+
+        return self._run_command("Hydrogens", apply)
+
     def clear_selection(self) -> None:
         if self._run_command("Clear selection", self._cmd.deselect):
             self.refresh_context_label()
@@ -695,7 +759,38 @@ class PymolControlBar(QFrame):
             )
 
         def apply() -> None:
-            spec.callback(self._cmd, self._context)
+            existing = set(self._cmd.get_names("objects"))
+            for obj in self._preset_objects & existing:
+                self._cmd.delete(obj)
+            self._preset_objects.clear()
+            if self._context.is_comparison and spec.per_grid_slot:
+                slots: dict[int, list[str]] = {}
+                source = " or ".join(f"({s})" for s in self._context.selections.values() if s) or self._context.target
+                for obj in self._cmd.get_object_list(source):
+                    if obj not in self._grid_label_objects:
+                        slot = self._cmd.get_setting_int("grid_slot", obj)
+                        if slot > 0:
+                            slots.setdefault(slot, []).append(obj)
+                if not slots:
+                    spec.callback(self._cmd, self._context)
+                for slot, objects in sorted(slots.items()):
+                    target = " or ".join(objects)
+                    context = replace(
+                        self._context, target=target,
+                        selections={role: f"({selection}) and ({target})"
+                                    for role, selection in self._context.selections.items()},
+                    )
+                    before = set(self._cmd.get_names("objects"))
+                    spec.callback(self._cmd, context)
+                    for obj in set(self._cmd.get_names("objects")) - before:
+                        # PyMOL reuses names such as polar_contacts on its next preset call.
+                        name = self._cmd.get_unused_name(f"{obj}_slot{slot}")
+                        self._cmd.set_name(obj, name)
+                        self._preset_objects.add(name)
+                        associate_scene_objects(self._cmd, [name], reference=objects[0])
+            else:
+                spec.callback(self._cmd, self._context)
+            self.apply_hydrogen_visibility()
             if self._context.is_comparison:
                 self._sync_grid_labels()
 
@@ -714,6 +809,7 @@ class PymolControlBar(QFrame):
                 key=key,
                 label=label,
                 callback=_builtin_preset(method),
+                per_grid_slot=True,
             )
 
     def _sync_selection_mode(self) -> None:
@@ -781,6 +877,7 @@ class PymolDockWidget(MSDockWidget):
             self.cmd.set("internal_gui", False)
 
         self.control_bar = PymolControlBar(self.cmd, self)
+        self.pymol_widget.before_render.connect(self.control_bar.apply_hydrogen_visibility)
         self.toolbar = self.control_bar
         self.pymol_widget.installEventFilter(self)
 
@@ -899,6 +996,7 @@ class PymolDockWidget(MSDockWidget):
 
 __all__ = [
     "COMPARISON_COLORS",
+    "associate_scene_objects",
     "PymolControlBar",
     "PymolDockWidget",
     "PymolPresetSpec",

{ms_components-0.3.2 → ms_components-0.3.4}/src/ms_components/ms_settings/panel.py

@@ -311,8 +311,8 @@ class AppSettingsPanel(QWidget):
                 font-weight: 700;
             }
             QLabel#sourceDefault { color: palette(text); background: rgba(128, 128, 128, 0.18); }
-            QLabel#sourceGlobal { color: #4c9be8; background: rgba(76, 155, 232, 0.16); }
-            QLabel#sourceProject { color: #34c88a; background: rgba(52, 200, 138, 0.16); }
+            QLabel#sourceGlobal { background: rgba(76, 155, 232, 0.16); }
+            QLabel#sourceProject { background: rgba(52, 200, 138, 0.16); }
             """
         )
 
@@ -743,6 +743,7 @@ class AppSettingsPanel(QWidget):
         normalized = source if source in _SOURCE_LABELS else "default"
         label.setText(_SOURCE_LABELS[normalized])
         label.setObjectName(f"source{normalized.title()}")
+        label.setProperty("tone", {"global": "blue", "project": "green"}.get(normalized, ""))  # theme text hue
         label.style().unpolish(label)
         label.style().polish(label)
 

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

@@ -24,6 +24,10 @@ from .table_config import (
 )
 
 
+# Past this many rows a DuckDB seek numbers the rows instead of an ORDER BY + OFFSET.
+DUCKDB_RANK_FROM = 100_000
+
+
 class QueryBuilder:
     """Builds and runs paginated queries from a TableConfig.
 
@@ -147,7 +151,8 @@ class QueryBuilder:
             return []
         stmt = self._build_base_statement().with_only_columns(pk)
         with self._db.get_session() as session:
-            return [int(value) for value in session.exec(stmt).all() if value is not None]
+            # scalars(): with expr columns the base select has several entities and exec() yields Rows.
+            return [int(value) for value in session.scalars(stmt).all() if value is not None]
 
     def count(self) -> int:
         """Row total under the current filters/search, without fetching any row.
@@ -205,19 +210,51 @@ class QueryBuilder:
         has_more = len(raw) > self._page_size
         return [self._row_to_dict(row) for row in raw[:self._page_size]], has_more
 
-    def fetch_window_at(self, page_index: int) -> tuple[list[dict], bool]:
+    def fetch_window_at(self, page_index: int, anchor: tuple[Any, Any] | None = None,
+                        anchor_page: int = 0) -> tuple[list[dict], bool]:
         """Direct load for a scrollbar jump to a page that has not been walked yet.
 
-        The normal path is still keyset via :meth:`fetch_window_after`. OFFSET only
-        shows up when the user drags the scrollbar to a position with no known
-        cursor.
+        `anchor` is the keyset cursor that starts `anchor_page` (None = the top). The
+        walk from it to the target reads only (sort value, pk) - never whole rows -
+        and then the page itself is a keyset seek, so jumping to the end of a 4M-row
+        table no longer materializes 4M rows.
         """
-        offset = max(0, int(page_index)) * self._page_size
-        stmt = self._build_base_statement().offset(offset).limit(self._page_size + 1)
+        offset = max(0, int(page_index) - int(anchor_page)) * self._page_size
+        if self._get_pk_attr() is None:  # no keyset possible: plain OFFSET
+            stmt = self._build_base_statement().offset(int(page_index) * self._page_size)
+            with self._db.get_session() as session:
+                raw = session.exec(stmt.limit(self._page_size + 1)).all()
+            return [self._row_to_dict(row) for row in raw[:self._page_size]], len(raw) > self._page_size
+        cursor = self._seek(anchor, offset) if offset else anchor
+        if offset and cursor is None:
+            return [], False  # past the end (rows vanished under the scrollbar)
+        return self.fetch_window_after(cursor)
+
+    def _seek(self, anchor: tuple[Any, Any] | None, offset: int) -> tuple[Any, Any] | None:
+        """Cursor of the `offset`-th row after `anchor`, reading only the key columns."""
+        pk = self._get_pk_attr()
+        attr = self._resolve_attr(self._sorts[0].field) if self._sorts else None
+        keys = [attr.label("_seek_sort") if attr is not None else None, pk.label("_seek_pk")]
+        stmt = self._build_base_statement()
+        clause = self._keyset_clause(anchor)
+        if clause is not None:
+            stmt = stmt.where(clause)
         with self._db.get_session() as session:
-            raw = session.exec(stmt).all()
-        has_more = len(raw) > self._page_size
-        return [self._row_to_dict(row) for row in raw[:self._page_size]], has_more
+            if offset > DUCKDB_RANK_FROM and session.get_bind().dialect.name == "duckdb":
+                # DuckDB turns ORDER BY + OFFSET into a top-N heap the size of the offset
+                # (2.3 s at 3.85M rows); numbering the rows sorts once (0.2-0.7 s), which
+                # loses to the heap on short walks. SQLite: OFFSET 0.3 s, row_number() 2 s.
+                rank = func.row_number().over(order_by=self._order_clauses()).label("_seek_rank")
+                inner = stmt.with_only_columns(*[k for k in keys if k is not None], rank) \
+                    .order_by(None).subquery()
+                row = session.execute(select(*[c for c in inner.c if c.name != "_seek_rank"])
+                                   .where(inner.c._seek_rank == offset)).first()
+            else:
+                row = session.execute(stmt.with_only_columns(*[k for k in keys if k is not None])
+                                   .offset(offset - 1).limit(1)).first()
+        if row is None:
+            return None
+        return (row[0], row[1]) if attr is not None else (None, row[0])
 
     def _keyset_clause(self, cursor: tuple[Any, Any] | None):
         if cursor is None:
@@ -240,20 +277,19 @@ class QueryBuilder:
             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))
+        # The redundant `attr >= value` is what lets SQLite seek the index when the values
+        # are bound parameters (without it: a SCAN, 0.2 s per page at 3.85M rows) and
+        # DuckDB prune row groups by zone map.
+        # ponytail: descending keeps its `IS NULL` arm and so its scan; same fix needs the
+        # null tail fetched as a second query.
+        return and_(attr >= sort_value, 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)."""
-        stmt      = self._build_base_statement()
-        count_stmt = self._build_count_statement()
         with self._db.get_session() as session:
-            total: int = session.exec(count_stmt).one()  # type: ignore[arg-type]
-
-            offset = (self._page - 1) * self._page_size
-            stmt   = stmt.offset(offset).limit(self._page_size)
+            total: int = session.exec(self._build_count_statement()).one()  # type: ignore[arg-type]
 
-            raw_rows = session.exec(stmt).all()
-            rows     = [self._row_to_dict(r) for r in raw_rows]
+        rows, _has_more = self.fetch_window_at(self._page - 1)
         return rows, total
 
     # ──────────────────────────────────────────
@@ -302,24 +338,20 @@ class QueryBuilder:
         if search_clause is not None:
             stmt = stmt.where(search_clause)
 
-        # ORDER BY
-        if self._sorts:
-            for sort in self._sorts:
-                attr = self._resolve_attr(sort.field)
-                if attr is not None:
-                    stmt = stmt.order_by(attr.desc() if sort.descending else attr.asc())
-            # PK tie-break: without it two rows with the same score have undefined
-            # order and the keyset cursor skips or repeats rows across pages.
-            pk = self._get_pk_attr()
-            if pk is not None:
-                stmt = stmt.order_by(pk)
-        else:
-            # Default order: primary key of the main table
-            pk = self._get_pk_attr()
-            if pk is not None:
-                stmt = stmt.order_by(pk)
+        return stmt.order_by(*self._order_clauses())
 
-        return stmt
+    def _order_clauses(self) -> list:
+        clauses = []
+        for sort in self._sorts:
+            attr = self._resolve_attr(sort.field)
+            if attr is not None:
+                clauses.append(attr.desc() if sort.descending else attr.asc())
+        # PK tie-break (and default order): without it two rows with the same score have
+        # undefined order and the keyset cursor skips or repeats rows across pages.
+        pk = self._get_pk_attr()
+        if pk is not None:
+            clauses.append(pk)
+        return clauses
 
     def _build_count_statement(self):
         model = self._config.model_class