def main():
parser = GooeyParser(
prog='',
description="Detecting rare cell-types from single-cell "
"gene expression data",
epilog="Contributors: Lan Jiang, "
"Qian Zhu and Gregory Giecold.\nFor further help or information, "
"please contact us at [email protected],"
"[email protected] or [email protected]")
subparsers = parser.add_subparsers(dest='datatype',
help="Type of your input genomics dataset")
qPCR_parser = subparsers.add_parser('qpcr')
qPCR_parser.add_argument('Input', type=str, widget='FileChooser',
help='Select a file to process:')
qPCR_parser.add_argument('-e', '--epsilon', nargs='?',
type=float, const=0.25, default=0.25,
help='DBSCAN epsilon parameter:')
qPCR_parser.add_argument('-m', '--minPts', nargs='?',
type=int, const=5, default=5,
help='DBSCAN minPts parameter:')
qPCR_parser.add_argument('-O', '--Output', nargs='?', type=str,
default=path.join(getcwd(), 'GiniClust_results'),
help="Specify GiniClust's output directory:")
RNASeq_parser = subparsers.add_parser('rna')
RNASeq_parser.add_argument('Input', type=str, widget='FileChooser',
help='Select a file to process:')
RNASeq_parser.add_argument('-e', '--epsilon', nargs='?',
type=float, const=0.5, default=0.5,
help='DBSCAN epsilon parameter:')
RNASeq_parser.add_argument('-m', '--minPts', nargs='?',
type=int, const=3, default=3,
help='DBSCAN minPts parameter:')
RNASeq_parser.add_argument('-O', '--Output', nargs='?', type=str,
default=path.join(getcwd(), 'GiniClust_results'),
help="Specify GiniClust's output directory:")
command = 'Rscript'
path2Rscript = path.join(getcwd(), 'GiniClust_Main.R')
args = parser.parse_args()
if args.datatype == 'qpcr':
datatype_str = 'qPCR'
else:
datatype_str = 'RNA-seq'
cmd = [command, path2Rscript]
cmd += ['-f', args.Input, '-t', datatype_str, '-o', args.Output, '-e', str(args.epsilon), '-m', str(args.minPts)]
subprocess.check_output(cmd, universal_newlines=True)
def run():
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='commands')
train_parser = subs.add_parser('train', help='Configurate model training')
param_group = train_parser.add_argument_group("Model parameter option", gooey_options={'show_border': True, 'columns': 2})
args_param.add(param_group)
data_group = train_parser.add_argument_group("Data Options", gooey_options={'show_border': True}, )
args_data.add(data_group)
save_group = train_parser.add_argument_group("Save option", gooey_options={'show_border': True, 'columns': 2})
args_save.add(save_group)
test_parser = subs.add_parser('test', help='Configurate model testining')
data_group = test_parser.add_argument_group("Data Options", gooey_options={'show_border': True}, )
args_data.add(data_group)
load_group = test_parser.add_argument_group("Load option", gooey_options={'show_border': True, 'columns': 1})
args_load.add(load_group, model_savefiles())
save_group = test_parser.add_argument_group("Save option", gooey_options={'show_border': True, 'columns': 2})
args_save.add(save_group)
args = parser.parse_args()
X, Y = load_data(args.data_path)
if args.commands =='train':
train(args, X, Y, save_dir)
else:
with open(save_dir + args.load_model, 'rb') as f:
model = pickle.load(f)
test(args, X, Y, save_dir, model)
def main():
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='command')
img_calib_parser = subs.add_parser(
'Calib_image', help='Camera calibrattion by saved image')
add_args_calib_img(img_calib_parser)
cam_calib_parser = subs.add_parser(
'Calib_cam', help='Camera calibration by camera input directly')
add_args_calib_cam(cam_calib_parser)
disp_parser = subs.add_parser(
'Disparity_map',
help='Validate Camera calibration by visualization disparity map')
add_args_disp(disp_parser)
dic3d_parser = subs.add_parser('3D_DIC', help='Configuration DIC option')
add_args_3d_dic(dic3d_parser)
args = parser.parse_args()
print(args.command)
if args.command == 'Calib_image':
calibration.by_imgs(args, save_dir, camera_mtx_dir)
elif args.command == 'Calib_cam':
calibration.by_cam(args, save_dir, camera_mtx_dir)
elif args.command == 'Disparity_map':
disparity_vis.run(args, save_dir, camera_mtx_dir)
elif args.command == '3D_DIC':
dic3d.run(args, save_dir, camera_mtx_dir, mesh_dir)
def parse_args():
parser = GooeyParser(description="Encrypt and decrypt files")
subparsers = parser.add_subparsers(required=True)
encoder = subparsers.add_parser(
"encode", help="Encode a text file into an unreadable format")
decoder = subparsers.add_parser(
"decode", help="Decode an unreadable format into a text file")
encoder.add_argument("input", widget="FileChooser", help="File to encode")
decoder.add_argument("input", widget="FileChooser", help="File to decode")
encoder.add_argument("output",
widget="FileSaver",
help="Output file location")
decoder.add_argument("output",
widget="FileSaver",
help="Output file location")
encoder.add_argument("--key",
default=85,
widget="IntegerField",
help="Key to encrypt the file")
decoder.add_argument("--key",
default=85,
widget="IntegerField",
help="Key to decrypt the file")
return parser.parse_args()
def param_parser():
globalmapperexe = glob.glob('C:\\Program Files\\'+'GlobalMapper2*')
globalmapperexe = '{0}\\global_mapper.exe'.format(globalmapperexe[0])
print(globalmapperexe)
parser=GooeyParser(description="Make Contour")
sub_pars = parser.add_subparsers(help='commands', dest='command')
filter_parser = sub_pars.add_parser('Filter_LAZ_Files', help='Prepares the las files for contours by filtering')
filter_parser.add_argument("inputfolder", metavar="Input Folder", widget="DirChooser", help="Select input files (.las/.laz)", default='')
filter_parser.add_argument("filepattern",metavar="Input File Pattern", help="Provide a file pattern seperated by ';' for multiple patterns (*.laz or 123*_456*.laz;345*_789* )", default='*.laz')
filter_parser.add_argument("outputpath", metavar="Output Directory",widget="DirChooser", help="Output directory", default='')
filter_parser.add_argument("TL", metavar="Tilelayout", widget="FileChooser", help="tilelayout.json", default="")
filter_parser.add_argument("contourinterval", metavar="Contour interval", help="Provide contour interval", default='0.5')
filter_parser.add_argument("filterval",metavar="Filter Value", help="Must not be more than 30% of contour interval", type=float, default=0.15)
filter_parser.add_argument("-flatten", metavar="Flatten", help="Flatten points between intervals", action='store_true',default=False)
filter_parser.add_argument("-cores",metavar="Cores", help="No of cores to run", type=int, default=8)
main_parser = sub_pars.add_parser('Make_Contours', help='Creates the contours')
main_parser.add_argument("inputfolder", metavar="Contour Points Folder", widget="DirChooser", help="Select input files (.las/.laz)", default='')
main_parser.add_argument("filepattern",metavar="Input File Pattern", help="Provide a file pattern seperated by ';' for multiple patterns (*.laz or 123*_456*.laz;345*_789* )", default='*.laz')
main_parser.add_argument("layoutfile", metavar="TileLayout file", widget="FileChooser", help="TileLayout file(.json)", default='')
main_parser.add_argument("outputpath", metavar="Output Directory",widget="DirChooser", help="Output directory", default='')
main_parser.add_argument("aoi", metavar="AOI", widget="FileChooser", help="Area of interest(.shp file)", default="")
main_parser.add_argument("zone", metavar="UTM Zone", choices=['49','50','51','52','53','54','55','56'],default='55')
main_parser.add_argument("contourinterval", metavar="Contour interval", help="Provide contour interval", default='0.5')
main_parser.add_argument("indexinterval", metavar="Index Interval", help="Provide interval for contour index", default='5')
main_parser.add_argument("gmexe", metavar="Global Mapper EXE", widget="FileChooser", help="Location of Global Mapper exe", default=globalmapperexe)
main_parser.add_argument("-b", "--buffer",metavar="Buffer", help="Provide buffer", type=int, default=200)
main_parser.add_argument("-c", "--cores",metavar="Cores", help="No of cores to run", type=int, default=8)
main_parser.add_argument("-hpfiles", "--hydropointsfiles", widget="MultiFileChooser", metavar = "Hydro Points Files", help="Select files with Hydro points")
return parser.parse_args()
def run():
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='commands')
train_parser = subs.add_parser('train', help='Configurate model training')
param_group = train_parser.add_argument_group("Model parameter option", gooey_options={'show_border': True, 'columns': 2})
param_group = args_param.add(param_group)
data_group = train_parser.add_argument_group("Data Options", gooey_options={'show_border': True, 'columns': 1})
data_group = args_data.add(data_group)
save_group = train_parser.add_argument_group("Save option", gooey_options={'show_border': True, 'columns': 1})
save_group = args_save.add(save_group)
test_parser = subs.add_parser('test', help='Configurate model testing')
data_group = test_parser.add_argument_group("Data Options", gooey_options={'show_border': True}, )
data_group = args_data.add(data_group)
pretrained_group = test_parser.add_argument_group("Pretrained file Options", gooey_options={'show_border': True}, )
pretrained_group = args_pre.add(pretrained_group)
args = parser.parse_args()
if args.commands =='train':
train.train(args)
else:
test.test(args)
def main():
# make sure that the output is not buffered (cf. https://chriskiehl.com/article/packaging-gooey-with-pyinstaller)
# nonbuffered_stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
# sys.stdout = nonbuffered_stdout
####
parser = GooeyParser(description="Simulation of dynamical systems")
grazer_subparser = parser.add_subparsers(help="Programs")
grazer_run = grazer_subparser.add_parser("run", help="Run Simulation")
grazer_run_group = grazer_run.add_argument_group("Run Simulation")
grazer_run_group.add_argument(
"grazer-directory",
metavar="Grazer Directory",
widget="DirChooser",
help=
"Directory containing a 'problem' folder, will contain an output folder afterwards",
)
make_full_factory = grazer_subparser.add_parser("schema make-full-factory")
make_full_factory.add_argument(
"grazer-directory",
metavar="Grazer Directory",
widget="DirChooser",
help=
"Directory containing a 'problem' folder, will contain a 'schemas' folder afterwards",
)
insert_key = grazer_subparser.add_parser("schema insert-key")
insert_key.add_argument(
"grazer-directory",
metavar="Grazer Directory",
widget="DirChooser",
help=
"Directory containing a 'problem' and 'schema' folder, modifies the problem files with the schema key",
)
parser.parse_args()
def goo():
# For all systems, output will be EIF or TAC folder
parser = GooeyParser(description="Universal EO Prepper")
sub_pars = parser.add_subparsers(help='commands', dest='command')
vq_parser = sub_pars.add_parser(
'VQ_Prepper', help='Run EO preparation on VQ780i systems')
# VQ needs EIF folder, Global Mapper exe
vq_parser.add_argument('eif_folder',
metavar="EIF Folder",
widget='DirChooser',
help='Select folder containing EIF files')
vq_parser.add_argument(
'gm_exe',
metavar='Global Mapper Location',
widget='FileChooser',
help='Select your Global Mapper exe',
default=r"C:\Program Files\GlobalMapper21.0_64bit\global_mapper.exe")
vq_parser.add_argument(
'camera',
metavar=
"Which camera captured this? This has an impact on the calculations.",
choices=['MM010014', 'YC030345', 'YC030228', 'H68-IQ185'])
harrier_parser = sub_pars.add_parser(
'Harrier_Prepper', help='Run EO preparation on VQ780i systems')
# Harrier needs TAC_merged, sbet, zone , hardcoded calib_ini folder, gm exe location
harrier_parser.add_argument('tac_files',
metavar="Select your TAC files",
widget='MultiFileChooser',
help="You can select more than one.")
harrier_parser.add_argument('sbet_files',
metavar="Select your sbet files",
widget='FileChooser',
help="Just one this time.")
harrier_parser.add_argument(
'sbet_zone',
metavar="In what configuration is your sbet?",
choices=sbet_projections,
help="Select the native projection of your input sbet file")
harrier_parser.add_argument(
'gm_exe',
metavar='Global Mapper Location',
widget='FileChooser',
help='Select your Global Mapper exe',
default=r"C:\Program Files\GlobalMapper21.0_64bit\global_mapper.exe")
uce_parser = sub_pars.add_parser('UCE_Prepper',
help='Create ID file for the UCX')
uce_parser.add_argument(
'cos_log',
metavar=
'Please show me your COS log. \nYour output will also be placed here.',
widget='FileChooser')
uce_parser.add_argument('ead_folder',
metavar='Please show me your EAD_MM folder.',
widget='DirChooser')
uce_parser.add_argument(
'gm_exe',
metavar='Please show me your Global Mapper exe',
widget='FileChooser',
default=r"C:\Program Files\GlobalMapper21.1_64bit\global_mapper.exe")
return parser.parse_args()
def param_parser():
stored_args = {}
# get the script name without the extension & use it to build up
# the json filename
script_name = os.path.splitext(os.path.basename(__file__))[0]
congifg_folder = AtlassGen.makedir("C:\\pythontools")
args_file = os.path.join(congifg_folder,"{}-args.json".format(script_name))
# Read in the prior arguments as a dictionary
if os.path.isfile(args_file):
with open(args_file) as data_file:
stored_args = json.load(data_file)
parser=GooeyParser(description="QA Check Files")
subs = parser.add_subparsers(help='commands', dest='command')
parser2 = subs.add_parser('CHECKFILES', help='Check files for corruption')
parser2.add_argument("ori_path", metavar="LAS file Folder with original files(unclassified)", widget="DirChooser", help="Select las file folder", default=stored_args.get('ori_path'))
parser2.add_argument("rec_path", metavar="LAS file Folder with recieved files(classified)", widget="DirChooser", help="Select las file folder", default=stored_args.get('rec_path'))
parser2.add_argument("layoutfile", metavar="TileLayout file", widget="FileChooser", help="TileLayout file(.json)", default=stored_args.get('layoutfile'))
parser2.add_argument("outputpath", metavar="Output Directory",widget="DirChooser", help="Output directory", default=stored_args.get('outputpath'))
parser2.add_argument("filetype", metavar="File Type",help="input filetype (laz/las)", default='laz')
parser2.add_argument("-c", "--cores",metavar="Cores", help="No of cores to run", type=int, default=stored_args.get('cores'))
args = parser.parse_args()
# Store the values of the arguments so we have them next time we run
with open(args_file, 'w') as data_file:
# Using vars(args) returns the data as a dictionary
json.dump(vars(args), data_file)
return args
def parse_args():
prog_descrip = 'Pyinstaller example with Gooey'
parser = GooeyParser(description=prog_descrip)
sub_parsers = parser.add_subparsers(help='commands', dest='command')
first_parser = sub_parsers.add_parser(
'file', help='This function prints the chosen file name')
first_parser.add_argument('file_path',
help='Select a random file',
type=str,
widget='FileChooser')
first_parser.add_argument('--file-size',
help='Do you want to print the file size?',
action='store_true')
second_parser = sub_parsers.add_parser(
'folder', help='This funtion prints all files in a folder')
second_parser.add_argument('folder_path',
help='Select a folder',
type=str,
widget='DirChooser')
second_parser.add_argument('--file-type',
help='Specify file type with .jpg',
type=str)
args = parser.parse_args()
return args
def param_parser():
parser=GooeyParser(description="Clip to AOIs")
subs = parser.add_subparsers(help='commands', dest='command')
main_parser = subs.add_parser('laz', help='Create Tile layout using files')
main_parser.add_argument("inputfolder", metavar="Input Folder", widget="DirChooser", help="Select input las/laz folder", default="")
main_parser.add_argument("outputpath", metavar="Output Folder", widget="DirChooser", help="Select output folder", default="")
main_parser.add_argument("filepattern",metavar="Input File Pattern", help="Provide a file pattern seperated by ';' for multiple patterns \nex: (*.laz) or (123*_456*.laz; 345*_789*.laz )", default='*.laz')
main_parser.add_argument("outputtype",metavar="Output File Type", help="las or laz\n", default='laz')
main_parser.add_argument("poly", metavar="AOI folder", widget="DirChooser", help="Folder with Polygons(Script will take all .shp files)", default='')
main_parser.add_argument("cores", metavar="Cores", help="Number of cores to be used\n", type=int)
epsg_group = main_parser.add_argument_group("EPSG Settings", "Optional", gooey_options={'show_border': True,'columns': 3})
epsg_group.add_argument("--hasepsg", metavar="Insert EPSG", action='store_true', default=False)
epsg_group.add_argument("--epsg", metavar="EPSG value", help="EPSG value to use")
asc_parser = subs.add_parser('asc', help='Create Tile layout using files')
asc_parser.add_argument("inputpath", metavar="Input Folder", widget="DirChooser", help="Select input las/laz folder", default="")
asc_parser.add_argument("outputpath", metavar="Output Folder", widget="DirChooser", help="Select output folder", default="")
asc_parser.add_argument("poly", metavar="AOI folder", widget="DirChooser", help="Folder with Polygons(Script will take all .shp files)", default='')
asc_parser.add_argument("epsg", metavar="EPSG value", help="EPSG value to use")
asc_parser.add_argument("step", metavar="Step value", type = float)
asc_parser.add_argument("tilesize", metavar="Tile size", help="Select Size of Tile in meters [size x size]", default=500, type=int)
name_group = asc_parser.add_argument_group("File name settings", "Required when files have different naming conventions", gooey_options={'show_border': True,'columns': 3})
name_group.add_argument("-hfn", "--hasfilename", metavar="Has filename pattern", action='store_true', default=False)
name_group.add_argument("-addzero", metavar="Zeros to add", help="Multiplication to be used at the end of X and Y\n1 = None, 100, 1000 etc..", type=int)
name_group.add_argument("--namepattern", metavar="Input File Name Convention", help="Ex: MGA55_dem_Mo%X%_%Y%_1.laz\n ", default = 'DEM-GRID_001_%X%_%Y%_500m.asc')
asc_parser.add_argument("cores", metavar="Cores", help="Number of cores to be used\n", type=int)
return parser.parse_args()
def main():
parser = GooeyParser()
subs = parser.add_subparsers(help="commands", dest="command")
crawl = subs.add_parser("crawl",
prog="Crawl New Lightnovel").add_argument_group("")
crawl.add_argument(
"-i",
"--input_link",
required=True,
help="Link of Light Novel",
gooey_options=dict(fullwidth=True),
)
# crawl.add_argument(
# "-o",
# "--output_file",
# required=True,
# help="Save file location",
# widget="FileSaver",
# gooey_options=dict(wildcard="EPUB (.epub)|*.epub",fullwidth = True)
# )
update_group = subs.add_parser("update", prog="Update Lightnovel")
update = update_group.add_argument_group("")
update.add_argument("-i",
"--input_file",
required=True,
help="File of Light Novel",
widget="FileChooser",
gooey_options=dict(
wildcard="Epub files (*.epub)|*.epub",
full_width=True,
))
url_settings = update_group.add_argument_group("URL")
url_group = url_settings.add_mutually_exclusive_group(
required=True,
gooey_options=dict(
title="",
full_width=True,
),
)
url_group.add_argument("--use_internal_url",
metavar="Use the internal URL",
action="store_true")
url_group.add_argument(
"--external_url",
metavar="Use the external URL",
help="Link of the update LightNovel",
widget="TextField",
)
args = parser.parse_args()
run(args)
def create_parser():
p = GooeyParser()
subp = p.add_subparsers(title="helper_target", dest="helper_target")
for k, v in HELPERS.items():
subpi = subp.add_parser(k)
v[1](subpi)
return p
def main():
parser = GooeyParser()
subs = parser.add_subparsers(help="commands", dest="command")
from_archive = subs.add_parser(
'analyse_arc',
prog='Validar de Arquivo',
).add_argument_group('')
from_dir = subs.add_parser(
'analyse_dir',
prog='Validar de Diretório',
).add_argument_group('')
# de arquivo
from_archive.add_argument('input_files',
metavar='Arquivo a ser verificado:',
widget="MultiFileChooser",
nargs='*',
gooey_options=dict(wildcard="(*)|*",
full_width=True))
from_archive.add_argument(
'output_file',
widget="FileSaver",
metavar='Arquivo de saída:',
gooey_options=dict(wildcard="(*.csv, *.txt)|*.csv; *.txt",
default_file='migrador-dicover-' + str(random()) +
'.csv',
full_width=True))
# de diretório
from_dir.add_argument('dir',
metavar='Pasta a ser verificada',
widget="DirChooser",
gooey_options=dict(full_width=True))
from_dir.add_argument(
'output_file',
widget="FileSaver",
metavar='Arquivo de saída:',
gooey_options=dict(wildcard="(*.csv, *.txt)|*.csv; *.txt",
default_file='migrador-dicover-' + str(random()) +
'.csv',
full_width=True))
args = parser.parse_args()
if args.command == 'analyse_arc':
for index, arc in enumerate(args.input_files):
print('Arquivo #', index)
nt, r, d = enum_data(arc)
show_results(nt, r, d)
elif args.command == 'analyse_dir':
for index, arc in enumerate(list_sub_dir(args.dir)):
print('Arquivo #', index)
dir_path = args.dir + '\\' + arc
nt, r, d = enum_data(dir_path)
show_results(nt, r, d)
def main():
parser = GooeyParser(description='Yet another friendly COS utilities')
subparsers = parser.add_subparsers(help='commands')
setup_config_parser(subparsers)
upload_parser = subparsers.add_parser('Upload', help='Upload file to COS')
args = parser.parse_args()
args.func(args)
def main():
parser = GooeyParser()
subparser = parser.add_subparsers()
dimensions_parser = subparser.add_parser('dimensions')
dimensions_parser.add_argument('--dimension',
widget='Dropdown',
dest='dimension_value',
choices=config.DIMENSION_NAMES,
help='dimension to run',
required=True)
dimensions_parser.add_argument('--list_len',
dest='list_len_value',
help='list length',
required=True)
dimensions_parser.add_argument('--rule_name',
dest='rule_name_value',
help='rule name',
required=True)
dimensions_parser.add_argument('--param',
dest='rule_param_value',
help='rule param',
required=True)
preview_parser = subparser.add_parser('play')
preview_parser.add_argument('--do_preview',
widget='Dropdown',
dest='do_preview_value',
choices=["play as human", "let ML guess"])
results = parser.parse_args()
try:
if results.do_preview_value == "play as human":
def display_html():
html_to_display = TH.to_html()
webview.load_html(html_to_display)
t = threading.Thread(target=display_html)
t.start()
webview.create_window('Play', width=850, height=600)
else:
P.predict_bool()
except:
R = Run()
print("Generating list of " + str(results.list_len_value) +
" hands with " + str(config.CARDS_TO_DRAW) + " cards")
R.generate_list(results.dimension_value, results.list_len_value,
[results.rule_name_value, results.rule_param_value])
RC = RunCsv()
RC.generate_csv()
def main():
"""
Collects command line arguments with GooeyParser and run functions
from expensetrackkerfortwogui.
Possible functions are entering a transaction (EnterExpense) and
viewing expenses and expense breakdowns (ViewExpenses).
"""
parser = GooeyParser()
subparsers = parser.add_subparsers()
# create the parser and arguments for the "EnterExpense" command
parser_enter = subparsers.add_parser('EnterExpense')
parser_enter.add_argument("Name", help="Who paid for this expense?")
parser_enter.add_argument("Amount",
help="How much was the expense?",
type=int)
parser_enter.add_argument("Category", help="What type of expense was it?")
parser_enter.add_argument("ExpenseDate",
widget="DateChooser",
help="What was the date of the expense?")
parser_enter.set_defaults(func=ex.enterExpense)
# create the parser and arguments for the "View" command
parser_view = subparsers.add_parser('ViewExpenses')
parser_view.add_argument(
"DateRange",
widget='Listbox',
nargs='+',
choices=['Last 7 days', 'Last 30 days', 'All time'],
default='Last 30 days',
help="Select the date range for expenses")
parser_view.add_argument("Total",
widget='Listbox',
nargs='+',
choices=['Yes', 'No'],
default='Yes',
help="View total expenses")
parser_view.add_argument("Category",
widget='Listbox',
nargs='+',
choices=['Yes', 'No'],
default='Yes',
help="View category breakdown of expenses")
parser_view.add_argument("Person",
widget='Listbox',
nargs='+',
choices=['Yes', 'No'],
default='Yes',
help="View per person breakdown of expenses")
parser_view.set_defaults(func=ex.viewExpenses)
# parsing command line arguments and running functions
args = parser.parse_args()
args.func(args)
def param_parser():
parser=GooeyParser(description="Make Tile Layout")
subs = parser.add_subparsers(help='commands', dest='command')
main_parser = subs.add_parser('main', help='Create Tile layout using files')
main_parser.add_argument("input_folder", metavar="Input Folder", widget="DirChooser", help="Select folder with las/laz files")
main_parser.add_argument("filepattern",metavar="Input filter Pattern", help="Provide a file pattern seperated by ';' for multiple patterns\n(*.laz or 123*_456*.laz;345*_789* )", default='*.laz')
main_parser.add_argument("filetype",metavar="Input File Type", help="Select input file type", choices=['las', 'laz','zip','rar','txt','asc'], default='laz')
main_parser.add_argument("tile_size", metavar="Tile size", help="Select Size of Tile in meters [size x size]", default=500, type=int)
main_parser.add_argument("output_dir", metavar="Output Directory",widget="DirChooser", help="Output directory", default="")
main_parser.add_argument("--cores", metavar="Number of Cores", help="Number of cores", type=int, default=8)
main_parser.add_argument("--jsonfile", metavar="Output File Name", help="Provide name for outputfile (.json)", default="TileLayout")
main_parser.add_argument("--prjfile", metavar="Output Prj file name",help="Provide name for prj file (.prj)", default="tile_layout.prj")
attr_group = main_parser.add_argument_group("Attribute settings", "Required for spec jobs", gooey_options={'show_border': True,'columns': 3})
attr_group.add_argument("-dt", metavar="Date", widget="DateChooser")
attr_group.add_argument("-brnumber", metavar="BR Number")
attr_group.add_argument("-projection", metavar="Projection", help="GDAXXXX_MGAXX")
attr_group.add_argument("-vertD", metavar="Vertical Datum", choices=['AHD', 'ELL','AWS'])
attr_group.add_argument("-rgb", metavar="RGB", choices=['Yes', 'No'])
attr_group.add_argument("-cls", metavar="Classification", choices=['C1', 'C2','C3'])
attr_group.add_argument("-xadj", metavar="X adjustment", type=float)
attr_group.add_argument("-yadj", metavar="Y adjustment", type=float)
attr_group.add_argument("-zadj", metavar="Z adjustment", type=float)
attr_group.add_argument("-spath", metavar="Storage Location")
name_group = main_parser.add_argument_group("File name settings", "Required when files have different naming conventions", gooey_options={'show_border': True,'columns': 3})
name_group.add_argument("-hfn", "--hasfilename", metavar="Has filename pattern", action='store_true', default=False)
name_group.add_argument("-addzero", metavar="Zeros to add", help="Multiplication to be used at the end of X and Y\n1 = None, 100, 1000 etc..", type=int)
name_group.add_argument("--namepattern", metavar="Input File Name Convention", help="Ex: MGA55_dem_Mo%X%_%Y%_1.laz\n ")
product_group = main_parser.add_argument_group("Other outputs", "Select Other outputs", gooey_options={'show_border': True,'columns': 5})
product_group.add_argument("-shp", "--makeshp", metavar="shp", action='store_true', default=False)
product_group.add_argument("-prj", "--makeprj", metavar="prj", action='store_true', default=False)
boundingbox_parser = subs.add_parser('boundingbox', help='Create a Tile layout using a box boundingbox ')
boundingbox_parser.add_argument('xmin',type=int)
boundingbox_parser.add_argument('ymin',type = int)
boundingbox_parser.add_argument('xmax',type = int)
boundingbox_parser.add_argument('ymax',type = int)
boundingbox_parser.add_argument("output_dir", metavar="Output Directory",widget="DirChooser", help="Output directory", default="")
boundingbox_parser.add_argument("--tilesize", metavar="Tile size", help="Select Size of Tile in meters [size x size]", default=1000, type=int)
boundingbox_parser.add_argument("--jsonfile", metavar="Output File Name", help="Provide name for outputfile (.json)", default="TileLayout")
boundingbox_parser.add_argument("--shpfile", metavar="Output shape file name",help="Provide name for shape file (.shp)", default="tile_layout_shapefile.shp")
output_group = main_parser.add_argument_group("Output tilename settings", "Required when client requires different tilename on tilelayout file", gooey_options={'show_border': True,'columns': 3})
output_group.add_argument("-ohtn", "--ohastilename", metavar="Has filename pattern", action='store_true', default=False)
output_group.add_argument("--tilename", metavar="Output tilename File Name Convention", help="MR12345_SW_%X%_%Y%_1k\n ")
lastedit_parser = subs.add_parser('lastedit', help='Create a Tile layout with last Edited tiles ')
lastedit_parser.add_argument('inputdir',metavar="Input Folder", widget="DirChooser", help="Select folder with las/laz files")
lastedit_parser.add_argument("outputdir", metavar="Output Directory",widget="DirChooser", help="Output directory", default="")
lastedit_parser.add_argument('datefilter',metavar="Date Filter",widget="DateChooser", help="Filter files with modified date after", default="")
lastedit_parser.add_argument("timefilter", metavar="Time Filter", help="Time filter (HH:MM:SS)", default="00:00:00")
lastedit_parser.add_argument("tilesize", metavar="Tile size", help="Select Size of Tile in meters [size x size]", default=500, type=int)
lastedit_parser.add_argument('filetype',metavar="Input File Type", help="Select input file type", choices=['las', 'laz','zip','rar','txt'], default='laz')
lastedit_parser.add_argument("--cores", metavar="Number of Cores", help="Number of cores", type=int, default=8)
lastedit_parser.add_argument("--jsonfile", metavar="Output File Name", help="Provide name for outputfile (.json)", default="TileLayout")
args = parser.parse_args()
return args
def parse_args():
prog_descrip = 'Elapsed / Remaining Timer on Progress in Gooey'
parser = GooeyParser(description=prog_descrip)
sub_parsers = parser.add_subparsers(help='commands', dest='command')
range_parser = sub_parsers.add_parser('range')
range_parser.add_argument('--length', default=10)
return parser.parse_args()
def action_one():
desc = "Example application to see if we can process two commands at once"
my_cool_parser = GooeyParser(description=desc)
#adding subparsers
subparsers = my_cool_parser.add_subparsers(help="Subparser help")
subparser_1 = subparsers.add_parser('s1', help='subparser 1 help')
subparser_1.add_argument('--s1', widget="CheckBox", action='store_true')
subparser_2 = subparsers.add_parser('s2', help='subparser 2 help')
subparser_2.add_argument('--s2', widget="CheckBox", action='store_true')
my_cool_parser.parse_args()
def main():
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='command')
subparser1 = subs.add_parser('Load Analyzer')
apply_my_common_args1(subparser1)
subparser2 = subs.add_parser('Load Check')
apply_my_common_args2(subparser2)
args = parser.parse_args()
def main():
func.preparation()
parser = GooeyParser(description="Curse Minecraft Modpack Producer")
# parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()
begin = subparsers.add_parser(
"Begin", help="Set the basic information of your modpack")
begin.add_argument("Name", help="The name of your modpack")
begin.add_argument("Author", help="The author of the modpack")
begin.add_argument("MCVersion",
help="The Minecraft Version of your modpack")
begin.add_argument("ModpackVersion", help="The version of your modpack")
begin.set_defaults(func=func.set_modpack_info)
custom = subparsers.add_parser("Custom",
help="Add project by ProjectID and FileID")
custom.add_argument("ProjectID",
type=int,
help="the project id on curseforge")
custom.add_argument("FileID", type=int, help="the file id on curseforge")
custom.set_defaults(func=func.custom_add)
fix = subparsers.add_parser(
"Fix", help="Fix some probable problem for manifest.json")
fix.set_defaults(func=func.fix)
sub1 = subparsers.add_parser("C1", help="The first way using cfwidget api")
sub1.set_defaults(func=cfwidget_func.analysis_file)
sub2 = subparsers.add_parser("C2",
help="The second way using cfwidget api")
sub2.set_defaults(func=cfwidget_func.zipfile_info)
sub3 = subparsers.add_parser("C3")
sub3.add_argument("Name", help="The name of the mod")
sub3.set_defaults(func=cfwidget_func.analysis_api_info)
sub4 = subparsers.add_parser("T1", help="The first way using twitch api")
sub4.set_defaults(func=twitch_func.analysis_file)
sub5 = subparsers.add_parser("T2", help="The second way using twitch api")
sub5.set_defaults(func=twitch_func.zipfile_info)
sub6 = subparsers.add_parser("T3")
sub6.add_argument("Name", help="The name of the mod")
sub6.set_defaults(func=twitch_func.analysis_api_info)
args = parser.parse_args()
if "Name" in args or "ProjectID" in args:
args.func(args)
else:
args.func()
def main():
parser = GooeyParser(
description=
'A collection of the FFMPEG commands I most often use (and forget)')
subparsers = parser.add_subparsers(help='commands', dest='command')
screen_recorder.add_parser(subparsers)
gif.add_parser(subparsers)
trim_crop.add_parser(subparsers)
slideshow.add_parser(subparsers)
watermark.watermark_parser(subparsers)
args = parser.parse_args()
globals()[args.command].run(args)
def main():
parser = GooeyParser()
subs = parser.add_subparsers()
foo = subs.add_parser('foo')
foo.add_argument('a')
foo.add_argument('b')
foo.add_argument('p')
bar = subs.add_parser('bar')
bar.add_argument('a')
bar.add_argument('b')
bar.add_argument('z')
parser.parse_args(['foo'])
def test_ignore_gooey(self):
parser = GooeyParser()
subs = parser.add_subparsers()
foo = subs.add_parser('foo')
foo.add_argument('a')
foo.add_argument('b')
foo.add_argument('p')
bar = subs.add_parser('bar')
bar.add_argument('a')
bar.add_argument('b')
bar.add_argument('z')
control.bypass_gooey(gooey_params())(parser)
def main():
p = GooeyParser(description='Data Visulaization ')
sp = p.add_subparsers(help='commands', dest='command')
#f1='plot_table'
#sp1=sp.add_parser(f1)
#a1=sp1.add_argument
#a1('ifile', help='table input file (columns separated by spaces or tab), no header/ column name/ index', widget='FileChooser')
#a1('-xcol1', action='store_true', help='column 1 is x-axis')
#a1('-ofile', help='output file, default: ifile_plot_table.png', widget='FileChooser')
#sp1.set_defaults(func=eval(f1))
f2 = 'csv_list_columns_index'
sp2 = sp.add_parser(f2)
a2 = sp2.add_argument
a2('ifile', help='csv input file', widget='FileChooser')
sp2.set_defaults(func=eval(f2))
f3 = 'csv_box_plot'
sp3 = sp.add_parser(f3)
a3 = sp3.add_argument
a3('ifile', help='csv input file', widget='FileChooser')
a3('columns', help='list column names separated by space')
sp3.set_defaults(func=eval(f3))
f4 = 'csv_violin_plot'
sp4 = sp.add_parser(f4)
a4 = sp4.add_argument
a4('ifile', help='csv input file', widget='FileChooser')
a4('columns', help='list column names separated by space')
sp4.set_defaults(func=eval(f4))
f5 = 'csv_scatter_plot'
sp5 = sp.add_parser(f5)
a5 = sp5.add_argument
a5('ifile', help='csv input file', widget='FileChooser')
a5('X', help='column name')
a5('Y', help='column name')
sp5.set_defaults(func=eval(f5))
f6 = 'csv_many_scatter_plots'
sp6 = sp.add_parser(f6)
a6 = sp6.add_argument
a6('ifile', help='csv input file', widget='FileChooser')
a6('columns', help='list column names separated by space')
sp6.set_defaults(func=eval(f6))
a = p.parse_args()
a.func(a)
def param_parser():
parser=GooeyParser(description="Make Data Obfuscated")
subs = parser.add_subparsers(help='commands', dest='command')
part3_parser = subs.add_parser('Replace_Z', help='Create a Tile layout with last Edited tiles ')
part3_parser.add_argument('source_data',metavar="Source Data", widget="DirChooser", help="Correct z")
part3_parser.add_argument('target_data',metavar="Target Data", widget="DirChooser", help="incorrect z")
part3_parser.add_argument("jsonfile", metavar="Tilelayout", widget="FileChooser",help="Provide the tilelayout")
part3_parser.add_argument("output_dir", metavar="Output Directory",widget="DirChooser", help="Output directory", default="")
part3_parser.add_argument('filetype',metavar="Input File Type", help="Select input file type", default='laz')
part3_parser.add_argument("--cores", metavar="Number of Cores", help="Number of cores", type=int, default=8)
args = parser.parse_args()
return args
def main():
path = os.getenv('LOCALAPPDATA')
array = os.listdir(path)
setup_run = portsConfig['setupRun']
parser = GooeyParser(
description="Generate Reports from Github Repositories using GitPorts")
subparsers = parser.add_subparsers(help="GitPorts Reports")
if not setup_run:
## Setup
setupPorts = subparsers.add_parser('setup',
help='Setup utils for GitPorts')
setupPorts.add_argument(
'-t',
metavar='Save User Token',
help='Output token to config file for quicker report generation',
type=str,
required=True)
setupPorts.add_argument('-o',
metavar='Default Repository Owner',
help='Default Repository Owner')
else:
## Issues
issuePorts = subparsers.add_parser(
'issue', help='GitPorts Report Generation for GitHub Issues')
issuePorts.add_argument('repo',
metavar='Repository',
help='Github Repo to generate report from',
type=str)
issuePorts.add_argument(
'-t',
metavar='User Token',
help='GitHub User Token for Repo (Set Default In Config)',
required=True,
type=str,
default=portsConfig['gitToken'])
issuePorts.add_argument(
'-p',
metavar='Page Count',
help='Number of pages to generate report from (100/page)',
default=1,
type=int)
issuePorts.add_argument(
'-l',
metavar='Issue Labels',
help='Filter based on Issue Labels (comma-seperated list)',
type=str)
parser.parse_args()
def main():
current_config, file_not_found = configure_peakcaller.load_config()
if file_not_found:
show_error_modal(
"No configuration file found at {}.\nWrote default configuration to that location.\nContinuing with default config."
.format(file_not_found))
parser = GooeyParser(description='Get Mass Peaks from Raw Lifescale Data')
subs = parser.add_subparsers(help='commands', dest='command')
add_call_peak_gui(subs, current_config)
add_config_gui(subs, current_config)
args = parser.parse_args()
opts = vars(args)
func = partial(DISPATCHER[args.command], config=current_config)
current_config = func(**opts)
def build_parser():
# we build a new parser for each subtest
# since we monkey patch the hell out of it
# each time
parser = GooeyParser()
subs = parser.add_subparsers()
foo = subs.add_parser('foo')
foo.add_argument('a')
foo.add_argument('b')
foo.add_argument('p')
bar = subs.add_parser('bar')
bar.add_argument('a')
bar.add_argument('b')
bar.add_argument('z')
return parser
def interface():
"""Gooey User Interface
Turn any Python command line program into a full GUI application
with one line. Follows argparse declaration format.
Other Parameters
----------------
program_name : str
Defaults to script name
program_description : str
Defaults to ArgParse Description
default_size : tuple
starting size of the GUI
navigation : str
Sets the "navigation" style of Gooey's top level window.
Choose between 'TABBED' or 'SIDEBAR'
tabbed_groups : bool
Tabbed the group instead of putting them in all in one window
image_dir : str
Path to the directory in which Gooey should look for
custom images/icons
monospace_display : bool
Uses a mono-spaced font in the output screen
Returns
-------
arg : obj
return arguments
"""
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='command')
subs = mechanical.add_parser(subs)
# subs = electrical.add_parser(subs)
# subs = cooperation.add_parser(subs)
if subs is not None:
args = parser.parse_args()
args.open_model = not args.open_model
args.recursive = not args.recursive
args.update_drawing_revision = not args.update_drawing_revision
args.update_parent_revision = not args.update_parent_revision
args.exclude_same_revision = not args.exclude_same_revision
args.output_report = not args.output_report
args.output_import = not args.output_import
return args
def main():
parser = GooeyParser()
subs = parser.add_subparsers(help='commands', dest='command')
parser_one = subs.add_parser('parser1', prog="Parser 1")
parser_one.add_argument('--textfield', default=2, widget="TextField")
parser_one.add_argument('--textarea', default="oneline twoline", widget='Textarea')
parser_one.add_argument('--password', default="hunter42", widget='PasswordField')
parser_one.add_argument('--commandfield', default="cmdr", widget='CommandField')
parser_one.add_argument('--dropdown',
choices=["one", "two"], default="two", widget='Dropdown')
parser_one.add_argument('--listboxie',
nargs='+',
default=['Option three', 'Option four'],
choices=['Option one', 'Option two', 'Option three',
'Option four'],
widget='Listbox',
gooey_options={
'height': 300,
'validate': '',
'heading_color': '',
'text_color': '',
'hide_heading': True,
'hide_text': True,
}
)
parser_one.add_argument('-c', '--counter', default=3, action='count',
widget='Counter')
#
parser_one.add_argument("-o", "--overwrite", action="store_true",
default=True,
widget='CheckBox')
### Mutex Group ###
verbosity = parser_one.add_mutually_exclusive_group(
required=True,
gooey_options={
'initial_selection': 1
}
)
verbosity.add_argument(
'--mutexone',
default=True,
action='store_true',
help="Show more details")
verbosity.add_argument(
'--mutextwo',
default='mut-2',
widget='TextField')
parser_one.add_argument("--filechooser", default="fc-value", widget='FileChooser')
parser_one.add_argument("--filesaver", default="fs-value", widget='FileSaver')
parser_one.add_argument("--dirchooser", default="dc-value", widget='DirChooser')
parser_one.add_argument("--datechooser", default="2015-01-01", widget='DateChooser')
parser_two = subs.add_parser('parser2', prog="parser 2")
parser_two.add_argument('--textfield', default=2, widget="TextField")
parser_two.add_argument('--textarea', default="oneline twoline",
widget='Textarea')
parser_two.add_argument('--password', default="hunter42", widget='PasswordField')
parser_two.add_argument('--commandfield', default="cmdr", widget='CommandField')
parser_two.add_argument('--dropdown',
choices=["one", "two"], default="two", widget='Dropdown')
parser_two.add_argument('--listboxie',
nargs='+',
default=['Option three', 'Option four'],
choices=['Option one', 'Option two', 'Option three',
'Option four'],
widget='Listbox',
gooey_options={
'height': 300,
'validate': '',
'heading_color': '',
'text_color': '',
'hide_heading': True,
'hide_text': True,
}
)
parser_two.add_argument('-c', '--counter', default=3, action='count',
widget='Counter')
#
parser_two.add_argument("-o", "--overwrite", action="store_true",
default=True,
widget='CheckBox')
### Mutex Group ###
verbosity = parser_two.add_mutually_exclusive_group(
required=True,
gooey_options={
'initial_selection': 1
}
)
verbosity.add_argument(
'--mutexone',
default=True,
action='store_true',
help="Show more details")
verbosity.add_argument(
'--mutextwo',
default='mut-2',
widget='TextField')
parser_two.add_argument("--filechooser", default="fc-value", widget='FileChooser')
parser_two.add_argument("--filesaver", default="fs-value", widget='FileSaver')
parser_two.add_argument("--dirchooser", default="dc-value", widget='DirChooser')
parser_two.add_argument("--datechooser", default="2015-01-01",widget='DateChooser')
dest_vars = [
'textfield',
'textarea',
'password',
'commandfield',
'dropdown',
'listboxie',
'counter',
'overwrite',
'mutextwo',
'filechooser',
'filesaver',
'dirchooser',
'datechooser'
]
parser.parse_args()
args = parser.parse_args()
import time
time.sleep(.6)
for i in dest_vars:
assert getattr(args, i) is not None
print("Success")
def main():
description_msg = 'Initiate batch downloads GPS collar data' \
' for commonly used collar websites'
parser = GooeyParser(description=description_msg)
# parser.add_argument('--verbose', help='output detailed text describing operation while executing',
# action='store_true', default=False)
subs = parser.add_subparsers(help='commands', dest='command')
tellus_parser = subs.add_parser('tellus', help='http://tellus.televilt.se')
vectronic_parser = subs.add_parser('vectronic',help='http://www.vectronic-wildlife.com')
sirtrack_parser = subs.add_parser('sirtrack',help='https://data.sirtrack.com')
#### Sirtrack #####
#Usage: sirtrack.rb [options]
# -u, --username user Username
# -p, --password password Password
# -d, --dir dir Directory
# -h, --help Displays Help
# -v, --[no-]verbose Run verbosely
# -x, --csv [CSV_FILENAME] Translate to single CSV/TXT
# (using filename if supplied)
# -z, --debug Run in debug mode
sirtrack_parser.add_argument('username', type=str,
help='User name for your account',
default='*****@*****.**')
sirtrack_parser.add_argument('password', type=str,
help='Password for your account (not secure)')
sirtrack_parser.add_argument('-d', '--dir', type=str,
help='Directory in which to download data files',
default='data')
# sirtrack_parser.add_argument('-b', '--begin', type=str, widget='DateChooser',
# help='beginning date to retrieve data from')
# sirtrack_parser.add_argument('-e', '--end', type=str, widget='DateChooser',
# help='ending date to retrieve data from')
# sirtrack_parser.add_argument('-h', '--help', dest='help', action="store_true",
# help='Display help with command options')
sirtrack_filename = 'sirtrack' + time.strftime("%Y%m%d") + '.txt'
# sirtrack_parser.add_argument('-x', '--csv', type=str,
# help='Translate to a single CSV/TXT file',
# default=sirtrack_filename)
sirtrack_parser.add_argument('-v', '--verbose', action='store_true',
help='output details of downloading process', default=True)
#### Vectronic ####
# Usage: vectronic.rb [options]
# -u, --username user Username
# -D, --database [database] db name
# -p, --password password Password
# -d, --dir dir Directory
# -h, --help Displays Help
# -b, --begin [date] Beginning date to retrieve data
# -e, --end [date] Ending date to retrieve data
# -v, --[no-]verbose Run verbosely
# -x, --csv [CSV_FILENAME] Translate to CSV/TXT
vectronic_parser.add_argument('username', type=str,
help='User name for your account', default='snbs')
vectronic_parser.add_argument('password', type=str,
help='Password for your account (not secure)')
vectronic_parser.add_argument('database', type=str,
help='database name',default='sierrabighorn')
vectronic_parser.add_argument('-d', '--dir', type=str, widget="DirChooser",
help='Directory in which to download data files', default='data')
vectronic_parser.add_argument('-b', '--begin', type=str, widget='DateChooser',
help='beginning date to retrieve data from')
vectronic_parser.add_argument('-e', '--end', type=str, widget='DateChooser',
help='ending date to retrieve data from')
vectronic_filename = 'vectronic_' + time.strftime("%Y%m%d") + '.txt'
vectronic_parser.add_argument('-x', '--csv', type=str, help='Translate to a single CSV/TXT file. Enter name of file.',
default=vectronic_filename)
vectronic_parser.add_argument('-v', '--verbose', action='store_true',
help='output details of downloading process', default=True)
#### Vectronic #####
#### Tellus #####
# Usage: tellus.rb [options]
# -u, --username user Username
# -p, --password password Password
# -d, --dir dir Directory
# -h, --help Displays Help
# -b, --begin [date] Beginning date to retrieve data
# -e, --end [date] Ending date to retrieve data
# -v, --[no-]verbose Run verbosely
# -x, --csv [CSV_FILENAME] Translate to single CSV/TXT
# (using filename if supplied)
# -z, --debug Run in debug mode
tellus_parser.add_argument('username', type=str,
help='User name for your account', default='david@desert')
tellus_parser.add_argument('password', type=str,
help='Password for your account (not secure)')
tellus_parser.add_argument('-d', '--dir', type=str, widget="DirChooser",
help='Directory in which to download data files', default='data')
tellus_parser.add_argument('-b', '--begin', type=str, widget='DateChooser',
help='beginning date to retrieve data from')
tellus_parser.add_argument('-e', '--end', type=str, widget='DateChooser',
help='ending date to retrieve data from')
tellus_filename = 'tellus_' + time.strftime("%Y%m%d") + '.txt'
tellus_parser.add_argument('-x', '--csv', type=str,
help='Translate to a single CSV/TXT file. Enter name of file.',
default=tellus_filename)
tellus_parser.add_argument('-v', '--verbose', action='store_true',
help='output details of downloading process', default=True)
#### Convert arguments to command line string: ####
interpreter = 'ruby'
args = parser.parse_args()
dargs = args.__dict__
command = dargs.pop('command')
program_file = 'bin/' + command + '.rb'
arg_list = []
for key in dargs:
if dargs[key] != None :
if len(key) == 1 :
prefix = "-"
elif len(key) > 1 :
prefix = "--"
option = prefix + key
arg_list.append(option)
arg = dargs[key]
if type(arg) == str :
arg_list.append(arg)
collardl_command = [interpreter, program_file] + arg_list
# program_file = args.command + '.rb'
print( "running the following command:")
print(args)
print( ' '.join(collardl_command))
dl_cmd = Popen(collardl_command)
def main():
settings_msg = 'Subparser example demonstating bundled configurations ' \
'for Siege, Curl, and FFMPEG'
parser = GooeyParser(description=settings_msg)
parser.add_argument('--verbose', help='be verbose', dest='verbose',
action='store_true', default=False)
subs = parser.add_subparsers(help='commands', dest='command')
curl_parser = subs.add_parser(
'curl', help='curl is a tool to transfer data from or to a server')
curl_parser.add_argument('Path',
help='URL to the remote server',
type=str, widget='FileChooser')
curl_parser.add_argument('--connect-timeout',
help='Maximum time in seconds that you allow curl\'s connection to take')
curl_parser.add_argument('--user-agent',
help='Specify the User-Agent string ')
curl_parser.add_argument('--cookie',
help='Pass the data to the HTTP server as a cookie')
curl_parser.add_argument('--dump-header', type=argparse.FileType,
help='Write the protocol headers to the specified file')
curl_parser.add_argument('--progress-bar', action="store_true",
help='Make curl display progress as a simple progress bar')
curl_parser.add_argument('--http2', action="store_true",
help='Tells curl to issue its requests using HTTP 2')
curl_parser.add_argument('--ipv4', action="store_true",
help=' resolve names to IPv4 addresses only')
# ########################################################
siege_parser = subs.add_parser(
'siege', help='Siege is an http/https regression testing and benchmarking utility')
siege_parser.add_argument('--get',
help='Pull down headers from the server and display HTTP transaction',
type=str)
siege_parser.add_argument('--concurrent',
help='Stress the web server with NUM number of simulated users',
type=int)
siege_parser.add_argument('--time',
help='allows you to run the test for a selected period of time',
type=int)
siege_parser.add_argument('--delay',
help='simulated user is delayed for a random number of seconds between one and NUM',
type=int)
siege_parser.add_argument('--message',
help='mark the log file with a separator',
type=int)
# ########################################################
ffmpeg_parser = subs.add_parser(
'ffmpeg', help='A complete, cross-platform solution to record, convert and stream audio and video')
ffmpeg_parser.add_argument('Output',
help='Pull down headers from the server and display HTTP transaction',
widget='FileSaver', type=argparse.FileType)
ffmpeg_parser.add_argument('--bitrate',
help='set the video bitrate in kbit/s (default = 200 kb/s)',
type=str)
ffmpeg_parser.add_argument('--fps',
help='set frame rate (default = 25)',
type=str)
ffmpeg_parser.add_argument('--size',
help='set frame size. The format is WxH (default 160x128)',
type=str)
ffmpeg_parser.add_argument('--aspect',
help='set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)',
type=str)
ffmpeg_parser.add_argument('--tolerance',
help='set video bitrate tolerance (in kbit/s)',
type=str)
ffmpeg_parser.add_argument('--maxrate',
help='set min video bitrate tolerance (in kbit/s)',
type=str)
ffmpeg_parser.add_argument('--bufsize',
help='set ratecontrol buffere size (in kbit)',
type=str)
parser.parse_args()
display_message()
