p2smi 0.1.0__tar.gz

p2smi-0.1.0/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2025 Aaron Feller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

p2smi-0.1.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: p2smi
+Version: 0.1.0
+Summary: A package for converting peptide FASTA to SMILES strings and calculating molecular properties.
+Home-page: https://github.com/AaronFeller/p2smi
+Author: Aaron L. Feller
+Author-email: Aaron Feller <aaronleefeller@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rdkit
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# p2smi: Peptide FASTA-to-SMILES Conversion and Molecular Property Tools
+
+**p2smi** is a Python package for generating and modifying peptide SMILES strings from FASTA input and computing molecular properties. It supports cyclic and linear peptides, noncanonical amino acids, and common chemical modifications (e.g., N-methylation, PEGylation).
+
+This package was released in its current form to support work on the **PeptideCLM** model, described in our [Publication](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01441).
+
+> **If you use this tool, please cite the PeptideCLM paper.** A JOSS publication is forthcoming.
+
+## Manuscript
+- [View PDF](manuscript/paper.pdf)
+- [View markdown source](manuscript/paper.md)
+
+## Directory
+
+- [Features](#features)  
+- [Installation](#installation)  
+- [Command-Line Tools](#command-line-tools)  
+- [Example Usage](#example-usage)  
+- [Future Work](#future-work)  
+- [License](#license)  
+- [Citation](#citation)  
+
+## Features
+- Convert peptide FASTA files into valid SMILES strings
+- Automatically handle peptide cyclizations (disulfide, head-to-tail, side-chain to N-term, side-chain to C-term, side-chain to side-chain)
+- Modify peptide SMILES with customizable N-methylation and PEGylation
+- Evaluate synthesis feasibility with defined synthesis rules
+- Compute molecular properties: logP, TPSA, molecular formula, and Lipinski rule evaluation
+
+## Installation
+```bash
+pip install p2smi
+```
+For development:
+```bash
+git clone &lt;your-repo-url&gt;
+cd p2smi
+pip install -e .[dev]
+```
+
+## Command-Line Tools
+
+| Command               | Description                                                     |
+|-----------------------|-----------------------------------------------------------------|
+| `generate-peptides`  | Generate random peptide sequences based on user-defined constraints and modifications |
+| `fasta2smi`          | Convert a FASTA file of peptide sequences into SMILES format    |
+| `modify-smiles`      | Apply modifications (N-methylation, PEGylation) to existing SMILES strings |
+| `smiles-props`       | Compute molecular properties (logP, TPSA, formula, Lipinski rules) from SMILES |
+| `synthesis-check`    | Check synthesis constraints for peptides (*currently only functional for natural amino acids*) |
+
+> Run each command with `--help` to view usage and options:
+```bash
+generate-peptides --help
+fasta2smi --help
+modify-smiles --help
+smiles-props --help
+synthesis-check --help
+```
+
+## Example Usage
+
+**Convert a FASTA file to SMILES:**
+```bash
+fasta2smi -i peptides.fasta -o output.smi
+```
+
+**Modify existing SMILES strings (N-methylation/PEGylation):**
+```bash
+modify-smiles -i input.smi -o modified.smi --peg_rate 0.3 --nmeth_rate 0.2 --nmeth_residues 0.25
+```
+
+**Compute properties of a SMILES string:**
+```bash
+smiles-props "C1CC(NC(=O)C2CC2)C1"
+```
+
+## Future Work
+- Expand support for additional post-translational modifications
+- Enhance synthesis-check with rules for noncanonical amino acid and modified peptides
+- 
+
+## License
+MIT License
+
+## Citation
+> If you use this tool, please cite:  
+- [Peptide-Aware Chemical Language Model Successfully Predicts Membrane Diffusion of Cyclic Peptides (JCIM)](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01441)  
+A JOSS paper will follow.

p2smi-0.1.0/README.md

@@ -0,0 +1,88 @@
+# p2smi: Peptide FASTA-to-SMILES Conversion and Molecular Property Tools
+
+**p2smi** is a Python package for generating and modifying peptide SMILES strings from FASTA input and computing molecular properties. It supports cyclic and linear peptides, noncanonical amino acids, and common chemical modifications (e.g., N-methylation, PEGylation).
+
+This package was released in its current form to support work on the **PeptideCLM** model, described in our [Publication](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01441).
+
+> **If you use this tool, please cite the PeptideCLM paper.** A JOSS publication is forthcoming.
+
+## Manuscript
+- [View PDF](manuscript/paper.pdf)
+- [View markdown source](manuscript/paper.md)
+
+## Directory
+
+- [Features](#features)  
+- [Installation](#installation)  
+- [Command-Line Tools](#command-line-tools)  
+- [Example Usage](#example-usage)  
+- [Future Work](#future-work)  
+- [License](#license)  
+- [Citation](#citation)  
+
+## Features
+- Convert peptide FASTA files into valid SMILES strings
+- Automatically handle peptide cyclizations (disulfide, head-to-tail, side-chain to N-term, side-chain to C-term, side-chain to side-chain)
+- Modify peptide SMILES with customizable N-methylation and PEGylation
+- Evaluate synthesis feasibility with defined synthesis rules
+- Compute molecular properties: logP, TPSA, molecular formula, and Lipinski rule evaluation
+
+## Installation
+```bash
+pip install p2smi
+```
+For development:
+```bash
+git clone <your-repo-url>
+cd p2smi
+pip install -e .[dev]
+```
+
+## Command-Line Tools
+
+| Command               | Description                                                     |
+|-----------------------|-----------------------------------------------------------------|
+| `generate-peptides`  | Generate random peptide sequences based on user-defined constraints and modifications |
+| `fasta2smi`          | Convert a FASTA file of peptide sequences into SMILES format    |
+| `modify-smiles`      | Apply modifications (N-methylation, PEGylation) to existing SMILES strings |
+| `smiles-props`       | Compute molecular properties (logP, TPSA, formula, Lipinski rules) from SMILES |
+| `synthesis-check`    | Check synthesis constraints for peptides (*currently only functional for natural amino acids*) |
+
+> Run each command with `--help` to view usage and options:
+```bash
+generate-peptides --help
+fasta2smi --help
+modify-smiles --help
+smiles-props --help
+synthesis-check --help
+```
+
+## Example Usage
+
+**Convert a FASTA file to SMILES:**
+```bash
+fasta2smi -i peptides.fasta -o output.smi
+```
+
+**Modify existing SMILES strings (N-methylation/PEGylation):**
+```bash
+modify-smiles -i input.smi -o modified.smi --peg_rate 0.3 --nmeth_rate 0.2 --nmeth_residues 0.25
+```
+
+**Compute properties of a SMILES string:**
+```bash
+smiles-props "C1CC(NC(=O)C2CC2)C1"
+```
+
+## Future Work
+- Expand support for additional post-translational modifications
+- Enhance synthesis-check with rules for noncanonical amino acid and modified peptides
+- 
+
+## License
+MIT License
+
+## Citation
+> If you use this tool, please cite:  
+- [Peptide-Aware Chemical Language Model Successfully Predicts Membrane Diffusion of Cyclic Peptides (JCIM)](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01441)  
+A JOSS paper will follow.

p2smi-0.1.0/p2smi/chemMods.py

@@ -0,0 +1,136 @@
+import argparse
+import math
+import random
+import re
+
+from rdkit import Chem
+
+
+def is_valid_smiles(sequence):
+    return Chem.MolFromSmiles(sequence) is not None
+
+
+def add_n_methylation(sequence, methylation_residue_fraction):
+    pattern = r"C\(=O\)N\[C@"
+    positions = [m.start() for m in re.finditer(pattern, sequence)]
+    num_to_methylate = math.ceil(len(positions) * methylation_residue_fraction)
+
+    for pos in sorted(
+        random.sample(positions, min(num_to_methylate, len(positions))),
+        reverse=True,
+    ):
+        sequence = sequence[: pos + 6] + "(C)" + sequence[pos + 6 :]
+    return sequence, num_to_methylate
+
+
+def add_pegylation(sequence):
+    peg = "O" + "".join(["CCO" for _ in range(random.randint(1, 4))]) + "C"
+    positions = [m.start() for m in re.finditer(r"CN\)", sequence)]
+    if not positions:
+        return sequence, None
+    pos = random.choice(positions)
+    return sequence[: pos + 2] + peg + sequence[pos + 2 :], peg
+
+
+def parse_input_lines(input_lines):
+    for line in input_lines:
+        parts = line.strip().split(": ", 1)
+        if len(parts) == 2:
+            yield tuple(parts)
+        else:
+            yield ("[Malformed line]", None)
+
+
+def modify_sequence(sequence, methylate, pegylate, nmeth_residues):
+    modifications = []
+    if methylate:
+        sequence, methyl_count = add_n_methylation(sequence, nmeth_residues)
+        modifications.append(f"N-methylation({methyl_count})")
+    if pegylate:
+        sequence, peg = add_pegylation(sequence)
+        # find number of PEG units added
+        if peg:
+            number_of_peg_units = peg.count("CCO")
+            modifications.append(f"PEGylation({number_of_peg_units})")
+        else:
+            modifications.append("PEGylation('N/A')")
+    return sequence, modifications
+
+
+def process_sequences(input_lines, nmeth_rate, peg_rate, nmeth_residues):
+    total = len(input_lines)
+    methylate_indices = (
+        set(random.sample(range(total), math.ceil(total * nmeth_rate)))
+        if nmeth_rate > 0
+        else set()
+    )
+    pegylate_indices = (
+        set(random.sample(range(total), math.ceil(total * peg_rate)))
+        if peg_rate > 0
+        else set()
+    )
+
+    for i, (header, seq) in enumerate(parse_input_lines(input_lines)):
+        if seq is None:
+            yield f"{header} [Skipped malformed line]"
+            continue
+
+        sequence, mods = modify_sequence(
+            seq, i in methylate_indices, i in pegylate_indices, nmeth_residues
+        )
+
+        if not is_valid_smiles(sequence):
+            yield f"{header} [Invalid SMILES skipped]"
+            continue
+
+        mod_str = f" [{' - '.join(mods)}]" if mods else ""
+        yield f"{header}{mod_str}: {sequence}"
+
+
+def process_file(input_file, output_file, peg_rate, nmeth_rate, nmeth_residues):
+    with open(input_file, "r") as infile:
+        lines = [line.strip() for line in infile if line.strip()]
+
+    modified_lines = process_sequences(lines, nmeth_rate, peg_rate, nmeth_residues)
+
+    with open(output_file, "w") as outfile:
+        outfile.write("\n".join(modified_lines) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=("Modify peptide sequences with" "PEGylation and N-methylation.")
+    )
+    parser.add_argument("-i", "--input_file", required=True, help="Input file path.")
+    parser.add_argument("-o", "--output_file", required=True, help="Output file path.")
+    parser.add_argument(
+        "--peg_rate",
+        type=float,
+        default=0.2,
+        help="Fraction of sequences to PEGylate (0-1).",
+    )
+    parser.add_argument(
+        "--nmeth_rate",
+        type=float,
+        default=0.2,
+        help="Fraction of sequences to N-methylate (0-1).",
+    )
+    parser.add_argument(
+        "--nmeth_residues",
+        type=float,
+        default=0.2,
+        help="Fraction of bonds in each sequence to N-methylate (0-1).",
+    )
+    args = parser.parse_args()
+
+    process_file(
+        args.input_file,
+        args.output_file,
+        args.peg_rate,
+        args.nmeth_rate,
+        args.nmeth_residues,
+    )
+
+
+if __name__ == "__main__":
+    main()

p2smi-0.1.0/p2smi/chemProps.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+"""
+Chemical data about a molecule.
+
+Molecules are defined by SMILES strings.
+Computes logP, Lipinski's rules, molecular formula,
+TPSA, rotatable bonds, ring count, fraction Csp3,
+heavy atom count, and formal charge.
+
+Uses RDKit.
+"""
+
+from rdkit import Chem
+from rdkit.Chem import (
+    Crippen,
+    Descriptors,
+    Lipinski,
+    rdMolDescriptors,
+    rdmolops,
+)
+
+
+class SmilesError(Exception):
+    pass
+
+
+def log_partition_coefficient(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise SmilesError(f"{smiles} is not a valid SMILES string")
+    return Crippen.MolLogP(mol)
+
+
+def lipinski_trial(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise SmilesError(f"{smiles} is not a valid SMILES string")
+
+    passed, failed = [], []
+    num_hdonors = Lipinski.NumHDonors(mol)
+    num_hacceptors = Lipinski.NumHAcceptors(mol)
+    mol_weight = Descriptors.MolWt(mol)
+    mol_logp = Crippen.MolLogP(mol)
+
+    if num_hdonors > 5:
+        failed.append(f"Over 5 H-bond donors (found {num_hdonors})")
+    else:
+        passed.append(f"{num_hdonors} H-bond donors")
+
+    if num_hacceptors > 10:
+        failed.append(f"Over 10 H-bond acceptors (found {num_hacceptors})")
+    else:
+        passed.append(f"{num_hacceptors} H-bond acceptors")
+
+    if mol_weight >= 500:
+        failed.append(f"Molecular weight over 500 (calculated {mol_weight:.2f})")
+    else:
+        passed.append(f"Molecular weight: {mol_weight:.2f}")
+
+    if mol_logp >= 5:
+        failed.append(f"logP over 5 (calculated {mol_logp:.2f})")
+    else:
+        passed.append(f"logP: {mol_logp:.2f}")
+
+    return passed, failed
+
+
+def lipinski_pass(smiles):
+    _, failed = lipinski_trial(smiles)
+    return not failed
+
+
+def molecular_formula(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise SmilesError(f"{smiles} is not a valid SMILES string")
+    return rdMolDescriptors.CalcMolFormula(mol)
+
+
+def tpsa(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise SmilesError(f"{smiles} is not a valid SMILES string")
+    return Descriptors.TPSA(mol)
+
+
+def molecule_summary(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise SmilesError(f"{smiles} is not a valid SMILES string")
+
+    summary = {
+        "Formula": molecular_formula(smiles),
+        "Molecular Weight": round(Descriptors.MolWt(mol), 2),
+        "logP": round(Crippen.MolLogP(mol), 2),
+        "TPSA": round(Descriptors.TPSA(mol), 2),
+        "H-bond donors": Lipinski.NumHDonors(mol),
+        "H-bond acceptors": Lipinski.NumHAcceptors(mol),
+        "Rotatable Bonds": Lipinski.NumRotatableBonds(mol),
+        "Rings": mol.GetRingInfo().NumRings(),
+        "Fraction Csp3": round(rdMolDescriptors.CalcFractionCSP3(mol), 3),
+        "Heavy Atoms": mol.GetNumHeavyAtoms(),
+        "Formal Charge": rdmolops.GetFormalCharge(mol),
+        "Lipinski pass": lipinski_pass(smiles),
+    }
+    return summary
+
+
+if __name__ == "__main__":
+    import argparse
+    import json
+
+    parser = argparse.ArgumentParser(
+        description="Analyze SMILES strings for molecular properties."
+    )
+    parser.add_argument("smiles", type=str, help="SMILES string of the molecule")
+    args = parser.parse_args()
+
+    result = molecule_summary(args.smiles)
+    print(json.dumps(result, indent=2))

p2smi-0.1.0/p2smi/fasta2smi.py

@@ -0,0 +1,101 @@
+"""
+Module to input FASTA peptide files and generate 3D structures.
+Original by Fergal; modified by Aaron Feller (2025)
+"""
+
+import argparse
+
+import p2smi.utilities.smilesgen as smilesgen
+
+
+class InvalidConstraintError(Exception):
+    pass
+
+
+def parse_fasta(fasta_file):
+    """
+    Generator that yields (sequence, constraint) tuples from a FASTA file.
+    """
+    with open(fasta_file, "r") as fasta:
+        sequence, constraint = "", ""
+        for line in fasta:
+            line = line.strip()
+            if line.startswith(">"):
+                if sequence:
+                    yield sequence, constraint
+                sequence = ""
+                constraint = line.split("|")[-1] if "|" in line else ""
+            else:
+                sequence += line
+        if sequence:
+            yield sequence, constraint
+
+
+def constraint_resolver(sequence, constraint):
+    """
+    Resolves constraints for a sequence using available functions
+    or generates fallback structures.
+    """
+    constraint_functions = {
+        "SS": smilesgen.can_ssbond,
+        "HT": smilesgen.can_htbond,
+        "SCNT": smilesgen.can_scntbond,
+        "SCCT": smilesgen.can_scctbond,
+        "SCSC": smilesgen.can_scscbond,
+    }
+    valid_constraints = smilesgen.what_constraints(sequence)
+
+    if constraint.upper() in valid_constraints:
+        return (sequence, constraint)
+    elif constraint.upper() in constraint_functions:
+        result = constraint_functions[constraint.upper()](sequence)
+        return result or (sequence, "")
+    elif constraint.upper() == "SC":
+        for func in [
+            constraint_functions[k] for k in constraint_functions if "SC" in k
+        ]:
+            result = func(sequence)
+            if result:
+                return result
+        raise InvalidConstraintError(f"{sequence} has invalid constraint {constraint}")
+    elif constraint in (None, ""):
+        return (sequence, "")
+    else:
+        raise InvalidConstraintError(f"{sequence} has invalid constraint {constraint}")
+
+
+def process_constraints(fasta_file):
+    """
+    Processes constraints for all sequences in the FASTA file.
+    """
+    return (constraint_resolver(seq, constr) for seq, constr in parse_fasta(fasta_file))
+
+
+def generate_3d_structures(input_fasta, out_file):
+    """
+    Generates 3D structures from FASTA input and writes to output.
+    """
+    resolved_sequences = process_constraints(input_fasta)
+    smilesgen.write_library(
+        (
+            smilesgen.constrained_peptide_smiles(seq, constr)
+            for seq, constr in resolved_sequences
+        ),
+        out_file,
+        write="text",
+        write_to_file=True,
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate peptides from a FASTA file.")
+    parser.add_argument(
+        "-i", "--input_fasta", required=True, help="FASTA file of peptides."
+    )
+    parser.add_argument("-o", "--out_file", required=True, help="Output file.")
+    args = parser.parse_args()
+    generate_3d_structures(args.input_fasta, args.out_file)
+
+
+if __name__ == "__main__":
+    main()