ligandparam 0.3.0__tar.gz

ligandparam-0.3.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: ligandparam
+Version: 0.3.0
+Summary: A ligand parameterization package for Amber
+Author-email: Zeke Piskulich <piskulichz@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/piskulichz/ligandparam
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numpy<2
+Requires-Dist: pandas
+Requires-Dist: requests
+Requires-Dist: MDAnalysis>2.7.0
+Requires-Dist: pathlib
+Requires-Dist: parmed
+Requires-Dist: ase
+Requires-Dist: deepmd-kit
+Requires-Dist: tensorflow
+Requires-Dist: tblite
+Provides-Extra: other
+Requires-Dist: openbabel; extra == "other"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+
+# Ligand Parametrization
+
+## Overview
+This is a Python package designed to provide a simple workflow for ligand parameterization. It automates many of the 
+key features encountered by users, including...
+
+## Documentation
+
+The online documentation is located here: https://ligandparam.readthedocs.io/en/latest/
+

ligandparam-0.3.0/README.md

@@ -0,0 +1,10 @@
+# Ligand Parametrization
+
+## Overview
+This is a Python package designed to provide a simple workflow for ligand parameterization. It automates many of the 
+key features encountered by users, including...
+
+## Documentation
+
+The online documentation is located here: https://ligandparam.readthedocs.io/en/latest/
+

ligandparam-0.3.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ligandparam"
+version = "0.3.0"
+description = "A ligand parameterization package for Amber"
+readme = "README.md"
+requires-python = ">=3.6"
+license = {text = "MIT"}
+authors = [
+  {name = "Zeke Piskulich", email = "piskulichz@gmail.com"}
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent"
+]
+dependencies = [
+  "numpy<2",
+  "pandas",
+  "requests",
+  "MDAnalysis>2.7.0",
+  "pathlib",
+  "parmed",
+  "ase",
+  "deepmd-kit",
+  "tensorflow",
+  "tblite"
+]
+
+
+urls = { "Homepage" = "https://github.com/piskulichz/ligandparam" }
+
+[project.scripts]
+lighfix = "ligandparam.cli.cli_lighfix:lighfix"
+lig-getparam = "ligandparam.cli.ligandparam_getparam:main"
+smiles-to-pdb = "ligandparam.cli.smiles_to_pdb:main"
+
+[project.optional-dependencies]
+other = [
+  "openbabel",
+]
+docs = [
+  "sphinx",
+  "sphinx_rtd_theme",
+]
+
+[tool.ruff]
+line-length = 120
+indent-width = 4
+
+[tool.ruff.format]
+skip-magic-trailing-comma = true
+

ligandparam-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ligandparam-0.3.0/src/ligandparam/__init__.py

@@ -0,0 +1,4 @@
+# This file is intentionally left blank.
+__version__ = "0.3.0"
+__logging_name__ = "ligandparam"
+

ligandparam-0.3.0/src/ligandparam/cli/cli_lighfix.py

@@ -0,0 +1,50 @@
+import sys
+from pathlib import Path
+import argparse
+import logging
+
+from ligandparam.stages import LigHFix
+
+
+def get_opts() -> dict:
+    parser = argparse.ArgumentParser(description="Fix hydrogenation and bonding in ligands that come from PDB")
+    parser.add_argument("-i", "--ligand_id", help="Path to the input PDB file.", required=True)
+    parser.add_argument("-p", "--in_pdb", help="Path to the input PDB file.", required=True)
+    parser.add_argument("-o", "--out_pdb", help="Path to the output file.", default="output.txt", required=True)
+
+    args = parser.parse_args()
+    opts = {}
+    opts["ligand_id"] = args.ligand_id
+    opts["in_pdb"] = Path(args.in_pdb)
+    opts["out_pdb"] = Path(args.out_pdb)
+
+    if not opts["in_pdb"].is_file() or opts["in_pdb"].suffix != ".pdb":
+        raise ValueError(f"Bad input PDB: {opts['in_pdb']}")
+
+    if not opts["out_pdb"].parent.is_dir():
+        raise ValueError(f"Bad dir for out_pdb: {opts['out_pdb'].parent}")
+
+    if opts["out_pdb"].suffix != ".pdb":
+        raise ValueError(f"Bad output PDB: {opts['out_pdb']}")
+
+    return opts
+
+
+def ligfix():
+    opts = get_opts()
+
+    # Send output to stdout, though it probably won't print anything unless there's an error
+    logger = logging.getLogger("mylog")
+    logger.setLevel(logging.INFO)
+    stream_handler = logging.StreamHandler(sys.stdout)
+    stream_handler.setLevel(logging.INFO)
+    logger.addHandler(stream_handler)
+
+    s = LigHFix("liga", main_input=opts["ligand_id"], cwd=opts["out_pdb"].parent, in_pdb=opts["in_pdb"],
+                out_pdb=opts["out_pdb"], logger=logger)
+
+    s.execute()
+
+
+if __name__ == "__main__":
+    ligfix()

ligandparam-0.3.0/src/ligandparam/cli/ligandparam_getparam.py

@@ -0,0 +1,237 @@
+import logging
+import sys, shutil
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+from ligandparam import __version__
+from ligandparam.stages import PDB_Name_Fixer
+
+
+
+def set_file_logger(
+    logfilename: Path, logname: str = None, filemode: str = "a"
+    ) -> logging.Logger:
+    """ Set up a file logger for the ligand parameterization process.
+    
+    Parameters
+    ----------
+    logfilename : Path
+        The path to the log file where the logs will be written.
+    logname : str, optional
+        The name of the logger. If None, it will be derived from the log filename.
+    filemode : str, optional
+        The mode in which the log file will be opened. Default is 'a' (append
+        mode). Use 'w' for write mode to overwrite the log file.
+    Returns
+    -------
+    logger : logging.Logger
+        A configured logger instance that writes logs to the specified file.
+    
+    """
+    if logname is None:
+        logname = Path(logfilename).stem
+    logger = logging.getLogger(logname)
+    logger.setLevel(logging.INFO)
+    formatter = logging.Formatter(
+        "{asctime} - {levelname} - {version} {message}",
+        style="{",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        defaults={"version": __version__},
+    )
+    file_handler = logging.FileHandler(filename=logfilename, mode=filemode)
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    return logger
+
+def worker(recipe_name: str, mol: str, resname: str, cwd: Path, net_charge: float, atom_type: str = "gaff2", charge_model: str = "bcc", model: str = None, sqm: str = True, data_cwd: str = "param", nprocs: int = 1, mem: int = 1, reference_pdb: str = None) -> Path:
+    binder_dir = cwd / data_cwd / resname
+    binder_dir.mkdir(parents=True, exist_ok=True)
+    binder_pdb = cwd / mol
+    logger = set_file_logger(
+        binder_dir / f"{resname}.log", filemode="w"
+    )
+    """ Worker function to execute the ligand parameterization recipe.
+    
+    Parameters
+    ----------
+    recipe_name : str
+        The name of the recipe to be used for ligand parameterization.
+    mol : str
+        The input PDB file containing the ligand.
+    resname : str
+        The residue name for the ligand.
+    cwd : Path
+        The current working directory where the output files will be stored.
+    net_charge : float
+        The net charge of the ligand.
+    atom_type : str, optional
+        The atom type for the ligand (default is "gaff2").
+    charge_model : str, optional
+        The charge model for the ligand (default is "bcc"). Options are "bcc" or
+        "abcg2".
+    model : str, optional
+        The path to the DeepMD model file (optional).
+    sqm : bool, optional
+        Whether to use SQM calculations for geometry optimization (default is True).
+    data_cwd : str, optional
+        The directory to store output files (default is "param").
+    nprocs : int, optional
+        The number of processes to use for parallel execution (default is 1).
+    mem : int, optional
+        The amount of memory in GB to allocate for the process (default is 1GB).
+    
+    Returns
+    -------
+    None
+    """
+
+    print("Working on ligand:", resname)
+    if not binder_pdb.is_file():
+        raise FileNotFoundError(f"Input file {binder_pdb} does not exist. Please provide a valid PDB file.")
+    if not binder_dir.is_dir():
+        raise NotADirectoryError(f"Output directory {binder_dir} does not exist. Please provide a valid directory.")
+    
+    logger.info(f"Starting ligand parameterization for {resname} using recipe '{recipe_name}'")
+    logger.info(f"Input file: {binder_pdb}")
+    logger.info(f"Output directory: {binder_dir}")
+    logger.info(f"Net charge: {net_charge}")
+    logger.info(f"Atom type: {atom_type}")
+    logger.info(f"Charge model: {charge_model}")
+    if model is not None:
+        logger.info(f"Using DeepMD model: {model}")
+    if sqm:
+        logger.info("Using SQM calculations for geometry optimization.") 
+    else:
+        logger.info("Not using SQM calculations for geometry optimization.")
+    logger.info("Starting recipe execution...")
+
+    
+    
+    if reference_pdb is not None:
+        logger.info(f"Reference PDB file: {reference_pdb}")
+        fix_pdb_stage = PDB_Name_Fixer(f"build_{resname}", binder_pdb, binder_dir, out_pdb=f"{binder_pdb.parent}/fix_{binder_pdb.name}", reference_pdb=reference_pdb, align=True, logger=logger)
+        fix_pdb_stage.execute(dry_run=False)
+        logger.info("PDB name fixing complete.")
+        out_pdb = f"{binder_pdb.parent}/fix_{binder_pdb.name}"
+    else:
+        out_pdb = binder_pdb
+
+
+    recipe = recipe_selector(
+        recipe_name,
+        in_filename = f"{out_pdb}",
+        cwd        = binder_dir,
+        atom_type  = atom_type,
+        charge_model = charge_model,
+        net_charge = net_charge,
+        logger     = logger,
+        molname    = resname,
+        model      = model,
+        sqm        = sqm,
+        nproc      = nprocs,
+        mem        = mem
+    )
+    logger.info(f"Recipe selected: {recipe_name}")
+    recipe.setup()
+    recipe.execute()
+    logger.info("Recipe execution complete.")
+
+def recipe_selector(recipe_name: str, **kwargs):
+    """ Selects and returns the appropriate recipe class based on the recipe name.
+    
+    Parameters
+    ----------
+    recipe_name : str
+        The name of the recipe to be used for ligand parameterization.
+    **kwargs : dict
+        Additional keyword arguments to be passed to the recipe class constructor.
+    
+    Returns
+    -------
+    AbstractStage
+        An instance of the selected recipe class.
+    
+    Raises
+    ------
+    ValueError
+        If the recipe name is not recognized, a ValueError is raised with a message
+        listing the available recipes.
+    
+    """
+    if recipe_name == "lazyligand":
+        from ligandparam.recipes.lazyligand import LazyLigand
+        return LazyLigand(**kwargs)
+    elif recipe_name == "lazierligand":
+        from ligandparam.recipes.lazierligand import LazierLigand
+        return LazierLigand(**kwargs)
+    elif recipe_name == "freeligand":
+        from ligandparam.recipes.freeligand import FreeLigand
+        return FreeLigand(**kwargs)
+    elif recipe_name == "dplazyligand":
+        from ligandparam.recipes.dplazyligand import DPLigand
+        return DPLigand(**kwargs)
+    elif recipe_name == "dpfreeligand":
+        from ligandparam.recipes.dpfreeligand import DPFreeLigand
+        return DPFreeLigand(**kwargs)
+    elif recipe_name == "sqmligand":
+        from ligandparam.recipes import SQMLigand
+        return SQMLigand(**kwargs)
+    else:
+        raise ValueError(f"Unknown recipe name: {recipe_name}. Available recipes: lazyligand, lazierligand, freeligand, dplazyligand, dpfreeligand.")
+
+
+def main():
+    """ Main function to parse command line arguments and execute the ligand parameterization worker.
+    
+    This function uses argparse to handle command line arguments and calls the worker
+    function with the parsed arguments. It sets up the current working directory and
+    initializes the logger for the ligand parameterization process.
+    
+    Raises
+    ------
+    SystemExit
+        If the command line arguments are not provided correctly, argparse will raise
+        a SystemExit exception, which will terminate the program with an error message.
+    
+    """
+    import argparse
+
+
+    parser = argparse.ArgumentParser(description="Ligand parameterization CLI")
+    parser.add_argument("-i", "--input", type=str, required=True, help="Input PDB file with ligand")
+    parser.add_argument("-r", "--resname", type=str, required=True, help="Residue name for the ligand")
+    parser.add_argument("-d", "--data_cwd", type=Path, required=True, help="Directory to store output files")
+    parser.add_argument("-a", "--atom_type", type=str, default="gaff2", help="Atom type for the ligand (default: gaff2)")
+    parser.add_argument("-cm", "--charge_model", type=str, default="bcc", choices=["bcc", "abcg2"], help="Charge model for the ligand (default: bcc, options: bcc, abcg2)")
+    parser.add_argument("-c", "--net_charge", type=float, default=0.0, help="Net charge of the ligand")
+    parser.add_argument("-m", "--model", type=str, default=None, help="DeepMD model file path (optional)")
+    parser.add_argument("--sqm", action='store_true', help="Use SQM calculations")
+    parser.add_argument("-rn", "--recipe_name", type=str, required=True, help="Recipe name for the ligand processing")
+    parser.add_argument("-n", "--nproc", type=int, default=1, help="Number of processes to use (default: 1)")
+    parser.add_argument("-mem", "--mem", type=int, default=1, help="Memory in GB to allocate for the process (default: 1GB)")
+    parser.add_argument("-ref", "--reference_pdb", type=str, default=None, help="Reference PDB file for name fixing (optional)")
+
+    args = parser.parse_args()
+
+    cwd = Path.cwd()
+
+    worker(
+        recipe_name=args.recipe_name,
+        mol=args.input,
+        cwd=cwd,
+        resname=args.resname,
+        data_cwd=args.data_cwd,
+        net_charge=args.net_charge,
+        atom_type=args.atom_type,
+        charge_model=args.charge_model,
+        model=args.model,
+        sqm=args.sqm,
+        nprocs=args.nproc,
+        mem=args.mem,
+        reference_pdb=args.reference_pdb
+    )
+
+if __name__ == "__main__":
+    main()

ligandparam-0.3.0/src/ligandparam/cli/smiles_to_pdb.py

@@ -0,0 +1,40 @@
+import argparse
+from rdkit import Chem
+from rdkit.Chem import AllChem
+
+def smiles_to_pdb(smiles, pdb_filename, resname="LIG"):
+    # Generate molecule from SMILES
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError("Invalid SMILES string.")
+
+    # Add hydrogens
+    mol = Chem.AddHs(mol)
+
+    # Generate 3D coordinates
+    if AllChem.EmbedMolecule(mol, AllChem.ETKDG()) != 0:
+        raise RuntimeError("3D coordinate generation failed.")
+
+    # Minimize with MMFF or UFF
+    if AllChem.MMFFHasAllMoleculeParams(mol):
+        AllChem.MMFFOptimizeMolecule(mol)
+    else:
+        AllChem.UFFOptimizeMolecule(mol)
+    # Set residue name for all atoms
+    for atom in mol.GetAtoms():
+        atom.SetProp("resName", resname)
+    # Write to PDB
+    with open(pdb_filename, 'w') as f:
+        f.write(Chem.MolToPDBBlock(mol))
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert SMILES to PDB with 3D coordinates and minimization.")
+    parser.add_argument("-s", "--smiles", required=True, help="Input SMILES string")
+    parser.add_argument("-o", "--output", required=True, help="Output PDB filename")
+    parser.add_argument("-rn", "--resname", default="LIG", help="Residue name for the ligand (default: LIG)")
+    args = parser.parse_args()
+
+    smiles_to_pdb(args.smiles, args.output, args.resname)
+
+if __name__ == "__main__":
+    main()

ligandparam-0.3.0/src/ligandparam/deprecated/stagegausrotation.py

@@ -0,0 +1,52 @@
+import MDAnalysis as mda
+
+from ligandparam.abstractstage import AbstractStage
+from ligandparam.coordinates import Coordinates
+from ligandparam.gaussianIO import GaussianWriter, GaussianInput
+
+from ligandparam.log import get_logger
+
+
+
+class StageGaussianRotation(AbstractStage):
+    def __init__(self, name, alpha = [0.0], beta = [0.0], gamma = [0.0], base_cls=None) -> None:
+        self.name = name
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
+
+        if base_cls.coord_object is None:
+            raise ValueError(f"Error (Stage {self.name}): Coordinate object not set")
+
+        if base_cls.name is None:
+            raise ValueError(f"Error (Stage {self.name}): Base name not set")
+
+        if base_cls.header is None:
+            raise ValueError(f"Error (Stage {self.name}): Header not set")
+
+        self.base_cls = base_cls
+        
+        return
+    
+    def _append_stage(self, stage: "AbstractStage") -> "AbstractStage":
+        return stage
+
+    def execute(self, dry_run=False, nproc=1, mem=1) -> Any:
+        self.logger.info(f"Executing {self.stage_name} with alpha={self.alpha}, beta={self.beta}, and gamma={self.gamma}")
+
+        run_apply = print
+
+        for a in self.alpha:
+            for b in self.beta:
+                for g in self.gamma:
+                    #TODO: add elements and header, and make sure they are consistent between steps. Probably initialized with class
+                    newgau = GaussianWriter('gaussianCalcs/'+self.base_cls.name+f'_rot_{a}_{b}.com')
+                    
+                    newgau.add_block(GaussianInput(command=f"#P {self.base_cls.theory['low']} OPT(CalcFC)",
+                                        initial_coordinates = self.base_cls.coord_object.rotate(alpha=a, beta=b),
+                                        elements = self.base_cls.coord_object.get_elements(),
+                                        header=self.base_cls.header))
+                    newgau.write(dry_run=dry_run)
+                    run_apply(newgau.get_run_command())
+        
+        return

ligandparam-0.3.0/src/ligandparam/deprecated/stagegaussian.py

@@ -0,0 +1,43 @@
+import os
+
+import MDAnalysis as mda
+
+from ligandparam.abstractstage import AbstractStage
+from ligandparam.coordinates import Coordinates
+from ligandparam.gaussianIO import GaussianWriter, GaussianInput
+from ligandparam.interfaces import Gaussian
+
+
+class StageGaussian(AbstractStage):
+    def __init__(self, name, base_cls=None) -> None:
+        self.name = name
+        self.base_cls = base_cls
+        return
+
+    def _append_stage(self, stage: "AbstractStage") -> "AbstractStage":
+        return stage
+
+    def execute(self, dry_run=False, nproc=1, mem=1) -> Any:
+        stageheader = self.base_cls.header
+        stageheader.append(f"%chk={self.base_cls.name}.antechamber.chk")
+        gau = GaussianWriter(f'gaussianCalcs/{self.base_cls.name}.com')
+        gau.add_block(GaussianInput(command=f"#P {self.base_cls.theory['low']} OPT(CalcFC)",
+                                    initial_coordinates=self.base_cls.coord_object.get_coordinates(),
+                                    elements=self.base_cls.coord_object.get_elements(),
+                                    header=stageheader))
+        gau.add_block(GaussianInput(command=f"#P {self.base_cls.theory['high']} OPT(CalcFC) GEOM(ALLCheck) Guess(Read)",
+                                    header=stageheader))
+        gau.add_block(GaussianInput(
+            command=f"#P {self.base_cls.theory['low']} GEOM(AllCheck) Guess(Read) NoSymm Pop=mk IOp(6/33=2) GFInput GFPrint",
+            header=stageheader))
+
+        has_run = gau.write(dry_run=dry_run)
+
+        if not has_run:
+            gau_run = Gaussian()
+            gau_run.call(inp_pipe=self.base_cls.name + '.com',
+                         out_pipe=self.base_cls.name + '.log',
+                         dry_run=dry_run)
+        os.chdir('..')
+
+        return

ligandparam-0.3.0/src/ligandparam/deprecated/stagegaussiantomol2.py

@@ -0,0 +1,63 @@
+import warnings
+
+import MDAnalysis as mda
+
+from ligandparam.abstractstage import AbstractStage
+from ligandparam.interfaces import Antechamber
+
+
+class StageGaussiantoMol2(AbstractStage):
+    def __init__(self, name, base_cls=None, dry_run=None) -> None:
+        self.name = name
+        self.base_cls = base_cls
+        self.dry_run = dry_run
+
+    def _append_stage(self, stage: "AbstractStage") -> "AbstractStage":
+        return stage
+
+    def execute(self, dry_run=False, nproc=1, mem=1) -> Any:
+        if self.dry_run is not None:
+            dry_run = self
+
+        # Convert from gaussian to mol2
+        ante = Antechamber()
+        ante.call(
+            i=self.base_cls.name + ".log",
+            fi="gout",
+            o=self.base_cls.name + ".tmp1.mol2",
+            fo="mol2",
+            pf="y",
+            at=self.base_cls.atom_type,
+            an="no",
+            nc=self.net_charge,
+            run=(not dry_run),
+        )
+
+        # Assign the charges
+        if not dry_run:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                u1 = mda.Universe(self.base_cls.name + ".antechamber.mol2")
+                u2 = mda.Universe(self.base_cls.name + ".tmp1.mol2")
+                assert len(u1.atoms) == len(u2.atoms), "Number of atoms in the two files do not match"
+
+                u2.atoms.charges = u1.atoms.charges
+
+                ag = u2.select_atoms("all")
+                ag.write(self.base_cls.name + ".tmp2.mol2")
+
+        # Use antechamber to clean up the mol2 format
+        ante = Antechamber(self.cwd)
+        ante.call(
+            i=self.base_cls.name + ".tmp2.mol2",
+            fi="mol2",
+            o=self.base_cls.name + ".log.mol2",
+            fo="mol2",
+            pf="y",
+            at=self.base_cls.atom_type,
+            an="no",
+            nc=self.net_charge,
+            run=(not dry_run),
+        )
+
+        return

ligandparam-0.3.0/src/ligandparam/deprecated/stageinitialize.py

@@ -0,0 +1,41 @@
+from typing import Optional,  Any
+from ligandparam.abstractstage import AbstractStage
+from ligandparam.interfaces import Antechamber
+
+
+class StageInitialize(AbstractStage):
+    """This class is used to initialize from pdb to mol2 file using Antechamber.
+
+    Parameters
+    ----------
+    name : str
+        Name of the stage.
+    base_cls : object
+        Object of the base class.
+
+    """
+
+    def __init__(self, name, base_cls=None) -> None:
+        self.name = name
+        self.base_cls = base_cls
+
+        return
+
+    def _append_stage(self, stage: "AbstractStage") -> "AbstractStage":
+        return stage
+
+    def execute(self, dry_run=False, nproc=1, mem=1) -> Any:
+        ante = Antechamber()
+        ante.call(
+            i=self.base_cls.name + ".pdb",
+            fi="pdb",
+            o=self.base_cls.name + ".antechamber.mol2",
+            fo="mol2",
+            c="bcc",
+            nc=self.base_cls.net_charge,
+            pf="y",
+            at=self.base_cls.atom_type,
+            an="no",
+            dry_run=dry_run,
+        )
+

ligandparam-0.3.0/src/ligandparam/deprecated/stagelazyresp.py

@@ -0,0 +1,33 @@
+import MDAnalysis as mda
+import numpy as np
+
+from ligandparam.abstractstage import AbstractStage
+from ligandparam.interfaces import Antechamber
+from ligandparam.log import get_logger
+
+
+class StageLazyResp(AbstractStage):
+    def __init__(self, name, base_cls=None) -> None:
+        self.name = name
+        self.base_cls = base_cls
+        return
+
+    def _append_stage(self, stage: "AbstractStage") -> "AbstractStage":
+        return stage
+
+    def execute(self, dry_run=False, nproc=1, mem=1) -> Any:
+        self.logger.info(f"Executing {self.name} with netcharge={self.base_cls.net_charge}")
+        ante = Antechamber()
+        ante.call(
+            i=f"gaussianCalcs/{self.base_cls.name}.log",
+            fi="gout",
+            o=self.base_cls.name + ".resp.mol2",
+            fo="mol2",
+            gv=0,
+            c="resp",
+            nc=self.base_cls.net_charge,
+            at="gaff2",
+            an="no",
+            dry_run=dry_run,
+        )
+        return