def testFromArgsNonexistentTrigPoint(self):
"""
If --trig is given on a command line with a non-existent trig point
name, we should be able to catch it but currently cannot.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
def testFromArgsScalarParameters(self):
"""
All scalar arguments must be processed by fromArgs as expected.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args([
'--limitPerLandmark',
'5',
'--maxDistance',
'10',
'--minDistance',
'3',
'--distanceBase',
'1.9',
'--featureLengthBase',
'2.3',
'--randomLandmarkDensity',
'0.7',
'--randomTrigPointDensity',
'0.3',
])
dbParams = DatabaseParameters.fromArgs(args)
self.assertEqual(5, dbParams.limitPerLandmark)
self.assertEqual(10, dbParams.maxDistance)
self.assertEqual(3, dbParams.minDistance)
self.assertEqual(1.9, dbParams.distanceBase)
self.assertEqual(2.3, dbParams.featureLengthBase)
self.assertEqual(0.7, dbParams.randomLandmarkDensity)
self.assertEqual(0.3, dbParams.randomTrigPointDensity)
def testFromArgsNoTrigPoints(self):
"""
If --noTrigPoints is given on a command line, the returned parameters
from fromArgs must have no trig points.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args(['--noTrigPoints'])
dbParams = DatabaseParameters.fromArgs(args)
self.assertEqual([], dbParams.trigPointFinders)
def testFromArgsNoArgs(self):
"""
If no arguments are given on a command line, default parameters must
be returned by fromArgs.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args([])
dbParams = DatabaseParameters.fromArgs(args)
self.assertIs(None, dbParams.compare(DatabaseParameters()))
def testFromArgsTrigPoints(self):
"""
If --trig is given on a command line, the returned parameters
from fromArgs must have the expected trig point finders.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args(['--trig', 'Troughs', '--trig', 'Peaks'])
dbParams = DatabaseParameters.fromArgs(args)
self.assertEqual(['Peaks', 'Troughs'],
sorted(dbParams.trigPointFinderNames()))
def testFromArgsLandmarks(self):
"""
If --landmark is given on a command line, the returned parameters
from fromArgs must have the expected landmark finders.
"""
parser = argparse.ArgumentParser()
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args(
['--landmark', 'AlphaHelix', '--landmark', 'BetaStrand'])
dbParams = DatabaseParameters.fromArgs(args)
self.assertEqual(['AlphaHelix', 'BetaStrand'],
dbParams.landmarkFinderNames())
def addArgsToParser(self, parser):
"""
Add standard database creation or loading arguments to an argparse
parser, depending on the allowable ways of specifying a database.
@param parser: An C{argparse.ArgumentParser} instance.
"""
parser.add_argument(
'--filePrefix',
help=('The prefix of the name of a file containing saved '
'data. The suffix "%s" will be added to database '
'save files, "%s" to connector save files, and '
'"%s-N" to backend save files (where N is a numeric '
'backend index).' %
(Database.SAVE_SUFFIX, SimpleConnector.SAVE_SUFFIX,
Backend.SAVE_SUFFIX)))
if self._allowWamp:
parser.add_argument(
'--wampClient',
action='store_true',
default=False,
help=('If True, use a database that is actually just a client '
'of a remote WAMP distributed database.'))
parser.add_argument(
'--wampServer',
action='store_true',
default=False,
help='If True, serve a WAMP-connected distributed database.')
addWampArgsToParser(parser)
if self._allowCreation:
DatabaseParameters.addArgsToParser(parser)
if self._allowPopulation:
parser.add_argument(
'--databaseFasta',
help=('The name of a FASTA file containing the sequences that '
'should be added to the database.'))
parser.add_argument(
'--databaseSequence',
action='append',
dest='databaseSequences',
metavar='"id sequence"',
help=('Amino acid sequences to add to the database. The '
'sequence id will be the text up to the last space, if '
'any, otherwise will be automatically assigned.'))
#!/usr/bin/env python
"""
Print all database and find parameters available via the command line,
with their default values (according to argparse).
"""
from __future__ import print_function
import argparse
from light.parameters import DatabaseParameters, FindParameters
dbParams = DatabaseParameters()
parser = argparse.ArgumentParser(
add_help=False, formatter_class=argparse.ArgumentDefaultsHelpFormatter)
dbParams.addArgsToParser(parser)
print('Database parameters:')
# Splitting on 'optional arguments:\n' is a hack that works nicely as the
# first part of the help message is a summary of how to call the program
# and doesn't show descriptions or default values.
print(parser.format_help().split('optional arguments:\n')[1])
findParams = FindParameters()
parser = argparse.ArgumentParser(
add_help=False, formatter_class=argparse.ArgumentDefaultsHelpFormatter)
findParams.addArgsToParser(parser)
print('Find parameters:')
print(parser.format_help().split('optional arguments:\n')[1])
default=False,
action='store_true',
help=('If given, print the values of all parameters used.'))
parser.add_argument('--description',
default='<not given>',
help='A description of the code being tested.')
parser.add_argument(
'--testIdPrefix',
default=None,
help=('A test id prefix. Tests whose ids do not contain this pattern '
'will not be run. The pattern is case-sensitive.'))
FindParameters.addArgsToParser(parser)
DatabaseParameters.addArgsToParser(parser)
args = parser.parse_args()
# If no parameter sets were specified, use the ones on the command line.
if not args.parameterSets:
args.parameterSets = ['command-line']
if 'command-line' in args.parameterSets:
PARAMETER_SETS['command-line'] = {
'dbParams': DatabaseParameters.fromArgs(args),
'findParams': FindParameters.fromArgs(args),
}
if args.printParams:
for parameterSet in args.parameterSets: