fix: search tracks

app.py

@@ -262,16 +262,44 @@ def _rank_search(query: str, names: list[str], limit: int) -> list[str]:
     return out[:limit]
 
 
-def search_bigwigs(species: str, query: str):
+def search_bigwigs(species: str, query: str, current_selected: list[str]):
     """Search BigWig tracks and return formatted display names."""
+    # Handle None or empty query
+    if query is None:
+        query = ""
+    query_stripped = query.strip()
+    
+    # If query is empty, return empty results immediately (don't show all tracks)
+    if not query_stripped:
+        displayed_selected = current_selected or []
+        show_selected = bool(displayed_selected)
+        return (
+            gr.update(choices=[], value=[], interactive=True),  # empty results, explicitly clear checked state
+            gr.update(visible=show_selected, choices=displayed_selected, value=displayed_selected),  # show ALL selected tracks
+        )
+    
     names = _get_bigwig_names(species)
     # Search in both track IDs and display names
     metadata = _load_track_metadata()
-    query_lower = query.lower()
+    query_lower = query_stripped.lower()
+    
+    # Show selected tracks section if user is typing or has selections
+    show_selected = bool(query_stripped) or bool(current_selected)
+    
+    # Show ALL selected tracks (not limited to 20)
+    displayed_selected = current_selected or []
+    
+    # Extract track IDs from already selected tracks (to exclude them from results)
+    selected_track_ids = set()
+    if current_selected:
+        selected_track_ids = {_extract_track_id(x) for x in current_selected}
     
     # Build list of (display_format, track_id) tuples for searching
     track_display_pairs = []
     for track_id in names:
+        # Skip tracks that are already selected
+        if track_id in selected_track_ids:
+            continue
         display_name = metadata.get(track_id, track_id)
         display_format = _format_track_for_display(track_id)
         track_display_pairs.append((display_format, track_id, display_name))
@@ -284,9 +312,12 @@ def search_bigwigs(species: str, query: str):
             query_lower in display_format.lower()):
             matching.append(display_format)
     
-    # Limit results
+    # Limit search results
     results = matching[:SEARCH_MAX_RESULTS]
-    return gr.update(choices=results, value=[])
+    return (
+        gr.update(choices=results, value=[], interactive=True),  # results - limited to SEARCH_MAX_RESULTS, explicitly clear checked state
+        gr.update(visible=show_selected, choices=displayed_selected, value=displayed_selected),  # show ALL selected tracks
+    )
 
 
 def add_selected(current_selected: list[str], to_add: list[str]):
@@ -304,13 +335,16 @@ def add_selected(current_selected: list[str], to_add: list[str]):
             cur_ids.append(tid)
             cur_display.append(_format_track_for_display(tid))
     
-    return gr.update(choices=cur_display, value=cur_display)  # show + keep all checked
+    # Show ALL selected tracks (no limit)
+    return gr.update(choices=cur_display, value=cur_display)  # show all selected tracks
 
 
 def remove_selected(current_selected: list[str], to_remove: list[str]):
     """Remove tracks from selected list."""
     cur = [x for x in (current_selected or []) if x not in set(to_remove or [])]
-    return gr.update(choices=cur, value=cur)
+    # Show ALL remaining selected tracks (no limit)
+    show_selected = bool(cur)
+    return gr.update(choices=cur, value=cur, visible=show_selected)
 
 
 def update_coords_on_species_change(species: str):
@@ -324,17 +358,25 @@ def reset_on_species_change(species: str):
         track_ids = _get_bigwig_names(species)  # warms cache if available
         # Format available tracks for display
         formatted_tracks = [_format_track_for_display(tid) for tid in track_ids]
+        
+        # Get default tracks for this species (filter to what's available)
+        default_track_ids = [tid for tid in DEFAULT_BIGWIG_TRACKS if tid in track_ids]
+        default_formatted = [_format_track_for_display(tid) for tid in default_track_ids]
+        
+        # Show selected tracks section if there are default tracks
+        show_selected = bool(default_formatted)
+        
         return (
             gr.update(value=""),          # query textbox
             gr.update(choices=[], value=[]),  # results list
-            gr.update(choices=formatted_tracks, value=[]),  # selected list (with formatted names)
+            gr.update(choices=formatted_tracks, value=default_formatted, visible=show_selected),  # selected list with defaults
         )
     except (ValueError, AttributeError):
         # Species doesn't have bigwigs, that's okay
         return (
             gr.update(value=""),          # query textbox
             gr.update(choices=[], value=[]),  # results list
-            gr.update(choices=[], value=[]),  # selected list
+            gr.update(choices=[], value=[], visible=False),  # selected list (hidden)
         )
 
 
@@ -375,11 +417,11 @@ def predict(
         if not seq or not seq.strip():
             raise gr.Error("seq is required when use_coords=False")
         inputs = {"seq": seq.strip(), "species": species}
-    
+
     # Verify species is in inputs before calling pipeline
     if "species" not in inputs:
         raise gr.Error(f"Internal error: species not found in inputs dict. Inputs: {list(inputs.keys())}")
-    
+
     out = pipe(inputs)
 
     bw_names = out.bigwig_track_names or []
@@ -715,9 +757,9 @@ _init_bed_selected = [elem for elem in DEFAULT_BED_ELEMENTS if elem in _init_bed
 # Default coordinates per species
 DEFAULT_COORDS = {
     "human": {"chrom": "chr19", "start": 6_700_000, "end": 6_831_072},
-    "mouse": {"chrom": "chr1", "start": 0, "end": 32_768},
-    "drosophila_melanogaster": {"chrom": "chr2L", "start": 0, "end": 32_768},
-    "arabidopsis_thaliana": {"chrom": "chr1", "start": 0, "end": 32_768},
+    "mouse": {"chrom": "chr1", "start": 9_880_168, "end": 10_142_312},
+    "drosophila_melanogaster": {"chrom": "chr2L", "start": 6_700_000, "end": 6_831_072},
+    "arabidopsis_thaliana": {"chrom": "chr1", "start": 13_135_095, "end": 13_397_239},
 }
 
 # Get default coordinates for default species
@@ -824,7 +866,7 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
     
     # Get all available species from the pipeline
     all_species = sorted(ASSEMBLY_TO_SPECIES.values())
-    
+
     with gr.Row():
         species = gr.Dropdown(
             choices=all_species,
@@ -909,6 +951,7 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
         choices=_init_bigwig_selected,
         value=_init_bigwig_selected,
         label="Selected functional tracks (used for prediction)",
+        visible=bool(_init_bigwig_selected),  # Show if there are default tracks, otherwise hidden
     )
 
     bigwig_query = gr.Textbox(
@@ -954,23 +997,132 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
 
     # --- wiring (live search + auto-add) ---
 
-    # Live search on every keystroke
+    # Live search on every keystroke and when text changes (including deletion)
     bigwig_query.input(
         fn=search_bigwigs,
-        inputs=[species, bigwig_query],
-        outputs=[bigwig_results],
+        inputs=[species, bigwig_query, bigwig_selected],
+        outputs=[bigwig_results, bigwig_selected],
+    )
+    # Also trigger on change to catch deletions
+    bigwig_query.change(
+        fn=search_bigwigs,
+        inputs=[species, bigwig_query, bigwig_selected],
+        outputs=[bigwig_results, bigwig_selected],
     )
 
+    # Helper function to get search results choices directly (without gr.update wrapper)
+    def _get_search_results_choices(species: str, query: str, current_selected: list[str]) -> list[str]:
+        """Get search results choices as a list, excluding selected tracks."""
+        if query is None:
+            query = ""
+        query_stripped = query.strip()
+        
+        if not query_stripped:
+            return []
+        
+        names = _get_bigwig_names(species)
+        metadata = _load_track_metadata()
+        query_lower = query_stripped.lower()
+        
+        # Extract track IDs from already selected tracks
+        selected_track_ids = set()
+        if current_selected:
+            selected_track_ids = {_extract_track_id(x) for x in current_selected}
+        
+        # Build and filter results
+        matching = []
+        for track_id in names:
+            if track_id in selected_track_ids:
+                continue
+            display_name = metadata.get(track_id, track_id)
+            display_format = _format_track_for_display(track_id)
+            if (query_lower in track_id.lower() or 
+                query_lower in display_name.lower() or 
+                query_lower in display_format.lower()):
+                matching.append(display_format)
+        
+        return matching[:SEARCH_MAX_RESULTS]
+    
     # Auto-add: whenever user checks items in results, add them to Selected,
     # then clear results selection (so it feels like "click to add")
-    def _auto_add(selected_now: list[str], results_checked: list[str]):
+    def _auto_add(selected_now: list[str], results_checked: list[str], current_query: str, current_results: list[str], current_species: str):
         upd = add_selected(selected_now, results_checked)  # reuses your function
-        # clear checks in results, keep choices
-        return upd, gr.update(value=[])
+        # Show selected tracks section if there are selections
+        show_selected = bool(upd["value"])
+        
+        # Get the new search results choices directly (excluding all selected tracks)
+        new_choices = _get_search_results_choices(current_species, current_query, upd["value"])
+        
+        # Create a completely fresh update with explicit empty value to prevent any checked state
+        # Force Gradio to clear checked state by explicitly setting value to empty list
+        # Use a workaround: set choices to empty first, then to new_choices to force a complete refresh
+        # But since we can only return one update, we'll ensure value is explicitly empty
+        # and that we're not preserving any state from the previous update
+        
+        # Ensure no items from results_checked are in new_choices (they should already be filtered, but double-check)
+        checked_track_ids = {_extract_track_id(x) for x in results_checked}
+        new_choices_filtered = [c for c in new_choices if _extract_track_id(c) not in checked_track_ids]
+        
+        # Create update with explicit empty value - this should force Gradio to clear all checked items
+        fresh_update = gr.update(
+            choices=new_choices_filtered,
+            value=[],  # CRITICAL: Explicitly empty list to clear all checked state
+        )
+        
+        return gr.update(**upd, visible=show_selected), fresh_update
 
+    # Use a wrapper that ensures results are cleared before updating
+    def _auto_add_wrapper(selected_now: list[str], results_checked: list[str], current_query: str, current_results: list[str], current_species: str):
+        # First, get the updates
+        selected_update, results_update = _auto_add(selected_now, results_checked, current_query, current_results, current_species)
+        
+        # Force the results update to have an explicit empty value
+        # Extract choices from results_update if it's a dict-like object
+        if isinstance(results_update, dict):
+            results_choices = results_update.get("choices", [])
+        else:
+            # If it's a gr.update object, we need to access it differently
+            # Try to get choices from the update
+            try:
+                results_choices = results_update.choices if hasattr(results_update, 'choices') else []
+            except:
+                # Fallback: get choices from the search function directly
+                results_choices = _get_search_results_choices(
+                    current_species, 
+                    current_query, 
+                    selected_now + results_checked if isinstance(selected_now, list) and isinstance(results_checked, list) else []
+                )
+        
+        # Create a completely fresh update with explicit empty value
+        # This should force Gradio to clear all checked items
+        fresh_results_update = gr.update(choices=results_choices, value=[])
+        
+        return selected_update, fresh_results_update
+    
     bigwig_results.change(
-        fn=_auto_add,
-        inputs=[bigwig_selected, bigwig_results],
+        fn=_auto_add_wrapper,
+        inputs=[bigwig_selected, bigwig_results, bigwig_query, bigwig_results, species],
+        outputs=[bigwig_selected, bigwig_results],
+    )
+
+    # Update selected tracks immediately when user unchecks items
+    def _update_selected_tracks(selected_value: list[str], current_query: str, current_species: str):
+        """Update selected tracks when user checks/unchecks items directly."""
+        # selected_value contains only the currently checked items
+        # Update choices to match the current selections (so unchecked items are removed)
+        show_selected = bool(selected_value)
+        
+        # Also update search results to reflect the new selection (tracks that were unchecked can now appear in results)
+        search_updates = search_bigwigs(current_species, current_query, selected_value)
+        
+        return (
+            gr.update(choices=selected_value, value=selected_value, visible=show_selected),  # Update selected tracks
+            search_updates[0],  # Update search results
+        )
+    
+    bigwig_selected.change(
+        fn=_update_selected_tracks,
+        inputs=[bigwig_selected, bigwig_query, species],
         outputs=[bigwig_selected, bigwig_results],
     )
 
@@ -1011,10 +1163,19 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
             try:
                 track_ids = _get_bigwig_names(species)
                 formatted_tracks = [_format_track_for_display(tid) for tid in track_ids]
+                # Get default tracks for this species (filter to what's available)
+                default_track_ids = [tid for tid in DEFAULT_BIGWIG_TRACKS if tid in track_ids]
+                default_formatted = [_format_track_for_display(tid) for tid in default_track_ids]
+                # Show selected tracks section if there are default tracks
+                show_selected_tracks = bool(default_formatted)
             except:
                 formatted_tracks = []
+                default_formatted = []
+                show_selected_tracks = False
         else:
             formatted_tracks = []
+            default_formatted = []
+            show_selected_tracks = False
         
         return (
             gr.update(visible=show_coords, value=coords["chrom"]),
@@ -1023,7 +1184,7 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
             gr.update(value=is_supported, visible=is_supported),  # Show/hide and enable use_coords only if supported
             gr.update(visible=show_coords),  # Show/hide the row
             gr.update(visible=not has_bigwigs),  # Show "no tracks" message if no bigwigs
-            gr.update(visible=has_bigwigs, choices=formatted_tracks, value=[]),  # Show bigwig selection if available
+            gr.update(visible=show_selected_tracks, choices=formatted_tracks, value=default_formatted),  # Show bigwig selection with defaults if available
             gr.update(visible=has_bigwigs),  # Show bigwig query if available
             gr.update(visible=has_bigwigs),  # Show bigwig results if available
             gr.update(visible=has_bigwigs),  # Show bigwig buttons if available