No project description provided
The Hotspots API is the Python package for the Fragment Hotspot Maps project, a knowledge-based method for determining small molecule binding "hotspots".
For more information on this method:
Although the Hotspots API is publicly available, it is dependant on the CSD Python API - a commercial package.
If you are an academic user, it's likely your institution will have a license. If you are unsure if you have a license or would like to enquire about purchasing one, please contact email@example.com.
Please note, this is an academic project and we would therefore welcome feedback, contributions and collaborations. If you have any queries regarding this package please contact us (firstname.lastname@example.org)!
1 Install CSDS 2019
The CSDS is available from here.
You will need a valid site number and confirmation code, this will have been emailed to you when you bought your CSDS 2019 license.
2 Install GHECOM
Ghecom is available from here.
"The source code of the GHECOM is written in C, and developed and executed on the linux environment (actually on the Fedora Core). For the installation, you need the gcc compiler. If you do not want to use it, please change the "Makefile" in the "src" directory."
Download the file
tar zxvf ghecom-src-[date].tar.gz cd src make
NB: The executable will be located at the parent directory.
3 Create conda environment (recommended)
conda create -n hotspots python=2.7
4 Create Install RDKit and CSD Python API
conda install -n hotspots -c rdkit rdkit
The standalone CSD-Python-API installer from is available here.
Install the Python CSD API:
conda install -n hotspots csd-python-api-2.x.x-linux-py2.7-conda.tar.bz2
5 Install Hotspots
Install Hotspots v1.x.x:
conda activate hotspots pip install https://github.com/prcurran/hotspots/archive/v1.x.x.zip
NB: dependencies should install automatically. If they do not, please see setup.py for the package requirements!
Hotspots API Usage
Start activating your Anaconda environment and setting some variables.
conda activate hotspots export GHECOM_EXE=<path_to_GHECOM_executable> export CSDHOME=<path_to_CSDS_installation>/CSD_2019
Running a Calculation
The first step is to make sure your protein is correctly prepared for the calculation. The structures should be protonated with small molecules and waters removed. Any waters or small molecules left in the structure will be included in the calculation.
One way to do this is to use the CSD Python API:
from ccdc.protein import Protein prot = Protein.from_file('protein.pdb') prot.remove_all_waters() prot.add_hydrogens() for l in prot.ligands: prot.remove_ligand(l.identifier)
For best results, manually check proteins before submitting them for calculation.
Calculating Fragment Hotspot Maps
Once the protein is prepared, the
hotspots.calculation.Runner object can be
used to perform the calculation:
from hotspots.calculation import Runner runner = Runner() # Only SuperStar jobs are parallelised (one job per processor). By default there are 3 jobs, when calculating charged interactions there are 5. results = runner.from_pdb(prot, nprocesses=3)
Alternatively, for a quick calculation, you can supply a PDB code and we will prepare the protein as described above:
runner = Runner() results = runner.from_pdb("1hcl", nprocesses=3)
Reading and Writing Hotspots
hotspots.hs_io module handles the reading and writing of both
hotspots.best_volume.Extractor objects. The output
.grd files can become quite large,
but are highly compressible, therefore the results are written to a
.zip archive by default,
along with a PyMOL run script to visualise the output.
from hotspots.hs_io import HotspotWriter out_dir = "results/pdb1" # Creates "results/pdb1/out.zip" with HotspotWriter(out_dir) as writer: writer.write(results)
If you want to revisit the results of a previous calculation, you can load the
out.zip archive directly into a
from hotspots.hs_io import HotspotReader results = HotspotReader('results/pdb1/out.zip').read()
Using the Output
While Fragment Hotspot Maps provide a useful visual guide, the grid-based data can be used in other SBDD analysis.
One example is scoring atoms of either proteins or small molecules.
This can be done as follows:
from ccdc.protein import Protein from ccdc.io import MoleculeReader, MoleculeWriter from hotspots.calculation import Runner r = Runner() prot = Protein.from_file("1hcl.pdb") # prepared protein hs = r.from_protein(prot) # score molecule mol = MoleculeReader("mol.mol2") scored_mol = hs.score(mol) with MoleculeWriter("score_mol.mol2") as w: w.write(scored_mol) # score protein scored_prot = hs.score(hs.prot) with MoleculeWriter("scored_prot.mol2") as w: w.write(scored_prot)
To learn about other ways you can use the Hotspots API please see the examples directory and read our API documentation.
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
|Filename, size||File type||Python version||Upload date||Hashes|
|Filename, size hotspots-1.0.1-py2-none-any.whl (112.0 kB)||File type Wheel||Python version py2||Upload date||Hashes View|
|Filename, size hotspots-1.0.1.tar.gz (86.7 kB)||File type Source||Python version None||Upload date||Hashes View|