Update app.py

app.py

@@ -811,125 +811,152 @@ def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_leng
 
 
 
-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. 
-    NOTE: This function assumes there's an `analyze_sequence(...)` function 
-    defined elsewhere that returns the needed SHAP information.
-    """
-    # 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]:
-        return f"Error in sequence analysis: {sequence_results[0]}", None, None
-        
-    # Get SHAP values
-    shap_means = sequence_results[3]["shap_means"]
-    
-    # Parse gene features
-    try:
-        if features_text.strip():
-            genes = parse_gene_features(features_text)
-        else:
-            with open(features_file, 'r') as f:
-                genes = parse_gene_features(f.read())
-    except Exception as e:
-        return f"Error reading features file: {str(e)}", None, None
-            
-    # Analyze each gene
-    gene_results = []
-    for gene in genes:
-        try:
-            location = gene['metadata'].get('location', '')
-            if not location:
-                continue
-                
-            start, end = parse_location(location)
-            if start is None or end is None:
-                continue
-                
-            # Get SHAP values for this region
-            gene_shap = shap_means[start:end]
-            stats = compute_gene_statistics(gene_shap)
-            
-            gene_results.append({
-                'gene_name': gene['metadata'].get('gene', 'Unknown'),
-                'location': location,
-                'start': start,
-                'end': end,
-                'locus_tag': gene['metadata'].get('locus_tag', ''),
-                'avg_shap': stats['avg_shap'],
-                'median_shap': stats['median_shap'],
-                'std_shap': stats['std_shap'],
-                'max_shap': stats['max_shap'],
-                'min_shap': stats['min_shap'],
-                'pos_fraction': stats['pos_fraction'],
-                'classification': 'Human' if stats['avg_shap'] > 0 else 'Non-human',
-                'confidence': abs(stats['avg_shap'])
-            })
-            
-        except Exception as e:
-            print(f"Error processing gene {gene['metadata'].get('gene', 'Unknown')}: {str(e)}")
-            continue
-    
-    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"
-    
-    results_text += "Top 10 most distinctive genes:\n"
-    for gene in sorted_genes[:10]:
-        results_text += (
-            f"Gene: {gene['gene_name']}\n"
-            f"Location: {gene['location']}\n"
-            f"Classification: {gene['classification']} "
-            f"(confidence: {gene['confidence']:.4f})\n"
-            f"Average SHAP: {gene['avg_shap']:.4f}\n\n"
-        )
-    
-    # Create CSV content
-    csv_content = "gene_name,location,avg_shap,median_shap,std_shap,max_shap,min_shap,"
-    csv_content += "pos_fraction,classification,confidence,locus_tag\n"
-    
+def create_simple_genome_diagram(gene_results, genome_length):
+    from PIL import Image, ImageDraw, ImageFont
+
+    # Validate inputs
+    if not gene_results or genome_length <= 0:
+        img = Image.new('RGBA', (800, 100), color=(255, 255, 255, 255))
+        draw = ImageDraw.Draw(img, 'RGBA')
+        draw.text((10, 40), "Error: Invalid input data", fill='black')
+        return img
+
+    # Ensure valid gene coords
     for gene in gene_results:
-        csv_content += (
-            f"{gene['gene_name']},{gene['location']},{gene['avg_shap']:.4f},"
-            f"{gene['median_shap']:.4f},{gene['std_shap']:.4f},{gene['max_shap']:.4f},"
-            f"{gene['min_shap']:.4f},{gene['pos_fraction']:.4f},{gene['classification']},"
-            f"{gene['confidence']:.4f},{gene['locus_tag']}\n"
-        )
-    
-    # Save CSV to temp file
-    try:
-        temp_dir = tempfile.gettempdir()
-        temp_path = os.path.join(temp_dir, f"gene_analysis_{os.urandom(4).hex()}.csv")
-        
-        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
-    
-    # Create visualization
+        gene['start'] = max(0, int(gene['start']))
+        gene['end']   = min(genome_length, int(gene['end']))
+        if gene['start'] >= gene['end']:
+            print(f"Warning: Invalid coordinates for gene {gene.get('gene_name','?')}: "
+                  f"{gene['start']}-{gene['end']}")
+
+    # Dimensions
+    width, height = 1500, 600
+    margin = 50
+    track_height = 40
+
+    # Create RGBA image
+    img = Image.new('RGBA', (width, height), (255, 255, 255, 255))
+    draw = ImageDraw.Draw(img, 'RGBA')
+
+    # Fonts
     try:
-        diagram_img = create_simple_genome_diagram(gene_results, len(shap_means))
-    except Exception as 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
+        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 = ImageFont.load_default()
+        title_font = ImageFont.load_default()
+
+    # Draw title text
+    draw.text((margin, margin // 2), "Genome SHAP Analysis", fill='black', font=title_font)
+
+    # Draw genome line & ticks FIRST (so rectangles are partially see-through)
+    line_y = height // 2
+    draw.line([(margin, line_y), (width - margin, line_y)], fill='black', width=2)
+
+    # Scale factor
+    scale = (width - 2 * margin) / float(genome_length)
+
+    # Ticks
+    num_ticks = 10
+    step = 1 if genome_length < num_ticks else (genome_length // num_ticks)
+    for i in range(0, genome_length + 1, step):
+        x_coord = margin + i * scale
+        draw.line([(int(x_coord), line_y - 5), (int(x_coord), line_y + 5)], 
+                  fill='black', width=1)
+        draw.text((int(x_coord - 20), line_y + 10), f"{i:,}", fill='black', font=font)
+
+    # Sort genes by absolute shap so smaller shap genes get drawn first
+    # (and partially appear behind bigger shap genes).
+    sorted_genes = sorted(gene_results, key=lambda x: abs(x['avg_shap']))
+
+    # Draw gene boxes with partial alpha
+    for idx, gene in enumerate(sorted_genes):
+        start_x = margin + int(gene['start'] * scale)
+        end_x   = margin + int(gene['end'] * scale)
+
+        # Compute color
+        avg_shap = gene['avg_shap']
+        intensity = min(255, int(abs(avg_shap)*500))
+        # clamp a bit so it doesn't look white
+        intensity = max(50, intensity)
+
+        if avg_shap > 0:
+            # Red-ish
+            color = (255, 255 - intensity, 255 - intensity, 180)  
+        else:
+            # Blue-ish
+            color = (255 - intensity, 255 - intensity, 255, 180)  
+
+        # Partially transparent rectangle
+        draw.rectangle([
+            (start_x, line_y - track_height // 2),
+            (end_x,   line_y + track_height // 2)
+        ], fill=color, outline=(0, 0, 0, 255))
+
+        # Label
+        label = gene.get('gene_name', '?')
+        label_mask = font.getmask(label)
+        label_width, label_height = label_mask.size
+
+        # Above or below
+        if idx % 2 == 0:
+            text_y = line_y - track_height - 15
+        else:
+            text_y = line_y + track_height + 5
+
+        # If there's room, draw horizontally; else rotate
+        gene_width = end_x - start_x
+        if gene_width > label_width:
+            text_x = start_x + (gene_width - label_width) // 2
+            draw.text((text_x, text_y), label, fill='black', font=font)
+        elif gene_width > 20:
+            txt_img = Image.new('RGBA', (label_width, label_height), (255, 255, 255, 0))
+            txt_draw = ImageDraw.Draw(txt_img)
+            txt_draw.text((0, 0), label, font=font, fill='black')
+            rotated_img = txt_img.rotate(90, expand=True)
+            img.paste(rotated_img, (int(start_x), int(text_y)), rotated_img)
+
+    # Legend
+    legend_x = margin
+    legend_y = height - margin
+    draw.text((legend_x, legend_y - 60), "SHAP Values:", fill='black', font=font)
+
+    box_width, box_height = 20, 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, 255), outline=(0, 0, 0, 255))
+    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, 255), outline=(0, 0, 0, 255))
+    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, 255), outline=(0, 0, 0, 255))
+    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, 255), outline=(0, 0, 0, 255))
+    draw.text((legend_x + 250 + box_width + spacing, legend_y - 20), 
+              "Strong non-human-like signal", fill='black', font=font)
+
+    return img
+
 
 
 ###############################################################################