Package: hotspots
Hotspots APIThe 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:Radoux, C.J. et. al., Identifying the Interactions that Determine Fragment Binding at Protein Hotspots J. Med. Chem. 2016, 59 (9), 4314-4325Getting StartedAlthough 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 contactsupport@ccdc.cam.ac.uk.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 (pcurran@ccdc.cam.ac.uk)!Installation1 Install CSDS 2019The CSDS is available fromhere.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 GHECOMGhecom is available fromhere."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 fileghecom-src-[date].tar.gzfile.tar zxvf ghecom-src-[date].tar.gz
cd src
makeNB: The executable will be located at the parent directory.3 Create conda environment (recommended)conda create -n hotspots python=2.74 Create Install RDKit and CSD Python APIInstall RDKit:conda install -n hotspots -c rdkit rdkitThe latest standalone CSD-Python-API installer from is availablehere.Install the Python CSD API:unzip csd-python-api-2.1.0-linux-64-py2.7-conda
 conda install -n hotspots -c <path to ccdc_conda_channel> csd-python-api5 Install HotspotsInstall Hotspots v1.x.x:a) Latest stable release (recommended for most users):conda activate hotspots

pip install hotspots
or 
pip install https://github.com/prcurran/hotspots/archive/v1.x.x.zipb) Very latest codemkdir ./hotspots_code
git clone git@github.com:prcurran/hotspots.git
conda activate hotspots
cd hotspots_code
pip install hotspots_codeNB: dependencies should install automatically. If they do not, please see setup.py for the package requirements!Hotspots API UsageStart 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_2019Running a CalculationProtein PreparationThe 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 MapsOnce the protein is prepared, thehotspots.calculation.Runnerobject 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_protein(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 HotspotsWritingThehotspots.hs_iomodule handles the reading and writing of bothhotspots.calculation.resultsandhotspots.best_volume.Extractorobjects. The output.grdfiles can become quite large,
but are highly compressible, therefore the results are written to a.ziparchive 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)ReadingIf you want to revisit the results of a previous calculation, you can load theout.ziparchive directly into ahotspots.calculation.resultsinstance:from hotspots.hs_io import HotspotReader

results = HotspotReader('results/pdb1/out.zip').read()Using the OutputWhile Fragment Hotspot Maps provide a useful visual guide, the grid-based data
can be used in other SBDD analysis.ScoringOne 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.