pautodock 1.0.0__tar.gz

pautodock-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: pautodock
+Version: 1.0.0
+Summary: A simple tool to parallelize AutoDock JOBs
+Home-page: https://github.com/gmrandazzo/PAutoDock
+License: lglpv3
+Author: Giuseppe Marco Randazzo
+Author-email: gmrandazzo@gmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Project-URL: Repository, https://github.com/gmrandazzo/PAutoDock
+Description-Content-Type: text/markdown
+
+# PAutodock - Parallelize AutoDock JOBs
+
+PAutodock is a powerful set of scripts designed to parallelize AutoDock jobs, enabling fast screening across multiple CPUs. This tool is particularly useful for researchers and scientists working in computational biology and drug discovery, allowing them to efficiently manage and execute docking simulations.
+
+## Table of Contents
+
+- [License](#license)
+- [Dependencies](#dependencies)
+- [Changelog](#changelog)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [Contact](#contact)
+
+## License
+
+PAutodock is distributed under the GPLv3 license. For detailed information on how the license works, please refer to the file "LICENSE" or visit [GNU GPLv3 License](http://www.gnu.org/licenses/gpl-3.0.en.html).
+
+Copyright © Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+
+## Dependencies
+
+To run PAutodock, you will need the following software installed:
+
+- [AutoDock](http://autodock.scripps.edu/)
+- [AutoGrid](http://autodock.scripps.edu/resources/autogrid)
+- [AutoDock Vina](http://vina.scripps.edu/)
+- [OpenBabel](http://openbabel.org/index.html)
+
+Ensure that these dependencies are properly installed and accessible from your command line.
+
+## Changelog
+
+- **2024**: Revamp in a more organized form
+- **2022**: First time online
+- **2017**: Initial release
+
+## Usage
+
+To use PAutodock for parallelizing AutoDock jobs, follow these steps:
+
+1. **Prepare the Receptor and Ligand**:
+   - Ensure you have a receptor file (in PDB format) that represents the target protein or enzyme.
+   - Prepare a ligand file (also in PDB format) that contains the molecule you want to dock with the receptor.
+
+2. **Create a Multimol2 File**:
+   - Prepare a multimol2 file that includes all the ligands you wish to screen.
+   - Each ligand in the file must have:
+     - **Partial Charges**: Ensure that the ligands have Gasteiger partial charges assigned.
+     - **3D Coordinates**: The ligands should be represented in 3D space.
+     - **Unique Names**: Each molecule must have a unique name to avoid conflicts during the screening process.
+
+3. **Execute the Command**:
+   - Once your receptor and multimol2 file are ready, execute the following command in your terminal:
+
+   ```bash
+   cd data/3EML
+   pautodock --receptor rec.pdb --cx -9.06364 --cy -7.1446 --cz 55.8626 --db dataset.mol2 --wdir example_calculation --out screening_results.csv --vina ON --atd OFF
+

pautodock-1.0.0/Readme.md

@@ -0,0 +1,57 @@
+# PAutodock - Parallelize AutoDock JOBs
+
+PAutodock is a powerful set of scripts designed to parallelize AutoDock jobs, enabling fast screening across multiple CPUs. This tool is particularly useful for researchers and scientists working in computational biology and drug discovery, allowing them to efficiently manage and execute docking simulations.
+
+## Table of Contents
+
+- [License](#license)
+- [Dependencies](#dependencies)
+- [Changelog](#changelog)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [Contact](#contact)
+
+## License
+
+PAutodock is distributed under the GPLv3 license. For detailed information on how the license works, please refer to the file "LICENSE" or visit [GNU GPLv3 License](http://www.gnu.org/licenses/gpl-3.0.en.html).
+
+Copyright © Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+
+## Dependencies
+
+To run PAutodock, you will need the following software installed:
+
+- [AutoDock](http://autodock.scripps.edu/)
+- [AutoGrid](http://autodock.scripps.edu/resources/autogrid)
+- [AutoDock Vina](http://vina.scripps.edu/)
+- [OpenBabel](http://openbabel.org/index.html)
+
+Ensure that these dependencies are properly installed and accessible from your command line.
+
+## Changelog
+
+- **2024**: Revamp in a more organized form
+- **2022**: First time online
+- **2017**: Initial release
+
+## Usage
+
+To use PAutodock for parallelizing AutoDock jobs, follow these steps:
+
+1. **Prepare the Receptor and Ligand**:
+   - Ensure you have a receptor file (in PDB format) that represents the target protein or enzyme.
+   - Prepare a ligand file (also in PDB format) that contains the molecule you want to dock with the receptor.
+
+2. **Create a Multimol2 File**:
+   - Prepare a multimol2 file that includes all the ligands you wish to screen.
+   - Each ligand in the file must have:
+     - **Partial Charges**: Ensure that the ligands have Gasteiger partial charges assigned.
+     - **3D Coordinates**: The ligands should be represented in 3D space.
+     - **Unique Names**: Each molecule must have a unique name to avoid conflicts during the screening process.
+
+3. **Execute the Command**:
+   - Once your receptor and multimol2 file are ready, execute the following command in your terminal:
+
+   ```bash
+   cd data/3EML
+   pautodock --receptor rec.pdb --cx -9.06364 --cy -7.1446 --cz 55.8626 --db dataset.mol2 --wdir example_calculation --out screening_results.csv --vina ON --atd OFF

pautodock-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[tool.black]
+line-length = 88
+target-version = ["py311"]
+
+[tool.isort]
+profile = "black"
+
+[tool.poetry]
+name = "pautodock"
+version = "1.0.0"
+description = "A simple tool to parallelize AutoDock JOBs"
+authors = ["Giuseppe Marco Randazzo <gmrandazzo@gmail.com>"]
+readme = "Readme.md"
+license = "lglpv3"
+repository = "https://github.com/gmrandazzo/PAutoDock"
+packages = [{include = "pautodock", from = "src"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS :: MacOS X",
+    "Topic :: Scientific/Engineering :: Bio-Informatics"
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+requests = "^2.32.3"
+
+[tool.poetry.dev-dependencies]
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+pre-commit = "^3.3.3"
+tox = "^4.2.3"
+
+[tool.poetry.scripts]
+pautodock = "pautodock.__main__:main"
+pautodock-recover-output = "pautodock.__recover_output__:main"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

pautodock-1.0.0/src/pautodock/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

pautodock-1.0.0/src/pautodock/__main__.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""main.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+
+Provides the basic main function to run autodock screening
+in parallel.
+"""
+
+import argparse
+import sys
+
+from pautodock.adparallel import ADParallel
+
+
+def main():
+    """
+    main.py: with that you run the program.
+    """
+    p = argparse.ArgumentParser()
+    p.add_argument("--receptor", default=None, type=str, help="receptor")
+    p.add_argument("--ligand", default=None, type=str, help="ligand PDB")
+    p.add_argument("--cx", default=None, type=float, help="center x")
+    p.add_argument("--cy", default=None, type=float, help="center y")
+    p.add_argument("--cz", default=None, type=float, help="center z")
+    p.add_argument("--gx", default=30, type=int, help="grid x size")
+    p.add_argument("--gy", default=30, type=int, help="grid y size")
+    p.add_argument("--gz", default=30, type=int, help="grid z size")
+    p.add_argument("--db", default=None, type=str, help="multimol2 database")
+    p.add_argument("--wdir", default=None, type=str, help="work directory")
+    p.add_argument("--smode", default="fast", type=str, help="screening mode")
+    p.add_argument("--out", default=None, type=str, help="screening output")
+    p.add_argument("--atd", default="OFF", type=str, help="Autodock ON")
+    p.add_argument("--vina", default="ON", type=str, help="Vina ON")
+    args = p.parse_args(sys.argv[1:])
+
+    if args.receptor is None or args.ligand is None and args.cx is None:
+        print("\nUsage: %s  --receptor [input pdb]" % sys.argv[0])
+        print("                --ligand [input pdb/mol2]")
+        print("                --cx [center x]")
+        print("                --cy [center y]")
+        print("                --cz [center z]")
+        print("                --db [multi mol2]")
+        print("                --wdir [work path]")
+        print("                --smode=[slow,medium,fast]")
+        print("                --gx=[grid x size]")
+        print("                --gy=[grid y size]")
+        print("                --gz=[grid z size]")
+        print("                --out [screening output]")
+        print("                --atd [ON;OFF]")
+        print("                --vina [ON;OFF]")
+    else:
+        # Load import pdb; pdb.set_trace()#
+        dock = ADParallel(args.receptor, args.ligand, args.db, args.wdir)
+        if args.ligand is None:
+            dock.cx = args.cx
+            dock.cy = args.cy
+            dock.cz = args.cz
+
+        if args.atd == "OFF":
+            dock.atd = False
+
+        if args.vina == "ON":
+            dock.vina = True
+
+        dock.speed = args.smode
+        dock.gsize_x = args.gx
+        dock.gsize_y = args.gy
+        dock.gsize_z = args.gz
+        dock.virtual_screening(args.out)
+    return 0
+
+
+if __name__ == "__main__":
+    main()

pautodock-1.0.0/src/pautodock/__recover_output__.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""recover_output.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+Provides a commandline script to recover the output result of a virtualscreening.
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from pautodock.adparallel import ADParallel
+
+
+def main():
+    """
+    main.py
+    """
+    p = argparse.ArgumentParser()
+    p.add_argument("--wdir", default=None, type=str, help="work directory")
+    p.add_argument("--out", default=None, type=str, help="screening output")
+    p.add_argument("--ligand", default=None, type=str, help="ligand")
+    args = p.parse_args(sys.argv[1:])
+
+    if args.wdir is None or args.out is None:
+        print("\nUsage: %s --receptor [input pdb]" % sys.argv[0])
+        print("                --wdir [work path]")
+        print("                --ligand [ligand PDB]")
+        print("                --out [screening output]")
+    else:
+        dock = ADParallel("", None, None, args.ligand, None, args.wdir)
+        vinalogout = []
+        dpfout = []
+        mnames = []
+        for root, directories, filenames in os.walk(str(Path(args.wdir).absolute())):
+            for filename in filenames:
+                if "vina_log.txt" in filename:
+                    vinalogout.append(os.path.join(root, filename))
+                    mname = str(Path(vinalogout[-1]).parents[0].name)
+                    if mname not in mnames:
+                        mnames.append(mname)
+                elif "ind.dlg" in filename:
+                    dpfout.append(os.path.join(root, filename))
+                    mname = str(Path(dpfout[-1]).parents[0].name)
+                    if mname not in mnames:
+                        mnames.append(mname)
+                else:
+                    continue
+        dock.gen_vs_output(vinalogout, dpfout, mnames, args.out)
+
+
+if __name__ == "__main__":
+    main()

pautodock-1.0.0/src/pautodock/adparallel.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""adparallel.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+
+Provides the basic code to run autodock in parallel on a machine.
+
+"""
+
+import logging
+import math
+import multiprocessing
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+from pautodock import molop, multimol2op
+from pautodock.fileutils import get_bin_path
+from pautodock.mgltoolsinstall import install_mgltools
+
+
+class ADParallel(object):
+    def __init__(self, receptor, ligand, db, wpath):
+        try:
+            self.atdpath = get_bin_path("autodock")
+        except ValueError:
+            self.atdpath = None
+        try:
+            self.vinapath = get_bin_path("vina")
+        except ValueError:
+            self.vinapath = None
+
+        if not self.atdpath and not self.vinapath:
+            msg = "Error!! autodock and vina are not installed!\n"
+            msg += "Unable to run any calculation."
+            raise ValueError(msg)
+
+        self.mglpath = Path(f"{Path.home()}/.pautodock/MGLTools")
+        if not self.mglpath.exists():
+            install_mgltools(f"{Path.home()}/.pautodock")
+        self.receptor = receptor
+        self.ligand = ligand
+        self.db = db
+        self.wpath = wpath
+        self.results = []
+        self.cx = 0.0
+        self.cy = 0.0
+        self.cz = 0.0
+        self.gsize_x = 30
+        self.gsize_y = 30
+        self.gsize_z = 30
+        self.speed = "slow"
+        self.atd = True
+        self.vina = True
+
+    def read_atom_types(self, rec_mol):
+        """
+        Read atom types in pdb and return in a list
+        """
+        atlst = []
+        f = open(rec_mol, "r")
+        for line in f:
+            if "ATOM" in line:
+                at = line.strip().split(" ")[-1]
+                if at in atlst:
+                    continue
+                else:
+                    if len(at) > 0:
+                        atlst.append(at)
+                    else:
+                        continue
+        f.close()
+        atlst = list(set(atlst))
+        atypes_str = "%s" % atlst[0]
+        for i in range(1, len(atlst)):
+            atypes_str += " %s" % atlst[i]
+        return atypes_str, atlst
+
+    def write_autodock_param_files(self, path, rec_pdbqt, mol_pdbqt, cc):
+        path_ = Path(path).absolute()
+        rat_str, _ = self.read_atom_types(rec_pdbqt)
+        lat_str, lat_lst = self.read_atom_types(path + "/" + mol_pdbqt)
+        # write the GPF
+        f = open(path + "/grid.gpf", "w")
+        f.write(
+            "npts %d %d %d # num.grid points in xyz\n"
+            % (self.gsize_x, self.gsize_y, self.gsize_z)
+        )
+        f.write("gridfld %s/receptor_model.maps.fld     # grid_data_file\n" % (path_))
+        f.write("spacing 0.33 # spacing(A)\n")
+        f.write("receptor_types %s # receptor atom types\n" % (rat_str))
+        f.write("ligand_types %s # ligand atom types\n" % (lat_str))
+        f.write("receptor %s    # macromolecule\n" % (rec_pdbqt))
+        f.write(
+            "gridcenter %.3f %.3f %.3f       # xyz-coordinates or auto\n"
+            % (cc[0], cc[1], cc[2])
+        )
+        f.write("smooth 0.5  # store minimum energy w/in rad(A)\n")
+        for at in lat_lst:
+            f.write(
+                "map %s/receptor_model.%s.map # atom-specific aff. map\n" % (path_, at)
+            )
+        f.write("elecmap %s/receptor_model.e.map # El. Pot potential map\n" % (path_))
+        f.write("dsolvmap %s/receptor_model.d.map # desolv. potential map\n" % (path_))
+        f.write("dielectric -0.1465 # <0, AD4 dist-dep.diel;>0, constant\n")
+        f.close()
+
+        # Write autodock file
+        f = open(path + "/ind.dpf", "w")
+        f.write("autodock_parameter_version 4.2")
+        f.write("# used by autodock to validate parameter set\n")
+        f.write("outlev 1 # diagnostic output level\n")
+        f.write("intelec # calculate internal electrostatics\n")
+        f.write("seed time pid # seeds for random generator\n")
+        f.write("ligand_types %s # atoms types in ligand\n" % (lat_str))
+        f.write("fld %s/receptor_model.maps.fld      # grid_data_file\n" % (path_))
+        for at in lat_lst:
+            f.write(
+                "map %s/receptor_model.%s.map # atom-specific aff. map\n" % (path_, at)
+            )
+        f.write("elecmap %s/receptor_model.e.map    # electrostatics map\n" % (path_))
+        f.write("desolvmap %s/receptor_model.d.map   # desolvation map\n" % (path_))
+        f.write("move %s/%s                    # small molecule\n" % (path_, mol_pdbqt))
+        f.write(
+            "about %.4f %.4f %.4f       # small molecule center\n"
+            % (cc[0], cc[1], cc[2])
+        )
+        f.write("tran0 %.4f %.4f %.4f " % (cc[0], cc[1], cc[2]))
+        f.write("# initial coordinates/A or random\n")
+        f.write("quaternion0 random ")
+        f.write("# initial orientation\n")
+        f.write("dihe0 random ")
+        f.write("# initial dihedrals (relative) or random\n")
+        f.write("torsdof 5 ")
+        f.write("# torsional degrees of freedom\n")
+        f.write("rmstol 2.0  # cluster_tolerance/A\n")
+        f.write("extnrg 1000.0  # external grid energy\n")
+        f.write("e0max 0.0 10000 ")
+        f.write("# max initial energy; max number of retries\n")
+        f.write("ga_pop_size 150 ")
+        f.write("# number of individuals in population\n")
+        if self.speed == "slow":
+            f.write("ga_num_evals 25000000 ")
+        elif self.speed == "medium":
+            f.write("ga_num_evals 2500000 ")
+        else:
+            f.write("ga_num_evals 250000 ")
+        f.write("               # maximum number of energy evaluations\n")
+        f.write("ga_num_generations 27000 ")
+        f.write("# maximum number of generations\n")
+        f.write("ga_elitism 1 ")
+        f.write("# number of top individuals to survive to next generation\n")
+        f.write("ga_mutation_rate 0.02 # rate of gene mutation\n")
+        f.write("ga_crossover_rate 0.8 # rate of crossover\n")
+        f.write("ga_window_size 10 # \n")
+        f.write("ga_cauchy_alpha 0.0 ")
+        f.write("# Alpha parameter of Cauchy distribution\n")
+        f.write("ga_cauchy_beta 1.0 ")
+        f.write("# Beta parameter Cauchy distribution\n")
+        f.write("set_ga")
+        f.write(" # set the above parameters for GA or LGA\n")
+        f.write("sw_max_its 300")
+        f.write("# iterations of Solis & Wets local search\n")
+        f.write("sw_max_succ 4 ")
+        f.write(" # consecutive successes before changing rho\n")
+        f.write("sw_max_fail 4 ")
+        f.write(" # consecutive failures before changing rho\n")
+        f.write("sw_rho 1.0 ")
+        f.write("# size of local search space to sample\n")
+        f.write("sw_lb_rho 0.01                       # lower bound on rho\n")
+        f.write("ls_search_freq 0.06 ")
+        f.write("# probability of performing local search on individual\n")
+        f.write("set_psw1 ")
+        f.write("# set the above pseudo-Solis & Wets parameters\n")
+        f.write("unbound_model bound ")
+        f.write("# state of unbound ligand\n")
+        f.write("ga_run 10 ")
+        f.write("# do this many hybrid GA-LS runs\n")
+        f.write("analysis ")
+        f.write("# perform a ranked cluster analysis\n")
+        f.close()
+        grid_path = Path(path + "/grid.gpf").absolute()
+        ind_path = Path(path + "/ind.dpf").absolute()
+        return grid_path, ind_path
+
+    def write_vina_param_files(self, path, cc, ss):
+        f = open(path + "/vina_conf.txt", "w")
+        f.write("center_x = %.4f\n" % (cc[0]))
+        f.write("center_y = %.4f\n" % (cc[1]))
+        f.write("center_z = %.4f\n" % (cc[2]))
+        f.write("size_x = %d\n" % (ss[0]))
+        f.write("size_y = %d\n" % (ss[1]))
+        f.write("size_z = %d\n" % (ss[2]))
+        f.write("num_modes = 9\n")
+        f.close()
+        return Path(path + "/vina_conf.txt").absolute()
+
+    def RunAutoGrid(self, cmd):
+        atg_path = str(Path("%s/autogrid4" % (self.atdpath)).absolute())
+        return os.system("%s %s" % (atg_path, cmd))
+
+    def RunAutoDock(self, cmd):
+        atd_path = str(Path("%s/autodock4" % (self.atdpath)).absolute())
+        return os.system("%s %s" % (atd_path, cmd))
+
+    def RunVina(self, cmd):
+        vina_path = str(Path("%s/vina" % (self.vinapath)).absolute())
+        return os.system("%s %s" % (vina_path, cmd))
+
+    def ReadOutput(self, ofile):
+        r = []
+        header = []
+        benergy = []
+        c_rmsd = []
+        r_rmsd = []
+        f = open(str(Path(ofile).absolute()), "r")
+        for line in f:
+            if "Partition function, Q =" in line:
+                header.append("Part. Func.")
+                r.append(molop.nsplit(line.strip(), " ")[4])
+            elif "Free energy,        A ~" in line:
+                r.append(molop.nsplit(line.strip(), " ")[4])
+                header.append("Free Energy")
+            elif "Internal energy,    U =" in line:
+                header.append("Internal Energy")
+                r.append(molop.nsplit(line.strip(), " ")[4])
+            elif "Entropy,            S =" in line:
+                header.append("Entropy")
+                r.append(molop.nsplit(line.strip(), " ")[3])
+            elif "RANKING" in line:
+                v = molop.nsplit(line.strip(), " ")
+                benergy.append(float(v[3]))
+                c_rmsd.append(float(v[4]))
+                r_rmsd.append(float(v[5]))
+        f.close()
+        header.append("Binding Energy Average")
+        r.append(round(sum(benergy) / float(len(benergy)), 3))
+        header.append("Cluster RMSD Average")
+        r.append(round(sum(c_rmsd) / float(len(c_rmsd)), 3))
+        header.append("Ref. RMSD Average")
+        r.append(round(sum(r_rmsd) / float(len(r_rmsd)), 3))
+        return header, r
+
+    def LigandPosesBaricentreDistance(self, dock_pdbqt: str) -> float:
+        """
+        Calculate the distance between the ligand and docking pose baricentres.
+        """
+        poses_cc = molop.get_mol_baricentre(dock_pdbqt)
+        if int(self.cx) == 0:
+            self.cx, self.cy, self.cz = molop.get_mol_baricentre(self.ligand)
+        return math.sqrt(
+            (self.cx - poses_cc[0]) ** 2
+            + (self.cy - poses_cc[1]) ** 2
+            + (self.cz - poses_cc[2]) ** 2
+        )
+
+    def read_vina_output(self, ofile):
+        benergy = []
+        f = open(str(Path(ofile).absolute()), "r")
+        getres = False
+        for line in f:
+            if getres:
+                # Filter double outputs
+                if "Writing output ... done." in line or "AutoDock Vina" in line:
+                    getres = False
+                else:
+                    try:
+                        v = molop.nsplit(line.strip(), " ")
+                        benergy.append(float(v[1]))
+                    except ValueError as err:
+                        logging.error("Error with file %s - %s" % (ofile, err))
+            else:
+                if "-----+------------+----------+----------" in line:
+                    getres = True
+                else:
+                    continue
+
+        f.close()
+        if len(benergy) > 0:
+            return (
+                round(sum(benergy) / float(len(benergy)), 3),
+                min(benergy),
+                max(benergy),
+            )
+        else:
+            return 9999.0, 9999.0, 9999.0
+
+    def gen_vs_output(self, vinalogout, dpfout, mnames, otab):
+        """
+        Collect vina results
+        """
+        # Collect the vina results
+        vbind = []
+        for i, vout in enumerate(vinalogout):
+            avg_b, min_b, max_b = self.read_vina_output(vout)
+            try:
+                dock_poses = (
+                    f"{Path(vout).parent.absolute()}/dock_confs_{mnames[i]}.pdbqt"
+                )
+                lp_dst = self.LigandPosesBaricentreDistance(dock_poses)
+            except FileNotFoundError as err:
+                logging.error("%s not found", err)
+                lp_dst = 9999.0
+            vbind.append([avg_b, min_b, max_b, lp_dst])
+        # Collect results
+        fo = open(otab, "w")
+        firstline = True
+        for i in range(len(mnames)):
+            h = []
+            r = []
+            if len(dpfout) > 0:
+                if Path(dpfout[i]).is_file():
+                    h, r = self.ReadOutput(dpfout[i])
+            if firstline:
+                firstline = False
+                fo.write("Molname;")
+                for j in range(len(h)):
+                    fo.write("%s;" % (h[j]))
+                fo.write("Avg. vina Binding Energy;")
+                fo.write("Min vina Binding Energy;Max vina Binding Energy;")
+                fo.write("Template-Ligand Baricenter Distance (docking pose check)\n")
+            fo.write("%s;" % (mnames[i]))
+            for j in range(len(r)):
+                fo.write("%s;" % (r[j]))
+            fo.write(
+                "%f;%f;%f;%f\n" % (vbind[i][0], vbind[i][1], vbind[i][2], vbind[i][3])
+            )
+        fo.close()
+
+    def make_vina_cmd(
+        self, vconf_path, rec_pdbqt, mol_pdbqt, mpath, molname, vinalogout
+    ) -> str:
+        vc = f'--config "{vconf_path}"'
+        vc += f' --receptor "{rec_pdbqt}"'
+        vc += f' --ligand "{mol_pdbqt}"'
+        vc += f' --out "{mpath}/dock_confs_{molname}.pdbqt" >> {vinalogout}'
+        return vc
+
+    def virtual_screening(self, otab):
+        # Prepare the receptor
+        rec = molop.Receptor(self.receptor, self.mglpath)
+        rec_pdbqt = rec.topdbqt()
+        if self.ligand is not None:
+            self.cx, self.cy, self.cz = molop.get_mol_baricentre(self.ligand)
+        # Prepare the database split multi mol2
+        tmppath = tempfile.mkdtemp()
+        mol2lst = multimol2op.split_mol2(self.db, tmppath)
+        agcmdlst = []
+        adcmdlst = []
+        vinacmdlst = []
+        vinalogout = []
+        dpfout = []
+        mnames = []
+        # Create a directory with the name of the mol2 molecule
+        # and copy the receptor and itself
+        for mol2 in mol2lst:
+            molname_ext = str(Path(mol2).resolve().name)
+            molname = molname_ext.replace(".mol2", "")
+            mnames.append(molname)
+            mpath = str(Path(self.wpath + "/" + molname).absolute())
+            if not Path(f"{mpath}/dock_confs_{molname}.pdbqt").exists():
+                if not Path(mpath).exists():
+                    os.makedirs(mpath)
+                if not Path(mpath + "/" + molname_ext).exists():
+                    shutil.move(str(Path(mol2).resolve()), mpath)
+
+                mol = molop.Molecule(
+                    str(Path(mpath + "/" + molname_ext).absolute()), self.mglpath
+                )
+                mol_pdbqt = mol.topdbqt([self.cx, self.cy, self.cz])
+                mol_pdbqt_name = str(Path(mol_pdbqt).resolve().name)
+                if self.atd:
+                    gpf_path, dpf_path = self.write_autodock_param_files(
+                        mpath, rec_pdbqt, mol_pdbqt_name, [self.cx, self.cy, self.cz]
+                    )
+                    first_arg = str(gpf_path)
+                    second_arg = str(gpf_path).replace(".gpf", "")
+                    ag = f'-p "{first_arg}" -l "{second_arg}.glg"'
+                    agcmdlst.append(ag)
+                    dpfout.append(str(dpf_path).replace(".dpf", ".dlg"))
+                    ad = f'-p "{str(dpf_path)}" -l "{dpfout[-1]}"'
+                    adcmdlst.append(ad)
+
+                if self.vina:
+                    vinalogout.append(f"{mpath}/vina_log.txt")
+                    # If the log and the docking pose extists then
+                    # there is no need to run the calculation
+                    vconf_path = self.write_vina_param_files(
+                        mpath,
+                        [self.cx, self.cy, self.cz],
+                        [self.gsize_x, self.gsize_y, self.gsize_z],
+                    )
+                    vinacmdlst.append(
+                        self.make_vina_cmd(
+                            vconf_path,
+                            rec_pdbqt,
+                            mol_pdbqt,
+                            mpath,
+                            molname,
+                            vinalogout[-1],
+                        )
+                    )
+            else:
+                vinalogout.append(f"{mpath}/vina_log.txt")
+        shutil.rmtree(tmppath)
+        ncpu = multiprocessing.cpu_count()
+        if self.atd:
+            # Run AutoGrid
+            pool = multiprocessing.Pool(ncpu)
+            pool.map(self.RunAutoGrid, agcmdlst)
+            # RunAutodock
+            pool = multiprocessing.Pool(ncpu)
+            pool.map(self.RunAutoDock, adcmdlst)
+
+        if self.vina:
+            # RunVina
+            pool = multiprocessing.Pool(ncpu)
+            pool.map(self.RunVina, vinacmdlst)
+
+        # Write the output table
+        self.gen_vs_output(vinalogout, dpfout, mnames, otab)

pautodock-1.0.0/src/pautodock/fileutils.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""fileutils.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+Provides the basic operation for molecular files.
+
+"""
+import logging
+import platform
+import tarfile
+from pathlib import Path
+
+import requests
+
+
+def get_bin_path(bin_name: str):
+    """
+    Get the path to the bin_name executable based on the operating system.
+    """
+    paths = {"Linux": ["/usr/bin/", "/usr/local/bin"], "Darwin": ["/opt/homebrew/bin/"]}
+    system = platform.system()
+    if system not in paths:
+        raise ValueError("Platform not supported")
+
+    for bin_path in paths.get(system):
+        if bin_path and Path(f"{bin_path}/{bin_name}").exists():
+            return bin_path
+    raise ValueError(f"Unable to find {bin_name} installed.")
+
+
+def download_file(url, destination):
+    """
+    Download a file from a URL to a local destination.
+    """
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        with open(destination, "wb") as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+        logging.info(f"Downloaded: {destination}")
+    except requests.RequestException as err:
+        logging.error(f"Failed to download file: {err}")
+        return False
+    return True
+
+
+def extract_tar_gz(file_path, extract_to):
+    """
+    Extract a .tar.gz file to a specified directory.
+    """
+    try:
+        with tarfile.open(file_path, "r:gz") as tar:
+            tar.extractall(path=extract_to)
+        logging.info(f"Extracted: {file_path} to {extract_to}")
+    except (tarfile.TarError, IOError) as err:
+        logging.error(f"Failed to extract file: {err}")
+        return False
+    return True

pautodock-1.0.0/src/pautodock/mgltoolsinstall.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""mgltoolsinstall.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+Provides the basic operation for molecular files.
+
+"""
+
+import logging
+import platform
+import subprocess
+from pathlib import Path
+
+from pautodock.fileutils import download_file, extract_tar_gz
+
+
+def install_mgltools(dir: str):
+    """
+    Install MGLTools from the official website.
+    """
+    directory = Path(dir)
+    directory.mkdir(exist_ok=True)
+    destination = directory / "mgltools_1.5.7.tar.gz"
+    dir_name = None
+
+    system = platform.system()
+    if system == "Linux":
+        url = "https://ccsb.scripps.edu/download/532/"
+        dir_name = "mgltools_x86_64Linux2_1.5.7"
+    elif system == "Darwin":
+        url = "https://ccsb.scripps.edu/download/529/"
+        dir_name = "mgltools_1.5.7_MacOS-X"
+    else:
+        logging.error("Unsupported platform")
+        return False
+
+    if not destination.exists():
+        if not download_file(url, destination):
+            return False
+
+    if extract_tar_gz(destination, directory):
+        install_dir = directory / "MGLTools"
+        install_script = directory / dir_name / "install.sh"
+        cmd_args = ["sh", str(install_script), "-d", str(install_dir)]
+
+        try:
+            subprocess.check_output(
+                cmd_args,
+                cwd=directory / dir_name,
+                shell=False,
+                text=True,
+                stderr=subprocess.DEVNULL,
+            )
+            logging.info("MGLTools installed successfully.")
+            return True
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Installation failed: {err}")
+            return False
+    else:
+        return False

pautodock-1.0.0/src/pautodock/molop.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""molop.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+Provides the basic operation for molecular files.
+
+"""
+
+import logging
+import subprocess
+from pathlib import Path
+
+from pautodock.fileutils import get_bin_path
+
+
+def nsplit(s, delim=None):
+    return [x for x in s.split(delim) if x]
+
+
+def extract_coordinates(line, ftype):
+    if ftype == "pdb":
+        if "HETATM" in line:
+            x = float(line[29:39].strip())
+            y = float(line[39:47].strip())
+            z = float(line[47:55].strip())
+            return [float(x), float(y), float(z)]
+    elif ftype == "pdbqt":
+        if "ATOM" in line:
+            x = float(line[31:39].strip())
+            y = float(line[38:46].strip())
+            z = float(line[46:54].strip())
+            return [float(x), float(y), float(z)]
+    else:
+        return None
+
+
+def get_mol_baricentre(mol: str) -> tuple:
+    """
+    Get molecular baricentre from a molecule
+    """
+    cc = [0.0, 0.0, 0.0]
+    n = 0
+    if mol.endswith(".pdbqt"):
+        ftype = "pdbqt"
+    elif mol.endswith(".pdb"):
+        ftype = "pdb"
+    else:
+        raise ValueError(
+            "Molecual format not supported {mol}. Supported formats: pdb or pdbqt"
+        )
+
+    with open(mol, "r", encoding="utf-8") as f:
+        for line in f:
+            if ("ATOM" in line or "HETATM" in line) and "REMARK" not in line:
+                try:
+                    ex_cc = extract_coordinates(line.strip(), ftype)
+                    if ex_cc:
+                        for i, val in enumerate(ex_cc):
+                            cc[i] += val
+                    n += 1
+                except IndexError as err:
+                    logging.error("%s get_mol_baricentre problem with %s", err, line)
+    return [cc[i] / float(n) for i in range(len(cc))]
+
+
+class Receptor(object):
+    def __init__(self, receptor, mglpath):
+        self.receptor = receptor
+        self.mglpath = str(Path(mglpath).resolve())
+
+    def topdbqt(self):
+        python_env = (
+            "export LD_LIBRARY_PATH=\"%s/lib\"${LD_LIBRARY_PATH:+':'$LD_LIBRARY_PATH};"
+            % (self.mglpath)
+        )
+        python_env += "%s/bin/python2" % (self.mglpath)
+        prep_rec = self.mglpath
+        prep_rec += "/MGLToolsPckgs/AutoDockTools/Utilities24/"
+        prep_rec += "prepare_receptor4.py"
+        pdbqt = self.receptor.replace(".pdb", ".pdbqt")
+        cmd = "%s %s -r '%s' -o '%s'" % (python_env, prep_rec, self.receptor, pdbqt)
+        subprocess.call([cmd], shell=True)
+        return str(Path(pdbqt).resolve())
+
+
+class Molecule(object):
+    def __init__(self, molecule, mglpath):
+        self.molecule = molecule
+        self.mglpath = str(Path(mglpath).resolve())
+        self.obabel_path = get_bin_path("obabel")
+
+    def topdbqt(self, tran0=[]):
+        """
+        tran0 is the vector of centre x,y,z where to translate the molecule
+        """
+        obabel = f"{self.obabel_path}/obabel"
+        molname = self.molecule
+        if ".mol2" in molname.lower():
+            molname = molname.replace(".mol2", ".pdbqt")
+        else:
+            molname = molname.replace(".pdb", ".pdbqt")
+        cmd = "%s -p gastaiger -imol2 '%s' -opdbqt -O '%s'" % (
+            obabel,
+            self.molecule,
+            molname,
+        )
+        subprocess.call([cmd], shell=True)
+        # Translate to the new center
+        fpdbqt = str(Path(molname).resolve())
+        if len(tran0) > 0:
+            mem = []
+            fi = open(fpdbqt, "r")
+            for line in fi:
+                if "ATOM" in line:
+                    ex_cc = extract_coordinates(line.strip(), "pdbqt")
+                    if ex_cc:
+                        copy_line = line
+                        x = float(ex_cc[0]) + tran0[0]
+                        copy_line.replace(str(ex_cc[0]), str(x))
+                        y = float(ex_cc[1]) + tran0[0]
+                        copy_line.replace(str(ex_cc[1]), str(y))
+                        z = float(ex_cc[2]) + tran0[0]
+                        copy_line.replace(str(ex_cc[2]), str(z))
+                        mem.append(copy_line)
+                    else:
+                        msg = "Molecule.topdbqt Error!\n"
+                        msg += " X Y Z coordinates not found in "
+                        msg += f"line {line.strip()}"
+                        raise ValueError(msg)
+                else:
+                    mem.append(line)
+            fi.close()
+
+            fo = open(fpdbqt, "w")
+            for line in mem:
+                fo.write(line)
+            fo.close()
+        return fpdbqt

pautodock-1.0.0/src/pautodock/multimol2op.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""multimol2op.py
+
+This file is part of PAutoDock.
+Copyright (C) 2020 Giuseppe Marco Randazzo <gmrandazzo@gmail.com>
+PAutoDock is distributed under GPLv3 license.
+To know more in detail how the license work,
+please read the file "LICENSE" or
+go to "http://www.gnu.org/licenses/gpl-3.0.en.html"
+
+Provides the basic operation for MOL2 files in parallel
+
+"""
+
+import os
+import shutil
+from pathlib import Path
+
+
+def read_molname(filemol2: str):
+    f = open(filemol2, "r")
+    molname = None
+    next_is_name = False
+    for line in f:
+        if line.strip().lower() == "@<TRIPOS>MOLECULE".lower():
+            next_is_name = True
+        else:
+            if next_is_name is True:
+                molname = line.strip()
+                next_is_name = False
+    f.close()
+    return molname
+
+
+def get_mol2_name(filemol2: str):
+    molname = read_molname("tmp_")
+    filename = molname + ".mol2"
+    cc = 1
+    while True:
+        if os.path.isfile(filename) is False:
+            break
+        else:
+            filename = molname + "_" + str(cc) + ".mol2"
+            cc = cc + 1
+    return filename
+
+
+def split_mol2(mmol2, path="./"):
+    mol2splitted = []
+    fmol2 = open(mmol2, "r")
+    ftmp = open("tmp_", "w")
+    firstmol = True
+    for line in fmol2:
+        if line.strip().lower() == "@<TRIPOS>MOLECULE".lower():
+            if ftmp.closed is False and firstmol is False:
+                ftmp.close()
+                filename = get_mol2_name("tmp_")
+                mpath = str(Path(path + "/" + filename).absolute())
+                if Path(mpath).exists() is False:
+                    shutil.move("tmp_", mpath)
+                    mol2splitted.append(mpath)
+                else:
+                    os.remove("tmp_")
+                ftmp = open("tmp_", "w")
+            firstmol = False
+            ftmp.write(line)
+        else:
+            ftmp.write(line)
+
+    if ftmp.closed is False:
+        ftmp.close()
+        filename = get_mol2_name("tmp_")
+        mpath = str(Path(path + "/" + filename).absolute())
+        if Path(mpath).exists() is False:
+            shutil.move("tmp_", mpath)
+            mol2splitted.append(mpath)
+        else:
+            os.remove("tmp_")
+    fmol2.close()
+    return mol2splitted