Restore colorful clusters in state-dynamic plots

- Keep colorful Set1 palette for cluster visualization
- Viridis gradient for position coloring
- Green/red start/end markers
- Monochrome styling only for UI elements, not data viz

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -642,9 +642,8 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
     hover_text = [f"Window {i}<br>Position: {pos}-{pos+1000} bp<br>Cluster: {c}"
                   for i, (pos, c) in enumerate(zip(positions, cluster_labels))]
 
-    # Monochrome grayscale palette for clusters
-    grays = [f'rgba({int(40 + i * 180 / n_clusters)}, {int(40 + i * 180 / n_clusters)}, {int(40 + i * 180 / n_clusters)}, 0.8)'
-             for i in range(n_clusters)]
+    # Colorful palette for clusters
+    colors = px.colors.qualitative.Set1[:n_clusters]
 
     if use_3d:
         fig = go.Figure()
@@ -655,12 +654,12 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
             y=embedding_reduced[:, 1],
             z=embedding_reduced[:, 2],
             mode='lines',
-            line=dict(color='rgba(113,113,122,0.3)', width=2),
+            line=dict(color='rgba(100,100,100,0.3)', width=2),
             name='Trajectory',
             hoverinfo='skip'
         ))
 
-        # Points - grayscale colorscale
+        # Points - colorful by cluster
         fig.add_trace(go.Scatter3d(
             x=embedding_reduced[:, 0],
             y=embedding_reduced[:, 1],
@@ -669,7 +668,7 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
             marker=dict(
                 size=5,
                 color=cluster_labels,
-                colorscale='Greys',
+                colorscale='Set1',
                 opacity=0.85,
                 line=dict(width=0.5, color='white')
             ),
@@ -678,22 +677,22 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
             name='Windows'
         ))
 
-        # Start marker - dark
+        # Start marker - green
         fig.add_trace(go.Scatter3d(
             x=[embedding_reduced[0, 0]],
             y=[embedding_reduced[0, 1]],
             z=[embedding_reduced[0, 2]],
             mode='markers',
-            marker=dict(size=10, color='#18181b', symbol='diamond'),
+            marker=dict(size=10, color='green', symbol='diamond'),
             name="5' start"
         ))
-        # End marker - medium gray
+        # End marker - red
         fig.add_trace(go.Scatter3d(
             x=[embedding_reduced[-1, 0]],
             y=[embedding_reduced[-1, 1]],
             z=[embedding_reduced[-1, 2]],
             mode='markers',
-            marker=dict(size=10, color='#71717a', symbol='square'),
+            marker=dict(size=10, color='red', symbol='square'),
             name="3' end"
         ))
 
@@ -739,7 +738,7 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
                 x=embedding_reduced[mask, 0],
                 y=embedding_reduced[mask, 1],
                 mode='markers',
-                marker=dict(size=7, color=grays[c],
+                marker=dict(size=7, color=colors[c], opacity=0.8,
                            line=dict(width=0.5, color='white')),
                 text=[hover_text[i] for i in np.where(mask)[0]],
                 hovertemplate='%{text}<extra></extra>',
@@ -750,24 +749,24 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
         # Start/End markers
         fig.add_trace(go.Scatter(
             x=[embedding_reduced[0, 0]], y=[embedding_reduced[0, 1]],
-            mode='markers', marker=dict(size=12, color='#18181b', symbol='triangle-up',
-                                        line=dict(width=1, color='white')),
+            mode='markers', marker=dict(size=12, color='green', symbol='triangle-up',
+                                        line=dict(width=1, color='black')),
             name="5'", showlegend=True
         ), row=1, col=1)
         fig.add_trace(go.Scatter(
             x=[embedding_reduced[-1, 0]], y=[embedding_reduced[-1, 1]],
-            mode='markers', marker=dict(size=12, color='#71717a', symbol='square',
-                                        line=dict(width=1, color='white')),
+            mode='markers', marker=dict(size=12, color='red', symbol='square',
+                                        line=dict(width=1, color='black')),
             name="3'", showlegend=True
         ), row=1, col=1)
 
-        # Right plot: by position - grayscale gradient
+        # Right plot: by position - viridis gradient
         fig.add_trace(go.Scatter(
             x=embedding_reduced[:, 0],
             y=embedding_reduced[:, 1],
             mode='lines+markers',
-            line=dict(color='rgba(113,113,122,0.2)', width=1),
-            marker=dict(size=7, color=np.arange(n_windows), colorscale='Greys',
+            line=dict(color='rgba(100,100,100,0.3)', width=1),
+            marker=dict(size=7, color=np.arange(n_windows), colorscale='Viridis',
                        showscale=True, colorbar=dict(title=dict(text='window', font=dict(size=10)),
                                                      x=1.02, tickfont=dict(size=9))),
             text=hover_text,
@@ -777,25 +776,25 @@ def create_interactive_state_plot(embeddings, n_clusters=8, stride=100, use_3d=F
 
         fig.add_trace(go.Scatter(
             x=[embedding_reduced[0, 0]], y=[embedding_reduced[0, 1]],
-            mode='markers', marker=dict(size=12, color='#18181b', symbol='triangle-up',
-                                        line=dict(width=1, color='white')),
+            mode='markers', marker=dict(size=12, color='green', symbol='triangle-up',
+                                        line=dict(width=1, color='black')),
             showlegend=False
         ), row=1, col=2)
         fig.add_trace(go.Scatter(
             x=[embedding_reduced[-1, 0]], y=[embedding_reduced[-1, 1]],
-            mode='markers', marker=dict(size=12, color='#71717a', symbol='square',
-                                        line=dict(width=1, color='white')),
+            mode='markers', marker=dict(size=12, color='red', symbol='square',
+                                        line=dict(width=1, color='black')),
             showlegend=False
         ), row=1, col=2)
 
-        # Bottom: sequence map - grayscale blocks
+        # Bottom: sequence map - colorful blocks
         window_size = 1000
         for i, (cluster, pos) in enumerate(zip(cluster_labels, positions)):
             fig.add_trace(go.Scatter(
                 x=[pos, pos + window_size, pos + window_size, pos, pos],
                 y=[0, 0, 1, 1, 0],
                 fill='toself',
-                fillcolor=grays[cluster],
+                fillcolor=colors[cluster],
                 line=dict(width=0),
                 hoverinfo='text',
                 text=f'Position {pos}-{pos+window_size} bp<br>Cluster {cluster}',
@@ -918,50 +917,64 @@ def create_sequence_viewer_html(sequence, positions, probabilities, threshold=0.
 
 def predict(sequence: str, stride: int = 100, threshold: float = 0.3):
     """Predict CRISPR array probability for each position."""
-    import tempfile
     import csv
     import time
 
     start_time = time.time()
 
-    sequence = strip_fasta_header(sequence.strip())
+    is_valid, sequence, error = normalize_sequence_input(sequence)
+    if not is_valid:
+        return prediction_error_outputs(error)
+
+    is_valid, stride, error = validate_stride(stride)
+    if not is_valid:
+        return prediction_error_outputs(error)
 
-    is_valid, error = validate_sequence(sequence)
+    is_valid, threshold, error = validate_threshold(threshold)
     if not is_valid:
-        return None, f"**Error**: {error}", None, None, None, None, None, None, None
+        return prediction_error_outputs(error)
 
     result = predict_sequence(sequence, stride=stride, aggregation="mean")
 
-    # Detect regions first (needed for plot annotations)
-    regions = detect_crispr_regions(sequence, threshold=threshold, min_length=100, stride=stride)
+    # Reuse the prediction result so the model only runs once per analysis.
+    regions = detect_crispr_regions(
+        sequence,
+        threshold=threshold,
+        min_length=100,
+        stride=stride,
+        prediction_result=result,
+    )
+
+    # User-facing coordinates are 1-based. Core inference stays 0-based.
+    display_positions = [pos + 1 for pos in result.positions]
 
     # Create interactive Plotly plot
-    fig = create_interactive_prediction_plot(result.positions, result.probabilities, threshold, regions)
+    fig = create_interactive_prediction_plot(display_positions, result.probabilities, threshold, regions)
 
     # Create static matplotlib plot for PNG/PDF export
-    static_fig = create_prediction_plot(result.positions, result.probabilities, threshold, regions)
-    png_path, pdf_path = save_figure_to_file(static_fig, "crispr_prediction")
+    output_dir = make_output_dir("crispr_prediction")
+    static_fig = create_prediction_plot(display_positions, result.probabilities, threshold, regions)
+    png_path, pdf_path = save_figure_to_file(static_fig, "crispr_prediction", output_dir)
     plt.close(static_fig)
 
     # Create CSV with prediction data
-    temp_dir = tempfile.gettempdir()
-    csv_path = os.path.join(temp_dir, "crispr_predictions.csv")
+    csv_path = os.path.join(output_dir, "crispr_predictions.csv")
     with open(csv_path, 'w', newline='') as f:
         writer = csv.writer(f)
-        writer.writerow(['position', 'probability', 'above_threshold'])
+        writer.writerow(['position_1based', 'probability', 'above_threshold'])
         for pos, prob in zip(result.positions, result.probabilities):
-            writer.writerow([pos, f"{prob:.4f}", prob >= threshold])
+            writer.writerow([pos + 1, f"{prob:.4f}", prob >= threshold])
 
     # Create GFF3 export
-    gff_path = create_gff3_export(regions, result.sequence_length) if regions else None
+    gff_path = create_gff3_export(regions, result.sequence_length, output_dir=output_dir) if regions else None
 
     # Create sequence viewer HTML
-    seq_viewer_html = create_sequence_viewer_html(sequence, result.positions, result.probabilities, threshold)
+    seq_viewer_html = create_sequence_viewer_html(sequence, display_positions, result.probabilities, threshold)
 
     elapsed_time = time.time() - start_time
 
     # Create summary text file
-    summary_path = os.path.join(temp_dir, "crispr_summary.txt")
+    summary_path = os.path.join(output_dir, "crispr_summary.txt")
     summary_text = f"""CRISPR Array Detection Summary
 ==============================
 
@@ -1008,9 +1021,15 @@ Detected CRISPR Regions: {len(regions)}
 
 def detect(sequence: str, threshold: float = 0.3, min_length: int = 160):
     """Detect CRISPR array regions."""
-    sequence = strip_fasta_header(sequence.strip())
+    is_valid, sequence, error = normalize_sequence_input(sequence)
+    if not is_valid:
+        return [], f"**Error**: {error}"
+
+    is_valid, threshold, error = validate_threshold(threshold)
+    if not is_valid:
+        return [], f"**Error**: {error}"
 
-    is_valid, error = validate_sequence(sequence)
+    is_valid, min_length, error = validate_min_length(min_length)
     if not is_valid:
         return [], f"**Error**: {error}"
 
@@ -1031,20 +1050,16 @@ def detect(sequence: str, threshold: float = 0.3, min_length: int = 160):
     return regions, summary
 
 
-def save_figure_to_file(fig, prefix="plot"):
+def save_figure_to_file(fig, prefix="plot", output_dir=None):
     """Save matplotlib figure to temporary files for download."""
-    import tempfile
-    import os
-
-    # Create temp directory if needed
-    temp_dir = tempfile.gettempdir()
+    output_dir = output_dir or make_output_dir(prefix)
 
     # Save PNG
-    png_path = os.path.join(temp_dir, f"{prefix}.png")
+    png_path = os.path.join(output_dir, f"{prefix}.png")
     fig.savefig(png_path, dpi=150, bbox_inches='tight', facecolor='white')
 
     # Save PDF
-    pdf_path = os.path.join(temp_dir, f"{prefix}.pdf")
+    pdf_path = os.path.join(output_dir, f"{prefix}.pdf")
     fig.savefig(pdf_path, bbox_inches='tight', facecolor='white')
 
     return png_path, pdf_path
@@ -1052,14 +1067,19 @@ def save_figure_to_file(fig, prefix="plot"):
 
 def get_embedding(sequence: str, mode: str = "mean", use_3d: bool = False):
     """Extract hidden state embedding and visualize as heatmap."""
-    sequence = strip_fasta_header(sequence.strip())
+    allowed_modes = {"state-dynamics", "mean", "max", "trajectory", "cls"}
+    if mode not in allowed_modes:
+        return embedding_error_outputs(
+            "Mode must be one of: state-dynamics, mean, max, trajectory, cls"
+        )
 
-    is_valid, error = validate_sequence(sequence)
+    is_valid, sequence, error = normalize_sequence_input(sequence)
     if not is_valid:
-        return None, f"**Error**: {error}", None, None
+        return embedding_error_outputs(error)
 
     result = embed_sequence(sequence, mode="trajectory" if mode == "state-dynamics" else mode)
     png_path, pdf_path = None, None
+    output_dir = make_output_dir("crispr_embedding")
 
     if mode == "trajectory":
         # Create trajectory heatmap (windows x dimensions)
@@ -1067,7 +1087,7 @@ def get_embedding(sequence: str, mode: str = "mean", use_3d: bool = False):
             result.embeddings,
             title="Embedding Trajectory Across Sequence"
         )
-        png_path, pdf_path = save_figure_to_file(fig, "trajectory_embedding")
+        png_path, pdf_path = save_figure_to_file(fig, "trajectory_embedding", output_dir)
         summary = f"""## Trajectory Embedding
 
 | Property | Value |
@@ -1090,7 +1110,7 @@ Blue = negative activation, Red = positive activation.
 
         # For downloads, create a static matplotlib version
         static_fig = create_state_dynamic_plot(embeddings, n_clusters=n_clusters, stride=100)
-        png_path, pdf_path = save_figure_to_file(static_fig, "state_dynamic_plot")
+        png_path, pdf_path = save_figure_to_file(static_fig, "state_dynamic_plot", output_dir)
         plt.close(static_fig)
 
         dim_text = "3D" if use_3d else "2D"
@@ -1121,7 +1141,7 @@ Blue = negative activation, Red = positive activation.
             result.embedding,
             title=f"Sequence Embedding ({result.method})"
         )
-        png_path, pdf_path = save_figure_to_file(fig, f"embedding_{mode}")
+        png_path, pdf_path = save_figure_to_file(fig, f"embedding_{mode}", output_dir)
         summary = f"""## Embedding Extracted
 
 | Property | Value |
@@ -1138,7 +1158,18 @@ Blue = negative activation, Red = positive activation.
 
 
 # Build interface
-with gr.Blocks(title="CRISPR Array Detection") as demo:
+with gr.Blocks(
+    title="CRISPR Array Detection",
+    theme=gr.themes.Base(
+        primary_hue=gr.themes.colors.zinc,
+        secondary_hue=gr.themes.colors.zinc,
+        neutral_hue=gr.themes.colors.zinc,
+        font=gr.themes.GoogleFont("Inter"),
+        font_mono=gr.themes.GoogleFont("Geist Mono"),
+    ),
+    css=CUSTOM_CSS,
+    delete_cache=(3600, 86400),
+) as demo:
     gr.Markdown("""
 # crispr-detect
 
@@ -1224,14 +1255,17 @@ Sliding window analysis with per-position probability scores. Export to GFF3/CSV
             results = predict(*args)
             # results = (fig, summary, regions, png, pdf, csv, summary_txt, gff, seq_html)
             # Return results plus visibility updates for accordions
-            return results + (gr.update(visible=True), gr.update(visible=True))
+            success = results[0] is not None
+            return results + (gr.update(visible=success), gr.update(visible=success))
 
         predict_btn.click(
             predict_and_show_downloads,
             inputs=[seq_input, stride_input, threshold_input],
             outputs=[plot_output, result_summary, regions_output, pred_download_png, pred_download_pdf,
                      pred_download_csv, pred_download_summary, pred_download_gff, seq_viewer_html,
-                     download_accordion, seq_viewer_accordion]
+                     download_accordion, seq_viewer_accordion],
+            api_name="predict",
+            concurrency_limit=1,
         )
 
     with gr.Tab("Embeddings"):
@@ -1289,12 +1323,15 @@ Repeats cluster together, spacers form distinct groups.
 
         def embed_and_show_downloads(*args):
             results = get_embedding(*args)
-            return results + (gr.update(visible=True),)
+            success = results[0] is not None
+            return results + (gr.update(visible=success),)
 
         embed_btn.click(
             embed_and_show_downloads,
             inputs=[embed_seq, embed_mode, use_3d],
-            outputs=[embed_plot, embed_summary, download_png, download_pdf, embed_download_accordion]
+            outputs=[embed_plot, embed_summary, download_png, download_pdf, embed_download_accordion],
+            api_name="get_embedding",
+            concurrency_limit=1,
         )
 
     with gr.Tab("API"):
@@ -1365,15 +1402,10 @@ if __name__ == "__main__":
     model = get_model()
     warmup_model(model)
     print(f"Model ready! GPU: {get_gpu_status()}")
+    demo.queue(max_size=QUEUE_MAX_SIZE, default_concurrency_limit=1)
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        theme=gr.themes.Base(
-            primary_hue=gr.themes.colors.zinc,
-            secondary_hue=gr.themes.colors.zinc,
-            neutral_hue=gr.themes.colors.zinc,
-            font=gr.themes.GoogleFont("Inter"),
-            font_mono=gr.themes.GoogleFont("Geist Mono"),
-        ),
-        css=CUSTOM_CSS
+        max_threads=4,
+        show_error=True,
     )