openms-insight 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

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/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/components/sequenceview.py

@@ -440,6 +440,9 @@ class SequenceView:
             self._deconvolved = deconvolved
             self._config = kwargs
             self._filters = filters or {}
+            self._filter_defaults = {}
+            for identifier in self._filters.keys():
+                self._filter_defaults[identifier] = None
             self._interactivity = interactivity or {}
 
             # Store annotation config with defaults
@@ -534,6 +537,9 @@ class SequenceView:
 
         # Restore all configuration
         self._filters = config.get("filters", {})
+        self._filter_defaults = {}
+        for identifier in self._filters.keys():
+            self._filter_defaults[identifier] = None
         self._interactivity = config.get("interactivity", {})
         self._title = config.get("title")
         self._height = config.get("height", 400)
@@ -650,6 +656,12 @@ class SequenceView:
                 filter_value = state.get(identifier)
                 if filter_value is not None:
                     filtered = filtered.filter(pl.col(column) == filter_value)
+                elif (
+                    identifier in self._filter_defaults
+                    and self._filter_defaults[identifier] is None
+                ):
+                    # Filter has None default and state is None - return empty intentionally
+                    return "", 1
 
         # Collect and get first row
         try:
@@ -681,6 +693,14 @@ class SequenceView:
                 filter_value = state.get(identifier)
                 if filter_value is not None:
                     filtered = filtered.filter(pl.col(column) == filter_value)
+                elif (
+                    identifier in self._filter_defaults
+                    and self._filter_defaults[identifier] is None
+                ):
+                    # Filter has None default and state is None - return empty intentionally
+                    return pl.DataFrame(
+                        schema={"peak_id": pl.Int64, "mass": pl.Float64}
+                    )
 
         # Select available columns
         cols = ["peak_id", "mass"]

openms_insight/components/table.py

@@ -1,6 +1,7 @@
 """Table component using Tabulator.js."""
 
 import logging
+import re
 from typing import Any, Dict, List, Optional
 
 import polars as pl
@@ -11,6 +12,20 @@ from ..preprocessing.filtering import compute_dataframe_hash
 
 logger = logging.getLogger(__name__)
 
+# Numeric data types for dtype checking
+NUMERIC_DTYPES = (
+    pl.Int8,
+    pl.Int16,
+    pl.Int32,
+    pl.Int64,
+    pl.UInt8,
+    pl.UInt16,
+    pl.UInt32,
+    pl.UInt64,
+    pl.Float32,
+    pl.Float64,
+)
+
 # Session state key for tracking last rendered selection per table component
 _LAST_SELECTION_KEY = "_svc_table_last_selection"
 # Session state key for tracking last sort/filter state per table component
@@ -419,10 +434,71 @@ class Table(BaseComponent):
 
         self._preprocessed_data["column_metadata"] = column_metadata
 
+        # Auto-detect go-to fields if not explicitly provided
+        if self._go_to_fields is None:
+            self._go_to_fields = self._auto_detect_go_to_fields(data)
+        elif self._go_to_fields == []:
+            # Explicitly disabled - keep empty list
+            pass
+        # else: use user-provided list as-is
+
         # Store LazyFrame for streaming to disk (filter happens at render time)
         # Base class will use sink_parquet() to stream without full materialization
         self._preprocessed_data["data"] = data  # Keep lazy
 
+    def _auto_detect_go_to_fields(self, data: pl.LazyFrame) -> List[str]:
+        """
+        Auto-detect columns suitable for go-to navigation.
+
+        Criteria:
+        - Integer or String (Utf8) type only (excludes Float)
+        - 100% unique values (no duplicates)
+        - Samples first 10,000 rows for performance
+
+        Args:
+            data: LazyFrame to analyze for unique columns
+
+        Returns:
+            List of column names in original schema order
+        """
+        schema = data.collect_schema()
+        sample = data.head(10000)
+
+        candidates = []
+        for col_name in schema.names():
+            dtype = schema[col_name]
+
+            # Only Integer and String types (exclude Float)
+            if dtype not in (
+                pl.Int8,
+                pl.Int16,
+                pl.Int32,
+                pl.Int64,
+                pl.UInt8,
+                pl.UInt16,
+                pl.UInt32,
+                pl.UInt64,
+                pl.Utf8,
+            ):
+                continue
+
+            # Check 100% uniqueness in sample
+            stats = sample.select(
+                [
+                    pl.col(col_name).len().alias("count"),
+                    pl.col(col_name).n_unique().alias("n_unique"),
+                ]
+            ).collect()
+
+            count = stats["count"][0]
+            n_unique = stats["n_unique"][0]
+
+            # Must be 100% unique (count == n_unique)
+            if count > 0 and count == n_unique:
+                candidates.append(col_name)
+
+        return candidates
+
     def _get_columns_to_select(self) -> Optional[List[str]]:
         """Get list of columns needed for this table."""
         if not self._column_definitions:
@@ -527,6 +603,7 @@ class Table(BaseComponent):
                         "total_rows": 0,
                         "total_pages": 0,
                     },
+                    "_auto_selection": {},  # No data = no auto-selection
                 }
 
             # Convert float to int for integer columns (JS numbers come as floats)
@@ -563,13 +640,29 @@ class Table(BaseComponent):
             elif filter_type == "<=":
                 data = data.filter(pl.col(field) <= value)
             elif filter_type == "regex":
-                # Text search with regex
-                data = data.filter(pl.col(field).str.contains(value, literal=False))
+                # Text search with regex - invalid patterns match nothing
+                try:
+                    re.compile(value)
+                    data = data.filter(pl.col(field).str.contains(value, literal=False))
+                except re.error:
+                    # Invalid regex pattern - filter to empty result
+                    data = data.filter(pl.lit(False))
 
         # 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()
@@ -578,34 +671,44 @@ class Table(BaseComponent):
         # Handle go-to request (server-side search for row by field value)
         navigate_to_page = None
         target_row_index = None
+        go_to_not_found = False
 
         if go_to_request:
             go_to_field = go_to_request.get("field")
             go_to_value = go_to_request.get("value")
             if go_to_field and go_to_value is not None:
-                # Try to convert to number if applicable
-                try:
-                    go_to_value = float(go_to_value)
-                    if go_to_value.is_integer():
-                        go_to_value = int(go_to_value)
-                except (ValueError, TypeError):
-                    pass
-
-                # Find the row with row_number
-                search_result = (
-                    data.with_row_index("_row_num")
-                    .filter(pl.col(go_to_field) == go_to_value)
-                    .select("_row_num")
-                    .head(1)
-                    .collect()
-                )
-
-                if len(search_result) > 0:
-                    row_num = search_result["_row_num"][0]
-                    target_page = (row_num // page_size) + 1
-                    navigate_to_page = target_page
-                    target_row_index = row_num % page_size
-                    page = target_page  # Jump to target page
+                # Only convert to numeric if the target column is numeric
+                schema = data.collect_schema()
+                if go_to_field in schema and schema[go_to_field] in NUMERIC_DTYPES:
+                    try:
+                        go_to_value = float(go_to_value)
+                        if go_to_value.is_integer():
+                            go_to_value = int(go_to_value)
+                    except (ValueError, TypeError):
+                        # Non-numeric string for numeric column - mark as not found
+                        go_to_not_found = True
+                # If column is string (Utf8), keep go_to_value as-is
+
+                # Only search if we have a valid value (not already marked as not found)
+                if not go_to_not_found:
+                    # Find the row with row_number
+                    search_result = (
+                        data.with_row_index("_row_num")
+                        .filter(pl.col(go_to_field) == go_to_value)
+                        .select("_row_num")
+                        .head(1)
+                        .collect()
+                    )
+
+                    if len(search_result) > 0:
+                        row_num = search_result["_row_num"][0]
+                        target_page = (row_num // page_size) + 1
+                        navigate_to_page = target_page
+                        target_row_index = row_num % page_size
+                        page = target_page  # Jump to target page
+                    else:
+                        # Row not found - set flag for Vue to show "not found" feedback
+                        go_to_not_found = True
 
         # === Selection and Sort/Filter based navigation ===
         # PURPOSE: When user sorts/filters, find where the selected row ended up and navigate there
@@ -669,12 +772,28 @@ class Table(BaseComponent):
                 for identifier, column in self._interactivity.items():
                     selected_value = state.get(identifier)
                     if selected_value is not None:
-                        # Convert float to int if needed (JS numbers come as floats)
-                        if (
-                            isinstance(selected_value, float)
-                            and selected_value.is_integer()
-                        ):
-                            selected_value = int(selected_value)
+                        # Type conversion based on column dtype (same logic as go-to)
+                        schema = data.collect_schema()
+                        if column in schema:
+                            col_dtype = schema[column]
+                            if col_dtype in NUMERIC_DTYPES:
+                                # Column is numeric - convert value to numeric if possible
+                                if isinstance(selected_value, str):
+                                    try:
+                                        selected_value = float(selected_value)
+                                        if selected_value.is_integer():
+                                            selected_value = int(selected_value)
+                                    except (ValueError, TypeError):
+                                        pass
+                                elif (
+                                    isinstance(selected_value, float)
+                                    and selected_value.is_integer()
+                                ):
+                                    selected_value = int(selected_value)
+                            else:
+                                # Column is string - convert value to string
+                                if not isinstance(selected_value, str):
+                                    selected_value = str(selected_value)
 
                         # SEARCH for the selected row in the sorted/filtered data
                         # with_row_index adds position so we know which page it's on
@@ -742,6 +861,22 @@ class Table(BaseComponent):
         # Clamp page to valid range
         page = max(1, min(page, total_pages))
 
+        # Compute auto-selection from first row (before pagination)
+        # This provides the first row's values for interactivity columns
+        # so downstream components can receive initial data when filters change
+        auto_selection: Dict[str, Any] = {}
+        if self._interactivity and total_rows > 0:
+            # Get the first row of sorted/filtered data
+            first_row = data.head(1).collect()
+            if first_row.height > 0:
+                for identifier, column in self._interactivity.items():
+                    if column in first_row.columns:
+                        value = first_row[column][0]
+                        # Convert numpy/polars types to Python types for JSON
+                        if hasattr(value, "item"):
+                            value = value.item()
+                        auto_selection[identifier] = value
+
         # Slice to current page
         offset = (page - 1) * page_size
         df_polars = data.slice(offset, page_size).collect()
@@ -761,12 +896,15 @@ class Table(BaseComponent):
                 "sort_column": sort_column,
                 "sort_dir": sort_dir,
             },
+            "_auto_selection": auto_selection,
         }
 
         if navigate_to_page is not None:
             result["_navigate_to_page"] = navigate_to_page
         if target_row_index is not None:
             result["_target_row_index"] = target_row_index
+        if go_to_not_found:
+            result["_go_to_not_found"] = True
 
         logger.info(
             f"[Table._prepare_vue_data] Returning: page={page}, total_rows={total_rows}, data_rows={len(df_polars)}"