def main():
ap = buildArgumentParser()
args = ap.parse_args()
if (args.domain != "synth-synth" and args.domain != "real-synth" and args.domain != "real-real"):
print("Error, the domain of dataset must be one of: synth-synth, real-synth, real-real.")
return
if (args.fov_type != "fixed" and args.fov_type != "real"):
print("Error, field-of-view option might be either fixed, or real.")
return
dc = PatchesDatasetCreator(args)
dc.createDataset()
def main(argv):
options = argparse.parse_args(args)
appdirs = AppDirs(APPNAME, APPAUTHOR)
init_log(options.debug[0].lower(), appdirs)
# We need to initialize the data directories if this is a first-run
if not isdir(appdirs.user_data_dir):
from core import first_run
first_run.main(appdirs.user_data_dir)
# Now that the database exists, we can safely open the connection
open_db(appdirs)
if options.no_gui:
launch_console(options)
else:
launch_gui(options)
def main(argv=sys.argv[1:]):
args = argparse.parse_args(argv)
legal_commands = {
"init": cmd_init,
# "add": cmd_add,
"cat-file": cmd_cat_file,
# "checkout": cmd_checkout,
# "commit": cmd_commit,
# "hash-object": cmd_hash_object,
# "log": cmd_log,
# "ls-tree": cmd_ls_tree,
# "merge": cmd_merge,
# "rebase": cmd_rebase,
# "rev-parse": cmd_rev_parse,
# "rm": cmd_rm,
# "show-ref": cmd_show_ref,
# "tag": cmd_tag,
}
if args.command in legal_commands:
fn = legal_commands.get(args.command, cmd_not_found)
fn(args)
import argparse as ap
if __name__ == "__main__":
parser = ap.ArgumentParser()
# parser.add_argument("test", help="this is a test")
parser.add_argument("-v", help="run with debug logging", action="store_true") # optional
parser.add_argument("-action", help="specify action to take on EC2 instance: create, stop, start, delete, list, list-running",
default="list")
args = parser.parse_args()
# print(args.echo)
print("all arguments={}".format(args))
import argparse
if __name__ == "__main__":
ap = argparse.ArgumentParser()
ap.add_argument("--action", type=str, default="list-all", choices=["list-all", "list-running"], help="legume")
my_args = ap.parse_args()
print(my_args.action)
# todo below
# list-all is default
# start / stop - can take optional pem
# key - can take optional filename
# default filename needs to be set
#
# create - can take # of instances (not yet)
import sys
from itertools import groupby
from operator import itemgetter
from collections import Counter, OrderedDict
from rugis import dbscan, Distance, GPS2GCJ
import json
import argparse as parser
sys.path.append("./scipy")
from sklearn.cluster import MeanShift
parser = parser.ArgumentParser()
parser.add_argument("-a", "--act", type=str, required = True)
parser.add_argument("-d", "--date", type=str, help="run date")
parser.add_argument("-w", "--window", type=int, default=90, help="date window")
args = parser.parse_args()
"""
offline version, after mapper, you need groupby by the key
useage:
1. [calculate all location]
cat training_data.TXT|python aoi_loc_cluster_model_local.py --act "m"|sort -n |python aoi_loc_cluster_model_local.py --act "runModel" --date "20160516" --window 90
2. [calculate weekend location]
cat training_data.TXT|python aoi_loc_cluster_model_local.py --act "mWeekend"|sort -n |python aoi_loc_cluster_model_local.py --act "runModel" --date "20160516" --window 90
3. [calculate weekday location]
cat training_data.TXT|python aoi_loc_cluster_model_local.py --act "mWeekday"|sort -n |python aoi_loc_cluster_model_local.py --act "runModel" --date "20160516" --window 90
"""
def main():
global STATS
global VERSION_KEY
global CHANGEDCT
global shutdown_event
global finished_event
global bulkError_event
parser = argparse.ArgumentParser()
dataSource = parser.add_mutually_exclusive_group(required=True)
dataSource.add_argument("-f", "--file", action="store", dest="file",
default=None, help="Input CSV file")
dataSource.add_argument("-d", "--directory", action="store", dest="directory",
default=None, help="Directory to recursively search for CSV files -- mutually exclusive to '-f' option")
parser.add_argument("-e", "--extension", action="store", dest="extension",
default='csv', help="When scanning for CSV files only parse files with given extension (default: 'csv')")
parser.add_argument("-r", "--redo", action="store_true", dest="redo",
default=False, help="Attempt to re-import a failed import or import more data, uses stored metatdata from previous import (-o, -n, and -x not required and will be ignored!!)")
parser.add_argument("-v", "--verbose", action="store_true", dest="verbose",
default=False, help="Be verbose")
parser.add_argument("--vverbose", action="store_true", dest="vverbose",
default=False, help="Be very verbose (Prints status of every domain parsed, very noisy)")
parser.add_argument("-s", "--stats", action="store_true", dest="stats",
default=False, help="Print out Stats after running")
updateMethod = parser.add_mutually_exclusive_group()
updateMethod.add_argument("-x", "--exclude", action="store", dest="exclude",
default="", help="Comma separated list of keys to exclude if updating entry")
updateMethod.add_argument("-n", "--include", action="store", dest="include",
default="", help="Comma separated list of keys to include if updating entry (mutually exclusive to -x)")
parser.add_argument("-o", "--comment", action="store", dest="comment",
default="", help="Comment to store with metadata")
parser.add_argument("-u", "--es-uri", nargs="*", dest="es_uri",
default=['localhost:9200'], help="Location(s) of ElasticSearch Server (e.g., foo.server.com:9200) Can take multiple endpoints")
parser.add_argument("-p", "--index-prefix", action="store", dest="index_prefix",
default='whois', help="Index prefix to use in ElasticSearch (default: whois)")
parser.add_argument("-i", "--identifier", action="store", dest="identifier", type=int,
default=None, help="Numerical identifier to use in update to signify version (e.g., '8' or '20140120')")
parser.add_argument("-B", "--bulk-size", action="store", dest="bulk_size", type=int,
default=5000, help="Size of Bulk Elasticsearch Requests")
parser.add_argument("--optimize-import", action="store_true", dest="optimize_import",
default=False, help="If enabled, will change ES index settings to speed up bulk imports, but if the cluster has a failure, data might be lost permanently!")
parser.add_argument("-t", "--threads", action="store", dest="threads", type=int,
default=2, help="Number of workers, defaults to 2. Note that each worker will increase the load on your ES cluster since it will try to lookup whatever record it is working on in ES")
parser.add_argument("--bulk-serializers", action="store", dest="bulk_serializers", type=int,
default=1, help="How many threads to spawn to combine messages from workers. Only increase this if you're are running a lot of workers and one cpu is unable to keep up with the load")
parser.add_argument("--bulk-threads", action="store", dest="bulk_threads", type=int,
default=1, help="How many threads to spawn to send bulk ES messages. The larger your cluster, the more you can increase this")
parser.add_argument("--enable-delta-indexes", action="store_true", dest="enable_delta_indexes",
default=False, help="If enabled, will put changed entries in a separate index. These indexes can be safely deleted if space is an issue, also provides some other improvements")
options = parser.parse_args()
if options.vverbose:
options.verbose = True
options.firstImport = False
threads = []
work_queue = jmpQueue(maxsize=options.bulk_size * options.threads)
insert_queue = jmpQueue(maxsize=options.bulk_size * options.bulk_threads)
bulk_request_queue = jmpQueue(maxsize = 2 * options.bulk_threads)
stats_queue = mpQueue()
meta_index_name = '@' + options.index_prefix + "_meta"
data_template = None
template_path = os.path.dirname(os.path.realpath(__file__))
with open("%s/es_templates/data.template" % template_path, 'r') as dtemplate:
data_template = json.loads(dtemplate.read())
if options.identifier is None and options.redo is False:
print("Identifier required\n")
argparse.parse_args(['-h'])
elif options.identifier is not None and options.redo is True:
print("Redo requested and Identifier Specified. Please choose one or the other\n")
argparse.parse_args(['-h'])
es = connectElastic(options.es_uri)
metadata = None
previousVersion = 0
#Create the metadata index if it doesn't exist
if not es.indices.exists(meta_index_name):
if options.redo:
print("Cannot redo when no initial data exists")
sys.exit(1)
if data_template is not None:
data_template["template"] = "%s-*" % options.index_prefix
es.indices.put_template(name='%s-template' % options.index_prefix, body = data_template)
#Create the metadata index with only 1 shard, even with thousands of imports
#This index shouldn't warrant multiple shards
#Also use the keyword analyzer since string analsysis is not important
es.indices.create(index=meta_index_name, body = {"settings" : {
"index" : {
"number_of_shards" : 1,
"analysis" : {
"analyzer" : {
"default" : {
"type" : "keyword"
}
}
}
}
}
})
#Create the 0th metadata entry
metadata = { "metadata": 0,
"firstVersion": options.identifier,
"lastVersion": options.identifier,
"deltaIndexes": options.enable_delta_indexes,
}
es.create(index=meta_index_name, doc_type='meta', id = 0, body = metadata)
#Specially create the first index to have 2x the shards than normal
#since future indices should be diffs of the first index (ideally)
index_name = "%s-%s" % (options.index_prefix, options.identifier)
if options.enable_delta_indexes:
index_name += "-o"
es.indices.create(index=index_name,
body = {"settings": {
"index": {
"number_of_shards": int(data_template["settings"]["number_of_shards"]) * 2
}
}
})
options.firstImport = True
else:
try:
result = es.get(index=meta_index_name, id=0)
if result['found']:
metadata = result['_source']
else:
raise Exception("Not Found")
except:
print("Error fetching metadata from index")
sys.exit(1)
if options.redo is False: #Identifier is auto-pulled from db, no need to check
# Pre-emptively create index
index_name = "%s-%s" % (options.index_prefix, options.identifier)
if options.enable_delta_indexes:
index_name += "-o"
es.indices.create(index=index_name)
if options.identifier < 1:
print("Identifier must be greater than 0")
sys.exit(1)
if metadata['lastVersion'] >= options.identifier:
print("Identifier must be 'greater than' previous identifier")
sys.exit(1)
previousVersion = metadata['lastVersion']
# Pre-emptively create delta index
if options.enable_delta_indexes and previousVersion > 0:
index_name = "%s-%s-d" % (options.index_prefix, previousVersion)
es.indices.create(index=index_name)
else:
result = es.search(index=meta_index_name,
body = { "query": {
"match_all": {}
},
"sort":[
{"metadata": {"order": "asc"}}
]
})
if result['hits']['total'] == 0:
print("Unable to fetch entries from metadata index")
sys.exit(1)
previousVersion = result['hits']['hits'][-2]['_id']
options.previousVersion = previousVersion
# Change Index settings to better suit bulk indexing
optimizeIndexes(es, options)
index_list = es.search(index=meta_index_name,
body = { "query": {
"match_all": {}
},
"_source": "metadata",
"sort":[
{"metadata": {"order": "desc"}}
]
})
index_list = [entry['_source']['metadata'] for entry in index_list['hits']['hits'][:-1]]
options.INDEX_LIST = []
for index_name in index_list:
if options.enable_delta_indexes:
options.INDEX_LIST.append('%s-%s-o' % (options.index_prefix, index_name))
else:
options.INDEX_LIST.append('%s-%s' % (options.index_prefix, index_name))
if options.redo is False:
if options.exclude != "":
options.exclude = options.exclude.split(',')
else:
options.exclude = None
if options.include != "":
options.include = options.include.split(',')
else:
options.include = None
#Start worker threads
if options.verbose:
print("Starting %i worker threads" % options.threads)
for i in range(options.threads):
t = Process(target=process_worker,
args=(work_queue,
insert_queue,
stats_queue,
options),
name='Worker %i' % i)
t.daemon = True
t.start()
threads.append(t)
#Upate the lastVersion in the metadata
es.update(index=meta_index_name, id=0, doc_type='meta', body = {'doc': {'lastVersion': options.identifier}} )
#Create the entry for this import
meta_struct = {
'metadata': options.identifier,
'comment' : options.comment,
'total' : 0,
'new' : 0,
'updated' : 0,
'unchanged' : 0,
'duplicates': 0,
'changed_stats': {}
}
if options.exclude != None:
meta_struct['excluded_keys'] = options.exclude
elif options.include != None:
meta_struct['included_keys'] = options.include
es.create(index=meta_index_name, id=options.identifier, doc_type='meta', body = meta_struct)
else: #redo is True
#Get the record for the attempted import
options.identifier = int(metadata['lastVersion'])
try:
redo_record = es.get(index=meta_index_name, id=options.identifier)['_source']
except:
print("Unable to retrieve information for last import")
sys.exit(1)
if 'excluded_keys' in redo_record:
options.exclude = redo_record['excluded_keys']
else:
options.exclude = None
if 'included_keys' in redo_record:
options.include = redo_record['included_keys']
else:
options.include = None
options.comment = redo_record['comment']
STATS['total'] = int(redo_record['total'])
STATS['new'] = int(redo_record['new'])
STATS['updated'] = int(redo_record['updated'])
STATS['unchanged'] = int(redo_record['unchanged'])
STATS['duplicates'] = int(redo_record['duplicates'])
CHANGEDCT = redo_record['changed_stats']
if options.verbose:
print("Re-importing for: \n\tIdentifier: %s\n\tComment: %s" % (options.identifier, options.comment))
for ch in CHANGEDCT.keys():
CHANGEDCT[ch] = int(CHANGEDCT[ch])
#Start the reworker threads
if options.verbose:
print("Starting %i reworker threads" % options.threads)
for i in range(options.threads):
t = Process(target=process_reworker,
args=(work_queue,
insert_queue,
stats_queue,
options),
name='Worker %i' % i)
t.daemon = True
t.start()
threads.append(t)
#No need to update lastVersion or create metadata entry
# Start up the Elasticsearch Bulk Serializers
# Its job is just to combine work into bulk-sized chunks to be sent to the bulk API
# One serializer should be enough for a lot of workers, but anyone with a super large cluster might
# be able to run a lot of workers which can subsequently overwhelm a single serializer
es_serializers = []
for i in range(options.bulk_serializers):
es_serializer = Process(target=es_serializer_proc, args=(insert_queue, bulk_request_queue, options))
es_serializer.start()
es_serializers.append(es_serializer)
# Start up ES Bulk Shippers, each in their own process
# As far as I can tell there's an issue (bug? feature?) that causes every request made to ES to hinder the entire process even if it's in a separate python thread
# not sure if this is GIL related or not, but instead of debugging how the elasticsearch library or urllib does things
# its easier to just spawn a separate process for every connection being made to ES
for i in range(options.bulk_threads):
es_bulk_shipper = Process(target=es_bulk_shipper_proc, args=(bulk_request_queue, i, options))
es_bulk_shipper.daemon = True
es_bulk_shipper.start()
stats_worker_thread = Thread(target=stats_worker, args=(stats_queue,), name = 'Stats')
stats_worker_thread.daemon = True
stats_worker_thread.start()
#Start up Reader Thread
reader_thread = Thread(target=reader_worker, args=(work_queue, options), name='Reader')
reader_thread.daemon = True
reader_thread.start()
try:
while True:
reader_thread.join(.1)
if not reader_thread.is_alive():
break
# If bulkError occurs stop reading from the files
if bulkError_event.is_set():
sys.stdout.write("Bulk API error -- forcing program shutdown \n")
raise KeyboardInterrupt("Error response from ES worker, stopping processing")
if options.verbose:
sys.stdout.write("All files ingested ... please wait for processing to complete ... \n")
sys.stdout.flush()
while not work_queue.empty():
# If bulkError occurs stop processing
if bulkError_event.is_set():
sys.stdout.write("Bulk API error -- forcing program shutdown \n")
raise KeyboardInterrupt("Error response from ES worker, stopping processing")
work_queue.join()
try:
# Since this is the shutdown section, ignore Keyboard Interrupts
# especially since the interrupt code (below) does effectively the same thing
insert_queue.join()
finished_event.set()
for t in threads:
t.join()
# Wait for the es serializer(s) to package up all of the bulk requests
for es_serializer in es_serializers:
es_serializer.join()
# Wait for shippers to send all bulk requests
bulk_request_queue.join()
# Change settings back
unOptimizeIndexes(es, data_template, options)
stats_queue.put('finished')
stats_worker_thread.join()
#Update the stats
try:
es.update(index=meta_index_name, id=options.identifier,
doc_type='meta',
body = { 'doc': {
'total' : STATS['total'],
'new' : STATS['new'],
'updated' : STATS['updated'],
'unchanged' : STATS['unchanged'],
'duplicates': STATS['duplicates'],
'changed_stats': CHANGEDCT
}}
);
except Exception as e:
sys.stdout.write("Error attempting to update stats: %s\n" % str(e))
except KeyboardInterrupt:
pass
if options.verbose:
sys.stdout.write("Done ...\n\n")
sys.stdout.flush()
if options.stats:
print("Stats: ")
print("Total Entries:\t\t %d" % STATS['total'])
print("New Entries:\t\t %d" % STATS['new'])
print("Updated Entries:\t %d" % STATS['updated'])
print("Duplicate Entries\t %d" % STATS['duplicates'])
print("Unchanged Entries:\t %d" % STATS['unchanged'])
except KeyboardInterrupt as e:
sys.stdout.write("\rCleaning Up ... Please Wait ...\nWarning!! Forcefully killing this might leave Elasticsearch in an inconsistent state!\n")
shutdown_event.set()
# Flush the queue if the reader is alive so it can see the shutdown_event
# in case it's blocked on a put
sys.stdout.write("\tShutting down input reader threads ...\n")
while reader_thread.is_alive():
try:
work_queue.get_nowait()
work_queue.task_done()
except queue.Empty:
break
reader_thread.join()
# Don't join on the work queue, we don't care if the work has been finished
# The worker threads will exit on their own after getting the shutdown_event
# Joining on the insert queue is important to ensure ES isn't left in an inconsistent state if delta indexes are being used
# since it 'moves' documents from one index to another which involves an insert and a delete
insert_queue.join()
# All of the workers should have seen the shutdown event and exited after finishing whatever they were last working on
sys.stdout.write("\tStopping workers ... \n")
for t in threads:
t.join()
# Send the finished message to the stats queue to shut it down
stats_queue.put('finished')
stats_worker_thread.join()
sys.stdout.write("\tWaiting for ElasticSearch bulk uploads to finish ... \n")
# The ES serializer does not recognize the shutdown event only the graceful finished_event
# so set the event so it can gracefully shutdown
finished_event.set()
# Wait for es serializer(s) to package up all bulk requests
for es_serializer in es_serializers:
es_serializer.join()
# Wait for shippers to send all bulk requests, otherwise ES might be left in an inconsistent state
bulk_request_queue.join()
#Attempt to update the stats
#XXX
try:
sys.stdout.write("\tFinalizing metadata\n")
es.update(index=meta_index_name, id=options.identifier,
body = { 'doc': {
'total' : STATS['total'],
'new' : STATS['new'],
'updated' : STATS['updated'],
'unchanged' : STATS['unchanged'],
'duplicates': STATS['duplicates'],
'changed_stats': CHANGEDCT
}
})
except:
pass
sys.stdout.write("\tFinalizing settings\n")
# Make sure to de-optimize the indexes for import
unOptimizeIndexes(es, data_template, options)
try:
work_queue.close()
insert_queue.close()
stats_queue.close()
except:
pass
sys.stdout.write("... Done\n")
sys.exit(0)
logging.info('Error: response text {}'.format(r.text))
raise e
if __name__ == "__main__":
argParser = argParser.ArgumentParser(
description='Process a csv file for rollback. '
'The csv file should have the following columns'
'(some are not used and can be left empty, but structure is important here):\n'
'1. Date\n'
'2. User name\n'
'3. User email (not used)\n'
'4. IP Address (not used)\n'
'5. Action (not used)\n'
'6. item name (file or folder name)\n'
'7. Size (not used)\n'
'8. Parent folder\n'
'9. Change details\n')
argParser.add_argument('--csv',
dest='csv_file',
required=True,
help='csv file to process')
args = argParser.parse_args()
print "CSVFile Processing {}".format(args.csv_file)
if (args.csv_file):
restore = Restore(shouldAuthenticate=True)
restore.rollbackFilesInCSV(args.csv_file)
else:
print "Error: Requires csv_file to process"
argParser.print_help()
'''Import the necessary packages'''
import numpy
import argparse
import cv2
import imutils
from imutils import contours as ct
'''Get the image'''
argparse = argparse.ArgumentParser()
argparse.add_argument("-i",
"--image",
required=True,
help="Adds the image from the command line")
image = vars(argparse.parse_args())
'''Define the answer key that maps to the question number
The answers are
A, B, C, D, E, E, D, C, B, A
'''
ANSWER_KEY = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 4, 6: 3, 7: 2, 8: 1, 9: 0}
'''Preprocess the input image'''
image = cv2.imread(image["image"])
#change the width and height of the original image
imageCopy = imutils.resize(image, height=500)
#Start main preprocessing
gray = cv2.cvtColor(imageCopy, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (1, 1), 0)
edged = cv2.Canny(blur, 105, 150)
'''Display each image when it was processed'''
cv2.imshow("Original Image", imageCopy)
cv2.waitKey(0)
cv2.imshow("Grayed Image", gray)
def __init__(self):
ap = make_argument_parser()
arguments = vars(ap.parse_args())
super(NewZasimWindow, self).__init__(ap, arguments)
nucs = {'A', 'G', 'T', 'C'}
if d == 0:
return [pattern]
if len(pattern) == 1:
return nucs
neighborhood = set()
suffix_neighbors = neighbors(pattern[1:], d)
for suffix in suffix_neighbors:
if hamming_distance(pattern[1:], suffix) < d:
for nuc in nucs:
neighborhood.add(nuc + suffix)
else:
neighborhood.add(pattern[0] + suffix)
return neighborhood
def hamming_distance(p, q):
hamming_distance = 0
p_len = len(p)
q_len = len(q)
for i in range(0, p_len):
if i < p_len and i < q_len and p[i] != q[i]:
hamming_distance += 1
elif not i < p_len:
hamming_distance = hamming_distance + q_len - 1
elif not i < q_len:
hamming_distance = hamming_distance + p_len - 1
return hamming_distance
if __name__ == '__main__':
sequence, k, d = parse_args(sys.argv[1:])
print(*find_kmers_with_mismatches_and_reverse_complements(sequence, k, d))
import argparse
import sys
argparse = argparse.ArgumentParser()
argparse.add_argument("f_sp_input")
argparse.add_argument("e_sp_input")
argparse.add_argument("align_file")
argparse.add_argument("--debug", action='store_true')
args = argparse.parse_args()
DELIMITER = "▁"
def main():
exit_status = 0
for line, (f_sp, e_sp, align) in enumerate(
iter_input(args.f_sp_input, args.e_sp_input, args.align_file)):
# Grouping piece together
f_sp_word = []
for i, piece in enumerate(f_sp):
if DELIMITER in piece:
f_sp_word.append([])
f_sp_word[-1].append((piece, i))
e_sp_word = []
for i, piece in enumerate(e_sp):
if DELIMITER in piece:
e_sp_word.append([])
e_sp_word[-1].append((piece, i))
align = align_missings(len(f_sp_word), len(e_sp_word), align)
# execute
batch_split(os.path.join(processed_dir, 'Before'), join(dst, 'Before'))
batch_split(os.path.join(processed_dir, 'After'), join(dst, 'After'))
print("IMAGE SPLIT COMPLETED")
# def batch_split(id_dir, dst):
# print(dst)
# for bundel in os.walk(id_dir):
# if bundel[2]:
# copy_dst = join(dst, bundel[0].split('Processed')[-1])
# print(copy_dst)
# copy_dst_right = join(copy_dst, 'right')
# copy_dst_left = join(copy_dst, 'left')
# os.makedirs(copy_dst_right, exist_ok=True)
# os.makedirs(copy_dst_left, exist_ok=True)
# mode = 0 if 'masks' in bundel[0] else 1
# for fn in bundel[2]:
# if os.path.splitext(fn)[-1] == 'png':
# img_p = join(bundel[0], fn)
# split_one(img_p, copy_dst, mode=mode)
# elif os.path.splitext(fn)[-1] == 'xlsx':
# shutil.copy(join(bundel[0], fn), join(copy_dst_right, fn))
# shutil.copy(join(bundel[0], fn), join(copy_dst_left, fn))
if __name__ == "__main__":
argparse = argparse.ArgumentParser(description='Split one set of evaluation and masks into right and left')
argparse.add_argument('-i', required=True)
argparse.add_argument('-o', required=True)
commands = argparse.parse_args()
main(commands.i, commands.o)
#!/usr/bin/python
import os
import numpy as np
import nibabel as nib
import argparse as ap
ap = ap.ArgumentParser(description="fast split of 4D nifti image")
ap.add_argument("-i", "--input", nargs=1, help="[4D_image]", metavar=('*.nii.gz'), required=True)
#ap.add_argument("-o", "--output", nargs=1, help="[outname]", metavar=('vol_????.nii.gz'), default=('vol'))
opts = ap.parse_args()
os.system("zcat %s > temp_4d.nii" % opts.input[0])
img_all = nib.load('temp_4d.nii')
data_all = img_all.get_data()
affine_all = img_all.get_affine()
header_all = img_all.get_header()
numImages=data_all.shape[3]
#outhead=str(opts.output[0])
for i in range(int(numImages)):
nib.save(nib.Nifti1Image(data_all[:,:,:,i],affine_all),"vol%05d.nii.gz" % (i))
os.system("rm temp_4d.nii")
csv_file.next() # read the first line and discard
if args.to_stdout:
out = sys.stdout
else:
out = open(os.path.splitext(csv_name)[0] + ".vcf", "w+")
out.write(header())
write_fields(csv_file, out)
os.remove(csv_name)
out.close()
if __name__ == '__main__':
argparse = argparse.ArgumentParser()
argparse.add_argument("files", nargs='+',
help="the xls(x) files to process")
argparse.add_argument("--stdout", action="store_true", dest="to_stdout",
help="output goes to stdout instead of a file")
args = argparse.parse_args()
# Constants
FORMAT = "GT:COV:QS:TS:CM:PM:OAS:EAS"
# fields from the csv
cols = ["CHR", "CO", "REF", "VAR", "COV", "QS", "ZYG", "GENE", "TRANS",
"CM", "PM", "DB", "OAS", "EAS"]
FIELDS = dict(zip(cols, range(len(cols))))
for xls in args.files:
process_xls(xls)
if parallel:
from llll import MultithreadedMapper, PoolMaster
pm = PoolMaster('lineenv.py', is_filename=True, nproc=ncpu)
def to_optimize(v):
return pm.call(v)
vv = mc.to_vec()
for i in range(100):
pm.call(vv, mc.indices) # assure indices propagated to all slaves
import argparse as ap
ap = ap.ArgumentParser()
ap.add_argument('filename')
d = ap.parse_args()
# le = StrokeEnv(grayscale=False)
# le = LineEnvCMYK()
# le = LineEnv2()
le = LineEnv4()
# le.load_image('hjt.jpg', target_width=256)
le.load_image(d.filename, target_width=256)
# le.load_image('fruits.jpg', target_width=256)
# le.load_image('jeff.jpg', target_width=256)
# le.load_image('forms.jpg', target_width=128)
# le.load_image('forms.jpg', target_width=64)
le.init_segments(num_segs=1000)
# le.set_metric(SSIMLoss)
# le.set_metric(LabPyramidLoss)
def main():
'''
`main' is entrance of this program.
Do not call it DIRECTLY.
[return code]:
- If all successful, return 0.
- If it has some issues, but no big deal,
still return 0
- If it has some issues which makes problem
can't run successfuly, return 1.
- If it has some fatal issues, return 2.
- If exception has been triggered, return 1.
'''
argList = arg.parse_args()
# BRANCH PART: If user specified `branch', it will
# check whether `branch' is valid or not, otherwise
# let users choose branch.
branch = ""
if argList.branch:
branch = parseBranch(argList.branch)
else:
branch = parseBranch()
# DOWNLOAD PART: It will download the templates
# of those ts files.
# If user specified `all', then it will reversive
# compList.
mergeFn = {}
if argList.component_name == "all":
for comp in compList:
untranFn = filenameFormat.format(component=comp, langcode=untranslatedFilename)
mergeFn.update({untranFn: filenameFormat.format(component=comp, langcode=argList.language_name)})
# http://l10n-files.qt.io/l10n-files/{branch_name}/{untranFn}
downFile(f"{downloadURL.format(branch_name=branch)}{untranFn}", untranFn, _("The template of {comp}").format(comp=comp))
else:
untranFn = filenameFormat.format(component=argList.component_name, langcode=untranslatedFilename)
mergeFn.update({untranFn: filenameFormat.format(component=argList.component_name, langcode=argList.language_name)})
# http://l10n-files.qt.io/l10n-files/{branch_name}/{untranFn}
downFile(f"{downloadURL.format(branch_name=branch)}{untranFn}", untranFn, _("The template of {comp}").format(comp=argList.component_name))
# MERGE PART: It will merge the translate file with template file.
# It will make a backup like "qtbase-zh_TW.ts~" first, and then to merge.
for templateFn in mergeFn:
tranFn = mergeFn[templateFn]
if argList.toMerge:
if os.path.exists(tranFn) != True or os.path.isfile(tranFn) != True:
print(_("Creating: {translate_file}...").format(translate_file=tranFn), end=" ")
shutil.copy(templateFn, tranFn)
print(_("Success."))
else:
if argList.backup:
shutil.copy(tranFn, f"{tranFn}~")
mergeTS(templateFn, tranFn, argList.language_name, preserveLocation= argList.cleanTags)
# Remove template file
print(_("Removing: {template_file}...").format(template_file=templateFn), end=" ")
os.remove(templateFn)
print(_("Success."))
else:
print(_("You can merge {translate_file} manually now. The template filename: {template_file}").format(translate_file=tranFn, template_file=templateFn))
parser.add_argument('--imagedir',
action='store',
dest='imagedir',
help='Image directory for logo search',
default=None)
parser.add_argument('--no-entropy',
action='store_true',
dest='no_entropy',
help="Don't search for high entropy",
default=None)
parser.add_argument('--no-cc',
action='store_true',
dest='no_cc',
help="Don't search for credit card",
default=None)
parser.add_argument('--no-keyword',
action='store_true',
dest='no_keyword',
help="Don't search for keywords",
default=None)
argv = parser.parse_args()
if argv.no_entropy:
argv.no_entropy = True
if argv.no_cc:
argv.no_cc = True
if argv.no_keyword:
argv.no_keyword = True
action(argv.code, argv.imagedir, argv.no_entropy, argv.no_cc, argv.no_keyword)
import numpy as np
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v", "--video", help="path to the video file")
ap.add_argument("-a",
"--min-area",
type=int,
default=5000,
help="minimum area size")
ap.add_argument('-t',
"--tempfolder",
help="Folder for temp files",
required=True)
args = vars(ap.parse_args())
# if the video argument is None, then we are reading from webcam
if args.get("video", None) is None:
camera = cv2.VideoCapture(0)
time.sleep(0.25)
# otherwise, we are reading from a video file
else:
camera = cv2.VideoCapture(args["video"])
# initialize the first frame in the video stream
firstFrame = None
_object_type = "Car"
_temp_path = args["tempfolder"]
import argparse
from datetime import datetime, timedelta
import pandas
import matplotlib.pyplot as plt
from container import Container
from model.DataSource import DataSource
argparse = argparse.ArgumentParser()
argparse.add_argument("-d", "--days-behind", required=True, dest="days_behind", type=int,
help="Days behind to be taken into account")
args = vars(argparse.parse_args())
container = Container()
datapoints_repository = container.datapoints_repository()
start_date = datetime.today() - timedelta(days=args['days_behind'])
end_date = datetime.today()
extracted_data = datapoints_repository.get(DataSource.WEATHER_STATION.value, start_date, end_date)
dataframe = pandas.DataFrame(extracted_data).set_index('_id')
fig, axes = plt.subplots(5, figsize=(13, 8))
dataframe.plot(subplots=True, kind='line', x='date', y='temperature', ax=axes[0])
dataframe.plot(subplots=True, kind='line', x='date', y='pressure', color='red', ax=axes[1])
dataframe.plot(subplots=True, kind='line', x='date', y='humidity', color='blue', ax=axes[2])
dataframe.plot(subplots=True, kind='line', x='date', y='light', color='purple', ax=axes[3])
dataframe.plot(subplots=True, kind='line', x='date', y='rain', color='black', ax=axes[4])
plt.show()
results_with_input, results_no_input = main_module.main_executor()
if df1 is None:
df1 = results_with_input
else:
df1 = df1.append(results_with_input, ignore_index=True)
if df2 is None:
df2 = results_no_input
else:
df2 = df2.append(results_no_input, ignore_index=True)
plot_figure(df1, df2)
return
# ---------------------------------------------
parser = argparse.parse_args()
parser.add_argument('--DIR',
choices=[
'us_import1', 'us_import2', 'us_import3', 'us_import4',
'us_import5', 'us_import6'
],
default=None)
parser.add_argument('--feedback_size', type=int, default=10)
parser.add_argument(
'--top_K',
type=int,
default=10,
)
args = parser.parse_args()
DIR = args.DIR
command.type = data_arr[0]
command.posx = round(float(data_arr[1]), 3)
command.posy = round(float(data_arr[2]), 3)
self.pub.publish(command)
if __name__ == '__main__':
rospy.init_node('yumi_eneroth_bridge')
argparse = argparse.ArgumentParser(prog='eneroth_bridge.py')
argparse.add_argument("--host", type=str, help='Host address')
argparse.add_argument("--port", type=int, help='Host port', default=5000)
args = argparse.parse_args(rospy.myargv(argv=sys.argv)[1:])
enerothclient = EnerothYumiClient(host=args.host, port=args.port)
if (not enerothclient.connect()):
rospy.signal_shutdown("Communication Error with the Server")
rospy.loginfo("Yumi Eneroth bridge started...")
while not rospy.is_shutdown():
data = enerothclient.listen()
if len(data) > 0:
enerothclient.parsedata(data)
enerothclient.close()
from skimage.feature import hog
from sklearn.externals import joblib
import argparse as ap
from nms import nms
from config import *
from PIL import Image
from resizeimage import resizeimage
import numpy as np
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v", "--video", help="path to the video file")
ap.add_argument("-a", "--min-area", type=int, default=5000, help="minimum area size")
ap.add_argument('-t', "--tempfolder", help="Folder for temp files", required=True)
args = vars(ap.parse_args())
# if the video argument is None, then we are reading from webcam
if args.get("video", None) is None:
camera = cv2.VideoCapture(0)
time.sleep(0.25)
# otherwise, we are reading from a video file
else:
camera = cv2.VideoCapture(args["video"])
# initialize the first frame in the video stream
firstFrame = None
_object_type = "Car"
_temp_path = args["tempfolder"]
except Exception as e:
logging.info( 'Error: delete did not work.. on file {}'.format(fileItem['name']) )
logging.info( 'Error: response text {}'.format(r.text) )
raise e
if __name__ == "__main__":
argParser = argParser.ArgumentParser(description='Process a csv file for rollback. '
'The csv file should have the following columns'
'(some are not used and can be left empty, but structure is important here):\n'
'1. Date\n'
'2. User name\n'
'3. User email (not used)\n'
'4. IP Address (not used)\n'
'5. Action (not used)\n'
'6. item name (file or folder name)\n'
'7. Size (not used)\n'
'8. Parent folder\n'
'9. Change details\n')
argParser.add_argument('--csv', dest='csv_file', required=True, help='csv file to process')
args = argParser.parse_args()
print "CSVFile Processing {}".format(args.csv_file)
if (args.csv_file):
restore = Restore(shouldAuthenticate=True)
restore.rollbackFilesInCSV(args.csv_file)
else:
print "Error: Requires csv_file to process"
argParser.print_help()
