def test_pdb_checkup(self):
"""It tests the safety check function for PDB files."""
LIGAND_GOOD = get_data_file_path('ligands/ethylene.pdb')
LIGAND_ERROR1 = get_data_file_path('tests/ethylene_error1.pdb')
LIGAND_ERROR2 = get_data_file_path('tests/ethylene_error2.pdb')
LIGAND_ERROR3 = get_data_file_path('tests/ethylene_error3.pdb')
LIGAND_ERROR4 = get_data_file_path('tests/ethylene_error4.pdb')
# This should work without any complain
_ = Molecule(LIGAND_GOOD)
# All atom names need to be unique
with pytest.raises(Exception):
_ = Molecule(LIGAND_ERROR1)
# All residue ids must match
with pytest.raises(Exception):
_ = Molecule(LIGAND_ERROR2)
# All residue names must match
with pytest.raises(Exception):
_ = Molecule(LIGAND_ERROR3)
# Check warning message in the logger when connectivity is missing
import io
from peleffy.utils import Logger
import logging
from importlib import reload
logging.shutdown()
reload(logging)
log = Logger()
log.set_level('WARNING')
# Catch logger messages to string buffer
with io.StringIO() as buf:
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
_ = Molecule(LIGAND_ERROR4)
output = buf.getvalue()
assert output == "Warning: input PDB has no information " \
+ "about the connectivity and this could result in " \
+ "an unexpected bond assignment\n"
def __init__(self, dihedral_atom_indexes, molecule):
"""
It initializes a DihedralBenchmark object.
Parameters
----------
dihedral_atom_indexes : tuple[int]
The indexes of atoms involved in the dihedral
molecule : an peleffy.topology.Molecule
The peleffy's Molecule object
"""
# Hide peleffy output
from peleffy.utils import Logger
logger = Logger()
logger.set_level('WARNING')
molecule.assert_parameterized()
self._atom_indexes = dihedral_atom_indexes
self._molecule = molecule
self._forcefield = molecule.forcefield
def __init__(self, PELE_exec, PELE_src, n_proc=1):
"""
It initializes a MultiMinimizer object.
Parameters
----------
PELE_exec : str
Path to the PELE executable
PELE_src : str
Path to PELE source folder
n_proc : int
The number of processors to employ to gather and parse data
"""
# Supress INFO messages from peleffy
from peleffy.utils import Logger
log = Logger()
log.set_level('WARNING')
self._PELE_exec = PELE_exec
self._PELE_src = PELE_src
self._output_path = None
self.n_proc = n_proc
def main(args):
"""
It reads the command-line arguments and runs peleffy.
Parameters
----------
args : argparse.Namespace
It contains the command-line arguments that are supplied by the user
Examples
--------
From the command-line:
>>> python main.py molecule.pdb -f openff_unconstrained-1.2.0.offxml
-r 30 -o output_path/ --with_solvent --as_datalocal -c gasteiger
"""
exclude_terminal_rotamers = not args.include_terminal_rotamers
# Supress OpenForceField toolkit warnings
import logging
logging.getLogger().setLevel(logging.ERROR)
# Set peleffy logger to the corresponding level
logger = Logger()
if args.silent:
logger.set_level('CRITICAL')
elif args.debug:
logger.set_level('DEBUG')
else:
logger.set_level('INFO')
run_peleffy(pdb_file=args.pdb_file,
forcefield_name=args.forcefield,
resolution=args.resolution,
charge_method=args.charge_method,
exclude_terminal_rotamers=exclude_terminal_rotamers,
output=args.output,
with_solvent=args.with_solvent,
as_datalocal=args.as_datalocal,
chain=args.chain,
conformation_path=args.conformations_info_path,
charges_from_file=args.charges_from_file)
def test_logger_levels(self):
"""
It checks the correct behaviour of the different log levels.
"""
def push_messages(log):
"""Pull some messages at different levels."""
log.debug('Debug message')
log.info('Info message')
log.warning('Warn message')
log.error('Error message')
log.critical('Critical message')
import logging
# Force a hard reset of logging library and the logger it manages
from importlib import reload
logging.shutdown()
reload(logging)
# Initiate logger
log = Logger()
# Try the default level (INFO)
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Info message\nWarn message\n' \
+ 'Error message\nCritical message\n', \
'Unexpected logger message at standard output'
# Try DEBUG level
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Try DEBUG level
log.set_level('DEBUG')
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Debug message\nInfo message\n'\
+ 'Warn message\nError message\nCritical message\n', \
'Unexpected logger message at standard output'
# Try INFO level
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Try INFO level
log.set_level('INFO')
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Info message\nWarn message\n' \
+ 'Error message\nCritical message\n', \
'Unexpected logger message at standard output'
# Try WARNING level
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Try WARNING level
log.set_level('WARNING')
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Warn message\nError message\n' \
+ 'Critical message\n', \
'Unexpected logger message at standard output'
# Try ERROR level
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Try ERROR level
log.set_level('ERROR')
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Error message\nCritical message\n', \
'Unexpected logger message at standard output'
# Try CRITICAL level
# Catch logger messages to string buffer
with io.StringIO() as buf:
# Add custom handler to logger
log_handler = logging.StreamHandler(buf)
log._logger.handlers = list()
log._logger.addHandler(log_handler)
# Try CRITICAL level
log.set_level('CRITICAL')
# Push messages
push_messages(log)
# Get string from buffer
output = buf.getvalue()
assert output == 'Critical message\n', \
'Unexpected logger message at standard output'
def __init__(self,
pele_exec,
pele_src,
pele_license,
ploprottemp_src,
schrodinger_src,
charge_method='am1bcc',
solvent='OBC',
opls_nonbonding=False,
opls_bonds_angles=False,
n_proc=1,
forcefield_name=None,
forcefield=None):
"""
It initialized an SolventBenchmark object.
Parameters
----------
PELE_exec : str
Path to the PELE executable
PELE_src : str
Path to PELE source folder
PELE_license : str
Path to PELE license directory
ploprottemp_src : str
Path to PlopRotTemp source code
schrodinger_src : str
Path to Schrodinger source code
charge_method : str
The method to calculate partial charges
solvent : str
The solvent model to employ
opls_nonbonding : bool
Whether to use OPLS2005 to parameterize nonbonding terms or not
opls_bonds_angles : bool
Whether to use OPLS2005 to paramterize bonds and angles or not
n_proc : int
Number of parallel computing processors to employ. Default is 1
forcefield_name : str
The force field name to employ. Default is None
forcefield : an peleffy.forcefield._BaseForceField
The forcefield representation to employ. Default is None
"""
self.pele_exec = pele_exec
self.pele_src = pele_src
self.pele_license = pele_license
self.charge_method = charge_method
self.solvent = solvent
self.opls_nonbonding = opls_nonbonding
self.opls_bonds_angles = opls_bonds_angles
self.ploprottemp_src = ploprottemp_src
self.schrodinger_src = schrodinger_src
self._n_proc = n_proc
self.forcefield_name = forcefield_name
self.forcefield = forcefield
self._results = dict()
# Deactivate peleffy output
from peleffy.utils import Logger
logger = Logger()
logger.set_level('WARNING')
# Supress OpenForceField toolkit warnings
import logging
logging.getLogger().setLevel(logging.ERROR)