feat: clean track names

app.py

@@ -1,6 +1,8 @@
 import os
 import uuid
 import tempfile
+import csv
+from pathlib import Path
 import numpy as np
 import gradio as gr
 import asyncio
@@ -114,6 +116,85 @@ def _save_fig_png(fig) -> str:
 # Cache track lists per species so search is instant after first load
 _BIGWIG_CACHE: dict[str, list[str]] = {}
 
+# Cache for track metadata (track_id -> display_name)
+_TRACK_METADATA_CACHE: dict[str, str] = {}
+
+
+def _load_track_metadata() -> dict[str, str]:
+    """Load track metadata from CSV and create display name mapping."""
+    if _TRACK_METADATA_CACHE:
+        return _TRACK_METADATA_CACHE
+    
+    csv_path = Path(__file__).parent / "data" / "functional_tracks_metadata.csv"
+    if not csv_path.exists():
+        return {}
+    
+    metadata = {}
+    try:
+        with open(csv_path, 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                track_id = row['file_id']
+                tissue = row.get('tissue', '').strip()
+                assay = row.get('assay', '').strip()
+                experiment_target = row.get('experiment_target', '').strip()
+                biosample_type = row.get('biosample_type', '').strip()
+                strand = row.get('strand', '').strip()
+                
+                # Build display name from available fields
+                parts = []
+                if biosample_type and biosample_type != 'tissue':
+                    parts.append(biosample_type)
+                if tissue:
+                    parts.append(tissue)
+                if assay:
+                    # For RNA-seq, include strand information if available
+                    if strand:
+                        if strand == 'plus':
+                            strand = '+'
+                        elif strand == 'minus':
+                            strand = '-'
+                        parts.append(f"{assay} {strand}")
+                    else:
+                        parts.append(assay)
+                if experiment_target and experiment_target not in ('none', 'RNA-seq'):
+                    parts.append(experiment_target)
+                
+                if parts:
+                    display_name = " - ".join(parts)
+                else:
+                    display_name = track_id  # Fallback to ID if no metadata
+                
+                metadata[track_id] = display_name
+    except Exception as e:
+        print(f"Warning: Could not load track metadata: {e}")
+        return {}
+    
+    _TRACK_METADATA_CACHE.update(metadata)
+    return metadata
+
+
+def _get_track_display_name(track_id: str) -> str:
+    """Get display name for a track ID, or return the ID if not found."""
+    metadata = _load_track_metadata()
+    return metadata.get(track_id, track_id)
+
+
+def _format_track_for_display(track_id: str) -> str:
+    """Format track ID for display: 'display_name (track_id)'."""
+    display_name = _get_track_display_name(track_id)
+    if display_name == track_id:
+        return track_id  # No metadata available, just show ID
+    return f"{display_name} ({track_id})"
+
+
+def _extract_track_id(display_value: str) -> str:
+    """Extract track ID from display format 'display_name (track_id)' or return as-is."""
+    if " (" in display_value and display_value.endswith(")"):
+        # Extract track_id from format "display_name (track_id)"
+        return display_value.rsplit(" (", 1)[1][:-1]
+    return display_value  # No parentheses, assume it's already just the ID
+
 
 def _get_bigwig_names(species: str) -> list[str]:
     if species not in _BIGWIG_CACHE:
@@ -182,20 +263,52 @@ def _rank_search(query: str, names: list[str], limit: int) -> list[str]:
 
 
 def search_bigwigs(species: str, query: str):
+    """Search BigWig tracks and return formatted display names."""
     names = _get_bigwig_names(species)
-    results = _rank_search(query, names, SEARCH_MAX_RESULTS)
+    # Search in both track IDs and display names
+    metadata = _load_track_metadata()
+    query_lower = query.lower()
+    
+    # Build list of (display_format, track_id) tuples for searching
+    track_display_pairs = []
+    for track_id in names:
+        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))
+    
+    # Filter by query (search in display name, display format, and track_id)
+    matching = []
+    for display_format, track_id, display_name in track_display_pairs:
+        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)
+    
+    # Limit results
+    results = matching[:SEARCH_MAX_RESULTS]
     return gr.update(choices=results, value=[])
 
 
 def add_selected(current_selected: list[str], to_add: list[str]):
-    cur = list(dict.fromkeys(current_selected or []))  # preserve order, unique
-    for x in (to_add or []):
-        if x not in cur:
-            cur.append(x)
-    return gr.update(choices=cur, value=cur)  # show + keep all checked
+    """Add tracks to selected list, converting display format to track IDs if needed."""
+    # Extract track IDs from current selection (in case they're in display format)
+    cur_ids = [_extract_track_id(x) for x in (current_selected or [])]
+    cur_display = [_format_track_for_display(tid) for tid in cur_ids]
+    
+    # Extract track IDs from items to add
+    to_add_ids = [_extract_track_id(x) for x in (to_add or [])]
+    
+    # Add new track IDs
+    for tid in to_add_ids:
+        if tid not in cur_ids:
+            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
 
 
 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)
 
@@ -208,15 +321,21 @@ def update_coords_on_species_change(species: str):
 def reset_on_species_change(species: str):
     # Clear results + selected when species changes (avoids mismatched IDs)
     try:
-        _get_bigwig_names(species)  # warms cache if available
+        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]
+        return (
+            gr.update(value=""),          # query textbox
+            gr.update(choices=[], value=[]),  # results list
+            gr.update(choices=formatted_tracks, value=[]),  # selected list (with formatted names)
+        )
     except (ValueError, AttributeError):
         # Species doesn't have bigwigs, that's okay
-        pass
-    return (
-        gr.update(value=""),          # query textbox
-        gr.update(choices=[], value=[]),  # results list
-        gr.update(choices=[], value=[]),  # selected list
-    )
+        return (
+            gr.update(value=""),          # query textbox
+            gr.update(choices=[], value=[]),  # results list
+            gr.update(choices=[], value=[]),  # selected list
+        )
 
 
 # -----------------------------
@@ -236,6 +355,9 @@ def predict(
     if not species:
         raise gr.Error("Species parameter is missing. Please select a species.")
     
+    # Extract track IDs from display format if needed
+    bigwig_selected = [_extract_track_id(tid) for tid in bigwig_selected]
+    
     if use_coords:
         # Check if this species supports coordinate-based fetching
         if species not in SPECIES_WITH_COORDINATE_SUPPORT:
@@ -583,7 +705,9 @@ DEFAULT_BED_ELEMENTS = ["protein_coding_gene", "exon", "intron"]
 
 # Get available BigWig tracks for default species and filter defaults
 _init_bigwig = _get_bigwig_names(DEFAULT_SPECIES)
-_init_bigwig_selected = [tid for tid in DEFAULT_BIGWIG_TRACKS if tid in _init_bigwig]
+_init_bigwig_selected_ids = [tid for tid in DEFAULT_BIGWIG_TRACKS if tid in _init_bigwig]
+# Format for display
+_init_bigwig_selected = [_format_track_for_display(tid) for tid in _init_bigwig_selected_ids]
 
 # Filter default BED elements to only those available
 _init_bed_selected = [elem for elem in DEFAULT_BED_ELEMENTS if elem in _init_bed]
@@ -745,6 +869,37 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
 
     gr.Markdown("## Select functional tracks")
     
+    # Button to download tracks metadata
+    def get_metadata_file_path():
+        """Return path to metadata CSV file for download."""
+        csv_path = Path(__file__).parent / "data" / "functional_tracks_metadata.csv"
+        if csv_path.exists():
+            return str(csv_path)
+        return None
+    
+    metadata_file_path = get_metadata_file_path()
+    download_metadata_btn = gr.Button(
+        "📋 Download metadata for all functional tracks",
+        variant="secondary",
+        visible=metadata_file_path is not None,
+    )
+    metadata_download_file = gr.File(
+        label="Tracks metadata",
+        visible=False,
+    )
+    
+    def download_metadata():
+        """Return metadata file for download."""
+        if metadata_file_path and Path(metadata_file_path).exists():
+            return gr.update(value=metadata_file_path, visible=True)
+        return gr.update(visible=False)
+    
+    download_metadata_btn.click(
+        fn=download_metadata,
+        inputs=[],
+        outputs=[metadata_download_file],
+    )
+    
     bigwig_no_tracks_msg = gr.Markdown(
         "⚠️ No functional genomic tracks available for this species in the current model.",
         visible=False,
@@ -850,6 +1005,17 @@ with gr.Blocks(title="NTv3 Tracks Demo") as demo:
         coords = DEFAULT_COORDS.get(species, DEFAULT_COORDS["human"])
         # Show coordinates only if species is supported AND use_coords is True
         show_coords = is_supported and use_coords_val
+        
+        # Format available tracks for display if species has bigwigs
+        if has_bigwigs:
+            try:
+                track_ids = _get_bigwig_names(species)
+                formatted_tracks = [_format_track_for_display(tid) for tid in track_ids]
+            except:
+                formatted_tracks = []
+        else:
+            formatted_tracks = []
+        
         return (
             gr.update(visible=show_coords, value=coords["chrom"]),
             gr.update(visible=show_coords, value=coords["start"]),
@@ -857,7 +1023,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),  # Show bigwig selection if available
+            gr.update(visible=has_bigwigs, choices=formatted_tracks, value=[]),  # Show bigwig selection 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