def _DefineFlagAndValidators(self, first_validator, second_validator): local_flags = gflags.FlagValues() gflags.DEFINE_integer('test_flag', 2, 'test flag', flag_values=local_flags) gflags.RegisterValidator('test_flag', first_validator, message='', flag_values=local_flags) gflags.RegisterValidator('test_flag', second_validator, message='', flag_values=local_flags) argv = ('./program') local_flags(argv)
def DEFINE_linspace(name, default, help_string, nonempty=False, increasing=False, flag_values=gflags.FLAGS, **kwargs): # pylint: disable=invalid-name """Defines a 'linspace' flag. The flag value should be specified as <lower>,<upper>,<count>. The components are used as arguments to numpy.linspace, so they must be parsable as float, float, and int, respectively. The parsed flag value will be a 1-dimensional numpy.ndarray. Args: name: Name of the flag. default: Default value (as unparsed string), or None if flag is unset by default. help_string: Helpful description of the flag. nonempty: Indicates whether the flag value is required to be nonempty. If True, None is still an allowable default. Use gflags.MarkFlagAsRequired to disallow None. increasing: Indicates whether the flag value should be an increasing array. This is only enforced if the parsed value has >=2 elements. flag_values: The gflags.FlagValues object in which to define the flag. **kwargs: See gflags.DEFINE. """ gflags.DEFINE(_LinspaceParser(), name, default, help_string, flag_values=flag_values, **kwargs) if nonempty: # numpy.array can't be implicitly converted to a boolean. # pylint: disable=g-explicit-length-test gflags.RegisterValidator(name, lambda v: len(v) > 0, '--%s must specify a nonempty range.' % name, flag_values=flag_values) if increasing: gflags.RegisterValidator(name, lambda v: len(v) < 2 or v[-1] > v[0], '--%s must specify an increasing range.', flag_values=flag_values)
def main(argv): """Entry point.""" gflags.RegisterValidator('ccx_file', lambda f: f.endswith('.ccx'), message='Expected a .ccx file.') try: argv = FLAGS(argv) except gflags.FlagsError, e: print '{}\nUsage: {} ARGS\n{}'.format(e, sys.argv[0], FLAGS) sys.exit(1)
def main(argv): """Implement a simple demo for computing error CDFs.""" # Input/output flags. gflags.DEFINE_string('input_file', None, 'Full path to wing HDF5 log file.') gflags.MarkFlagAsRequired('input_file') gflags.DEFINE_string('output_file', None, 'Full path to output MAT file.') gflags.MarkFlagAsRequired('output_file') # Segment processing flags. gflags.DEFINE_integer('increment', 100, 'Integer number of messages between segments.') gflags.DEFINE_integer('seg_length', 1000, 'Integer number of messages in each segment.') # Evaluate segments over a specific time interval. gflags.DEFINE_float('start_time', -float('inf'), 'Start time to evaluate segment errors.') gflags.DEFINE_float('end_time', float('inf'), 'End time to evaluate segment errors.') # Override default parameters. gflags.DEFINE_list('params', [], 'A comma-separated list of param=value tokens, where ' 'each param describes the dot path to a parameter in ' 'EstimatorParams.') gflags.RegisterValidator('params', lambda l: all(len(s.split('=')) == 2 for s in l), message='Invalid key=value parameter syntax.') # Scenarios to process. gflags.DEFINE_bool('scenario_pure_inertial', False, 'Process pure inertial scenario.') gflags.DEFINE_bool('scenario_gps_dropout', False, 'Process GPS dropout scenario.') # Common faults to introduce. gflags.DEFINE_bool('fault_weather', False, 'Fault weather subsystems to avoid an assert when ' 'reprocessing historical data.') gflags.DEFINE_bool('fault_glas', False, 'Fault GLAS subsystems.') # Specify flight for special handling. gflags.DEFINE_string('flight', None, 'Fix known issues associated with the given flight.') try: argv = gflags.FLAGS(argv) except gflags.FlagsError, e: print '{}\nUsage: {} ARGS\n{}'.format(e, sys.argv[0], gflags.FLAGS) sys.exit(1)
def testDefaultValueNotUsedSuccess(self): def Checker(x): self.call_args.append(x) return True gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program', '--test_flag=1') self.flag_values(argv) self.assertEquals(1, self.flag_values.test_flag) self.assertEquals([1], self.call_args)
def testErrorMessageWhenCheckerRaisesExceptionOnStart(self): def Checker(x): self.call_args.append(x) raise gflags_validators.Error('Specific message') gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program', '--test_flag=1') try: self.flag_values(argv) raise AssertionError('IllegalFlagValue expected') except gflags.IllegalFlagValue, e: self.assertEquals('flag --test_flag=1: Specific message', str(e))
def testValidatorNotCalledWhenOtherFlagIsChanged(self): def Checker(x): self.call_args.append(x) return True gflags.DEFINE_integer('test_flag', 1, 'Usual integer flag', flag_values=self.flag_values) gflags.DEFINE_integer('other_flag', 2, 'Other integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program') self.flag_values(argv) self.assertEquals(1, self.flag_values.test_flag) self.flag_values.other_flag = 3 self.assertEquals([1], self.call_args)
def testSuccess(self): def Checker(x): self.call_args.append(x) return True gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program') self.flag_values(argv) self.assertEquals(None, self.flag_values.test_flag) self.flag_values.test_flag = 2 self.assertEquals(2, self.flag_values.test_flag) self.assertEquals([None, 2][0], self.call_args[0]) self.assertEquals([None, 2][1], self.call_args[1])
def testExceptionRaisedIfCheckerFails(self): def Checker(x): self.call_args.append(x) return x == 1 gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program', '--test_flag=1') self.flag_values(argv) try: self.flag_values.test_flag = 2 raise AssertionError('gflags.IllegalFlagValue expected') except gflags.IllegalFlagValue, e: self.assertEquals('flag --test_flag=2: Errors happen', str(e))
def testExceptionRaisedIfCheckerRaisesException(self): def Checker(x): self.call_args.append(x) if x == 1: return True raise gflags_validators.Error('Specific message') gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program', '--test_flag=1') self.flag_values(argv) try: self.flag_values.test_flag = 2 raise AssertionError('gflags.IllegalFlagValue expected') except gflags.IllegalFlagValue as e: self.assertEquals('flag --test_flag=2: Specific message', str(e)) self.assertEquals([1, 2], self.call_args)
def testErrorMessageWhenCheckerReturnsFalseOnStart(self): def Checker(x): self.call_args.append(x) return False gflags.DEFINE_integer('test_flag', None, 'Usual integer flag', flag_values=self.flag_values) gflags.RegisterValidator('test_flag', Checker, message='Errors happen', flag_values=self.flag_values) argv = ('./program', '--test_flag=1') try: self.flag_values(argv) raise AssertionError('gflags.IllegalFlagValue expected') except gflags.IllegalFlagValue as e: self.assertEqual('flag --test_flag=1: Errors happen', str(e)) self.assertEqual([1], self.call_args)
import boto import boto.sqs import boto.sdb import boto.s3 import json import gflags from fractions import Fraction FLAGS = gflags.FLAGS gflags.DEFINE_string('source', None, 'Source SQS queue to read from') gflags.RegisterValidator('source', lambda x: x is not None, 'You must specify a source queue') gflags.DEFINE_multistring('targets', [], 'Select SQS queue target') gflags.DEFINE_string('region', 'us-west-1', 'AWS region to connect to') gflags.DEFINE_string('bucket', 'wnyc.org-foliage-exif', 'bucket to read from') gflags.RegisterValidator('bucket', lambda x: x is not None, 'You must specify a bucket') gflags.DEFINE_string('domain', None, 'Domain') gflags.DEFINE_float('threshold', 5.0, 'Brightness threshold for outdoors') def main(argv=None, stdin=None, stdout=None, stderr=None): import sys argv = argv or sys.argv stdin = stdin or sys.stdin stdout = stdout or sys.stdout stderr = stderr or sys.stderr try: argv = FLAGS(argv)[1:] except gflags.FlagsError, e:
override_method='derived') # Write parameters to the output_file or to stdout. if FLAGS.output_file is None: print params else: if FLAGS.type == 'json': WriteJsonParams(params, FLAGS.output_file) elif FLAGS.type == 'control': WriteDefaultControlParams(params, FLAGS.output_file) elif FLAGS.type == 'monitor': WriteDefaultMonitorParams(params, FLAGS.output_file) elif FLAGS.type == 'sim': WriteDefaultSimParams(params, FLAGS.output_file) elif FLAGS.type == 'system': WriteDefaultSystemParams(params, FLAGS.output_file) else: assert False, '--type was not properly validated.' if __name__ == '__main__': gflags.RegisterValidator('input_file', lambda f: f is None or os.path.isfile(f), message='input_file does not exist.') gflags.RegisterValidator( 'input_file', lambda f: f is None or (f.startswith('config/') and f.endswith('.py')), message='input_file must be a .py file under the config/ directory.') main(sys.argv)
u"Backend type for MinQL server") gflags.DEFINE_string('dbname', u"dbname", u"Backend db name for MinQL server") gflags.DEFINE_string('dbuser', u"dbuser", u"Backend db user for MinQL server") gflags.DEFINE_string('dbpass', u"dbpass", u"Backend db password for MinQL server") gflags.DEFINE_integer('workers', 10, u"Number of proxy Workers", short_name='w') gflags.RegisterValidator('workers', lambda workers: 1 <= workers <= 50, message=u"Number of workers must be between 1 and 50.") gflags.DEFINE_string('schema', u"", u"Schema for MinQL server") gflags.DEFINE_string('dataset', u"", u"Dataset for MinQL server") try: import sys argv = gflags.FLAGS(sys.argv) except gflags.FlagsError, e: print('%s\n\nUsage %s ARGS \n%s' % (e, sys.argv[0], gflags.FLAGS)) sys.exit(0) FLAGS = gflags.FLAGS
from makani.sim.physics import physics from matplotlib import pyplot import numpy as np FLAGS = gflags.FLAGS flag_types.DEFINE_linspace('alphas_deg', '-10.0, 10.0, 20', 'Linspace range of angle-of-attack values [deg].') flag_types.DEFINE_linspace('betas_deg', '-15.0, 15.0, 20', 'Linspace range of sideslip angles [deg].') gflags.DEFINE_boolean('plot_sim', False, 'Whether to display the sim aero model.') gflags.DEFINE_list('flaps_deg', [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'Flap deflections [deg].') gflags.RegisterValidator('flaps_deg', lambda x: len(x) == system_types.kNumFlaps, 'Wrong number of flaps in input.') gflags.DEFINE_float('reynolds_number', 1e6, 'Reynolds number for the simulator.') gflags.DEFINE_float('p_hat', 0.0, 'Normalized roll rate.') gflags.DEFINE_float('q_hat', 0.0, 'Normalized pitch rate.') gflags.DEFINE_float('r_hat', 0.0, 'Normalized yaw rate.') gflags.DEFINE_float('thrust_coeff', 0.0, 'Total thrust coefficient.') def _SwigVec3ToArray(v): """Converts a Swig Vec3 data structure to an array.""" return np.array([v.x, v.y, v.z]) def _ArrayToSwigVec3(a):
# Within the cache directory, the path is the GCS path with "gs://" stripped # off. cached_file = os.path.join(cache_dir, FLAGS.gcs_path[5:]) for i in range(5): try: DownloadFileIfNecessary(cached_file, FLAGS.sha256, FLAGS.gcs_path) except ValueError: continue # retry else: break if FLAGS.gunzip: with gzip.open(cached_file, 'rb') as source: with open(FLAGS.output_path, 'wb') as dest: dest.write(source.read()) else: shutil.copyfile(cached_file, FLAGS.output_path) if __name__ == '__main__': gflags.MarkFlagAsRequired('gcs_path') gflags.RegisterValidator('gcs_path', lambda p: p.startswith('gs://')) gflags.MarkFlagAsRequired('package') gflags.MarkFlagAsRequired('target') gflags.MarkFlagAsRequired('sha256') gflags.MarkFlagAsRequired('output_path') main(sys.argv)
gflags.DEFINE_multistring( 'empty_root_dir', [], 'An empty root directory to add to the layer. This will create a directory that' 'is a peer of "root_directory". "empty_dir" creates an empty directory inside of' '"root_directory"') gflags.DEFINE_multistring('tar', [], 'A tar file to add to the layer') gflags.DEFINE_multistring('deb', [], 'A debian package to add to the layer') gflags.DEFINE_multistring( 'link', [], 'Add a symlink a inside the layer ponting to b if a:b is specified') gflags.RegisterValidator( 'link', lambda l: all(value.find(':') > 0 for value in l), message='--link value should contains a : separator') gflags.DEFINE_string( 'directory', None, 'Directory in which to store the file inside the layer') gflags.DEFINE_string( 'compression', None, 'Compression (`gz` or `bz2`), default is none.') gflags.DEFINE_multistring( 'modes', None, 'Specific mode to apply to specific file (from the file argument),' ' e.g., path/to/file=0o455.') gflags.DEFINE_multistring('owners', None, 'Specify the numeric owners of individual files, '
gflags.DEFINE_bool("plot", True, "Enable/disable plotting of the resulting data.") gflags.DEFINE_bool("verbose", False, "Verbose mode: print extra details.", short_name='v') gflags.DEFINE_bool("api", True, ("Use http API rather than 'bq' executable, say --noapi "+ "to use 'bq' command-line tool instead.")) gflags.DEFINE_string('priority', 'INTERACTIVE', 'Priority at which to run the query', short_name = 'p') gflags.RegisterValidator('priority', lambda value: value in [ 'BATCH', 'INTERACTIVE' ], message='--priority must be "BATCH" or "INTERACTIVE"') def cmd_exists(cmd): """ Returns: bool, True if 'cmd' is in PATH, False otherwise.""" return subprocess.call("type " + cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) == 0 def bigquery_exec(query_string, output_filename, options): """ A wrapper for the 'bq' command line tool. Args: query_string - a bigquery-SQL query. Since this must be passed to 'bq' via the command line, mind your use of quotes. TODO: find a way to call the bq python function. output_filename - filename to save results. If None, a temporary
import boto import boto.sdb from boto.sqs.connection import SQSConnection from boto.sqs.message import Message import gflags import time import datetime import json FLAGS = gflags.FLAGS gflags.DEFINE_multistring('targets', [], 'Select SQS queue target') gflags.DEFINE_string('region', 'us-west-1', 'AWS region to connect to') gflags.DEFINE_string('bucket', None, 'bucket to read from') gflags.RegisterValidator('bucket', lambda x: x is not None, 'You must specify a bucket') gflags.DEFINE_string('domain', 'foliage', 'Domain') def main(argv=None, stdin=None, stdout=None, stderr=None): import sys argv = argv or sys.argv stdin = stdin or sys.stdin stdout = stdout or sys.stdout stderr = stderr or sys.stderr try: argv = FLAGS(argv)[1:] except gflags.FlagsError, e: stderr.write("%s\\nUsage: %s update_id_addresses\\n%s\n" % (e, sys.argv[0], FLAGS))
FLAGS = gflags.FLAGS gflags.DEFINE_bool("subject", False, "Print option: prints certificate subject") gflags.DEFINE_bool("issuer", False, "Print option: prints certificate issuer") gflags.DEFINE_bool("fingerprint", False, "Print option: prints certificate " "fingerprint") gflags.DEFINE_string("digest", "sha1", "Print option: fingerprint digest to use") gflags.DEFINE_bool("debug", False, "Print option: prints full ASN.1 debug information") gflags.DEFINE_string( "filetype", "", "Read option: specify an input file " "format (pem or der). If no format is specified, the " "parser attempts to detect the format automatically.") gflags.RegisterValidator( "filetype", lambda value: not value or value.lower() in {"pem", "der"}, message="--filetype must be one of pem or der") def print_cert(certificate): if not FLAGS.subject and not FLAGS.issuer and not FLAGS.fingerprint: if FLAGS.debug: print "%r" % certificate else: print certificate else: if FLAGS.subject: print "subject:\n%s" % certificate.print_subject_name() if FLAGS.issuer: print "issuer:\n%s" % certificate.print_issuer_name() if FLAGS.fingerprint:
from makani.lib.python import wing_flag from makani.lib.python.batch_sim import batch_sim_util from makani.lib.python.batch_sim import gcloud_constants from makani.lib.python.batch_sim import gcloud_util wing_flag.AppeaseLintWhenImportingFlagOnly() gflags.DEFINE_boolean('upload_worker_package', True, 'Upload worker package.') gflags.DEFINE_integer('num_workers', None, 'Number of worker instances.') gflags.DEFINE_integer( 'max_jobs_per_worker', None, 'Set number of workers to assign at most this many ' 'configs per worker.') gflags.RegisterValidator('max_jobs_per_worker', lambda m: m is None or m > 0) gflags.DEFINE_bool( 'delete_old_workers', False, 'Delete workers left from a previous run. Do not run ' 'a new batch sim.') gflags.DEFINE_string( 'sim_name', None, 'Name of the batch simulation. This must not match the ' 'name of any currently-running batch simulation, as it ' 'identifies file paths on Cloud Storage and worker ' 'instances on Compute Engine.') gflags.DEFINE_string( 'local_output_dir', None, 'Directory in which to store local output. If ' 'unspecified, a temp directory will be used.')
gflags.DEFINE_integer( 'N', 300, 'Number of samples to use', ) gflags.DEFINE_string( 'metric', 'rbf', 'Kernel metric', ) gflags.RegisterValidator( 'metric', lambda x: x in ['rbf', 'sigmoid', 'polynomial', 'poly', 'linear', 'cosine'], "metric must be in ['rbf', 'sigmoid', 'polynomial', 'poly', 'linear', 'cosine']" ) gflags.DEFINE_float( 'xmax', 16.0, 'Heatmap plot limit', ) gflags.DEFINE_float( 'gamma', 0.2, 'Kernel size parameter, as in exp(-gamma d^2) for RBF', ) gflags.DEFINE_string( 'dataset',
'maximum dimension for uploaded encrypted image', short_name='m') gflags.DEFINE_boolean('enable_diff', False, 'slow diff coordinates image') gflags.DEFINE_string('password', None, 'Password to encrypt image with.', short_name='p') gflags.DEFINE_integer('threads', 1, 'number of threads', short_name='t') gflags.DEFINE_boolean('extra_logs', False, 'write extra logs') gflags.DEFINE_boolean('ecc', False, 'Use ECC encoding.') gflags.DEFINE_integer('ecc_n', 128, 'codeword length', short_name='n') gflags.DEFINE_integer('ecc_k', 64, 'message byte length', short_name='k') gflags.RegisterValidator('encrypted_image_quality', lambda x: x > 0 and x <= 95, message='jpeg quality range', flag_values=FLAGS) gflags.RegisterValidator('scale', lambda x: x > 0, message='image scaling fraction', flag_values=FLAGS) gflags.RegisterValidator('ecc_n', lambda x: x <= 255 and x > FLAGS.ecc_k, message='Reed Solomon boundaries', flag_values=FLAGS) gflags.RegisterValidator('ecc_k', lambda x: x > 0, message='Reed Solomon boundaries', flag_values=FLAGS) gflags.MarkFlagAsRequired('password')
flags.DEFINE_boolean( 'experimental_capitalize_enums', False, 'Dangerous: attempt to rewrite enum values to be uppercase.') flags.DEFINE_enum('experimental_name_convention', util.Names.DEFAULT_NAME_CONVENTION, util.Names.NAME_CONVENTIONS, 'Dangerous: use a particular style for generated names.') flags.DEFINE_boolean('experimental_proto2_output', False, 'Dangerous: also output a proto2 message file.') FLAGS = flags.FLAGS flags.MarkFlagAsRequired('client_id') flags.MarkFlagAsRequired('client_secret') flags.RegisterValidator('infile', lambda i: not (i and FLAGS.discovery_url), 'Cannot specify both --infile and --discovery_url') flags.RegisterValidator('discovery_url', lambda i: not (i and FLAGS.infile), 'Cannot specify both --infile and --discovery_url') def _CopyLocalFile(filename): with contextlib.closing(open(filename, 'w')) as out: src_data = pkgutil.get_data('apitools.base.py', filename) if src_data is None: raise exceptions.GeneratedClientError('Could not find file %s' % filename) out.write(src_data) def _GetCodegenFromFlags(): """Create a codegen object from flags."""
dirpath = os.path.dirname(FLAGS.source_path) existing_dest_paths, gcs = auto_upload.PrepareToUpload( dirpath, FLAGS.destination_path) if gcs is None: return rename_template = None result = auto_upload.TryUploadFile(filename, dirpath, FLAGS.destination_path, existing_dest_paths, file_regex, rename_template, gcs, FLAGS.preserve_local, False) if result: uploaded_files.append(result) else: logging.error('Cannot upload %s. Must be a file or a directory.', FLAGS.source_path) return # Report results. for local_path, dest_path in uploaded_files: logging.info('Uploaded %s to %s', local_path, dest_path) if __name__ == '__main__': gflags.MarkFlagAsRequired('destination_path') gflags.MarkFlagAsRequired('source_path') gflags.RegisterValidator( 'source_path', lambda p: os.path.isfile(p) or os.path.isdir(p), '--source_path must point to a file or directory.') _Upload(sys.argv)
from makani.lib.python import os_util import numpy # Angle [rad] over which to blend the XFOIL parameters with the high # angle-of-attack parameters after stall. _STALL_BLENDING_ANGLE = 5.0 * numpy.pi / 180.0 # Full path to the XFOIL binary. _XFOIL_BIN = os.path.join(makani.HOME, 'third_party/xfoil/xfoil') # Name of temporary file that XFOIL will use to store airfoils. _TEMP_FILENAME = 'tmp_xfoil' gflags.DEFINE_string('airfoil_file', None, 'Name of the airfoil definition file.') gflags.RegisterValidator('airfoil_file', lambda x: not x or os.path.exists(x), 'airfoil_file does not exist.') gflags.DEFINE_boolean('display_log', False, 'Displays output of XFOIL.') gflags.DEFINE_boolean('display_input', False, 'Displays input to XFOIL.') gflags.DEFINE_string('json_output_file', None, 'Name of output JSON file.') gflags.RegisterValidator('json_output_file', lambda f: f and os.path.basename(f), 'json_output_file mush have a valid file name.') flag_types.DEFINE_linspace('flap_deflections_deg', '0.0, 0.0, 1', 'Linspace range of flap deflections [deg].') flag_types.DEFINE_linspace('alphas_deg', '-10.0, 10.0, 20', 'Linspace range of angles-of-attack [deg].') # TODO: Support 5 digit NACA airfoils. This requires a
from multiprocessing import Process import socket from subprocess import Popen, PIPE import sys import time gflags.DEFINE_integer("loglevel", 20, "The level for logging. 20 for INFO and 10 for DEBUG.") gflags.DEFINE_string( "launch", "local", "The launch mode. See mincepie.launcher.launch() for details.") gflags.DEFINE_integer( "num_clients", 1, "The number of clients. Does not apply in the case of MPI.") gflags.RegisterValidator('num_clients', lambda x: x > 0, message='--num_clients must be positive.') # slurm flags gflags.DEFINE_string("slurm_shebang", "#!/bin/bash", "The shebang of the slurm batch script") gflags.DEFINE_string("slurm_python_bin", "python", "The command to call python") gflags.DEFINE_string("sbatch_bin", "sbatch", "The command to call sbatch") gflags.DEFINE_string("scancel_bin", "scancel", "The command to call scancel") gflags.DEFINE_multistring("sbatch_args", [], "The sbatch arguments") # easy access to FLAGS FLAGS = gflags.FLAGS def process_argv(argv): """processes the arguments using gflags
''' import cPickle as pickle import cProfile import gflags import logging from iceberk import mpi, visiondata, pipeline, classifier, datasets, mathutil from iceberk.experimental import pinker import numpy as np import os import sys gflags.DEFINE_string("root", "", "The root to the cifar dataset (python format)") gflags.RegisterValidator('root', lambda x: x != "", message='--root must be provided.') gflags.DEFINE_string( "output_dir", ".", "The output directory that stores dumped feature and" "classifier files.") gflags.DEFINE_string("model_file", "conv.pickle", "The filename to output the CNN model.") gflags.DEFINE_string("feature_file", "cnn_features", "The filename to output the features.") gflags.DEFINE_string("svm_file", "svm.pickle", "The filename to output the trained svm parameters.") gflags.DEFINE_string( "profile_file", "", "If set, do cProfile analysis, and output the result" "to the filename given by the flag.") gflags.DEFINE_integer("patch", 0, "")
import gflags import pandas as pd import numpy as np from market import market from portfolio import portfolio from simulations_code import simulate gflags.DEFINE_multi_int('hour', 24, 'Hours in between market') gflags.DEFINE_float( 'min_percentage_change', 0.1, "Minimum variation in 'balance' needed to place an order." "1 is 100%") gflags.DEFINE_string('state_csv', None, "path to csv containing a 'state'") FLAGS = gflags.FLAGS gflags.RegisterValidator('min_percentage_change', lambda x: x >= 0, 'Should be positive or 0') #gflags.RegisterValidator('state_csv', os.path.isfile) if __name__ == "__main__": try: argv = FLAGS(sys.argv) except gflags.FlagsError as e: print "%s\nUsage: %s ARGS\n%s" % (e, sys.argv[0], FLAGS) sys.exit(1) print '*' * 80 print 'FLAGS.simulating:', FLAGS.simulating # currently we have only XRP in bittrex, start a portfolio with 'desired' state given only by 'XRP' and 'ETH' desired_state = portfolio.state_from_currencies([ 'ADA', 'TRIG', 'OK', 'RISE', 'IOP', 'NAV', 'MONA', 'EMC2', 'ADX', 'VTC', 'MCO', 'XVG', 'SYS', 'XLM', 'KMD', 'TKN'
for output in outputs if output['sim_success'] == success_val ], plot_style) pylab.xlabel('Wind speed [m/s]') pylab.ylabel('Joystick throttle') pylab.ylim([0.0, 1.1]) pylab.legend(['successful simulations', 'crashed simulations'], loc='lower right') pylab.savefig(FLAGS.output_dir + '/sim_success_param_space.svg') # Copy HTML file that displays the charts to the output directory. dashboard_file = os.path.join( makani.HOME, 'analysis/power_curve/power_curve_dashboard.html') final_output_file = os.path.join(FLAGS.output_dir, 'index.html') shutil.copyfile(dashboard_file, final_output_file) logging.info('Output may be viewed at file://%s.', os.path.abspath(final_output_file)) def main(argv): client_base.InitMain(argv) client = PowerCurveSimClient() client.Run() if __name__ == '__main__': gflags.RegisterValidator( 'output_dir', lambda o: not os.path.exists(o) or os.path.isdir(o), '--output_dir cannot refer to an existing, non-directory object.') main(sys.argv)