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 main():
# get some settings from setting file
settings = SettingFileReader()
defaultOutput = settings.getSetting("defaultSettings", "output")
defaultWidth = settings.getSetting("defaultSettings", "width")
defaultFramerate = settings.getSetting("defaultSettings", "framerate")
defaultBitrateKb = settings.getSetting("defaultSettings", "bitratekb")
description = "Compose a timelapse movie from a sequence of jpg images"
#parser = argparse.ArgumentParser(description=description)
parser = GooeyParser(description=description)
parser.add_argument('-input', required=True, type=argparse.FileType('r'), help='A jpeg file from the sequence' , widget="FileChooser")
parser.add_argument('-output', required=False, default=defaultOutput, help='Output sequence file name (default : ' + defaultOutput + ')' )
parser.add_argument('-width', required=False, default=defaultWidth, type=int, help='With of the output sequence (default : ' + str(defaultWidth) + ')' )
parser.add_argument('-height', required=False, type=int, help='height of the output sequence (default : keeps proportion to width)' )
parser.add_argument('-framerate', required=False, default=defaultFramerate, type=int, help='Framerate of the output sequence (default : ' + str(defaultFramerate) + ')' )
parser.add_argument('-bitrate', required=False, default=1920, type=int, help='Bitrate of the output sequence in kb/s (default : ' + str(defaultBitrateKb) + 'kb/s)' )
args = parser.parse_args()
print args.input.name
print args.output
print args.width
print args.height
print args.framerate
print args.bitrate
def _parser():
parser = GooeyParser(description='Filter the linelist by a'
' column and an upper limit')
parser.add_argument('input', help='Input linelist', widget='FileChooser')
parser.add_argument('col',
help='Column to be sorted (starting at 0)',
type=int)
parser.add_argument('limit',
help='The upper limit on the column',
type=float)
parser.add_argument('-o', '--output',
help='The output linelist',
default=None)
parser.add_argument('-s', '--sign',
help='Include values above',
default=False,
action='store_true'
)
parser.add_argument('-e', '--element',
help='If value is 26.1 then FeII lines will'
' not be removed.',
default=26.1,
type=float)
args = parser.parse_args()
return args
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") # positional
my_cool_parser.add_argument("DirectoryChooser", help=file_help_msg, widget="DirChooser") # positional
my_cool_parser.add_argument("FileSaver", help=file_help_msg, widget="FileSaver") # positional
my_cool_parser.add_argument("MultiFileSaver", help=file_help_msg, widget="MultiFileChooser") # positional
my_cool_parser.add_argument("MultiDirChooser", help=file_help_msg, widget="MultiDirChooser") # positional
my_cool_parser.add_argument("directory", help="Directory to store output") # positional
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 arbitrary_function():
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") # positional
# my_cool_parser.add_argument("DirectoryChooser", help=file_help_msg, widget="DirChooser") # positional
# my_cool_parser.add_argument("FileSaver", help=file_help_msg, widget="FileSaver") # positional
# my_cool_parser.add_argument("MultiFileSaver", help=file_help_msg, widget="MultiFileChooser") # positional
# my_cool_parser.add_argument("directory", help="Directory to store output") # positional
my_cool_parser.add_argument('-c', '--countdown', default=2, type=int, help='sets the time to count down from you see its quite simple!')
my_cool_parser.add_argument('-j', '--cron-schedule', type=int, help='Set the datetime when the cron should begin', widget='DateChooser')
my_cool_parser.add_argument("-s", "--showtime", action="store_true", help="display the countdown timer")
my_cool_parser.add_argument("-d", "--delay", action="store_true", help="Delay execution for a bit")
my_cool_parser.add_argument('-v', '--verbose', action='count')
my_cool_parser.add_argument("-o", "--obfuscate", action="store_true", help="obfuscate the countdown timer!")
my_cool_parser.add_argument('-r', '--recursive', choices=['yes', 'no'], help='Recurse into subfolders')
my_cool_parser.add_argument("-w", "--writelog", default="No, NOT whatevs", help="write log to some file or something")
my_cool_parser.add_argument("-e", "--expandAll", action="store_true", help="expand all processes")
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")
print my_cool_parser._actions
print 'inside of main(), my_cool_parser =', my_cool_parser
args = my_cool_parser.parse_args()
main(args)
def arbitrary_function():
desc = u"\u041f\u0440\u0438\u043c\u0435\u0440 \u043f\u0440\u0438\u043b\u043e\u0436\u0435\u043d\u0438\u044f \u002c \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u043a\u0430\u0437\u0430\u0442\u044c "
file_help_msg = u"\u0418\u043c\u044f \u0444\u0430\u0439\u043b\u0430\u002c \u043a\u043e\u0442\u043e\u0440\u044b\u0439 \u0432\u044b \u0445\u043e\u0442\u0438\u0442\u0435 \u043e\u0431\u0440\u0430\u0431\u043e\u0442\u0430\u0442\u044c"
my_cool_parser = GooeyParser(description=desc)
my_cool_parser.add_argument(
'foo',
metavar=u"\u0432\u044b\u0431\u043e\u0440\u0430\u0444\u0430\u0439\u043b\u043e\u0432",
help=file_help_msg,
widget="FileChooser")
my_cool_parser.add_argument(
'bar',
metavar=u"\u041d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0444\u0430\u0439\u043b\u043e\u0432 \u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c",
help=file_help_msg,
widget="MultiFileChooser")
my_cool_parser.add_argument(
'-d',
metavar=u'--\u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c',
default=2,
type=int,
help=u'\u041f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u0028 \u0432 \u0441\u0435\u043a\u0443\u043d\u0434\u0430\u0445 \u0029 \u043d\u0430 \u0432\u044b\u0445\u043e\u0434\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b')
my_cool_parser.add_argument(
'-s',
metavar=u'--\u043a\u0440\u043e\u043d \u002d \u0433\u0440\u0430\u0444\u0438\u043a',
help=u'\u0414\u0430\u0442\u0430',
widget='DateChooser')
args = my_cool_parser.parse_args()
main(args)
def parse_args_gooey():
'''parse command line arguments'''
parser = GooeyParser(description='Search images for Joe')
parser.add_argument("directory", default=None, help="directory containing image files", widget='DirChooser')
parser.add_argument("--mission", default=None, type=file, help="mission file to display", widget='FileChooser')
parser.add_argument("--mavlog", default=None, type=file, help="MAVLink telemetry log file", widget='FileChooser')
parser.add_argument("--kmzlog", default=None, type=file, help="kmz file for image positions", widget='FileChooser')
parser.add_argument("--triggerlog", default=None, type=file, help="robota trigger file for image positions", widget='FileChooser')
parser.add_argument("--time-offset", type=float, default=0, help="offset between camera and mavlink log times (seconds)")
parser.add_argument("--view", action='store_true', default=False, help="show images")
parser.add_argument("--saveview", action='store_true', default=False, help="save image view")
parser.add_argument("--lens", default=28.0, type=float, help="lens focal length")
parser.add_argument("--sensorwidth", default=35.0, type=float, help="sensor width")
parser.add_argument("--service", default='MicrosoftSat',
choices=['GoogleSat', 'MicrosoftSat', 'OviSat', 'OpenStreetMap', 'MicrosoftHyb', 'OviHybrid', 'GoogleMap'], help="map service")
parser.add_argument("--camera-params", default=None, type=file, help="camera calibration json file from OpenCV", widget='FileChooser')
parser.add_argument("--debug", default=False, action='store_true', help="enable debug info")
parser.add_argument("--roll-stabilised", default=False, action='store_true', help="assume roll stabilised camera")
parser.add_argument("--rotate-180", default=False, action='store_true', help="rotate images 180 degrees")
parser.add_argument("--altitude", default=0, type=float, help="altitude (0 for auto)")
parser.add_argument("--thumbsize", default=60, type=int, help="thumbnail size")
parser.add_argument("--mosaic-thumbsize", default=35, type=int, help="mosaic thumbnail size")
parser.add_argument("--minscore", default=100, type=int, help="minimum score")
parser.add_argument("--gammalog", default=None, type=str, help="gamma.log from flight", widget='FileChooser')
parser.add_argument("--target", default=None, type=str, help="lat,lon,radius target")
parser.add_argument("--categories", default=None, type=str, help="xml file containing categories for classification", widget='FileChooser')
if 1 != len(sys.argv):
parser.add_argument("--flag", default=[], type=str, action='append', help="flag positions"),
parser.add_argument("--blue-emphasis", default=False, action='store_true', help="enable blue emphasis in scanner")
return parser.parse_args()
def main():
desc = "Example application to show Gooey's various widgets"
parser = GooeyParser(prog="example_progress_bar_1")
_ = parser.parse_args(sys.argv[1:])
import time
time.sleep(1)
print('Success')
def main():
parser = GooeyParser(prog="example_progress_bar_1")
_ = parser.parse_args(sys.argv[1:])
for i in range(100):
print("progress: {}%".format(i + 1))
sys.stdout.flush()
sleep(0.1)
def initOptParser():
parser = GooeyParser(description="Copy files to specified location")
# Option for the path of files to move (can be a full directory).
parser.add_argument('--files', metavar='file', nargs='*',
help='file(s) you wish to copy', widget="MultiFileChooser")
parser.add_argument('--directories', metavar='dir', nargs='*', help="The directorie(s) you wish to copy.", widget="MultiDirChooser")
# Option to specify which project said files go to.
parser.add_argument('-p', '--path', metavar='path',dest='path', type=str,
help='Path which will be considered as root of all projects. Default is currently : ' + utils.defaultFolderPath,
default=utils.defaultFolderPath, widget="DirChooser")
parser.add_argument('projectName', metavar='projectName', type=str,
help='The project you wish to retrieve/add files to/from.')
# Option to specify the version name of the commit.
parser.add_argument('-v', '--version', metavar='versionName', type=str,
help='The name of the directory which will be created during an update. By default, this will be : VERSION_X.')
# Option allowing overwrite of current version.
parser.add_argument('-m', '--message', metavar='logMessage', type=str, help='Use to specify a log message which will be put in a versFile at the root of the project directory.')
# Specify --get to retrieve files instead of commiting them.
parser.add_argument('-g', '--get', dest='method', action='store_const', help='Retrieve files from project (last version by default)', const=get.get, default=push.push)
# Allows 'locking'. Not really a lock. Basically a warning message to all users who try to check out if a user checked out without commiting his files.
parser.add_argument('-l', '--lock', action="store_true",
help='Locks the current project. '+
'Unlocked when next push from the locking user is made')
# User name. Just to allow 'locking'/'unlocking'
parser.add_argument('user', metavar='userName', type=str, help='Specify your name.')
parser.add_argument('-a', '--archive', metavar='archivePath', type=str, help='Use to specify a directory which will be used as an archive. Current default is : ' + utils.archivePath, widget="DirChooser")
# Will pop up a windows fileselector to choose which files will be copied.
parser.add_argument('-s', '--store', metavar="destPath", help='Use to specify where you want the files retrieved from the project to be copied.', widget="DirChooser")
# Function to call to get all arguments.
args = parser.parse_args()
#print(args.files)
#print(args.directories)
if (args.files == None and args.directories == None):
return (None)
if (args.files and args.directories):
args.files = args.files + args.directories#args.files[0].split(";") + args.directories[0].split(";")
elif (args.directories):
args.files = args.directories
print("The following files/directories will be copied (along with all sub-directories) :")
for myFile in args.files:
print("- [" + myFile + "]")
return (args)
def main():
parser = GooeyParser(description='Zelda clean this mess\nReorganize date/pod -> pod/date')
parser.add_argument('pattern', nargs='?', default=r"""(.*)_(.*)_(.*)_(.*)_(.*)_(.*)-(.{8})-(.*).datx_(.*)""",
help="pattern which allow to get groups\nmoteur = mo.group(1)\nuseless = mo.group(2)\nbanc = mo.group(3)\npod = mo.group(4)\nuseless = mo.group(5)\nrun = mo.group(6)\ndate = mo.group(7)\nheure = mo.group(8)")
parser.add_argument('srcDir', nargs='?', default=os.getcwd(), widget='FileChooser',
help='Engine directory : root/???/*.*')
args = parser.parse_args()
Zelda.trier(args.srcDir, args.pattern)
def generate_trials_gui():
# General information
parser = GooeyParser(description='Create_general_experiment')
parser.add_argument('Number_of_blocks', default=1, action='store', type=int, help='Number')
parser.add_argument('Number_of_training_trials', default=4, action='store', type=int, help='Number')
parser.add_argument('Number_of_experiment_trials', default=4, action='store', type=int, help='Number')
parser.add_argument('File_name', default='experiment', type=str, help='Name of file with not personalized data')
parser.add_argument('--Instruction', widget='FileChooser', help='Choose instruction file')
parser.add_argument('--Instruction_show_time', default=5, action='store', type=int, help='Number')
# Information about training
parser.add_argument('--Training_task', default='letters',
choices=['letters', 'figures', 'symbols', 'numbers', 'greek_letters'],
help='Choose trial type')
parser.add_argument('--Training_number', default=1, action='store', type=int, help='Number of relations')
parser.add_argument('--Training_stim_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_resp_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_feedback', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_feedback_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_wait', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_bin', default='1', choices=['1', '0'], help='Choose view type')
parser.add_argument('--Training_trial_type', default='1', choices=['1', '2', '3', '4'], help='Choose view type')
# Information about experiment
parser.add_argument('--Experiment_task', default='letters',
choices=['letters', 'figures', 'symbols', 'numbers', 'greek_letters'],
help='Choose trial type')
parser.add_argument('--Experiment_number', default=1, action='store', type=int, help='Number of relations')
parser.add_argument('--Experiment_stim_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_resp_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_feedback', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_feedback_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_wait', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_bin', default='1', choices=['1', '0'], help='Choose view type')
parser.add_argument('--Experiment_trial_type', default='1', choices=['1', '2', '3', '4'], help='Choose view type')
args = parser.parse_args()
experiment = []
name = args.Instruction.split('/')[-1]
for block in range(args.Number_of_blocks):
instruction = [block + 1, 'instruction', args.Instruction_show_time, name]
experiment.append(instruction)
for idx in range(0, args.Number_of_training_trials):
trial = [block + 1, args.Training_task, args.Training_number, idx + 1, args.Training_stim_time,
args.Training_resp_time, args.Training_feedback, args.Training_feedback_time,
args.Training_wait, 0, int(args.Training_bin), int(args.Training_trial_type)]
experiment.append(trial)
for idx in range(0, args.Number_of_experiment_trials):
trial = [block + 1, args.Experiment_task, args.Experiment_number, idx + 1, args.Experiment_stim_time,
args.Experiment_resp_time, args.Experiment_feedback, args.Experiment_feedback_time,
args.Experiment_wait, 1, int(args.Experiment_bin), int(args.Experiment_trial_type)]
experiment.append(trial)
save_to_xlsx(experiment, args.File_name)
def _parser():
"""Take care of all the CLI/GUI stuff.
"""
parser = GooeyParser(description='Plot FITS spectra effortless')
parser.add_argument('fname',
action='store',
widget='FileChooser',
help='Input fits file', metavar='Fits file')
parser.add_argument('-m', '--model',
default=False,
widget='FileChooser',
help='If not the Sun shoul be used as a model, put'
' the model here (only support BT-Settl for the'
' moment)', metavar='Model atmosphere')
path_lines = os.path.join(os.path.expanduser('~/.plotfits/'), 'linelist.moog')
parser.add_argument('--linelist',
# default=False,
default=path_lines,
widget='FileChooser',
help='Linelist with 1 line header and wavelength in 1st col', metavar='Line list')
parser.add_argument('-s', '--sun',
help='Over plot solar spectrum',
action='store_true')
parser.add_argument('-t', '--telluric',
help='Over plot telluric spectrum',
action='store_true')
parser.add_argument('-r', '--rv',
help='RV shift to observed spectra in km/s',
default=False,
type=float)
parser.add_argument('-r1', '--rv1',
help='RV shift to model/solar spectrum in km/s',
default=False,
type=float)
parser.add_argument('-r2', '--rv2',
help='RV shift to telluric spectra in km/s',
default=False,
type=float)
parser.add_argument('-l', '--lines',
help='Lines to plot on top (multiple lines is an'
' option). If multiple lines needs to be plotted, then'
' separate with a space',
default=False, type=float, nargs='+', metavar='Atomic lines')
parser.add_argument('-c', '--ccf',
default='none',
choices=['none', 'sun', 'model', 'telluric', 'both'],
help='Calculate the CCF for Sun/model or tellurics or both.')
parser.add_argument('--ftype', help='Select which type the fits file is',
choices=['1D', 'CRIRES', 'GIANO', 'UVES'], default='1D',
metavar='Instrument')
parser.add_argument('--fitsext', help='Select fits extention for CRIRES',
choices=map(str, range(1, 5)), default='1', metavar='FITS extention')
parser.add_argument('--order', help='Select which GIANO order to be investigated',
choices=map(str, range(32, 81)), default='77', metavar='GIANO order')
return parser.parse_args()
def parse_args_gooey():
'''parse command line arguments'''
parser = GooeyParser(description="Convert pgm image to png or jpg")
parser.add_argument("directory", default=None,
help="directory containing PGM image files", widget='DirChooser')
parser.add_argument("--output-directory", default=None,
help="directory to use for converted files", widget='DirChooser')
parser.add_argument("--format", default='png', choices=['png', 'jpg'], help="type of file to convert to (png or jpg)")
return parser.parse_args()
def get_params():
parser = GooeyParser()
parser.add_argument('search_term', help="The search term")
parser.add_argument(
dest='mode',
widget='Dropdown',
choices=['Director', 'IMDB Code', 'Keyword']
)
args = parser.parse_args()
return args.mode, args.search_term
def main():
parser = GooeyParser(prog="example_progress_bar_2")
parser.add_argument("steps", type=int, default=15)
parser.add_argument("delay", type=int, default=1)
args = parser.parse_args(sys.argv[1:])
for i in range(args.steps):
print("progress: {}/{}".format(i+1, args.steps))
sys.stdout.flush()
sleep(args.delay)
def main():
parser = GooeyParser(description="Create_concrete_experiment")
parser.add_argument("Experiment_file_name", widget="FileChooser", help="Choose experiment file with general info")
parser.add_argument("Participant_ID", type=str)
parser.add_argument("Participant_Age", default=0, type=int)
parser.add_argument("Participant_Sex", default="M", choices=["M", "F"])
parser.add_argument("Random", default="True", choices=["True", "False"], help="Present trials in random order")
parser.add_argument("EEG_connected", default="1", choices=["1", "0"], help="Choice")
args = parser.parse_args()
number_of_blocks, data = load_info(args.Experiment_file_name)
experiment = Experiment(
[], args.Participant_ID, args.Participant_Sex, args.Participant_Age, int(args.EEG_connected)
)
for idx in range(number_of_blocks):
block = Block([])
experiment.list_of_blocks.append(block)
for idx in range(len(data)):
trial_info = data[idx]
block_number = trial_info["BLOCK_NUMBER"]
if trial_info["SAMPLE_TYPE"] == "instruction":
if trial_info["INSTRUCTION"][-3:] == "txt":
instruction_type = "text"
elif trial_info["INSTRUCTION"][-3:] == "bmp" or trial_info["INSTRUCTION"][-3:] == "jpg":
instruction_type = "image"
else:
raise AssertionError("wrong instruction file type")
trial = Instruction(trial_info["INSTRUCTION"], instruction_type, trial_info["SHOW_TIME"])
else:
trial = Trial(
trial_info["SAMPLE_TYPE"],
trial_info["N"],
trial_info["NR"],
trial_info["MEMORY"],
trial_info["INTEGR"],
trial_info["SHOW_TIME"],
trial_info["RESP_TIME"],
trial_info["MAX_TIME"],
trial_info["FEEDB"],
trial_info["FEEDB_TIME"],
trial_info["WAIT"],
trial_info["EXP"],
trial_info["FIX_TIME"],
trial_info["LIST_VIEW"],
)
trial.create_sample()
experiment.list_of_blocks[block_number - 1].list_of_trials.append(trial)
if args.Random:
experiment.randomize()
experiment.save()
def _parser():
parser = GooeyParser(description='Look up an object in VizieR'
' and print mean/median'
' values of given parameters')
parser.add_argument('object', help='Object, e.g. HD20010', nargs='+')
parser.add_argument('-p', '--params', default=True, action='store_true',
help='List of parameters (Teff, logg, [Fe/H] be default)')
parser.add_argument('-m', '--method', choices=['median', 'mean', 'both'], default='both',
help='Which method to print values (mean or median). Default is both')
parser.add_argument('-c', '--coordinate', default=False, action='store_true',
help='Return the RA and DEC (format for NOT\'s visibility plot)')
return parser.parse_args()
def main():
parser = GooeyParser(description="Calculate a rocket stage's delta V for KSP")
parser.add_argument("mass_initial", help="Initial mass of the spacecraft (tonnes)", type=float)
parser.add_argument("mass_final", help="Final mass of the spacecraft (tonnes)", type=float)
parser.add_argument("isp", help="Specific impulse", type=float)
parser.add_argument("--thrust", help="Thrust per engine (0 for unknown)", type=float, default=0.0)
parser.add_argument("--engine_count", help="Number of engines", type=int, default=1)
args = parser.parse_args()
thrust = args.thrust * args.engine_count
get_and_process_stage(args.mass_initial, args.mass_final, args.isp, thrust)
def get_args() -> Namespace:
parser = GooeyParser(description='Process VMI counts and '
'create quote and OE Upload files')
parser.add_argument(
'count_file',
default=INPUT_COUNT_FILE,
widget='FileChooser',
help='Provide a path to a count file to import (Excel or CSV)')
parser.add_argument(
'backorder_file',
default=INPUT_BACKORDER_FILE,
widget='FileChooser',
help='Provide a path to a backorder file to import (Excel or CSV)')
parser.add_argument(
'--config',
dest='config_file',
default=os.path.join(BASE_PATH, CONFIG_FOLDER, CONFIG_FILE),
widget='FileChooser',
help='Provide a config file in JSON format; see example')
parser.add_argument(
'--product_data',
dest='product_data_file',
default=os.path.join(BASE_PATH, DATA_FOLDER, DATA_FILE),
widget='FileChooser',
help='Provide a product data file in CSV or Excel format; see example')
parser.add_argument(
'--path',
'-P',
dest='output_path',
default=OUTPUT_PATH,
widget='DirChooser',
help='Provide a folder path for the ouput files')
parser.add_argument(
'--add_prices',
'-A',
dest='add_prices',
action='store_true',
widget='CheckBox',
help='Toggle if you want to add prices to upload file')
parser.add_argument(
'--quote',
'-Q',
dest='quote_name',
default=OUTPUT_QUOTE_FILE,
help='Provide a filename prefix for output of Excel quotation file(s)')
parser.add_argument(
'--OEUpload',
'-O',
dest='OEUpload_name',
default=OUTPUT_OEUPLOAD_FILE,
help='Provide a filename for output of Excel OE upload template file')
return parser.parse_args()
def _parser():
"""Take care of all the argparse stuff.
:returns: the args
"""
parser = GooeyParser(description='Plot 1D fits files with wavelength information in the header.')
parser.add_argument('fname',
action='store',
widget='FileChooser',
help='Input fits file')
parser.add_argument('-m', '--model',
default=False,
widget='FileChooser',
help='If not the Sun shoul be used as a model, put'
' the model here (only support BT-Settl for the'
' moment)',)
parser.add_argument('-s', '--sun',
help='Over plot solar spectrum',
action='store_true')
parser.add_argument('-t', '--telluric',
help='Over plot telluric spectrum',
action='store_true')
parser.add_argument('-r', '--rv',
help='RV shift to observed spectra in km/s',
default=False,
type=float)
parser.add_argument('-r1', '--rv1',
help='RV shift to model/solar spectrum in km/s',
default=False,
type=float)
parser.add_argument('-r2', '--rv2',
help='RV shift to telluric spectra in km/s',
default=False,
type=float)
parser.add_argument('-l', '--lines',
help='Lines to plot on top (multiple lines is an'
' option). If multiple lines needs to be plotted, then'
' separate with a space',
default=False,
nargs='+',
type=float)
parser.add_argument('-c', '--ccf',
default='none',
choices=['none', 'sun', 'model', 'telluric', 'both'],
help='Calculate the CCF for Sun/model or tellurics '
'or both.')
parser.add_argument('--ftype', help='Select which type the fits file is',
choices=['1D', 'CRIRES', 'GIANO'], default='1D')
parser.add_argument('--fitsext', help='Select fits extention, Default 0.',
choices=['0', '1', '2', '3', '4'], default='0')
parser.add_argument('--order', help='Select which GIANO order to be investigated',
choices=map(str, range(32,81)), default='77')
return parser.parse_args()
def arbitrary_function():
desc = u"\u30b3\u30de\u30f3\u30c9\u30e9\u30a4\u30f3\u5f15\u6570\u3092\u5165\u529b\u3057\u3066\u304f\u3060\u3055\u3044"
file_help_msg = u"\u51e6\u7406\u3057\u305f\u3044\u30d5\u30a1\u30a4\u30eb\u306e\u540d\u524d"
my_cool_parser = GooeyParser(description=desc)
my_cool_parser.add_argument(u"\u30d5\u30a1\u30a4\u30eb\u30d6\u30e9\u30a6\u30b6", help=file_help_msg, widget="FileChooser") # positional
my_cool_parser.add_argument('-d', u'--\u30c7\u30e5\u30ec\u30fc\u30b7\u30e7\u30f3', default=2, type=int, help=u'\u30d7\u30ed\u30b0\u30e9\u30e0\u51fa\u529b\u306e\u671f\u9593\uff08\u79d2\uff09')
my_cool_parser.add_argument('-s', u'--\u30b9\u30b1\u30b8\u30e5\u30fc\u30eb', type=int, help=u'\u65e5\u6642\u30d7\u30ed\u30b0\u30e9\u30e0\u3092\u958b\u59cb\u3059\u3079\u304d', widget='DateChooser')
my_cool_parser.add_argument("-c", u"--\u30b7\u30e7\u30fc\u30bf\u30a4\u30e0", action="store_true", help=u"\u30ab\u30a6\u30f3\u30c8\u30c0\u30a6\u30f3\u30bf\u30a4\u30de\u30fc\u3092\u8868\u793a\u3057\u307e\u3059")
my_cool_parser.add_argument("-p", u"--\u30dd\u30fc\u30ba", action="store_true", help=u"\u4e00\u6642\u505c\u6b62\u306e\u5b9f\u884c")
args = my_cool_parser.parse_args()
main(args)
def main():
parser = GooeyParser(description='This Demo will raise an error!')
parser.add_argument("name", type=str, default='Enter Name')
parser.add_argument("age", type=int)
parser.add_argument("gender", choices=["Female","Male"], default="Female")
parser.add_argument("animal", choices=["Dogs","Cats"], default="Dogs")
parser.add_argument("feet", type=int, default=5)
parser.add_argument("inches", type=int, default=3)
args = parser.parse_args()
print args.name
def main():
parser = GooeyParser(description='Package your Gooey applications into standalone executables')
parser.add_argument(
"program_name",
metavar='Program Name',
help='Destination name for the packaged executable'
)
parser.add_argument(
"source_path",
metavar="Program Source",
help='The main source file of your program',
widget="FileChooser"
)
parser.add_argument(
"output_dir",
metavar="Output Directory",
help='Location to store the generated files',
widget="DirChooser"
)
args = parser.parse_args()
if not os.path.exists(args.source_path):
raise IOError('{} does not appear to be a valid file path'.format(args.source_path))
if not os.path.exists(args.output_dir):
raise IOError('{} does not appear to be a valid directory'.format(args.output_dir))
with open(os.path.join(local_path(), 'build_template'), 'r') as f:
spec_details = f.read().format(program_name=args.program_name, source_path=args.source_path)
fileno, path = tempfile.mkstemp(prefix='gooeybuild', suffix='.spec')
with open(path, 'w') as f:
f.write(spec_details)
cmd = 'pyinstaller "{0}" --distpath="{1}"'.format(path, args.output_dir)
print cmd
from pexpect.popen_spawn import PopenSpawn
child = PopenSpawn(cmd)
child.logfile = sys.stdout
child.wait()
print dedent('''
___ _ _ ______ _
/ _ \| | | | _ \ | |
/ /_\ \ | | | | | |___ _ __ ___| |
| _ | | | | | | / _ \| '_ \ / _ \ |
| | | | | | | |/ / (_) | | | | __/_|
\_| |_/_|_| |___/ \___/|_| |_|\___(_)
''')
print 'Wrote Executable file to {}'.format(args.output_dir)
def main():
""""""
ap = GooeyParser()
ap.add_argument("-targ_dir",
default=r'C:\Data\EM\classification',
type=str,
help="path to directory for saving proofreading data",
widget='DirChooser')
ap.add_argument(
'-base_volume',
type=str,
default=
'487208920048:adultob:seg_v2_9nm_484558417fb_18nm_fb_107004781_otfa_multires_mesh',
help='base segmentation volume id in form of '
'"projectId:datasetId:volumeId"')
ap.add_argument('-raw_data',
type=str,
default='487208920048:adultob:full',
help='image data volume path')
ap.add_argument('-change_stack_id',
type=parse_chg_stack,
default='200614_prj487208920048_graph_postapr',
help='change stack id storing the agglomeration; to use '
'base volume enter one of: n, none, f. false, 0'
'graph')
ap.add_argument(
'-remove_token',
type=str2bool,
default=False,
help='flag that decides whether to delete the token created'
' by authenticating to neuroglancer upon exit of the '
'program. \n'
'Usage: true, yes, t, y, 1 or false, no, n, f, 0; '
'case-insensitive')
ap.add_argument('-timer_interval',
type=int,
default=600,
help='interval of the autosave tiner in sec')
ap.set_defaults(func=run_classifier)
ap_args = ap.parse_args()
ap_args.func(ap_args)
def main():
parser = GooeyParser(description='Just display the console')
parser.add_argument('--host',
help='Ze host!',
default=os.environ.get('HOST'))
group = parser.add_mutually_exclusive_group(
required=False,
# gooey_options={"initial_selection": 0}
)
group.add_argument("-b", type=str)
group.add_argument("-d", type=str, widget="DateChooser")
args = parser.parse_args()
print(args)
def _parser():
'''The argparse stuff'''
parser = GooeyParser(description='CRIRES spectrum to an 1D spectrum')
parser.add_argument('fname', action='store', widget='FileChooser', help='Input fits file')
parser.add_argument('--output', default=False,
help='Output to this name. If nothing is given, output will be: "wmin-wmax.fits"')
parser.add_argument('-u', '--unit', default='angstrom',
choices=['angstrom', 'nm'],
help='The unit of the output wavelength')
parser.add_argument('-c', '--clobber', default=True, action='store_false',
help='Do not overwrite existing files.')
args = parser.parse_args()
return args
def main():
parser = GooeyParser(description="PowerPoint Exporter")
parser.add_argument('powerpoint', widget="FileChooser")
parser.add_argument('output', help="Folder to place resulting images", widget="DirChooser")
parser.add_argument('width', help="Width of resulting image (0-3072)")
parser.add_argument('height', help="Height of resulting image (0-3072)")
args = parser.parse_args()
if not (os.path.isfile(args.powerpoint) and os.path.isdir(args.output)):
raise "Invalid paths!"
export_presentation(args.powerpoint, args.output, args.width, args.height)
print "Done!"
def main():
parser = GooeyParser()
parent = parser.add_argument_group('Search Options',
gooey_options={'columns': 2})
parent.add_argument('--query-string', help='the search string')
child_one = parent.add_argument_group('flags',
gooey_options={'show_border': True})
child_one.add_argument('--option1', help='some text here')
child_two = parent.add_argument_group('price',
gooey_options={'show_border': True})
child_two.add_argument('--option2', help='some text here')
args = parser.parse_args()
def parse_args_gooey():
'''parse command line arguments'''
parser = GooeyParser(description="Geotag images from flight log")
parser.add_argument("files", default=None, help="Image folder", widget='DirChooser')
parser.add_argument("mavlog", default=None, help="flight log for geo-referencing", widget='FileChooser')
parser.add_argument("--max-deltat", default=0.0, type=float, help="max deltat for interpolation")
parser.add_argument("--max-attitude", default=45, type=float, help="max attitude geo-referencing")
parser.add_argument("--lens", default=4.0, type=float, help="lens focal length")
parser.add_argument("--roll-stabilised", default=False, action='store_true', help="Is camera roll stabilised?")
parser.add_argument("--gps-lag", default=0.0, type=float, help="GPS lag in seconds")
parser.add_argument("--destdir", default=None, help="destination directory", widget='DirChooser')
parser.add_argument("--inplace", default=False, action='store_true', help="modify images in-place?")
return parser.parse_args()
def main():
# GooeyParser used in place of ArgumentParser in order to specify widgets
parser = GooeyParser(description="Image Recognition Search for Wikipedia")
# facilitates file selection for later image processing
parser.add_argument("Filename",
help="Select the the image file to process",
widget="FileChooser")
arg = parser.parse_args()
print("Your image is processing...")
# ImageAI library setup, sets specifications for image prediction and processing
execution_path = os.getcwd()
prediction = ImagePrediction()
prediction.setModelTypeAsResNet()
prediction.setModelPath(execution_path +
"/resnet50_weights_tf_dim_ordering_tf_kernels.h5")
prediction.loadModel()
# call of predictImage function, returns object predictions and probabilities
predictions, percentage_probabilities = prediction.predictImage(
arg.Filename, result_count=1)
# output testing of prediction and probabilities, used for debugging
# for index in range(len(predictions)):
# print(predictions[index], " : ", percentage_probabilities[index])
# if object probability is greater than 20%, proceed with output
if percentage_probabilities[0] > 20:
# removes underscores in string with spaces for cleaner output
prediction_object = predictions[0].replace('_', ' ')
print(
"Success!\nA " + prediction_object +
" has been detected.\nPlease see your default web browser to view the Wikipedia page.\n"
)
# calls fetch_webpage in order to load correct Wikipedia page
fetch_webpage(predictions[0])
# if object probability is less than 20%, print below and do NOT load webpage
else:
print(
"Sorry!\nWe couldn't find an object in your image with high probability.\n"
)
return
def main():
print 'minUP GUI'
desc = \
'A program to analyse minION fast5 files in real-time or post-run.'
print desc
parser = GooeyParser(description=desc)
for x in xs[1:]:
if len(x) > 1:
mkWidget(parser, x, settings)
# This is updated every time to update the values of the variables...
try:
vs = vars(parser.parse_args())
with open('settings.json', 'w') as f:
# print json.dumps(vs, indent=4, sort_keys=True)
f.write(json.dumps(vs, indent=4, sort_keys=True))
except:
return ()
# Build a dict of the var:vals
print '------------------'
ps = []
for k in vs:
ps.append(('-' + lut[k], toStr(vs[k])))
ps = map(fixAligner, ps)
aligner = vs['Aligner_to_Use']
ps = map(lambda o: fixAlignerOpts(aligner, o), ps)
ps = sorted(filter(isActive, ps))
params = ' '.join(map(showParam, ps))
# cmd = 'ls /a'
# cmd = 'c:\Python27\python.exe .\minup.v0.63.py ' +params
cmd = '.\\minUP.exe ' + params # + ' 2>&1'
print cmd
'''
fl = open("cmd.sh", 'w')
fl.write(cmd)
fl.close()
'''
run(cmd)
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,
'columns': 1
})
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)
save_group = test_parser.add_argument_group("Save option",
gooey_options={
'show_border': True,
'columns': 1
})
save_parser = args_save.add(save_group)
args = parser.parse_args()
if args.commands == 'train':
train.train(args)
else:
test.test(args)
def renameFiles():
parser = GooeyParser(description='Create Quarterly Marketing Report')
parser.add_argument('data_directory',
action='store',
widget='DirChooser',
help="Source directory that contains files")
parser.add_argument('FirstSplitPattern',
help="First Pattern to split file Name")
parser.add_argument('SecondSplitPattern',
help="Second Pattern to split file Name")
parser.add_argument(
'PrintFileName',
help="Indicator for just printing the new name instead of rename file")
args = parser.parse_args()
workingDir = args.data_directory
firstSplit = args.FirstSplitPattern
secondSplit = args.SecondSplitPattern
printNameOnly = args.PrintFileName
# Traverse root directory, and list directories as dirs and files as files
for root, dirs, fileList in os.walk(workingDir):
os.chdir(root)
path = root.split(os.sep)
print((len(path) - 1) * '***', os.path.basename(root))
for filename in fileList:
fname, ext = os.path.splitext(filename)
if firstSplit in fname:
fileSplit1 = fname.split(firstSplit)[1]
if secondSplit != '':
mainName = fileSplit1.split(secondSplit)[
0] #main file name
else:
mainName = fileSplit1
newname = mainName.strip() + ext
print(len(path) * '...', newname)
if printNameOnly == 'YES':
print(newname)
else:
os.rename(filename, newname)
else:
print(
f'Could not find Characters {firstSplit} or {secondSplit} in {filename}'
)
def parse_args():
""" Use GooeyParser to build up the arguments we will use in our script
Save the arguments in a default json file so that we can retrieve them
every time we run the script.
"""
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]
args_file = "{}-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='Create Quarterly Marketing Report')
parser.add_argument(
'data_directory',
action='store',
default=stored_args.get('data_directory'),
widget='DirChooser',
help="Source directory that contains Excel files",
)
parser.add_argument(
'output_directory',
action='store',
widget='DirChooser',
default=stored_args.get('output_directory'),
help="Output directory to save summary report",
)
parser.add_argument(
'cust_file',
action='store',
default=stored_args.get('cust_file'),
widget='FileChooser',
help='Customer Account Status File',
)
parser.add_argument(
'-d',
help='Start date to include',
default=stored_args.get('d'),
widget='DateChooser',
)
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 dictionary
json.dump(vars(args), data_file)
return args
def generate_trials_gui():
# General information
parser = GooeyParser(description='Create_general_experiment')
parser.add_argument('Number_of_blocks', default=1, action='store', type=int, help='Number')
parser.add_argument('Number_of_training_trials_in_blocks', default=4, action='store', type=int, help='Number')
parser.add_argument('Number_of_experiment_trials_in_blocks', default=4, action='store', type=int, help='Number')
parser.add_argument('File_name', default='experiment', type=str, help='Name of file with not personalized data')
parser.add_argument('EEG_connected', default='1', choices=['1', '0'], help='Choice')
parser.add_argument('--Instruction', widget='FileChooser', help='Choose instruction file')
parser.add_argument('--Instruction_show_time', default=5, action='store', type=int, help='Number')
# Information about training
parser.add_argument('--Training_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_relations', default='2', choices=['2', '3', '4'], help='Choose number of relations')
parser.add_argument('--Training_feedback', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_wait', default=1, action='store', type=int, help='Number')
parser.add_argument('--Training_tip', widget='FileChooser', help='Choose tip file')
parser.add_argument('--Training_tip_time', default=4, action='store', type=int, help='Number')
# Information about experiment
parser.add_argument('--Experiment_time', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_relations', default='2', choices=['2', '3', '4'],
help='Choose number of relations')
parser.add_argument('--Experiment_feedback', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_wait', default=1, action='store', type=int, help='Number')
parser.add_argument('--Experiment_tip', widget='FileChooser', help='Choose tip file')
parser.add_argument('--Experiment_tip_time', default=4, action='store', type=int, help='Number')
args = parser.parse_args()
experiment = []
name = args.Instruction.split('/')[-1]
for idx in range(args.Number_of_blocks):
instruction = [idx+1, Trial_type.instruction.value, args.Instruction_show_time, name]
experiment.append(instruction)
for _ in range(args.Number_of_training_trials_in_blocks):
trial = [idx+1, Trial_type.training.value, args.Training_time, int(args.Training_relations), args.Training_feedback,
args.Training_wait, args.Training_tip, args.Training_tip_time]
experiment.append(trial)
for _ in range(args.Number_of_experiment_trials_in_blocks):
trial = [idx+1, Trial_type.experiment.value, args.Experiment_time, int(args.Experiment_relations),
args.Experiment_feedback,
args.Experiment_wait, args.Experiment_tip, args.Experiment_tip_time]
experiment.append(trial)
save_to_xlsx(experiment, args.File_name)
def parse_args():
parser = GooeyParser(description='Generate REDCap import for CBCL scores from PDF reports')
required_group = parser.add_argument_group('Required Arguments', gooey_options={'columns': 1})
required_group.add_argument('--folder', widget='DirChooser', required=True, help='Folder containing score reports to be processed')
required_group.add_argument('--outfile', widget='FileChooser', required=True, help='File to output results to')
required_group.add_argument('--study_id_var', help='REDCap variable for study id (i.e. demo_study_id, newt_id)')
required_group.add_argument('--subject_prefix', required=True, help='prefix for subject identifier string (i.e. NT, NEWT, WOLF)')
optional_group = parser.add_argument_group('Optional Arguments', gooey_options={'columns': 1})
optional_group.add_argument('-s', '--subjects', nargs='+', help='Space-separated list of subject ids to run for (if blank, runs all in folder)')
optional_group.add_argument('--from_date', type=lambda d: datetime.strptime(d, '%Y-%m-%d'), widget='DateChooser', help='Process only files that were modified on/after specified date')
optional_group.add_argument('--flatten_sessions', action='store_true', help='flatten session names (only needed if REDCap is set up non-longitudinally)')
return parser.parse_args()
def parse_args():
parser = GooeyParser()
parser.add_argument(
'input_file',
widget='FileChooser',
help='REDCap export file containing yCBCL questionaire responses')
parser.add_argument('output_file',
widget='FileChooser',
help='CSV file to save scored results to')
parser.add_argument(
'--session',
metavar='session',
type=int,
help='Session number (for REDCap non-longitudinal studies only)')
return parser.parse_args()
def main():
my_parser = GooeyParser()
my_parser.add_argument('-flag1',
default=True,
metavar="Флаг1",
action='store_true',
help="включите Флаг1")
args = my_parser.parse_args()
print(args)
print(type(args))
print(vars(args))
def main():
parser = GooeyParser()
parser.add_argument("-p",
"--path",
help="enter the file path you want to remove file",
required=True,
widget="DirChooser")
parser.add_argument("-t",
"--type",
help="enter the file type that you want to remove",
required=True)
args = parser.parse_args()
file_path = args.path
file_type = args.type
rexe(file_path, file_type)
def main():
parser = GooeyParser(description='Process some integers.')
parser.add_argument('required_field',
metavar='Some Field',
help='Enter some text!')
parser.add_argument('-f',
'--foo',
metavar='Some Flag',
action='store_true',
help='I turn things on and off')
args = parser.parse_args()
print 'Hooray!'
def parse_arguments():
""" This parses any supplied arguements."""
parser = GooeyParser(
prog="EP2018_demo1", usage=None,
description="Demonstation CLI Program",
epilog=None,
add_help=True)
parser.add_argument("infile", help="One or More Input Files", nargs='+',
action='append', type=argparse.FileType('r'), widget='FileChooser')
parser.add_argument("--reverse", '-r', help="Do things backwards",
action="store_true")
parser.add_argument('--detail', '-l', help='Select the level of detail',
type=int, default=3)
opts = parser.parse_args()
return opts
def main():
parser = GooeyParser(description = 'Registry Search for Timestamp (inclusive dates) or Keywords')
parser.add_argument('hive', help="Windows registry hive file", widget='FileChooser')
parser.add_argument('-start', action='store', dest='startDate', help="Start date YYYY-MM-DD",
widget='DateChooser')
parser.add_argument('-end', action='store', dest='endDate', help="End date YYYY-MM-DD", widget='DateChooser')
parser.add_argument('-search', nargs='*', default=[], help="Search terms to find in registry (space delimited).")
args = parser.parse_args()
# check if a search parameter was provided
if not args.search and not args.startDate and not args.endDate:
print "Must include a search time, start date, or end date.\n"
return
# process start date if provided
if args.startDate != None:
try:
args.startDate = datetime.datetime(int(args.startDate[:4]), int(args.startDate[5:7]), int(args.startDate[-2:]), 0, 0, 0)
except:
print 'Unable to process: ' + args.startDate + '\n'
return
else:
args.startDate = datetime.datetime(1970, 1, 1)
# process end date if provided
if args.endDate != None:
try:
args.endDate = datetime.datetime(int(args.endDate[:4]), int(args.endDate[5:7]), int(args.endDate[-2:]), 23, 59, 59)
except:
print 'Unable to process: ' + args.startDate + '\n'
return
else:
now = datetime.datetime.now()
args.endDate = datetime.datetime(now.year, now.month, now.day + 1, 23, 59, 59)
# check if order of dates are correct
if args.startDate > args.endDate:
print 'Start date is after end date: %s - %s\n' % (args.startDate.strftime("%x"), args.endDate.strftime("%x"))
return
# begin search
curr = find(args.hive, args.startDate, args.endDate, args.search)
curr.beginSearch()
def main():
print 'minUP GUI'
desc = \
'A program to analyse minION fast5 files in real-time or post-run.'
print desc
parser = GooeyParser(description=desc)
for x in xs[1:]:
if len(x) > 1:
mkWidget(parser, x, settings)
# This is updated every time to update the values of the variables...
try:
vs = vars(parser.parse_args())
with open('settings.json', 'w') as f:
# print json.dumps(vs, indent=4, sort_keys=True)
f.write(json.dumps(vs, indent=4, sort_keys=True))
except:
return ()
# Build a dict of the var:vals
print '------------------'
ps = []
for k in vs:
ps.append(('-' + lut[k], toStr(vs[k])))
ps = map(fixAligner, ps)
aligner = vs['Aligner_to_Use']
ps = map(lambda o: fixAlignerOpts(aligner, o), ps)
ps = sorted(filter(isActive, ps))
params = ' '.join(map(showParam, ps))
# cmd = 'ls /a'
# cmd = 'c:\Python27\python.exe .\minup.v0.63.py ' +params
cmd = '.\\minUP.exe ' + params # + ' 2>&1'
print cmd
'''
fl = open("cmd.sh", 'w')
fl.write(cmd)
fl.close()
'''
run(cmd)
def main():
desc = "Choose your model"
main_parser = GooeyParser(description=desc)
model_sel_parser = main_parser.add_argument_group("Model Select",
gooey_options={
'show_border': True,
'columns': 1
})
model_kind = model_sel_parser.add_mutually_exclusive_group()
model_kind.add_argument('--Regression',
choices=REGRESSOR,
dest="Regression Model")
model_kind.add_argument('--Classification',
choices=CLASSIFIER,
dest="Classification Model")
model_kind.add_argument('--Clustering',
choices=CLUSTERING,
dest="Clustering Model")
model_kind.add_argument('--Image',
choices=IMAGE,
dest="Image Processing Model")
model_kind.add_argument('--Nlp',
choices=NLP,
dest="Natural Language Processing Model")
args = main_parser.parse_args()
for val in vars(args).values():
if val is not None:
model_name = val
break
print("[Start]\t{}".format(model_name))
PYTHON_PATH = sys.executable
process = Popen(
[PYTHON_PATH, os.path.join('Model', model_name, 'run.py')],
stdout=PIPE,
stderr=PIPE)
output, error = process.communicate()
# print(output)
# print(error)
print("[End]\t{}".format(model_name))
def main():
"""Running desktop app"""
desc = u'Введите параметр и нажмите "Запуск"'
p = GooeyParser(description=desc)
p.add_argument('-a',
'--a',
default=2,
type=int,
help='Кол-во перевозимых детей')
p.add_argument('-b', '--b', default=25, type=int, help='Возраст водителя')
p.add_argument('-c', '--c', default=3, type=int, help='Кол-во детей всего')
p.add_argument('-d', '--d', default=2, type=int, help='Возраст детей')
p.add_argument('-e', '--e', default=4, type=int, help='Водительский стаж')
p.add_argument('-f', '--f', default=2, type=int, help='Категории')
p.add_argument('-s',
'--s',
default=3,
type=int,
help='Кол-во страховых случаев')
p.add_argument('-i',
'--i',
default=2,
type=int,
help='Интегрированный показатель')
p.add_argument('-k', '--k', default=1, type=int, help='Возраст автомобиля')
p.add_argument('-m',
'--m',
default=2,
type=int,
help='Категория автомобиля')
global args
args = p.parse_args()
with open('xgb_model.pickle', 'rb') as f:
clf_2 = pickle.load(f)
result = clf_2.predict_proba(
pd.DataFrame([
args.a, args.b, args.c, args.d, args.e, args.f, args.s, args.i,
args.k, args.m
]).T)[0][0]
print 'вероятность наступления страхового случая составляет : {} процентов'.format(
result)
def main():
NRK = NRK(gui=True)
parser = GooeyParser()
parser.add_argument('-u', '--url', action='store', default=False,
required=False, widget='TextField', help='"url1 url2 url3"')
parser.add_argument('-e', '--encoding', default='latin-1',
required=False, help='Set encoding')
parser.add_argument('-save', '--save_path', default=False,
required=False, help='Download to this folder', widget='DirChooser')
parser.add_argument('-dr', '--dry_run', action='store_true', default=False,
required=False, help='Dry run, dont download anything')
parser.add_argument('-v', '--verbose', action='store_true', default=False,
required=False, help='Show ffmpeg output')
parser.add_argument('-w', '--workers', default=2,
required=False, help='Number of thread pool workers')
parser.add_argument('-st', '--subtitle', action='store_true', default=False,
required=False, help='Download subtitle for this media file?')
parser.add_argument('-if', '--input_file', default=False,
required=False, help='List of files to download', widget='FileChooser')
p = parser.parse_args()
NRK.dry_run = p.dry_run
NRK.verbose = p.verbose
NRK.subtitle = p.subtitle
NRK.cli = False
NRK.encoding = p.encoding
NRK.workers = int(p.workers)
if p.save_path:
NRK.SAVE_PATH = p.save_path
if p.input_file:
NRK._from_file(p.input_file)
if p.url:
NRK.parse_url(p.url)
def main():
parser = GooeyParser()
parser.add_argument(
"some_string",
action="store",
default="just press Start",
)
args = parser.parse_args()
print(args, flush=True)
# print too many messages (causes crash for me around 105k).
for email in email_stream(60000):
import time
time.sleep(.01)
print(email, flush=True)
def parse_args():
desc = "Konvertér en eller flere billedfiler til en enkelt flersidet PDF-fil."
dir_input_msg = "Vælg en folder med billeder, der skal konverteres"
save_file_msg = "Vælg placering og filnavn for pdf-filen"
parser = GooeyParser(description=desc)
parser.add_argument("in_folder",
metavar="Vælg mappe med billedfiler",
help=dir_input_msg,
widget="DirChooser")
parser.add_argument("out_file",
metavar="Hvor skal pdf-filen skal gemmes",
help=save_file_msg,
widget="FileSaver")
return parser.parse_args()
def main():
parser = GooeyParser(description="GE DICOM Text Parser")
parser.add_argument('outputfile',
help='Select Output Spreadsheet Filename',
widget="FileChooser")
area_threshold_group = parser.add_mutually_exclusive_group(required=True)
area_threshold_group.add_argument('--inputfile',
help='Input DCM File',
widget='FileChooser')
area_threshold_group.add_argument('--inputdir',
help='Input DCM Directory',
widget='DirChooser')
args = parser.parse_args()
runFile(args)
def main():
parser = GooeyParser()
# parser.add_argument('filename1')
args = parser.parse_args()
process = subprocess.Popen(
' '.join(cmd),
bufsize=1,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
shell=True
)
for line in process.stdout:
print(line)
def parse_arguments():
parser = GooeyParser(
description="Программа для быстрой и приятной работы с Яндекс.Толокой")
parser.add_argument("Логин", help="Логин пользователя")
parser.add_argument("Пароль",
help="Пароль пользователя",
widget='PasswordField')
parser.add_argument("Задание",
help="Выберите задание из списка ниже",
choices=CONST.GUI_CHOICES.keys())
parser.add_argument("--ZEN",
required=False,
help="Режим, в котором приятно работать",
action='store_true')
return parser.parse_args()
def param_parser():
parser=GooeyParser(description="Vicforestry prod Generator")
parser.add_argument("input_folder", metavar="Input Directory ", widget="DirChooser", help="Select folder with input files")
parser.add_argument("tilelayoutfile", metavar="TileLayout file", widget="FileChooser", help="TileLayout file(.json)")
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("geoid", metavar="GEOID", widget="FileChooser", help="laz file")
parser.add_argument("file_type",metavar="Input File Type", help="Select input file type", choices=['las', 'laz'], default='laz')
parser.add_argument('--name', metavar="AreaName", help="Project Area Name Used for Naming Convention, \neg : AreaName2020_C2_xxxxxx_yyyyyyy.las ", default="")
parser.add_argument('--year', metavar="Year of Survey", help="Year of Survey Naming Convention, \neg : AreaName2020_C2_xxxxxx_yyyyyyy.las ", default="")
parser.add_argument("epsg", metavar="EPSG", type=int, default=7855)
parser.add_argument("hz", metavar="hz", help="Provide maximum horizontal distance", default=20, type=int)
parser.add_argument("vt", metavar="vt", help="Provide vertical accuracy requirement", default=0.10, type=float)
parser.add_argument("-co", "--cores",metavar="Cores", help="No of cores to run in", type=int, default=4)
return parser.parse_args()
def main():
parser = GooeyParser(description='Process some integers.')
parser.add_argument(
'required_field',
metavar='Some Field',
help='Enter some text!')
parser.add_argument(
'-f', '--foo',
metavar='Some Flag',
action='store_true',
help='I turn things on and off')
args = parser.parse_args()
print('Hooray!')
def main():
parser = GooeyParser(description='CMTE License No. Checker')
parser.add_argument('filename', widget='FileChooser')
parser.add_argument('db', widget='FileChooser')
parser.add_argument('license_col',
type=int,
help='Column number of the license number')
parser.add_argument('fname_col',
type=int,
help='Column number of the first name')
parser.add_argument('lname_col',
type=int,
help='Column number of the last name')
args = parser.parse_args()
check_member_license(args.filename, args.db, args.license_col,
args.fname_col, args.lname_col)
def main():
parser = GooeyParser(description="PowerPoint Exporter")
parser.add_argument('powerpoint', widget="FileChooser")
parser.add_argument('output',
help="Folder to place resulting images",
widget="DirChooser")
parser.add_argument('width', help="Width of resulting image (0-3072)")
parser.add_argument('height', help="Height of resulting image (0-3072)")
args = parser.parse_args()
if not (os.path.isfile(args.powerpoint) and os.path.isdir(args.output)):
raise "Invalid paths!"
export_presentation(args.powerpoint, args.output, args.width, args.height)
print "Done!"
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 parse_args(args):
parser = GooeyParser(
description="Zip up unseasonable folders and unzip seasonable folders."
)
parser.add_argument(
"season",
choices=attic.Seasons.keys(),
help=
"The season to make clothes available for. Folders with 'Autumn' in the name are treated the same as folders with 'Fall' in the name."
)
parser.add_argument("folders",
help="Folders containing subfolders to seasonalize",
nargs="*",
widget="MultiDirChooser")
return parser.parse_args(args)
def main():
# Parse using gooey;
parser = GooeyParser(
description=
"Select a gif to ascii-fy, use the optional text boxes below to \n"
"configure some of the behavior of the program.")
parser.add_argument('path',
metavar='File',
widget="FileChooser",
help="Browse to your file.")
parser.add_argument(
'--scale_down',
metavar="Scale Down",
help="Scale down original gif by some percentage [%] \n"
"It is recommended to try higher numbers first.",
type=int,
default=50,
gooey_options={
'validator': {
'test': '0 < int(user_input) < 100',
'message': 'Scale down [%] has to be between 0 and 100%!'
}
})
parser.add_argument(
'--tile_size',
metavar="ASCII Tile Size",
help="Tiles are 50x50, lowering the value decreases output gif size.\n"
"Fiddle with with the scale down before fiddling with this.",
type=int,
default=20,
gooey_options={
'validator': {
'test': '0 < int(user_input) < 100',
'message': 'Tile can\'t be negative or larger than 100!'
}
})
arguments = parser.parse_args()
path = arguments.path
scale_down = arguments.scale_down
tile_size = arguments.tile_size
# Main flow
sprite_dictionary = get_sprite_dict(tile_size)
extract_frames(path, "gif_frames")
frames_to_ascii("gif_frames", sprite_dictionary, "ascii_frames",
scale_down)
create_gif("ascii_frames/*")
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
