def validate_modes(args_):
possible_values = ('google', 'bing')
values = [value.lower() for value in args_['--web']]
if len(values) > len(possible_values):
raise docopt.DocoptExit('Too many -w options.')
if len(values) > len(set(values)):
raise docopt.DocoptExit('Some -w options are repeated.')
for value in values:
if value not in possible_values:
raise docopt.DocoptExit('Invalid -w option: "{}"'.format(value))
return values
def validate_timeout(args_):
timeout = args_['--timeout']
try:
timeout = int(timeout)
except ValueError:
raise docopt.DocoptExit('Timeout has to be a number.')
if timeout < 0:
raise docopt.DocoptExit('Timeout has to be 0 or greater.')
if timeout > MAX_TIMEOUT:
raise docopt.DocoptExit(
'Timeout has to be {} or less.'.format(MAX_TIMEOUT))
return timeout
def extras_patch(help, version, options, doc):
"""Patch of docopt.extra handler.
Patch for docopt's 'extras' function is needed, as it is hard
sys-exiting the bot after '--help/-h' or '--version' commands
"""
exc = None
if help and any(
(o.name in ('-h', '--help')) and o.value for o in options):
exc = _docopt.DocoptExit()
exc.args = (doc.strip("\n"), )
if version and any(o.name == '--version' and o.value for o in options):
exc = _docopt.DocoptExit()
exc.args = (version, )
if exc is not None:
raise exc
def validate_kwargs(args_):
modes = validate_modes(args_)
if modes:
try:
counts = list(map(int, args_['--count']))
if not counts:
counts = [DEFAULT_COUNTS[mode] for mode in modes]
if len(counts) != len(modes):
raise docopt.DocoptExit(
'Option "-c" must be specified for every "-w".')
return {
'count': counts,
}
except Exception as e:
raise docopt.DocoptExit(
'Unexpected error with "-c" option: {}'.format(e))
return {}
def validate_input(args_):
in_file = args_['--input']
if in_file is None:
return in_file
if in_file == '+' and validate_modes(args_):
return in_file
exists = os.path.isfile(in_file)
if not exists:
raise docopt.DocoptExit('Input file does not exist.')
return in_file
def _configure_log(verbosity):
levels = {
'0': logging.CRITICAL,
'1': logging.ERROR,
'2': logging.WARNING,
'3': logging.INFO,
'4': logging.DEBUG,
}
if verbosity not in levels.keys():
raise docopt.DocoptExit(f'--verbosity not one of 0, 1, 2, 3, 4')
logging.basicConfig(level=levels[verbosity], format=LOG_FORMAT)
def main(argv=None):
args = docopt.docopt(__doc__, version='1', argv=argv)
try:
if args['set']:
set_current_brightness(args['<value>'])
else:
print_current_brightness()
except ValueError as e:
raise docopt.DocoptExit(str(e))
def validate_header(args_):
if args_['--header'] and args_['--noheader']:
raise docopt.DocoptExit('Specify either -e or -n but not both.')
exists, is_stdout, append, force = _output_args(args_)
is_file = not is_stdout
actually_appending = exists and append
header = is_file and not actually_appending
if args_['--header']:
header = True
if args_['--noheader']:
header = False
return header
def process_sample(name, initial_ng_uL, args):
initial_nM = initial_ng_uL * 1e6 / get_molecular_weight(name)
if args['--target-conc'].endswith('x'):
target_nM = 300 * float(args['--target-conc'][:-1])
else:
target_nM = float(args['--target-conc'])
if initial_nM < target_nM:
print("Warning: Cannot reach {:.1f} nM!\n".format(target_nM))
target_nM = initial_nM
if args['--target-volume']:
target_uL = float(args['--target-volume'])
sgrna_to_add = target_nM * target_uL / initial_nM
water_to_add = target_uL - sgrna_to_add
elif args['--target-water']:
water_to_add = float(args['--target-water'])
sgrna_to_add = water_to_add * target_nM / (initial_nM - target_nM)
elif args['--target-sgrna']:
sgrna_to_add = float(args['--target-sgrna'])
water_to_add = initial_nM * sgrna_to_add / target_nM - sgrna_to_add
elif args['--print-nM']:
print('{:>.2f} nM'.format(initial_nM))
return
else:
raise docopt.DocoptExit("""\
Must specify one of:
-v, --target-volume <uL>
-r, --target-sgrna <uL>
-w, --target-water <uL>
-p, --print-nM
""")
max_sgrna = args['--max-sgrna']
if max_sgrna is not None and float(max_sgrna) < sgrna_to_add:
sgrna_to_add *= float(max_sgrna) / sgrna_to_add
water_to_add *= float(max_sgrna) / sgrna_to_add
print('{:>6.2f} μL {:.1f} ng/uL {}'.format(sgrna_to_add, initial_ng_uL,
name))
print('{:>6.2f} μL nuclease-free water'.format(water_to_add))
print(30 * '─')
print('{:>6.2f} μL {:.1f} nM {}'.format(sgrna_to_add + water_to_add,
target_nM, name))
def main(self):
args = docopt.docopt(
__doc__, version=molecule.__version__, options_first=True)
command_name = args.get('<command>')
command_args = {} if args.get('<args>') is None else args.pop('<args>')
try:
command_module = getattr(command, command_name)
command_clazz = getattr(command_module, command_name.capitalize())
except AttributeError:
raise docopt.DocoptExit()
c = command_clazz(command_args, args)
util.sysexit(c.execute()[0])
def do(self):
name, auth, auth_key, priv, priv_key = get_args(self.args)
if bool(auth) != bool(auth_key):
raise docopt.DocoptExit('One of `auth` and `auth_key` is missing.')
if bool(priv) != bool(priv_key):
raise docopt.DocoptExit('One of `priv` and `priv_key` is missing.')
if priv and priv_key:
level = enums.SecurityLevel.AUTH_PRIV
else:
level = enums.SecurityLevel.AUTH_NO_PRIV
if not check_length(auth_key):
raise snmp_ex.UserInvalidPasswordError(
'Auth key length is {}, should be 8 to 24 '
'characters'.format(len(auth_key)))
if priv_key and not check_length(priv_key):
raise snmp_ex.UserInvalidPasswordError(
'Priv key length is {}, should be 8 to 24 '
'characters'.format(len(priv_key)))
access.Access().update_v3_user(name, level, auth, auth_key, priv,
priv_key)
def main():
"""Main cli entry point for distributing cli commands."""
args = docopt.docopt(__doc__,
options_first=True,
version=version.VersionInfo('ospt').release_string())
cmd_name = args.pop('<command>')
cmd_args = args.pop('<args>')
cmd_class = commands.CMD_DICT.get(cmd_name, None)
if cmd_class is None:
raise docopt.DocoptExit(
message="Not supported command: {}".format(cmd_name))
cmd_args = [cmd_name] + cmd_args
cmd = cmd_class(cmd_args, args)
return cmd.do()
def main():
"""Main cli entry point for distributing cli commands."""
args = docopt.docopt(__doc__,
version=snmpagent_unity.__version__,
options_first=True,
help=True)
cmd_name = args.pop('<command>')
cmd_args = args.pop('<args>')
cmd_class = commands.CMD_DICT.get(cmd_name, None)
if cmd_class is None:
raise docopt.DocoptExit(
message="Not supported command: {}".format(cmd_name))
cmd_args = [cmd_name] + cmd_args
cmd = cmd_class(cmd_args, args)
return cmd.do()
def main(self):
command_name = self.args.pop('<command>')
argv = self.args.pop('<args>')
if command_name in BaseCommand.COMMAND_MAP.keys():
command_class = self.get_command_class(command_name)
command = command_class(command_name, argv)
command.execute()
elif command_name == 'help':
if len(argv) == 1:
subcommand = argv[0]
if subcommand in BaseCommand.COMMAND_MAP.keys():
subcommand_class = self.get_command_class(subcommand)
exit(subcommand_class.__doc__)
sys.exit(call(['lpconnector', '--help']))
else:
raise docopt.DocoptExit("%r is not a valid command. See `lpconnector help`." % command_name)
def execute(self):
command_name = self.options.pop("<command>")
# Retrieve the command arguments.
command_args = self.options.pop("<args>")
if command_args is None:
command_args = {}
# Retrieve the class from the 'commands' module.
try:
command_func = getattr(self, command_name)
except AttributeError:
print(f"Unknown command. {command_name}.")
raise docopt.DocoptExit()
cmd_docstring = inspect.getdoc(command_func)
command_options = docopt.docopt(cmd_docstring,
argv=command_args,
options_first=False)
# Execute the command.
print("Execute the command")
command_func(command_options)
def get_opts():
"""Creates an argument parser and returns the arguments it has parsed
"""
import docopt
usage = """bootstrap-vz
Usage: bootstrap-vz [options] MANIFEST
Options:
--log <path> Log to given directory [default: /var/log/bootstrap-vz]
If <path> is `-' file logging will be disabled.
--pause-on-error Pause on error, before rollback
--dry-run Don't actually run the tasks
--color=auto|always|never
Colorize the console output [default: auto]
--debug Print debugging information
-h, --help show this help
"""
opts = docopt.docopt(usage)
if opts['--color'] not in ('auto', 'always', 'never'):
raise docopt.DocoptExit('Value of --color must be one of auto, always or never.')
return opts
def run(self):
raise docopt.DocoptExit()
def main():
args = docopt.docopt(__doc__, version='none')
with open(args['<docopt_file>'], 'r') as f:
args['<docopt_file>'] = f.read()
template_h_name = args['--template_h']
template_c_name = args['--template_c']
args['template_h_obj'] = read_template_file_contents(args['--template_h'])
args['template_c_obj'] = read_template_file_contents(args['--template_c'])
doc = args['<docopt_file>']
usage = docopt.printable_usage(doc)
all_options = docopt.parse_defaults(doc)
pattern = docopt.parse_pattern(docopt.formal_usage(usage), all_options)
prompt = usage.split()[1].strip()
usage_lines = [x.replace(prompt, "") for x in usage.split('\n')[1:]]
tokens = []
commands = []
# I'm not sure why we have to reach in here, but it "works"
required_commands = pattern.children[0].children
for idx, required in enumerate(required_commands):
parts = [
o.name for o in required.children if isinstance(o, docopt.Command)
]
if not parts:
continue
# "help" is a special case? So exclude?
if "help" in parts:
continue
tokens.extend(parts)
docopt_text = usage_lines[idx].strip(
) if idx < len(usage_lines) else None
commands.append(Command(parts, docopt_text))
if args['--short'] is not None:
doc = doc.replace(prompt + " ", args['--short'] + " ")
rendering = Rendering(args['<module_name>'], commands, prompt, doc,
args['--multithreaded'])
if len(rendering.tokens) > 64:
raise docopt.DocoptExit(
'Too many unique tokens ({}) for Docopt μC (max:64)'.format(
len(rendering.tokens)))
too_long_commands = []
for cmd in rendering.commands:
if len(cmd.parts) > 6:
too_long_commands.append(cmd)
if too_long_commands:
summaries = [
' > {}'.format(" ".join(p for p in c.parts))
for c in too_long_commands
]
raise docopt.DocoptExit('\n'.join([
'The following commands are too long for Docopt μC (max: 6 long):'
] + summaries))
output_h_filename = args['--template_h'].replace(args['--template_prefix'],
rendering.include_name)
output_c_filename = args['--template_c'].replace(args['--template_prefix'],
rendering.include_name)
output_h_filename = os.path.join(args['--output_dir'], output_h_filename)
output_c_filename = os.path.join(args['--output_dir'], output_c_filename)
with open(output_h_filename, 'w') as f:
f.write(args['template_h_obj'].render(rendering=rendering))
with open(output_c_filename, 'w') as f:
f.write(args['template_c_obj'].render(rendering=rendering))
if args["--no-docopt-args-h"] is False:
# copy the docopt header file to the output directory
docopt_args = pkg_resources.resource_filename(
__name__, 'templates/docopt_args.h')
shutil.copy2(docopt_args, args['--output_dir'])
def briltag_main(progname=sys.argv[0]):
docstr = '''
usage:
briltag (-h|--help|--version)
briltag [--debug|--warn] <command> [<args>...]
commands:
listdata list data tags
listiov list norm tags
insertiov insert norm tag
insertdata insert data tag
See 'briltag <command> --help' for more information on a specific command.
'''
argv = sys.argv[1:]
args = docopt.docopt(docstr,
argv,
help=True,
version=brilws.__version__,
options_first=True)
if args['--debug']:
log.setLevel(logging.DEBUG)
elif args['--warn']:
log.setLevel(logging.WARNING)
log.debug('global arguments: %s', args)
cmmdargv = [args['<command>']] + args['<args>']
log.debug('command arguments: %s', cmmdargv)
parseresult = {}
try:
if args['<command>'] == 'listdata':
import briltag_listdata
parseresult = docopt.docopt(briltag_listdata.__doc__,
argv=cmmdargv)
parseresult = briltag_listdata.validate(parseresult)
##parse selection params
pargs = clicommonargs.parser(parseresult)
dbschema = ''
if not pargs.dbconnect.find('oracle') != -1:
dbschema = 'cms_lumi_prod'
dbengine = create_engine(pargs.connecturl)
tags = api.data_gettags(dbengine, schemaname=dbschema)
header = [
'datatagnameid', 'datatagname', 'creationutc', 'comments'
]
ptable = display.create_table(header, header=True)
for tid, tval in tags.items():
display.add_row([str(tid), tval[0], tval[1], tval[2]],
ptable=ptable)
display.show_table(ptable, 'tab')
elif args['<command>'] == 'listiov':
import briltag_listiov
parseresult = docopt.docopt(briltag_listiov.__doc__, argv=cmmdargv)
parseresult = briltag_listiov.validate(parseresult)
pargs = clicommonargs.parser(parseresult)
dbschema = ''
if not pargs.dbconnect.find('oracle') != -1:
dbschema = 'cms_lumi_prod'
dbengine = create_engine(pargs.connecturl)
istypedefault = False
if parseresult.has_key('--isdefault'):
istypedefault = True
if not pargs.name:
iovtaglist = api.iov_gettags(dbengine,
datasource=pargs.lumitype,
applyto=pargs.applyto,
isdefault=istypedefault,
schemaname=dbschema)
header = [
'tagname', 'tagid', 'creationutc', 'applyto', 'datasource',
'isdefault', 'comments'
]
ptable = display.create_table(header, header=True)
for tagname, tagcontents in iovtaglist.items():
display.add_row([
tagname,
str(tagcontents[0]), tagcontents[1], tagcontents[2],
tagcontents[3], tagcontents[4], tagcontents[5]
],
ptable=ptable)
display.show_table(ptable, 'tab')
else:
iovtagdata = api.iov_gettagdata(dbengine,
pargs.name,
schemaname=dbschema)
#print iovtagdata
header = ['since', 'func', 'payload', 'comments']
ptable = display.create_table(header, header=True)
for sincedata in iovtagdata:
since = sincedata[0]
func = sincedata[1]
payload = sincedata[2]
comments = sincedata[3]
display.add_row(['%d' % since, func, payload, comments],
ptable=ptable)
display.show_table(ptable, 'tab')
elif args['<command>'] == 'insertiov':
import briltag_insertiov
parseresult = docopt.docopt(briltag_insertiov.__doc__,
argv=cmmdargv)
parseresult = briltag_insertiov.validate(parseresult)
pargs = clicommonargs.parser(parseresult)
dbschema = ''
if not pargs.dbconnect.find('oracle') != -1:
dbschema = 'cms_lumi_prod'
dbengine = create_engine(pargs.connecturl)
istypedefault = False
if pargs.yamlobj.has_key('istypedefault'):
istypedefault = pargs.yamlobj['istypedefault']
iovtagname = ''
if pargs.yamlobj.has_key('name'):
iovtagname = pargs.yamlobj['name']
else:
ValueError('name cannot be empty')
applyto = 'lumi'
if pargs.yamlobj.has_key('applyto'):
applyto = pargs.yamlobj['applyto']
datasource = None
if pargs.yamlobj.has_key('datasource'):
datasource = pargs.yamlobj['datasource']
else:
raise ValueError('datasource cannot be empty')
comments = ''
if pargs.yamlobj.has_key('comments'):
comments = pargs.yamlobj['comments']
istypedefault = False
if pargs.yamlobj.has_key('istypedefault'):
istypedefault = True
iovdata = None
if pargs.yamlobj.has_key('since'):
iovdata = pargs.yamlobj['since']
else:
raise ValueError('since cannot be empty')
#print iovtagname,applyto,datasource,comments,istypedefault
iovtagid = api.iov_insertdata(dbengine,
iovtagname,
datasource,
iovdata,
applyto=applyto,
isdefault=istypedefault,
comments=comments,
schemaname=dbschema)
elif args['<command>'] == 'insertdata':
import briltag_insertdata
parseresult = docopt.docopt(briltag_insertdata.__doc__,
argv=cmmdargv)
parseresult = briltag_insertdata.validate(parseresult)
pargs = clicommonargs.parser(parseresult)
dbschema = ''
if not pargs.dbconnect.find('oracle') != -1:
dbschema = 'cms_lumi_prod'
dbengine = create_engine(pargs.connecturl)
name = pargs.name
if not name: raise NameError('--name cannot be empty')
datatagnameid = api.data_createtag(dbengine,
datatagname=name,
comments=pargs.comments,
schemaname=dbschema)
print 'created datatag %s , datatagnameid %ul , comments %s' % (
name, datatagnameid, pargs.comments)
else:
exit("%r is not a briltag command. See 'briltag --help'." %
args['<command>'])
except docopt.DocoptExit:
raise docopt.DocoptExit('Error: incorrect input format for ' +
args['<command>'])
except schema.SchemaError as e:
exit(e)
Find the largest prime factor of <value>.
"""
import docopt
import numpy as np
import math
def prime_numbers_upto(limit):
is_prime = np.array([True] * (limit - 1))
for c in np.arange(2, int(math.sqrt(limit)) + 1):
if is_prime[c - 2]:
is_prime[np.arange(c**2 - 2, limit - 1, c)] = False
candidates = np.arange(2, limit + 1)
return candidates[is_prime]
if __name__ == "__main__":
args = docopt.docopt(__doc__)
try:
value = int(args['<value>'])
except:
raise docopt.DocoptExit('<value> must be an integer')
primes = prime_numbers_upto(int(math.sqrt(value)))
for candidate in primes[::-1]:
if value % candidate == 0:
print candidate
exit()
import numpy as np
def fibonacci_below(limit):
fib_seq = []
if limit > 1:
fib_seq.append(1)
if limit > 2:
fib_seq.append(2)
if limit > 3:
next_elem = fib_seq[-1] + fib_seq[-2]
while next_elem < limit:
fib_seq.append(next_elem)
next_elem = fib_seq[-1] + fib_seq[-2]
return np.array(fib_seq)
if __name__ == "__main__":
args = docopt.docopt(__doc__)
try:
limit = int(args['<limit>'])
except:
raise docopt.DocoptExit('<limit> must be an integer')
fibs = fibonacci_below(limit)
even_fib_indices = np.arange(1, fibs.shape[0], 3)
even_fibs = fibs[even_fib_indices]
print even_fibs.sum()
current_row[i] = value
i += 1
palindromes = np.concatenate(palindromes_with_digits)
palindromes = np.unique(palindromes)
palindromes = palindromes[palindromes <= max_value]
palindromes = palindromes[palindromes >= min_value]
return palindromes
if __name__ == "__main__":
args = docopt.docopt(__doc__)
try:
digits = int(args['<digits>'])
except:
raise docopt.DocoptExit("'digits' must be a positive integer")
if digits < 1:
raise docopt.DocoptExit("'digits' must be a positive integer")
largest_number = 10**(digits) - 1
smallest_number = 10**(digits - 1)
largest_product = largest_number**2
smallest_product = smallest_number**2
candidates = palindromes_between(smallest_product, largest_product)[::-1]
for candidate in candidates:
factor = largest_number
while is_n_decimal_digits(
factor,
digits) and n_decimal_digits(candidate / factor) <= digits:
if candidate % factor == 0:
def validate_verbosity(args_):
if args_['--verbosity'] not in ('0', '1', '2', '3', '4'):
raise docopt.DocoptExit('Verbosity not one of: 0, 1, 2, 3, 4')
return int(args_['--verbosity'])
def validate_overwrite(args_):
exists, is_stdout, append, force = _output_args(args_)
if exists and not append and not force:
raise docopt.DocoptExit(
'Output file already exists. Overwrite: "-f" or append: "-a"')
return not append
def brilschema_main(progname=sys.argv[0]):
docstr = '''
usage:
brilschema (-h|--help)
brilschema --version
brilschema --checkforupdate
brilschema [--debug|--nowarning] <command> [<args>...]
commands:
create generate table creat/drop sql
loadmap load map data
loaddata load data
loadresult load result
See 'brilschema <command> --help' for more information on a specific command.
'''
args = {}
argv = sys.argv[1:]
args = docopt.docopt(docstr,
argv,
help=True,
version=brilws.__version__,
options_first=True)
if '--debug' in sys.argv:
log.setLevel(logging.DEBUG)
ch.setLevel(logging.DEBUG)
if args['--version']: print brilws.__version__
log.debug('global arguments: %s', args)
cmmdargv = [args['<command>']] + args['<args>']
log.debug('command arguments: %s', cmmdargv)
parseresult = {}
try:
if args['<command>'] == 'create':
import brilschema_create
parseresult = docopt.docopt(brilschema_create.__doc__,
argv=cmmdargv)
parseresult = brilschema_create.validate(parseresult)
columntypemap = {}
schemadatadef = {}
infile = parseresult['-i']
infilenamebase = os.path.basename(infile.name).split('.')[0]
suffix = parseresult['--suffix']
writeraccount = ''
if parseresult['-f'] == 'oracle':
columntypemap = api.oracletypemap
if parseresult.has_key('--writer'):
writeraccount = parseresult['--writer']
else:
columntypemap = api.sqlitetypemap
schemadatadef = yaml.load(parseresult['-i'])
print 'Creating drop sql file for: %s' % infilenamebase
api.drop_tables_sql(infilenamebase,
schemadatadef,
suffix=suffix,
dbflavor=parseresult['-f'])
print 'Creating create sql file for: %s' % infilenamebase
api.create_tables_sql(infilenamebase,
schemadatadef,
suffix=suffix,
dbflavor=parseresult['-f'],
writeraccount=writeraccount)
print 'Done'
elif args['<command>'] == 'loadmap':
import brilschema_loadmap
parseresult = docopt.docopt(brilschema_loadmap.__doc__,
argv=cmmdargv)
parseresult = brilschema_loadmap.validate(parseresult)
inengine = os.path.expanduser(parseresult['-i'])
outengine = os.path.expanduser(parseresult['-o'])
iniparser = SafeConfigParser()
if parseresult['--name'] == 'datatable':
d = api.DatatableMap()
elif parseresult['--name'] == 'amodetag':
d = api.AmodetagMap()
elif parseresult['--name'] == 'beamstatus':
d = api.BeamStatusMap()
result = d.from_sourcedb(inengine)
elif parseresult['--name'] == 'trgbit':
d = api.TrgBitMap()
elif parseresult['--name'] == 'hltconfig':
d = api.HltConfigMap()
elif parseresult['--name'] == 'l1seed':
d = api.L1SeedMap()
elif parseresult['--name'] == 'hltpath':
d = api.HLTPathMap()
elif parseresult['--name'] == 'trghltseed':
d = api.TrgHltSeedMap()
elif parseresult['--name'] == 'dataset':
d = api.DatasetMap()
elif parseresult['--name'] == 'hltstreamdataset':
d = api.HLTStreamDatasetMap()
if not os.path.isfile(inengine):
sourceurl = inengine
if sourceurl.find('oracle') != -1:
iniparser.read(
os.path.join(parseresult['-p'], 'readdb2.ini'))
sourcepasswd = parser.get(outengine, 'pwd')
sourceschema = parser.get(outengine, 'schema')
idx = sourceengine.find('@')
sourceurl = sourceengine[:idx] + ':' + sourcepasswd.decode(
'base64') + sourceengine[idx:]
inengine = create_engine(soureceurl)
result = d.from_sourcedb(inengine)
print result
if os.path.isfile(outengine):
d.to_csv(outengine, result)
else:
desturl = outengine
if desturl.find('oracle') != -1:
iniparser.read(
os.path.join(parseresult['-p'], 'authentication.ini'))
destpasswd = parser.get(outengine, 'pwd')
idx = outengine.find('@')
desturl = outengine[:idx] + ':' + destpasswd.decode(
'base64') + outengine[idx:]
outengine = create_engine(desturl)
d.to_brildb(outengine, result)
elif args['<command>'] == 'loaddata':
import brilschema_loaddata
parseresult = docopt.docopt(brilschema_loadmap.__doc__,
argv=cmmdargv)
parseresult = brilschema_loaddata.validate(parseresult)
incsv = os.path.expanduser(parseresult['-i'])
c = api.get_filepath_or_buffer(incsv)
if os.path.isfile(c):
pass
else:
pass
outengine = os.path.expanduser(parseresult['-o'])
iniparser = SafeConfigParser()
if parseresult['--name'] == 'fillinfo':
d = api.FillInfo()
if parseresult['--lumidb']:
d.from_lumidb(lumidbengine, fillnum)
print d
elif args['<command>'] == 'loadresult':
import brilschema_loadresult
iniparser = SafeConfigParser()
parseresult = docopt.docopt(brilschema_loadresult.__doc__,
argv=cmmdargv)
parseresult = brilschema_loadresult.validate(parseresult)
incsv = os.path.expanduser(parseresult['-i'])
runlsselect = api.parsecmsselectJSON(runlsselect)
lumidb = api.get_filepath_or_buffer(parseresult['--lumidb'])
if os.path.isfile(lumidb):
print lumidb
else:
lumidburl = lumidb
if lumidburl.find('oracle') != -1:
iniparser.read(
os.path.join(parseresult['-p'], 'authentication.ini'))
lumidbpasswd = parser.get(lumidburl, 'pwd')
idx = lumidburl.find('@')
lumidburl = lumidburl[:idx] + ':' + lumidbpasswd.decode(
'base64') + lumidburl[idx:]
lumidbengine = create_engine(lumidburl)
datasourcename = parseresult['--name'].lower()
d = api.LumiResult(datasourcename)
for run, lss in runlsselect:
print run, lss
#d.from_lumidb(lumidbengine,)
else:
exit("%r is not a brilschema command. See 'brilschema --help'." %
args['<command>'])
except docopt.DocoptExit:
raise docopt.DocoptExit('Error: incorrect input format for ' +
args['<command>'])
except schema.SchemaError as e:
exit(e)
if not parseresult.has_key('--debug'):
if parseresult.has_key('--nowarning'):
log.setLevel(logging.ERROR)
ch.setLevel(logging.ERROR)
else:
log.setLevel(logging.DEBUG)
ch.setLevel(logging.DEBUG)
log.debug('create arguments: %s', parseresult)
"""Project Euler problem 1 solution
Usage:
solution.py <limit>
Finds the sum of multiples of 3 and 5 up to <limit>
"""
import docopt
import numpy as np
def sum_multiples_below(limit, factors=[3, 5]):
total_sum = 0
for n in range(limit):
for factor in factors:
if n % factor == 0:
total_sum += n
break
return total_sum
if __name__ == "__main__":
args = docopt.docopt(__doc__)
try:
limit = int(args['<limit>'])
except:
raise docopt.DocoptExit("<limit> must be an integer")
print sum_multiples_below(limit)
