def main():
# TODO Add option to load previous guild id
parser = GooeyParser(description='Game listener')
parser.add_argument(
'guild_id',
metavar='Server ID',
help='Can be found using the .info command!'
)
parser.add_argument(
'vc_id',
metavar='Voice Channel ID',
help='Can be found using the .info command!'
)
args = parser.parse_args()
print(stylize("-----------------------------------------------------------------------------", attr("bold")))
print(stylize("Thanks for checking out ImposterBot!", attr("underlined")))
print(stylize("================================================", attr("bold")))
print(stylize("ImposterBot is an ongoing project and is open source.", fg("green")))
print("If you have any questions or issues or would like to learn more, check it out here:")
print(stylize("ImposterBot GitHub.", fg("blue") + attr("bold")))
print(stylize("https://github.com/shiv213/ImposterBot", fg("blue")))
print(stylize("Made with <3 by Shiv Trivedi.", fg("violet") + attr("bold")))
print(stylize("-----------------------------------------------------------------------------", attr("bold")))
while running:
pointer_loop()
time.sleep(1)
changes_loop()
if previous_state != current_state:
pushData["serverID"] = args.guild_id
pushData["vcID"] = args.vc_id
# pushData["roomCode"] = "TESTER"
# pushData["players"] = {}
# pushData["players"]["red"] = "alive"
# pushData["players"]["blue"] = "alive"
# pushData["players"]["green"] = "alive"
# pushData["players"]["pink"] = "alive"
# pushData["players"]["orange"] = "alive"
# pushData["players"]["yellow"] = "alive"
# pushData["players"]["black"] = "alive"
# pushData["players"]["white"] = "alive"
# pushData["players"]["purple"] = "alive"
# pushData["players"]["brown"] = "alive"
# pushData["players"]["cyan"] = "alive"
# pushData["players"]["lime"] = "alive"
if current_state == VoteState(0):
pushData["gameState"] = "game"
print(stylize("MUTED", fg("red") + attr("bold")))
else:
pushData["gameState"] = "discussion"
print(stylize("UNMUTED", fg("green") + attr("bold")))
# print(pushData)
response = requests.post('https://imposter-bot.herokuapp.com/push', json=pushData)
# response = requests.post('http://127.0.0.1/push', json=pushData)
if response.status_code != 200:
print("Connection error!")
def main():
parser = GooeyParser()
parser.add_argument('filename1')
parser.add_argument('secret-advanced-argument',
default='TOO POWERFUL!!',
gooey_options={'visible': False})
args = parser.parse_args()
def param_parser():
parser = GooeyParser(description="Valeria Prod Gen tool")
parser.add_argument("input_folder",
metavar="Input Directory ",
widget="DirChooser",
help="Select folder with input files")
parser.add_argument("output_dir",
metavar="Output Directory",
widget="DirChooser",
help="Output directory")
parser.add_argument("workingpath",
metavar="working Directory",
widget="DirChooser",
help="working directory")
parser.add_argument("inputtilelayoutfile",
metavar="Input TileLayout file",
widget="FileChooser",
help="TileLayout file(.json)")
parser.add_argument("-hydropoints",
metavar="Hydropoints file",
widget="FileChooser",
help=".laz file")
parser.add_argument("aoi",
metavar="AOI file",
widget="FileChooser",
help=".shp file")
parser.add_argument("-co",
"--cores",
metavar="Cores",
help="No of cores to run in",
type=int,
default=8)
return parser.parse_args()
def parse_args():
# parser = argparse.ArgumentParser(description='Anonymise DICOM images')
parser = GooeyParser(description='Anonymise DICOM images')
parser.add_argument('source', type=str, metavar="Source",
widget="DirChooser",
help='location of dicom file or folder to anonymise')
parser.add_argument('destination', type=str, metavar="Destination",
widget="DirChooser",
help='Destination folder to save anonymised images')
parser.add_argument('-t', '--tagfile', default=default_tagfile_text, metavar="Tag file",
widget="FileChooser",
help='path to custom tags file')
parser.add_argument('-i', '--intact', action="store_true", metavar="Intact",
help='Leave filenames unchanged')
args = parser.parse_args()
args.tagfile = Path(args.tagfile)
args.source = Path(args.source)
args.destination = Path(args.destination)
if (args.source == args.destination) and (args.intact_filename):
print('Source and destination are the same and filenames to be left intact. This will overwrite original files. Exiting.')
sys.exit()
return args
def main():
parser = GooeyParser(description="Extracting frames from a movie using FFMPEG")
ffmpeg = parser.add_argument_group('Frame Extraction Util')
ffmpeg.add_argument('-i',
metavar='Input Movie',
help='The movie for which you like extract frames',
required=True,
widget='FileChooser')
ffmpeg.add_argument('output',
metavar='Output Image',
help='Where to save the extracted frame',
widget='FileSaver',
)
ffmpeg.add_argument('-ss',
metavar='Timestamp',
required=True,
help='Timestamp of snapshot (in seconds)',
gooey_options={
'validator': {
'test': 'user_input.isdigit()',
'message': 'Please enter a number'
}
})
ffmpeg.add_argument('-frames:v',
metavar='Timestamp',
default=1,
required=True,
gooey_options={'visible': False})
parser.parse_args()
def main():
mk_savedir() # Make directory to store user's save files
parser = GooeyParser(
description='An example of polling for updates at runtime')
g = parser.add_argument_group()
stuff = g.add_mutually_exclusive_group(
required=True, gooey_options={'initial_selection': 0})
stuff.add_argument('--save',
metavar='Save Progress',
action='store_true',
help='Take a snap shot of your current progress!')
stuff.add_argument('--load',
metavar='Load Previous Save',
help='Load a Previous save file',
dest='filename',
widget='Dropdown',
choices=list_savefiles(),
gooey_options={
'validator': {
'test': 'user_input != "Select Option"',
'message': 'Choose a save file from the list'
}
})
args = parser.parse_args()
if args.save:
save_file()
else:
read_file(os.path.join('saves', args.filename))
print('Finished reading file!')
def main():
desc = "Example application to show Gooey's various widgets"
file_help_msg = "Name of the file you want to process"
my_cool_parser = GooeyParser(description=desc)
my_cool_parser.add_argument("FileChooser", help=file_help_msg, widget="FileChooser")
my_cool_parser.add_argument("DirectoryChooser", help=file_help_msg, widget="DirChooser")
my_cool_parser.add_argument("FileSaver", help=file_help_msg, widget="FileSaver")
my_cool_parser.add_argument("MultiFileSaver", help=file_help_msg, widget="MultiFileChooser")
my_cool_parser.add_argument("MultiDirChooser", help=file_help_msg, widget="MultiDirChooser")
my_cool_parser.add_argument("directory", help="Directory to store output")
my_cool_parser.add_argument('-d', '--duration', default=2, type=int, help='Duration (in seconds) of the program output')
my_cool_parser.add_argument('-s', '--cron-schedule', type=int, help='datetime when the cron should begin', widget='DateChooser')
my_cool_parser.add_argument("-c", "--showtime", action="store_true", help="display the countdown timer")
my_cool_parser.add_argument("-p", "--pause", action="store_true", help="Pause execution")
my_cool_parser.add_argument('-v', '--verbose', action='count')
my_cool_parser.add_argument("-o", "--overwrite", action="store_true", help="Overwrite output file (if present)")
my_cool_parser.add_argument('-r', '--recursive', choices=['yes', 'no'], help='Recurse into subfolders')
my_cool_parser.add_argument("-w", "--writelog", default="writelogs", help="Dump output to local file")
my_cool_parser.add_argument("-e", "--error", action="store_true", help="Stop process on error (default: No)")
verbosity = my_cool_parser.add_mutually_exclusive_group()
verbosity.add_argument('-t', '--verbozze', dest='verbose', action="store_true", help="Show more details")
verbosity.add_argument('-q', '--quiet', dest='quiet', action="store_true", help="Only output on error")
args = my_cool_parser.parse_args()
display_message()
def main():
parser = GooeyParser()
g = parser.add_argument_group('Параметры', 'Задайте Параметры Поиска')
g.add_argument('dict',
help='выберите словарь',
widget='Dropdown',
choices=list(os.listdir('dicts')))
g.add_argument('regex', help='введите маску')
g.add_argument('number', help='введите кол-во слов')
args = parser.parse_args()
tree = ET.parse(f'dicts/{args.dict}/dict.xdxf')
root = tree.getroot()
count = 0
n = int(args.number)
with open('WORDS.txt', 'w', encoding='UTF-8') as fout:
for article in root.iterfind('ar'):
for key in article.iterfind('k'):
if re.search(args.regex, key.text):
print(
key.text.strip(), file=fout, flush=True
) # очищение буфера, для немедленного сохранения в файл
print("progress: {}/{}".format(count + 1, n))
sleep(0.001)
count += 1
if count >= n:
break
if count >= n:
break
def main():
# Gooey stuff
parser = GooeyParser(description="Gather AncestryDNA Matches")
username = parser.add_argument('username', metavar='Ancestry User Name')
password = parser.add_argument('password',
metavar='Ancestry Password',
widget='PasswordField')
user_max = parser.add_argument(
'pages',
metavar='Number of match pages to gather',
help='1 page is about 50 matches. Default is 30 pages (~1500 matches).'
)
if user_max == "":
user_max = "30"
max_pages = int(user_max)
args = parser.parse_args()
# Delete old files
delete_old()
# Create new files
make_data_file("nodes.csv")
make_data_file("edges.csv")
# Login
# username, password, max_pages = get_credentials()
payload = {"username": username, "password": password}
# Create session object
session_requests = requests.session()
# Start Session
with session_requests as session:
session.post(login_url, data=payload)
data = get_json(session, prefix_url)
# Get the list of tests available
test_guids = get_guids(data)
print()
for k, v in test_guids.items(): # Print them out...work on formatting
print("Test", str(k) + ":", v[0], v[1])
print()
test_selection = int(
input("Select the Test # that you want to gather \
matches for: "))
guid = test_guids[test_selection][1]
# Start to gather match data using number of pages variable
print("Gathering match details. Please wait.")
for page_number in range(1, max_pages + 1):
test_url = str(prefix_url + guid + matches_url_suffix +
str(page_number))
matches = get_json(session, test_url)
harvest_matches(session, matches, guid)
time.sleep(1)
def create_arg_parser():
arg_parser = GooeyParser()
group = arg_parser.add_argument_group('Input/Output',
gooey_options={'columns': 1})
group.add_argument(
dest='divisions_file',
widget='FileChooser',
help=
('The CSV with division information; see the Division Columns tab for details.'
))
group.add_argument(
dest='professors_file',
widget='FileChooser',
help=
'The CSV with professor information; see Professor Columns tab for details.',
)
group.add_argument(
dest='students_file',
widget='FileChooser',
help=
'The CSV with student information; see the Student Columns tab for details.'
)
group.add_argument(
dest='output_dir',
default='~/Desktop/',
widget='DirChooser',
help='The folder to put the output.csv.',
)
return arg_parser
def gui_main():
parser = GooeyParser(
description="Creating blanks for C language source code files")
parser.add_argument('source_dir', widget='DirChooser',
help="The directory containing source code files to be processed.")
args = parser.parse_args()
main(args.source_dir)
def param_parser():
main_parser = GooeyParser(description="Check Header")
main_parser.add_argument("inputfolder",
metavar="Input Folder",
widget="DirChooser",
help="Select input las/laz folder",
default="")
main_parser.add_argument("outputfolder",
metavar="Output Folder",
widget="DirChooser",
help="Select output folder",
default="")
main_parser.add_argument("filetype",
metavar="Input File Type",
default='laz')
main_parser.add_argument("attrib",
metavar="Attribute To search",
default='')
main_parser.add_argument("cores",
metavar="Cores",
help="No of cores to run in",
type=int,
default=8)
return main_parser.parse_args()
def arbitrary_function():
desc = u"コマンドライン引数を入力してください"
file_help_msg = u"処理したいファイルの名前"
my_cool_parser = GooeyParser(description=desc)
my_cool_parser.add_argument('foo',
metavar=u"ファイルブラウザ",
help=file_help_msg,
widget="FileChooser") # positional
my_cool_parser.add_argument('-d',
metavar=u'--デュレーション',
default=2,
type=int,
help=u'プログラム出力の期間（秒）')
my_cool_parser.add_argument('-s',
metavar=u'--スケジュール',
help=u'日時プログラムを開始すべき',
widget='DateChooser')
my_cool_parser.add_argument("-c",
metavar=u"--ショータイム",
action="store_true",
help=u"カウントダウンタイマーを表示します")
my_cool_parser.add_argument("-p",
metavar=u"--ポーズ",
action="store_true",
help=u"一時停止の実行")
args = my_cool_parser.parse_args()
main(args)
def makeParser(self, **kwargs):
parser = GooeyParser(description='description')
parser.add_argument('--widget',
action='count',
widget="Counter",
**kwargs)
return parser
def get_parser() -> argparse.ArgumentParser:
parser = GooeyParser()
parser.add_argument(
nargs="*",
default=["foo bar"],
dest="multi_arg",
)
parser.add_argument('--foo', nargs=1, default=['a', 'b'])
# parser.add_argument(
# '--bar',
# nargs='+',
# choices=["one", "two"],
# default="one",
# )
parser.add_argument(
'--listboxie',
metavar='Multiple selection',
nargs='+',
# default=['Option three', 'Option four'],
default='123',
choices=[123, 'Option two', 'Option three', 'Option four'],
help='Choose an action!',
widget='Listbox',
gooey_options={
# 'height': 500,
'validate': '',
'heading_color': '',
'text_color': '',
'show_label': False,
'hide_text': True,
})
return parser
def param_parser():
main_parser = GooeyParser(description="Reading XML")
main_parser.add_argument("variable_file",
metavar="Variable text File",
widget="FileChooser",
help="Select .txt file",
default="")
main_parser.add_argument("xml",
metavar="XML template File",
widget="FileChooser",
help="Select .xml file",
default="")
main_parser.add_argument("wd",
metavar="Word template File",
widget="FileChooser",
help="Select .docx file",
default="")
main_parser.add_argument("outputpath",
metavar="Output Directory",
widget="DirChooser",
help="Output directory",
default='')
main_parser.add_argument("fid1", metavar="File ID 1", default='')
main_parser.add_argument("fid2", metavar="File ID 2", default='')
main_parser.add_argument("fid3", metavar="File ID 3", default='')
main_parser.add_argument("fid4", metavar="File ID 4", default='')
main_parser.add_argument("flownyear", metavar="Year Flown", default='2018')
return main_parser.parse_args()
def main():
parser = GooeyParser(description='Getting Over it without the "Hurt"')
g = parser.add_argument_group()
stuff = g.add_mutually_exclusive_group(
required=True, gooey_options={'initial_selection': 0})
stuff.add_argument('--save',
metavar='Save Progress',
action='store_true',
help='Take a snap shot of your current progress!')
stuff.add_argument('--load',
metavar='Load Previous Save',
help='Load a Previous save file',
dest='filename',
widget='Dropdown',
choices=list_savefiles(),
gooey_options={
'validator': {
'test': 'user_input != "Select Option"',
'message': 'Choose a save file from the list'
}
})
args = parser.parse_args()
print(args)
if args.save:
save_registry(collect_regvals(load_regkey()))
else:
replace_reg_values(load_regkey(),
load_registry(os.path.join('saves', args.filename)))
print('Successfully Loaded snapshot!')
print('Make sure to fix your mouse sensitivity! ^_^\n')
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():
argparser = GooeyParser(
description='Sort out messy folders with many files')
argparser.add_argument('-i',
'--input',
help="name of the sortfile to process",
widget='FileChooser')
# argparser.add_argument(
# '-i', '--input',
# action='store',
# type=str,
# help='Name of sort file: User self defined csv of keywords to filter sorted files.'
# )
argparser.add_argument(
'-e',
'--ext',
action='store_true',
help='Use this to set to use extensions as sort destination')
argparser.add_argument(
'-t',
'--type',
choices=fileExts.keys(),
type=str.lower,
help=
'Preset defined categories to filter on eg Documents. Default = All files if flag not specified'
)
args = argparser.parse_args()
args = checkType(args)
welcome()
organise(args)
def param_parser():
parser = GooeyParser(description="Add attributes to a Tile Layout")
parser.add_argument("inputfile",
metavar="Input Tilelayout File",
widget="FileChooser",
help="Select Tilelayout json file")
parser.add_argument("output_dir",
metavar="Output Directory",
widget="DirChooser",
help="Output directory",
default="")
attr_group = parser.add_argument_group("Attribute",
gooey_options={
'show_border': True,
'columns': 3
})
attr_group.add_argument("attrname",
metavar="Attribute Name",
help="Attribute Name\n\n")
attr_group.add_argument(
"attrval",
metavar="Attribute Value",
help=
"if Naming convention for files used, \nreplace x,y with %X% and %Y%.\nex: dem_%X%m_%Y%m.asc"
)
attr_group.add_argument(
"--division",
metavar="Shorten X, Y",
help=
"Reduce the X and Y values to the nearest 100,1000. \nleave blank for None\n",
type=int)
args = parser.parse_args()
return args
def main():
if is_windows:
ctypes.windll.shcore.SetProcessDpiAwareness(2)
parser = GooeyParser(description='')
parser.add_argument('--src',
metavar='源目录',
widget='DirChooser',
help='源目录, 如大疆SD的目录就是: X:\\DCIM')
parser.add_argument(
'--dst',
metavar='输出目录',
widget='DirChooser',
help='目的目标, 如D:\\Target，则会将DCIM内的文件拷贝到D:\\Target\\DCIM')
argcomplete.autocomplete(parser)
args = parser.parse_args()
if not args.src or not args.dst:
parser.print_usage()
exit(1)
if not os.path.exists(args.src):
print('source path:{} does not exist.'.format(args.src))
exit(1)
if not os.path.exists(args.src):
print('source path:{} does not exist.'.format(args.dst))
exit(1)
print('{} -> {}'.format(args.src, args.dst))
args.dst = util.get_copy_dst_name(args.src, args.dst)
copy_files(args.src, args.dst)
error = check_copy(args.src, args.dst)
if error:
exit(1)
exit(0)
def main():
parser = GooeyParser(description="Open HTML File")
parser.add_argument("File Path",
help="Provide a file path to an .html file.",
widget='FileChooser')
parser.add_argument('-d',
'--Delete Blanks',
choices=['yes', 'no'],
help='Delete all blank buttons?')
parser.add_argument("-o",
"--Overwrite",
action="store_true",
help="Overwrite input file")
parser.add_argument('-n',
"--New File Path",
help="Provide a path to save processed file to",
widget="FileSaver")
#get arguments from parser
parser_args = parser.parse_args()
parser_vars = vars(parser_args)
#open and prepare new html file for processing
my_file = soupaccessories.open_existing_file(parser.parse_args())
my_soup_handler = Soup_Handler(my_file)
#check to see what user wanted to do
if (parser_vars['Delete Blanks'] == 'yes'):
my_soup_handler.delete_all_blank_top_buttons(my_soup_handler.soup)
#check to see if we overwrite old file or create new one
if (parser_vars['Overwrite']):
my_soup_handler.overwrite_input_file(my_soup_handler.soup)
else:
my_soup_handler.save_as_new_file(my_soup_handler.soup,
parser_vars['New File Path'])
def test_required_not_enforced(self):
parser = GooeyParser()
ArgumentParser.original_parse_args = ArgumentParser.parse_args
parser.add_argument('--arg', type=int, required=True)
parser.add_argument('--argn', type=int, nargs='+')
parser.add_argument('argp', type=int)
mutex = parser.add_mutually_exclusive_group(required=True)
mutex.add_argument('--one', action='store_true')
mutex.add_argument('--two', action='store_true')
# No error when we don't provide required arguments
cmd_args.parse_cmd_args(parser)
# Test that required/argn have been restored in parser
argrequired = next(action for action in parser._actions
if action.dest == 'arg').required
self.assertEqual(argrequired, True)
argnnargs = next(action for action in parser._actions
if action.dest == 'argn').nargs
self.assertEqual(argnnargs, '+')
argpnargs = next(action for action in parser._actions
if action.dest == 'argp').nargs
self.assertEqual(argpnargs, None)
mutexrequired = next(
mutex for mutex in parser._mutually_exclusive_groups).required
self.assertEqual(mutexrequired, True)
def init_args():
parser = GooeyParser(description='Lyric Scraper')
# Required Parameters
parser.add_argument(
'--scan_dir',
required=True,
metavar='Scan Directory',
help='Path to the directory to scan for music. Scans recursively',
widget='DirChooser')
# Optional Parameters
optional_group = parser.add_argument_group('Optional Options', )
optional_group.add_argument('--embed',
required=False,
metavar='Write IDv3 Tags',
action='store_true',
help='Write any scraped lyrics to IDv3 tags')
optional_group.add_argument(
'--force',
required=False,
metavar='Force Overwrite',
action='store_true',
help='Forces program to overwrite existing txt (lyric) files')
optional_group.add_argument('--debug',
required=False,
metavar='Enable Debug mode',
action='store_true',
help='Change logging level to debug')
return parser.parse_args()
def arbitrary_function():
desc = u"Пример приложения , чтобы показать "
file_help_msg = u"Имя файла, который вы хотите обработать"
my_cool_parser = GooeyParser(description=desc)
my_cool_parser.add_argument('foo',
metavar=u"выборафайлов",
help=file_help_msg,
widget="FileChooser")
my_cool_parser.add_argument('bar',
metavar=u"Несколько файлов Сохранить",
help=file_help_msg,
widget="MultiFileChooser")
my_cool_parser.add_argument(
'-d',
metavar=u'--продолжительность',
default=2,
type=int,
help=u'Продолжительность ( в секундах ) на выходе программы')
my_cool_parser.add_argument('-s',
metavar=u'--крон - график',
help=u'Дата',
widget='DateChooser')
args = my_cool_parser.parse_args()
main(args)
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=
'Format redcap export for ADM import\n(Assumes REDCap form is in order of actual CBCL questionnaire)'
)
required_group = parser.add_argument_group('Required Arguments',
gooey_options={'columns': 1})
required_group.add_argument('--export_file',
required=True,
widget='FileChooser',
help='Demographics + CBCL export from REDCap')
required_group.add_argument('--data_dict',
required=True,
widget='FileChooser',
help='REDCap data dictionary export for CBCL')
required_group.add_argument('--output_folder',
required=True,
widget='DirChooser',
help='Folder to store output CBC files')
required_group.add_argument(
'--age_var',
required=True,
help=
'REDCap variable containing subject age (i.e. childs_age, age_decimal)'
)
return parser
def main():
cli = GooeyParser(description='Utils')
required_args = cli.add_argument_group("Required Arguments")
required_args.add_argument('-i',
'--in',
required=True,
metavar='PATH',
dest='inpath')
required_args.add_argument('-o',
'--out',
required=True,
metavar='PATH',
dest='outpath')
advanced_section = cli.add_argument_group(
"Advanced Options",
description='Change these options at your own risk!!!',
gooey_options={'show_border': True})
advanced_section.add_argument(
'--dont-destroy-computer',
help='When enabled this will NOT cause an explosion',
metavar="Avoid Violently Delf Destruct",
action='store_true',
widget='BlockCheckbox',
default=True)
args = cli.parse_args()
def add(parser: GooeyParser = GooeyParser()) -> GooeyParser:
parser.add_argument(
'data_path',
widget='FileChooser',
metavar='Data Path',
help="Data path (file path of .csv format)",
)
parser.add_argument(
"--x_columns",
type=str,
metavar='The x columns you want to use',
default="CRIM,ZN,INDUS,CHAS,NOX,RM,AGE,DIS,RAD,TAX,PTRATIO,B,LSTAT",
help='At least one columns must be selected.',
)
parser.add_argument(
"--y_column",
type=str,
metavar='The y columns you want to use',
default='MEDV',
help='Only one column must be selected',
)
return parser
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)
