Spaces:
Running
Running
| import os | |
| import gradio_client.utils as client_utils | |
| # Monkey path gradio_client issue | |
| _original = client_utils._json_schema_to_python_type | |
| def _safe_json_schema_to_python_type(schema, defs=None): | |
| if isinstance(schema, bool): | |
| return "Any" | |
| return _original(schema, defs) | |
| client_utils._json_schema_to_python_type = _safe_json_schema_to_python_type | |
| client_utils.json_schema_to_python_type = _safe_json_schema_to_python_type | |
| import gradio as gr | |
| import gradio.blocks | |
| 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 | |
| import tempfile | |
| from rdkit import Chem | |
| from swisssidechain import all_aminos | |
| class PeptideAnalyzer: | |
| def __init__(self): | |
| self.bond_patterns = [ | |
| #(r'OC\(=O\)', 'ester'), # Ester bond | |
| (r'N\(C\)C\(=O\)', 'n_methyl'), # N-methylated peptide bond | |
| (r'N[0-9]C\(=O\)', 'proline'), # Proline peptide bond | |
| (r'NC\(=O\)', 'peptide'), # Standard peptide bond | |
| (r'C\(=O\)N\(C\)', 'n_methyl_reverse'), # Reverse N-methylated | |
| (r'C\(=O\)N[12]?', 'peptide_reverse') # Reverse peptide bond | |
| ] | |
| self.complex_residue_patterns = [ | |
| (r'\[C[@]H\]\(CCCNC\(=O\)CCC\[C@@H\]\(NC\(=O\)CCCCCCCCCCCCCCCC\)C\(=O\)OC\(C\)\(C\)C\)', 'Kpg'), | |
| (r'CCCCCCCCCCCCCCCCC\(=O\)N\[C@H\]\(CCCC\(=O\)NCCC\[C@@H\]', 'Kpg'), | |
| (r'\[C@*H\]\(CSC\(c\d+ccccc\d+\)\(c\d+ccccc\d+\)c\d+ccc\(OC\)cc\d+\)', 'Cmt'), | |
| (r'CSC\(c.*?c.*?OC\)', 'Cmt'), | |
| (r'COc.*?ccc\(C\(SC', 'Cmt'), | |
| (r'c2ccccc2\)c2ccccc2\)cc', 'Cmt'), | |
| # Glu(OAll) | |
| (r'C=CCOC\(=O\)CC\[C@@H\]', 'Eal'), | |
| (r'\(C\)OP\(=O\)\(O\)OCc\d+ccccc\d+', 'Tpb'), | |
| #(r'COc\d+ccc\(C\(SC\[C@@H\]\d+.*?\)\(c\d+ccccc\d+\)c\d+ccccc\d+\)cc\d+', 'Cmt-cyclic'), | |
| # Dtg - Asp(OtBu)-(Dmb)Gly | |
| (r'CN\(Cc\d+ccc\(OC\)cc\d+OC\)C\(=O\)\[C@H\]\(CC\(=O\)OC\(C\)\(C\)C\)', 'Dtg'), | |
| (r'C\(=O\)N\(CC\d+=C\(C=C\(C=C\d+\)OC\)OC\)CC\(=O\)', 'Dtg'), | |
| (r'N\[C@@H\]\(CC\(=O\)OC\(C\)\(C\)C\)C\(=O\)N\(CC\d+=C\(C=C\(C=C\d+\)OC\)OC\)CC\(=O\)', 'Dtg'), | |
| ] | |
| # Three to one letter code mapping | |
| self.three_to_one = { | |
| 'Ala': 'A', 'Cys': 'C', 'Asp': 'D', 'Glu': 'E', | |
| 'Phe': 'F', 'Gly': 'G', 'His': 'H', 'Ile': 'I', | |
| 'Lys': 'K', 'Leu': 'L', 'Met': 'M', 'Asn': 'N', | |
| 'Pro': 'P', 'Gln': 'Q', 'Arg': 'R', 'Ser': 'S', | |
| 'Thr': 'T', 'Val': 'V', 'Trp': 'W', 'Tyr': 'Y', | |
| 'ala': 'a', 'cys': 'c', 'asp': 'd', 'glu': 'e', | |
| 'phe': 'f', 'gly': 'g', 'his': 'h', 'ile': 'i', | |
| 'lys': 'k', 'leu': 'l', 'met': 'm', 'asn': 'n', | |
| 'pro': 'p', 'gln': 'q', 'arg': 'r', 'ser': 's', | |
| 'thr': 't', 'val': 'v', 'trp': 'w', 'tyr': 'y', 'Cmt-cyclic': 'Ĉ', | |
| 'Aib': 'Ŷ', 'Dtg': 'Ĝ', 'Cmt': 'Ĉ', 'Eal': 'Ė', 'Nml': "Ŀ", 'Nma': 'Ṃ', | |
| 'Kpg': 'Ƙ', 'Tpb': 'Ṯ', 'Cyl': 'Ċ', 'Nle': 'Ł', 'Hph': 'Ĥ', 'Cys-Cys': 'CC', 'cys-cys': 'cc', | |
| } | |
| self._build_swisssidechain_lookups() | |
| def _build_swisssidechain_lookups(self): | |
| """Side chain lookups for SwissSidechain UAAs""" | |
| # Exact SMILES match | |
| self.exact_smiles_lookup = {} | |
| # Clean SMILES lookup (without stereochemistry) | |
| self.clean_smiles_lookup = {} | |
| for uaa_name, uaa_data in all_aminos.items(): | |
| code = uaa_data["Code"] | |
| letter = uaa_data["Letter"] | |
| smiles = uaa_data["SMILES"] | |
| self.three_to_one[code] = letter | |
| self.exact_smiles_lookup[smiles] = code | |
| # Clean SMILES (no stereochemistry) | |
| clean_smiles = self._remove_stereochemistry(smiles) | |
| if clean_smiles not in self.clean_smiles_lookup: | |
| self.clean_smiles_lookup[clean_smiles] = [] | |
| self.clean_smiles_lookup[clean_smiles].append(code) | |
| def _remove_stereochemistry(self, smiles): | |
| """Remove stereochemistry from SMILES""" | |
| cleaned = smiles | |
| stereochemistry_patterns = [ | |
| '[C@@H]', '[C@H]', '[C@@]', '[C@]', | |
| '[S@@]', '[S@]', '[N@@]', '[N@]', | |
| '@@', '@' | |
| ] | |
| for pattern in stereochemistry_patterns: | |
| cleaned = cleaned.replace(pattern, pattern.replace('@@', '').replace('@', '').replace('[', '').replace(']', '')) | |
| return cleaned | |
| def preprocess_complex_residues(self, smiles): | |
| """Identify and protect complex residues with internal peptide bonds - improved to prevent overlaps""" | |
| complex_positions = [] | |
| for pattern, residue_type in self.complex_residue_patterns: | |
| for match in re.finditer(pattern, smiles): | |
| if not any(pos['start'] <= match.start() < pos['end'] or | |
| pos['start'] < match.end() <= pos['end'] for pos in complex_positions): | |
| complex_positions.append({ | |
| 'start': match.start(), | |
| 'end': match.end(), | |
| 'type': residue_type, | |
| 'pattern': match.group() | |
| }) | |
| complex_positions.sort(key=lambda x: x['start']) | |
| if not complex_positions: | |
| return smiles, [] | |
| preprocessed_smiles = smiles | |
| offset = 0 | |
| protected_residues = [] | |
| for pos in complex_positions: | |
| start = pos['start'] + offset | |
| end = pos['end'] + offset | |
| complex_part = preprocessed_smiles[start:end] | |
| if not ('[C@H]' in complex_part or '[C@@H]' in complex_part): | |
| continue | |
| placeholder = f"COMPLEX_RESIDUE_{len(protected_residues)}" | |
| preprocessed_smiles = preprocessed_smiles[:start] + placeholder + preprocessed_smiles[end:] | |
| offset += len(placeholder) - (end - start) | |
| protected_residues.append({ | |
| 'placeholder': placeholder, | |
| 'type': pos['type'], | |
| 'content': complex_part | |
| }) | |
| return preprocessed_smiles, protected_residues | |
| def split_on_bonds(self, smiles, protected_residues=None): | |
| """Split SMILES into segments based on peptide bonds, with improved handling of protected residues""" | |
| positions = [] | |
| used = set() | |
| # Handle protected complex residues if any | |
| if protected_residues: | |
| for residue in protected_residues: | |
| match = re.search(residue['placeholder'], smiles) | |
| if match: | |
| positions.append({ | |
| 'start': match.start(), | |
| 'end': match.end(), | |
| 'type': 'complex', | |
| 'pattern': residue['placeholder'], | |
| 'residue_type': residue['type'], | |
| 'content': residue['content'] | |
| }) | |
| used.update(range(match.start(), match.end())) | |
| # Find all peptide bonds | |
| bond_positions = [] | |
| # Find Gly pattern first | |
| gly_pattern = r'NCC\(=O\)' | |
| for match in re.finditer(gly_pattern, smiles): | |
| if not any(p in range(match.start(), match.end()) for p in used): | |
| bond_positions.append({ | |
| 'start': match.start(), | |
| 'end': match.end(), | |
| 'type': 'gly', | |
| 'pattern': match.group() | |
| }) | |
| used.update(range(match.start(), match.end())) | |
| for pattern, bond_type in self.bond_patterns: | |
| for match in re.finditer(pattern, smiles): | |
| if not any(p in range(match.start(), match.end()) for p in used): | |
| bond_positions.append({ | |
| 'start': match.start(), | |
| 'end': match.end(), | |
| 'type': bond_type, | |
| 'pattern': match.group() | |
| }) | |
| used.update(range(match.start(), match.end())) | |
| bond_positions.sort(key=lambda x: x['start']) | |
| all_positions = positions + bond_positions | |
| all_positions.sort(key=lambda x: x['start']) | |
| segments = [] | |
| if all_positions and all_positions[0]['start'] > 0: | |
| segments.append({ | |
| 'content': smiles[0:all_positions[0]['start']], | |
| 'bond_after': all_positions[0]['pattern'] if all_positions[0]['type'] != 'complex' else None, | |
| 'complex_after': all_positions[0]['pattern'] if all_positions[0]['type'] == 'complex' else None | |
| }) | |
| for i in range(len(all_positions)-1): | |
| current = all_positions[i] | |
| next_pos = all_positions[i+1] | |
| if current['type'] == 'complex': | |
| segments.append({ | |
| 'content': current['content'], | |
| 'bond_before': all_positions[i-1]['pattern'] if i > 0 and all_positions[i-1]['type'] != 'complex' else None, | |
| 'bond_after': next_pos['pattern'] if next_pos['type'] != 'complex' else None, | |
| 'complex_type': current['residue_type'] | |
| }) | |
| elif current['type'] == 'gly': | |
| segments.append({ | |
| 'content': 'NCC(=O)', | |
| 'bond_before': all_positions[i-1]['pattern'] if i > 0 and all_positions[i-1]['type'] != 'complex' else None, | |
| 'bond_after': next_pos['pattern'] if next_pos['type'] != 'complex' else None | |
| }) | |
| else: | |
| content = smiles[current['end']:next_pos['start']] | |
| if content and next_pos['type'] != 'complex': | |
| segments.append({ | |
| 'content': content, | |
| 'bond_before': current['pattern'], | |
| 'bond_after': next_pos['pattern'] if next_pos['type'] != 'complex' else None | |
| }) | |
| # Last segment | |
| if all_positions and all_positions[-1]['end'] < len(smiles): | |
| if all_positions[-1]['type'] == 'complex': | |
| segments.append({ | |
| 'content': all_positions[-1]['content'], | |
| 'bond_before': all_positions[-2]['pattern'] if len(all_positions) > 1 and all_positions[-2]['type'] != 'complex' else None, | |
| 'complex_type': all_positions[-1]['residue_type'] | |
| }) | |
| else: | |
| segments.append({ | |
| 'content': smiles[all_positions[-1]['end']:], | |
| 'bond_before': all_positions[-1]['pattern'] | |
| }) | |
| return segments | |
| def is_peptide(self, smiles): | |
| """Check if the SMILES represents a peptide structure""" | |
| 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 | |
| return False | |
| def is_cyclic(self, smiles): | |
| # Check for C-terminal carboxyl | |
| if smiles.endswith('C(=O)O'): | |
| return False, [], [] | |
| # Find all numbers used in ring closures | |
| ring_numbers = re.findall(r'(?:^|[^c])[0-9](?=[A-Z@\(\)])', smiles) | |
| # Aromatic ring numbers | |
| aromatic_matches = re.findall(r'c[0-9](?:ccccc|c\[nH\]c)[0-9]', smiles) | |
| aromatic_cycles = [] | |
| for match in aromatic_matches: | |
| numbers = re.findall(r'[0-9]', match) | |
| aromatic_cycles.extend(numbers) | |
| peptide_cycles = [n for n in ring_numbers if n not in aromatic_cycles] | |
| is_cyclic = len(peptide_cycles) > 0 and not smiles.endswith('C(=O)O') | |
| return is_cyclic, peptide_cycles, aromatic_cycles | |
| def clean_terminal_carboxyl(self, segment): | |
| """Remove C-terminal carboxyl only if it's the true terminus""" | |
| content = segment['content'] | |
| # Only clean if: | |
| # 1. Contains C(=O)O | |
| # 2. No bond_after exists (meaning it's the last segment) | |
| if 'C(=O)O' in content and not segment.get('bond_after'): | |
| # Remove C(=O)O pattern regardless of position | |
| cleaned = re.sub(r'\(C\(=O\)O\)', '', content) | |
| # Remove any leftover empty parentheses | |
| cleaned = re.sub(r'\(\)', '', cleaned) | |
| return cleaned | |
| return content | |
| def identify_residue(self, segment): | |
| if 'complex_type' in segment: | |
| return segment['complex_type'], [] | |
| content = self.clean_terminal_carboxyl(segment) | |
| mods = self.get_modifications(segment) | |
| if content.startswith('COc1ccc(C(SC[C@@H]'): | |
| print("DIRECT MATCH: Found Cmt at beginning") | |
| return 'Cmt', mods | |
| if '[C@@H]3CCCN3C2=O)(c2ccccc2)c2ccccc2)cc' in content: | |
| print("DIRECT MATCH: Found Pro at end") | |
| return 'Pro', mods | |
| # Eal - Glu(OAll) | |
| if 'CCC(=O)OCC=C' in content or 'CC(=O)OCC=C' in content or 'C=CCOC(=O)CC' in content: | |
| return 'Eal', mods | |
| # Proline (P) | |
| if any([ | |
| (segment.get('bond_after', '').startswith(f'N{n}C(=O)') and 'CCC' in content and | |
| any(f'[C@@H]{n}' in content or f'[C@H]{n}' in content for n in '123456789')) | |
| for n in '123456789' | |
| ]) or any([(segment.get('bond_before', '').startswith(f'C(=O)N{n}') and 'CCC' in content and | |
| any(f'CCC{n}' for n in '123456789')) | |
| for n in '123456789' | |
| ]) or any([ | |
| (f'CCCN{n}' in content and content.endswith('=O') and | |
| any(f'[C@@H]{n}' in content or f'[C@H]{n}' in content for n in '123456789')) | |
| for n in '123456789' | |
| ]) or any([ | |
| # CCC[C@H]n | |
| (content == f'CCC[C@H]{n}' and segment.get('bond_before', '').startswith(f'C(=O)N{n}')) or | |
| (content == f'CCC[C@@H]{n}' and segment.get('bond_before', '').startswith(f'C(=O)N{n}')) or | |
| # N-terminal Pro with any ring number | |
| (f'N{n}CCC[C@H]{n}' in content) or | |
| (f'N{n}CCC[C@@H]{n}' in content) | |
| for n in '123456789' | |
| ]): | |
| return 'Pro', mods | |
| # D-Proline (p) | |
| if ('N1[C@H](CCC1)' in content): | |
| return 'pro', mods | |
| # Tryptophan (W) | |
| if re.search(r'c[0-9]c\[nH\]c[0-9]ccccc[0-9][0-9]', content) and \ | |
| 'c[nH]c' in content.replace(' ', ''): | |
| if '[C@H](CC' in content: # D-form | |
| return 'trp', mods | |
| return 'Trp', mods | |
| # Lysine (K) | |
| if '[C@@H](CCCCN)' in content or '[C@H](CCCCN)' in content: | |
| if '[C@H](CCCCN)' in content: # D-form | |
| return 'lys', mods | |
| return 'Lys', mods | |
| # Arginine (R) | |
| if '[C@@H](CCCNC(=N)N)' in content or '[C@H](CCCNC(=N)N)' in content: | |
| if '[C@H](CCCNC(=N)N)' in content: # D-form | |
| return 'arg', mods | |
| return 'Arg', mods | |
| if content == 'C' and segment.get('bond_before') and segment.get('bond_after'): | |
| if ('C(=O)N' in segment['bond_before'] or 'NC(=O)' in segment['bond_before'] or 'N(C)C(=O)' in segment['bond_before']) and \ | |
| ('NC(=O)' in segment['bond_after'] or 'C(=O)N' in segment['bond_after'] or 'N(C)C(=O)' in segment['bond_after']): | |
| return 'Gly', mods | |
| if 'CNC' in content and any(f'C{i}=' in content for i in range(1, 10)): | |
| return 'Gly', mods #'CNC1=O' | |
| if not segment.get('bond_before') and segment.get('bond_after'): | |
| if content == 'C' or content == 'NC': | |
| if ('NC(=O)' in segment['bond_after'] or 'C(=O)N' in segment['bond_after'] or 'N(C)C(=O)' in segment['bond_after']): | |
| return 'Gly', mods | |
| # Leucine patterns (L/l) | |
| if 'CC(C)C[C@H]' in content or 'CC(C)C[C@@H]' in content or '[C@@H](CC(C)C)' in content or '[C@H](CC(C)C)' in content or (('N[C@H](CCC(C)C)' in content or 'N[C@@H](CCC(C)C)' in content) and segment.get('bond_before') is None): | |
| if '[C@H](CC(C)C)' in content or 'CC(C)C[C@H]' in content: # D-form | |
| return 'leu', mods | |
| return 'Leu', mods | |
| # Threonine patterns (T/t) | |
| if '[C@@H]([C@@H](C)O)' in content or '[C@H]([C@H](C)O)' in content or '[C@@H]([C@H](C)O)' in content or '[C@H]([C@@H](C)O)' in content: | |
| if '[C@H]([C@@H](C)O)' in content: # D-form | |
| return 'thr', mods | |
| return 'Thr', mods | |
| if re.search(r'\[C@H\]\(CCc\d+ccccc\d+\)', content) or re.search(r'\[C@@H\]\(CCc\d+ccccc\d+\)', content): | |
| return 'Hph', mods | |
| # Phenylalanine patterns (F/f) | |
| if re.search(r'\[C@H\]\(Cc\d+ccccc\d+\)', content) or re.search(r'\[C@@H\]\(Cc\d+ccccc\d+\)', content): | |
| if re.search(r'\[C@H\]\(Cc\d+ccccc\d+\)', content): # D-form | |
| return 'phe', mods | |
| return 'Phe', mods | |
| if ('CC(C)[C@@H]' in content or 'CC(C)[C@H]' in content or | |
| '[C@H](C(C)C)' in content or '[C@@H](C(C)C)' in content or | |
| 'C(C)C[C@H]' in content or 'C(C)C[C@@H]' in content): | |
| if not any(p in content for p in ['CC(C)C[C@H]', 'CC(C)C[C@@H]', 'CCC(=O)']): | |
| if '[C@H]' in content and not '[C@@H]' in content: # D-form | |
| return 'val', mods | |
| return 'Val', mods | |
| # Isoleucine patterns (I/i) | |
| if (any(['CC[C@@H](C)' in content, '[C@@H](C)CC' in content, '[C@@H](CC)C' in content, | |
| 'C(C)C[C@@H]' in content, '[C@@H]([C@H](C)CC)' in content, '[C@H]([C@@H](C)CC)' in content, | |
| '[C@@H]([C@@H](C)CC)' in content, '[C@H]([C@H](C)CC)' in content, | |
| 'C[C@H](CC)[C@@H]' in content, 'C[C@@H](CC)[C@H]' in content, | |
| 'C[C@H](CC)[C@H]' in content, 'C[C@@H](CC)[C@@H]' in content, | |
| 'CC[C@H](C)[C@@H]' in content, 'CC[C@@H](C)[C@H]' in content, | |
| 'CC[C@H](C)[C@H]' in content, 'CC[C@@H](C)[C@@H]' in content]) | |
| and 'CC(C)C' not in content): # Exclude valine pattern | |
| if any(['[C@H]([C@@H](CC)C)' in content, '[C@H](CC)C' in content, | |
| '[C@H]([C@@H](C)CC)' in content, '[C@H]([C@H](C)CC)' in content, | |
| 'C[C@@H](CC)[C@H]' in content, 'C[C@H](CC)[C@H]' in content, | |
| 'CC[C@@H](C)[C@H]' in content, 'CC[C@H](C)[C@H]' in content]): | |
| # D-form | |
| return 'ile', mods | |
| return 'Ile', mods | |
| # Tpb - Thr(PO(OBzl)OH) | |
| if re.search(r'\(C\)OP\(=O\)\(O\)OCc[0-9]ccccc[0-9]', content) or 'OP(=O)(O)OCC' in content: | |
| return 'Tpb', mods | |
| # Alanine patterns (A/a) | |
| if ('[C@H](C)' in content or '[C@@H](C)' in content): | |
| if not any(p in content for p in ['C(C)C', 'COC', 'CN(', 'C(C)O', 'CC[C@H]', 'CC[C@@H]']): | |
| if '[C@H](C)' in content: # D-form | |
| return 'ala', mods | |
| return 'Ala', mods | |
| # Tyrosine patterns (Y/y) | |
| if re.search(r'Cc[0-9]ccc\(O\)cc[0-9]', content): | |
| if '[C@H](Cc1ccc(O)cc1)' in content: # D-form | |
| return 'tyr', mods | |
| return 'Tyr', mods | |
| # Serine patterns (S/s) | |
| if '[C@H](CO)' in content or '[C@@H](CO)' in content: | |
| if not ('C(C)O' in content or 'COC' in content): | |
| if '[C@H](CO)' in content: # D-form | |
| return 'ser', mods | |
| return 'Ser', mods | |
| if 'CSSC' in content: | |
| # cysteine-cysteine bridge | |
| if re.search(r'\[C@@H\].*CSSC.*\[C@@H\]', content) or re.search(r'\[C@H\].*CSSC.*\[C@H\]', content): | |
| if '[C@H]' in content and not '[C@@H]' in content: # D-form | |
| return 'cys-cys', mods | |
| return 'Cys-Cys', mods | |
| # N-terminal amine group | |
| if '[C@@H](N)CSSC' in content or '[C@H](N)CSSC' in content: | |
| if '[C@H](N)CSSC' in content: # D-form | |
| return 'cys-cys', mods | |
| return 'Cys-Cys', mods | |
| # C-terminal carboxyl | |
| if 'CSSC[C@@H](C(=O)O)' in content or 'CSSC[C@H](C(=O)O)' in content: | |
| if 'CSSC[C@H](C(=O)O)' in content: # D-form | |
| return 'cys-cys', mods | |
| return 'Cys-Cys', mods | |
| # Cysteine patterns (C/c) | |
| if '[C@H](CS)' in content or '[C@@H](CS)' in content: | |
| if '[C@H](CS)' in content: # D-form | |
| return 'cys', mods | |
| return 'Cys', mods | |
| # Methionine patterns (M/m) | |
| if ('CCSC' in content) or ("CSCC" in content): | |
| if '[C@H](CCSC)' in content: # D-form | |
| return 'met', mods | |
| elif '[C@H]' in content: | |
| return 'met', mods | |
| return 'Met', mods | |
| # Glutamine patterns (Q/q) | |
| if (content == '[C@@H](CC' or content == '[C@H](CC' and segment.get('bond_before')=='C(=O)N' and segment.get('bond_after')=='C(=O)N') or ('CCC(=O)N' in content) or ('CCC(N)=O' in content): | |
| if '[C@H](CCC(=O)N)' in content: # D-form | |
| return 'gln', mods | |
| return 'Gln', mods | |
| # Asparagine patterns (N/n) | |
| if (content == '[C@@H](C' or content == '[C@H](C' and segment.get('bond_before')=='C(=O)N' and segment.get('bond_after')=='C(=O)N') or ('CC(=O)N' in content) or ('CCN(=O)' in content) or ('CC(N)=O' in content): | |
| if '[C@H](CC(=O)N)' in content: # D-form | |
| return 'asn', mods | |
| return 'Asn', mods | |
| # Glutamic acid patterns (E/e) | |
| if ('CCC(=O)O' in content): | |
| if '[C@H](CCC(=O)O)' in content: # D-form | |
| return 'glu', mods | |
| return 'Glu', mods | |
| # Aspartic acid patterns (D/d) | |
| if ('CC(=O)O' in content): | |
| if '[C@H](CC(=O)O)' in content: # D-form | |
| return 'asp', mods | |
| return 'Asp', mods | |
| if re.search(r'Cc\d+c\[nH\]cn\d+', content) or re.search(r'Cc\d+cnc\[nH\]\d+', content): | |
| if '[C@H]' in content: # D-form | |
| return 'his', mods | |
| return 'His', mods | |
| if 'C2(CCCC2)' in content or 'C1(CCCC1)' in content or re.search(r'C\d+\(CCCC\d+\)', content): | |
| return 'Cyl', mods | |
| if ('N[C@@H](CCCC)' in content or '[C@@H](CCCC)' in content or 'CCCC[C@@H]' in content or | |
| 'N[C@H](CCCC)' in content or '[C@H](CCCC)' in content) and 'CC(C)' not in content: | |
| return 'Nle', mods | |
| if 'C(C)(C)(N)' in content: | |
| return 'Aib', mods | |
| if 'C(C)(C)' in content and 'OC(C)(C)C' not in content: | |
| if (segment.get('bond_before') and segment.get('bond_after') and | |
| any(bond in segment['bond_before'] for bond in ['C(=O)N', 'NC(=O)', 'N(C)C(=O)']) and | |
| any(bond in segment['bond_after'] for bond in ['NC(=O)', 'C(=O)N', 'N(C)C(=O)'])): | |
| return 'Aib', mods | |
| # Dtg - Asp(OtBu)-(Dmb)Gly | |
| if 'CC(=O)OC(C)(C)C' in content and 'CC1=C(C=C(C=C1)OC)OC' in content: | |
| return 'Dtg', mods | |
| # Kpg - Lys(palmitoyl-Glu-OtBu) | |
| if 'CCCNC(=O)' in content and 'CCCCCCCCCCCC' in content: | |
| return 'Kpg', mods | |
| #======================Other UAAs from the SwissSidechain========================================== | |
| # ADD SWISSSIDECHAIN MATCHING AT THE VERY END - only if nothing else matched | |
| if content in self.exact_smiles_lookup: | |
| return self.exact_smiles_lookup[content], mods | |
| # Look up without stereochemistry differences) | |
| content_clean = self._remove_stereochemistry(content) | |
| if content_clean in self.clean_smiles_lookup: | |
| matches = self.clean_smiles_lookup[content_clean] | |
| if len(matches) == 1: | |
| return matches[0], mods | |
| else: | |
| # Prefer L-forms (non-D prefixed codes) over D-forms | |
| l_forms = [m for m in matches if not m.startswith('D')] | |
| if l_forms: | |
| return l_forms[0], mods | |
| return matches[0], mods | |
| return None, mods | |
| def get_modifications(self, segment): | |
| """Get modifications based on bond types and segment content - fixed to avoid duplicates""" | |
| mods = [] | |
| # Check for N-methylation in any form, but only add it once | |
| # Check both bonds and segment content for N-methylation patterns | |
| if ((segment.get('bond_after') and | |
| ('N(C)' in segment['bond_after'] or segment['bond_after'].startswith('C(=O)N(C)'))) or | |
| ('N(C)C(=O)' in segment['content'] or 'N(C)C1=O' in segment['content']) or | |
| (segment['content'].endswith('N(C)C(=O)') or segment['content'].endswith('N(C)C1=O'))): | |
| mods.append('N-Me') | |
| # Check for O-linked modifications | |
| #if segment.get('bond_after') and 'OC(=O)' in segment['bond_after']: | |
| #mods.append('O-linked') | |
| return mods | |
| def analyze_structure(self, smiles, verbose=False): | |
| logs = [] | |
| preprocessed_smiles, protected_residues = self.preprocess_complex_residues(smiles) | |
| is_cyclic, peptide_cycles, aromatic_cycles = self.is_cyclic(smiles) | |
| segments = self.split_on_bonds(preprocessed_smiles, protected_residues) | |
| sequence = [] | |
| for i, segment in enumerate(segments): | |
| if verbose: | |
| logs.append(f"\nSegment {i}:") | |
| logs.append(f" Content: {segment.get('content','None')}") | |
| logs.append(f" Bond before: {segment.get('bond_before','None')}") | |
| logs.append(f" Bond after: {segment.get('bond_after','None')}") | |
| residue, mods = self.identify_residue(segment) | |
| if residue: | |
| if mods: | |
| sequence.append(f"{residue}({','.join(mods)})") | |
| else: | |
| sequence.append(residue) | |
| else: | |
| logs.append(f"Warning: Could not identify residue in segment: {segment.get('content', 'None')}") | |
| three_letter = '-'.join(sequence) | |
| one_letter = ''.join(self.three_to_one.get(aa.split('(')[0], 'X') for aa in sequence) | |
| if is_cyclic: | |
| three_letter = f"cyclo({three_letter})" | |
| one_letter = f"cyclo({one_letter})" | |
| return { | |
| 'three_letter': three_letter, | |
| 'one_letter': one_letter, | |
| 'is_cyclic': is_cyclic, | |
| 'residues': sequence, | |
| 'details': "\n".join(logs) | |
| } | |
| def get_uaa_information(self): | |
| uaa_info = """ | |
| ## Supported Non-Standard Amino Acids (UAAs) (Common) | |
| - **Kpg** - Lys(palmitoyl-Glu-OtBu) | |
| - **Cmt** - Cys(Mmt) | |
| - **Eal** - Glu(OAll) | |
| - **Tpb** - Thr(PO(OBzl)OH) | |
| - **Dtg** - Asp(OtBu)-(Dmb)Gly | |
| - **Aib** - α-Aminoisobutyric acid | |
| - **Nle** - Norleucine | |
| - **Hph** - Homophenylalanine | |
| - **Cyl** - Cycloleucine | |
| - **Nml** - N-methylleucine | |
| - **Nma** - N-methylalanine | |
| ### Special Cases: | |
| - **Cys-Cys** - Disulfide-bridged cysteine dimer | |
| --- | |
| ## Three-to-One Letter Code Mapping | |
| ### Standard Amino Acids: | |
| **L-amino acids:** A, C, D, E, F, G, H, I, K, L, M, N, P, Q, R, S, T, V, W, Y | |
| **D-amino acids:** a, c, d, e, f, g, h, i, k, l, m, n, p, q, r, s, t, v, w, y | |
| ### UAA Single Letter Codes: | |
| | UAA | Code | UAA | Code | UAA | Code | | |
| |-----|------|-----|------|-----|------| | |
| | Aib | Ŷ | Dtg | Ĝ | Cmt | Ĉ | | |
| | Eal | Ė | Nml | Ŀ | Nma | Ṃ | | |
| | Kpg | Ƙ | Tpb | Ṯ | Cyl | Ċ | | |
| | Nle | Ł | Hph | Ĥ | | | | |
| ### Special Cases: | |
| - **Cys-Cys:** CC (L-form) or cc (D-form) | |
| ## For other mappings, please refer to the [SwissSideChain webside](https://www.swisssidechain.ch/browse/family/table.php?family=all) | |
| """ | |
| return uaa_info | |
| def annotate_cyclic_structure(mol, sequence): | |
| """Create structure visualization""" | |
| AllChem.Compute2DCoords(mol) | |
| drawer = Draw.rdMolDraw2D.MolDraw2DCairo(2000, 2000) | |
| drawer.drawOptions().addAtomIndices = False | |
| drawer.DrawMolecule(mol) | |
| drawer.FinishDrawing() | |
| img = Image.open(BytesIO(drawer.GetDrawingText())) | |
| draw = ImageDraw.Draw(img) | |
| try: | |
| small_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 60) | |
| except OSError: | |
| try: | |
| small_font = ImageFont.truetype("arial.ttf", 60) | |
| except OSError: | |
| print("Warning: TrueType fonts not available, using default font") | |
| small_font = ImageFont.load_default() | |
| seq_text = f"Sequence: {sequence}" | |
| bbox = draw.textbbox((1000, 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((1000, 100), seq_text, | |
| font=small_font, fill='black', anchor="mm") | |
| return img | |
| def create_enhanced_linear_viz(sequence, smiles): | |
| """"Linear visualization""" | |
| analyzer = PeptideAnalyzer() | |
| fig = plt.figure(figsize=(15, 10)) | |
| gs = fig.add_gridspec(2, 1, height_ratios=[1, 2]) | |
| ax_struct = fig.add_subplot(gs[0]) | |
| ax_detail = fig.add_subplot(gs[1]) | |
| if sequence.startswith('cyclo('): | |
| residues = sequence[6:-1].split('-') | |
| else: | |
| residues = sequence.split('-') | |
| segments = analyzer.split_on_bonds(smiles) | |
| print(f"Number of residues: {len(residues)}") | |
| print(f"Number of segments: {len(segments)}") | |
| ax_struct.set_xlim(0, 10) | |
| ax_struct.set_ylim(0, 2) | |
| num_residues = len(residues) | |
| spacing = 9.0 / (num_residues - 1) if num_residues > 1 else 9.0 | |
| y_pos = 1.5 | |
| for i in range(num_residues): | |
| x_pos = 0.5 + i * spacing | |
| rect = patches.Rectangle((x_pos-0.3, y_pos-0.2), 0.6, 0.4, | |
| facecolor='lightblue', edgecolor='black') | |
| ax_struct.add_patch(rect) | |
| if i < num_residues - 1: | |
| segment = segments[i] if i < len(segments) else None | |
| if segment: | |
| bond_type = 'ester' if 'O-linked' in segment.get('bond_after', '') else 'peptide' | |
| is_n_methylated = 'N-Me' in segment.get('bond_after', '') | |
| bond_color = 'red' if bond_type == 'ester' else 'black' | |
| linestyle = '--' if bond_type == 'ester' else '-' | |
| ax_struct.plot([x_pos+0.3, x_pos+spacing-0.3], [y_pos, y_pos], | |
| color=bond_color, linestyle=linestyle, linewidth=2) | |
| mid_x = x_pos + spacing/2 | |
| bond_label = f"{bond_type}" | |
| if is_n_methylated: | |
| bond_label += "\n(N-Me)" | |
| ax_struct.text(mid_x, y_pos+0.1, bond_label, | |
| ha='center', va='bottom', fontsize=10, | |
| color=bond_color) | |
| ax_struct.text(x_pos, y_pos-0.5, residues[i], | |
| ha='center', va='top', fontsize=14) | |
| ax_detail.set_ylim(0, len(segments)+1) | |
| ax_detail.set_xlim(0, 1) | |
| segment_y = len(segments) | |
| for i, segment in enumerate(segments): | |
| y = segment_y - i | |
| # Check if this is a bond or residue | |
| residue, mods = analyzer.identify_residue(segment) | |
| if residue: | |
| text = f"Residue {i+1}: {residue}" | |
| if mods: | |
| text += f" ({', '.join(mods)})" | |
| color = 'blue' | |
| else: | |
| text = f"Bond {i}: " | |
| if 'O-linked' in segment.get('bond_after', ''): | |
| text += "ester" | |
| elif 'N-Me' in segment.get('bond_after', ''): | |
| text += "peptide (N-methylated)" | |
| else: | |
| text += "peptide" | |
| color = 'red' | |
| ax_detail.text(0.05, y, text, fontsize=12, color=color) | |
| ax_detail.text(0.5, y, f"SMILES: {segment.get('content', '')}", fontsize=10, color='gray') | |
| # If cyclic, add connection indicator | |
| if sequence.startswith('cyclo('): | |
| ax_struct.annotate('', xy=(9.5, y_pos), xytext=(0.5, y_pos), | |
| arrowprops=dict(arrowstyle='<->', color='red', lw=2)) | |
| ax_struct.text(5, y_pos+0.3, 'Cyclic Connection', | |
| ha='center', color='red', fontsize=14) | |
| ax_struct.set_title("Peptide Structure Overview", pad=20) | |
| ax_detail.set_title("Segment Analysis Breakdown", pad=20) | |
| for ax in [ax_struct, ax_detail]: | |
| ax.set_xticks([]) | |
| ax.set_yticks([]) | |
| ax.axis('off') | |
| plt.tight_layout() | |
| return fig | |
| class PeptideStructureGenerator: | |
| """Generate 3D structures of peptides using different embedding methods""" | |
| def prepare_molecule(smiles): | |
| """Prepare molecule with proper hydrogen handling""" | |
| mol = Chem.MolFromSmiles(smiles, sanitize=False) | |
| if mol is None: | |
| raise ValueError("Failed to create molecule from SMILES") | |
| for atom in mol.GetAtoms(): | |
| atom.UpdatePropertyCache(strict=False) | |
| # Sanitize with reduced requirements | |
| Chem.SanitizeMol(mol, | |
| sanitizeOps=Chem.SANITIZE_FINDRADICALS| | |
| Chem.SANITIZE_KEKULIZE| | |
| Chem.SANITIZE_SETAROMATICITY| | |
| Chem.SANITIZE_SETCONJUGATION| | |
| Chem.SANITIZE_SETHYBRIDIZATION| | |
| Chem.SANITIZE_CLEANUPCHIRALITY) | |
| mol = Chem.AddHs(mol) | |
| return mol | |
| def get_etkdg_params(attempt=0): | |
| """Get ETKDG parameters""" | |
| params = AllChem.ETKDGv3() | |
| params.randomSeed = -1 | |
| params.maxIterations = 200 | |
| params.numThreads = 4 # Reduced for web interface | |
| params.useBasicKnowledge = True | |
| params.enforceChirality = True | |
| params.useExpTorsionAnglePrefs = True | |
| params.useSmallRingTorsions = True | |
| params.useMacrocycleTorsions = True | |
| params.ETversion = 2 | |
| params.pruneRmsThresh = -1 | |
| params.embedRmsThresh = 0.5 | |
| if attempt > 10: | |
| params.bondLength = 1.5 + (attempt - 10) * 0.02 | |
| params.useExpTorsionAnglePrefs = False | |
| return params | |
| def generate_structure_etkdg(self, smiles, max_attempts=20): | |
| """Generate 3D structure using ETKDG without UFF optimization""" | |
| success = False | |
| mol = None | |
| for attempt in range(max_attempts): | |
| try: | |
| mol = self.prepare_molecule(smiles) | |
| params = self.get_etkdg_params(attempt) | |
| if AllChem.EmbedMolecule(mol, params) == 0: | |
| success = True | |
| break | |
| except Exception as e: | |
| continue | |
| if not success: | |
| raise ValueError("Failed to generate structure with ETKDG") | |
| return mol | |
| def generate_structure_uff(self, smiles, max_attempts=20): | |
| """Generate 3D structure using ETKDG followed by UFF optimization""" | |
| best_mol = None | |
| lowest_energy = float('inf') | |
| for attempt in range(max_attempts): | |
| try: | |
| test_mol = self.prepare_molecule(smiles) | |
| params = self.get_etkdg_params(attempt) | |
| if AllChem.EmbedMolecule(test_mol, params) == 0: | |
| res = AllChem.UFFOptimizeMolecule(test_mol, maxIters=2000, | |
| vdwThresh=10.0, confId=0, | |
| ignoreInterfragInteractions=True) | |
| if res == 0: | |
| ff = AllChem.UFFGetMoleculeForceField(test_mol) | |
| if ff: | |
| current_energy = ff.CalcEnergy() | |
| if current_energy < lowest_energy: | |
| lowest_energy = current_energy | |
| best_mol = Chem.Mol(test_mol) | |
| except Exception: | |
| continue | |
| if best_mol is None: | |
| raise ValueError("Failed to generate optimized structure") | |
| return best_mol | |
| def mol_to_sdf_bytes(mol): | |
| """Convert RDKit molecule to SDF file bytes""" | |
| sio = StringIO() | |
| writer = Chem.SDWriter(sio) | |
| writer.write(mol) | |
| writer.close() | |
| return sio.getvalue().encode('utf-8') | |
| def process_input( | |
| smiles_input=None, | |
| file_obj=None, | |
| #show_linear=False, | |
| show_segment_details=False, | |
| generate_3d=False, | |
| use_uff=False | |
| ): | |
| """Actual Execution Command.""" | |
| analyzer = PeptideAnalyzer() | |
| temp_dir = tempfile.mkdtemp() if generate_3d else None | |
| structure_files = [] | |
| # Retrieve UAA information | |
| uaa_info = analyzer.get_uaa_information() | |
| # Handle direct SMILES input | |
| if smiles_input: | |
| smiles = smiles_input.strip() | |
| if not analyzer.is_peptide(smiles): | |
| return "Error: Input SMILES does not appear to be a peptide structure.", None, None, [] | |
| try: | |
| # Preprocess to protect complex residues | |
| pre_smiles, protected_residues = analyzer.preprocess_complex_residues(smiles) | |
| # Report protected residues in summary if any | |
| protected_info = None | |
| if protected_residues: | |
| protected_info = [res['type'] for res in protected_residues] | |
| mol = Chem.MolFromSmiles(smiles) | |
| if mol is None: | |
| return "Error: Invalid SMILES notation.", None, None, [] | |
| if generate_3d: | |
| generator = PeptideStructureGenerator() | |
| try: | |
| # Generate ETKDG structure | |
| mol_etkdg = generator.generate_structure_etkdg(smiles) | |
| etkdg_path = os.path.join(temp_dir, "structure_etkdg.sdf") | |
| writer = Chem.SDWriter(etkdg_path) | |
| writer.write(mol_etkdg) | |
| writer.close() | |
| structure_files.append(etkdg_path) | |
| # Generate UFF structure if requested | |
| if use_uff: | |
| mol_uff = generator.generate_structure_uff(smiles) | |
| uff_path = os.path.join(temp_dir, "structure_uff.sdf") | |
| writer = Chem.SDWriter(uff_path) | |
| writer.write(mol_uff) | |
| writer.close() | |
| structure_files.append(uff_path) | |
| except Exception as e: | |
| return f"Error generating 3D structures: {str(e)}", None, None, [] | |
| analysis = analyzer.analyze_structure(smiles, verbose=show_segment_details) | |
| three_letter = analysis['three_letter'] | |
| one_letter = analysis['one_letter'] | |
| is_cyclic = analysis['is_cyclic'] | |
| details = analysis.get('details', "") | |
| img_cyclic = annotate_cyclic_structure(mol, three_letter) | |
| summary = "Summary:\n" | |
| summary += f"Sequence: {three_letter}\n" | |
| summary += f"One-letter code: {one_letter}\n" | |
| summary += f"Is Cyclic: {'Yes' if is_cyclic else 'No'}\n" | |
| # Add segment details if requested | |
| if show_segment_details and details: | |
| summary += "\n" + "="*50 + "\n" | |
| summary += "SEGMENT ANALYSIS:\n" | |
| summary += "="*50 + "\n" | |
| summary += details + "\n" | |
| detected_uaas = [aa for aa in analysis['residues'] if aa not in [ | |
| 'Ala', 'Cys', 'Asp', 'Glu', 'Phe', 'Gly', 'His', 'Ile', 'Lys', 'Leu', | |
| 'Met', 'Asn', 'Pro', 'Gln', 'Arg', 'Ser', 'Thr', 'Val', 'Trp', 'Tyr', | |
| 'ala', 'cys', 'asp', 'glu', 'phe', 'gly', 'his', 'ile', 'lys', 'leu', | |
| 'met', 'asn', 'pro', 'gln', 'arg', 'ser', 'thr', 'val', 'trp', 'tyr' | |
| ]] | |
| if detected_uaas: | |
| summary += f"\nDetected UAAs: {', '.join(set(detected_uaas))}\n" | |
| if structure_files: | |
| summary += "\n3D Structures Generated:\n" | |
| for filepath in structure_files: | |
| summary += f"- {os.path.basename(filepath)}\n" | |
| #return summary, img_cyclic, img_linear, structure_files if structure_files else None | |
| return summary, img_cyclic, uaa_info | |
| except Exception as e: | |
| #return f"Error processing SMILES: {str(e)}", None, None, [] | |
| return f"Error processing SMILES: {str(e)}", None, uaa_info | |
| # Handle file input | |
| if file_obj is not None: | |
| try: | |
| if hasattr(file_obj, 'name'): | |
| with open(file_obj.name, 'r') as f: | |
| content = f.read() | |
| else: | |
| content = file_obj.decode('utf-8') if isinstance(file_obj, bytes) else str(file_obj) | |
| output_text = "" | |
| for line in content.splitlines(): | |
| smiles = line.strip() | |
| if not smiles: | |
| continue | |
| if not analyzer.is_peptide(smiles): | |
| output_text += f"Skipping non-peptide SMILES: {smiles}\n" | |
| continue | |
| try: | |
| result = analyzer.analyze_structure(smiles) | |
| output_text += f"\nSummary for SMILES: {smiles}\n" | |
| output_text += f"Sequence: {result['three_letter']}\n" | |
| output_text += f"One-letter code: {result['one_letter']}\n" | |
| output_text += f"Is Cyclic: {'Yes' if result['is_cyclic'] else 'No'}\n" | |
| output_text += "-" * 50 + "\n" | |
| except Exception as e: | |
| output_text += f"Error processing SMILES: {smiles} - {str(e)}\n" | |
| output_text += "-" * 50 + "\n" | |
| return output_text, None, uaa_info | |
| except Exception as e: | |
| #return f"Error processing file: {str(e)}", None, None, [] | |
| return f"Error processing file: {str(e)}", None, uaa_info | |
| return ( | |
| output_text or "No analysis done.", | |
| img_cyclic if 'img_cyclic' in locals() else None, uaa_info | |
| #img_linear if 'img_linear' in locals() else None, | |
| #structure_files if structure_files else [] | |
| ) | |
| 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"] | |
| ), | |
| gr.Checkbox( | |
| label="Show show segmentation details", | |
| value=False | |
| ),], | |
| outputs=[ | |
| gr.Textbox( | |
| label="Analysis Results", | |
| lines=10 | |
| ), | |
| gr.Image( | |
| label="2D Structure with Annotations", | |
| type="pil" | |
| ), | |
| #gr.File( | |
| #label="3D Structure Files", | |
| #file_count="multiple" | |
| #), | |
| gr.Markdown( | |
| label="Side Notes for Non-Standard Amino Acids", | |
| ) | |
| ], | |
| title="Peptide Structure Analyzer and Visualizer", | |
| description=''' | |
| 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 | |
| Input: Either enter a SMILES string directly or upload a text file containing SMILES strings | |
| Example SMILES strings (copy and paste): | |
| ``` | |
| CC(C)C[C@@H]1NC(=O)[C@@H](CC(C)C)N(C)C(=O)[C@@H](C)N(C)C(=O)[C@H](Cc2ccccc2)NC(=O)[C@H](CC(C)C)N(C)C(=O)[C@H]2CCCN2C1=O | |
| ``` | |
| ``` | |
| C(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 | |
| ``` | |
| ``` | |
| CC(C)C[C@H]1C(=O)N(C)[C@@H](Cc2ccccc2)C(=O)NCC(=O)N[C@H](C(=O)N2CCCCC2)CC(=O)N(C)CC(=O)N[C@@H]([C@@H](C)O)C(=O)N(C)[C@@H](C)C(=O)N[C@@H](COC(C)(C)C)C(=O)N(C)[C@@H](Cc2ccccc2)C(=O)N1C | |
| ``` | |
| ''', | |
| flagging_mode="never" | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch(share=True) | |
| """ | |
| 5. Optional linear representation | |
| 6. Optional 3D structure generation (ETKDG and UFF methods) | |
| gr.Checkbox( | |
| label="Generate 3D structure (sdf file format)", | |
| value=False | |
| ), | |
| gr.Checkbox( | |
| label="Use UFF optimization (may take long)", | |
| value=False | |
| ) | |
| ], | |
| """ |