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

{ms_components-0.3.0 → ms_components-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.0
+Version: 0.3.1
 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/docs/api_reference.md

@@ -0,0 +1,102 @@
+# API reference
+
+The reference below is generated directly from the current Python sources.
+Names beginning with an underscore are implementation details.
+
+## Smart table
+
+::: ms_components.ms_table
+
+## Monitor
+
+::: ms_components.ms_monitor
+
+## Hosts and executors
+
+::: ms_components.ms_executors
+
+## Projects
+
+::: ms_components.ms_projects
+
+## Settings
+
+::: ms_components.ms_settings
+
+## PyMOL
+
+::: ms_components.ms_pymol
+
+Comparison scenes provide grid and overlay layouts without reloading structures
+or changing the camera. Assign each structure/pose pair the same positive PyMOL
+`grid_slot`, then pass its display name:
+
+```python
+dock.set_scene_context(
+    "comparison",
+    grid_labels={1: "Complex A", 3: "Complex B"},
+)
+dock.set_comparison_layout("overlay")
+```
+
+`grid_labels` is also accepted by `PymolControlBar` and `PymolSceneContext`.
+Without explicit labels, molecular object titles (or object names when no title
+is available) are joined per positive `grid_slot` within the context's `target`.
+Applications must pass display names if those names are not present in PyMOL.
+
+The **Display > Comparison > Grid / Overlay** menu appears only in comparison
+scenes. The chosen layout persists when changing poses or applying presets.
+Overlay displays the existing coordinates together; alignment remains the
+caller's responsibility.
+
+Each label is a pseudoatom named `panel_text<slot>`, initially sized 14.
+Grid labels appear at the top-left of their panel; overlay labels form a stacked
+legend that follows viewport resizing. Receptor cartoons, carbon atoms and label
+text share the slot's `COMPARISON_COLORS` color. Heteroatom colors are preserved.
+The label outline uses PyMOL's background-adaptive `front` color for readability
+on light and dark backgrounds. The palette has ten colors and repeats beyond ten
+slots.
+Existing labels are updated in place, so individual settings remain editable,
+for example `cmd.set("label_size", 18, "panel_text3")`. Presets restore label
+visibility after changing molecular representations.
+
+To replace one pose without rebuilding the scene, pass its bytes directly:
+
+```python
+dock.replace_comparison_object(
+    "pose_a", pdb_bytes, "pdb",
+    reference="receptor_a", label="Complex A [P2]",
+)
+```
+
+The new object inherits the reference's transformation and slot, is shown as
+sticks, and receives the same comparison color. Camera and auto-zoom settings
+are preserved. The previous object remains available until the replacement loads
+successfully. This API neither fetches data nor calls the hosting application.
+Hosts remain responsible for reading their data and discarding stale requests.
+
+Setting any non-comparison scene context after a comparison context removes
+the managed labels and sets `grid_mode` to zero. Applications should update
+the scene context when leaving their off-target view, even without loading a
+new structure. Unrelated grid scenes and user-created annotations are not
+removed. `"offtarget"` remains accepted as an alias for `"comparison"`.
+
+## Stepper
+
+::: ms_components.ms_stepper
+
+## Guided tutorials
+
+::: ms_components.ms_tutorial
+
+## Tool panel
+
+::: ms_components.tool_panel
+
+## Step dialog
+
+::: ms_components.step_dialog
+
+## Theme
+
+::: ms_components.theme

{ms_components-0.3.0 → ms_components-0.3.1}/docs/usage.md

@@ -178,6 +178,19 @@ panel.show()
 
 ## Projects, settings, and PyMOL
 
+Applications embedding PyMOL should call
+`ms_components.opengl.prepare_pymol_opengl()` **before creating `QApplication`**.
+It requests desktop OpenGL and shared contexts, then checks the actual context
+and compiles legacy GLSL shaders in an isolated process. A failed native check
+can select `xcb` on Linux only when an X11 display passes the same check and
+`QT_QPA_PLATFORM` was not explicitly set. Windows and macOS retain their native
+platforms. If no tested backend works, it raises `RuntimeError` before the
+application starts. Skip this call when PyMOL is disabled or running headlessly.
+
+`PymolDockWidget` also requests desktop OpenGL on its own widget and validates
+the actual context before drawing. An incompatible context displays an error
+in the viewer instead of passing it to PyMOL.
+
 - `ProjectsMenuWidget(app_id=...)` and `ProjectBrowserWindow(app_id=...)` list
   and create projects through the public `ms_flow` project catalog. Connect
   `project_requested` to open the chosen project; do not read the MolSuite

{ms_components-0.3.0 → ms_components-0.3.1}/src/ms_components/ms_pymol/__init__.py

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

{ms_components-0.3.0 → ms_components-0.3.1}/src/ms_components/ms_pymol/widget.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
+import logging
 import os
 from collections.abc import Callable, Mapping
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
 from ms_components.ms_dockwidget.widget import MSDockWidget
+from ms_components.opengl import pymol_context_error, pymol_surface_format
 
 os.environ.setdefault("QT_API", "pyside6")
 
 from PySide6.QtCore import QByteArray, QEvent, QSize, Qt, QTimer, Signal
-from PySide6.QtGui import QAction, QActionGroup, QIcon, QPainter, QPixmap
+from PySide6.QtGui import QAction, QActionGroup, QGuiApplication, QIcon, QPainter, QPixmap
 from PySide6.QtSvg import QSvgRenderer
 from PySide6.QtWidgets import (
     QFrame,
@@ -36,6 +38,44 @@ except ImportError:
 from . import plugins as _pymol_plugins  # noqa: F401
 
 
+class _PymolGLWidget(PyMOLGLWidget):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self._opengl_error: str | None = None
+        self._opengl_error_label: QLabel | None = None
+        if hasattr(self, "setFormat"):
+            self.setFormat(pymol_surface_format(self.format()))
+
+    def initializeGL(self):
+        context = self.context()
+        self._opengl_error = pymol_context_error(context)
+        if self._opengl_error_label is not None:
+            self._opengl_error_label.hide()
+        if self._opengl_error:
+            logging.getLogger(__name__).error(self._opengl_error)
+            if self._opengl_error_label is None:
+                self._opengl_error_label = QLabel(self)
+                self._opengl_error_label.setWordWrap(True)
+                QVBoxLayout(self).addWidget(self._opengl_error_label)
+            self._opengl_error_label.setText(f"PyMOL viewer unavailable.\n{self._opengl_error}")
+            self._opengl_error_label.show()
+            return
+        fmt = context.format()
+        logging.getLogger(__name__).info(
+            "PyMOL context: %s, OpenGL %s.%s %s",
+            QGuiApplication.platformName(), *fmt.version(), fmt.profile().name,
+        )
+        super().initializeGL()
+
+    def paintGL(self):
+        if self._opengl_error is None:
+            super().paintGL()
+
+    def resizeGL(self, width, height):
+        if self._opengl_error is None:
+            super().resizeGL(width, height)
+
+
 SELECTION_MODES = (
     ("Atoms", 0),
     ("Residues", 1),
@@ -53,6 +93,10 @@ REPRESENTATIONS = (
 )
 
 _TOOLBAR_ICONS = Path(__file__).parent / "icons"
+COMPARISON_COLORS = (
+    "orange", "tv_green", "cyan", "magenta", "yellow",
+    "salmon", "violet", "lime", "deepteal", "hotpink",
+)
 
 
 @dataclass(frozen=True)
@@ -61,6 +105,11 @@ class PymolSceneContext:
     target: str = "all"
     selections: Mapping[str, str] = field(default_factory=dict)
     default_preset: str = ""
+    grid_labels: Mapping[int, str] = field(default_factory=dict)
+
+    @property
+    def is_comparison(self) -> bool:
+        return self.kind in {"comparison", "offtarget"}
 
     def selection(self, role: str, fallback: str = "") -> str:
         value = str(dict(self.selections or {}).get(str(role)) or "").strip()
@@ -100,6 +149,8 @@ class PymolControlBar(QFrame):
         super().__init__(parent)
         self._cmd = cmd
         self._context = PymolSceneContext()
+        self._grid_label_objects: set[str] = set()
+        self._comparison_layout = "grid"
         self._presets: dict[str, PymolPresetSpec] = {}
         self.setObjectName("PymolControlBar")
 
@@ -168,6 +219,18 @@ class PymolControlBar(QFrame):
             "Apply a representation to the current selection or scene target.",
             menu=representation_menu,
         )
+        self.comparison_menu = representation_menu.addMenu("Comparison")
+        self.comparison_menu.menuAction().setVisible(False)
+        comparison_group = QActionGroup(self.comparison_menu)
+        comparison_group.setExclusive(True)
+        self._comparison_layout_actions: dict[str, QAction] = {}
+        for label, value in (("Grid", "grid"), ("Overlay", "overlay")):
+            action = self.comparison_menu.addAction(label)
+            action.setCheckable(True)
+            action.setChecked(value == self._comparison_layout)
+            comparison_group.addAction(action)
+            action.triggered.connect(lambda checked=False, layout=value: self.set_comparison_layout(layout))
+            self._comparison_layout_actions[value] = action
 
         hide_menu = QMenu("Hide", bar)
         for label, value in (("Everything", "everything"), *REPRESENTATIONS):
@@ -359,6 +422,7 @@ class PymolControlBar(QFrame):
         target: str = "all",
         selections: Mapping[str, str] | None = None,
         default_preset: str = "",
+        grid_labels: Mapping[int, str] | None = None,
     ) -> None:
         if isinstance(context, PymolSceneContext):
             normalized = context
@@ -372,11 +436,136 @@ class PymolControlBar(QFrame):
                     if str(key).strip() and str(value).strip()
                 },
                 default_preset=str(default_preset or "").strip(),
+                grid_labels=dict(grid_labels or {}),
             )
+        was_comparison = self._context.is_comparison
         self._context = normalized
+        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.refresh_context_label()
         self._refresh_preset_menu()
 
+    @property
+    def comparison_layout(self) -> str:
+        return self._comparison_layout
+
+    def set_comparison_layout(self, layout: str) -> None:
+        if layout not in self._comparison_layout_actions:
+            raise ValueError(f"Unsupported comparison layout: {layout}")
+        if not self._context.is_comparison:
+            raise ValueError("A comparison scene is required to change its layout.")
+        previous = self._comparison_layout
+        self._comparison_layout = layout
+
+        def apply() -> None:
+            self._sync_grid_labels()
+            self._cmd.refresh()
+
+        if not self._run_command("Comparison layout", apply):
+            self._comparison_layout = previous
+        for value, action in self._comparison_layout_actions.items():
+            action.setChecked(value == self._comparison_layout)
+
+    def _sync_grid_labels(self, *, color_objects: bool = True) -> None:
+        labels = dict(self._context.grid_labels)
+        if self._context.is_comparison:
+            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:
+                    continue
+                slot = self._cmd.get_setting_int("grid_slot", obj)
+                if slot > 0:
+                    color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+                    if color_objects:
+                        self._cmd.set("cartoon_color", color, selection=obj)
+                        self._cmd.color(color, f"({obj}) and elem C")
+                    slot_names.setdefault(slot, []).append(self._cmd.get_title(obj, 1) or obj)
+            if not labels:
+                labels = {slot: " + ".join(names) for slot, names in slot_names.items()}
+        else:
+            labels = {}
+            self._cmd.set("grid_mode", 0)
+
+        wanted = {f"panel_text{slot}" for slot in labels}
+        for obj in self._grid_label_objects - wanted:
+            self._cmd.delete(obj)
+        self._grid_label_objects.intersection_update(wanted)
+        existing = set(self._cmd.get_names("objects"))
+        for slot, title in sorted(labels.items()):
+            if slot <= 0:
+                raise ValueError("Grid label slots must be positive integers.")
+            obj = f"panel_text{slot}"
+            if obj not in existing:
+                self._cmd.pseudoatom(obj, label=title)
+                self._grid_label_objects.add(obj)
+                self._cmd.hide("everything", obj)
+                self._cmd.set("label_relative_mode", 1, selection=obj)
+                self._cmd.set("label_size", 14, selection=obj)
+                self._cmd.set("label_position", [1, -1, 0], selection=obj)
+                self._cmd.set("grid_slot", slot, selection=obj)
+            elif obj in self._grid_label_objects:
+                self._cmd.label(obj, repr(title))
+            else:
+                raise ValueError(f"Grid label object '{obj}' already exists.")
+            color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+            self._cmd.set("label_color", color, selection=obj)
+            self._cmd.set("label_outline_color", "front", selection=obj)
+            self._cmd.show("labels", obj)
+        self._position_comparison_labels()
+
+    def _position_comparison_labels(self) -> None:
+        if not self._context.is_comparison:
+            return
+        existing = set(self._cmd.get_names("objects"))
+        height = max(1, self._cmd.get_viewport()[1])
+        offset = 0.0
+        for obj in sorted(self._grid_label_objects & existing,
+                          key=lambda name: self._cmd.get_setting_int("grid_slot", name)):
+            self._cmd.set("label_screen_point", [-1, 1 - offset, 0], selection=obj)
+            if self._comparison_layout == "overlay":
+                offset += 2 * (abs(self._cmd.get_setting_float("label_size", obj)) + 6) / height
+
+    def replace_comparison_object(
+        self, name: str, data: bytes, fmt: str, *, reference: str, label: str,
+    ) -> bool:
+        def apply() -> None:
+            if not self._context.is_comparison:
+                raise ValueError("A comparison scene is required to replace an object.")
+            objects = self._cmd.get_names("objects")
+            if name not in objects or reference not in objects:
+                raise ValueError("The comparison object and its reference must already exist.")
+            if name == reference:
+                raise ValueError("The comparison object must differ from its reference.")
+            slot = self._cmd.get_setting_int("grid_slot", reference)
+            if slot <= 0:
+                raise ValueError("The comparison reference must have a positive grid slot.")
+            auto_zoom = self._cmd.get_setting_int("auto_zoom")
+            temporary = self._cmd.get_unused_name("_comparison_pose")
+            try:
+                self._cmd.set("auto_zoom", 0)
+                self._cmd.load_raw(data, fmt, temporary)
+                self._cmd.matrix_copy(reference, temporary)
+                self._cmd.set("grid_slot", slot, temporary)
+                self._cmd.show("sticks", temporary)
+                self._cmd.color("atomic", temporary)
+                color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+                self._cmd.set("cartoon_color", color, temporary)
+                self._cmd.color(color, f"({temporary}) and elem C")
+                self._cmd.delete(name)
+                self._cmd.set_name(temporary, name)
+                self._context = replace(
+                    self._context, grid_labels={**self._context.grid_labels, slot: label},
+                )
+                self._sync_grid_labels(color_objects=False)
+            finally:
+                if temporary in self._cmd.get_names("objects"):
+                    self._cmd.delete(temporary)
+                self._cmd.set("auto_zoom", auto_zoom)
+
+        return self._run_command("Replace comparison object", apply)
+
     def register_preset(self, spec: PymolPresetSpec) -> None:
         key = str(spec.key or "").strip()
         if not key:
@@ -507,6 +696,8 @@ class PymolControlBar(QFrame):
 
         def apply() -> None:
             spec.callback(self._cmd, self._context)
+            if self._context.is_comparison:
+                self._sync_grid_labels()
 
         if self._run_command(spec.label, apply):
             self.preset_applied.emit(normalized_key)
@@ -585,13 +776,13 @@ class PymolDockWidget(MSDockWidget):
 
     def __init__(self, title: str, manager, parent=None):
         super().__init__(title, manager, parent)
-        self.pymol_widget = PyMOLGLWidget(self)
-        self.pymol_widget.installEventFilter(self)
+        self.pymol_widget = _PymolGLWidget(self)
         if self.cmd is not None:
             self.cmd.set("internal_gui", False)
 
         self.control_bar = PymolControlBar(self.cmd, self)
         self.toolbar = self.control_bar
+        self.pymol_widget.installEventFilter(self)
 
         self._side_panel_widget: QWidget | None = None
         self._splitter = QSplitter(Qt.Horizontal, self)
@@ -640,17 +831,31 @@ class PymolDockWidget(MSDockWidget):
         target: str = "all",
         selections: Mapping[str, str] | None = None,
         default_preset: str = "",
+        grid_labels: Mapping[int, str] | None = None,
     ) -> None:
         self.control_bar.set_scene_context(
             context,
             target=target,
             selections=selections,
             default_preset=default_preset,
+            grid_labels=grid_labels,
         )
 
     def register_preset(self, spec: PymolPresetSpec) -> None:
         self.control_bar.register_preset(spec)
 
+    def set_comparison_layout(self, layout: str) -> None:
+        self.control_bar.set_comparison_layout(layout)
+
+    @property
+    def comparison_layout(self) -> str:
+        return self.control_bar.comparison_layout
+
+    def replace_comparison_object(
+        self, name: str, data: bytes, fmt: str, *, reference: str, label: str,
+    ) -> bool:
+        return self.control_bar.replace_comparison_object(name, data, fmt, reference=reference, label=label)
+
     def unregister_preset(self, key: str) -> None:
         self.control_bar.unregister_preset(key)
 
@@ -687,10 +892,13 @@ class PymolDockWidget(MSDockWidget):
     def eventFilter(self, watched, event):
         if watched is self.pymol_widget and event.type() == QEvent.Type.MouseButtonRelease:
             QTimer.singleShot(0, self.control_bar.refresh_context_label)
+        elif watched is self.pymol_widget and event.type() == QEvent.Type.Resize and self.scene_context.is_comparison:
+            QTimer.singleShot(0, self.control_bar._position_comparison_labels)
         return super().eventFilter(watched, event)
 
 
 __all__ = [
+    "COMPARISON_COLORS",
     "PymolControlBar",
     "PymolDockWidget",
     "PymolPresetSpec",

ms_components-0.3.1/src/ms_components/opengl.py

@@ -0,0 +1,139 @@
+"""Desktop OpenGL setup and an isolated compatibility check for embedded PyMOL."""
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from PySide6.QtCore import QCoreApplication, Qt
+from PySide6.QtGui import QOpenGLContext, QSurfaceFormat
+
+_log = logging.getLogger(__name__)
+
+
+def pymol_surface_format(base: QSurfaceFormat | None = None) -> QSurfaceFormat:
+    """Keep stereo/multisampling while requesting the desktop API used by PyMOL's shaders."""
+    fmt = QSurfaceFormat(base) if base is not None else QSurfaceFormat()
+    fmt.setRenderableType(QSurfaceFormat.RenderableType.OpenGL)
+    fmt.setVersion(2, 1)
+    fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.NoProfile)
+    fmt.setDepthBufferSize(24)
+    fmt.setStencilBufferSize(8)
+    return fmt
+
+
+def configure_pymol_opengl() -> None:
+    """Call before QApplication so Qt's shared contexts use the same desktop API."""
+    QSurfaceFormat.setDefaultFormat(pymol_surface_format())
+    QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts, True)
+
+
+def pymol_context_error(context: QOpenGLContext | None) -> str | None:
+    """Check the actual context, since drivers can ignore the requested format."""
+    if context is None or not context.isValid():
+        return "Qt could not create a valid OpenGL context."
+    fmt = context.format()
+    if context.isOpenGLES():
+        return "PyMOL requires desktop OpenGL; Qt provided OpenGL ES."
+    if fmt.version() < (2, 1):
+        return "PyMOL requires an OpenGL 2.1 or newer compatibility context."
+    if fmt.version() >= (3, 2) and fmt.profile() != QSurfaceFormat.OpenGLContextProfile.CompatibilityProfile:
+        return "PyMOL's legacy shaders require a compatibility context, not OpenGL Core."
+    return None
+
+
+def _probe(platform: str | None = None) -> tuple[bool, str]:
+    env = os.environ.copy()
+    if platform is not None:
+        env["QT_QPA_PLATFORM"] = platform
+    try:
+        result = subprocess.run(
+            [sys.executable, str(Path(__file__).resolve())],
+            env=env, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, str(exc)
+    detail = result.stdout.strip()
+    if result.returncode:
+        detail = f"OpenGL probe exited with {result.returncode}: {detail}\n{result.stderr[-2000:]}".strip()
+    return result.returncode == 0, detail
+
+
+def prepare_pymol_opengl() -> None:
+    """Verify the native backend first; select X11 only after a successful fallback probe."""
+    from PySide6.QtWidgets import QApplication
+
+    if QApplication.instance() is not None:
+        raise RuntimeError("PyMOL OpenGL must be prepared before QApplication is created.")
+    configure_pymol_opengl()
+    supported, detail = _probe()
+    print(f"PyMOL OpenGL: {detail}", file=sys.stderr)
+    if supported:
+        return
+    if sys.platform.startswith("linux") and os.environ.get("DISPLAY") and not os.environ.get("QT_QPA_PLATFORM"):
+        supported, fallback_detail = _probe("xcb")
+        if supported:
+            os.environ["QT_QPA_PLATFORM"] = "xcb"
+            _log.warning("Native OpenGL check failed; using X11 for PyMOL: %s", fallback_detail)
+            return
+        detail += f"\nX11 fallback: {fallback_detail}"
+    raise RuntimeError(f"No compatible OpenGL context is available for PyMOL.\n{detail}")
+
+
+def _main() -> int:
+    # The driver or Qt platform plugin may abort; only this short-lived process is at risk.
+    from PySide6.QtGui import QOffscreenSurface
+    from PySide6.QtOpenGL import QOpenGLShader, QOpenGLShaderProgram
+    from PySide6.QtWidgets import QApplication
+
+    configure_pymol_opengl()
+    app = QApplication(["pymol-opengl-check"])
+    context = QOpenGLContext()
+    context.setFormat(QSurfaceFormat.defaultFormat())
+    context.setShareContext(QOpenGLContext.globalShareContext())
+    if not context.create():
+        print(f"{app.platformName()}: context creation failed", flush=True)
+        return 1
+    surface = QOffscreenSurface()
+    surface.setFormat(context.format())
+    surface.create()
+    if not surface.isValid() or not context.makeCurrent(surface):
+        print(f"{app.platformName()}: could not activate the OpenGL context", flush=True)
+        return 1
+    try:
+        error = pymol_context_error(context)
+        if error is None:
+            # Exercise the legacy GLSL built-ins rejected in an ES or core-only context.
+            shader = QOpenGLShaderProgram()
+            vertex_ok = shader.addShaderFromSourceCode(QOpenGLShader.Vertex, """
+                #version 120
+                void main() {
+                    gl_Position = gl_Vertex;
+                    gl_FrontColor = gl_Color;
+                    gl_BackColor = gl_Color;
+                }
+            """)
+            fragment_ok = shader.addShaderFromSourceCode(QOpenGLShader.Fragment, """
+                #version 120
+                void main() { gl_FragColor = gl_Color; }
+            """)
+            if not vertex_ok or not fragment_ok or not shader.link():
+                error = f"PyMOL's required legacy GLSL features are unavailable: {shader.log()}"
+            shader.removeAllShaders()
+        fmt = context.format()
+        functions = context.functions()
+        print(
+            f"{app.platformName()}: OpenGL {fmt.majorVersion()}.{fmt.minorVersion()} "
+            f"{fmt.profile().name}; {functions.glGetString(0x1F00)}; "
+            f"{functions.glGetString(0x1F01)}; {error or 'compatible'}",
+            flush=True,
+        )
+        return int(error is not None)
+    finally:
+        context.doneCurrent()
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.0
+Version: 0.3.1
 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.0 → ms_components-0.3.1}/src/ms_components.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/ms_components/chips.py
 src/ms_components/listview.py
 src/ms_components/ms_executors.py
 src/ms_components/ms_stepper.py
+src/ms_components/opengl.py
 src/ms_components/pagination.py
 src/ms_components/palettes.py
 src/ms_components/step_dialog.py
@@ -108,8 +109,10 @@ tests/test_molsuite_monitor_bridge.py
 tests/test_molsuite_monitor_widgets.py
 tests/test_monitor_config.py
 tests/test_ms_projects_widget.py
+tests/test_opengl.py
 tests/test_progress_column.py
 tests/test_project_browser.py
+tests/test_pymol_grid.py
 tests/test_pymol_toolbar.py
 tests/test_query_builder_keyset.py
 tests/test_shift_hscroll.py

{ms_components-0.3.0 → ms_components-0.3.1}/src/ms_components.egg-info/scm_file_list.json

@@ -88,6 +88,7 @@
     "src/ms_components/ms_tutorial/controller.py",
     "src/ms_components/ms_tutorial/models.py",
     "src/ms_components/ms_tutorial/overlay.py",
+    "src/ms_components/opengl.py",
     "src/ms_components/pagination.py",
     "src/ms_components/palettes.py",
     "src/ms_components/step_dialog.py",
@@ -102,8 +103,10 @@
     "tests/test_molsuite_monitor_widgets.py",
     "tests/test_monitor_config.py",
     "tests/test_ms_projects_widget.py",
+    "tests/test_opengl.py",
     "tests/test_progress_column.py",
     "tests/test_project_browser.py",
+    "tests/test_pymol_grid.py",
     "tests/test_pymol_toolbar.py",
     "tests/test_query_builder_keyset.py",
     "tests/test_shift_hscroll.py",

ms_components-0.3.1/src/ms_components.egg-info/scm_version.json

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