def test_unterminated_block():
r = InputReader(ignoreunknown=True)
a = r.add_block_key('red')
a.add_boolean_key('rose')
with raises(ReaderError) as e:
r.read_input(['red', 'rose'])
assert search('Unterminated block', str(e.value))
def test_block_read_end():
r = InputReader()
a = r.add_block_key('red', end='subend')
a.add_boolean_key('rose', default=False)
inp = r.read_input(['red', 'rose', 'subend'])
assert inp.red.rose
inp = r.read_input(['red', 'subend'])
assert not inp.red.rose
def test_line_read_case_sensitive():
r = InputReader()
r.add_line_key('blue', type=str)
inp = r.read_input(['blue HeLLo'])
assert inp.blue == 'hello'
r.add_line_key('red', type=str, case=True)
inp = r.read_input(['red HeLLo'])
assert inp.red == 'HeLLo'
def test_unknown_keys_cause_failure(setup):
# Don't ignore unknown keys
parse_string = setup[-1]
reader = InputReader(comment='//', ignoreunknown=False)
reader.add_boolean_key('red')
reader.add_line_key('path')
with raises(ReaderError) as e:
reader.read_input(parse_string)
assert 'Unrecognized key' in str(e.value)
def test_comments_are_handled_correctly(setup):
parse_string = setup[-1]
reader = InputReader(comment='#')
reader.add_boolean_key('red')
reader.add_boolean_key('blue')
reader.add_line_key('path')
with raises(ReaderError) as e:
reader.read_input(parse_string)
regex = r'expected \d+ arguments, got \d+'
assert search(regex, str(e.value))
def test_line_read_using_defaults():
r = InputReader()
r.add_line_key('blue')
inp = r.read_input(['blue bird'])
assert inp.blue == 'bird'
with raises(ReaderError) as e:
inp = r.read_input(['blue'])
assert search(r'expected .*\d+ arguments, got \d+', str(e.value))
with raises(ReaderError) as e:
inp = r.read_input(['blue bird egg'])
assert search(r'expected .*\d+ arguments, got \d+', str(e.value))
def test_block_read_case_sensitive():
r = InputReader()
a = r.add_block_key('red', case=True, end='END')
a.add_boolean_key('ROSE')
inp = r.read_input(['RED', 'ROSE', 'END'])
assert 'rose' not in inp.red
assert inp.red.ROSE
b = r.add_block_key('pink', case=False)
b.add_boolean_key('ROSE')
inp = r.read_input(['PINK', 'ROSE', 'END'])
assert 'ROSE' not in inp.pink
assert inp.pink.rose
def test_block_read_ignoreunknown():
r = InputReader()
a = r.add_block_key('red', ignoreunknown=False)
a.add_boolean_key('rose')
with raises(ReaderError) as e:
inp = r.read_input(['red', 'rose', 'rider', 'end'])
assert 'Unrecognized key' in str(e.value)
b = r.add_block_key('blue', ignoreunknown=True)
b.add_boolean_key('rose')
inp = r.read_input(['blue', 'rose', 'rider', 'end'])
assert inp.blue.rose
assert 'rider' not in inp.blue
def test_block_read_subblocks():
r = InputReader()
a = r.add_block_key('red')
b = a.add_block_key('blue')
b.add_boolean_key('egg')
inp = r.read_input(['red', 'blue', 'egg', 'end', 'end'])
assert inp.red.blue.egg
c = r.add_block_key('pink')
d = c.add_block_key('blue', end='subend')
d.add_boolean_key('egg')
inp = r.read_input(['pink', 'blue', 'egg', 'subend', 'end'])
assert inp.pink.blue.egg
def test_read_mutex_set_required():
r = InputReader()
meg = r.add_mutually_exclusive_group(required=True)
meg.add_boolean_key('red')
meg.add_boolean_key('blue')
meg.add_boolean_key('green')
inp = r.read_input(['blue'])
assert inp.blue
assert not inp.red
assert not inp.green
with raises(ReaderError) as e:
inp = r.read_input([])
assert search(r'One and only one of .* must be included', str(e.value))
def test_regex_read():
r = InputReader()
# Remember it's case-insensitive
r.add_regex_line('red', r'funny(\d+)DOG\s*(kitty)?')
inp = r.read_input(['funny14dog'])
assert inp.red.group(0) == 'funny14dog'
assert inp.red.group(1) == '14'
inp = r.read_input(['funny12DOG kitty'])
# Regex won't lowercase for you
assert inp.red.group(0) == 'funny12DOG kitty'
assert inp.red.group(1) == '12'
assert inp.red.group(2) == 'kitty'
r.add_regex_line('blue', r'(SILLY|ODD)\s*(goose|duck)', case=True)
inp = r.read_input(['SILLY goose'])
assert inp.blue.group(0) == 'SILLY goose'
inp = r.read_input(['ODD duck'])
assert inp.blue.group(0) == 'ODD duck'
def test_ignoreunknown_actually_ignores_unknown(setup):
# Ignore unknown keys
parse_string = setup[-1]
reader = InputReader(comment='//', ignoreunknown=True)
reader.add_boolean_key('red')
reader.add_line_key('path')
inp = reader.read_input(parse_string)
with raises(AttributeError):
inp.blue
def test_block_read_using_defaults():
r = InputReader()
a = r.add_block_key('blue')
inp = r.read_input(['blue', 'end'])
assert inp.blue == Namespace()
b = r.add_block_key('red')
b.add_boolean_key('rose', default=False)
b.add_boolean_key('rider', default=False)
inp = r.read_input(['red', 'rose', 'end'])
assert inp.red.rose
assert not inp.red.rider
inp = r.read_input(['red', 'end'])
assert not inp.red.rose
assert not inp.red.rider
c = r.add_block_key('cyan')
with raises(ReaderError) as e:
inp = r.read_input(['cyan word', 'end'])
assert search(r'The block "\w+" was given arguments, this is illegal',
str(e.value))
def test_read_mutex():
r = InputReader()
meg = r.add_mutually_exclusive_group()
meg.add_boolean_key('red')
meg.add_boolean_key('blue')
meg.add_boolean_key('green')
inp = r.read_input(['red'])
assert inp.red
assert not inp.blue
assert not inp.green
with raises(ReaderError) as e:
inp = r.read_input(['red', 'blue'])
assert search(r'Only one of .* may be included', str(e.value))
# Unfortunately we cannot detect duplicate groups in different meg's
meg2 = r.add_mutually_exclusive_group()
meg2.add_boolean_key('red')
def test_read_mutex_set_dest_set_required():
r = InputReader()
meg = r.add_mutually_exclusive_group(required=True, dest='color')
meg.add_boolean_key('red')
meg.add_boolean_key('blue')
meg.add_boolean_key('green')
r.add_boolean_key('cyan')
with raises(ReaderError) as e:
inp = r.read_input(['cyan'])
assert search(r'One and only one of .* must be included', str(e.value))
def test_read_mutex_set_default():
r = InputReader()
meg = r.add_mutually_exclusive_group(default='water')
meg.add_boolean_key('red')
meg.add_boolean_key('blue')
meg.add_boolean_key('green')
inp = r.read_input(['red'])
assert inp.red
assert inp.blue == 'water'
assert inp.green == 'water'
inp = r.read_input([])
assert inp.red == 'water'
assert inp.blue == 'water'
assert inp.green == 'water'
# Using default=SUPPRESS was the intended use case of default for meg's
meg = r.add_mutually_exclusive_group(default=SUPPRESS)
meg.add_boolean_key('pink')
meg.add_boolean_key('gray')
meg.add_boolean_key('cyan')
inp = r.read_input(['pink'])
assert inp.pink
assert 'gray' not in inp
assert 'cyan' not in inp
def test_read_mutex_set_dest():
r = InputReader()
# This is the best way to use meg's
meg = r.add_mutually_exclusive_group(dest='color')
meg.add_boolean_key('red', action='red')
meg.add_boolean_key('blue', action='blue')
meg.add_boolean_key('green', action='green')
meg.add_boolean_key('pink', action='pink')
meg.add_boolean_key('gray', action='pink')
meg.add_boolean_key('cyan', action='cyan')
r.add_boolean_key('white')
inp = r.read_input(['cyan', 'white'])
assert inp.color == 'cyan'
assert inp.white
assert 'red' not in inp
assert 'blue' not in inp
assert 'green' not in inp
assert 'pink' not in inp
assert 'gray' not in inp
assert 'cyan' not in inp
def test_line_reading_types():
r = InputReader()
r.add_line_key('blue', type=int)
inp = r.read_input(['blue 23'])
assert inp.blue == 23
with raises(ReaderError) as e:
inp = r.read_input(['blue bird'])
assert search(r'expected \w+, got "\w+"', str(e.value))
r.add_line_key('red', type=(0, 1, 2, 3))
inp = r.read_input(['red 3'])
assert inp.red == 3
with raises(ReaderError) as e:
inp = r.read_input(['red 4'])
assert search(r'expected one of .+, got "\w+"', str(e.value))
r.add_line_key('green', type=(float, None))
inp = r.read_input(['green 3'])
assert inp.green == 3
inp = r.read_input(['green 3.5'])
assert inp.green == 3.5
inp = r.read_input(['green none'])
assert inp.green is None
with raises(ReaderError) as e:
inp = r.read_input(['green bird'])
assert search(r'expected one of .+, got "\w+"', str(e.value))
r.add_line_key('cyan', type=[str, (None, str), float])
inp = r.read_input(['cyan cat dog 6'])
assert inp.cyan == ('cat', 'dog', 6)
with raises(ReaderError) as e:
inp = r.read_input(['cyan cat dog 7 8'])
assert search('expected .+, got \w+', str(e.value))
with raises(ReaderError) as e:
inp = r.read_input(['cyan cat none bird'])
assert search('expected \w+, got "\w+"', str(e.value))
inp = r.read_input(['cyan cat none 7.8'])
assert inp.cyan == ('cat', None, 7.8)
r.add_line_key('black', type=('hey', str('hi'), 4, 2.8))
inp = r.read_input(['black 4'])
assert inp.black == 4
inp = r.read_input(['black 2.8'])
assert inp.black == 2.8
inp = r.read_input(['black hey'])
assert inp.black == 'hey'
inp = r.read_input(['black hi'])
assert inp.black == 'hi'
with raises(ReaderError) as e:
inp = r.read_input(['black whoops'])
assert search('expected one of [a-zA-Z0-9, ".]+, got "\w+"', str(e.value))
with raises(ReaderError) as e:
inp = r.read_input(['black 2'])
assert search('expected one of [a-zA-Z0-9, ".]+, got "\d+"', str(e.value))
import re
r.add_line_key('pink', type=re.compile(r'neat\d+'))
inp = r.read_input(['pink neat68'])
assert inp.pink == 'neat68'
with raises(ReaderError) as e:
inp = r.read_input(['pink near68'])
assert search('expected regex\(.*\)', str(e.value))
def test_line_read_using_globs():
r = InputReader()
r.add_line_key('blue', type=[int, int],
glob={'len':'*', 'type':int})
inp = r.read_input(['blue 1 2 3 4 5 6 7'])
assert inp.blue == (1, 2, 3, 4, 5, 6, 7)
inp = r.read_input(['blue 1 2'])
assert inp.blue == (1, 2)
r.add_line_key('red', type=[int, int],
glob={'len':'*', 'type':int, 'join':True})
inp = r.read_input(['red 1 2 3 4 5 6 7'])
assert inp.red == (1, 2, '3 4 5 6 7')
inp = r.read_input(['red 1 2'])
assert inp.red == (1, 2)
r.add_line_key('pink', type=[int, int],
glob={'len':'+', 'type':float, 'join':True})
inp = r.read_input(['pink 1 2 3 4 5 6 7'])
assert inp.pink == (1, 2, '3.0 4.0 5.0 6.0 7.0')
inp = r.read_input(['pink 1 2 3'])
assert inp.pink == (1, 2, '3.0')
r.add_line_key('cyan', type=[int, int],
glob={'len':'?', 'type':int})
inp = r.read_input(['cyan 1 2 3'])
assert inp.cyan == (1, 2, 3)
inp = r.read_input(['cyan 1 2'])
assert inp.cyan == (1, 2)
r.add_line_key('yellow', type=int, glob={'len':'?', 'type':int})
inp = r.read_input(['yellow 1 2'])
assert inp.yellow == (1, 2)
inp = r.read_input(['yellow 1'])
assert inp.yellow == (1,)
r.add_line_key('teal', type=int, glob={'len':'?', 'type':int, 'default':3})
inp = r.read_input(['teal 1 2'])
assert inp.teal == (1, 2)
inp = r.read_input(['teal 1'])
assert inp.teal == (1, 3)
r.add_line_key('gray', type=None, glob={'len':'?'})
inp = r.read_input(['gray bye'])
assert inp.gray == 'bye'
inp = r.read_input(['gray'])
assert inp.gray == ''
r.add_line_key('white', type=None, glob={'len':'*'})
inp = r.read_input(['white hi lo'])
assert inp.white == ('hi', 'lo')
inp = r.read_input(['white'])
assert inp.white == ()
r.add_line_key('green', type=None, glob={'len':'+', 'join':True})
inp = r.read_input(['green hi lo'])
assert inp.green == 'hi lo'
r.add_line_key('orange', type=None, glob={'len':'*', 'join':True})
inp = r.read_input(['orange'])
assert inp.orange == ''
r.add_line_key('black', type=int, glob={'len':'?', 'type':int})
with raises(ReaderError) as e:
r.read_input(['black 1 2 3'])
assert search(r'expected at most \d+ arguments, got \d+', str(e.value))
r.add_line_key('maroon', type=int, glob={'len':'+', 'type':int})
with raises(ReaderError) as e:
r.read_input(['maroon 1'])
assert search(r'expected at least \d+ arguments, got \d+', str(e.value))
def test_line_read_using_keywords():
r = InputReader()
r.add_line_key('red', type=int,
keywords={'robin':{}})
inp = r.read_input(['red 5 robin=early'])
assert inp.red == (5, {'robin':'early'})
inp = r.read_input(['red 5'])
assert inp.red == (5, {})
with raises(ReaderError) as e:
r.read_input(['red 5 robin=early light=special'])
assert 'Unknown keyword' in str(e.value)
r.add_line_key('blue', type=[int, int],
keywords={'egg':{'type':int, 'default':1},
'ice':{'type':(4, 5)}})
inp = r.read_input(['blue 5 7 egg=6 ice=4'])
assert inp.blue == (5, 7, {'egg':6, 'ice':4})
inp = r.read_input(['blue 5 7 ice=5'])
assert inp.blue == (5, 7, {'egg':1, 'ice':5})
inp = r.read_input(['blue 5 7'])
assert inp.blue == (5, 7, {'egg':1})
r.add_line_key('cyan', type=None, keywords={'by':{'type':int},
'to':{'type':int}})
inp = r.read_input(['cyan by=14 to=11'])
assert inp.cyan == {'by':14, 'to':11}
inp = r.read_input(['cyan by=14'])
assert inp.cyan == {'by':14}
inp = r.read_input(['cyan'])
assert inp.cyan == {}
with raises(ReaderError) as e:
inp = r.read_input(['cyan by = 3'])
assert 'Error reading keyword argument' in str(e.value)
def read_input(input_file):
'''Defines what to expect from the input file and then
reads it in.'''
# Creates an input reader instance
reader = InputReader(default=SUPPRESS)
# Rate parameter, either rate or lifetime, not both
rate = reader.add_mutually_exclusive_group(required=True)
# The units are s, ns, ps, or fs. The default is ps.
rate.add_line_key('lifetime', type=float,
glob={'len' : '?',
'type' : ('ps', 'fs', 'ns', 's'),
'default' : 'ps'})
rate.add_line_key('rate', type=float,
glob={'len' : '?',
'type' : ('thz', 'phz', 'ghz', 'hz'),
'default' : 'thz'})
# The range of the X-axis
reader.add_line_key('xlim', type=[int, int], default=(1900, 2000))
reader.add_boolean_key('reverse', action=True, default=False)
# Read in the raw data.
reader.add_line_key('raw', type=[], glob={'len':'*', 'join':True, },
default=None, case=True)
# Read in the peak data. The wavenumber and height is required.
# The Lorentzian and Gaussian widths are defaulted to 10 if not given.
floatkw = {'type' : float, 'default' : 10.0}
reader.add_line_key('peak', required=True, repeat=True, type=[float,float],
keywords={'g':floatkw, 'l':floatkw,
'num' : {'type':int,'default':-1}})
# Read the exchange information.
reader.add_line_key('exchange', repeat=True, type=[int, int],
glob={'type' : float,
'default' : 1.0,
'len' : '?'})
reader.add_boolean_key('nosym', action=False, default=True,
dest='symmetric_exchange')
# Actually read the input file
args = reader.read_input(input_file)
# Make sure the filename was given correctly and read in data
if args.raw:
args.add('rawName', args.raw)
args.raw = loadtxt(abs_file_path(args.raw))
# Make the output file path absolute if given
args.data = abs_file_path(args.data) if 'data' in args else ''
if 'save_plot_script' in args:
args.save_plot_script = abs_file_path(args.save_plot_script)
else:
args.save_plot_script = ''
# Adjust the input rate or lifetime to wavenumbers
if 'lifetime' in args:
convert = { 'ps' : 1E-12, 'ns' : 1E-9, 'fs' : 1E-15, 's' : 1 }
args.add('k', 1 / ( convert[args.lifetime[1]] * args.lifetime[0] ))
else:
convert = { 'thz' : 1E12, 'ghz' : 1E9, 'phz' : 1E15, 'hz' : 1 }
args.add('k', convert[args.rate[1]] * args.rate[0])
args.k *= HZ2WAVENUM / ( 2 * pi )
# Parse the vibrational input
num, vib, Gamma_Lorentz, Gamma_Gauss, heights, rel_rates, num_given = (
[], [], [], [], [], [], [])
for peak in args.peak:
# Vibration #
num.append(peak[2]['num'])
num_given.append(False if peak[2]['num'] < 0 else True)
# Angular frequency
vib.append(peak[0])
# Relative peak heights
heights.append(peak[1])
# Default Gaussian or Lorentzian width or relative rate
Gamma_Lorentz.append(peak[2]['l'])
Gamma_Gauss.append(peak[2]['g'])
# Either all or none of the numbers must be given explicitly
if not (all(num_given) or not any(num_given)):
raise ReaderError('All or none of the peaks must '
'be given numbers explicitly')
# If the numbers were give, make sure there are no duplicates
if all(num_given):
if len(num) != len(set(num)):
raise ReaderError('Duplicate peaks cannot be given')
# If none were given, number automatically
else:
num = range(1, len(num)+1, 1)
args.add('num', array(num))
args.add('vib', array(vib))
args.add('heights', array(heights))
args.add('Gamma_Lorentz', array(Gamma_Lorentz))
args.add('Gamma_Gauss', array(Gamma_Gauss))
# Set up the exchanges
# Make sure the each exchange number appears in num.
num = set(num)
ex = []
rates = []
string = 'Requested peak {0} in exchange does not exist'
if 'exchange' in args:
for exchange in args.exchange:
p1 = exchange[0]
if p1 not in num:
raise ReaderError(string.format(p1))
p2 = exchange[1]
if p2 not in num:
raise ReaderError(string.format(p2))
if p1 == p2 and args.symmetric_exchange:
raise ReaderError('Self exchange is not allowed')
rate = exchange[2]
# Offset the peak number by one to match python indicies
ex.append([p1-1, p2-1])
rates.append(rate)
else:
ex = []
rates = []
args.add('exchanges', array(ex, dtype=int))
args.add('exchange_rates', array(rates))
# Make sure the xlimits are ascending
try:
range_check(args.xlim[0], args.xlim[1])
except ValueError:
raise ReaderError('In xrange, the low value must '
'less than the high value')
return args
