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(): 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(): 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