Update app.py

app.py

@@ -645,19 +645,36 @@ def compute_gene_statistics(gene_shap: np.ndarray) -> Dict[str, float]:
 
 def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_length: int) -> Image.Image:
     """Create a simple genome diagram using PIL"""
-    # Validate inputs
+    # Validate inputs and convert to proper types
     if not gene_results or genome_length <= 0:
         img = Image.new('RGB', (800, 100), color='white')
         draw = ImageDraw.Draw(img)
         draw.text((10, 40), "Error: Invalid input data", fill='black')
         return img
-        
-    # Ensure all gene coordinates are valid integers
+
+    # Ensure all gene coordinates are valid integers and within bounds
+    valid_genes = []
     for gene in gene_results:
-        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['gene_name']}: {gene['start']}-{gene['end']}")
+        try:
+            start = max(0, int(float(gene['start'])))
+            end = min(genome_length, int(float(gene['end'])))
+            if start < end:
+                gene_copy = gene.copy()
+                gene_copy['start'] = start
+                gene_copy['end'] = end
+                valid_genes.append(gene_copy)
+            else:
+                print(f"Warning: Skipping gene {gene.get('gene_name', 'unknown')} due to invalid coordinates: {start}-{end}")
+        except (ValueError, TypeError) as e:
+            print(f"Warning: Skipping gene due to coordinate conversion error: {str(e)}")
+            continue
+
+    if not valid_genes:
+        img = Image.new('RGB', (800, 100), color='white')
+        draw = ImageDraw.Draw(img)
+        draw.text((10, 40), "Error: No valid genes to display", fill='black')
+        return img
+
     # Image dimensions
     width = 1500
     height = 600
@@ -668,17 +685,16 @@ def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_leng
     img = Image.new('RGB', (width, height), 'white')
     draw = ImageDraw.Draw(img)
     
-    # Try to load font, fall back to default if unavailable
+    # Use default font if custom font not available
     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
+        font = ImageFont.load_default()
+        title_font = ImageFont.load_default()
     
     # Draw title
-    draw.text((margin, margin//2), "Genome SHAP Analysis", 
-              fill='black', font=title_font or font)
+    draw.text((margin, margin//2), "Genome SHAP Analysis", fill='black', font=title_font)
     
     # Draw genome line
     line_y = height // 2
@@ -689,57 +705,62 @@ def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_leng
     
     # Draw scale markers
     for i in range(0, genome_length + 1, genome_length // 10):
-        x = int(margin + i * scale)
+        x = margin + int(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']))
+    # Sort genes by absolute SHAP value
+    sorted_genes = sorted(valid_genes, key=lambda x: abs(float(x['avg_shap'])))
     
     # Draw genes
-    for gene in sorted_genes:
-        # Calculate position and ensure integers
-        start_x = int(margin + gene['start'] * scale)
-        end_x = int(margin + gene['end'] * scale)
+    for idx, gene in enumerate(sorted_genes):
+        # Calculate position
+        start_x = margin + int(float(gene['start']) * scale)
+        end_x = margin + int(float(gene['end']) * scale)
         
         # Calculate color based on SHAP value
-        if gene['avg_shap'] > 0:
-            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+        avg_shap = float(gene['avg_shap'])
+        if avg_shap > 0:
+            intensity = min(255, int(abs(avg_shap * 500)))
             color = (255, 255 - intensity, 255 - intensity)  # Red
         else:
-            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+            intensity = min(255, int(abs(avg_shap * 500)))
             color = (255 - intensity, 255 - intensity, 255)  # Blue
         
-        # Draw gene box with integer coordinates
-        draw.rectangle([
-            (start_x, int(line_y - track_height // 2)),
-            (end_x, int(line_y + track_height // 2))
-        ], fill=color, outline='black')
+        # Draw gene box
+        y_top = line_y - track_height // 2
+        y_bottom = line_y + track_height // 2
+        draw.rectangle([(start_x, y_top), (end_x, y_bottom)], 
+                      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]
+        label = str(gene['gene_name'])
+        # Get text size for positioning
+        if hasattr(font, 'getsize'):
+            label_width, label_height = font.getsize(label)
+        else:
+            label_width = len(label) * 6  # Approximate width
+            label_height = 12
         
-        # Try to place label, alternating above and below
-        if sorted_genes.index(gene) % 2 == 0:
-            text_y = line_y - track_height - 15
+        # Alternate label position above/below
+        if idx % 2 == 0:
+            text_y = y_top - label_height - 5
         else:
-            text_y = line_y + track_height + 5
+            text_y = y_bottom + 5
         
-        # Draw label with rotation if space is tight
+        # Draw label
         gene_width = end_x - start_x
         if gene_width > label_width:
             # Horizontal label
-            text_x = int(start_x + (gene_width - label_width) // 2)
-            draw.text((text_x, int(text_y)), label, fill='black', font=font)
+            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))
+            # Vertical label
+            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')
             txt_img = txt_img.rotate(90, expand=True)
-            img.paste(txt_img, (int(start_x), text_y), txt_img)
+            img.paste(txt_img, (start_x, text_y), txt_img)
     
     # Draw legend
     legend_x = margin
@@ -751,213 +772,145 @@ def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_leng
     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)
+    legend_items = [
+        ((255, 0, 0), "Strong human-like signal", (legend_x, legend_y - 45)),
+        ((255, 200, 200), "Weak human-like signal", (legend_x, legend_y - 20)),
+        ((200, 200, 255), "Weak non-human-like signal", (legend_x + 250, legend_y - 45)),
+        ((0, 0, 255), "Strong non-human-like signal", (legend_x + 250, legend_y - 20))
+    ]
     
-    # 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)
+    for color, label, (x, y) in legend_items:
+        draw.rectangle([(x, y, x + box_width, y + box_height)], 
+                      fill=color, outline='black')
+        draw.text((x + box_width + spacing, y), label, fill='black', font=font)
     
     return img
 
-def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_length: int) -> Image.Image:
-    """Create a simple genome diagram using PIL with proper coordinate handling"""
-    # Validate inputs and ensure genome_length is an integer
-    if not gene_results or not isinstance(genome_length, int) or genome_length <= 0:
-        img = Image.new('RGB', (800, 100), color='white')
-        draw = ImageDraw.Draw(img)
-        draw.text((10, 40), "Error: Invalid input data", fill='black')
-        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"""
+    # 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"]
     
-    # Pre-process gene coordinates and handle type conversion
-    processed_genes = []
-    for gene in gene_results:
-        try:
-            # Ensure start and end are integers
-            start = int(float(gene['start']))
-            end = int(float(gene['end']))
+    # 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
             
-            # Validate coordinates
-            if start < 0 or end > genome_length or start >= end:
-                print(f"Warning: Skipping gene {gene.get('gene_name', 'unknown')} due to invalid coordinates: {start}-{end}")
+    # Analyze each gene
+    gene_results = []
+    for gene in genes:
+        try:
+            location = gene['metadata'].get('location', '')
+            if not location:
                 continue
                 
-            processed_gene = gene.copy()
-            processed_gene['start'] = start
-            processed_gene['end'] = end
-            processed_genes.append(processed_gene)
-        except (ValueError, TypeError) as e:
-            print(f"Warning: Error processing gene coordinates: {str(e)}")
-            continue
-    
-    if not processed_genes:
-        img = Image.new('RGB', (800, 100), color='white')
-        draw = ImageDraw.Draw(img)
-        draw.text((10, 40), "Error: No valid genes to display", fill='black')
-        return img
-    
-    # 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
-    line_coords = [(margin, line_y), (width - margin, line_y)]
-    draw.line(line_coords, fill='black', width=2)
-    
-    # Calculate scale factor
-    scale = float(width - 2 * margin) / float(genome_length)
-    
-    # Draw scale markers
-    for i in range(0, genome_length + 1, max(1, genome_length // 10)):
-        x = int(margin + i * scale)
-        marker_coords = [(x, line_y - 5), (x, line_y + 5)]
-        draw.line(marker_coords, 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(processed_genes, key=lambda x: abs(float(x.get('avg_shap', 0))))
-    
-    # Draw genes
-    for gene in sorted_genes:
-        try:
-            # Calculate position
-            start_x = int(margin + gene['start'] * scale)
-            end_x = int(margin + gene['end'] * scale)
-            
-            # Ensure minimum visible width
-            if end_x - start_x < 2:
-                end_x = start_x + 2
-            
-            # Calculate color based on SHAP value
-            avg_shap = float(gene.get('avg_shap', 0))
-            if avg_shap > 0:
-                intensity = min(255, int(abs(avg_shap * 500)))
-                color = (255, 255 - intensity, 255 - intensity)  # Red
-            else:
-                intensity = min(255, int(abs(avg_shap * 500)))
-                color = (255 - intensity, 255 - intensity, 255)  # Blue
-            
-            # Draw gene box
-            box_coords = [
-                start_x,
-                int(line_y - track_height // 2),
-                end_x,
-                int(line_y + track_height // 2)
-            ]
-            draw.rectangle(box_coords, fill=color, outline='black')
-            
-            # Draw gene name
-            label = str(gene.get('gene_name', 'Unknown'))
-            if font:
-                label_bbox = draw.textbbox((0, 0), label, font=font)
-                label_width = label_bbox[2] - label_bbox[0]
-            else:
-                label_width = len(label) * 6  # Rough estimate if no font
+            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)
             
-            # 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
+            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'])
+            })
             
-            # Draw label with rotation if space is tight
-            gene_width = end_x - start_x
-            if gene_width > label_width:
-                # Horizontal label
-                text_x = int(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)
-        
         except Exception as e:
-            print(f"Warning: Error drawing gene {gene.get('gene_name', 'unknown')}: {str(e)}")
+            print(f"Error processing gene {gene['metadata'].get('gene', 'Unknown')}: {str(e)}")
             continue
     
-    # Draw legend
-    legend_x = margin
-    legend_y = height - margin
-    draw.text((legend_x, legend_y - 60), "SHAP Values:", fill='black', font=font)
+    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)
     
-    # Draw legend boxes
-    box_width = 20
-    box_height = 20
-    spacing = 15
+    # 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"
     
-    # 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)
+    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"
+        )
     
-    # 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)
+    # 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"
     
-    # 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)
+    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"
+        )
     
-    # 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)
+    # Save CSV to temp file
+    try:
+        temp_dir = tempfile.gettempdir()
+        temp_path = None
     
-    return img
+    # Create visualization with robust error handling
+    try:
+        # Ensure all gene coordinates are numeric and valid
+        for gene in gene_results:
+            try:
+                gene['start'] = int(float(gene['start']))
+                gene['end'] = int(float(gene['end']))
+                if gene['start'] >= gene['end']:
+                    raise ValueError(f"Invalid coordinates for gene {gene['gene_name']}: {gene['start']}-{gene['end']}")
+            except (ValueError, TypeError) as e:
+                print(f"Warning: Invalid coordinates for gene {gene['gene_name']}: {str(e)}")
+                continue
+        
+        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 os.path.join(temp_dir, f"gene_analysis_{os.urandom(4).hex()}.csv")
+        
+        with open(temp_path, 'w') as f:
+            f.write(csv_content)
+
 ###############################################################################
 # 12. DOWNLOAD FUNCTIONS
 ###############################################################################