def _parse_raw_args(parser, args):
"""Simulate parsing by *parser*, return a list of tuples of
(dest, option_string, args).
If *args* contains unknown args or is otherwise malformed, we don't
raise an error (we leave this to the actual argument parser).
"""
results = []
class RawArgAction(Action):
def __call__(self, parser, namespace, values, option_string=None):
# ignore *namespace*, append to *results*
results.append((self.dest, option_string, values))
def error(msg):
raise ValueError(msg)
raw_parser = ArgumentParser(add_help=False)
raw_parser.error = error
for action in parser._actions:
# single args become single item lists
nargs = 1 if action.nargs is None else action.nargs
raw_parser.add_argument(*action.option_strings,
action=RawArgAction,
dest=action.dest,
nargs=nargs)
# leave errors to the real parser
raw_parser.parse_known_args(args)
return results
def main():
parser = ArgumentParser(description="A command line tool that converts magnet links in to .torrent files")
parser.add_argument('-m','--magnet', help='The magnet url')
parser.add_argument('-o','--output', help='The output torrent file name')
#
# This second parser is created to force the user to provide
# the 'output' arg if they provide the 'magnet' arg.
#
# The current version of argparse does not have support
# for conditionally required arguments. That is the reason
# for creating the second parser
#
# Side note: one should look into forking argparse and adding this
# feature.
#
conditionally_required_arg_parser = ArgumentParser(description="A command line tool that converts magnet links in to .torrent files")
conditionally_required_arg_parser.add_argument('-m','--magnet', help='The magnet url')
conditionally_required_arg_parser.add_argument('-o','--output', help='The output torrent file name', required=True)
magnet = None
output_name = None
#
# Attempting to retrieve args using the new method
#
args = vars(parser.parse_known_args()[0])
if args['magnet'] is not None:
magnet = args['magnet']
argsHack = vars(conditionally_required_arg_parser.parse_known_args()[0])
output_name = argsHack['output']
if args['output'] is not None and output_name is None:
output_name = args['output']
if magnet is None:
#
# This is a special case.
# This is when the user provides only the "output" args.
# We're forcing him to provide the 'magnet' args in the new method
#
print ('usage: {0} [-h] [-m MAGNET] -o OUTPUT'.format(sys.argv[0]))
print ('{0}: error: argument -m/--magnet is required'.format(sys.argv[0]))
sys.exit()
#
# Defaulting to the old of doing things
#
if output_name is None and magnet is None:
if len(sys.argv) >= 2:
magnet = sys.argv[1]
if len(sys.argv) >= 3:
output_name = sys.argv[2]
print magnet, output_name
magnet2torrent(magnet, output_name)
def main():
"""Main method in CLI method."""
parser = ArgumentParser()
parser.add_argument('-a', '--address', dest='address',
help='address of Locust Agent')
parser.add_argument('-k', '--key', dest='key',
help='secret key for particular node')
options, args = parser.parse_known_args()
for arg in args:
if arg.startswith('--'):
option = arg[:arg.index('=')] if '=' in arg else arg
parser.add_argument(option)
all_options, args = parser.parse_known_args()
command_options = dict((k, v) for k, v in all_options.__dict__.items() if
k not in options.__dict__)
if not options.address:
if environ.get('LOCUST_AGENT'):
options.address = environ['LOCUST_AGENT']
else:
parser.error('Agent address is not specified. '
'Please provide -a|--address option '
'or set environment variable LOCUST_AGENT.')
if not options.key:
if environ.get('LOCUST_KEY'):
options.key = environ['LOCUST_KEY']
else:
parser.error('Secret key is not specified. '
'Please provide -k | --key option '
'or set environment variable LOCUST_KEY.')
if 'http' not in options.address:
options.address = 'http://' + options.address
command = []
arguments = {}
arguments.update(command_options)
for arg in args:
if '=' in arg:
option, value = arg.split('=')
arguments[option] = value
else:
command.append(arg)
data = {}
if command:
data['command'] = '_'.join(command)
if arguments:
data['arguments'] = arguments
data['key'] = options.key
try:
data = dumps(data) if data else None
print urlopen(options.address, data).read()
except HTTPError as error:
print error
print error.read()
class AvocadoApp(object):
"""
Avocado application.
"""
def __init__(self, external_plugins=None):
# Catch all libc runtime errors to STDERR
os.environ['LIBC_FATAL_STDERR_'] = '1'
self.external_plugins = external_plugins
self.plugin_manager = None
self.app_parser = ArgumentParser(prog='avocado',
version=VERSION,
description='Avocado Test Runner')
self.app_parser.add_argument('-V', '--verbose', action='store_true',
help='print extra debug messages',
dest='verbose')
self.app_parser.add_argument('--logdir', action='store',
help='Alternate logs directory',
dest='logdir', default='')
self.app_parser.add_argument('--loglevel', action='store',
help='Debug Level',
dest='log_level', default='')
self.app_parser.add_argument('--plugins', action='store',
help='Load extra plugins from directory',
dest='plugins_dir', default='')
args, _ = self.app_parser.parse_known_args()
self.cmd_parser = self.app_parser.add_subparsers(title='subcommands',
description='valid subcommands',
help='subcommand help')
self.load_plugin_manager(args.plugins_dir)
args, _ = self.app_parser.parse_known_args()
self.plugin_manager.activate(args)
self.args = self.app_parser.parse_args()
def load_plugin_manager(self, plugins_dir):
"""Load Plugin Manager.
:param plugins_dir: Extra plugins directory.
"""
self.plugin_manager = get_plugin_manager()
self.plugin_manager.load_plugins(plugins_dir)
if self.external_plugins:
self.plugin_manager.add_plugins(self.external_plugins)
self.plugin_manager.configure(self.app_parser, self.cmd_parser)
def run(self):
return self.args.func(self.args)
def parseArgument(self):
"""Parse method specified options.There are two kinds of options.
1) general options such as madlib_schema, algorithm, method,
target_base_name(test item name) and so on.
2) specific options that come from algorithm, method above
"""
#1) general options
parser = ArgumentParser(description="MADLib Executor")
parser.add_argument("--p" , type=str, required = False,
default = 'greenplum')
parser.add_argument("--madlib_schema" , type=str, required = False
, default = 'madlib')
parser.add_argument("--algorithm" , type=str, required = True)
parser.add_argument("--method" , type=str, required = True)
parser.add_argument("--target_base_name", type=str, required = True)
parser.add_argument("--run_id" , type=str, required = False
, default = '0')
parser.add_argument("--spec_file" , type=str, required = False
, default = '../xml/config/' + Path.algorithmsSpecXml)
parser.add_argument("--conn", "-C",
metavar = "CONNSTR",
default = '',
dest = 'connection_string')
parser.parse_known_args(args = self.argv, namespace = self)
(self.logusername, self.logpassword, self.loghostname, self.logport,
self.logdatabase, _) = parseConnectionStr(self.connection_string)
#come out the executor specification
self.spec = ExecutorSpec(self.spec_file, self.madlib_schema)
#2) specific options
parser = ArgumentParser(description="MADLib Executor")
method = self.spec.getAlgorithm(self.algorithm).getMethod(self.method)
paras = method.getInputParams()
for para in paras:
if para.getDefaultValue():
parser.add_argument("--"+para.getName(), type=str, required = False
, default = para.getDefaultValue())
else:
parser.add_argument("--"+para.getName(), type=str, required = True)
try:
argument, _ = parser.parse_known_args(args = self.argv, namespace = self)
self.argument = argument
except Exception as e:
print 'Error in ArgumentParser', str(e)
def get_config_args(self, parser: argparse.ArgumentParser) -> argparse.Namespace:
"""Overrides the default CLI parsing.
Sets the configuration parameters for what a SageMaker run should do.
Note, this does not support the "play" mode.
"""
# first, convert the parser to a Namespace object with all default values.
empty_arg_list = []
args, _ = parser.parse_known_args(args=empty_arg_list)
parser = self.sagemaker_argparser()
sage_args, unknown = parser.parse_known_args()
# Now fill in the args that we care about.
sagemaker_job_name = os.environ.get("sagemaker_job_name", "sagemaker-experiment")
args.experiment_name = logger.get_experiment_name(sagemaker_job_name)
# Override experiment_path used for outputs
args.experiment_path = '/opt/ml/output/intermediate'
rl_coach.logger.experiment_path = '/opt/ml/output/intermediate' # for gifs
args.checkpoint_save_dir = '/opt/ml/output/data/checkpoint'
args.checkpoint_save_secs = 10 # should avoid hardcoding
# onnx for deployment for mxnet (not tensorflow)
save_model = (sage_args.save_model == 1)
backend = os.getenv('COACH_BACKEND', 'tensorflow')
if save_model and backend == "mxnet":
args.export_onnx_graph = True
args.no_summary = True
args.num_workers = sage_args.num_workers
args.framework = Frameworks[backend]
args.preset = sage_args.RLCOACH_PRESET
# args.apply_stop_condition = True # uncomment for old coach behaviour
self.hyperparameters = CoachConfigurationList()
if len(unknown) % 2 == 1:
raise ValueError("Odd number of command-line arguments specified. Key without value.")
for i in range(0, len(unknown), 2):
name = unknown[i]
if name.startswith("--"):
name = name[2:]
else:
raise ValueError("Unknown command-line argument %s" % name)
val = unknown[i+1]
self.map_hyperparameter(name, val)
return args
def ctw(args, extraVMarguments=None):
"""run CompileTheWorld"""
defaultCtwopts = '-Inline'
parser = ArgumentParser(prog='mx ctw')
parser.add_argument('--ctwopts', action='store', help='space separated JVMCI options used for CTW compilations (default: --ctwopts="' + defaultCtwopts + '")', default=defaultCtwopts, metavar='<options>')
parser.add_argument('--cp', '--jar', action='store', help='jar or class path denoting classes to compile', metavar='<path>')
args, vmargs = parser.parse_known_args(args)
if args.ctwopts:
# Replace spaces with '#' since -G: options cannot contain spaces
vmargs.append('-G:CompileTheWorldConfig=' + re.sub(r'\s+', '#', args.ctwopts))
if args.cp:
cp = os.path.abspath(args.cp)
else:
cp = join(_jdk.home, 'lib', 'modules', 'bootmodules.jimage')
vmargs.append('-G:CompileTheWorldExcludeMethodFilter=sun.awt.X11.*.*')
# suppress menubar and dock when running on Mac; exclude x11 classes as they may cause vm crashes (on Solaris)
vmargs = ['-Djava.awt.headless=true'] + vmargs
if _vm.jvmciMode == 'disabled':
vmargs += ['-XX:+CompileTheWorld', '-Xbootclasspath/p:' + cp]
else:
if _vm.jvmciMode == 'jit':
vmargs += ['-XX:+BootstrapJVMCI']
vmargs += ['-G:CompileTheWorldClasspath=' + cp, 'com.oracle.graal.hotspot.CompileTheWorld']
run_vm(vmargs + _noneAsEmptyList(extraVMarguments))
class Options:
def __init__(self):
self._init_parser()
def _init_parser(self):
# overrides usage that is by default something like:
# usage: PROG [-h] [--foo [FOO]] bar [bar ...]
usage = './bin/run_project'
self.parser = ArgumentParser(usage=usage)
# inits the argparser with an argument 'example' with
# a default value 'example-value'
self.parser.add_argument('-x',
'--example',
default='example-value', # specifies default value
dest='example', # determines the name of the attribute that parse_args yields
help='An example option') # specifies help message
def parse(self, args=None):
# parse known args, returns a Namespace object
# unknown args are ignored
# Parse known args returns (Namespace_of_known, list_of_unknown)
self.known, self.unknown = self.parser.parse_known_args(args)[:]
if len(self.unknown) != 0:
print '*WARN* Unknown args received: '+repr(self.unknown)
def __init__(self, context,namespace = None):
# it is either "" or the input given at creation of plugin
self.namespace = self._parse_args(context.argv())
super(saverPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('saverPlugin')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'saver.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('saverUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# ---------------------------------------------- #
# ---------------------------------------------- #
# BUTTON TO START EXPERIMENT
self._widget.ButtonSTART_SIM.stateChanged.connect(self.StartSimulatorService)
# Button to Reset Simulator
self._widget.ResetSimulator.clicked.connect(self.ResetSimulator)
# BUTTON TO CONNECT TO QUALISYS
self._widget.Qualisys.stateChanged.connect(self.QualisysConnect)
# BUTTON TO CHANGE ID
self._widget.changeID.clicked.connect(self.changeID)
# Default Value for Id of Quad (as in QUALISYS computer)
self._widget.ID.setValue(13)
def __init__(self, context):
super(utilityPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName("utilityPlugin")
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true", dest="quiet", help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print "arguments: ", args
print "unknowns: ", unknowns
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "utility.ui")
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName("utilityUi")
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (" (%d)" % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self.ID = 0
self.State = QuadPositionDerived()
self.Target = QuadPositionDerived()
self.sub = ""
self.name = ""
self.pwd = os.environ["PWD"]
self._widget.IrisInputBox.insertItems(0, ["iris1", "iris2", "iris3", "iris4", "iris5"])
self._widget.bStart.clicked.connect(self.Start)
self._widget.GravityCancelButton.clicked.connect(self.adjust_gravity_cancel)
self._widget.XBox.setMinimum(-10.0)
self._widget.XBox.setMaximum(10.0)
self._widget.XBox.setSingleStep(0.1)
self._widget.YBox.setMinimum(-10.0)
self._widget.YBox.setMaximum(10.0)
self._widget.YBox.setSingleStep(0.1)
self._widget.ZBox.setMinimum(-10.0)
self._widget.ZBox.setMaximum(10.0)
self._widget.ZBox.setSingleStep(0.1)
self._widget.GravitySpinBox.setMaximum(1800)
self._widget.GravitySpinBox.setMinimum(1200)
self._widget.GravitySpinBox.setSingleStep(10)
self._widget.GravitySpinBox.setValue(1500)
def parse_global_args(arglist):
""" Parse global arguments list. """
usage = "%s [options] command [command_args]" % sys.argv[0]
args = []
while len(arglist) != 0 and arglist[0] not in CMDS:
args.append(arglist[0])
arglist.pop(0)
parser = ArgumentParser(usage=usage)
parser.add_argument("-a", "--hostname", dest="host", default="127.0.0.1",
help="Specify the EmPOWER host; default='127.0.0.1'")
parser.add_argument("-p", "--port", dest="port", default="8888",
help="Specify the EmPOWER web port; default=8888")
parser.add_argument("-u", "--user", dest="user", default="root",
help="EmPOWER admin user; default='root'")
parser.add_argument("-n", "--no-passwd", action="store_true",
dest="no_passwd", default=False,
help="Run empowerctl with no password; default false")
parser.add_argument("-f", "--passwd-file", dest="passwdfile",
default=None, help="Password file; default=none")
parser.add_argument("-t", "--transport", dest="transport", default="http",
help="Specify the transport; default='http'")
(args, _) = parser.parse_known_args(args)
return args, arglist, parser
def main():
parser = ArgumentParser()
parser.add_argument("--dbfile", default="sums.db")
parser.add_argument("--action", default="scan")
parser.add_argument("--trashcan", default="trash.zip")
parser.add_argument("--delete", action="store_true")
parser.add_argument("--loglevel", type=int, default=10)
parser.add_argument("--maxsize", type=int, default=(10*1024**2))
opts,args = parser.parse_known_args()
args = map(lambda x: unicode(x, "utf8"), args)
if opts.delete:
raise Exception("delete is true")
Utils.delete = opts.delete
if opts.loglevel:
logging.getLogger().setLevel(opts.loglevel)
db = Database('sqlite', os.path.abspath(opts.dbfile), create_db=True)
init(db)
Handlers.dispatch(opts.action, opts, args)
pass
def __init__(self, argv, classes, aliases):
parser = ArgumentParser()
self.config = Config()
self.argv = argv
all_arguments = {}
def add_argument(name, *args, **kwargs):
parser.add_argument(name, *args, **kwargs)
all_arguments[name] = kwargs['dest']
for cls in classes:
for name in cls.class_traits(config=True):
dest = cls.__name__ + '.' + name
trait = getattr(cls, name)
nargs = trait._metadata.get('nargs', None)
add_argument('--' + name, type=str, dest=dest, nargs=nargs)
for k, v in aliases.iteritems():
try:
add_argument('--' + k, type=str, dest=v, nargs=None)
except ArgumentError:
pass
known_args, extra_args = parser.parse_known_args(argv)
self.known_args = known_args
self.extra_args = extra_args
if len(extra_args) > 1:
for item in extra_args[1:]:
raise AliasError(item[2:], all_arguments)
def main():
parser = ArgumentParser(add_help=False)
appendIndependentArguments(parser)
args,unknown = parser.parse_known_args()
parser = ArgumentParser(add_help=True,
description = description)
appendIndependentArguments(parser)
if args.manipulator.lower() == 'ln':
parser.add_argument('-l','--axis-list',nargs='+',
type=int, default=[1, 2, 3],
help='List of axis (for use with LN manipulator)')
parser.add_argument('-n','--axis-name',nargs='+',
type=str, default=['x','y','z'],
help='List of axis names (for use with LN manipulator)')
args = parser.parse_args()
# Defining it as a global so that I can close it atexit
global manipulator
if args.manipulator.lower() == 'ln':
manipulator = LNmanipulator(port=args.device_port,
axislist=args.axis_list,
axisname=args.axis_name)
mainApp = QtGui.QApplication(sys.argv)
app = manipulator_control(opts = args)
sys.exit(mainApp.exec_())
def parse_args(self, argv):
"""Custom and check param list.
"""
parser = ArgumentParser(prog="cocos %s" % self.__class__.plugin_name(),
description=self.__class__.brief_description())
parser.add_argument('-c', dest='clean', action="store_true",
help=MultiLanguage.get_string('GEN_LIBS_ARG_CLEAN'))
parser.add_argument('-e', dest='engine_path', help=MultiLanguage.get_string('GEN_LIBS_ARG_ENGINE'))
parser.add_argument('-p', dest='platform', action="append", choices=['ios', 'mac', 'android', 'win32'],
help=MultiLanguage.get_string('GEN_LIBS_ARG_PLATFORM'))
parser.add_argument('-m', "--mode", dest='compile_mode', default='release', choices=['debug', 'release'],
help=MultiLanguage.get_string('GEN_LIBS_ARG_MODE'))
parser.add_argument('--dis-strip', dest='disable_strip', action="store_true",
help=MultiLanguage.get_string('GEN_LIBS_ARG_DISABLE_STRIP'))
group = parser.add_argument_group(MultiLanguage.get_string('GEN_LIBS_GROUP_WIN'))
group.add_argument('--vs', dest='vs_version', type=int, default=None,
help=MultiLanguage.get_string('GEN_LIBS_ARG_VS'))
group = parser.add_argument_group(MultiLanguage.get_string('GEN_LIBS_GROUP_ANDROID'))
group.add_argument("--app-abi", dest="app_abi",
help=MultiLanguage.get_string('GEN_LIBS_ARG_ABI'))
group.add_argument("--ap", dest="android_platform",
help=MultiLanguage.get_string('COMPILE_ARG_AP'))
(args, unknown) = parser.parse_known_args(argv)
self.init(args)
return args
def __init__(self, context):
super(ThrusterControl, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('ThrusterControl')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
self._mainWindow = ThrusterWidget()
self._mainWindow.setWindowTitle(self._mainWindow.windowTitle())
if context.serial_number() > 1:
self._mainWindow.setWindowTitle(self._mainWindow.windowTitle() + (' (%d)' % context.serial_number()))
self._mainWindow.setPalette(context._handler._main_window.palette())
self._mainWindow.setAutoFillBackground(True)
# Add widget to the user interface
context.add_widget(self._mainWindow)
def __init__(self, context):
super(ReconfClientPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('ReconfClientPlugin')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
# Create QWidget
self._widget = tiny_ref_gui.ReconfigureWidget()
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
#parent = QTreeWidgetItem(self._widget.parameterTree)
#parent.setText(0, "Name {}".format(2))
#parent.setText(1, "Type")
#parent.setText(2, "Value")
#parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable | Qt.ItemIsEditable)
context.add_widget(self._widget)
def _cmd_parse(self):
"""Add command options, add options whthin this method."""
blade_cmd_help = 'blade <subcommand> [options...] [targets...]'
arg_parser = ArgumentParser(prog='blade', description=blade_cmd_help)
sub_parser = arg_parser.add_subparsers(dest="command",
help="Available subcommands")
build_parser = sub_parser.add_parser("build",
help="Build specified targets")
run_parser = sub_parser.add_parser("run",
help="Build and runs a single target")
test_parser = sub_parser.add_parser("test",
help="Build the specified targets and runs tests")
clean_parser = sub_parser.add_parser("clean",
help="Remove all Blade-created output")
query_parser = sub_parser.add_parser("query",
help="Execute a dependency graph query")
self._add_build_arguments(build_parser)
self._add_build_arguments(run_parser)
self._add_build_arguments(test_parser)
self._add_run_arguments(run_parser)
self._add_test_arguments(test_parser)
self._add_clean_arguments(clean_parser)
self._add_query_arguments(query_parser)
return arg_parser.parse_known_args()
def __init__(self, context):
super(MyPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyPlugin')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_mypkg'), 'resource', 'MyPlugin.ui')
# Extend the widget with all atrributes and children from UI File
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin(when it's set in _widget).
# This is useful when you open multiple plugins aat once. Also if you open multiple
# instances of your plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' %d' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self._widget.cancelButton.clicked[bool].connect(self._handle_cancel_clicked)
self._widget.okButton.clicked[bool].connect(self._handle_ok_clicked)
def parse_args(mode=True, name=None):
mname = name
if not name:
mname = 'burp-ui'
parser = ArgumentParser(prog=mname)
parser.add_argument('-v', '--verbose', dest='log', help='increase output verbosity (e.g., -vv is more verbose than -v)', action='count')
parser.add_argument('-d', '--debug', dest='debug', help='enable debug mode', action='store_true')
parser.add_argument('-V', '--version', dest='version', help='print version and exit', action='store_true')
parser.add_argument('-c', '--config', dest='config', help='burp-ui configuration file', metavar='<CONFIG>')
parser.add_argument('-l', '--logfile', dest='logfile', help='output logs in defined file', metavar='<FILE>')
parser.add_argument('-i', '--migrations', dest='migrations', help='migrations directory', metavar='<MIGRATIONSDIR>')
parser.add_argument('remaining', nargs=REMAINDER)
if mode:
parser.add_argument('-m', '--mode', dest='mode', help='application mode', metavar='<agent|server|celery|manage|monitor|legacy>')
options, unknown = parser.parse_known_args()
if mode and options.mode and options.mode not in ['celery', 'manage', 'server']:
options = parser.parse_args()
unknown = []
if options.version:
from burpui.desc import __title__, __version__, __release__
ver = '{}: v{}'.format(mname or __title__, __version__)
if options.log:
ver = '{} ({})'.format(ver, __release__)
print(ver)
sys.exit(0)
return options, unknown
def __init__(self, context):
super(Dashboard, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('Dashboard')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet", help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
rospy.sleep(2.)
self._layout = DashboardGrid()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
##ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
##loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._layout.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._layout.setWindowTitle(self._layout.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._layout)
def __init__(self, context):
name = "SimMan"
resource = os.path.join(os.path.dirname(
os.path.realpath(__file__)),
"resource/" + name + ".ui")
GuiT = SimManGui
RosT = SimManROS
super(SimManRqt, self).__init__(context)
self.setObjectName(name)
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print "arguments: ", args
print "unknowns: ", unknowns
# Create QWidget
self._gui = GuiT()
self._ros = RosT()
loadUi(resource, self._gui)
self._ros.setup(self._gui)
self._gui.setup(name + "Rqt", self._ros)
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(" (%d)" % context.serial_number()))
context.add_widget(self._gui)
def main():
""" /// WARNING ///
The ThreatButt API tool embarks on a high speed, turbulent voyage with sudden turns and sharp drops.
This tool employs safety restraints which may restrict certain guests from using due to their mental shape and size.
You must posses the ability to remain in an upright position at all times while laying down.
Persons with the following conditions should not use this tool:
- Heart Condition or Abnormal Blood Pressure
- Back, Neck or Similar Physical Condition
- Expectant Parents
- Motion Sickness or Dizziness
- Media Sensitivity to Strobe Effects
- Claustrophobia
- Recent Surgery or Other Conditions That May Be Aggravated By This Tool
"""
parser = ArgumentParser()
parser.add_argument('-v', '--version', action='version', version='%(prog)s ' + __version__)
parser.add_argument('-i', '--ioc', dest='ioc', default=None,
help='[OPTIONAL] An IoC to attribute.')
parser.add_argument('-m', '--md5', dest='md5', default=None,
help='[OPTIONAL] An MD5 hash.')
parser.add_argument('--maltego', dest='maltego', default=False, action='store_true',
help='[OPTIONAL] Run in Maltego compatibility mode.')
args, _ = parser.parse_known_args()
tb = ThreatButt(args.maltego)
if args.ioc:
tb.clown_strike_ioc(args.ioc)
elif args.md5:
tb.bespoke_md5(args.md5)
else:
parser.print_help()
def __init__(self, context):
super(NodeManager, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('NodeManagerFKIE')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
node_manager_fkie.init_settings()
masteruri = node_manager_fkie.settings().masteruri()
node_manager_fkie.init_globals(masteruri)
# Create QWidget
try:
self._widget = MainWindow()
# self._widget.read_view_history()
except Exception, e:
msgBox = QMessageBox()
msgBox.setText(str(e))
msgBox.exec_()
raise
def parse_arguments():
usage = "python benchrun.py -f <list of test files> -t <list of thread configurations>"
parser = ArgumentParser(description="Performance testing script framework thing.", usage=usage)
parser.add_argument('-f', '--testfiles', dest='testfiles', nargs="+",
help='Provide a list of js test files to run',
default=None)
parser.add_argument('-t', '--threads', dest='threads', nargs="+",
help='Specify which thread configuration to use',
type=int, default=[1, 2, 4, 8, 12, 16])
parser.add_argument('-m', '--multidb', dest='multidb',
help='Specify how many databases the test should use',
type=int, default=1)
parser.add_argument('-l', '--label', dest='reportlabel',
help='Specify the label for the report stats saved to bench_results db',
default='')
parser.add_argument('--rhost', '--reporthost', dest='reporthost',
help='Host name of the mongod where the results will be saved',
default='localhost')
parser.add_argument('--rport', '--reportport', dest='reportport',
help='Port of the mongod where the results will be saved',
default='27017')
parser.add_argument('-s', '--shell', dest='shellpath',
help="Path to the mongo shell executable to use.",
default='mongo')
return parser.parse_known_args()
def __init__(self, context):
super(TriangleGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('TriangleGUI')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
self._toolbar = QToolBar()
self._toolbar.addWidget(QLabel('Triangle'))
# Create a container widget and give it a layout
self._container = QWidget()
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._layout.addWidget(self._toolbar)
# Add a button for killing nodes
self._go_button = QPushButton('Go')
self._go_button.clicked.connect(self._go)
self._layout.addWidget(self._go_button)
self._clear_button = QPushButton('Clear')
self._clear_button.clicked.connect(self._clear)
self._layout.addWidget(self._clear_button)
# self._step_run_button.setStyleSheet('QPushButton {color: black}')
context.add_widget(self._container)
def __init__(self, context):
super(ToolBar, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('EnableAxis')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
self._toolbar = QToolBar()
self._palette = Palette()
self._enableAxisWidget = EnableAxisWidget()
context._handler._main_window.setPalette(self._palette.palette())
self._batteryWidget = BatteryWidget()
# Add widget to the user interface
self._toolbar.addWidget(self._enableAxisWidget)
self._toolbar.addWidget(self._batteryWidget)
context.add_toolbar(self._toolbar)
def __init__(self, context):
super(CalibrationControl, self).__init__(context)
self.setObjectName('CalibrationControl')
# Argument parsing
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('industrial_calibration_gui'), 'resource', 'calibration_control.ui')
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('calibration_control_Ui')
# Custom code begins here
self._widget.cal_button.clicked[bool].connect(self.__handle_cal_clicked)
self.cal_service = rospy.ServiceProxy('calibration_service', Empty)
# Add widget to the user interface
context.add_widget(self._widget)
def _launch_mpisub(self, args, site_dir):
# extract the mpirun run argument
parser = ArgumentParser(add_help=False)
# these values are ignored. This is a hack to filter out unused argv.
parser.add_argument("--single", default=False, action='store_true')
parser.add_argument("--mpirun", default=None)
parser.add_argument("--xterm", default=False, action='store_true')
_args, additional = parser.parse_known_args()
# now call with mpirun
mpirun = args.mpirun.split()
if args.xterm:
mpirun.extend(['xterm', '-hold', '-e'])
cmdargs = [sys.executable, '-u', sys.argv[0], '--mpisub']
if site_dir is not None:
# mpi subs will use system version of package
cmdargs.extend(['--mpisub-site-dir=' + site_dir])
# workaround the strict openmpi oversubscribe policy
# the parameter is found from
# https://github.com/open-mpi/ompi/blob/ba47f738871ff06b8e8f34b8e18282b9fe479586/orte/mca/rmaps/base/rmaps_base_frame.c#L169
# see the faq:
# https://www.open-mpi.org/faq/?category=running#oversubscribing
os.environ['OMPI_MCA_rmaps_base_oversubscribe'] = '1'
os.execvp(mpirun[0], mpirun + cmdargs + additional)
# if we are here os.execvp has failed; bail
sys.exit(1)
def main():
parser = ArgumentParser(
description='compare the results of two benchmarks')
parser.add_argument(
'test1', metavar='test1', type=str, nargs=1,
help='A benchmark executable or JSON output file')
parser.add_argument(
'test2', metavar='test2', type=str, nargs=1,
help='A benchmark executable or JSON output file')
# FIXME this is a dummy argument which will never actually match
# any --benchmark flags but it helps generate a better usage message
parser.add_argument(
'benchmark_options', metavar='benchmark_option', nargs='*',
help='Arguments to pass when running benchmark executables'
)
args, unknown_args = parser.parse_known_args()
# Parse the command line flags
test1 = args.test1[0]
test2 = args.test2[0]
if args.benchmark_options:
print("Unrecognized positional argument arguments: '%s'"
% args.benchmark_options)
exit(1)
benchmark_options = unknown_args
check_inputs(test1, test2, benchmark_options)
# Run the benchmarks and report the results
json1 = gbench.util.run_or_load_benchmark(test1, benchmark_options)
json2 = gbench.util.run_or_load_benchmark(test2, benchmark_options)
output_lines = gbench.report.generate_difference_report(json1, json2)
print 'Comparing %s to %s' % (test1, test2)
for ln in output_lines:
print(ln)
def __init__(self, argv):
"""
Initialize Eddy.
:type argv: list
"""
super().__init__(argv)
parser = ArgumentParser()
parser.add_argument('--nosplash', dest='nosplash', action='store_true')
parser.add_argument('--tests', dest='tests', action='store_true')
options, args = parser.parse_known_args(args=argv)
self.inSocket = None
self.inStream = None
self.outSocket = QLocalSocket()
self.outSocket.connectToServer(APPID)
self.outStream = None
self.isRunning = self.outSocket.waitForConnected()
self.mainwindow = None
self.pendingOpen = []
self.server = None
# We do not initialize a new instance of Eddy if there is a process running
# and we are not executing the tests suite: we'll create a socket instead so we can
# exchange messages between the 2 processes (this one and the already running one).
if self.isRunning and not options.tests:
self.outStream = QTextStream(self.outSocket)
self.outStream.setCodec('UTF-8')
else:
self.server = QLocalServer()
self.server.listen(APPID)
self.outSocket = None
self.outStream = None
connect(self.server.newConnection, self.newConnection)
connect(self.messageReceived, self.readMessage)
############################################################################################################
# #
# PERFORM EDDY INITIALIZATION #
# #
############################################################################################################
# Draw the splashscreen.
self.splashscreen = None
if not options.nosplash:
self.splashscreen = SplashScreen(min_splash_time=4)
self.splashscreen.show()
# Setup layout.
self.setStyle(Clean('Fusion'))
with open(expandPath('@eddy/ui/clean.qss')) as sheet:
self.setStyleSheet(sheet.read())
# Create the main window.
self.mainwindow = MainWindow()
# Close the splashscreen.
if self.splashscreen:
self.splashscreen.wait(self.splashscreen.remaining)
self.splashscreen.close()
# Display the mainwindow.
self.mainwindow.show()
if Platform.identify() is Platform.Darwin:
# On MacOS files being opened are handled as a QFileOpenEvent but since we don't
# have a Main Window initialized we store them locally and we open them here.
for filepath in self.pendingOpen:
self.openFile(filepath)
self.pendingOpen = []
else:
# Perform document opening if files have been added to sys.argv. This is not
# executed on Mac OS since this is already handled as a QFileOpenEvent instance.
for filepath in argv:
self.openFile(filepath)
"--end_learning_rate",
default=2e-6,
type=float,
help="The ending learning rate when `--use_scheduler` is poly.",
)
parser.add_argument("--weight_decay", default=1e-2, type=float)
parser.add_argument(
"-l",
"--log",
dest="logLevel",
default="INFO",
choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
help="Set the logging level (default: 'Info').",
)
main_args = parser.parse_known_args()
if main_args[0].mode == "abstractive":
parser = AbstractiveSummarizer.add_model_specific_args(parser)
else:
parser = ExtractiveSummarizer.add_model_specific_args(parser)
main_args = parser.parse_args()
# Setup logging config
logging.basicConfig(
format="%(asctime)s|%(name)s|%(levelname)s> %(message)s",
level=logging.getLevelName(main_args.logLevel),
)
# Set the `nlp` logging verbosity since its default is not INFO.
def main(spider_name,
thread_number=None,
slave=False,
settings='settings',
network_logs=False,
disable_proxy=False,
ignore_lock=False,
*args,
**kwargs):
default_logging(propagate_network_logger=network_logs)
root_config = build_root_config(settings)
spider_class = load_spider_class(root_config, spider_name)
spider_config = build_spider_config(spider_class, root_config)
spider_args = None
if hasattr(spider_class, 'setup_arg_parser'):
parser = ArgumentParser()
spider_class.setup_arg_parser(parser)
opts, trash = parser.parse_known_args()
spider_args = vars(opts)
if thread_number is None:
thread_number = \
int(spider_config.get('thread_number',
deprecated_key='GRAB_THREAD_NUMBER'))
stat_task_object = kwargs.get('stat_task_object', None)
bot = spider_class(
thread_number=thread_number,
slave=slave,
config=spider_config,
network_try_limit=int(
spider_config.get('network_try_limit',
deprecated_key='GRAB_NETWORK_TRY_LIMIT')),
task_try_limit=int(
spider_config.get('task_try_limit',
deprecated_key='GRAB_TASK_TRY_LIMIT')),
args=spider_args,
)
opt_queue = spider_config.get('queue', deprecated_key='GRAB_QUEUE')
if opt_queue:
bot.setup_queue(**opt_queue)
opt_cache = spider_config.get('cache', deprecated_key='GRAB_CACHE')
if opt_cache:
bot.setup_cache(**opt_cache)
opt_proxy_list = spider_config.get('proxy_list',
deprecated_key='GRAB_PROXY_LIST')
if opt_proxy_list:
if disable_proxy:
logger.debug('Proxy servers disabled via command line')
else:
bot.load_proxylist(**opt_proxy_list)
opt_ifaces = spider_config.get('command_interfaces',
deprecated_key='GRAB_COMMAND_INTERFACES')
if opt_ifaces:
for iface_config in opt_ifaces:
bot.controller.add_interface(**iface_config)
# Dirty hack
# FIXIT: REMOVE
bot.dump_spider_stats = kwargs.get('dump_spider_stats')
bot.stats_object = kwargs.get('stats_object')
try:
bot.run()
except KeyboardInterrupt:
pass
stats = bot.render_stats(timing=spider_config.get(
'display_timing', deprecated_key='GRAB_DISPLAY_TIMING'))
if spider_config.get('display_stats', deprecated_key='GRAB_DISPLAY_STATS'):
logger.debug(stats)
pid = os.getpid()
logger.debug('Spider pid is %d' % pid)
if spider_config.get('save_report', deprecated_key='GRAB_SAVE_REPORT'):
for subdir in (str(pid), 'last'):
dir_ = 'var/%s' % subdir
if not os.path.exists(dir_):
os.mkdir(dir_)
else:
clear_directory(dir_)
for key, lst in bot.items.iteritems():
fname_key = key.replace('-', '_')
bot.save_list(key, '%s/%s.txt' % (dir_, fname_key))
with open('%s/report.txt' % dir_, 'wb') as out:
out.write(stats)
return {
'spider_stats': bot.render_stats(timing=False),
'spider_timing': bot.render_timing(),
}
def parse_args_and_arch(
parser: argparse.ArgumentParser,
input_args: List[str] = None,
parse_known: bool = False,
suppress_defaults: bool = False,
modify_parser: Optional[Callable[[argparse.ArgumentParser], None]] = None,
):
"""
Args:
parser (ArgumentParser): the parser
input_args (List[str]): strings to parse, defaults to sys.argv
parse_known (bool): only parse known arguments, similar to
`ArgumentParser.parse_known_args`
suppress_defaults (bool): parse while ignoring all default values
modify_parser (Optional[Callable[[ArgumentParser], None]]):
function to modify the parser, e.g., to set default values
"""
if suppress_defaults:
# Parse args without any default values. This requires us to parse
# twice, once to identify all the necessary task/model args, and a second
# time with all defaults set to None.
args = parse_args_and_arch(
parser,
input_args=input_args,
parse_known=parse_known,
suppress_defaults=False,
)
suppressed_parser = argparse.ArgumentParser(add_help=False,
parents=[parser])
suppressed_parser.set_defaults(
**{k: None
for k, v in vars(args).items()})
args = suppressed_parser.parse_args(input_args)
return argparse.Namespace(
**{k: v
for k, v in vars(args).items() if v is not None})
from fairseq.models import ARCH_MODEL_REGISTRY, ARCH_CONFIG_REGISTRY
# Before creating the true parser, we need to import optional user module
# in order to eagerly import custom tasks, optimizers, architectures, etc.
usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
usr_parser.add_argument("--user-dir", default=None)
usr_args, _ = usr_parser.parse_known_args(input_args)
utils.import_user_module(usr_args)
if modify_parser is not None:
modify_parser(parser)
# The parser doesn't know about model/criterion/optimizer-specific args, so
# we parse twice. First we parse the model/criterion/optimizer, then we
# parse a second time after adding the *-specific arguments.
# If input_args is given, we will parse those args instead of sys.argv.
args, _ = parser.parse_known_args(input_args)
# Add model-specific args to parser.
if hasattr(args, "arch"):
model_specific_group = parser.add_argument_group(
"Model-specific configuration",
# Only include attributes which are explicitly given as command-line
# arguments or which have default values.
argument_default=argparse.SUPPRESS,
)
ARCH_MODEL_REGISTRY[args.arch].add_args(model_specific_group)
# Add *-specific args to parser.
from fairseq.registry import REGISTRIES
for registry_name, REGISTRY in REGISTRIES.items():
choice = getattr(args, registry_name, None)
if choice is not None:
cls = REGISTRY["registry"][choice]
if hasattr(cls, "add_args"):
cls.add_args(parser)
if hasattr(args, "task"):
from fairseq.tasks import TASK_REGISTRY
TASK_REGISTRY[args.task].add_args(parser)
if getattr(args, "use_bmuf", False):
# hack to support extra args for block distributed data parallelism
from fairseq.optim.bmuf import FairseqBMUF
FairseqBMUF.add_args(parser)
# Modify the parser a second time, since defaults may have been reset
if modify_parser is not None:
modify_parser(parser)
# Parse a second time.
if parse_known:
args, extra = parser.parse_known_args(input_args)
else:
args = parser.parse_args(input_args)
extra = None
# Post-process args.
if hasattr(args,
"max_sentences_valid") and args.max_sentences_valid is None:
args.max_sentences_valid = args.max_sentences
if hasattr(args, "max_tokens_valid") and args.max_tokens_valid is None:
args.max_tokens_valid = args.max_tokens
if getattr(args, "memory_efficient_fp16", False):
args.fp16 = True
if getattr(args, "memory_efficient_bf16", False):
args.bf16 = True
args.tpu = getattr(args, "tpu", False)
args.bf16 = getattr(args, "bf16", False)
if args.bf16:
args.tpu = True
if args.tpu and args.fp16:
raise ValueError("Cannot combine --fp16 and --tpu, use --bf16 on TPUs")
if getattr(args, "seed", None) is None:
args.seed = 1 # default seed for training
args.no_seed_provided = True
else:
args.no_seed_provided = False
# Apply architecture configuration.
if hasattr(args, "arch"):
ARCH_CONFIG_REGISTRY[args.arch](args)
if parse_known:
return args, extra
else:
return args
def main():
prog = "python statistics.py WhatIsThis <manyPickles> WhatIsThis <manyPickles> [WhatIsThis <manyPickles>]"
description = "Return some statistical information"
parser = ArgumentParser(description=description, prog=prog)
parser.add_argument("-p",
"--space",
dest="spaceFile",
help="Where is the space.py located?")
parser.add_argument("-m",
"--maxEvals",
dest="maxEvals",
help="How many evaluations?")
parser.add_argument("-s",
"--seed",
default="1",
dest="seed",
type=int,
help="Seed for the TPE algorithm")
parser.add_argument(
"-r",
"--restore",
action="store_true",
dest="restore",
help="When this flag is set state.pkl is restored in " +
"the current working directory")
parser.add_argument("--random",
default=False,
action="store_true",
dest="random",
help="Use a random search")
parser.add_argument("--cwd",
help="Change the working directory before "
"optimizing.")
args, unknown = parser.parse_known_args()
if args.cwd:
os.chdir(args.cwd)
if not os.path.exists(args.spaceFile):
logger.critical("Search space not found: %s" % args.spaceFile)
sys.exit(1)
# First remove ".py"
space, ext = os.path.splitext(os.path.basename(args.spaceFile))
# Then load dict searchSpace and out function cv.py
sys.path.append("./")
sys.path.append("")
module = import_module(space)
search_space = module.space
fn = cv.main # doForTPE
if args.random:
# We use a random search
tpe_with_seed = partial(hyperopt.tpe.rand.suggest, seed=int(args.seed))
logger.info("Using Random Search")
else:
tpe_with_seed = partial(hyperopt.tpe.suggest, seed=int(args.seed))
# Now run TPE, emulate fmin.fmin()
state_filename = "state.pkl"
if args.restore:
# We do not need to care about the state of the trials object since it
# is only serialized in a synchronized state, there will never be a save
# with a running experiment
fh = open(state_filename)
tmp_dict = cPickle.load(fh)
domain = tmp_dict['domain']
trials = tmp_dict['trials']
print trials.__dict__
else:
domain = hyperopt.Domain(fn, search_space, rseed=int(args.seed))
print(search_space)
trials = hyperopt.Trials()
fh = open(state_filename, "w")
# By this we probably loose the seed; not too critical for a restart
cPickle.dump({"trials": trials, "domain": domain}, fh)
fh.close()
for i in range(int(args.maxEvals) + 1):
# in exhaust, the number of evaluations is max_evals - num_done
rval = hyperopt.FMinIter(tpe_with_seed, domain, trials, max_evals=i)
rval.exhaust()
fh = open(state_filename, "w")
cPickle.dump({"trials": trials, "domain": domain}, fh)
fh.close()
best = trials.argmin
print "Best Value found for params:", best
def parse_known_args_and_warn(
parser: argparse.ArgumentParser,
other_args: List[str],
export_allowed: int = NO_EXPORT,
raw: bool = False,
limit: int = 0,
):
"""Parses list of arguments into the supplied parser
Parameters
----------
parser: argparse.ArgumentParser
Parser with predefined arguments
other_args: List[str]
List of arguments to parse
export_allowed: int
Choose from NO_EXPORT, EXPORT_ONLY_RAW_DATA_ALLOWED,
EXPORT_ONLY_FIGURES_ALLOWED and EXPORT_BOTH_RAW_DATA_AND_FIGURES
raw: bool
Add the --raw flag
limit: int
Add a --limit flag with this number default
Returns
-------
ns_parser:
Namespace with parsed arguments
"""
parser.add_argument(
"-h", "--help", action="store_true", help="show this help message"
)
if export_allowed > NO_EXPORT:
choices_export = []
help_export = "Does not export!"
if export_allowed == EXPORT_ONLY_RAW_DATA_ALLOWED:
choices_export = ["csv", "json", "xlsx"]
help_export = "Export raw data into csv, json, xlsx"
elif export_allowed == EXPORT_ONLY_FIGURES_ALLOWED:
choices_export = ["png", "jpg", "pdf", "svg"]
help_export = "Export figure into png, jpg, pdf, svg "
else:
choices_export = ["csv", "json", "xlsx", "png", "jpg", "pdf", "svg"]
help_export = "Export raw data into csv, json, xlsx and figure into png, jpg, pdf, svg "
parser.add_argument(
"--export",
choices=choices_export,
default="",
type=str,
dest="export",
help=help_export,
)
if raw:
parser.add_argument(
"--raw",
dest="raw",
action="store_true",
default=False,
help="Flag to display raw data",
)
if limit > 0:
parser.add_argument(
"-l",
"--limit",
dest="limit",
default=limit,
help="Number of entries to show in data.",
type=int,
)
if gtff.USE_CLEAR_AFTER_CMD:
system_clear()
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(other_args)
except SystemExit:
# In case the command has required argument that isn't specified
console.print("")
return None
if ns_parser.help:
txt_help = parser.format_help()
console.print(f"[help]{txt_help}[/help]")
return None
if l_unknown_args:
console.print(f"The following args couldn't be interpreted: {l_unknown_args}")
return ns_parser
def run(argv):
"""Run a simulation or analysis."""
usage = "%(prog)s run [options] [arg1, ...] [param=value, ...]"
description = dedent("""\
The list of arguments will be passed on to the simulation/analysis script.
It should normally contain at least the name of a parameter file, but
can also contain input files, flags, etc.
If the parameter file should be in a format that Sumatra understands (see
documentation), then the parameters will be stored to allow future
searching, comparison, etc. of records.
For convenience, it is possible to specify a file with default parameters
and then specify those parameters that are different from the default values
on the command line with any number of param=value pairs (note no space
around the equals sign).""")
parser = ArgumentParser(usage=usage, description=description)
parser.add_argument(
'-v',
'--version',
metavar='REV',
help=
"use version REV of the code (if this is not the same as the working copy, it will be checked out of the repository). If this option is not specified, the most recent version in the repository will be used. If there are changes in the working copy, the user will be prompted to commit them first"
)
parser.add_argument(
'-l',
'--label',
help=
"specify a label for the experiment. If no label is specified, one will be generated automatically."
)
parser.add_argument(
'-r',
'--reason',
help="explain the reason for running this simulation/analysis.")
parser.add_argument(
'-e',
'--executable',
metavar='PATH',
help=
"Use this executable for this run. If not specified, the project's default executable will be used."
)
parser.add_argument(
'-m',
'--main',
help=
"the name of the script that would be supplied on the command line if running the simulation/analysis normally, e.g. init.hoc. If not specified, the project's default will be used."
)
parser.add_argument(
'-n',
'--num_processes',
metavar='N',
type=int,
help=
"run a distributed computation on N processes using MPI. If this option is not used, or if N=0, a normal, serial simulation/analysis is run."
)
parser.add_argument('-t',
'--tag',
help="tag you want to add to the project")
parser.add_argument('-D',
'--debug',
action='store_true',
help="print debugging information.")
parser.add_argument(
'-i',
'--stdin',
help=
"specify the name of a file that should be connected to standard input."
)
parser.add_argument(
'-o',
'--stdout',
help=
"specify the name of a file that should be connected to standard output."
)
args, user_args = parser.parse_known_args(argv)
user_args = [str(arg) for arg in user_args] # unifying types for Py2/Py3
if args.debug:
logger.setLevel(logging.DEBUG)
project = load_project()
parameters, input_data, script_args = parse_arguments(
user_args, project.input_datastore, args.stdin, args.stdout,
project.allow_command_line_parameters)
if len(parameters) == 0:
parameters = {}
elif len(parameters) == 1:
parameters = parameters[0]
else:
parser.error("Only a single parameter file allowed.") # for now
if args.executable:
executable_path, executable_options = parse_executable_str(
args.executable)
executable = get_executable(path=executable_path)
executable.options = executable_options
elif args.main:
executable = get_executable(
script_file=args.main
) # should we take the options from project.default_executable, if they match?
else:
executable = 'default'
if args.num_processes:
if hasattr(project.default_launch_mode, 'n'):
project.default_launch_mode.n = args.num_processes
else:
parser.error(
"Your current launch mode does not support using multiple processes."
)
reason = args.reason or ''
if reason:
reason = reason.strip('\'"')
label = args.label
try:
run_label = project.launch(parameters,
input_data,
script_args,
label=label,
reason=reason,
executable=executable,
main_file=args.main or 'default',
version=args.version or 'current')
except (UncommittedModificationsError, MissingInformationError) as err:
print(err)
sys.exit(1)
if args.tag:
project.add_tag(run_label, args.tag)
if os.path.exists('.smt'):
with open('.smt/labels', 'w') as f:
f.write('\n'.join(project.get_labels()))
def parse_args(self):
parser = ArgumentParser(prog="dstack run gradio")
if not self.workflow.data.get("workflow_name"):
parser.add_argument("file", metavar="FILE", type=str)
parser.add_argument("-r", "--requirements", type=str, nargs="?")
parser.add_argument('-e', '--env', action='append', nargs="?")
parser.add_argument('-a', '--artifact', action='append', nargs="?")
# TODO: Support depends-on
parser.add_argument("--working-dir", type=str, nargs="?")
# parser.add_argument('--depends-on', action='append', nargs="?")
parser.add_argument("--cpu", type=int, nargs="?")
parser.add_argument("--memory", type=str, nargs="?")
parser.add_argument("--gpu", type=int, nargs="?")
parser.add_argument("--gpu-name", type=str, nargs="?")
parser.add_argument("--gpu-memory", type=str, nargs="?")
parser.add_argument("--shm-size", type=str, nargs="?")
if not self.workflow.data.get("workflow_name"):
parser.add_argument("args",
metavar="ARGS",
nargs=argparse.ZERO_OR_MORE)
args, unknown = parser.parse_known_args(self.provider_args)
args.unknown = unknown
if not self.workflow.data.get("workflow_name"):
self.workflow.data["file"] = args.file
_args = args.unknown + args.args
if _args:
self.workflow.data["args"] = _args
if args.requirements:
self.workflow.data["requirements"] = args.requirements
if args.artifact:
self.workflow.data["artifacts"] = args.artifact
if args.working_dir:
self.workflow.data["working_dir"] = args.working_dir
if args.env:
environment = self.workflow.data.get("environment") or {}
for e in args.env:
if "=" in e:
tokens = e.split("=", maxsplit=1)
environment[tokens[0]] = tokens[1]
else:
environment[e] = ""
self.workflow.data["environment"] = environment
if args.cpu or args.memory or args.gpu or args.gpu_name or args.gpu_memory or args.shm_size:
resources = self.workflow.data["resources"] or {}
self.workflow.data["resources"] = resources
if args.cpu:
resources["cpu"] = args.cpu
if args.memory:
resources["memory"] = args.memory
if args.gpu or args.gpu_name or args.gpu_memory:
gpu = self.workflow.data["resources"].get(
"gpu") or {} if self.workflow.data.get(
"resources") else {}
if type(gpu) is int:
gpu = {"count": gpu}
resources["gpu"] = gpu
if args.gpu:
gpu["count"] = args.gpu
if args.gpu_memory:
gpu["memory"] = args.gpu_memory
if args.gpu_name:
gpu["name"] = args.gpu_name
if args.shm_size:
resources["shm_size"] = args.shm_size
default=False,
help="Overwrite existing output? Default is to append.")
parser.add_argument("--parameters",
default=None,
action="store",
help="Select specific parameter set?")
parser.add_argument("--help", action="store_true", help="Show help")
parser.add_argument("--degree",
action="store",
default=1,
type=int,
help="degree of problem")
args, _ = parser.parse_known_args()
if args.help:
help = parser.format_help()
PETSc.Sys.Print("%s\n" % help)
problem_cls = module.Problem
if args.parameters is not None:
if args.parameters not in problem_cls.parameter_names:
raise ValueError("Unrecognised parameter '%s', not in %s",
args.parameters, problem_cls.parameter_names)
parameter_names = [args.parameters]
else:
parameter_names = problem_cls.parameter_names
def check_iargs_parser(iargs):
"""[For wrapping-up SPARK] Defines the possible arguments of the program, generates help
and usage messages, and issues errors in case of invalid arguments.
"""
parser = ArgumentParser(prog='spark.py',
description=dedent('''\
SParsity-based Analysis of Reliable K-hubness (SPARK) for brain fMRI functional
connectivity
____________________________________________________________________________________
8b d8 88 88 88 888888 88 888888 88 88 88b 88 88 dP 88 8b d8
88b d88 88 88 88 88 88 88__ 88 88 88Yb88 88odP 88 88b d88
88YbdP88 Y8 8P 88 .o 88 88 88"" Y8 8P 88 Y88 88"Yb 88 88YbdP88
88 YY 88 `YbodP' 88ood8 88 88 88 `YbodP' 88 Y8 88 Yb 88 88 YY 88
------------------------------------------------------------------------------
Multimodal Functional Imaging Laboratory
____________________________________________________________________________________
'''),
add_help=False,
formatter_class=RawTextHelpFormatter)
# Required
required = parser.add_argument_group(title=' REQUIRED arguments',
description=dedent('''\
__________________________________________________________________________________
'''))
required.add_argument(
'--WRAP-UP',
action='store_true',
required=True,
help='\n____________________________________________________________')
required.add_argument('--fmri',
nargs=1,
type=str,
required=True,
help=dedent('''\
Path (absolute or relative) to the fMRI data to analyze.
Notes:
- This file should be a valid fMRI file of a BIDS dataset.
- The filename will be used to name the outputs, for
example: 'kmap_sub-01_task-rest_bold.mat'.
(type: %(type)s)
____________________________________________________________
'''),
metavar='XXX',
dest='fmri')
required.add_argument('--out-dir',
nargs=1,
type=str,
required=True,
help=dedent('''\
Path (absolute or relative) to the output directory (old
files might get replaced).
This directory should have been previously populated with
--SETUP and --RUN and at least contain the pipeline '.opt'
file corresponding to the input --fmri.
(type: %(type)s)
____________________________________________________________
'''),
metavar=('XXX'),
dest='out_dir')
# Optional
optional = parser.add_argument_group(title=' OPTIONAL arguments',
description=dedent('''\
__________________________________________________________________________________
'''))
optional.add_argument('-h',
'--help',
action='help',
help=dedent('''\
Shows this help message and exits.
____________________________________________________________
'''))
optional.add_argument('--move-outputs',
action='store_true',
help=dedent('''\
If set, all outputs for this analysis will be moved to the
specified output directory --out-dir.
This flag is useful to merge in a single directory the
results of different analyses where the input fMRI were
different.
(default: %(default)s)
____________________________________________________________
'''),
dest='move_outputs')
optional.add_argument('-v',
'--verbose',
action='store_true',
help=dedent('''\
If set, the program will provide some additional details.
(default: %(default)s)
____________________________________________________________
'''),
dest='verbose')
oargs = vars(parser.parse_known_args(iargs)[0])
# Hack: when (nargs=1) a list should not be returned
for k in ['fmri', 'out_dir', 'move_outputs', 'verbose']:
if type(oargs[k]) is list:
oargs[k] = oargs[k][0]
return oargs
def pre_parse(args):
"""
Pre-parse path to input file (or some general options).
"""
if not args:
args = ['--help']
parser = ArgumentParser(
add_help=False,
usage='{0:s} CONFIGFILE --help'.format(basename(__file__)),
description=
'Command line interface for NoTeX functionality.\n\nCommands provided by extensions will become visible if you provide an input file!',
epilog=
'Provide an input file to load all commands provided by it\'s extensions.'
)
parser.add_argument(
dest='input',
nargs='?',
type=str,
default=SUPPRESS,
help='The main input file (you can also use --input PATH).')
parser.add_argument('--input', dest='input', type=str, help=SUPPRESS)
parser.add_argument(
'--only',
dest='only',
type=str,
help=
'A regular expression, only includes and renders with matching paths will be compiled.'
)
parser.add_argument('-v',
'--verbose',
dest='verbosity',
action='count',
default=0,
help='Show more information (can be stacked, -vv).')
parser.add_argument('--version',
dest='show_version',
action='store_true',
help='Show version information and exit.')
parser.add_argument('-h',
'--help',
dest='show_help',
action='store_true',
help='Show this help and exit.')
opts, rest = parser.parse_known_args(args)
# this is important, without it <resource> doesn't work if it and resource are both relative
opts.input = realpath(opts.input)
if opts.show_help:
parser.print_help()
exit()
if opts.show_version:
try:
version = get_distribution('notex').version #todo package name
except DistributionNotFound as err:
stderr.write(
'Unable to obtain version through PyPi. Reason: {0:s}\n'.
format(str(err)))
else:
stdout.write('{0:}\n'.format(version))
exit()
opts.verbosity += 1
return opts, rest
from argparse import ArgumentParser
import tibia_terminator.main as start
if __name__ == "__main__":
parser = ArgumentParser(description='Main Tibia Terminator Entry-Point')
subparsers = parser.add_subparsers(title="Tibia Terminator Commands",
dest="command",
required=True)
run_terminator_parser = subparsers.add_parser(
"start", help="Run the Tibia Terminator")
known, other_args = parser.parse_known_args()
if known.command == "start":
main_parser = start.build_parser()
start.main(main_parser.parse_args(other_args))
default=8080,
action='store',
help='port number')
parser.add_argument('-r',
'--rover',
dest='roverMode',
default=False,
action='store_true',
help='rover mode, to access motes connected on rovers')
webapp = None
if __name__ == "__main__":
parser = ArgumentParser()
_addParserArgs(parser)
argspace = parser.parse_known_args()[0]
# log
log.info('Initializing OpenVisualizerWeb with options: \n\t{0}'.format(
'\n '.join([
'host = {0}'.format(argspace.host),
'port = {0}'.format(argspace.port)
])))
#===== start the app
app = openVisualizerApp.main(parser, argspace.roverMode)
#===== add a web interface
websrv = bottle.Bottle()
webapp = OpenVisualizerWeb(app, websrv, argspace.roverMode)
import sys
import traceback
from argparse import ArgumentParser
from lib.utils import save_stderr, restore_stderr
from lib import extensions
parser = ArgumentParser()
parser.add_argument("--extension")
my_args, remaining_args = parser.parse_known_args()
extension_name = my_args.extension
# example: foo_bar_baz -> FooBarBaz
extension_class_name = extension_name.title().replace("_", "")
extension_class = getattr(extensions, extension_class_name)
extension = extension_class()
exception = None
save_stderr()
try:
extension.affect(args=remaining_args)
except (SystemExit, KeyboardInterrupt):
raise
except Exception:
exception = traceback.format_exc()
finally:
restore_stderr()
def main():
"""
Run the muddery main program.
"""
# set up argument parser
parser = ArgumentParser(description=configs.CMDLINE_HELP,
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument(
'--init',
nargs='+',
action='store',
dest="init",
metavar="<gamename> [template name]",
help=
"creates a new gamedir 'name' at current location (from optional template)."
)
parser.add_argument(
'--log',
'-l',
action='store_true',
dest='tail_log',
default=False,
help="tail the portal and server logfiles and print to stdout")
parser.add_argument('-v',
'--version',
action='store_true',
dest='show_version',
default=False,
help="show version info")
parser.add_argument(
'--upgrade',
nargs='?',
const='',
dest='upgrade',
metavar="[template]",
help="Upgrade a game directory 'game_name' to the latest version.")
parser.add_argument('--loaddata',
action='store_true',
dest='loaddata',
default=False,
help="Load local data from the worlddata folder.")
parser.add_argument('--sysdata',
action='store_true',
dest='sysdata',
default=False,
help="Load system default data.")
parser.add_argument('--migrate',
action='store_true',
dest='migrate',
default=False,
help="Migrate databases to new version.")
parser.add_argument(
'--port',
'-p',
nargs=1,
action='store',
dest='port',
metavar="<N>",
help=
"Set game's network ports when init the game, recommend to use ports above 10000."
)
parser.add_argument("operation",
nargs='?',
default="noop",
help=configs.ARG_OPTIONS)
parser.epilog = (
"Common Django-admin commands are shell, dbshell, test and migrate.\n"
"See the Django documentation for more management commands.")
args, unknown_args = parser.parse_known_args()
# handle arguments
option = args.operation
# make sure we have everything
check_main_dependencies()
from muddery.launcher import manager
if not args:
# show help pane
manager.print_help()
sys.exit()
elif args.init:
# initialization of game directory
game_name = args.init[0]
template = None
if len(args.init) > 1:
template = args.init[1]
port = None
if args.port:
try:
port = int(args.port[0])
except:
print("Port must be a number.")
sys.exit(-1)
try:
manager.init_game(game_name, template, port)
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
elif args.upgrade is not None:
template = None
if args.upgrade:
template = args.upgrade
try:
manager.upgrade_game(template)
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
elif args.loaddata:
try:
manager.load_game_data()
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
elif args.sysdata:
try:
manager.load_system_data()
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
elif args.migrate:
try:
manager.migrate_database()
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
if args.show_version:
# show the version info
manager.show_version(option == "help")
sys.exit()
if option != "noop":
try:
manager.run_evennia(option)
except Exception as e:
print(e)
sys.exit(-1)
sys.exit()
else:
# no input; print muddery info
manager.print_about()
sys.exit()
def main():
from argparse import ArgumentParser, RawDescriptionHelpFormatter
VERSION = None
if "--version" in sys.argv:
# We cannot import sympy before this is run, because flags like -C and
# -t set environment variables that must be set before SymPy is
# imported. The only thing we need to import it for is to get the
# version, which only matters with the --version flag.
import sympy
VERSION = sympy.__version__
usage = "isympy [options] -- [ipython options]"
parser = ArgumentParser(
usage=usage,
description=__doc__,
formatter_class=RawDescriptionHelpFormatter,
)
parser.add_argument("--version", action="version", version=VERSION)
parser.add_argument(
"-c",
"--console",
dest="console",
action="store",
default=None,
choices=["ipython", "python"],
metavar="CONSOLE",
help=("select type of interactive session: ipython | python; defaults "
"to ipython if IPython is installed, otherwise python"),
)
parser.add_argument(
"-p",
"--pretty",
dest="pretty",
action="store",
default=None,
metavar="PRETTY",
choices=["unicode", "ascii", "no"],
help=("setup pretty printing: unicode | ascii | no; defaults to "
"unicode printing if the terminal supports it, otherwise ascii"),
)
parser.add_argument(
"-t",
"--types",
dest="types",
action="store",
default=None,
metavar="TYPES",
choices=["gmpy", "gmpy1", "python"],
help=
("setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 "
"or gmpy is installed, otherwise python"),
)
parser.add_argument(
"-o",
"--order",
dest="order",
action="store",
default=None,
metavar="ORDER",
choices=[
"lex",
"grlex",
"grevlex",
"rev-lex",
"rev-grlex",
"rev-grevlex",
"old",
"none",
],
help=
("setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old |"
" none; defaults to lex"),
)
parser.add_argument(
"-q",
"--quiet",
dest="quiet",
action="store_true",
default=False,
help="print only version information at startup",
)
parser.add_argument(
"-d",
"--doctest",
dest="doctest",
action="store_true",
default=False,
help=
"use the doctest format for output (you can just copy and paste it)",
)
parser.add_argument(
"-C",
"--no-cache",
dest="cache",
action="store_false",
default=True,
help="disable caching mechanism",
)
parser.add_argument(
"-a",
"--auto-symbols",
dest="auto_symbols",
action="store_true",
default=False,
help="automatically construct missing symbols",
)
parser.add_argument(
"-i",
"--int-to-Integer",
dest="auto_int_to_Integer",
action="store_true",
default=False,
help="automatically wrap int literals with Integer",
)
parser.add_argument(
"-I",
"--interactive",
dest="interactive",
action="store_true",
default=False,
help="equivalent to -a -i",
)
parser.add_argument(
"-D",
"--debug",
dest="debug",
action="store_true",
default=False,
help="enable debugging output",
)
(options, ipy_args) = parser.parse_known_args()
if "--" in ipy_args:
ipy_args.remove("--")
if not options.cache:
os.environ["SYMPY_USE_CACHE"] = "no"
if options.types:
os.environ["SYMPY_GROUND_TYPES"] = options.types
if options.debug:
os.environ["SYMPY_DEBUG"] = str(options.debug)
if options.doctest:
options.pretty = "no"
options.console = "python"
session = options.console
if session is not None:
ipython = session == "ipython"
else:
try:
import IPython
ipython = True
except ImportError:
if not options.quiet:
from sympy.interactive.session import no_ipython
print(no_ipython)
ipython = False
args = {
"pretty_print": True,
"use_unicode": None,
"use_latex": None,
"order": None,
"argv": ipy_args,
}
if options.pretty == "unicode":
args["use_unicode"] = True
elif options.pretty == "ascii":
args["use_unicode"] = False
elif options.pretty == "no":
args["pretty_print"] = False
if options.order is not None:
args["order"] = options.order
args["quiet"] = options.quiet
args["auto_symbols"] = options.auto_symbols or options.interactive
args[
"auto_int_to_Integer"] = options.auto_int_to_Integer or options.interactive
from sympy.interactive import init_session
init_session(ipython, **args)
except ImportError:
print(
"ERROR: Setuptools is required to install networkit python module.\nInstall via pip3 install setuptools."
)
sys.exit(1)
import os
import subprocess #calling cmake, make and cython
################################################
# get the optional arguments for the compilation
################################################
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("-j", "--jobs", dest="jobs", help="specify number of jobs")
(options, args) = parser.parse_known_args()
if options.jobs is not None:
jobs = options.jobs
if "NETWORKIT_PARALLEL_JOBS" in os.environ:
jobs = int(os.environ["NETWORKIT_PARALLEL_JOBS"])
else:
import multiprocessing
jobs = multiprocessing.cpu_count()
# make sure sys.argv is correct for setuptools
sys.argv = [__file__] + args
################################################
# compiler identification
################################################
candidates = [
def argparse():
parser = ArgumentParser(
description='Convert pl checkpoint to transformers format')
parser.add_argument('ckpt_path', type=str)
args, _ = parser.parse_known_args()
return args
def unittest(args):
"""run the JUnit tests"""
parser = ArgumentParser(
prog='mx unittest',
description='run the JUnit tests',
formatter_class=RawDescriptionHelpFormatter,
epilog=unittestHelpSuffix,
)
parser.add_argument('--blacklist',
help='run all testcases not specified in <file>',
metavar='<file>')
parser.add_argument('--whitelist',
help='run testcases specified in <file> only',
metavar='<file>')
parser.add_argument('--verbose',
help='enable verbose JUnit output',
action='store_true')
parser.add_argument('--very-verbose',
help='enable very verbose JUnit output',
action='store_true')
parser.add_argument(
'--fail-fast',
help='stop after first JUnit test class that has a failure',
action='store_true')
parser.add_argument(
'--enable-timing',
help='enable JUnit test timing (requires --verbose/--very-verbose)',
action='store_true')
parser.add_argument(
'--regex',
help='run only testcases matching a regular expression',
metavar='<regex>')
parser.add_argument('--color',
help='enable color output',
action='store_true')
parser.add_argument('--gc-after-test',
help='force a GC after each test',
action='store_true')
parser.add_argument('--suite',
help='run only the unit tests in <suite>',
metavar='<suite>')
parser.add_argument('--repeat',
help='run only the unit tests in <suite>',
type=is_strictly_positive)
eagerStacktrace = parser.add_mutually_exclusive_group()
eagerStacktrace.add_argument(
'--eager-stacktrace',
action='store_const',
const=True,
dest='eager_stacktrace',
help='print test errors as they occur (default)')
eagerStacktrace.add_argument(
'--no-eager-stacktrace',
action='store_const',
const=False,
dest='eager_stacktrace',
help='print test errors after all tests have run')
ut_args = []
delimiter = False
# check for delimiter
while len(args) > 0:
arg = args.pop(0)
if arg == '--':
delimiter = True
break
ut_args.append(arg)
if delimiter:
# all arguments before '--' must be recognized
parsed_args = parser.parse_args(ut_args)
else:
# parse all know arguments
parsed_args, args = parser.parse_known_args(ut_args)
if parsed_args.whitelist:
try:
with open(parsed_args.whitelist) as fp:
parsed_args.whitelist = [
re.compile(fnmatch.translate(l.rstrip()))
for l in fp.readlines() if not l.startswith('#')
]
except IOError:
mx.log('warning: could not read whitelist: ' +
parsed_args.whitelist)
if parsed_args.blacklist:
try:
with open(parsed_args.blacklist) as fp:
parsed_args.blacklist = [
re.compile(fnmatch.translate(l.rstrip()))
for l in fp.readlines() if not l.startswith('#')
]
except IOError:
mx.log('warning: could not read blacklist: ' +
parsed_args.blacklist)
if parsed_args.eager_stacktrace is None:
parsed_args.eager_stacktrace = True
_unittest(args, ['@Test', '@Parameters'], **parsed_args.__dict__)
def parse_known_args(self, *args, **kwargs):
args, remainder = ArgumentParser.parse_known_args(
self, *args, **kwargs)
return (self.validate(args), remainder)
def create_trial_from_spec(spec: dict, output_path: str,
parser: argparse.ArgumentParser, **trial_kwargs):
"""Creates a Trial object from parsing the spec.
Args:
spec: A resolved experiment specification. Arguments should
The args here should correspond to the command line flags
in ray.tune.experiment.config_parser.
output_path: A specific output path within the local_dir.
Typically the name of the experiment.
parser: An argument parser object from
make_parser.
trial_kwargs: Extra keyword arguments used in instantiating the Trial.
Returns:
A trial object with corresponding parameters to the specification.
"""
global _cached_pgf
spec = spec.copy()
resources = spec.pop("resources_per_trial", None)
try:
args, _ = parser.parse_known_args(to_argv(spec))
except SystemExit:
raise TuneError("Error parsing args, see above message", spec)
if resources:
if isinstance(resources, PlacementGroupFactory):
trial_kwargs["placement_group_factory"] = resources
else:
# This will be converted to a placement group factory in the
# Trial object constructor
try:
trial_kwargs["resources"] = json_to_resources(resources)
except (TuneError, ValueError) as exc:
raise TuneError("Error parsing resources_per_trial",
resources) from exc
remote_checkpoint_dir = spec.get("remote_checkpoint_dir")
sync_config = spec.get("sync_config", SyncConfig())
if (sync_config.syncer is None or sync_config.syncer == "auto"
or isinstance(sync_config.syncer, Syncer)):
custom_syncer = sync_config.syncer
else:
raise ValueError(
f"Unknown syncer type passed in SyncConfig: {type(sync_config.syncer)}. "
f"Note that custom sync functions and templates have been deprecated. "
f"Instead you can implement you own `Syncer` class. "
f"Please leave a comment on GitHub if you run into any issues with this: "
f"https://github.com/ray-project/ray/issues")
return Trial(
# Submitting trial via server in py2.7 creates Unicode, which does not
# convert to string in a straightforward manner.
trainable_name=spec["run"],
# json.load leads to str -> unicode in py2.7
config=spec.get("config", {}),
local_dir=os.path.join(spec["local_dir"], output_path),
# json.load leads to str -> unicode in py2.7
stopping_criterion=spec.get("stop", {}),
remote_checkpoint_dir=remote_checkpoint_dir,
custom_syncer=custom_syncer,
checkpoint_freq=args.checkpoint_freq,
checkpoint_at_end=args.checkpoint_at_end,
sync_on_checkpoint=sync_config.sync_on_checkpoint,
keep_checkpoints_num=args.keep_checkpoints_num,
checkpoint_score_attr=args.checkpoint_score_attr,
export_formats=spec.get("export_formats", []),
# str(None) doesn't create None
restore_path=spec.get("restore"),
trial_name_creator=spec.get("trial_name_creator"),
trial_dirname_creator=spec.get("trial_dirname_creator"),
log_to_file=spec.get("log_to_file"),
# str(None) doesn't create None
max_failures=args.max_failures,
**trial_kwargs,
)
def parse_args(sys_args):
parser = ArgumentParser()
parser.add_argument("--world-size", type=int, nargs=2, default=(50, 50))
return parser.parse_known_args(sys_args)
# cache = "/cluster/projects/radiomics/Temp/colin/isotropic_nrrd/unpaired"
cache = "/cluster/home/carrowsm/img-cache"
checkpoint_path = "/cluster/home/carrowsm/logs/cycleGAN/8_256_256px/2u1-0/version_2/checkpoints/epoch=48.ckpt"
parser = ArgumentParser()
# Paths to data and logs
parser.add_argument("--csv_path", type=str, default=csv_path,
help="Path to the CSV containing all image DA statuses and DA locations")
parser.add_argument("--in_img_dir", default=img_dir, type=str,
help="Path to the input image data (DICOM).")
parser.add_argument("--cache_dir", default=cache, type=str,
help="Where to cache images for model input.")
parser.add_argument("--out_img_dir", default=log_dir, type=str,
help='Where to save clean output images.')
### Hyperparams for model testing ###
parser.add_argument("--n_gpus", type=int, default=1,
help="Number of GPUs to use for training")
parser.add_argument("--n_cpus", type=int, default=1,
help="Number of parallel workers to use for data loading.")
### Model selection and training parameters ###
parser.add_argument("--checkpoint", type=str, default=checkpoint_path,
help="The path to a checkpoint file. If 'None', training will start from scratch.")
args, unparsed = parser.parse_known_args()
main(args)
def configure(self):
defaults = {}
defaults["message"] = "UNCLASSIFIED"
defaults["fgcolor"] = "#FFFFFF"
defaults["bgcolor"] = "#007A33"
defaults["face"] = "liberation-sans"
defaults["size"] = "small"
defaults["weight"] = "bold"
defaults["show_top"] = True
defaults["show_bottom"] = True
defaults["hres"] = 0
defaults["vres"] = 0
defaults["sys_info"] = False
defaults["opacity"] = 0.75
defaults["esc"] = True
defaults["spanning"] = False
# Check if a configuration file was passed in from the command line
default_heading = DEFAULTSECT
conf_parser = ArgumentParser(
formatter_class=RawDescriptionHelpFormatter, add_help=False)
conf_parser.add_argument("-c",
"--config",
help="Specify the configuration file",
metavar="FILE")
conf_parser.add_argument("--heading",
help="Specify the config. section to use.",
default=default_heading)
options, args = conf_parser.parse_known_args()
config_file = None
if options.config:
config_file = os.path.abspath(options.config)
if not os.path.isfile(config_file):
print("ERROR: Specified configuration file does not exist.")
sys.exit(1)
else:
config_file = os.path.abspath(CONF_FILE)
if not os.path.isfile(config_file):
config_file = None
# In order to maintain backwards compatibility with the way the
# previous configuration file format, a dummy section may need
# to be added to the configuration file. If this is the case,
# a temporary file is used in order to avoid overwriting the
# user's configuration.
config = ConfigParser()
if config_file is not None:
fp = open(config_file, "r")
while True:
try:
if python.major is 3:
config.read_file(fp, source=config_file)
else:
config.readfp(fp, config_file)
break
except MissingSectionHeaderError:
# Recreate the file, adding a default section.
fp.close()
fp = TemporaryFile()
with open(config_file) as original:
fp.write("[%s]\n" % default_heading + original.read())
fp.seek(0)
fp.close() # If this was a temporary file it will now be deleted.
# ConfigParser treats everything as strings and any quotation
# marks in a setting are explicitly added to the string.
# One way to fix this is to add everything to the defaults and
# then strip the quotation marks off of everything.
defaults.update(dict(config.items(options.heading)))
for key, val in defaults.items():
if config.has_option(options.heading, key):
defaults[key] = val.strip("\"'")
# TODO: This coercion section is hacky and should be fixed.
for key in ["show_top", "show_bottom", "sys_info", "esc", "spanning"]:
if config.has_option(options.heading, key):
defaults[key] = config.getboolean(options.heading, key)
for key in ["hres", "vres"]:
if config.has_option(options.heading, key):
defaults[key] = config.getint(options.heading, key)
for key in ["opacity"]:
if config.has_option(options.heading, key):
defaults[key] = config.getfloat(options.heading, key)
# Use the global config to set defaults for command line options
parser = ArgumentParser(parents=[conf_parser])
parser.add_argument("-m",
"--message",
default=defaults["message"],
help="Set the Classification message")
parser.add_argument("-f",
"--fgcolor",
default=defaults["fgcolor"],
help="Set the Foreground (text) color")
parser.add_argument("-b",
"--bgcolor",
default=defaults["bgcolor"],
help="Set the Background color")
parser.add_argument("-x",
"--hres",
default=defaults["hres"],
type=int,
help="Set the Horizontal Screen Resolution")
parser.add_argument("-y",
"--vres",
default=defaults["vres"],
type=int,
help="Set the Vertical Screen Resolution")
parser.add_argument(
"-o",
"--opacity",
default=defaults["opacity"],
type=float,
dest="opacity",
help="Set the window opacity for composted window managers")
parser.add_argument("--face",
default=defaults["face"],
help="Font face")
parser.add_argument("--size",
default=defaults["size"],
help="Font size")
parser.add_argument("--weight",
default=defaults["weight"],
help="Set the Font weight")
parser.add_argument("--disable-esc-msg",
default=defaults["esc"],
dest="esc",
action="store_false",
help="Disable the 'ESC to hide' message")
parser.add_argument("--hide-top",
default=defaults["show_top"],
dest="show_top",
action="store_false",
help="Disable the top banner")
parser.add_argument("--hide-bottom",
default=defaults["show_bottom"],
dest="show_bottom",
action="store_false",
help="Disable the bottom banner")
parser.add_argument("--system-info",
default=defaults["sys_info"],
dest="sys_info",
action="store_true",
help="Show user and hostname in the top banner")
parser.add_argument(
"--enable-spanning",
default=defaults["spanning"],
dest="spanning",
action="store_true",
help="Enable banner(s) to span across screens as a single banner")
options = parser.parse_args()
return options
def argparse():
parser = ArgumentParser(description='Make dataset')
parser.add_argument('--test_size', type=float, default=0.1)
args, _ = parser.parse_known_args()
return args
def main(self,
argv=None,
standalone=None,
plugin_argument_provider=None,
plugin_manager_settings_prefix=''):
if argv is None:
argv = sys.argv
# extract --args and everything behind manually since argparse can not handle that
arguments = argv[1:]
# extract plugin specific args when not being invoked in standalone mode programmatically
if not standalone:
plugin_args = []
if '--args' in arguments:
index = arguments.index('--args')
plugin_args = arguments[index + 1:]
arguments = arguments[0:index + 1]
parser = ArgumentParser(os.path.basename(Main.main_filename),
add_help=False)
self.add_arguments(parser,
standalone=bool(standalone),
plugin_argument_provider=plugin_argument_provider)
self._options = parser.parse_args(arguments)
if standalone:
# rerun parsing to separate common arguments from plugin specific arguments
parser = ArgumentParser(os.path.basename(Main.main_filename),
add_help=False)
self.add_arguments(parser, standalone=bool(standalone))
self._options, plugin_args = parser.parse_known_args(arguments)
self._options.plugin_args = plugin_args
# set default values for options not available in standalone mode
if standalone:
self._options.freeze_layout = False
self._options.lock_perspective = False
self._options.multi_process = False
self._options.perspective = None
self._options.perspective_file = None
self._options.standalone_plugin = standalone
self._options.list_perspectives = False
self._options.list_plugins = False
self._options.command_pid = None
self._options.command_start_plugin = None
self._options.command_switch_perspective = None
self._options.embed_plugin = None
self._options.embed_plugin_serial = None
self._options.embed_plugin_address = None
# check option dependencies
try:
if self._options.plugin_args and not self._options.standalone_plugin and not self._options.command_start_plugin and not self._options.embed_plugin:
raise RuntimeError(
'Option --args can only be used together with either --standalone, --command-start-plugin or --embed-plugin option'
)
if self._options.freeze_layout and not self._options.lock_perspective:
raise RuntimeError(
'Option --freeze_layout can only be used together with the --lock_perspective option'
)
list_options = (self._options.list_perspectives,
self._options.list_plugins)
list_options_set = [
opt for opt in list_options if opt is not False
]
if len(list_options_set) > 1:
raise RuntimeError(
'Only one --list-* option can be used at a time')
command_options = (self._options.command_start_plugin,
self._options.command_switch_perspective)
command_options_set = [
opt for opt in command_options if opt is not None
]
if len(command_options_set) > 0 and not self._dbus_available:
raise RuntimeError(
'Without DBus support the --command-* options are not available'
)
if len(command_options_set) > 1:
raise RuntimeError(
'Only one --command-* option can be used at a time (except --command-pid which is optional)'
)
if len(command_options_set
) == 0 and self._options.command_pid is not None:
raise RuntimeError(
'Option --command_pid can only be used together with an other --command-* option'
)
embed_options = (self._options.embed_plugin,
self._options.embed_plugin_serial,
self._options.embed_plugin_address)
embed_options_set = [
opt for opt in embed_options if opt is not None
]
if len(command_options_set) > 0 and not self._dbus_available:
raise RuntimeError(
'Without DBus support the --embed-* options are not available'
)
if len(embed_options_set) > 0 and len(embed_options_set) < len(
embed_options):
raise RuntimeError(
'Missing option(s) - all \'--embed-*\' options must be set'
)
if len(embed_options_set) > 0 and self._options.clear_config:
raise RuntimeError(
'Option --clear-config can only be used without any --embed-* option'
)
groups = (list_options_set, command_options_set, embed_options_set)
groups_set = [opt for opt in groups if len(opt) > 0]
if len(groups_set) > 1:
raise RuntimeError(
'Options from different groups (--list, --command, --embed) can not be used together'
)
perspective_options = (self._options.perspective,
self._options.perspective_file)
perspective_options_set = [
opt for opt in perspective_options if opt is not None
]
if len(perspective_options_set) > 1:
raise RuntimeError(
'Only one --perspective-* option can be used at a time')
if self._options.perspective_file is not None and not os.path.isfile(
self._options.perspective_file):
raise RuntimeError(
'Option --perspective-file must reference existing file')
except RuntimeError as e:
print(str(e))
#parser.parse_args(['--help'])
# calling --help will exit
return 1
# set implicit option dependencies
if self._options.standalone_plugin is not None:
self._options.lock_perspective = True
# create application context containing various relevant information
from .application_context import ApplicationContext
context = ApplicationContext()
context.qtgui_path = self._qtgui_path
context.options = self._options
if self._dbus_available:
from dbus import DBusException, Interface, SessionBus
# non-special applications provide various dbus interfaces
if self._dbus_available:
context.provide_app_dbus_interfaces = len(groups_set) == 0
context.dbus_base_bus_name = 'org.ros.qt_gui'
if context.provide_app_dbus_interfaces:
context.dbus_unique_bus_name = context.dbus_base_bus_name + '.pid%d' % os.getpid(
)
# provide pid of application via dbus
from .application_dbus_interface import ApplicationDBusInterface
_dbus_server = ApplicationDBusInterface(
context.dbus_base_bus_name)
# determine host bus name, either based on pid given on command line or via dbus application interface if any other instance is available
if len(command_options_set) > 0 or len(embed_options_set) > 0:
host_pid = None
if self._options.command_pid is not None:
host_pid = self._options.command_pid
else:
try:
remote_object = SessionBus().get_object(
context.dbus_base_bus_name, '/Application')
except DBusException:
pass
else:
remote_interface = Interface(
remote_object,
context.dbus_base_bus_name + '.Application')
host_pid = remote_interface.get_pid()
if host_pid is not None:
context.dbus_host_bus_name = context.dbus_base_bus_name + '.pid%d' % host_pid
# execute command on host application instance
if len(command_options_set) > 0:
if self._options.command_start_plugin is not None:
try:
remote_object = SessionBus().get_object(
context.dbus_host_bus_name, '/PluginManager')
except DBusException:
(rc,
msg) = (1,
'unable to communicate with GUI instance "%s"' %
context.dbus_host_bus_name)
else:
remote_interface = Interface(
remote_object,
context.dbus_base_bus_name + '.PluginManager')
(rc, msg) = remote_interface.start_plugin(
self._options.command_start_plugin,
' '.join(self._options.plugin_args))
if rc == 0:
print('qt_gui_main() started plugin "%s" in GUI "%s"' %
(msg, context.dbus_host_bus_name))
else:
print(
'qt_gui_main() could not start plugin "%s" in GUI "%s": %s'
% (self._options.command_start_plugin,
context.dbus_host_bus_name, msg))
return rc
elif self._options.command_switch_perspective is not None:
remote_object = SessionBus().get_object(
context.dbus_host_bus_name, '/PerspectiveManager')
remote_interface = Interface(
remote_object,
context.dbus_base_bus_name + '.PerspectiveManager')
remote_interface.switch_perspective(
self._options.command_switch_perspective)
print(
'qt_gui_main() switched to perspective "%s" in GUI "%s"' %
(self._options.command_switch_perspective,
context.dbus_host_bus_name))
return 0
raise RuntimeError('Unknown command not handled')
# choose selected or default qt binding
setattr(sys, 'SELECT_QT_BINDING', self._options.qt_binding)
from python_qt_binding import QT_BINDING
from python_qt_binding.QtCore import qDebug, qInstallMessageHandler, QSettings, Qt, QtCriticalMsg, QtDebugMsg, QtFatalMsg, QTimer, QtWarningMsg
from python_qt_binding.QtGui import QIcon
from python_qt_binding.QtWidgets import QAction, QMenuBar
from .about_handler import AboutHandler
from .composite_plugin_provider import CompositePluginProvider
from .container_manager import ContainerManager
from .help_provider import HelpProvider
from .icon_loader import get_icon
from .main_window import MainWindow
from .minimized_dock_widgets_toolbar import MinimizedDockWidgetsToolbar
from .perspective_manager import PerspectiveManager
from .plugin_manager import PluginManager
# TODO PySide2 segfaults when invoking this custom message handler atm
if QT_BINDING != 'pyside':
def message_handler(type_, context, msg):
colored_output = 'TERM' in os.environ and 'ANSI_COLORS_DISABLED' not in os.environ
cyan_color = '\033[36m' if colored_output else ''
red_color = '\033[31m' if colored_output else ''
reset_color = '\033[0m' if colored_output else ''
if type_ == QtDebugMsg and self._options.verbose:
print(msg, file=sys.stderr)
elif type_ == QtWarningMsg:
print(cyan_color + msg + reset_color, file=sys.stderr)
elif type_ == QtCriticalMsg:
print(red_color + msg + reset_color, file=sys.stderr)
elif type_ == QtFatalMsg:
print(red_color + msg + reset_color, file=sys.stderr)
sys.exit(1)
qInstallMessageHandler(message_handler)
app = self.create_application(argv)
self._check_icon_theme_compliance()
settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
'ros.org', self._settings_filename)
if len(embed_options_set) == 0:
if self._options.clear_config:
settings.clear()
main_window = MainWindow()
if self._options.on_top:
main_window.setWindowFlags(Qt.WindowStaysOnTopHint)
main_window.statusBar()
def sigint_handler(*args):
qDebug('\nsigint_handler()')
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
menu_bar = main_window.menuBar()
file_menu = menu_bar.addMenu(menu_bar.tr('&File'))
action = QAction(file_menu.tr('&Quit'), file_menu)
action.setIcon(QIcon.fromTheme('application-exit'))
action.triggered.connect(main_window.close)
file_menu.addAction(action)
else:
app.setQuitOnLastWindowClosed(False)
main_window = None
menu_bar = None
self._add_plugin_providers()
# setup plugin manager
plugin_provider = CompositePluginProvider(self.plugin_providers)
plugin_manager = PluginManager(
plugin_provider,
settings,
context,
settings_prefix=plugin_manager_settings_prefix)
if self._options.list_plugins:
# output available plugins
print('\n'.join(sorted(plugin_manager.get_plugins().values())))
return 0
help_provider = HelpProvider()
plugin_manager.plugin_help_signal.connect(
help_provider.plugin_help_request)
# setup perspective manager
if main_window is not None:
perspective_manager = PerspectiveManager(settings, context)
if self._options.list_perspectives:
# output available perspectives
print('\n'.join(sorted(perspective_manager.perspectives)))
return 0
else:
perspective_manager = None
if main_window is not None:
container_manager = ContainerManager(main_window, plugin_manager)
plugin_manager.set_main_window(
main_window,
menu_bar if not self._options.lock_perspective else None,
container_manager)
if not self._options.freeze_layout:
minimized_dock_widgets_toolbar = MinimizedDockWidgetsToolbar(
container_manager, main_window)
main_window.addToolBar(Qt.BottomToolBarArea,
minimized_dock_widgets_toolbar)
plugin_manager.set_minimized_dock_widgets_toolbar(
minimized_dock_widgets_toolbar)
if menu_bar is not None and not self._options.lock_perspective:
perspective_menu = menu_bar.addMenu(menu_bar.tr('P&erspectives'))
perspective_manager.set_menu(perspective_menu)
# connect various signals and slots
if perspective_manager is not None and main_window is not None:
# signal changed perspective to update window title
perspective_manager.perspective_changed_signal.connect(
main_window.perspective_changed)
# signal new settings due to changed perspective
perspective_manager.save_settings_signal.connect(
main_window.save_settings)
perspective_manager.restore_settings_signal.connect(
main_window.restore_settings)
perspective_manager.restore_settings_without_plugin_changes_signal.connect(
main_window.restore_settings)
if perspective_manager is not None and plugin_manager is not None:
perspective_manager.save_settings_signal.connect(
plugin_manager.save_settings)
plugin_manager.save_settings_completed_signal.connect(
perspective_manager.save_settings_completed)
perspective_manager.restore_settings_signal.connect(
plugin_manager.restore_settings)
perspective_manager.restore_settings_without_plugin_changes_signal.connect(
plugin_manager.restore_settings_without_plugins)
if plugin_manager is not None and main_window is not None:
# signal before changing plugins to save window state
plugin_manager.plugins_about_to_change_signal.connect(
main_window.save_setup)
# signal changed plugins to restore window state
plugin_manager.plugins_changed_signal.connect(
main_window.restore_state)
# signal save settings to store plugin setup on close
main_window.save_settings_before_close_signal.connect(
plugin_manager.close_application)
# signal save and shutdown called for all plugins, trigger closing main window again
plugin_manager.close_application_signal.connect(
main_window.close, type=Qt.QueuedConnection)
if main_window is not None and menu_bar is not None:
about_handler = AboutHandler(context.qtgui_path, main_window)
help_menu = menu_bar.addMenu(menu_bar.tr('&Help'))
action = QAction(file_menu.tr('&About'), help_menu)
action.setIcon(QIcon.fromTheme('help-about'))
action.triggered.connect(about_handler.show)
help_menu.addAction(action)
# set initial size - only used without saved configuration
if main_window is not None:
main_window.resize(600, 450)
main_window.move(100, 100)
# ensure that qt_gui/src is in sys.path
src_path = os.path.realpath(
os.path.join(os.path.dirname(__file__), '..'))
if src_path not in sys.path:
sys.path.append(src_path)
# load specific plugin
plugin = None
plugin_serial = None
if self._options.embed_plugin is not None:
plugin = self._options.embed_plugin
plugin_serial = self._options.embed_plugin_serial
elif self._options.standalone_plugin is not None:
plugin = self._options.standalone_plugin
plugin_serial = 0
if plugin is not None:
plugins = plugin_manager.find_plugins_by_name(plugin)
if len(plugins) == 0:
print('qt_gui_main() found no plugin matching "%s"' % plugin)
return 1
elif len(plugins) > 1:
print(
'qt_gui_main() found multiple plugins matching "%s"\n%s' %
(plugin, '\n'.join(plugins.values())))
return 1
plugin = plugins.keys()[0]
qDebug('QtBindingHelper using %s' % QT_BINDING)
plugin_manager.discover()
if self._options.reload_import:
qDebug(
'ReloadImporter() automatically reload all subsequent imports')
from .reload_importer import ReloadImporter
_reload_importer = ReloadImporter()
self._add_reload_paths(_reload_importer)
_reload_importer.enable()
# switch perspective
if perspective_manager is not None:
if plugin:
perspective_manager.set_perspective(
plugin, hide_and_without_plugin_changes=True)
elif self._options.perspective_file:
perspective_manager.import_perspective_from_file(
self._options.perspective_file,
perspective_manager.HIDDEN_PREFIX +
'__cli_perspective_from_file')
else:
perspective_manager.set_perspective(self._options.perspective)
# load specific plugin
if plugin:
plugin_manager.load_plugin(plugin, plugin_serial,
self._options.plugin_args)
running = plugin_manager.is_plugin_running(plugin, plugin_serial)
if not running:
return 1
if self._options.standalone_plugin:
# use icon of standalone plugin (if available) for application
plugin_descriptor = plugin_manager.get_plugin_descriptor(
plugin)
action_attributes = plugin_descriptor.action_attributes()
if 'icon' in action_attributes and action_attributes[
'icon'] is not None:
base_path = plugin_descriptor.attributes().get(
'plugin_path')
try:
icon = get_icon(
action_attributes['icon'],
action_attributes.get('icontype', None), base_path)
except UserWarning:
pass
else:
app.setWindowIcon(icon)
if main_window is not None:
main_window.show()
if sys.platform == 'darwin':
main_window.raise_()
return app.exec_()
NAME = "Dtls"
VERSION = "1.2.3"
if __name__ == "__main__":
# Full upload sequence for new version:
# 1. python setup.py bdist_wheel
# 2. python setup.py bdist_wheel -p win32
# 3. python setup.py bdist_wheel -p win_amd64
# 4. twine upload dist/*
parser = ArgumentParser(add_help=False)
parser.add_argument("-h", "--help", action="store_true")
parser.add_argument("command", nargs="*")
parser.add_argument("-p", "--plat-name")
args = parser.parse_known_args()[0]
dist = "bdist_wheel" in args.command and not args.help
plat_dist = dist and args.plat_name
if dist:
from pypandoc import convert
long_description = convert("README.md", "rst")\
.translate({ord("\r"): None})
with open("README.rst", "w") as readme:
readme.write(long_description)
else:
long_description = open("README.md").read()
top_package_plat_files_file = "dtls_package_files"
if dist:
if plat_dist:
prebuilt_platform_root = "dtls/prebuilt"
if args.plat_name == "win32":
parser.add_argument(
'--cytomine_id_project',
dest='id_project',
required=False,
help="The project to which the property will be added (optional)")
parser.add_argument(
'--cytomine_id_image_instance',
dest='id_image_instance',
required=False,
help="The image to which the property will be added (optional)")
parser.add_argument(
'--cytomine_id_annotation',
dest='id_annotation',
required=False,
help="The annotation to which the property will be added (optional)")
params, other = parser.parse_known_args(sys.argv[1:])
with Cytomine(host=params.host,
public_key=params.public_key,
private_key=params.private_key) as cytomine:
if params.id_project:
prop = Property(Project().fetch(params.id_project),
key=params.key,
value=params.value).save()
print(prop)
if params.id_image_instance:
prop = Property(ImageInstance().fetch(params.id_image_instance),
key=params.key,
value=params.value).save()
compute_api = "https://binaries.artheriom.fr/artifactory/api/storage/"
parser = ArgumentParser()
parser.add_argument("-r",
"--requested",
help="Define requested repository.",
default="")
parser.add_argument("-m",
"--isMaven",
help="Define if project is Maven Project.",
default=False)
parser.add_argument("-o",
"--output",
help="Define artifact output",
default="")
args, unknown = parser.parse_known_args()
if (args.requested == "" or args.output == ""):
print("FATAL : You must define props !")
exit(0)
isMaven = args.isMaven
outputName = args.output
requested = args.requested
instances_rq = requests.get(url=compute_api + requested,
verify=False,
auth=HTTPBasicAuth("admin", "MDP"))
instance_file = json.loads(instances_rq.content)
found = False
sparsity_vs_accuracy, val_vs_episodes, train_vs_episodes = dense_model.fit(
n_epochs=FLAGS.n_epochs,
learning_rate_schedule=simple_config.learning_rate_schedule,
batch_size=FLAGS.batch_size,
config=simple_config)
fig = plot_several_graphs(data=val_vs_episodes, name='val_acc')
_ = plot_several_graphs(data=train_vs_episodes, name='train_acc', last=1)
plot_conv_weights(dense_model)
dense_model.sess.close()
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--model_path',
type=str,
default=simple_config.model_path,
help=' Directory where to save model checkpoint.')
parser.add_argument('--n_epochs',
type=int,
default=simple_config.n_epochs,
help='number of epoches')
parser.add_argument('--batch_size',
type=int,
default=simple_config.batch_size,
help='batch_size')
parser.add_argument('--dropout',
type=int,
default=simple_config.dropout,
help='dropout')
FLAGS, unparsed = parser.parse_known_args()
main()
