def main():
parser, args = parseArgs()
if len(sys.argv) > 1:
resolver(args.input, args.output, args.justificado, args.guion)
else:
parser.print_help(sys.stderr)
sys.exit()
def communism(bot, update):
amount, reason = parseArgs(update.message, [ARG_AMOUNT, ARG_REST],
[None, ""],
"\nUsage: /communism <amount> [reason ...]")
sender = getOrCreateUser(update.message.from_user)
id = str(sender['id'])
if id in communisms:
update.message.reply_text("You already have a communism in progress")
return
communism = Communism(sender, amount, reason)
communism.message = update.message.reply_text(
str(communism), reply_markup=communism.message_markup)
communisms[id] = communism
def pay(bot, update):
amount, reason = parseArgs(update.message, [ARG_AMOUNT, ARG_REST],
[None, ""],
"\nUsage: /pay <amount> [reason ...]")
sender = getOrCreateUser(update.message.from_user)
id = str(sender['id'])
if id in pays:
update.message.reply_text("You already have a pay in progress")
return
pay = Pay(sender, amount, reason)
pay.message = update.message.reply_text(str(pay),
reply_markup=pay.message_markup)
pays[id] = pay
def send(bot, update):
args = parseArgs(update.message, [ARG_AMOUNT, ARG_USER], [None, None],
"\nUsage: /send <amount> <user>")
sender = getOrCreateUser(update.message.from_user)
receiver = args[1]
amount = args[0]
if sender == receiver:
update.message.reply_text("You cannot send money to yourself")
return
createTransaction(sender, -amount, "sent to {}".format(receiver['name']))
createTransaction(receiver, amount,
"received from {}".format(sender['name']))
update.message.reply_text("OK, you sent {}€ to {}" \
.format(amount / float(100), receiver['name']))
def getAmountHelper(msg, name) -> int:
args = parseArgs(msg, [ARG_INT], [1], "/{} [amount]".format(name))
if isinstance(args[0], int):
if args[0] == 0:
msg.reply_text("You can't consume zero {}s".format(name))
return 0
elif args[0] < 0:
msg.reply_text(
"You can't consume a negative number of {}s".format(name))
return 0
elif args[0] > 10:
msg.reply_text(
"You can't consume more than 10 {}s at once!".format(name))
return 0
return args[0]
else:
msg.reply_text("Unknown parsing error")
return 0
def history(bot, update):
offset, count = parseArgs(update.message, [ARG_INT, ARG_INT], [0, 10],
"\nUsage: /history [offset = 0] [count = 10]")
user = getOrCreateUser(update.message.from_user)
entries = []
with open("transactions.log", "r") as fd:
for line in fd.readlines():
entry = json.loads(line)
if entry['user'] == user['id']:
entries.insert(0, entry)
texts = []
for entry in entries[offset:offset + count]:
time = datetime.datetime.fromtimestamp(
entry['timestamp']).strftime("%Y-%m-%d %H:%M")
texts.append("{} {:.2f}€ {}".format(time, entry['diff'] / float(100),
entry['reason']))
msg = "Transaction history for {}\n{}".format(user['name'],
"\n".join(texts))
update.message.reply_text(msg, disable_notification=True)
from args import parseArgs, getHelpStr, CLArgument
description = (
"Usage: length_filter.py [options] min_length(int) in1.{fa.fq} [in2.{fa,fq} ...]\n\n"
"Filter reads by their lengths"
)
argument_list = [["maxlen", "maxlen", int, -1, "Maximum length of reads"]]
arguments = map(CLArgument._make, argument_list)
if not len(sys.argv) > 2:
sys.exit(getHelpStr(description, arguments) + "\n")
(p_arg_map, args_remaining) = parseArgs(sys.argv[1:], arguments)
minlen = int(args_remaining[0])
files = args_remaining[1:]
if not all(map(os.path.exists, files)):
sys.exit("Not all files exist")
file_readers = starmap(fileIterator, zip(files, map(iteratorFromExtension, files)))
filt_cond = lambda record: seqlen(record) > minlen
if p_arg_map["maxlen"] > 1:
filt_cond = lambda record: seqlen(record) > minlen and seqlen(record) <= p_arg_map["maxlen"]
],
[
"counts", "counts", argflag, False,
("Graph counts instead of bases ie. number of reads")
],
[
"out", "out", str, "cellstats.pdf",
("Output filename. Default: 'cellstats.pdf'")
]]
arguments = map(CLArgument._make, argument_list)
if not len(sys.argv) > 1:
sys.exit(getHelpStr(description, arguments) + "\n")
(p_arg_map, args_remaining) = parseArgs(sys.argv[1:], arguments)
if not len(args_remaining) >= 1:
sys.exit(getHelpStr(description, arguments) + "\n")
title = args_remaining[0]
infiles = args_remaining[1:]
cellnames = map(lambda f: "_".join(f.split(".")[0].split("_")[:2]), infiles)
fit_gen = lambda filename: fileIterator(filename, lineItemIterator)
file_iterators = map(fit_gen, infiles)
def getBasesFromLineArr(arr):
if not bool(arr):
def getArgs():
parserSetup = {
"description":
"Create animations programatically from a psd file.",
"args": [
{
"flags": ["-s", "--script-path"],
"options": {
"type": Path,
"required": True,
"metavar": "Path",
"dest": "script_path",
"help": "Path to animation script file"
}
},
{
"flags": ["-o", "--output-path"],
"options": {
"default":
None,
"type":
Path,
"metavar":
"Path",
"dest":
"output_path",
"help":
"Animation output path (default: output.avi for video, output.png for textures)"
}
},
{
"flags": ["-p", "--psd-path"],
"options": {
"default": None,
"type": Path,
"metavar": "Path",
"dest": "psd_path",
"help":
"Path to psd file that will be used to generate images"
}
},
{
"flags": ["-i", "--image-cache"],
"options": {
"default": Path("./image_cache"),
"type": Path,
"metavar": "Path",
"dest": "directory",
"help":
"Path to the image cache (defaults to ./image_cache)"
}
},
{
"flags": ["--clear-cache"],
"options": {
"dest": "clear_cache",
"action": "store_true",
"help": "Clears the image cache"
}
},
{
"flags": ["--fps"],
"options": {
"dest": "fps",
"type": int,
"default": 24,
"metavar": "int",
"help": "Sets the output frames per second (default: 24)"
}
},
{
"flags": ["--speed"],
"options": {
"dest":
"speed_multiplier",
"type":
float,
"default":
1.0,
"metavar":
"float",
"help":
"Set the speed multiplier for the output (default: 1.0)"
}
},
{
"flags": ["--codec"],
"options": {
"dest":
"codec",
"type":
str,
"default":
"mp4v",
"metavar":
"codec",
"help":
"Sets the codec used when generating output video (default: mp4v)"
}
},
{
"flags": ["--dont-store"],
"options": {
"dest":
"store_new",
"action":
"store_false",
"help":
"If set newly generated images will not be stored to the image directory"
}
},
{
"flags": ["-v", "--verbose"],
"options": {
"dest": "verbose",
"action": "store_true",
"help": "Enable verbose output"
}
},
{
"flags": ["--print-states"],
"options": {
"dest": "print_states",
"action": "store_true",
"help": "Print the full list of parsed states"
}
},
{
"flags": ["--no-output"],
"options": {
"dest": "no_output",
"action": "store_true",
"help":
"Script will be parsed, but no output will be created"
}
},
{
"flags": ["-t", "--create-texture"],
"options": {
"dest":
"create_texture",
"action":
"store_true",
"help":
"Instead of a video file, output animation as a tiled texture image"
}
},
{
"flags": ["--texture-layout"],
"options": {
"dest": "texture_layout",
"default": "square",
"choices": ("square", "horizontal", "vertical"),
"help": "Sets texture image layout (default: square)"
}
},
{
"flags": ["--texture-dimensions"],
"options": {
"dest":
"texture_dimensions",
"metavar":
"dimension list",
"default":
None,
"help":
"Takes a list of one or more widthXheight pairs for the output dimensions of the texture. Defaults to full scale. Example: --texture-dimensions 1280x800,1080x720"
}
},
{
"flags": ["--force-vector"],
"options": {
"dest":
"force_vector",
"action":
"store_true",
"help":
"enables force vector mode in psd-tools compositing. Can solve some rending problems, but is very slow."
}
},
]
}
args = parseArgs(parserSetup)
#Texture dimension validation and extraction
if args.texture_dimensions is not None:
try:
dims = []
for pair in args.texture_dimensions.split(","):
width, _, height = pair.strip().lower().partition("x")
dims.append((int(width), int(height)))
args.texture_dimensions = dims
except Exception:
ArgumentTypeError("Invalid texture dimensions")
#Speed multiplier validation
if args.speed_multiplier <= 0:
raise ArgumentTypeError("speed-multiplier must be a positive value")
#Use the given output path, or default to output/out.{avi, png} depending on if we are creating a texture or video
if args.output_path is None:
args.output_path = Path(
"./output/out.png") if args.create_texture else Path(
"./output/out.avi")
return args
# UPDATE LEARNER
if 'observeTransition' in dir(agent):
agent.observeTransition(environment,state, action, reward)
returns += reward * totalDiscount
gamma = agent.getGamma(agent,state)
totalDiscount *= gamma
environment.state = nextState
######################################################
#### This runs q-learning with specified arguments####
######################################################
parameters = args.parseArgs(sys.argv[1:])
if parameters['m'] == 'old':
data = oldData()
if parameters['m'] == 'young':
data = youngData()
environment = animalMDP.animalMDP(data)
rat = agent.ratAgent(environment,parameters['e'],parameters['a'],parameters['d'])
startState= MDP.State('f2',1,0,0,None,0)
iterations = 100
with open('decisions.txt','w') as fi:
fi.write('0,')
if iterations > 0:
print
#!/usr/bin/env python
"""
Rally client.
"""
import sys
import os
from config import RallyCliConfig
from client import RallyClient
import args
options = [opt for opt in sys.argv[1:] if opt.startswith('--')]
if __name__ == "__main__":
args = args.parseArgs()
config = RallyCliConfig(args)
client = RallyClient(config)
getattr(client, args.command.lower()).__call__(args)
from nucio import lineRecordIterator, M4Record, M4RecordTypes, lineItemIterator
from args import arglist, parseArgs, getHelpStr, CLArgument, argflag
description = ("lengthhist.py [options] title alginments.m4 [alignments2.m4...]\n"
"Plot Make histograms from alignment (nucmer show-coords) "
"files")
argument_list = [["labels","labels",arglist,["Ectools","PacbioToCA"], "Labels for each dataset"],
["ymax", "ymax", int, -1, "Maximum Y-value"],
["lenfiles", "lenfiles", int, -1, ("Input files are just a column of lengths, "
"argument specifies the column")]]
args = map(CLArgument._make, argument_list)
(parg_map, args_remaining) = parseArgs(sys.argv[1:],args)
if not len(args_remaining) >= 3:
sys.exit(getHelpStr(description,args) + "\n")
title = args_remaining[0]
igetter = attrgetter("qseqlength")
flens = []
for fname in args_remaining[1:]:
with open(fname) as fh:
if parg_map["lenfiles"] < 0:
records = lineRecordIterator(fh, M4Record, M4RecordTypes)
flens.append( map(igetter, records) )
else:
getter = itemgetter(parg_map["lenfiles"])
# preprocessing
cropped_image = tf.random_crop(raw_image, [args.img_crop_height, args.img_crop_width, args.img_depth], name='cropped_image')
image = tf.image.resize_images(cropped_image, [args.output_height, args.output_width])
# generate batches
image_batch = tf.train.shuffle_batch([image], args.batch_size, capacity=4 * args.batch_size,
min_after_dequeue=args.batch_size, num_threads=args.n_threads,
name='image_batch')
return tf.cast(image_batch, tf.float32)
if __name__ == '__main__':
import traceback
import sys
from args import parseArgs
args = parseArgs()
image_batch = None
label_batch = None
if args.dataset == 'mnist':
image_batch, label_batch = loadData(args)
else:
image_batch = loadData(args)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
print 'Trying to load 100 data batches'
for i in xrange(100):
