Spaces:
Running
Running
| import gradio as gr | |
| import re | |
| import pandas as pd | |
| from io import StringIO | |
| def remove_nested_branches(smiles): | |
| """Remove nested branches from SMILES string""" | |
| result = '' | |
| depth = 0 | |
| for char in smiles: | |
| if char == '(': | |
| depth += 1 | |
| elif char == ')': | |
| depth -= 1 | |
| elif depth == 0: | |
| result += char | |
| return result | |
| def identify_linkage_type(segment): | |
| """ | |
| Identify the type of linkage between residues | |
| Returns: tuple (type, is_n_methylated) | |
| """ | |
| if 'OC(=O)' in segment: | |
| return ('ester', False) | |
| elif 'N(C)C(=O)' in segment: | |
| return ('peptide', True) # N-methylated peptide bond | |
| elif 'NC(=O)' in segment: | |
| return ('peptide', False) # Regular peptide bond | |
| return (None, False) | |
| def identify_residue(segment, next_segment=None, prev_segment=None): | |
| """ | |
| Identify amino acid residues with modifications and special handling for Proline | |
| Returns: tuple (residue, modifications) | |
| """ | |
| modifications = [] | |
| # Check for modifications in the next segment | |
| if next_segment: | |
| if 'N(C)C(=O)' in next_segment: | |
| modifications.append('N-Me') | |
| if 'OC(=O)' in next_segment: | |
| modifications.append('O-linked') | |
| # Special case for Proline - check for CCCN pattern and its cyclization | |
| # Proline can appear in several patterns due to its cyclic nature | |
| if any(pattern in segment for pattern in ['CCCN2', 'N2CCC', '[C@@H]2CCCN2', 'CCCN1', 'N1CCC']): | |
| return ('Pro', modifications) | |
| # Check if this segment is part of a Proline ring by looking at context | |
| if prev_segment and next_segment: | |
| if ('CCC' in segment and 'N' in next_segment) or ('N' in segment and 'CCC' in prev_segment): | |
| combined = prev_segment + segment + next_segment | |
| if re.search(r'CCCN.*C\(=O\)', combined): | |
| return ('Pro', modifications) | |
| # Aromatic amino acids | |
| if 'Cc2ccccc2' in segment or 'c1ccccc1' in segment: | |
| return ('Phe', modifications) | |
| if 'c2ccc(O)cc2' in segment: | |
| return ('Tyr', modifications) | |
| if 'c1c[nH]c2ccccc12' in segment: | |
| return ('Trp', modifications) | |
| if 'c1cnc[nH]1' in segment: | |
| return ('His', modifications) | |
| # Branched chain amino acids | |
| if 'CC(C)C[C@H]' in segment or 'CC(C)C[C@@H]' in segment: | |
| return ('Leu', modifications) | |
| if '[C@H](CC(C)C)' in segment or '[C@@H](CC(C)C)' in segment: | |
| return ('Leu', modifications) | |
| if 'C(C)C' in segment and not any(pat in segment for pat in ['CC(C)C', 'C(C)C[C@H]', 'C(C)C[C@@H]']): | |
| return ('Val', modifications) | |
| if 'C(C)C[C@H]' in segment or 'C(C)C[C@@H]' in segment: | |
| return ('Ile', modifications) | |
| # Small/polar amino acids | |
| if ('[C@H](C)' in segment or '[C@@H](C)' in segment) and 'C(C)C' not in segment: | |
| return ('Ala', modifications) | |
| if '[C@H](CO)' in segment: | |
| return ('Ser', modifications) | |
| if '[C@H](C(C)O)' in segment or '[C@@H](C(C)O)' in segment: | |
| return ('Thr', modifications) | |
| if '[C@H]' in segment and not any(pat in segment for pat in ['C(C)', 'CC', 'O', 'N', 'S']): | |
| return ('Gly', modifications) | |
| # Rest of amino acids remain the same... | |
| # [Previous code for other amino acids] | |
| return (None, modifications) | |
| def parse_peptide(smiles): | |
| """ | |
| Parse peptide sequence with enhanced Proline recognition | |
| """ | |
| # Split on peptide bonds while preserving cycle numbers | |
| bond_pattern = r'(NC\(=O\)|N\(C\)C\(=O\)|N\dC\(=O\)|OC\(=O\))' | |
| segments = re.split(bond_pattern, smiles) | |
| segments = [s for s in segments if s] | |
| sequence = [] | |
| i = 0 | |
| while i < len(segments): | |
| segment = segments[i] | |
| next_segment = segments[i+1] if i+1 < len(segments) else None | |
| prev_segment = segments[i-1] if i > 0 else None | |
| # Skip pure bond patterns | |
| if re.match(r'.*C\(=O\)$', segment): | |
| i += 1 | |
| continue | |
| residue, modifications = identify_residue(segment, next_segment, prev_segment) | |
| if residue: | |
| # Format residue with modifications | |
| formatted_residue = residue | |
| if modifications: | |
| formatted_residue += f"({','.join(modifications)})" | |
| sequence.append(formatted_residue) | |
| i += 1 | |
| is_cyclic = is_cyclic_peptide(smiles) | |
| # Print debug information | |
| print("\nDetailed Analysis:") | |
| print("Segments:", segments) | |
| print("Found sequence:", sequence) | |
| # Format the final sequence | |
| if is_cyclic: | |
| return f"cyclo({'-'.join(sequence)})" | |
| return '-'.join(sequence) | |
| def is_cyclic_peptide(smiles): | |
| """ | |
| Determine if SMILES represents a cyclic peptide by checking: | |
| 1. Proper cycle number pairing | |
| 2. Presence of peptide bonds between cycle points | |
| 3. Distinguishing between aromatic rings and peptide cycles | |
| """ | |
| cycle_info = {} | |
| # Find all cycle numbers and their contexts | |
| for match in re.finditer(r'(\w{3})?(\d)(\w{3})?', smiles): | |
| number = match.group(2) | |
| pre_context = match.group(1) or '' | |
| post_context = match.group(3) or '' | |
| position = match.start(2) | |
| if number not in cycle_info: | |
| cycle_info[number] = [] | |
| cycle_info[number].append({ | |
| 'position': position, | |
| 'pre_context': pre_context, | |
| 'post_context': post_context, | |
| 'full_context': smiles[max(0, position-3):min(len(smiles), position+4)] | |
| }) | |
| # Check each cycle | |
| peptide_cycles = [] | |
| aromatic_cycles = [] | |
| for number, occurrences in cycle_info.items(): | |
| if len(occurrences) != 2: # Must have exactly 2 occurrences | |
| continue | |
| start, end = occurrences[0]['position'], occurrences[1]['position'] | |
| # Get the segment between cycle points | |
| segment = smiles[start:end+1] | |
| clean_segment = remove_nested_branches(segment) | |
| # Check if this is an aromatic ring | |
| is_aromatic = any(context['full_context'].count('c') >= 2 for context in occurrences) | |
| # Check if this is a peptide cycle | |
| has_peptide_bond = 'NC(=O)' in segment or 'N2C(=O)' in segment | |
| if is_aromatic: | |
| aromatic_cycles.append(number) | |
| elif has_peptide_bond: | |
| peptide_cycles.append(number) | |
| return len(peptide_cycles) > 0, peptide_cycles, aromatic_cycles | |
| def analyze_single_smiles(smiles): | |
| """Analyze a single SMILES string""" | |
| try: | |
| is_cyclic, peptide_cycles, aromatic_cycles = is_cyclic_peptide(smiles) | |
| sequence = parse_peptide(smiles) | |
| details = { | |
| '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' | |
| } | |
| return details | |
| except Exception as e: | |
| return { | |
| 'SMILES': smiles, | |
| 'Sequence': f'Error: {str(e)}', | |
| 'Is Cyclic': 'Error', | |
| 'Peptide Cycles': 'Error', | |
| 'Aromatic Cycles': 'Error' | |
| } | |
| def process_input(smiles_input=None, file_obj=None): | |
| """Process either direct SMILES input or file input""" | |
| results = [] | |
| # Handle direct SMILES input | |
| if smiles_input: | |
| result = analyze_single_smiles(smiles_input.strip()) | |
| results.append(result) | |
| # 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 | |
| # Create Gradio interface | |
| iface = gr.Interface( | |
| fn=process_input, | |
| inputs=[ | |
| gr.Textbox( | |
| label="Enter SMILES string", | |
| placeholder="Enter SMILES notation of peptide...", | |
| lines=2 | |
| ), | |
| gr.File( | |
| label="Or upload a text file with SMILES", | |
| file_types=[".txt"], | |
| type="binary" | |
| ) | |
| ], | |
| outputs=gr.Textbox( | |
| label="Analysis Results", | |
| lines=10 | |
| ), | |
| title="Peptide Structure Analyzer", | |
| 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 | |
| Input: Either enter a SMILES string directly or upload a text file with multiple SMILES (one per line) | |
| """, | |
| 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], | |
| # 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] | |
| ], | |
| allow_flagging="never" | |
| ) | |
| # Launch the app | |
| if __name__ == "__main__": | |
| iface.launch() | |