openms-insight 0.1.10__tar.gz → 0.1.11__tar.gz

{openms_insight-0.1.10 → openms_insight-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openms-insight
-Version: 0.1.10
+Version: 0.1.11
 Summary: Interactive visualization components for mass spectrometry data in Streamlit
 Project-URL: Homepage, https://github.com/t0mdavid-m/OpenMS-Insight
 Project-URL: Documentation, https://github.com/t0mdavid-m/OpenMS-Insight#readme
@@ -243,7 +243,9 @@ Heatmap(
 - `min_points`: Target size for downsampling (default: 20000)
 - `x_bins`, `y_bins`: Grid resolution for spatial binning
 - `colorscale`: Plotly colorscale name (default: 'Portland')
+- `reversescale`: Invert colorscale direction (default: False)
 - `log_scale`: Use log10 color mapping (default: True). Set to False for linear.
+- `low_values_on_top`: Prioritize low values during downsampling and display them on top (default: False). Use for scores where lower = better (e.g., e-values, PEP, q-values).
 - `intensity_label`: Custom colorbar label (default: 'Intensity')
 
 **Linear scale example:**
@@ -260,6 +262,24 @@ Heatmap(
 )
 ```
 
+**Low values on top (PSM scores):**
+For identification results where lower scores indicate better matches (e.g., e-values, PEP, q-values), use `low_values_on_top=True` to preserve low-scoring points during downsampling and display them on top of high-scoring points:
+
+```python
+Heatmap(
+    cache_id="psm_evalue",
+    data_path="psm_data.parquet",
+    x_column='rt',
+    y_column='mz',
+    intensity_column='e_value',
+    log_scale=True,               # Log scale for e-values
+    low_values_on_top=True,       # Keep/show low e-values (best hits)
+    reversescale=True,            # Bright color = low value = best
+    intensity_label='E-value',
+    colorscale='Portland',
+)
+```
+
 **Categorical mode:**
 Use `category_column` for discrete coloring by category instead of continuous intensity colorscale:
 

{openms_insight-0.1.10 → openms_insight-0.1.11}/README.md

@@ -208,7 +208,9 @@ Heatmap(
 - `min_points`: Target size for downsampling (default: 20000)
 - `x_bins`, `y_bins`: Grid resolution for spatial binning
 - `colorscale`: Plotly colorscale name (default: 'Portland')
+- `reversescale`: Invert colorscale direction (default: False)
 - `log_scale`: Use log10 color mapping (default: True). Set to False for linear.
+- `low_values_on_top`: Prioritize low values during downsampling and display them on top (default: False). Use for scores where lower = better (e.g., e-values, PEP, q-values).
 - `intensity_label`: Custom colorbar label (default: 'Intensity')
 
 **Linear scale example:**
@@ -225,6 +227,24 @@ Heatmap(
 )
 ```
 
+**Low values on top (PSM scores):**
+For identification results where lower scores indicate better matches (e.g., e-values, PEP, q-values), use `low_values_on_top=True` to preserve low-scoring points during downsampling and display them on top of high-scoring points:
+
+```python
+Heatmap(
+    cache_id="psm_evalue",
+    data_path="psm_data.parquet",
+    x_column='rt',
+    y_column='mz',
+    intensity_column='e_value',
+    log_scale=True,               # Log scale for e-values
+    low_values_on_top=True,       # Keep/show low e-values (best hits)
+    reversescale=True,            # Bright color = low value = best
+    intensity_label='E-value',
+    colorscale='Portland',
+)
+```
+
 **Categorical mode:**
 Use `category_column` for discrete coloring by category instead of continuous intensity colorscale:
 

{openms_insight-0.1.10 → openms_insight-0.1.11}/openms_insight/__init__.py

@@ -16,7 +16,7 @@ from .core.registry import get_component_class, register_component
 from .core.state import StateManager
 from .rendering.bridge import clear_component_annotations, get_component_annotations
 
-__version__ = "0.1.7"
+__version__ = "0.1.11"
 
 __all__ = [
     # Core

{openms_insight-0.1.10 → openms_insight-0.1.11}/openms_insight/components/heatmap.py

@@ -93,6 +93,7 @@ class Heatmap(BaseComponent):
         category_column: Optional[str] = None,
         category_colors: Optional[Dict[str, str]] = None,
         log_scale: bool = True,
+        low_values_on_top: bool = False,
         intensity_label: Optional[str] = None,
         **kwargs,
     ):
@@ -148,6 +149,11 @@ class Heatmap(BaseComponent):
                 If not provided, default Plotly colors will be used.
             log_scale: If True (default), apply log10 transformation to intensity
                 values for color mapping. Set to False for linear color mapping.
+            low_values_on_top: If True, invert the intensity priority for both downsampling
+                and display order. Default False keeps high-intensity points during
+                downsampling and draws them on top. Set to True when lower values are
+                "better" (e.g., e-values, PEP scores, q-values) so that low values are
+                preserved during downsampling and appear on top of high values.
             intensity_label: Custom label for the colorbar. Default is "Intensity".
                 Useful when displaying non-intensity values like scores or counts.
             **kwargs: Additional configuration options
@@ -169,6 +175,7 @@ class Heatmap(BaseComponent):
         self._category_column = category_column
         self._category_colors = category_colors or {}
         self._log_scale = log_scale
+        self._low_values_on_top = low_values_on_top
         self._intensity_label = intensity_label
         self._use_streaming = use_streaming
         self._categorical_filters = categorical_filters or []
@@ -228,6 +235,7 @@ class Heatmap(BaseComponent):
             "colorscale": self._colorscale,
             "category_column": self._category_column,
             "log_scale": self._log_scale,
+            "low_values_on_top": self._low_values_on_top,
             "intensity_label": self._intensity_label,
             # Note: category_colors is render-time styling, doesn't affect cache
         }
@@ -253,6 +261,7 @@ class Heatmap(BaseComponent):
         self._colorscale = config.get("colorscale", "Portland")
         self._category_column = config.get("category_column")
         self._log_scale = config.get("log_scale", True)
+        self._low_values_on_top = config.get("low_values_on_top", False)
         self._intensity_label = config.get("intensity_label")
         # category_colors is not stored in cache (render-time styling)
 
@@ -352,6 +361,7 @@ class Heatmap(BaseComponent):
                     current_source,
                     max_points=target_size,
                     intensity_column=self._intensity_column,
+                    descending=not self._low_values_on_top,
                 )
             else:
                 level = downsample_2d_streaming(
@@ -364,6 +374,7 @@ class Heatmap(BaseComponent):
                     y_bins=self._y_bins,
                     x_range=x_range,
                     y_range=y_range,
+                    descending=not self._low_values_on_top,
                 )
 
             # Sort and save immediately
@@ -1028,25 +1039,29 @@ class Heatmap(BaseComponent):
                     columns=columns_to_select,
                     filter_defaults=self._filter_defaults,
                 )
-                # Sort by intensity ascending so high-intensity points are drawn on top (scattergl)
+                # Sort for render order (last drawn = on top in scattergl)
+                # Default: ascending (high on top). low_values_on_top: descending (low on top)
                 if (
                     self._intensity_column
                     and self._intensity_column in df_pandas.columns
                 ):
                     df_pandas = df_pandas.sort_values(
-                        self._intensity_column, ascending=True
+                        self._intensity_column, ascending=not self._low_values_on_top
                     ).reset_index(drop=True)
             else:
                 # No filters to apply - levels already filtered by categorical filter
                 schema_names = data.collect_schema().names()
                 available_cols = [c for c in columns_to_select if c in schema_names]
                 df_polars = data.select(available_cols).collect()
-                # Sort by intensity ascending so high-intensity points are drawn on top (scattergl)
+                # Sort for render order (last drawn = on top in scattergl)
+                # Default: ascending (high on top). low_values_on_top: descending (low on top)
                 if (
                     self._intensity_column
                     and self._intensity_column in df_polars.columns
                 ):
-                    df_polars = df_polars.sort(self._intensity_column)
+                    df_polars = df_polars.sort(
+                        self._intensity_column, descending=self._low_values_on_top
+                    )
                 data_hash = compute_dataframe_hash(df_polars)
                 df_pandas = df_polars.to_pandas()
         else:
@@ -1058,9 +1073,12 @@ class Heatmap(BaseComponent):
             # Select only needed columns
             available_cols = [c for c in columns_to_select if c in df_polars.columns]
             df_polars = df_polars.select(available_cols)
-            # Sort by intensity ascending so high-intensity points are drawn on top (scattergl)
+            # Sort for render order (last drawn = on top in scattergl)
+            # Default: ascending (high on top). low_values_on_top: descending (low on top)
             if self._intensity_column and self._intensity_column in df_polars.columns:
-                df_polars = df_polars.sort(self._intensity_column)
+                df_polars = df_polars.sort(
+                    self._intensity_column, descending=self._low_values_on_top
+                )
             print(
                 f"[HEATMAP] Selected {len(df_polars)} pts for zoom, levels={level_sizes}",
                 file=sys.stderr,

{openms_insight-0.1.10 → openms_insight-0.1.11}/openms_insight/components/table.py

@@ -650,8 +650,19 @@ class Table(BaseComponent):
 
         # Apply server-side sort
         if sort_column:
+            # User-applied sort from pagination state takes precedence
             descending = sort_dir == "desc"
-            data = data.sort(sort_column, descending=descending)
+            data = data.sort(sort_column, descending=descending, maintain_order=True)
+        elif self._initial_sort:
+            # Fall back to initial_sort configuration on initial load
+            # initial_sort is a list of dicts: [{"column": "mass", "dir": "desc"}, ...]
+            sort_columns = [s["column"] for s in self._initial_sort]
+            sort_descending = [
+                s.get("dir", "asc") == "desc" for s in self._initial_sort
+            ]
+            data = data.sort(
+                sort_columns, descending=sort_descending, maintain_order=True
+            )
 
         # Get total row count (after filters, before pagination)
         total_rows = data.select(pl.len()).collect().item()