def process_options(self):
# process any optlist_ options
self.valid_opts.check_special_opts(sys.argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, apply -help
if len(sys.argv) <= 1 or '-help' in sys.argv:
print(g_help_string)
return 0
if '-hist' in sys.argv:
print(g_history)
return 0
if '-show_valid_opts' in sys.argv:
self.valid_opts.show('', 1)
return 0
if '-ver' in sys.argv:
print(g_version)
return 0
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(sys.argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return 1 # error condition
# ------------------------------------------------------------
# process non-chronological options, verb comes first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
# ------------------------------------------------------------
# process options sequentially, to make them like a script
for opt in uopts.olist:
# main options
if opt.name == '-infile':
if self.a1d != None:
print('** only 1 -infile option allowed')
return 1
val, err = uopts.get_string_opt('', opt=opt)
if val != None and err: return 1
if self.init_from_file(val): return 1
# general options
elif opt.name == '-verb':
val, err = uopts.get_type_opt(int, '', opt=opt)
if val != None and err: return 1
else: self.verb = val
continue
return 0
def read_opts(self):
"""check for terminal arguments, then read the user options"""
# process any optlist_ options
self.valid_opts.check_special_opts(sys.argv)
# ------------------------------------------------------------
# check for terminal args in argv (to ignore required args)
# if argv has only the program name, or user requests help, show it
if len(sys.argv) <= 1 or '-help' in sys.argv:
print(g_help_string)
return 0
if '-hist' in sys.argv:
print(g_history)
return 0
if '-show_valid_opts' in sys.argv: # show all valid options
self.valid_opts.show('', 1)
return 0
if '-ver' in sys.argv:
print(g_version)
return 0
# ------------------------------------------------------------
# now read user options
self.user_opts = option_list.read_options(sys.argv, self.valid_opts)
if not self.user_opts: return 1 # error condition
return None # normal completion
def process_options(self, argv=sys.argv):
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, apply -help
if '-help' in argv or len(argv) < 2:
print(g_help_string)
return 0
if '-help_rc_files' in argv or '-help_dot_files' in argv:
print(g_help_rc_files)
return 0
if '-hist' in argv:
print(g_history)
return 0
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 0
if '-todo' in argv:
print(g_todo)
return 0
if '-ver' in argv:
print(g_version)
return 0
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return 1 # error condition
# ------------------------------------------------------------
# process options, go after -verb first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
for opt in uopts.olist:
if opt.name == '-casematch':
if OL.opt_is_yes(opt): self.casematch = 1
else: self.casematch = 0
continue
if opt.name == '-check_all':
self.act = 1
self.sys_check = 1
continue
if opt.name == '-data_root':
self.data_root = opt.parlist[0]
continue
if opt.name == '-dot_file_list':
self.dot_file_list = 1
self.act = 1
continue
if opt.name == '-dot_file_pack':
self.dot_file_pack = opt.parlist[0]
self.act = 1
continue
if opt.name == '-dot_file_show':
self.dot_file_show = 1
self.act = 1
continue
if opt.name == '-exact':
if OL.opt_is_yes(opt):
self.exact = 1
# default of casematching is 1 for this
if self.casematch < 0: self.casematch = 1
else: self.exact = 0
continue
if opt.name == '-find_prog':
self.act = 1
self.find_prog = opt.parlist[0]
continue
# already processing options: just continue
if opt.name == '-verb': continue
# an unhandled option
print('** option %s not yet supported' % opt.name)
return 1
if not self.act:
print('** no action option found, please see -help output\n')
return 1
return None
def process_options(self):
"""return 1 on valid and exit
0 on valid and continue
-1 on invalid
"""
argv = sys.argv
# a quick out (no help, continue and open GUI)
if len(argv) == 0: return 0
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# ------------------------------------------------------------
# check for terminal options before processing the rest
if '-help' in argv:
print(g_command_help)
return 1
if '-help_gui' in argv:
print(USKEL.helpstr_gui)
return 1
if '-help_howto_program' in argv:
print(USKEL.helpstr_create_program)
return 1
if '-help_todo' in argv:
print(USKEL.helpstr_todo)
return 1
if '-hist' in argv:
print(USKEL.g_history)
return 1
if '-show_default_vars' in argv:
USKEL.g_user_defs.show('default uvars :')
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-ver' in argv:
print('uber_skel.py: version %s' % USKEL.g_version)
return 1
# ------------------------------------------------------------
# read and process user options (no check for terminal opts)
self.uopts = OPT.read_options(argv, self.valid_opts)
if not self.uopts: return -1
uopts = self.uopts # convenience
# init subject options struct
self.cvars = VO.VarsObject('control vars from command line')
self.uvars = VO.VarsObject('user vars from command line')
self.guiopts = ['uber_skel.py']
# first set verbose level
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
else: self.verb = 1
SUBJ.set_var_str_from_def('uvars',
'verb', ['%d' % self.verb],
self.uvars,
defs=USKEL.g_user_defs)
use_gui = 1 # assume GUI unless we hear otherwise
# first process all setup options
errs = 0
for opt in uopts.olist:
# skip -verb (any terminal option should block getting here)
if opt.name == '-verb':
continue
# and skip and post-setup options (print command, save, etc.)
elif opt.name == '-print_script':
continue
elif opt.name == '-save_script':
continue
# now go after "normal" options
if opt.name == '-no_gui':
use_gui = 0
continue
# get any PyQt4 options
elif opt.name == '-qt_opts':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err: return -1
self.guiopts.extend(val)
# cvar requires at least 2 parameters, name and value
elif opt.name == '-cvar':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err: return -1
# and set it from the form name = [value_list]
if SUBJ.set_var_str_from_def('cvars',
val[0],
val[1:],
self.cvars,
USKEL.g_ctrl_defs,
verb=self.verb) < 0:
errs += 1
continue
# uvar requires at least 2 parameters, name and value
elif opt.name == '-uvar':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err: return -1
# and set it from the form name = [value_list]
if SUBJ.set_var_str_from_def('uvars',
val[0],
val[1:],
self.uvars,
USKEL.g_user_defs,
verb=self.verb) < 0:
errs += 1
continue
if not errs: # then we can handle any processing options
if uopts.find_opt('-print_script'): self.print_script()
if not errs: # then we can handle any processing options
opt = uopts.find_opt('-save_script')
if opt != None:
val, err = uopts.get_string_opt('', opt=opt)
if val != None and not err: self.save_script(val)
if errs: return -1
if use_gui: return 0 # continue and open GUI
else: return 1 # no error, but terminate on return
def get_opts():
global g_help_string
okopts = option_list.OptionList('for input')
okopts.add_opt('-help', 0, [], \
helpstr='display program help')
okopts.add_opt('-hist', 0, [], \
helpstr='display the modification history')
okopts.add_opt('-show_valid_opts', 0, [], \
helpstr='display all valid options')
okopts.add_opt('-ver', 0, [], \
helpstr='display the current version number')
okopts.add_opt('-amplitudes', 0, [], \
helpstr='output is in -stim_times_AM1 format')
okopts.add_opt('-files',
-1, [],
req=1,
okdash=0,
helpstr='set the list of input files')
okopts.add_opt('-prefix', 1, [], req=1, \
helpstr='specify the prefix for output files')
okopts.add_opt('-tr', 1, [], req=1, \
helpstr='set the TR time, in seconds')
okopts.add_opt('-nt', 1, [], req=0, \
helpstr='set the number of TRs per run')
okopts.add_opt('-nruns', 1, [], req=0, \
helpstr='set the number of runs')
okopts.add_opt('-no_consec', 0, [], \
helpstr='do not allow consecutive events')
okopts.add_opt('-offset', 1, [], \
helpstr='specify offset to add to all output times')
okopts.add_opt('-run_trs', -1, [], req=0, \
helpstr='specify TRs per run, if they vary')
okopts.add_opt('-labels',
-1, [],
okdash=0,
helpstr='add these labels to the file names')
okopts.add_opt('-verb', 1, [], \
helpstr='set the verbosity level')
okopts.trailers = 1
# process any optlist_ options
okopts.check_special_opts(sys.argv)
# if argv has only the program name, or user requests help, show it
if len(sys.argv) <= 1 or '-help' in sys.argv:
print(g_help_string)
return
if '-hist' in sys.argv: # print history
print(g_mst_history)
return
if '-show_valid_opts' in sys.argv: # show all valid options
okopts.show('', 1)
return
if '-ver' in sys.argv: # print version
print(g_mst_version)
return
opts = option_list.read_options(sys.argv, okopts)
return opts
def process_options(self):
"""process all options, applying to interfaces where appropriate"""
# ==================================================
# first fire up the TCP interface
self.RTI = RT.RTInterface()
if not self.RTI: return None
# and store globally
global g_RTinterface
g_RTinterface = self.RTI # global for signal handler
# ==================================================
# gather and process the user options
self.user_opts = OL.read_options(sys.argv, self.valid_opts)
uopts = self.user_opts # for convenience
if not uopts: return 1
# process -verb first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err:
self.verb = val
self.RTI.verb = val
# ==================================================
# --- serial options ---
# port first: if set, create SerialInterface
val, err = uopts.get_string_opt('-serial_port')
if val != None and not err:
self.SER = RT.SerialInterface(val, verb=self.verb)
if not self.SER: return 1
# ==================================================
# --- feedback options ---
val, err = uopts.get_string_opt('-data_choice')
if val != None and not err: self.data_choice = val
val, err = uopts.get_type_list(float, '-dc_params')
if val != None and not err: self.dc_params = val
# ==================================================
# --- tcp options ---
val, err = uopts.get_string_opt('-show_data')
if val != None and not err:
if val == 'no': self.RTI.show_data = 0
else: self.RTI.show_data = 1
val, err = uopts.get_string_opt('-extras_on_one_line')
if val != None and not err:
if val == 'no': self.RTI.extras_one_line = 0
else: self.RTI.extras_one_line = 1
if uopts.find_opt('-show_comm_times'): self.RTI.show_times = 1
if uopts.find_opt('-swap'): self.RTI.swap = 1
val, err = uopts.get_type_opt(int, '-tcp_port')
if val != None and not err: self.RTI.server_port = val
# ==================================================
# --- text file writing options ---
# open text file
val, err = uopts.get_string_opt('-write_text_data')
if val != None and not err:
self.TEXT = RT.TextFileInterface(val, verb=self.verb)
if not self.TEXT: return 1
# ==================================================
# --- demo options ---
val, err = uopts.get_string_opt('-show_demo_data')
if val != None and not err:
if val == 'no': self.show_demo_data = 0
else: self.show_demo_data = 1
val, err = uopts.get_string_opt('-show_demo_gui')
if val != None and not err:
if val == 'yes':
if self.set_demo_gui():
print('\n** GUI demo failed, proceeding without GUI...\n')
return 0 # so continue and listen
def process_options(self):
"""return 1 on valid and exit
return 0 on valid and continue
return -1 on invalid
"""
argv = sys.argv
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, do default processing
if '-help' in argv or len(argv) < 2:
show_help()
return 1
if '-help_examples' in argv:
print(g_help_examples)
return 1
if '-hist' in argv:
print(g_history)
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-ver' in argv:
print(g_version)
return 1
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return -1 # error condition
# ------------------------------------------------------------
# process verb first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
# ------------------------------------------------------------
# process options sequentially, to make them like a script
errs = 0
for opt in self.user_opts.olist:
# check for anything to skip
if opt.name == '-verb': pass
elif opt.name == '-logfile':
self.logfile, err = uopts.get_string_opt('', opt=opt)
if self.logfile == None or err:
print('** failed to read -logfile name')
errs +=1
elif opt.name == '-labels':
self.labels, err = uopts.get_string_list('', opt=opt)
if self.labels == None or err:
print('** option -labels: failed to process option')
errs +=1
elif opt.name == '-show_all_orig':
pass # process later
elif opt.name == '-show_orig':
self.show_vals = SHOW_ORIG
elif opt.name == '-show_rank':
self.show_vals = SHOW_RANK
if self.user_opts.find_opt('-show_all_orig'):
if not (self.show_vals & SHOW_ORIG):
print("** -show_all_orig requires showing orig")
errs += 1
self.show_vals |= SHOW_ALL_ORIG
# allow early and late error returns
if errs: return -1
# ------------------------------------------------------------
## apply any trailing logic
if self.logfile == '':
print('** missing -logfile option')
errs += 1
if len(self.labels) < 1:
print('** missing -labels to search for')
errs += 1
if errs: return -1
return 0
def process_options(self):
"""return 1 on valid and exit
return 0 on valid and continue
return -1 on invalid
"""
argv = sys.argv
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, do default processing
if '-help' in argv or len(argv) < 2:
print(g_help_string)
return 1
if '-hist' in argv:
print(g_history)
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-ver' in argv:
print(g_version)
return 1
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return -1 # error condition
# ------------------------------------------------------------
# process verb first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
# ------------------------------------------------------------
# process options sequentially, to make them like a script
errs = 0
for opt in self.user_opts.olist:
# check for anything to skip
if opt.name == '-verb': pass
elif opt.name == '-infiles':
self.infiles, err = uopts.get_string_list('', opt=opt)
if self.infiles == None or err:
print('** failed to read -infiles list')
errs +=1
elif opt.name == '-overwrite':
self.overwrite = 1
elif opt.name == '-prefix':
val, err = uopts.get_string_opt(opt=opt)
if val != None and not err: self.prefix = val
# allow early and late error returns
if errs: return -1
# ------------------------------------------------------------
# apply any trailing logic
# if here, require input files
if len(self.infiles) < 1:
print('** missing -infiles option')
errs += 1
# if no -prefix and no -verb, default verb to 2
if not self.user_opts.find_opt('-verb') and self.prefix == '':
self.verb = 2
if errs: return -1
return 0
def process_options(self):
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(sys.argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return 1 # error condition
# ------------------------------------------------------------
# check -test_libs separately, as we may want to apply -verb
if '-test_libs' in sys.argv:
val, err = self.user_opts.get_type_opt(int, '-verb')
if val == None or err: val = 2
return self.test_libraries(verb=val)
# attempting real work, load AM (locally)
if self.set_afni_xmat(): return 1
# ------------------------------------------------------------
# check general options, esp. chrono
if uopts.find_opt('-chrono'): self.chrono = 1
# if options are not chronological, process general options now
# (so -show options are still in order)
if not self.chrono:
# general options might affect selection options
val, err = self.user_opts.get_type_opt(float, '-cormat_cutoff')
if val != None and not err: self.cormat_cut = val
val, err = self.user_opts.get_type_opt(float, '-cosmat_cutoff')
if val != None and not err: self.cosmat_cut = val
val, err = self.user_opts.get_type_opt(float, '-cosmat_motion')
if val != None and not err: self.cosmat_motion = 1
val, err = self.user_opts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
# selection options
val, err = uopts.get_string_opt('-load_xmat')
if val and not err:
if self.set_xmat(val): return 1
val, err = uopts.get_string_opt('-load_1D')
if val and not err:
if self.set_1D(val): return 1
val, err = uopts.get_string_opt('-choose_cols')
if val and not err:
rstr = self.set_cols_from_string(val)
if rstr:
print("** failed to apply '-choose_cols':\n%s" % rstr)
return 1
# ------------------------------------------------------------
# selection and process options:
# process sequentially, to make them like a script
for opt in uopts.olist:
# if all options are chronological, check load and general, too
if self.chrono:
# selection options
if opt.name == '-load_xmat':
if self.set_xmat(opt.parlist[0]): return 1
elif opt.name == '-load_1D':
if self.set_1D(opt.parlist[0]): return 1
elif opt.name == '-choose_cols':
rstr = self.set_cols_from_string(opt.parlist[0])
if rstr:
print("** failed to apply '-choose_cols':\n%s" % rstr)
return 1
# general options
elif opt.name == '-cormat_cutoff':
val, err = self.user_opts.get_type_opt(float, '', opt=opt)
if val != None and err: return 1
else: self.cormat_cut = val
elif opt.name == '-cosmat_cutoff':
val, err = self.user_opts.get_type_opt(float, '', opt=opt)
if val != None and err: return 1
else: self.cosmat_cut = val
elif opt.name == '-cosmat_motion':
self.cosmat_motion = 1
elif opt.name == '-verb':
val, err = self.user_opts.get_type_opt(int, '', opt=opt)
if val != None and err: return 1
else: self.verb = val
# 'show' options (allow these to fail?)
if opt.name == '-show_col_types':
if self.matX:
err, str = self.make_col_type_string()
print(str)
else: print("** -show_col_types: needs -load_xmat")
elif opt.name == '-show_conds':
if self.matX: print(self.matX.make_show_conds_str(self.col_list))
else: print("** -show_conds: needs -load_xmat")
elif opt.name == '-show_cormat':
err, str = self.make_cormat_string()
print('-- Correlation matrix for %s :' % self.fname_mat)
print(str)
elif opt.name == '-show_cormat_warnings':
err, str = self.make_cormat_warnings_string()
print('-- Correlation matrix warnings for %s :' % self.fname_mat)
print(str)
elif opt.name == '-show_cosmat':
err, str = self.make_cosmat_string()
print('-- Cosine matrix for %s :' % self.fname_mat)
print(str)
elif opt.name == '-show_cosmat_warnings':
err, str = self.make_cosmat_warnings_string()
print('-- Cosine matrix warnings for %s :' % self.fname_mat)
print(str)
elif opt.name == '-show_fit_betas':
err, rstr = self.make_matrix_fit_betas_string()
print(rstr)
elif opt.name == '-show_fit_ts':
err, rstr = self.make_matrix_fit_string()
print(rstr)
elif opt.name == '-show_xmat':
if self.matX: self.matX.show()
else: print("** -show_xmat: needs -load_xmat")
elif opt.name == '-show_1D':
if self.matX: self.mat1D.show()
else: print("** -show_1D: needs -load_1D")
# store gui options in a separate list
elif opt.name[0:5] == '-gui_': self.gui_opts.append(opt)
# ------------------------------------------------------------
# process GUI options
# ------------------------------------------------------------
# last test before returning
if uopts.find_opt('-no_gui'): self.use_gui = 0
else: self.use_gui = 1
return 0
def process_options(self):
argv = sys.argv
if len(argv) == 0: # non-gui out
print(g_command_help)
return 1
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, apply -help
if len(argv) <= 1 or '-help' in argv:
print(g_command_help)
return 1
if '-hist' in argv:
print(CLUST.g_history)
return 1
if '-show_default_cvars' in argv:
CLUST.g_ctrl_defs.show('')
return 1
if '-show_default_uvars' in argv:
CLUST.g_user_defs.show('')
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-ver' in argv:
print(CLUST.g_version)
return 1
# ============================================================
# read options specified by the user
self.user_opts = OPT.read_options(argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return -1 # error condition
# ------------------------------------------------------------
# init subject options struct
self.cvars = VO.VarsObject('control vars from command line')
self.uvars = VO.VarsObject('user vars from command line')
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
SUBJ.set_var_str_from_def('cvars',
'verb', ['%d' % self.verb],
self.cvars,
defs=CLUST.g_ctrl_defs)
# first process all setup options
errs = 0
for opt in uopts.olist:
# skip -verb (any terminal option should block getting here)
if opt.name == '-verb':
continue
# and skip and post-setup options (print command, save, etc.)
elif opt.name == '-print_script':
continue
elif opt.name == '-save_script':
continue
# now go after "normal" options
elif opt.name == '-on_surface':
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1
if self.cvars.set_var_with_defs(opt.name[1:],
val,
CLUST.g_ctrl_defs,
as_type=1,
oname='cvars',
verb=self.verb) < 0:
errs += 1
continue
# cvar requires at least 2 parameters, name and value
elif opt.name == '-cvar':
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1
# go after verb, in particular
if val[0] == 'verb':
try:
self.verb = int(val[1])
except:
print("** failed to set 'verb' level")
errs += 1
continue
# and set it from the form name = [value_list]
if SUBJ.set_var_str_from_def('cvars',
val[0],
val[1:],
self.cvars,
CLUST.g_ctrl_defs,
verb=self.verb) < 0:
errs += 1
continue
# uvar requires at least 2 parameters, name and value
elif opt.name == '-uvar':
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1
# and set it from the form name = [value_list]
if SUBJ.set_var_str_from_def('uvars',
val[0],
val[1:],
self.uvars,
CLUST.g_user_defs,
verb=self.verb) < 0:
errs += 1
continue
else:
print('** unknown option %s' % opt.name)
errs += 1
if self.verb > 2:
print('-' * 75)
self.uvars.show('post-init uvars', name=0)
self.cvars.show('post-init cvars', name=0)
print('-' * 75)
if errs: return -1
else: return 0 # no error, and continue on return
def process_options(self):
"""return 1 on valid and exit
0 on valid and continue
-1 on invalid
"""
argv = sys.argv
# a quick out (no help, continue and open GUI)
if len(argv) == 0: return 0
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# ------------------------------------------------------------
# check for terminal options before processing the rest
if '-help' in argv:
print(g_command_help)
return 1
if '-help_gui' in argv:
print(LTT.helpstr_gui)
return 1
if '-help_todo' in argv:
print(LTT.helpstr_todo)
return 1
if '-hist' in argv:
print(LTT.g_history)
return 1
if '-show_default_vars' in argv:
LTT.g_user_defs.show('default uvars :')
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-show_cvar_dict' in sys.argv:
dict = LTT.g_cvar_dict
keys = list(dict.keys())
keys.sort()
for key in keys:
print(' %-20s : %s' % (key, dict[key]))
return 1
if '-show_uvar_dict' in sys.argv:
dict = LTT.g_uvar_dict
keys = list(dict.keys())
keys.sort()
for key in keys:
print(' %-20s : %s' % (key, dict[key]))
return 1
if '-ver' in argv:
print('uber_ttest.py: version %s' % LTT.g_version)
return 1
# ------------------------------------------------------------
# read and process user options (no check for terminal opts)
self.uopts = OPT.read_options(argv, self.valid_opts)
if not self.uopts: return -1
uopts = self.uopts # convenience
# init subject options struct
self.cvars = VO.VarsObject('control vars from command line')
self.uvars = VO.VarsObject('user vars from command line')
self.guiopts = ['uber_ttest.py']
# first set verbose level
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
else: self.verb = 1
SUBJ.set_var_str_from_def('cvars',
'verb', ['%d' % self.verb],
self.cvars,
defs=LTT.g_ctrl_defs)
use_gui = 1 # assume GUI unless we hear otherwise
cvar_keys = list(LTT.g_cvar_dict.keys())
uvar_keys = list(LTT.g_uvar_dict.keys())
# we already processed terminal options
term_opts = [
'-help', '-help_gui', '-help_todo', '-hist', 'show_default_vars',
'-ver', '-show_cvar_dict', '-show_uvar_dict'
]
# skip post-setup options, to be checked later
post_opts = ['-print_script', '-save_script']
# first process all setup options
errs = 0
for opt in uopts.olist:
# skip -verb (any terminal option should block getting here)
if opt.name in term_opts: continue
# and skip and post-setup options (print command, save, etc.)
if opt.name in post_opts: continue
vname = opt.name[1:]
# now go after "normal" options
if opt.name == '-no_gui':
use_gui = 0
continue
# get any PyQt4 options
elif opt.name == '-qt_opts':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err:
errs += 1
continue
self.guiopts.extend(val)
# cvar requires at least 2 parameters, name and value
elif opt.name == '-cvar':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err:
errs += 1
continue
if self.cvars.set_var_with_defs(val[0],
val[1:],
LTT.g_ctrl_defs,
oname='cvars',
verb=self.verb) < 0:
errs += 1
continue
# uvar requires at least 2 parameters, name and value
elif opt.name == '-uvar':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err:
errs += 1
continue
if self.uvars.set_var_with_defs(val[0],
val[1:],
LTT.g_user_defs,
oname='uvars',
verb=self.verb) < 0:
errs += 1
continue
# maybe this is a control variable key
elif vname in cvar_keys:
val, err = uopts.get_string_list('', opt=opt)
if val == None or err:
errs += 1
continue
if self.cvars.set_var_with_defs(
vname, val, LTT.g_ctrl_defs, oname='cvars',
verb=self.verb) < 0:
errs += 1
continue
# maybe this is a user variable key
elif vname in uvar_keys:
val, err = uopts.get_string_list('', opt=opt)
if val == None or err:
errs += 1
continue
if self.uvars.set_var_with_defs(
vname, val, LTT.g_user_defs, oname='uvars',
verb=self.verb) < 0:
errs += 1
continue
else:
print('** invalid option: %s' % opt.name)
errs += 1
continue
if not errs: # then we can handle any processing options
if uopts.find_opt('-print_script'):
self.print_script()
use_gui = 0
#opt = uopts.find_opt('-save_script')
#if opt != None:
# val, err = uopts.get_string_opt('', opt=opt)
val, err = uopts.get_string_opt('-save_script')
if val != None and not err:
self.save_script(val)
use_gui = 0
if errs: return -1
if use_gui: return 0 # continue and open GUI
else: return 1 # no error, but terminate on return
def process_options(self):
"""return 1 on valid and exit
return 0 on valid and continue
return -1 on invalid
"""
argv = sys.argv
# process any optlist_ options
self.valid_opts.check_special_opts(argv)
# process terminal options without the option_list interface
# (so that errors are not reported)
# if no arguments are given, do default processing
if '-help' in argv or len(argv) < 2:
print(g_help_string)
return 1
if '-hist' in argv:
print(g_history)
return 1
if '-show_valid_opts' in argv:
self.valid_opts.show('', 1)
return 1
if '-ver' in argv:
print(g_version)
return 1
# ============================================================
# read options specified by the user
self.user_opts = OL.read_options(argv, self.valid_opts)
uopts = self.user_opts # convenience variable
if not uopts: return -1 # error condition
# ------------------------------------------------------------
# process verb first
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: self.verb = val
# ------------------------------------------------------------
# process options sequentially, to make them like a script
errs = 0
for opt in self.user_opts.olist:
# check for anything to skip
if opt.name == '-verb': pass
elif opt.name == '-infiles':
self.infiles, err = uopts.get_string_list('', opt=opt)
if self.infiles == None or err:
print('** failed to read -infiles list')
errs +=1
self.parse_infile_names()
elif opt.name == '-overwrite':
self.overwrite = 1
elif opt.name == '-separator':
self.separator, err = uopts.get_string_opt('', opt=opt)
if self.separator == None or err:
print("** bad -separator option")
errs += 1
if self.separator == 'tab': self.separator = '\t'
elif self.separator == 'whitespace': self.separator = 'ws'
self.seplen = len(self.separator)
elif opt.name == '-outlier_sep':
self.out_sep, err = uopts.get_string_opt('', opt=opt)
if self.out_sep == None or err:
print("** bad -outlier_sep option")
errs += 1
if self.out_sep == 'tab': self.out_sep = '\t'
elif self.out_sep == 'comma': self.out_sep = ','
# 'space' is handled as a special case
# ------------------------------
# report outliers
elif opt.name == '-report_outliers':
params, err = uopts.get_string_list('', opt=opt)
if params == None or err:
print('** failed to parse -report_outliers %s' % params)
errs +=1
continue
if self.add_test_to_outlier_report(params):
errs +=1
continue
self.report_outliers = 1
elif opt.name == '-report_outliers_fill_style':
self.ro_fill_type, err = uopts.get_string_opt('', opt=opt)
if self.ro_fill_type is None or err:
print("** bad opt: -report_outliers_fill_style %s" \
% self.ro_fill_type)
errs += 1
elif opt.name == '-report_outliers_header_style':
self.ro_head_type, err = uopts.get_string_opt('', opt=opt)
if self.ro_head_type is None or err:
print("** bad opt: -report_outliers_header_style %s" \
% self.ro_head_type)
errs += 1
# ------------------------------ outliers end
elif opt.name == '-showlabs':
self.showlabs = 1
elif opt.name == '-show_infiles':
self.show_infiles = 1
elif opt.name == '-show_missing':
self.show_missing = 1
# try to replace -tablefile with -write_table
elif opt.name == '-write_table' or opt.name == '-tablefile':
self.tablefile, err = uopts.get_string_opt('', opt=opt)
if self.tablefile == None or err:
print("** bad %s option" % opt.name)
errs +=1
elif opt.name == '-write_outliers':
self.ro_tablefile, err = uopts.get_string_opt('', opt=opt)
if self.ro_tablefile == None or err:
print("** bad -write_outliers option")
errs +=1
else:
oind = self.user_opts.olist.index(opt)
print('** unknown option # %d: %s' % (oind+1, opt.name))
errs += 1
break
# allow early and late error returns
if errs: return -1
# ------------------------------------------------------------
# apply any trailing logic
if len(self.infiles) < 1:
print('** missing -infiles option')
errs += 1
if errs: return -1
return 0
def process_options(valid_opts, argv):
"""return status and VarsObject structs of subject and control variables
- given list of valid options, read and process the user options
- if terminal option or -no_gui, return 0 (succesful quit)
return 1 : on success and terminate
0 : on success and continue with GUI
-1 : on error condition
"""
# a quick out
if len(argv) == 0: return 0, None, None, None
# process any optlist_ options
valid_opts.check_special_opts(argv)
# ------------------------------------------------------------
# check for terminal options before processing the rest
if '-help' in sys.argv:
print(g_command_help)
valid_opts.show('', 1, show_count=0)
print(g_help_trailer)
return 1, None, None, None
if '-help_gui' in sys.argv:
print(USUBJ.helpstr_usubj_gui)
return 1, None, None, None
if '-help_howto_program' in sys.argv:
print(USUBJ.helpstr_howto_program)
return 1, None, None, None
if '-help_install' in sys.argv:
print(g_install_str)
return 1, None, None, None
if '-help_install_nokia' in sys.argv:
print(g_install_nokia)
return 1, None, None, None
if '-hist' in sys.argv:
print(USUBJ.g_history)
return 1, None, None, None
if '-show_default_vars' in sys.argv:
USUBJ.g_ctrl_defs.show('default cvars :')
USUBJ.g_subj_defs.show('default svars :')
return 1, None, None, None
if '-show_valid_opts' in sys.argv:
valid_opts.show('', 1)
return 1, None, None, None
if '-show_svar_dict' in sys.argv:
dict = USUBJ.g_svar_dict
keys = list(dict.keys())
keys.sort()
for key in keys:
print(' %-20s : %s' % (key, dict[key]))
return 1, None, None, None
if '-todo' in sys.argv:
print(USUBJ.helpstr_todo)
return 1, None, None, None
if '-ver' in sys.argv:
print('uber_subject.py: version %s' % USUBJ.g_version)
return 1, None, None, None
# ------------------------------------------------------------
# read and process user options (no check for terminal opts)
uopts = OPT.read_options(argv, valid_opts)
if not uopts: return -1, None, None, None
# init subject options struct
svars = VO.VarsObject('subject vars from command line')
cvars = VO.VarsObject('control vars from command line')
guiopts = ['uber_subject.py']
# first set verbose level
val, err = uopts.get_type_opt(int, '-verb')
if val != None and not err: verb = val
else: verb = 1
USUBJ.set_vstr_from_def('cvars', 'verb', ['%d'%verb], cvars)
use_gui = 1 # assume GUI unless we hear otherwise
svar_keys = list(USUBJ.g_svar_dict.keys())
errs = 0
# ------------------------------------------------------------
# first process all setup options (e.g. -anal_type/domain)
# - since they might go via -svar, we must search
for opt in uopts.olist:
# just check for 'rest' here
if opt.name == '-anal_type':
val, err = uopts.get_string_opt('', opt=opt)
if val == None or err: return -1, None, None, None
if val == 'rest':
if verb > 1: print('-- init from rest defaults')
svars.merge(USUBJ.g_rdef_strs)
elif opt.name == '-anal_domain':
val, err = uopts.get_string_opt('', opt=opt)
if val == None or err: return -1, None, None, None
if val == 'surface':
print('** uber_subject.py: not ready for surface analysis')
return -1, None, None, None
elif opt.name == '-svar':
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1, None, None, None
if val[0] == '-anal_type':
if val[1] == 'rest':
if verb > 1: print('-- init from rest defaults')
svars.merge(USUBJ.g_rdef_strs)
elif val[0] == '-anal_domain':
if val[1] == 'surface':
print('** uber_subject.py: not ready for surface analysis')
return -1, None, None, None
# done with analysis init options
# ------------------------------------------------------------
for opt in uopts.olist:
# skip -verb and any terminal option (though they should not be here)
if opt.name == '-help': continue
elif opt.name == '-help_gui': continue
elif opt.name == '-hist': continue
elif opt.name == '-show_valid_opts': continue
elif opt.name == '-todo': continue
elif opt.name == '-ver': continue
elif opt.name == '-verb': continue
# and skip any pre-setup options ...
elif opt.name == '-anal_type': continue
elif opt.name == '-anal_domain': continue
# and skip any post-setup options ...
elif opt.name == '-print_ap_command':continue
elif opt.name == '-save_ap_command': continue
elif opt.name == '-exec_ap_command': continue
elif opt.name == '-exec_proc_script':continue
vname = opt.name[1:]
# now go after "normal" options
if opt.name == '-no_gui':
use_gui = 0
continue
# get any PyQt4 options
elif opt.name == '-qt_opts':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err: return -1, None, None, None
guiopts.extend(val)
# cvar requires at least 2 parameters, name and value
elif opt.name == '-cvar':
val, err = uopts.get_string_list('', opt=opt)
if val != None and err: return -1, None, None, None
# and set it from the form name = [value_list]
if USUBJ.set_vstr_from_def('cvars', val[0], val[1:],
cvars, verb=verb, spec=1) < 0:
errs += 1
continue
# svar requires at least 2 parameters, name and value
elif opt.name == '-svar':
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1, None, None, None
# and set it from the form name = [value_list]
if USUBJ.set_vstr_from_def('svars', val[0], val[1:],
svars, verb=verb, spec=1) < 0:
errs += 1
continue
# go after a direct svar key
elif vname in svar_keys:
val, err = uopts.get_string_list('', opt=opt)
if val == None or err: return -1, None, None, None
if USUBJ.set_vstr_from_def('svars', vname, val,
svars, verb=verb, spec=1) < 0:
errs += 1
continue
else:
print('** invalid option: %s' % opt.name)
errs += 1
continue
if not errs: # then we can handle any processing options
if uopts.find_opt('-print_ap_command'):
print_ap_command(svars, cvars)
if not errs: # then we can handle any processing options
opt = uopts.find_opt('-save_ap_command')
if opt != None:
val, err = uopts.get_string_opt('', opt=opt)
if val == None or err: return -1, None, None, None
save_ap_command(svars, cvars, val)
if not errs: # then we can handle any processing options
if uopts.find_opt('-exec_ap_command'):
subj = run_ap_command(svars, cvars)
if subj != None and uopts.find_opt('-exec_proc_script'):
subj.exec_proc_script()
if verb > 2: # show applied subject variables
changestr = cvars.changed_attrs_str(USUBJ.g_cdef_strs, skiplist='name',
showskip=0, showdel=0)
print('++ applied control variables: %s\n' % changestr)
changestr = svars.changed_attrs_str(USUBJ.g_sdef_strs, skiplist='name',
showskip=0, showdel=0)
print('++ applied subject variables: %s\n' % changestr)
if errs: return -1, None, None, None
if use_gui: return 0, svars, cvars, guiopts
else: return 1, svars, cvars, guiopts
