add more functions

README.md

@@ -24,7 +24,7 @@ This app analyzes peptide sequences from SMILES notation, identifying:
 The app will return:
 - The parsed peptide sequence
 - Whether the peptide is cyclic
-- Any modifications present
+- Visualize the peptide
 
 ## Examples
 Try the provided example SMILES strings to see how the analyzer works.

app.py

@@ -2,6 +2,37 @@ import gradio as gr
 import re
 import pandas as pd
 from io import StringIO
+import rdkit
+from rdkit import Chem
+from rdkit.Chem import AllChem, Draw
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from io import BytesIO
+
+def is_peptide(smiles):
+    """Check if the SMILES represents a peptide by looking for peptide bonds"""
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return False
+        
+    # Look for peptide bonds: NC(=O) pattern
+    peptide_bond_pattern = Chem.MolFromSmarts('[NH][C](=O)')
+    if mol.HasSubstructMatch(peptide_bond_pattern):
+        return True
+        
+    # Look for N-methylated peptide bonds: N(C)C(=O) pattern
+    n_methyl_pattern = Chem.MolFromSmarts('[N;H0;$(NC)](C)[C](=O)')
+    if mol.HasSubstructMatch(n_methyl_pattern):
+        return True
+        
+    # Look for ester bonds in cyclic depsipeptides: OC(=O) pattern
+    ester_bond_pattern = Chem.MolFromSmarts('O[C](=O)')
+    if mol.HasSubstructMatch(ester_bond_pattern):
+        return True
+        
+    return False
 
 def remove_nested_branches(smiles):
     """Remove nested branches from SMILES string"""
@@ -15,6 +46,7 @@ def remove_nested_branches(smiles):
         elif depth == 0:
             result += char
     return result
+
 def identify_linkage_type(segment):
     """
     Identify the type of linkage between residues
@@ -189,53 +221,219 @@ def analyze_single_smiles(smiles):
         sequence = parse_peptide(smiles)
         
         details = {
-            'SMILES': smiles,
+            #'SMILES': smiles,
             'Sequence': sequence,
             'Is Cyclic': 'Yes' if is_cyclic else 'No',
-            'Peptide Cycles': ', '.join(peptide_cycles) if peptide_cycles else 'None',
-            'Aromatic Cycles': ', '.join(aromatic_cycles) if aromatic_cycles else 'None'
+            #'Peptide Cycles': ', '.join(peptide_cycles) if peptide_cycles else 'None',
+            #'Aromatic Cycles': ', '.join(aromatic_cycles) if aromatic_cycles else 'None'
         }
         return details
         
     except Exception as e:
         return {
-            'SMILES': smiles,
+            #'SMILES': smiles,
             'Sequence': f'Error: {str(e)}',
             'Is Cyclic': 'Error',
-            'Peptide Cycles': 'Error',
-            'Aromatic Cycles': 'Error'
+            #'Peptide Cycles': 'Error',
+            #'Aromatic Cycles': 'Error'
         }
 
-def process_input(smiles_input=None, file_obj=None):
-    """Process either direct SMILES input or file input"""
+def annotate_cyclic_structure(mol, sequence):
+    """Create annotated 2D structure with clear, non-overlapping residue labels"""
+    # Generate 2D coordinates
+    AllChem.Compute2DCoords(mol)
+    
+    # Create drawer with larger size for annotations
+    drawer = Draw.rdMolDraw2D.MolDraw2DCairo(2000, 2000)  # Even larger size
+    
+    # Get residue list
+    if sequence.startswith('cyclo('):
+        residues = sequence[6:-1].split('-')
+    else:
+        residues = sequence.split('-')
+    
+    # Draw molecule first to get its bounds
+    drawer.drawOptions().addAtomIndices = False
+    drawer.DrawMolecule(mol)
+    drawer.FinishDrawing()
+    
+    # Convert to PIL Image
+    img = Image.open(BytesIO(drawer.GetDrawingText()))
+    draw = ImageDraw.Draw(img)
+    font = ImageFont.load_default(60)
+    small_font = ImageFont.load_default(60)
+
+    # Get molecule bounds
+    conf = mol.GetConformer()
+    positions = []
+    for i in range(mol.GetNumAtoms()):
+        pos = conf.GetAtomPosition(i)
+        positions.append((pos.x, pos.y))
+    
+    x_coords = [p[0] for p in positions]
+    y_coords = [p[1] for p in positions]
+    min_x, max_x = min(x_coords), max(x_coords)
+    min_y, max_y = min(y_coords), max(y_coords)
+    
+    # Calculate scaling factors
+    scale = 150  # Increased scale factor
+    center_x = 1000  # Image center
+    center_y = 1000
+    
+    # Add residue labels in a circular arrangement around the structure
+    n_residues = len(residues)
+    radius = 700  # Distance of labels from center
+    
+    for i, residue in enumerate(residues):
+        # Calculate position in a circle around the structure
+        angle = (2 * np.pi * i / n_residues) - np.pi/2  # Start from top
+        
+        # Calculate label position
+        label_x = center_x + radius * np.cos(angle)
+        label_y = center_y + radius * np.sin(angle)
+        
+        # Draw residue label
+        # Add white background for better visibility
+        text = f"{i+1}. {residue}"
+        bbox = draw.textbbox((label_x, label_y), text, font=font)
+        padding = 10
+        draw.rectangle([bbox[0]-padding, bbox[1]-padding, 
+                       bbox[2]+padding, bbox[3]+padding], 
+                      fill='white', outline='white')
+        draw.text((label_x, label_y), text, 
+                 font=font, fill='black', anchor="mm")
+    
+    # Add sequence at the top with white background
+    seq_text = f"Sequence: {sequence}"
+    bbox = draw.textbbox((center_x, 100), seq_text, font=small_font)
+    padding = 10
+    draw.rectangle([bbox[0]-padding, bbox[1]-padding, 
+                   bbox[2]+padding, bbox[3]+padding], 
+                  fill='white', outline='white')
+    draw.text((center_x, 100), seq_text, 
+             font=small_font, fill='black', anchor="mm")
+    
+    return img
+
+def create_linear_peptide_viz(sequence):
+    """
+    Create a linear representation of peptide with residue annotations
+    """
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=(15, 5))
+    ax.set_xlim(0, 10)
+    ax.set_ylim(0, 2)
+    
+    # Parse sequence to get residues
+    if sequence.startswith('cyclo('):
+        residues = sequence[6:-1].split('-')  # Remove cyclo() and split
+    else:
+        residues = sequence.split('-')
+    
+    num_residues = len(residues)
+    spacing = 9.0 / (num_residues - 1)  # Leave margins on sides
+    
+    # Draw peptide backbone
+    y_pos = 1.5
+    for i in range(num_residues):
+        x_pos = 0.5 + i * spacing
+        
+        # Draw amino acid box
+        rect = patches.Rectangle((x_pos-0.3, y_pos-0.2), 0.6, 0.4, 
+                               facecolor='lightblue', edgecolor='black')
+        ax.add_patch(rect)
+        
+        # Draw peptide bond
+        if i < num_residues - 1:
+            ax.plot([x_pos+0.3, x_pos+spacing-0.3], [y_pos, y_pos], 
+                   color='black', linestyle='-', linewidth=2)
+        
+        # Add residue label with larger font
+        ax.text(x_pos, y_pos-0.5, residues[i], ha='center', va='top', fontsize=14)
+    
+    # If cyclic, add arrow connecting ends
+    if sequence.startswith('cyclo('):
+        ax.annotate('', xy=(9.5, y_pos), xytext=(0.5, y_pos),
+                   arrowprops=dict(arrowstyle='<->', color='red', lw=2))
+        ax.text(5, y_pos+0.3, 'Cyclic Connection', ha='center', color='red', fontsize=14)
+    
+    # Add sequence at the top
+    ax.text(5, 1.9, f"Sequence: {sequence}", ha='center', va='bottom', fontsize=12)
+    
+    # Remove axes
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.axis('off')
+    
+    return fig
+
+def process_input(smiles_input=None, file_obj=None, show_linear=False):
+    """Process input and create visualizations"""
     results = []
+    images = []
     
     # Handle direct SMILES input
     if smiles_input:
-        result = analyze_single_smiles(smiles_input.strip())
-        results.append(result)
+        smiles = smiles_input.strip()
+        
+        # First check if it's a peptide
+        if not is_peptide(smiles):
+            return "Error: Input SMILES does not appear to be a peptide structure.", None, None
+            
+        try:
+            # Create molecule
+            mol = Chem.MolFromSmiles(smiles)
+            if mol is None:
+                return "Error: Invalid SMILES notation.", None, None
+            
+            # Get sequence and cyclic information
+            sequence = parse_peptide(smiles)
+            is_cyclic, peptide_cycles, aromatic_cycles = is_cyclic_peptide(smiles)
+            
+            # Create cyclic structure visualization
+            img_cyclic = annotate_cyclic_structure(mol, sequence)
+            
+            # Create linear representation if requested
+            img_linear = None
+            if show_linear:
+                fig_linear = create_linear_peptide_viz(sequence)
+                
+                # Convert matplotlib figure to image
+                buf = BytesIO()
+                fig_linear.savefig(buf, format='png', bbox_inches='tight', dpi=300)
+                buf.seek(0)
+                img_linear = Image.open(buf)
+                plt.close(fig_linear)
+            
+            # Format text output
+            output_text = f"Sequence: {sequence}\n"
+            output_text += f"Is Cyclic: {'Yes' if is_cyclic else 'No'}\n"
+            
+            return output_text, img_cyclic, img_linear
+            
+        except Exception as e:
+            return f"Error processing SMILES: {str(e)}", None, None
     
     # Handle file input
     if file_obj is not None:
-        content = file_obj.decode('utf-8')
-        for line in StringIO(content):
-            smiles = line.strip()
-            if smiles:  # Skip empty lines
-                result = analyze_single_smiles(smiles)
-                results.append(result)
-    
-    # Create formatted output
-    output_text = ""
-    for i, result in enumerate(results, 1):
-        output_text += f"Entry {i}:\n"
-        output_text += f"SMILES: {result['SMILES']}\n"
-        output_text += f"Sequence: {result['Sequence']}\n"
-        output_text += f"Is Cyclic: {result['Is Cyclic']}\n"
-        output_text += f"Peptide Cycles: {result['Peptide Cycles']}\n"
-        output_text += f"Aromatic Cycles: {result['Aromatic Cycles']}\n"
-        output_text += "-" * 50 + "\n"
-    
-    return output_text
+        try:
+            content = file_obj.decode('utf-8')
+            output_text = ""
+            for line in StringIO(content):
+                smiles = line.strip()
+                if smiles:
+                    if not is_peptide(smiles):
+                        output_text += f"Skipping non-peptide SMILES: {smiles}\n"
+                        continue
+                    result = analyze_single_smiles(smiles)
+                    output_text += f"Sequence: {result['Sequence']}\n"
+                    output_text += f"Is Cyclic: {result['Is Cyclic']}\n"
+                    output_text += "-" * 50 + "\n"
+            return output_text, None, None
+        except Exception as e:
+            return f"Error processing file: {str(e)}", None, None
+    
+    return "No input provided.", None, None
 
 # Create Gradio interface
 iface = gr.Interface(
@@ -250,30 +448,46 @@ iface = gr.Interface(
             label="Or upload a text file with SMILES",
             file_types=[".txt"],
             type="binary"
+        ),
+        gr.Checkbox(
+            label="Show linear representation",
+            value=False
         )
     ],
-    outputs=gr.Textbox(
-        label="Analysis Results",
-        lines=10
-    ),
-    title="Peptide Structure Analyzer",
+    outputs=[
+        gr.Textbox(
+            label="Analysis Results",
+            lines=10
+        ),
+        gr.Image(
+            label="2D Structure with Annotations",
+            type="pil"
+        ),
+        gr.Image(
+            label="Linear Representation",
+            type="pil",
+            visible=lambda x: x  # Only show when checkbox is checked
+        )
+    ],
+    title="Peptide Structure Analyzer and Visualizer",
     description="""
-    Analyze peptide structures from SMILES notation to:
-    1. Determine if the peptide is cyclic
-    2. Identify peptide cycles vs aromatic rings
-    3. Parse the amino acid sequence
+    Analyze and visualize peptide structures from SMILES notation:
+    1. Validates if the input is a peptide structure
+    2. Determines if the peptide is cyclic
+    3. Parses the amino acid sequence
+    4. Creates 2D structure visualization with residue annotations
+    5. Optional linear representation
     
-    Input: Either enter a SMILES string directly or upload a text file with multiple SMILES (one per line)
+    Input: Either enter a SMILES string directly or upload a text file
     """,
     examples=[
         # Example cyclic peptide with Proline
-        ["CC(C)C[C@@H]1NC(=O)[C@@H]2CCCN2C(=O)[C@@H](CC(C)C)NC(=O)[C@@H](CC(C)C)N(C)C(=O)[C@H](C)NC(=O)[C@H](Cc2ccccc2)NC1=O", None],
+        ["CC(C)C[C@@H]1NC(=O)[C@@H]2CCCN2C(=O)[C@@H](CC(C)C)NC(=O)[C@@H](CC(C)C)N(C)C(=O)[C@H](C)NC(=O)[C@H](Cc2ccccc2)NC1=O", None, True],
         # Example cyclic peptide with ester bond
-        ["CC(C)C[C@@H]1OC(=O)[C@H](C)NC(=O)[C@H](C(C)C)OC(=O)[C@H](C)N(C)C(=O)[C@@H](C)NC(=O)[C@@H](Cc2ccccc2)N(C)C1=O", None]
+        ["CC(C)C[C@@H]1OC(=O)[C@H](C)NC(=O)[C@H](C(C)C)OC(=O)[C@H](C)N(C)C(=O)[C@@H](C)NC(=O)[C@@H](Cc2ccccc2)N(C)C1=O", None, True]
     ],
     allow_flagging="never"
 )
-
 # Launch the app
 if __name__ == "__main__":
     iface.launch()

requirements.txt

@@ -1,2 +1,6 @@
 gradio==4.19.2
 pandas==2.2.0
+rdkit==2023.9.1
+Pillow==10.0.0
+matplotlib==3.7.1
+numpy>=1.24.3