Update app.py

app.py

@@ -645,36 +645,20 @@ 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 and convert to proper types
+    # Validate inputs
     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 and within bounds
-    valid_genes = []
+        
+    # Ensure all gene coordinates are valid integers
     for gene in gene_results:
-        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
-
+        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']}")
+    
     # Image dimensions
     width = 1500
     height = 600
@@ -685,104 +669,131 @@ def create_simple_genome_diagram(gene_results: List[Dict[str, Any]], genome_leng
     img = Image.new('RGB', (width, height), 'white')
     draw = ImageDraw.Draw(img)
     
-    # Use default font if custom font not available
+    # 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 = ImageFont.load_default()
-        title_font = ImageFont.load_default()
+        font = None
+        title_font = None
     
     # Draw title
-    draw.text((margin, margin//2), "Genome SHAP Analysis", fill='black', font=title_font)
+    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)
+    draw.line([(int(margin), int(line_y)), (int(width - margin), int(line_y))], fill='black', width=2)
     
     # Calculate scale factor
-    scale = (width - 2 * margin) / genome_length
+    scale = float(width - 2 * margin) / float(genome_length)
+    
+    # Determine a reasonable step for scale markers (avoid zero step if genome_length<10)
+    num_ticks = 10
+    if genome_length < num_ticks:
+        step = 1
+    else:
+        step = genome_length // num_ticks
     
     # Draw scale markers
-    for i in range(0, genome_length + 1, genome_length // 10):
-        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)
+    # Use min(genome_length, step * num_ticks) in range to avoid overshooting
+    for i in range(0, genome_length + 1, step):
+        x_coord = margin + i * scale
+        draw.line([
+            (int(x_coord), int(line_y - 5)), 
+            (int(x_coord), int(line_y + 5))
+        ], fill='black', width=1)
+        draw.text((int(x_coord - 20), int(line_y + 10)), f"{i:,}", fill='black', font=font)
     
-    # Sort genes by absolute SHAP value
-    sorted_genes = sorted(valid_genes, key=lambda x: abs(float(x['avg_shap'])))
+    # Sort genes by absolute SHAP value for drawing
+    sorted_genes = sorted(gene_results, key=lambda x: abs(x['avg_shap']))
     
     # Draw genes
     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 position and ensure integers
+        start_x = margin + int(gene['start'] * scale)
+        end_x = margin + int(gene['end'] * scale)
         
         # Calculate color based on SHAP value
-        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
+        if gene['avg_shap'] > 0:
+            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+            color = (255, max(0, 255 - intensity), max(0, 255 - intensity))  # Red-ish
         else:
-            intensity = min(255, int(abs(avg_shap * 500)))
-            color = (255 - intensity, 255 - intensity, 255)  # Blue
+            intensity = min(255, int(abs(gene['avg_shap'] * 500)))
+            color = (max(0, 255 - intensity), max(0, 255 - intensity), 255)  # Blue-ish
         
         # 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.rectangle([
+            (int(start_x), int(line_y - track_height // 2)),
+            (int(end_x),   int(line_y + track_height // 2))
+        ], fill=color, outline='black')
         
-        # Draw gene name
-        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
+        # Prepare gene name label
+        label = f"{gene['gene_name']}"
+        label_width, label_height = draw.textsize(label, font=font)
         
-        # Alternate label position above/below
+        # Alternate label positions above/below
         if idx % 2 == 0:
-            text_y = y_top - label_height - 5
+            text_y = line_y - track_height - 15
         else:
-            text_y = y_bottom + 5
+            text_y = line_y + track_height + 5
         
-        # Draw label
+        # Decide to rotate text or not based on available box width
         gene_width = end_x - start_x
         if gene_width > label_width:
-            # Horizontal label
+            # Draw horizontally
             text_x = start_x + (gene_width - label_width) // 2
-            draw.text((text_x, text_y), label, fill='black', font=font)
+            draw.text((int(text_x), int(text_y)), label, fill='black', font=font)
         elif gene_width > 20:
-            # Vertical label
+            # Create rotated text
             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, (start_x, text_y), txt_img)
+            rotated_img = txt_img.rotate(90, expand=True)
+            # Paste at (start_x, text_y) casted to int
+            img.paste(rotated_img, (int(start_x), int(text_y)), rotated_img)
     
     # Draw legend
     legend_x = margin
     legend_y = height - margin
-    draw.text((legend_x, legend_y - 60), "SHAP Values:", fill='black', font=font)
+    draw.text((int(legend_x), int(legend_y - 60)), "SHAP Values:", fill='black', font=font)
     
     # Draw legend boxes
     box_width = 20
     box_height = 20
     spacing = 15
     
-    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))
-    ]
+    # Strong human-like
+    draw.rectangle([
+        (int(legend_x), int(legend_y - 45)), 
+        (int(legend_x + box_width), int(legend_y - 45 + box_height))
+    ], fill=(255, 0, 0), outline='black')
+    draw.text((int(legend_x + box_width + spacing), int(legend_y - 45)), 
+              "Strong human-like signal", fill='black', font=font)
+    
+    # Weak human-like
+    draw.rectangle([
+        (int(legend_x), int(legend_y - 20)), 
+        (int(legend_x + box_width), int(legend_y - 20 + box_height))
+    ], fill=(255, 200, 200), outline='black')
+    draw.text((int(legend_x + box_width + spacing), int(legend_y - 20)), 
+              "Weak 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)
+    # Weak non-human-like
+    draw.rectangle([
+        (int(legend_x + 250), int(legend_y - 45)), 
+        (int(legend_x + 250 + box_width), int(legend_y - 45 + box_height))
+    ], fill=(200, 200, 255), outline='black')
+    draw.text((int(legend_x + 250 + box_width + spacing), int(legend_y - 45)), 
+              "Weak non-human-like signal", fill='black', font=font)
+    
+    # Strong non-human-like
+    draw.rectangle([
+        (int(legend_x + 250), int(legend_y - 20)), 
+        (int(legend_x + 250 + box_width), int(legend_y - 20 + box_height))
+    ], fill=(0, 0, 255), outline='black')
+    draw.text((int(legend_x + 250 + box_width + spacing), int(legend_y - 20)), 
+              "Strong non-human-like signal", fill='black', font=font)
     
     return img
 
@@ -790,7 +801,11 @@ 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"""
+    """
+    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]:
@@ -882,23 +897,17 @@ def analyze_gene_features(sequence_file: str,
     # 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 with robust error handling
+    # Create visualization
     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
@@ -906,10 +915,8 @@ def analyze_gene_features(sequence_file: str,
         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)
+    return results_text, temp_path, diagram_img
+
 
 ###############################################################################
 # 12. DOWNLOAD FUNCTIONS