mutadock 1.1__py2.py3-none-any.whl

docking/__init__.py

@@ -0,0 +1,40 @@
+################################################################################
+#                           PROJECT INFORMATION                                #
+#                              Name: MUTADOCK                                  #
+#                           Author: Naisarg Patel                              #
+#                                                                              #
+#       Copyright (C) 2024 Naisarg Patel (https://github.com/naisarg14)        #
+#                                                                              #
+#          Project: https://github.com/naisarg14/mutadock                      #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify it    #
+#  under the terms of the GNU General Public License version 3 as published    #
+#  by the Free Software Foundation.                                            #
+#                                                                              #
+#  This program is distributed in the hope that it will be useful, but         #
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  #
+#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    #
+#  for more details.                                                           #
+################################################################################
+
+if __name__ == "__main__":
+    print("""
+################################################################################
+#                           PROJECT INFORMATION                                #
+#                              Name: MUTADOCK                                  #
+#                           Author: Naisarg Patel                              #
+#                                                                              #
+#       Copyright (C) 2024 Naisarg Patel (https://github.com/naisarg14)        #
+#                                                                              #
+#          Project: https://github.com/naisarg14/mutadock                      #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify it    #
+#  under the terms of the GNU General Public License version 3 as published    #
+#  by the Free Software Foundation.                                            #
+#                                                                              #
+#  This program is distributed in the hope that it will be useful, but         #
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  #
+#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    #
+#  for more details.                                                           #
+################################################################################
+""")

docking/np_docking.py

@@ -0,0 +1,205 @@
+################################################################################
+#                           PROJECT INFORMATION                                #
+#                              Name: MUTADOCK                                  #
+#                           Author: Naisarg Patel                              #
+#                                                                              #
+#       Copyright (C) 2024 Naisarg Patel (https://github.com/naisarg14)        #
+#                                                                              #
+#          Project: https://github.com/naisarg14/mutadock                      #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify it    #
+#  under the terms of the GNU General Public License version 3 as published    #
+#  by the Free Software Foundation.                                            #
+#                                                                              #
+#  This program is distributed in the hope that it will be useful, but         #
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  #
+#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    #
+#  for more details.                                                           #
+################################################################################
+
+from itertools import product
+import os, time, sys
+import argparse
+from contextlib import contextmanager
+from tqdm import tqdm
+from vina_helper import prepare_receptor, prepare_ligand, vina_split, add_score_to_csv, dock_vina, read_config, calculate_geometric_center, backup
+
+
+@contextmanager
+def suppress_stdout():
+    with open(os.devnull, "w") as devnull:
+        old_stdout = sys.stdout
+        sys.stdout = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+
+
+def naisarg():
+    start_time = time.time()
+    receptors, ligands, config, autosite, quiet, completed_name, ignore_existing = prepare_inputs()
+
+    if config is None and autosite is None:
+        print("Both config and autosite not provided. Assuming center as [0,0,0] and box_size as [30,30,30].")
+
+    if config is not None:
+        values = read_config
+        values = read_config(config)
+        if values[0] is False:
+            sys.exit(f"Error while reading the config file {config} \nError: {values[1]}")
+        _, center, box_size, exhaustiveness, n_poses, n_poses_write, overwrite = values
+
+    if autosite is not None:
+        site = calculate_geometric_center(autosite)
+        if site[0] is not False:
+            center = site[0]
+        else:
+            sys.exit(f"Error while calculating the geometric center of the autosite file {autosite} \nError: {site[1]}")
+
+    try:
+        with open(completed_name, "r") as f:
+            completed = f.readlines()
+            completed = [x.replace("\n", "") for x in completed]
+    except FileNotFoundError:
+        completed = []
+
+    if ignore_existing:
+        completed = []
+
+    combinations = list(product(receptors, ligands))
+
+    combinations = [x for x in combinations if str(x) not in completed]
+
+    if not quiet and not ignore_existing: print(f"Found {len(completed)} completed receptor-ligand combinations. {len(combinations)} combinations to be docked.")
+
+    for combination in tqdm(combinations):
+        receptor = combination[0]
+        ligand = combination[1]
+        prepared_receptor = f"{receptor}qt"
+        
+        if ligand.endswith(".sdf"):
+            prepared_ligand = f"{ligand.removesuffix(".sdf")}.pdbqt"
+        elif ligand.endswith(".mol2"):
+            prepared_ligand = f"{ligand.removesuffix(".mol2")}.pdbqt"
+
+        if not quiet: print(f"Docking the receptor {receptor} to the ligand {ligand}")
+        master_folder_receptor, receptor_file = os.path.split(os.path.abspath(receptor))
+        master_folder_ligand, ligand_file = os.path.split(os.path.abspath(ligand))
+        
+        output_dir = os.path.join(master_folder_receptor, 'out')
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        out_pdb = os.path.join(output_dir, f'{receptor_file.removesuffix(".pdb")}_{ligand_file.removesuffix(".sdf")}_out.pdb')
+        log_file = os.path.join(output_dir, f'{receptor_file.removesuffix(".pdb")}_{ligand_file.removesuffix(".sdf")}_log.txt')
+        csv_file = os.path.join(output_dir, "docking_results.csv")
+
+        backup(out_pdb)
+        backup(log_file)
+
+        try:
+            if not quiet: print(f"Docking for {ligand} with {receptor}")
+            if not quiet: print("Press Ctrl+D (EOFE Error) to skip this receptor-ligand combination.")
+            if not os.path.exists(prepared_receptor) or ignore_existing:
+                if not quiet: print(f"Preparing receptor {receptor}")
+                with suppress_stdout(): rec_out = prepare_receptor(receptor_filename=receptor, outputfilename=prepared_receptor)
+                if not rec_out[0]:
+                    print(f"Error while preparing receptor {receptor} \nError: {rec_out[1]} \nSkipping this receptor-ligand combination.")
+                    continue
+
+            if not os.path.exists(prepared_ligand) or ignore_existing:
+                if not quiet: print(f"Preparing ligand {ligand}")
+                with suppress_stdout(): lig_out = prepare_ligand(in_file=ligand, out_file=prepared_ligand)
+                if not lig_out[0]:
+                    print(f"Error while preparing ligand {ligand} \nError: {lig_out[1]} \nSkipping this receptor-ligand combination.")
+                    continue
+
+            if not quiet: print(f"Starting docking")
+            with suppress_stdout(): vina_out = dock_vina(prepared_receptor, prepared_ligand, out_pdb, log_file, center=center, box_size=box_size, exhaustiveness=exhaustiveness, n_poses=n_poses, n_poses_write=n_poses_write, overwrite=overwrite)
+            if not vina_out[0]:
+                print(f"Error while docking {ligand} to {receptor} \nError: {vina_out[1]} \nSkipping this receptor-ligand combination.")
+                continue
+            if not quiet: print("Docking Completed, writing log file")
+
+            if not quiet: print("Getting the ligand 1 after docking")
+            ligand_1 = out_pdb.replace('.pdbqt', '_ligand_1.sdf')
+            with suppress_stdout(): score, _ = vina_split(input_file=out_pdb, output_file=out_pdb)
+            if not quiet: print("Adding affinity to CSV")
+            csv_add = add_score_to_csv(out_pdb, csv_file, score)
+            if not csv_add[0]:
+                print(f"Error while adding affinity to CSV file {csv_file} \nError: {csv_add[1]}")
+            
+            with open(completed_name, "a+") as file: file.write(f"{combination}\n")
+
+            if not quiet: print(f"Docking completed, log file is {log_file}, ligand_1 is {ligand_1.replace("pdbqt", "sdf")}, docking affinity is {score}. \n")
+
+        except EOFError:
+            continue
+
+ 
+    end_time = time.time()
+    elapsed_time = (end_time - start_time)/60
+    
+    print(f"All Outputs are saved in the folder: {output_dir}")
+
+    print(f"Completed in {elapsed_time:.2f} minutes!")
+
+
+def prepare_inputs():
+    parser = argparse.ArgumentParser(prog="np_dock", description=None, epilog="Part of mutadock library. Written by Naisarg Patel (https://github.com/naisarg14)")
+    parser.add_argument('receptor_txt', help="Text File with all receptors", metavar="RECEPTOR")
+    parser.add_argument("ligand_txt", help="Text File with all ligands", metavar="LIGAND")
+    parser.add_argument("--config",default=None, help="Text File with all Vina Configuration Settings", metavar="CONFIG")
+    parser.add_argument("--autosite",default=None, help="PDB generated by autosite for binding site of protein.", metavar="AUTOSITE")
+    parser.add_argument("--quiet", action="store_true", help="Run the Docking in quiet mode (default: False).")
+    parser.add_argument("--ignore_existing", action="store_true", help="Run the Docking while ingoring existing files. All dockings will be performed again. (default: False).")
+
+    args = parser.parse_args()
+
+    receptor_txt = args.receptor_txt
+    ligand_txt = args.ligand_txt
+    config = args.config
+
+    print("Receptor file:", receptor_txt)
+    print("Ligands file:", ligand_txt)
+    print("Config file:", config)
+    for f in [receptor_txt, ligand_txt]:
+        if not os.path.exists(f):
+            print(f"{f} not found or cannot be opened.")
+    try:
+        with open(receptor_txt, "r") as rec:
+            receptors = rec.readlines()
+    except IOError as err:
+        sys.exit(f"Error reading the file {receptor_txt}: ".format(receptor_txt, err))
+    try:
+        with open(ligand_txt, "r") as lig:
+            ligands = lig.readlines()
+    except IOError as err:
+        sys.exit(f"Error reading the file {ligand_txt}: ".format(ligand_txt, err))
+
+    for i in range(len(receptors)):
+        receptors[i] = receptors[i].replace("\n", "")
+        if not os.path.isabs(receptors[i]):
+            receptors[i] = os.path.join(os.getcwd(), receptors[i])
+    for i in range(len(ligands)):
+        ligands[i] = ligands[i].replace("\n", "")
+        if not os.path.isabs(ligands[i]):
+            ligands[i] = os.path.join(os.getcwd(), ligands[i])
+
+    receptor_basename = os.path.basename(receptor_txt)
+    ligand_basename = os.path.basename(ligand_txt)
+
+    if os.path.isabs(receptor_txt):
+        rec_folder = os.path.dirname(receptor_txt)
+    else:
+        rec_folder = os.path.dirname(os.path.abspath(receptor_txt))
+
+    completed_file_name = f"{receptor_basename.removesuffix(".txt")}_{ligand_basename.removesuffix(".txt")}_completed.txt"
+    completed_name = os.path.join(rec_folder, completed_file_name)
+
+    return receptors, ligands, config, args.autosite, args.quiet, completed_name, args.ignore_existing
+
+
+if __name__ == "__main__":
+    naisarg()

docking/vina_dock.py

@@ -0,0 +1,83 @@
+################################################################################
+#                           PROJECT INFORMATION                                #
+#                              Name: MUTADOCK                                  #
+#                           Author: Naisarg Patel                              #
+#                                                                              #
+#       Copyright (C) 2024 Naisarg Patel (https://github.com/naisarg14)        #
+#                                                                              #
+#          Project: https://github.com/naisarg14/mutadock                      #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify it    #
+#  under the terms of the GNU General Public License version 3 as published    #
+#  by the Free Software Foundation.                                            #
+#                                                                              #
+#  This program is distributed in the hope that it will be useful, but         #
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  #
+#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    #
+#  for more details.                                                           #
+################################################################################
+
+
+import sys, argparse
+
+def vina_dock(receptor, ligand, output, center=[0, 0, 0], box_size=[30, 30, 30], exhaustiveness=32, n_poses=20, n_poses_write=5, overwrite=True):
+    try:
+        from vina import Vina
+    except ModuleNotFoundError:
+        msg = "Error with importing modules for docking using Vina.\n"
+        msg += "Easiest way to fix this is to install vina using the following command:\n\n"
+        msg += "python -m pip install vina\n"
+        msg += "If you already have vina installed, please check the installation.\n"
+        msg += "If the problem persists, please create a github issue or contact developer at naisarg.patel14@hotmail.com"
+        print(msg)
+        sys.exit(2)
+    try:
+        print("Docking done using mutadock library developed by Naisarg Patel (Github:@naisarg14)")
+        v = Vina(sf_name='vina')
+
+        v.set_receptor(receptor)
+        v.set_ligand_from_file(ligand)
+        print(v)
+        v.compute_vina_maps(center=center, box_size=box_size)
+
+        v.dock(exhaustiveness=exhaustiveness, n_poses=n_poses)
+        v.write_poses(output, n_poses=n_poses_write, overwrite=overwrite)
+
+    except Exception as e:
+        return (False, e)
+    return (True, "")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run docking using AutoDock vina Python bindings.")
+
+    parser.add_argument("--receptor", type=str, help="Path to the receptor file.")
+    parser.add_argument("--ligand", type=str, help="Path to the ligand file.")
+    parser.add_argument("--output", type=str, help="Path for saving the output file.")
+    parser.add_argument("--log_file", type=str, help="Path for saving the log file.")
+
+    parser.add_argument("--center", nargs=3, type=float, default=[0, 0, 0], help="X-dimension of the center of search box (default: [0, 0, 0]).")
+
+    parser.add_argument("--box_size", nargs=3, type=float, default=[30, 30, 30], help="Size of the search box (default: [30, 30, 30]).")
+    parser.add_argument("--exhaustiveness", type=int, default=32, help="Exhaustiveness of the search (default: 32).")
+    parser.add_argument("--n_poses", type=int, default=20, help="Number of poses to generate (default: 20).")
+    parser.add_argument("--n_poses_write", type=int, default=5, help="Number of poses to write to the output (default: 5).")
+    parser.add_argument("--nooverwrite", action="store_false", default=True, help="Do not overwrite existing files.")
+
+    args = parser.parse_args()
+
+    vina_dock(
+        receptor=args.receptor,
+        ligand=args.ligand,
+        output=args.output,
+        center=args.center,
+        box_size=args.box_size,
+        exhaustiveness=args.exhaustiveness,
+        n_poses=args.n_poses,
+        n_poses_write=args.n_poses_write,
+        overwrite=args.nooverwrite,
+        )
+
+
+if __name__ == "__main__":
+    main()

docking/vina_helper.py

@@ -0,0 +1,340 @@
+################################################################################
+#                           PROJECT INFORMATION                                #
+#                              Name: MUTADOCK                                  #
+#                           Author: Naisarg Patel                              #
+#                                                                              #
+#       Copyright (C) 2024 Naisarg Patel (https://github.com/naisarg14)        #
+#                                                                              #
+#          Project: https://github.com/naisarg14/mutadock                      #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify it    #
+#  under the terms of the GNU General Public License version 3 as published    #
+#  by the Free Software Foundation.                                            #
+#                                                                              #
+#  This program is distributed in the hope that it will be useful, but         #
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  #
+#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    #
+#  for more details.                                                           #
+################################################################################
+
+
+def backup(file_path):
+    import os
+    from datetime import datetime
+
+    if not os.path.exists(file_path):
+        return False
+    master_folder, file = os.path.split(os.path.abspath(file_path))
+    target_directory = os.path.join(master_folder, 'backups')
+    if not os.path.exists(target_directory):
+        os.makedirs(target_directory)
+    modified_time = os.path.getmtime(file_path)
+    timestamp = datetime.fromtimestamp(modified_time).strftime("%b-%d-%Y_%H.%M")
+    name, ext = os.path.splitext(file)
+    target_file = os.path.join(target_directory, f'{name}_{timestamp}{ext}')
+    os.rename(file_path, target_file)
+    return True
+
+def read_pdb_file(file_path):
+    import re
+    try:
+        atoms = []
+        pattern = r'^ATOM\s+(\d+)\s+([A-Z]+)\s+([A-Z]{2,3})\s+([A-Z]?)\s*(\d+)\s+(-?\d+\.\d{3})\s+(-?\d+\.\d{3})\s+(-?\d+\.\d{3})\s+(\d+\.\d{1,2})\s+(\d+\.\d{1,3})(?:\s+(\d+\.\d{1,3}))?\s+[A-Z]$'
+        with open(file_path, 'r') as file:
+            for line in file:
+                if line.startswith(('ATOM', 'HETATM')):
+                    match = re.match(pattern, line)
+                if match:
+                    parts = {
+                        "atom_serial_number": int(match.group(1)),  # Atom Serial Number
+                        "atom_name": match.group(2).strip(),        # Atom Name
+                        "residue_name": match.group(3).strip(),     # Residue Name
+                        "chain_id": match.group(4).strip() or None, # Chain Identifier (optional)
+                        "residue_sequence_number": int(match.group(5)),  # Residue Sequence Number
+                        "x": float(match.group(6)),                 # X Coordinate
+                        "y": float(match.group(7)),                 # Y Coordinate
+                        "z": float(match.group(8)),                 # Z Coordinate
+                        "occupancy": float(match.group(9)),         # Occupancy
+                        "temp_factor": float(match.group(10)),      # Temperature Factor
+                        "extra_factor": float(match.group(11)) if match.group(11) else None,  # Extra Factor (optional)
+                    }
+                    atoms.append(parts)
+        return (atoms)
+    except Exception as e:
+        return (False, e)
+
+def calculate_geometric_center(pdb_file):
+    atoms = read_pdb_file(pdb_file)
+    num_atoms = len(atoms)
+    x_sum = sum(atom['x'] for atom in atoms)
+    y_sum = sum(atom['y'] for atom in atoms)
+    z_sum = sum(atom['z'] for atom in atoms)
+    
+    return (x_sum / num_atoms, y_sum / num_atoms, z_sum / num_atoms)
+
+def calculate_radius(pdb_file):
+    import math
+    atoms = read_pdb_file(pdb_file)
+    if isinstance(atoms, tuple):
+        return atoms
+
+    center = calculate_geometric_center(pdb_file)
+    max_distance = 0
+
+    for atom in atoms:
+        distance = math.sqrt(
+            (atom['x'] - center[0]) ** 2 +
+            (atom['y'] - center[1]) ** 2 +
+            (atom['z'] - center[2]) ** 2
+        )
+        if distance > max_distance:
+            max_distance = distance
+
+    return max_distance
+
+def vina_split(input_file, output_file=None):
+    try:
+        import sys
+        from meeko import PDBQTMolecule, RDKitMolCreate
+    except ModuleNotFoundError:
+        msg = "Error with importing modules for preparing ligand files for Docking.\n"
+        msg += "Easaies way to fix this is to install meeko using the following command:\n\n"
+        msg += "python -m pip install meeko\n"
+        msg += "If you already have meeko installed, please check the installation.\n"
+        msg += "If the problem persists, please create a github issue or contact developer at naisarg.patel14@hotmail.com"
+        print(msg)
+        sys.exit(2)
+
+    if output_file is None:
+        output_file = input_file.replace('.pdbqt', '_ligand_1.sdf')
+
+    pdbqt_string = ""
+    with open(input_file, 'r') as infile:
+        for line in infile:
+            if "vina result" in line.lower():
+                score = [float(x) for x in line.split() if x.replace('.', '', 1).replace('-', '', 1).isdigit()][0]
+            pdbqt_string += line
+            if line.startswith('ENDMDL'):
+                break
+    molecule = PDBQTMolecule(pdbqt_string)
+    sdf_string, failures = RDKitMolCreate.write_sd_string(molecule)
+
+    if len(failures) > 0:
+        msg = "\nCould not convert to RDKit. Maybe this library was not used for preparing\n"
+        msg += "the input PDBQT for docking, and the SMILES string is missing?\n"
+        msg += "Except for standard protein sidechains, all ligands and flexible residues\n"
+        msg += "require a REMARK SMILES line in the PDBQT, which is added automatically by meeko."
+        raise RuntimeError(msg)
+
+    footer_string = f"> <Docking Score>\n{score}\n> <Credits>\nCreated using a script in mutadock library written by Naisarg Patel (https://github.com/naisarg14/mutadock).\n$$$$\n"
+    with open(output_file, 'w') as outfile:
+        outfile.write(sdf_string.replace('$$$$', footer_string))
+    
+    return (score, output_file)
+
+def prepare_ligand(in_file, out_file=None):
+    try:
+        import sys
+        from meeko import MoleculePreparation, PDBQTWriterLegacy
+        from rdkit import Chem
+    except ModuleNotFoundError:
+        msg = "Error with importing modules for preparing ligand files for Docking.\n"
+        msg += "Easaies way to fix this is to install meeko and rdkit using the following command:\n\n"
+        msg += "python -m pip install meeko rdkit\n"
+        msg += "If you already have meeko and rdkit installed, please check the installation.\n"
+        msg += "If the problem persists, please create a github issue or contact developer at naisarg.patel14@hotmail.com"
+        print(msg)
+        sys.exit(2)
+
+    try:
+        #Add support for PDB files
+        if out_file is None:
+            if in_file.endswith(".sdf"):
+                out_file = f"{in_file.removesuffix(".sdf")}.pdbqt"
+            elif in_file.endswith(".mol2"):
+                out_file = f"{in_file.removesuffix(".mol2")}.pdbqt"
+            else:
+                return (False, "Input file is not in SDF or MOL2 format.")
+        
+        if in_file.endswith(".sdf"):
+            mol = Chem.SDMolSupplier(in_file)[0]
+        if in_file.endswith(".mol2"):
+            mol = Chem.MolFromMol2File(in_file)
+        
+        mol = Chem.AddHs(mol)
+        mp = MoleculePreparation()
+        molecule_setups = mp.prepare(mol)
+        pdbqt_string, success, error_msg = PDBQTWriterLegacy.write_string(molecule_setups[0])
+
+        if not success:
+            raise RuntimeError(f"Could not convert to PDBQT: {error_msg}")
+        with open(out_file, "w") as output_file:
+            output_file.write(pdbqt_string)
+    except Exception as e:
+        return (False, e)
+
+    return (True, pdbqt_string)
+
+def prepare_receptor(receptor_filename, outputfilename="None"):
+    try:
+        import sys, os
+        from MolKit import Read
+        from AutoDockTools.MoleculePreparation import AD4ReceptorPreparation
+    except ModuleNotFoundError:
+        msg = "Error with importing modules for preparing receptor files for Docking.\n"
+        msg += "Easaies way to fix this is to install AutoDockTools_py3 using the following command:\n\n"
+        msg += "python -m pip install git+https://github.com/Valdes-Tresanco-MS/AutoDockTools_py3\n"
+        msg += "If you already have AutoDockTools_py3 installed, please check the installation.\n"
+        msg += "If the problem persists, please create a github issue or contact developer at naisarg.patel14@hotmail.com"
+        print(msg)
+        sys.exit(2)
+    finally:
+        original_stdout = os.dup(1)
+        original_stderr = os.dup(2)
+    with open(os.devnull, 'w') as fnull:
+        os.dup2(fnull.fileno(), 1)
+        os.dup2(fnull.fileno(), 2)
+
+        if outputfilename is None:
+            outputfilename = f"{receptor_filename}qt"
+        
+        # initialize required parameters
+        repairs = 'hydrogens'
+        charges_to_add = 'gasteiger'
+        cleanup  = "waters"
+
+        mode = 'automatic'
+        delete_single_nonstd_residues = None
+        dictionary = None
+        unique_atom_names = False
+
+        try:
+            mols = Read(receptor_filename)
+            mol = mols[0]
+            if unique_atom_names:
+                for at in mol.allAtoms:
+                    if mol.allAtoms.get(at.name) >1:
+                        at.name = at.name + str(at._uniqIndex +1)
+
+            if len(mols)>1:
+                #use the molecule with the most atoms
+                ctr = 1
+                for m in mols[1:]:
+                    ctr += 1
+                    if len(m.allAtoms)>len(mol.allAtoms):
+                        mol = m
+
+            mol.buildBondsByDistance()
+            alt_loc_ats = mol.allAtoms.get(lambda x: "@" in x.name)
+            len_alt_loc_ats = len(alt_loc_ats)
+            if len_alt_loc_ats:
+                print("WARNING!", mol.name, "has",len_alt_loc_ats, ' alternate location atoms!\nUse prepare_pdb_split_alt_confs.py to create pdb files containing a single conformation.\n')
+
+            RPO = AD4ReceptorPreparation(mol, mode, repairs, charges_to_add, 
+                                cleanup, outputfilename=outputfilename,
+                                delete_single_nonstd_residues=delete_single_nonstd_residues,
+                                dict=dictionary)
+        except Exception as e:
+            os.dup2(original_stdout, 1)
+            os.dup2(original_stderr, 2)
+            os.close(original_stdout)
+            os.close(original_stderr)
+            return (False, e)
+        finally:
+            os.dup2(original_stdout, 1)
+            os.dup2(original_stderr, 2)
+            os.close(original_stdout)
+            os.close(original_stderr)
+     
+    return (True, "")
+
+def add_score_to_csv(out_pdb, csv_file, score):
+    import csv, os
+    try:
+        with open(csv_file, "r") as lc:
+            final_line = lc.readlines()[-1]
+            count = int(final_line.split(",")[0]) + 1
+    except FileNotFoundError:
+        count = 1
+    except ValueError:
+        count = 1
+    except Exception as e:
+        return (False, e)
+    
+    try:
+        name = f"{os.path.basename(out_pdb).removesuffix('_out.pdb')}"
+        with open(csv_file, "a+") as out:
+            writer = csv.DictWriter(out, fieldnames=["sr", "name", "affinity"])
+            writer.writerow({"sr": count, "name": name, "affinity": score})
+    
+    except Exception as e:
+        return (False, e)
+        
+    return (True, name)
+    
+def read_config(config_file):
+    try:
+        config = {}
+        with open(config_file, 'r') as file:
+            for line in file:
+                line = line.strip()
+                if line and not line.startswith('#') and "=" in line:
+                    key, value = line.split('=')
+                    config[key.strip()] = value.strip()
+
+        center_x = config.get('center_x', '0.0')
+        center_y = config.get('center_y', '0.0')
+        center_z = config.get('center_z', '0.0')
+        size_x = config.get('size_x', '30.0')
+        size_y = config.get('size_y', '30.0')
+        size_z = config.get('size_z', '30.0')
+        exhaustiveness = config.get('exhaustiveness', '32')
+        n_poses = config.get('n_poses', '20')
+        n_poses_write = config.get('n_poses_write', '5')
+        overwrite = config.get('overwrite', 'True')
+
+        center = (center_x, center_y, center_z)
+        box_size = (size_x, size_y, size_z)
+
+        return (True, center, box_size, exhaustiveness, n_poses, n_poses_write, overwrite)
+            
+    except Exception as e:
+        return (False, e)
+
+def dock_vina(receptor, ligand, output, log_file, config=None, autosite=None, center=[0, 0, 0], box_size=[30, 30, 30], exhaustiveness=32, n_poses=20, n_poses_write=5, overwrite=True):
+    if config is not None:
+        values = read_config(config)
+        if values[0] is False:
+            return values
+        _, center, box_size, exhaustiveness, n_poses, n_poses_write, overwrite = values
+
+    if autosite is not None:
+        center = calculate_geometric_center(autosite)
+    
+    import subprocess, os
+
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    vina_dock_script = os.path.join(current_dir, 'vina_dock.py')
+
+    commands = [
+        "python3", vina_dock_script, 
+        "--receptor", receptor, 
+        "--ligand", ligand, 
+        "--output", output, 
+        "--center", str(center[0]), str(center[1]), str(center[2]), 
+        "--box_size", str(box_size[0]), str(box_size[1]), str(box_size[2]),
+        "--exhaustiveness", str(exhaustiveness),
+        "--n_poses", str(n_poses),
+        "--n_poses_write", str(n_poses_write),
+        ]
+    if not overwrite: commands.append("--nooverwrite")
+    with open(log_file, 'w+') as lfile:
+        result = subprocess.run(commands, stdout=lfile, stderr=lfile, text=True) 
+
+    if result.returncode != 0:
+        return (False, f"Check the error in {log_file}")
+
+    return (True, "")
+
+if __name__ == "__main__":
+    print("This is a dependency file for mutadock (https://github.com/naisarg14/mutadock) library's docking module.")