Update app.py

app.py

@@ -567,16 +567,20 @@ def analyze_sequence_comparison(file1, file2, fasta1="", fasta2=""):
 # 11. GENE FEATURE ANALYSIS
 ###############################################################################
 
+import io
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import pandas as pd
+import tempfile
+import os
+from typing import List, Dict, Tuple, Optional, Any
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+import seaborn as sns
+
 def parse_gene_features(text: str) -> List[Dict[str, Any]]:
-    """
-    Parse gene features from text file in FASTA-like format
-    
-    Args:
-        text (str): Input text in FASTA format with gene metadata
-        
-    Returns:
-        List[Dict]: List of gene dictionaries containing sequence and metadata
-    """
+    """Parse gene features from text file in FASTA-like format"""
     genes = []
     current_header = None
     current_sequence = []
@@ -608,15 +612,7 @@ def parse_gene_features(text: str) -> List[Dict[str, Any]]:
     return genes
 
 def parse_gene_metadata(header: str) -> Dict[str, str]:
-    """
-    Extract metadata from gene header
-    
-    Args:
-        header (str): Gene header line starting with '>'
-        
-    Returns:
-        Dict[str, str]: Dictionary of metadata key-value pairs
-    """
+    """Extract metadata from gene header"""
     metadata = {}
     parts = header.split()
     
@@ -629,18 +625,9 @@ def parse_gene_metadata(header: str) -> Dict[str, str]:
     return metadata
 
 def parse_location(location_str: str) -> Tuple[Optional[int], Optional[int]]:
-    """
-    Parse gene location string, handling both forward and complement strands
-    
-    Args:
-        location_str (str): Location string (e.g., "1234..5678" or "complement(1234..5678)")
-        
-    Returns:
-        Tuple[Optional[int], Optional[int]]: Start and end positions, or (None, None) if parsing fails
-    """
+    """Parse gene location string, handling both forward and complement strands"""
     try:
-        # Handle complement strand
-        is_complement = location_str.startswith('complement(')
+        # Remove 'complement(' and ')' if present
         clean_loc = location_str.replace('complement(', '').replace(')', '')
         
         # Split on '..' and convert to integers
@@ -649,43 +636,12 @@ def parse_location(location_str: str) -> Tuple[Optional[int], Optional[int]]:
             return start, end
         else:
             return None, None
-            
     except Exception as e:
         print(f"Error parsing location {location_str}: {str(e)}")
         return None, None
 
-def save_results_to_temp(results: str, prefix: str = "analysis") -> Optional[str]:
-    """
-    Save results to a temporary file
-    
-    Args:
-        results (str): Content to save
-        prefix (str): Prefix for the temporary file name
-        
-    Returns:
-        Optional[str]: Path to temporary file, or None if save fails
-    """
-    try:
-        temp_dir = tempfile.gettempdir()
-        temp_path = os.path.join(temp_dir, f"{prefix}_{os.urandom(4).hex()}.csv")
-        
-        with open(temp_path, 'w') as f:
-            f.write(results)
-        return temp_path
-    except Exception as e:
-        print(f"Error saving results: {str(e)}")
-        return None
-
 def compute_gene_statistics(gene_shap: np.ndarray) -> Dict[str, float]:
-    """
-    Compute statistical measures for gene SHAP values
-    
-    Args:
-        gene_shap (np.ndarray): Array of SHAP values for a gene
-        
-    Returns:
-        Dict[str, float]: Dictionary of statistical measures
-    """
+    """Compute statistical measures for gene SHAP values"""
     return {
         'avg_shap': float(np.mean(gene_shap)),
         'median_shap': float(np.median(gene_shap)),
@@ -695,25 +651,132 @@ def compute_gene_statistics(gene_shap: np.ndarray) -> Dict[str, float]:
         'pos_fraction': float(np.mean(gene_shap > 0))
     }
 
+def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_length: int) -> Image.Image:
+    """Create a simple genome diagram using PIL"""
+    # Image dimensions
+    width = 1500
+    height = 600
+    margin = 50
+    track_height = 40
+    
+    # Create image with white background
+    img = Image.new('RGB', (width, height), 'white')
+    draw = ImageDraw.Draw(img)
+    
+    # Try to load font, fall back to default if unavailable
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 12)
+        title_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
+    except:
+        font = None
+        title_font = None
+    
+    # Draw title
+    draw.text((margin, margin//2), "Genome SHAP Analysis", 
+              fill='black', font=title_font or font)
+    
+    # Draw genome line
+    line_y = height // 2
+    draw.line([(margin, line_y), (width - margin, line_y)], fill='black', width=2)
+    
+    # Calculate scale factor
+    scale = (width - 2 * margin) / genome_length
+    
+    # Draw scale markers
+    for i in range(0, genome_length + 1, genome_length // 10):
+        x = margin + i * scale
+        draw.line([(x, line_y - 5), (x, line_y + 5)], fill='black', width=1)
+        draw.text((x - 20, line_y + 10), f"{i:,}", fill='black', font=font)
+    
+    # Sort genes by absolute SHAP value for drawing
+    sorted_genes = sorted(gene_results, key=lambda x: abs(x['avg_shap']))
+    
+    # Draw genes
+    for gene in sorted_genes:
+        # Calculate position
+        start_x = margin + gene['start'] * scale
+        end_x = margin + gene['end'] * scale
+        
+        # Calculate color based on SHAP value
+        if gene['avg_shap'] > 0:
+            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+            color = (255, 255 - intensity, 255 - intensity)  # Red
+        else:
+            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+            color = (255 - intensity, 255 - intensity, 255)  # Blue
+        
+        # Draw gene box
+        draw.rectangle([
+            (start_x, line_y - track_height // 2),
+            (end_x, line_y + track_height // 2)
+        ], fill=color, outline='black')
+        
+        # Draw gene name
+        label = f"{gene['gene_name']}"
+        label_bbox = draw.textbbox((0, 0), label, font=font)
+        label_width = label_bbox[2] - label_bbox[0]
+        
+        # Try to place label, alternating above and below
+        if sorted_genes.index(gene) % 2 == 0:
+            text_y = line_y - track_height - 15
+        else:
+            text_y = line_y + track_height + 5
+        
+        # Draw label with rotation if space is tight
+        gene_width = end_x - start_x
+        if gene_width > label_width:
+            # Horizontal label
+            text_x = start_x + (gene_width - label_width) // 2
+            draw.text((text_x, text_y), label, fill='black', font=font)
+        elif gene_width > 20:
+            # Create rotated text image
+            txt_img = Image.new('RGBA', (label_width, 20), (255, 255, 255, 0))
+            txt_draw = ImageDraw.Draw(txt_img)
+            txt_draw.text((0, 0), label, font=font, fill='black')
+            txt_img = txt_img.rotate(90, expand=True)
+            img.paste(txt_img, (int(start_x), text_y), txt_img)
+    
+    # Draw legend
+    legend_x = margin
+    legend_y = height - margin
+    draw.text((legend_x, legend_y - 60), "SHAP Values:", fill='black', font=font)
+    
+    # Draw legend boxes
+    box_width = 20
+    box_height = 20
+    spacing = 15
+    
+    # Strong human-like
+    draw.rectangle([(legend_x, legend_y - 45, legend_x + box_width, legend_y - 45 + box_height)], 
+                  fill=(255, 0, 0), outline='black')
+    draw.text((legend_x + box_width + spacing, legend_y - 45), 
+              "Strong human-like signal", fill='black', font=font)
+    
+    # Weak human-like
+    draw.rectangle([(legend_x, legend_y - 20, legend_x + box_width, legend_y - 20 + box_height)], 
+                  fill=(255, 200, 200), outline='black')
+    draw.text((legend_x + box_width + spacing, legend_y - 20), 
+              "Weak human-like signal", fill='black', font=font)
+    
+    # Weak non-human-like
+    draw.rectangle([(legend_x + 250, legend_y - 45, legend_x + 250 + box_width, legend_y - 45 + box_height)], 
+                  fill=(200, 200, 255), outline='black')
+    draw.text((legend_x + 250 + box_width + spacing, legend_y - 45), 
+              "Weak non-human-like signal", fill='black', font=font)
+    
+    # Strong non-human-like
+    draw.rectangle([(legend_x + 250, legend_y - 20, legend_x + 250 + box_width, legend_y - 20 + box_height)], 
+                  fill=(0, 0, 255), outline='black')
+    draw.text((legend_x + 250 + box_width + spacing, legend_y - 20), 
+              "Strong non-human-like signal", fill='black', font=font)
+    
+    return img
+
 def analyze_gene_features(sequence_file: str, 
                         features_file: str, 
                         fasta_text: str = "", 
                         features_text: str = "") -> Tuple[str, Optional[str], Optional[Image.Image]]:
-    """
-    Analyze SHAP values for each gene feature
-    
-    Args:
-        sequence_file (str): Path to FASTA file
-        features_file (str): Path to features file
-        fasta_text (str): FASTA content if provided as text
-        features_text (str): Features content if provided as text
-        
-    Returns:
-        Tuple[str, Optional[str], Optional[Image.Image]]: 
-            - Analysis results text
-            - Path to CSV file
-            - Genome diagram image
-    """
+    """Analyze SHAP values for each gene feature"""
     # First analyze whole sequence
     sequence_results = analyze_sequence(sequence_file, top_kmers=10, fasta_text=fasta_text)
     if isinstance(sequence_results[0], str) and "Error" in sequence_results[0]:
@@ -771,16 +834,16 @@ def analyze_gene_features(sequence_file: str,
     if not gene_results:
         return "No valid genes could be processed", None, None
             
+    # Sort genes by absolute SHAP value
+    sorted_genes = sorted(gene_results, key=lambda x: abs(x['avg_shap']), reverse=True)
+    
     # Create results text
     results_text = "Gene Analysis Results:\n\n"
     results_text += f"Total genes analyzed: {len(gene_results)}\n"
     results_text += f"Human-like genes: {sum(1 for g in gene_results if g['classification'] == 'Human')}\n"
     results_text += f"Non-human-like genes: {sum(1 for g in gene_results if g['classification'] == 'Non-human')}\n\n"
     
-    # Sort genes by absolute SHAP value for reporting
-    sorted_genes = sorted(gene_results, key=lambda x: abs(x['avg_shap']), reverse=True)
-    
-    results_text += "Top 10 genes by signal strength:\n"
+    results_text += "Top 10 most distinctive genes:\n"
     for gene in sorted_genes[:10]:
         results_text += (
             f"Gene: {gene['gene_name']}\n"
@@ -803,99 +866,28 @@ def analyze_gene_features(sequence_file: str,
         )
     
     # Save CSV to temp file
-    csv_path = save_results_to_temp(csv_content, "gene_analysis")
-    
     try:
-        # Create genome diagram
-        diagram_img = create_genome_diagram(gene_results, len(shap_means))
-    except Exception as e:
-        print(f"Error creating genome diagram: {str(e)}")
-        diagram_img = create_error_image(str(e))
-    
-    return results_text, csv_path, diagram_img
-
-def create_error_image(error_message: str) -> Image.Image:
-    """
-    Create an error image with message
-    
-    Args:
-        error_message (str): Error message to display
+        temp_dir = tempfile.gettempdir()
+        temp_path = os.path.join(temp_dir, f"gene_analysis_{os.urandom(4).hex()}.csv")
         
-    Returns:
-        Image.Image: Error image
-    """
-    img = Image.new('RGB', (800, 100), color='white')
-    draw = ImageDraw.Draw(img)
-    try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 12)
-    except:
-        font = None
-    draw.text((10, 40), f"Error creating genome diagram: {error_message}", 
-              fill='black', font=font)
-    return img
-
-def create_genome_diagram(gene_results: List[Dict[str, Any]], 
-                        genome_length: int) -> Image.Image:
-    """
-    Create genome diagram using BioPython
+        with open(temp_path, 'w') as f:
+            f.write(csv_content)
+    except Exception as e:
+        print(f"Error saving CSV: {str(e)}")
+        temp_path = None
     
-    Args:
-        gene_results (List[Dict]): List of gene analysis results
-        genome_length (int): Total length of the genome
-        
-    Returns:
-        Image.Image: Genome diagram image
-    """
+    # Create visualization
     try:
-        # Create diagram
-        gd_diagram = GenomeDiagram.Diagram("Genome SHAP Analysis")
-        gd_track = gd_diagram.new_track(1, name="Genes")
-        gd_feature_set = gd_track.new_set()
-        
-        # Add features
-        for gene in gene_results:
-            # Create feature
-            feature = SeqFeature(
-                FeatureLocation(gene['start'], gene['end']),
-                type="gene"
-            )
-            
-            # Calculate color based on SHAP value
-            if gene['avg_shap'] > 0:
-                intensity = min(1.0, abs(gene['avg_shap']) * 2)
-                color = colors.Color(1-intensity, 1-intensity, 1)  # Red
-            else:
-                intensity = min(1.0, abs(gene['avg_shap']) * 2)
-                color = colors.Color(1-intensity, 1-intensity, 1)  # Blue
-                
-            # Add to diagram
-            gd_feature_set.add_feature(
-                feature,
-                color=color,
-                label=True,
-                name=f"{gene['gene_name']}\n(SHAP: {gene['avg_shap']:.3f})"
-            )
-        
-        # Draw diagram
-        gd_diagram.draw(
-            format="linear",
-            orientation="landscape",
-            pagesize=(15, 5),
-            start=0,
-            end=genome_length,
-            fragments=1
-        )
-        
-        # Save to BytesIO and convert to PIL Image
-        buffer = io.BytesIO()
-        gd_diagram.write(buffer, "PNG")
-        buffer.seek(0)
-        return Image.open(buffer)
-        
+        diagram_img = create_simple_genome_diagram(gene_results, len(shap_means))
     except Exception as e:
-        print(f"Error creating genome diagram: {str(e)}")
-        return create_error_image(str(e))
-
+        print(f"Error creating visualization: {str(e)}")
+        # Create error image
+        diagram_img = Image.new('RGB', (800, 100), color='white')
+        draw = ImageDraw.Draw(diagram_img)
+        draw.text((10, 40), f"Error creating visualization: {str(e)}", fill='black')
+    
+    return results_text, temp_path, diagram_img
+    
 ###############################################################################
 # 12. DOWNLOAD FUNCTIONS
 ###############################################################################