def test_default_evaluate_arguments(self):
old_argv = sys.argv
enc = sys.stdin.encoding or sys.getdefaultencoding()
sys.argv = [s.encode(enc) for s in [u'script_name', u'foo', u'bar']]
p = Parser()
self.assertEqual(p.evaluate(), ({}, [u'foo', u'bar']))
sys.argv = old_argv
def test_options(self):
class TestDeclarative(Command):
spam = Option('a', 'asomething')
eggs = Option('b', 'bsomething')
a = TestDeclarative()
b = Command(options={
'spam': Option('a', 'asomething'),
'eggs': Option('b', 'bsomething')})
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo']),
({'c': ({'spam': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--asomething', u'foo']),
({'c': ({'spam': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-b', u'foo']),
({'c': ({u'eggs': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--bsomething', u'foo']),
({'c': ({u'eggs': u'foo'}, [])}, [])
)
def test_evaluate_no_quotes(self):
o = MultipleOptions(short='o')
p = Parser(options=dict(o=o))
self.assertEqual(
p.evaluate([u'-o', u'foo,bar,baz']),
({'o': [u'foo', u'bar', u'baz']}, [])
)
def test_disallow_abbreviated_commands(self):
class NewCommand(Command):
allow_abbreviated_commands = False
c = NewCommand(commands={'foo': Command()})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'f']), ({'c': ({}, [u'f'])}, []))
def test_evaluate(self):
o = BooleanOption(short="b")
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate([u'-b']), ({'b': True}, []))
o = BooleanOption(short="b", default=True)
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate(['-b']), ({'b': False}, []))
def test_default_evaluate_arguments(self):
old_argv = sys.argv
enc = sys.stdin.encoding or sys.getdefaultencoding()
sys.argv = [s.encode(enc) for s in [u'script_name', u'foo', u'bar']]
p = Parser()
self.assertEqual(p.evaluate(), ({}, [u'foo', u'bar']))
sys.argv = old_argv
def test_disallow_abbreviated_commands(self):
class NewCommand(Command):
allow_abbreviated_commands = False
c = NewCommand(commands={
'foo': Command()
})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'f']), ({'c': ({}, [u'f'])}, []))
def test_evaluate_with_quotes(self):
o = MultipleOptions(short='o')
p = Parser(options=dict(o=o))
self.assertEqual(p.evaluate([u'-o', u'foo,"bar,baz"']), ({
'o': [u'foo', u'bar,baz']
}, []))
self.assertEqual(p.evaluate([u'-o', u'"foo,bar",baz']), ({
'o': [u'foo,bar', u'baz']
}, []))
def test_remaining_arguments(self):
c = Command(options={'a': Option('a')})
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'foo']),
({'c': ({}, [u'foo'])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo']),
({'c': ({'a': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo', u'bar']),
({u'c': ({'a': u'foo'}, [u'bar'])}, [])
)
def test_remaining_arguments(self):
c = Command(options={'a': Option('a')})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'foo']), ({
'c': ({}, [u'foo'])
}, []))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo']), ({
'c': ({
'a': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo', u'bar']), ({
u'c': ({
'a': u'foo'
}, [u'bar'])
}, []))
def test_commands_and_options(self):
p = Parser(options={'foo': Option('f')},
commands={'bar': Command()},
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script [options] [commands]')
def test_positionals(self):
p = Parser(positionals=[Positional('a'),
Positional('b')],
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script a b')
def test_abbreviations(self):
c = Command(
options={
'stack': Option(long='stack'),
'stash': Option(long='stash')},
commands={
'stack': Command(),
'stash': Command()})
p = Parser(commands=dict(c=c))
cp = [u'script_name']
for s in [u's', u'st', u'sta']:
cmd = [u'c', s]
result = ({'c': ({}, [s])}, [])
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(
p.evaluate([u'c', u'stac']),
({'c': ({u'stack': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'stas']),
({'c': ({u'stash': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--stac', u'foo']),
({'c': ({u'stack': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--stas', u'foo']),
({'c': ({u'stash': u'foo'}, [])}, [])
)
def test_commands(self):
class TestDeclarative(Command):
spam = Command()
eggs = Command()
a = TestDeclarative()
b = Command(commands={
'spam': Command(),
'eggs': Command()})
cp = [u'script_name']
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'spam']),
({'c': ({u'spam': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'eggs']),
({'c': ({'eggs': ({}, [])}, [])}, [])
)
def test_commands(self):
class TestDeclarative(Command):
spam = Command()
eggs = Command()
a = TestDeclarative()
b = Command(commands={'spam': Command(), 'eggs': Command()})
cp = [u'script_name']
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'spam']), ({
'c': ({
u'spam': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'eggs']), ({
'c': ({
'eggs': ({}, [])
}, [])
}, []))
def test_positional_arguments(self):
p = Parser(positionals=[
Positional(u'foo'),
Positional(u'bar', short_description=u'something')
],
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContainsAll(output, [
u'usage: script foo bar', u'Positional arguments:', u' foo',
u'No short description.', u' bar', u'something'
])
def test_evaluate(self):
o = BooleanOption(short="b")
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate([u'-b']), ({'b': True}, []))
o = BooleanOption(short="b", default=True)
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate(['-b']), ({'b': False}, []))
def test_options(self):
class TestDeclarative(Command):
spam = Option('a', 'asomething')
eggs = Option('b', 'bsomething')
a = TestDeclarative()
b = Command(options={
'spam': Option('a', 'asomething'),
'eggs': Option('b', 'bsomething')
})
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo']), ({
'c': ({
'spam': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--asomething', u'foo']), ({
'c': ({
'spam': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'-b', u'foo']), ({
'c': ({
u'eggs': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--bsomething', u'foo']), ({
'c': ({
u'eggs': u'foo'
}, [])
}, []))
def test_options(self):
p = Parser(options={
'foo': Option('f'),
'bar': Option(long='bar'),
'baz': Option('b', 'baz')
},
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContainsAll(output, [
u'usage: script [options]', u'Options:', u' -f', u' --bar',
u' -b --baz'
])
def test_getattr(self):
p = Parser(options={'activate': Option('a')},
commands={
'foo':
Command(options={
'spam': Option('b'),
'eggs': Option('c')
})
})
p.activate
p.foo
p.foo.spam
p.foo.eggs
def test_commands(self):
p = Parser(commands={
'foo': Command(short_description=u'foo description'),
'bar': Command(short_description=u'bar description')
},
description=u'The script description',
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContainsAll(output, [
u'usage: script [commands]', p.long_description, u'Commands:',
u' foo', p.commands['foo'].short_description, u' bar',
p.commands['bar'].short_description
])
def test_alternative_options(self):
p = Parser(options={
'stack': Option(long='stack'),
'stash': Option(long='stash')
},
out_file=self.out_file)
for option in [u'--s', u'--st', u'--sta']:
self.assertRaises(SystemExit, p.evaluate, [option])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script [options]')
self.assertContains(
output,
u'option "{0}" does not exist, did you mean?'.format(option))
self.assertContains(output, u'--stack')
self.assertContains(output, u'--stash')
def test_alternative_commands(self):
p = Parser(commands={
'stack': Command(),
'stash': Command(),
},
out_file=self.out_file,
takes_arguments=False)
for cmd in [u's', u'st', u'sta']:
self.assertRaises(SystemExit, p.evaluate, [cmd])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script [commands]')
self.assertContains(
output,
u'command "{0}" does not exist, did you mean?'.format(cmd))
self.assertContains(output, u'stack')
self.assertContains(output, u'stash')
def test_commands_and_options(self):
p = Parser(commands={
'spam': Command(),
'eggs': Command()
},
options={
'foo': Option('f'),
'bar': Option('b')
},
out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContainsAll(output, [
u'usage: script [options] [commands]', u'Commands:', u' spam',
u' eggs', u'Options:', u' -f', u' -b'
])
def test_dynamically_adding_nodes(self):
p = Parser()
p.commands['foo'] = Command()
p.commands['foo'].options['a'] = BooleanOption('a')
p.options['bar'] = Option('b')
self.assertEquals(p.evaluate([u'-b', u'spam']), ({'bar': u'spam'}, []))
self.assertEquals(p.evaluate([u'foo']), ({
'foo': ({
'a': False
}, [])
}, []))
self.assertEquals(p.evaluate([u'foo', u'-a']), ({
'foo': ({
'a': True
}, [])
}, []))
def test_dynamically_adding_nodes(self):
p = Parser()
p.commands['foo'] = Command()
p.commands['foo'].options['a'] = BooleanOption('a')
p.options['bar'] = Option('b')
self.assertEquals(p.evaluate([u'-b', u'spam']), ({'bar': u'spam'}, []))
self.assertEquals(
p.evaluate([u'foo']),
({'foo': ({'a': False}, [])}, [])
)
self.assertEquals(
p.evaluate([u'foo', u'-a']),
({'foo': ({'a': True}, [])}, [])
)
def test_abbreviations(self):
c = Command(options={
'stack': Option(long='stack'),
'stash': Option(long='stash')
},
commands={
'stack': Command(),
'stash': Command()
})
p = Parser(commands=dict(c=c))
cp = [u'script_name']
for s in [u's', u'st', u'sta']:
cmd = [u'c', s]
result = ({'c': ({}, [s])}, [])
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate([u'c', u'stac']), ({
'c': ({
u'stack': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'stas']), ({
'c': ({
u'stash': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--stac', u'foo']), ({
'c': ({
u'stack': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--stas', u'foo']), ({
'c': ({
u'stash': u'foo'
}, [])
}, []))
def make_test(self, range, o):
p = Parser(options=dict(o=o))
for i in range:
self.assertEqual(p.evaluate([u'-o', unicode(i)]), ({'o': i}, []))
def test_nonexisting_short_option(self):
p = Parser(out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'-f'])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script')
self.assertContains(output, u'option "-f" does not exist')
def make_test(self, range, p):
parser = Parser(positionals=[p])
for i in range:
self.assertEqual(parser.evaluate([unicode(i)]), ({}, [i]))
def test_nonexisting_command(self):
p = Parser(out_file=self.out_file, takes_arguments=False)
self.assertRaises(SystemExit, p.evaluate, [u'foo'])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script')
self.assertContains(output, u'command "foo" does not exist')
def make_test(self, range, p):
parser = Parser(positionals=[p])
for i in range:
self.assertEqual(parser.evaluate([unicode(i)]), ({}, [i]))
def test_evaluate(self):
p = Parser(positionals=[Positional('foo')])
self.assertEquals(p.evaluate([u'spam']), ({}, [u'spam']))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from opts import Parser, Option
import ConfigParser, os, sys, datetime, subprocess
parser = Parser(description=u"Mail autoresponse filter for postfix", options={
"sender": Option("s", "sender",
short_description=u"Sender of the mail"),
"user": Option("r", "recipient",
short_description=u"Recipient of the mail"),
"sasl": Option("S", "sasl-username",
short_description=u"SASL username"),
"clientIP": Option("i", "client-ip",
short_description=u"Client IP address (optional))"),
"configFile": Option("c", "config",
short_description=u"Config file to read (default '/etc/autoresponder.conf')",
default="/etc/autoresponder.conf")
})
# parse command line
settings, arguments = parser.evaluate()
if (len(settings.keys()) == 0):
parser.evaluate(["help"])
# user name
try:
userName = settings["user"]
except KeyError:
print "You have to define a user by using -r or --recipient"
exit(1)
def make_test(self, range, o):
p = Parser(options=dict(o=o))
for i in range:
self.assertEqual(p.evaluate([u'-o', unicode(i)]), ({'o': i}, []))
def test_only_commands(self):
p = Parser(commands={'foo': Command()}, out_file=self.out_file)
self.assertRaises(SystemExit, p.evaluate, [u'help'])
output = self.out_file.getvalue()
self.assertContains(output, u'usage: script [commands]')
def main():
parser = Parser()
config = parser.config
for param, value in config.__dict__.items():
print(param + '.' * (50 - len(param) - len(str(value))) + str(value))
print()
# Load previous checkpoint if it exists
checkpoint = load_latest(config)
# Create model
model = load_model(config, checkpoint)
# print number of parameters in the model
n_params = sum([param.view(-1).size()[0] for param in model.parameters()])
print('Total number of parameters: \33[91m{}\033[0m'.format(n_params))
# Load train and test data
train_loader, valid_loader, test_loader = Loader(config)
n_batches = int(len(train_loader.dataset.train_data) / config.batch_size)
# save the configuration
with open(os.path.join(config.save, 'log.txt'), 'w') as file:
json.dump('json_stats: ' + str(config.__dict__), file)
# Instantiate the criterion, optimizer and learning rate scheduler
criterion = torch.nn.CrossEntropyLoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(),
lr=config.LR,
momentum=config.momentum,
weight_decay=config.weight_decay,
nesterov=config.nesterov)
start_time = 0
if checkpoint is not None:
start_epoch = checkpoint['time'] + 1
optimizer.load_state_dict(checkpoint['optimizer'])
if config.lr_shape == 'multistep':
scheduler = MultiStepLR(optimizer, milestones=[81, 122], gamma=0.1)
elif config.lr_shape == 'cosine':
if checkpoint is not None:
scheduler = checkpoint['scheduler']
else:
scheduler = CosineAnnealingRestartsLR(optimizer,
1,
config.T_e,
T_mul=config.T_mul)
# The trainer handles the training loop and evaluation on validation set
trainer = Trainer(model, criterion, config, optimizer, scheduler)
epoch = 1
while True:
# Train for a single epoch
train_top1, train_loss, stop_training = trainer.train(
epoch, train_loader)
# Run model on the validation and test set
valid_top1 = trainer.evaluate(epoch, valid_loader, 'valid')
test_top1 = trainer.evaluate(epoch, test_loader, 'test')
current_time = time.time()
results = {
'epoch': epoch,
'time': current_time,
'train_top1': train_top1,
'valid_top1': valid_top1,
'test_top1': test_top1,
'train_loss': float(train_loss.data),
}
with open(os.path.join(config.save, 'results.txt'), 'w') as file:
json.dump(str(results), file)
file.write('\n')
print(
'==> Finished epoch %d (budget %.3f): %7.3f (train) %7.3f (validation) %7.3f (test)'
% (epoch, config.budget, train_top1, valid_top1, test_top1))
if stop_training:
break
epoch += 1
if start_time >= config.budget:
trainer.evaluate(epoch, test_loader, 'test')
else:
save_checkpoint(int(config.budget), trainer.model, trainer.optimizer,
trainer.scheduler, config)
def test_evaluate(self):
p = Parser(positionals=[Positional('foo')])
self.assertEquals(p.evaluate([u'spam']), ({}, [u'spam']))
