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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openms-insight
-Version: 0.1.8
+Version: 0.1.10
 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

{openms_insight-0.1.8 → openms_insight-0.1.10}/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-0.1.8 → openms_insight-0.1.10}/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,8 +640,13 @@ 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:
@@ -578,34 +660,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 +761,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 +850,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 +885,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)}"

{openms_insight-0.1.8 → openms_insight-0.1.10}/openms_insight/rendering/bridge.py

@@ -16,6 +16,20 @@ _DEBUG_HASH_TRACKING = os.environ.get("SVC_DEBUG_HASH", "").lower() == "true"
 _DEBUG_STATE_SYNC = os.environ.get("SVC_DEBUG_STATE", "").lower() == "true"
 _logger = logging.getLogger(__name__)
 
+# Numeric data types for type conversion during selection validation
+NUMERIC_DTYPES = (
+    pl.Int8,
+    pl.Int16,
+    pl.Int32,
+    pl.Int64,
+    pl.UInt8,
+    pl.UInt16,
+    pl.UInt32,
+    pl.UInt64,
+    pl.Float32,
+    pl.Float64,
+)
+
 
 def _make_hashable(value: Any) -> Any:
     """
@@ -130,10 +144,27 @@ def clear_component_annotations() -> None:
         st.session_state[_COMPONENT_ANNOTATIONS_KEY].clear()
 
 
+def _compute_annotation_hash(component: "BaseComponent") -> Optional[str]:
+    """
+    Compute hash of component's dynamic annotations, if any.
+
+    Args:
+        component: The component to check for annotations
+
+    Returns:
+        Short hash string if annotations exist, None otherwise
+    """
+    annotations = getattr(component, "_dynamic_annotations", None)
+    if annotations is None:
+        return None
+    # Hash the sorted keys (sufficient for change detection)
+    return hashlib.md5(str(sorted(annotations.keys())).encode()).hexdigest()[:8]
+
+
 def _get_cached_vue_data(
     component_id: str,
     filter_state_hashable: Tuple[Tuple[str, Any], ...],
-) -> Optional[Tuple[Dict[str, Any], str]]:
+) -> Optional[Tuple[Dict[str, Any], str, Optional[str]]]:
     """
     Get cached Vue data for component if filter state matches.
 
@@ -145,13 +176,19 @@ def _get_cached_vue_data(
         filter_state_hashable: Current filter state (for cache validation)
 
     Returns:
-        Tuple of (vue_data, data_hash) if cache hit, None otherwise
+        Tuple of (vue_data, data_hash, annotation_hash) if cache hit, None otherwise
     """
     cache = _get_component_cache()
     if component_id in cache:
-        cached_state, vue_data, data_hash = cache[component_id]
+        entry = cache[component_id]
+        # Support both old (3-tuple) and new (4-tuple) format
+        if len(entry) == 4:
+            cached_state, vue_data, data_hash, ann_hash = entry
+        else:
+            cached_state, vue_data, data_hash = entry
+            ann_hash = None
         if cached_state == filter_state_hashable:
-            return (vue_data, data_hash)
+            return (vue_data, data_hash, ann_hash)
     return None
 
 
@@ -160,6 +197,7 @@ def _set_cached_vue_data(
     filter_state_hashable: Tuple[Tuple[str, Any], ...],
     vue_data: Dict[str, Any],
     data_hash: str,
+    ann_hash: Optional[str] = None,
 ) -> None:
     """
     Cache Vue data for component, replacing any previous entry.
@@ -171,9 +209,10 @@ def _set_cached_vue_data(
         filter_state_hashable: Current filter state
         vue_data: Data to cache
         data_hash: Hash of the data
+        ann_hash: Hash of dynamic annotations (if any)
     """
     cache = _get_component_cache()
-    cache[component_id] = (filter_state_hashable, vue_data, data_hash)
+    cache[component_id] = (filter_state_hashable, vue_data, data_hash, ann_hash)
 
 
 def _prepare_vue_data_cached(
@@ -212,12 +251,10 @@ def _prepare_vue_data_cached(
 
     if _DEBUG_HASH_TRACKING:
         cache_hit = cached is not None
-        _logger.warning(
-            f"[CacheDebug] {component._cache_id}: cache_hit={cache_hit}"
-        )
+        _logger.warning(f"[CacheDebug] {component._cache_id}: cache_hit={cache_hit}")
 
     if cached is not None:
-        cached_data, cached_hash = cached
+        cached_data, cached_hash, _ = cached  # Ignore cached annotation hash here
 
         if has_dynamic_annotations:
             # Cache hit but need to re-apply annotations (they may have changed)
@@ -240,6 +277,9 @@ def _prepare_vue_data_cached(
     # Cache miss - compute data
     vue_data = component._prepare_vue_data(state_dict)
 
+    # Compute annotation hash for cache storage
+    ann_hash = _compute_annotation_hash(component)
+
     if has_dynamic_annotations:
         # Store BASE data (without dynamic annotation columns) in cache
         if hasattr(component, "_strip_dynamic_columns"):
@@ -248,7 +288,9 @@ def _prepare_vue_data_cached(
             # Fallback: store without _plotConfig (may have stale column refs)
             base_data = {k: v for k, v in vue_data.items() if k != "_plotConfig"}
         base_hash = _hash_data(base_data)
-        _set_cached_vue_data(component_id, filter_state_hashable, base_data, base_hash)
+        _set_cached_vue_data(
+            component_id, filter_state_hashable, base_data, base_hash, ann_hash
+        )
 
         # Return full data with annotations
         data_hash = _hash_data(vue_data)
@@ -256,7 +298,9 @@ def _prepare_vue_data_cached(
     else:
         # Store complete data in cache
         data_hash = _hash_data(vue_data)
-        _set_cached_vue_data(component_id, filter_state_hashable, vue_data, data_hash)
+        _set_cached_vue_data(
+            component_id, filter_state_hashable, vue_data, data_hash, ann_hash
+        )
         return vue_data, data_hash
 
 
@@ -302,6 +346,101 @@ def get_vue_component_function():
     return _vue_component_func
 
 
+def _validate_interactivity_selections(
+    component: "BaseComponent",
+    state_manager: "StateManager",
+    state: Dict[str, Any],
+) -> bool:
+    """
+    Validate that interactivity selections still exist in filtered data.
+
+    When an external filter changes, the currently selected value may no longer
+    exist in the filtered dataset. This function checks each interactivity
+    selection and clears it if invalid.
+
+    Args:
+        component: The component to validate selections for
+        state_manager: StateManager to clear invalid selections
+        state: Current state dict (already has filter values)
+
+    Returns:
+        True if any selection was cleared (state changed), False otherwise
+    """
+    interactivity = getattr(component, "_interactivity", None)
+    if not interactivity:
+        return False
+
+    filters = getattr(component, "_filters", None) or {}
+    filter_defaults = getattr(component, "_filter_defaults", None) or {}
+
+    # Get the preprocessed data
+    preprocessed = getattr(component, "_preprocessed_data", None)
+    if preprocessed is not None:
+        data = preprocessed.get("data")
+    else:
+        data = None
+    if data is None:
+        data = getattr(component, "_raw_data", None)
+    if data is None:
+        # Component doesn't have data we can validate against
+        return False
+
+    # Ensure LazyFrame
+    if isinstance(data, pl.DataFrame):
+        data = data.lazy()
+
+    # Apply filters to get the filtered dataset
+    for identifier, column in filters.items():
+        selected_value = state.get(identifier)
+        if selected_value is None and identifier in filter_defaults:
+            selected_value = filter_defaults[identifier]
+
+        if selected_value is None:
+            # Awaiting filter - no data to validate against
+            return False
+
+        # Convert float to int for integer columns (type mismatch handling)
+        if isinstance(selected_value, float) and selected_value.is_integer():
+            selected_value = int(selected_value)
+
+        data = data.filter(pl.col(column) == selected_value)
+
+    # Validate each interactivity selection against filtered data
+    state_changed = False
+    schema = data.collect_schema()
+
+    for identifier, column in interactivity.items():
+        selected_value = state.get(identifier)
+        if selected_value is None:
+            continue  # No selection to validate
+
+        if column not in schema.names():
+            continue  # Column doesn't exist
+
+        # Type conversion for numeric columns
+        col_dtype = schema[column]
+        if col_dtype in NUMERIC_DTYPES:
+            if isinstance(selected_value, float) and selected_value.is_integer():
+                selected_value = int(selected_value)
+
+        # Check if value exists in filtered data (efficient: only fetch 1 row)
+        exists = (
+            data.filter(pl.col(column) == selected_value).head(1).collect().height > 0
+        )
+
+        if not exists:
+            # Selection is invalid - clear it
+            state_manager.set_selection(identifier, None)
+            state_changed = True
+            if _DEBUG_STATE_SYNC:
+                _logger.warning(
+                    f"[Bridge:{component._cache_id}] Cleared invalid selection: "
+                    f"{identifier}={selected_value} not in filtered data"
+                )
+
+    return state_changed
+
+
 def render_component(
     component: "BaseComponent",
     state_manager: "StateManager",
@@ -377,16 +516,28 @@ def render_component(
     # Check if cached data is VALID for current state
     # KEY FIX: Only send data when cache matches current state
     # - Before: Always sent cached data, even if stale (page 38 when Vue wants page 1)
-    # - Now: Only send if cache matches current state
+    # - Now: Only send if cache matches current state AND annotation state matches
     cache_valid = False
+    current_ann_hash = _compute_annotation_hash(component)
+
     if cached_entry is not None:
-        cached_state, cached_data, cached_hash = cached_entry
-        cache_valid = (cached_state == current_filter_state)
+        # Support both old (3-tuple) and new (4-tuple) cache format
+        if len(cached_entry) == 4:
+            cached_state, cached_data, cached_hash, cached_ann_hash = cached_entry
+        else:
+            cached_state, cached_data, cached_hash = cached_entry
+            cached_ann_hash = None
+
+        # Cache valid only if BOTH filter state AND annotation state match
+        filter_state_matches = cached_state == current_filter_state
+        ann_state_matches = cached_ann_hash == current_ann_hash
+        cache_valid = filter_state_matches and ann_state_matches
+
         if _DEBUG_STATE_SYNC:
             _logger.warning(
                 f"[Bridge:{component._cache_id}] Phase1: cache_valid={cache_valid}, "
-                f"cached_state={cached_state[:2] if cached_state else None}..., "
-                f"current_state={current_filter_state[:2] if current_filter_state else None}..."
+                f"filter_match={filter_state_matches}, ann_match={ann_state_matches}, "
+                f"cached_ann={cached_ann_hash}, current_ann={current_ann_hash}"
             )
 
     # Build payload - only send data if cache is valid for current state
@@ -482,6 +633,15 @@ def render_component(
             awaiting_filter = True
             break
 
+    # === Validate interactivity selections BEFORE preparing data ===
+    # When filter changes, the current selection may no longer exist
+    # in the filtered data. Clear it so auto-selection can kick in.
+    if not awaiting_filter:
+        if _validate_interactivity_selections(component, state_manager, state):
+            state_changed = True
+            # Refresh state after clearing invalid selections
+            state = state_manager.get_state_for_vue()
+
     if not awaiting_filter:
         # Extract state keys that affect this component's data
         state_keys = set(component.get_state_dependencies())
@@ -508,6 +668,14 @@ def render_component(
             component, component_id, filter_state_hashable, relevant_state
         )
 
+        # Apply auto-selection from first row (for tables with interactivity)
+        # This ensures downstream components receive data when a filter changes
+        auto_selection = vue_data.pop("_auto_selection", {})
+        for identifier, value in auto_selection.items():
+            if state_manager.get_selection(identifier) is None:
+                state_manager.set_selection(identifier, value)
+                state_changed = True
+
         # Check if Python overrode state during _prepare_vue_data
         # (e.g., table.py sets page to last page after sort)
         final_state = state_manager.get_state_for_vue()
@@ -522,7 +690,9 @@ def render_component(
         data_hash = "awaiting_filter"
         filter_state_hashable = ()
 
-    _logger.info(f"[bridge] Phase4: {component._cache_id} prepared data, hash={data_hash[:8] if data_hash else 'None'}")
+    _logger.info(
+        f"[bridge] Phase4: {component._cache_id} prepared data, hash={data_hash[:8] if data_hash else 'None'}"
+    )
 
     # === PHASE 5: Cache data for next render ===
     if vue_data:
@@ -538,8 +708,13 @@ def render_component(
             else:
                 converted_data[data_key] = value
 
-        # Store in cache for next render
-        cache[component_id] = (filter_state_hashable, converted_data, data_hash)
+        # Store in cache for next render (include annotation hash for validity check)
+        cache[component_id] = (
+            filter_state_hashable,
+            converted_data,
+            data_hash,
+            current_ann_hash,
+        )
 
         # If cache was invalid at Phase 1, we didn't send data to Vue (dataChanged=False).
         # Trigger a rerun so the newly cached data gets sent on the next render.
@@ -555,9 +730,13 @@ def render_component(
 
         if _DEBUG_STATE_SYNC:
             # Log what we're caching for debugging
-            pagination_key = next((k for k, v in filter_state_hashable if "page" in k.lower()), None)
+            pagination_key = next(
+                (k for k, v in filter_state_hashable if "page" in k.lower()), None
+            )
             if pagination_key:
-                pagination_val = next((v for k, v in filter_state_hashable if k == pagination_key), None)
+                pagination_val = next(
+                    (v for k, v in filter_state_hashable if k == pagination_key), None
+                )
                 _logger.warning(
                     f"[Bridge:{component._cache_id}] Phase5: Cached data with hash={data_hash[:8]}, "
                     f"filter_state includes {pagination_key}={pagination_val}"
@@ -624,7 +803,11 @@ def _hash_data(data: Dict[str, Any]) -> str:
     hash_parts = []
     for key, value in sorted(data.items()):
         # Skip internal metadata but NOT dynamic annotation columns or pagination
-        if key.startswith("_") and not key.startswith("_dynamic") and not key.startswith("_pagination"):
+        if (
+            key.startswith("_")
+            and not key.startswith("_dynamic")
+            and not key.startswith("_pagination")
+        ):
             continue
         if isinstance(value, pd.DataFrame):
             # Efficient hash for DataFrames

{openms_insight-0.1.8 → openms_insight-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openms-insight"
-version = "0.1.8"
+version = "0.1.10"
 description = "Interactive visualization components for mass spectrometry data in Streamlit"
 readme = "README.md"
 license = "BSD-3-Clause"