def read_params(args):
parser = ArgumentParser(description= "GraPhlAn "+__version__+" ("+__date__+") "
"AUTHORS: "+__author__)
arg = parser.add_argument
arg('intree', type=str, default = None, metavar='input_tree',
help = "the input tree in PhyloXML format " )
arg('outimg', type=str, default = None, metavar='output_image',
help = "the output image, the format is guessed from the extension "
"unless --format is given. Available file formats are: png, "
"pdf, ps, eps, svg" )
arg('--format', choices=['png','pdf','ps','eps','svg'], default=None,
type = str, metavar=['output_image_format'],
help = "set the format of the output image (default none meaning that "
"the format is guessed from the output file extension)")
arg('--warnings', default=1, type=int,
help = "set whether warning messages should be reported or not (default 1)")
arg('--positions', default=0, type=int,
help = "set whether the absolute position of the points should be reported on "
"the standard output. The two cohordinates are r and theta")
arg('--dpi', default=72, type=int, metavar='image_dpi',
help = "the dpi of the output image for non vectorial formats")
arg('--size', default=7.0, type=float, metavar='image_size',
help = "the size of the output image (in inches, default 7.0)")
arg('--pad', default=0.5, type=float, metavar='pad_in',
help = "the distance between the most external graphical element and "
"the border of the image")
arg( '-v','--version', action='version', version="GraPhlAn version "+__version__+" ("+__date__+")",
help="Prints the current GraPhlAn version and exit" )
return vars(parser.parse_args())
def main():
parser = ArgumentParser()
parser_with_options = set_options(parser)
args = parser_with_options.parse_args()
arguments = vars(args)
if 'help' in arguments:
parser.print_help()
else:
config = Config()
config.format = arguments['output']
config.total_lists = arguments['lists']
config.total_words = arguments['number']
if arguments['file'] is None:
current_path = os.path.abspath(
inspect.getfile(inspect.currentframe())
)
dir = os.path.dirname(current_path)
config.file_path = os.path.join(dir, config.internal_words_file)
else:
config.file_path = arguments['file']
words = generate(config)
if words:
print(words)
exit(0)
def rpt_getnew(args):
parser = ArgumentParser(prog='mx rpt-getnew')
_add_common_args(parser)
args = _check_verbose(parser.parse_args(args))
if not os.path.exists(args.logdir):
_safe_mkdir(args.logdir)
gatedirs = get_gate_dirs(gate_url, _is_result_dir, _strip_dotslash)
localdirs = get_local_dirs(args.logdir)
for gatedir in gatedirs:
gate_url_dir = join(gate_url, gatedir)
local_dir = join(args.logdir, gatedir)
if not gatedir in localdirs:
if args.verbose:
print 'processing: ' + gatedir
f = urllib.urlopen(join(gate_url_dir, 'testlog'))
testlog = f.read()
_safe_mkdir(local_dir)
with open(join(local_dir, 'testlog'), 'w') as t:
t.write(testlog)
# if True:
# get test results
gate_url_test = join(gate_url_dir, 'test')
local_dir_test = join(local_dir, 'test')
_safe_mkdir(local_dir_test)
pkgs = get_gate_dirs(gate_url_test, _is_package_dir, _strip_slash)
for pkg in pkgs:
if args.verbose:
print ' processing package: ' + pkg
gate_url_test_pkg = join(gate_url_test, pkg)
local_dir_test_pkg = join(local_dir_test, pkg)
_copy_files(gate_url_test_pkg, local_dir_test_pkg, pkg)
def __init__(self):
ArgumentParser.__init__(
self, prog="see", description="Mark episodes as SEEN", epilog="example: see lost.s01* lost.s02*"
)
self.add_argument(
"filters", metavar="EPISODE", nargs="+", default=[""], help="episode name or filter, ex: lost.s01e0*"
)
def rpt_install_status(args):
parser = ArgumentParser(prog='mx rpt-install-status')
parser.add_argument('--detail', action='store_true', help='display package status')
parser.add_argument('--displaymode', action='store', default='latest', help='display mode: all | latest')
parser.add_argument('--failed', action='store_true', help='list packages that failed to install')
parser.add_argument('--ok-any', action='store_true', help='treat as OK if a package ever installed')
_add_pattern_arg(parser)
_add_common_args(parser)
args = _check_verbose(parser.parse_args(args))
pkgtable = _build_pkgtable(_get_results(args.logdir))
pkgnames = []
for pkgname, occurrences in pkgtable.iteritems():
if re.search(args.pattern, pkgname) is None:
continue
status = _check_any_ok(occurrences, args.ok_any)
if args.failed:
if not status:
pkgnames.append(pkgname)
else:
if status:
pkgnames.append(pkgname)
pkgnames.sort()
for pkgname in pkgnames:
print pkgname
if args.detail:
if args.displaymode == 'all':
occurrences = pkgtable[pkgname]
for occurrence in occurrences:
print " ${0}".format(str(occurrence))
else:
print " ${0}".format(str(occurrences[0]))
def rpt_list_testdates(args):
parser = ArgumentParser(prog='mx rpt-list-testdates')
_add_common_args(parser)
parser.add_argument('--printdir', action='store_true', help='print directory containing tests')
_add_pattern_arg(parser)
args = _check_verbose(parser.parse_args(args))
fastr = dict()
local_dirs = get_local_dirs(args.logdir)
for local_dir in local_dirs:
resultInfo = ResultInfo(local_dir)
result_outputs = _gather_test_outputs(join(args.logdir, local_dir, "test"))
for pkg, _ in result_outputs.iteritems():
if re.search(args.pattern, pkg) is None:
continue
if not fastr.has_key(pkg):
testdates = []
fastr[pkg] = testdates
else:
testdates = fastr[pkg]
testdates.append(resultInfo)
for pkg, testdates in fastr.iteritems():
sortedList = sorted(testdates, reverse=True)
print pkg
for resultInfo in sortedList:
if args.printdir:
print ' ' + join(args.logdir, resultInfo.localdir)
else:
print ' ' + str(resultInfo.date)
def rpt_compare(args):
'''
Analyze package test results by comparing test output with GnuR output.
Uses either a specific directory, i.e. the 'test' subdirectory of the --testdir argument
or (default) the latest downloaded results from the --logdir directory
Return 0 if passed, non-zero if failed
'''
parser = ArgumentParser(prog='mx rpt-compare')
_add_common_args(parser)
parser.add_argument('--testdir', action='store', help='specific dir containing fastr results')
parser.add_argument('--pkg', action='store', help='pkg to compare')
parser.add_argument('--diff', action='store_true', help='execute given diff program on differing outputs')
parser.add_argument('--difftool', action='store', help='diff tool', default='diff')
_add_pattern_arg(parser)
args = _check_verbose(parser.parse_args(args))
if args.pkg:
# backwards compatibility
args.pattern = args.pkg
gnur = _gather_test_outputs(join(os.getcwd(), "test_gnur"))
if args.testdir:
fastr = _gather_test_outputs(join(args.testdir, "test"))
else:
fastr = _get_test_outputs(_gather_all_test_outputs(args.logdir))
rdict = _rpt_compare_pkgs(gnur, fastr, args.verbose, args.pattern, args.diff, args.difftool)
for _, rc in rdict.iteritems():
if rc == 1:
return 1
return 0
def cli(args=sys.argv[1:]):
parser = ArgumentParser()
parser.add_argument('-o', '--output-directory', dest='outdir',
default=here, help="Directory to save runtime data.")
parser.add_argument('-i', '--input-directory', dest='indir',
default=here, help="Directory from which to read current runtime data.")
parser.add_argument('-p', '--platforms', default=None,
help="Comma separated list of platforms from which to generate data.")
parser.add_argument('-s', '--suite', dest='suite', default=None,
help="Suite for which to generate data.")
args = parser.parse_args(args)
if not args.suite:
raise ValueError("Must specify suite with the -u argument")
if ',' in args.suite:
raise ValueError("Passing multiple suites is not supported")
if args.platforms:
args.platforms = args.platforms.split(',')
data = query_activedata(args.suite, args.platforms)
write_runtimes(data, args.suite, indir=args.indir, outdir=args.outdir)
def parseargs():
parser = ArgumentParser(description='Writes some data on mutliple autodetected USB devices. Be careful, they will be formatted!')
parser.add_argument('data',help="The upper most folder which need to be transferred on all usb Sticks")
parser.add_argument('-l','--loop',action='store_true',help='Activates the loop, which will then let the program wait for any new devices plugged in. Abort by CRTL+C')
parser.add_argument('-f','--format',required=False,choices=["ntfs","fat32"],default=formats[0],help="Formats the sticks, default format %(default)s")
parser.add_argument('-fl','--formatlabel',required=False,type=str,help="Formats the Devices with this Label")
return parser.parse_args()
def main(argv=None):
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
parser = ArgumentParser(
description="PCAWG Report Generator Gathering Counts", formatter_class=RawDescriptionHelpFormatter
)
parser.add_argument(
"-m", "--metadata_dir", dest="metadata_dir", help="Directory containing metadata manifest files", required=True
)
args = parser.parse_args()
metadata_dir = args.metadata_dir # this dir contains gnos manifest files, will also host all reports
if not os.path.isdir(metadata_dir): # TODO: should add more directory name check to make sure it's right
sys.exit("Error: specified metadata directory does not exist!")
report_name = re.sub(r"^pc_report-", "", os.path.basename(__file__))
report_name = re.sub(r"\.py$", "", report_name)
generate_report(metadata_dir, report_name)
return 0
def main():
opt_parser = ArgumentParser(
description="Manage annotation databases of region_analysis.",
prog="region_analysis_db.py")
subparsers = opt_parser.add_subparsers(title="Subcommands",
help="additional help")
# list parser.
parser_list = subparsers.add_parser("list", help="List genomes installed \
in database")
parser_list.set_defaults(func=listgn)
# install parser.
parser_install = subparsers.add_parser("install",
help="Install genome from tar.gz \
package file")
parser_install.add_argument("pkg", help="Package file(.tar.gz) to install",
type=str)
parser_install.set_defaults(func=install)
parser_install.add_argument(
"-y", "--yes", help="Say yes to all prompted questions",
action="store_true")
# remove parser.
parser_remove = subparsers.add_parser("remove",
help="Remove genome from database")
parser_remove.add_argument("gn", help="Name of genome to be \
removed(e.g. hg19)", type=str)
parser_remove.set_defaults(func=remove)
parser_remove.add_argument(
"-y", "--yes", help="Say yes to all prompted questions",
action="store_true")
args = opt_parser.parse_args()
args.func(args)
def main():
"""
Parse arguments, set configuration values, then start the broker
"""
parser = ArgumentParser(description="Crawl frontier worker.")
parser.add_argument(
'--config', type=str,
help='Settings module name, should be accessible by import.')
parser.add_argument(
'--address', type=str,
help='Hostname, IP address or Wildcard * to bind. Default is 127.0.0.1'
'. When binding to wildcard it defaults to IPv4.')
parser.add_argument(
'--log-level', '-L', type=str, default='INFO',
help='Log level, for ex. DEBUG, INFO, WARN, ERROR, FATAL. Default is'
' INFO.')
parser.add_argument(
'--port', type=int,
help='Base port number, server will bind to 6 ports starting from base'
'. Default is 5550')
args = parser.parse_args()
settings = Settings(module=args.config)
address = args.address if args.address else settings.get("ZMQ_ADDRESS")
port = args.port if args.port else settings.get("ZMQ_BASE_PORT")
server = Server(address, port)
server.logger.setLevel(args.log_level)
server.start()
def parse_args():
parser = ArgumentParser()
parser.add_argument('-v', '--version', action='version', version='0.2')
parser.add_argument('-c', '--configuration', default=expanduser("~") + '/.stools/configuration.cfg')
parser.add_argument('-e', '--execute', nargs='*')
parser.add_argument('-l', '--log', default='ERROR')
return parser.parse_args()
def parse_args():
"""parse command-line arguments"""
parser = ArgumentParser(
description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter
)
parser.add_argument(
'--infile', required=True,
help='Input I3 filename'
)
parser.add_argument(
'--outdir', default=None,
help='Output directory'
)
#parser.add_argument(
# '--n-per-file', type=int, required=True,
# help='Maximum number of events per output file'
#)
parser.add_argument(
'--n-total', type=int, default=None,
help='''Total events to split out into sub-files; if not specified,
take all (that pass --keep-criteria)'''
)
parser.add_argument(
'--keep-criteria', type=str, default=None,
help='''Criteria for choosing the event for splitting out; events that
fail to meet the criteria will not count towards n-total or n-per-file.
This will be evaluated where the `frame` variable is available to
retrieve info from.'''
)
return parser.parse_args()
def run(cls):
parser = ArgumentParser(
description=("The theme development utility. "
"Includes three modes: "
"one for serving a theme compiled on-the-fly, "
"the other for compiling statically a theme "
"and the latter to dump URLs to files")
)
subparsers = parser.add_subparsers(
title="Commands",
description="Available commands (modes of operation)"
)
for key, target in cls.commands.items():
if target is None:
target = cls
else:
target = getattr(cls, target)
subparser = subparsers.add_parser(
key,
description=target.__doc__,
help=target.__doc__.splitlines()[0]
)
target.setup_parser(subparser)
subparser.set_defaults(target=target)
args = parser.parse_args()
if hasattr(args, 'target'):
sys.exit(args.target.main(args))
else:
parser.print_usage()
sys.exit(-1)
def base_multinode_parser():
"""Creates a parser with arguments specific to sending HTTP requests
to multiple REST APIs.
Returns:
{ArgumentParser}: Base parser with default HTTP args
"""
base_parser = ArgumentParser(add_help=False)
base_parser.add_argument(
'urls',
type=str,
nargs='+',
help="The URLs of the validator's REST APIs of interest, separated by"
" commas or spaces. (no default)")
base_parser.add_argument(
'--users',
type=str,
action='append',
metavar='USERNAME[:PASSWORD]',
help='Specify the users to authorize requests, in the same order as '
'the URLs, separate by commas. Passing empty strings between commas '
'is supported.')
return base_parser
def main():
set_stdout_encoding()
parser = ArgumentParser(
formatter_class=ArgumentDefaultsHelpFormatter,
description='Convert text file to communication',
)
parser.set_defaults(annotation_level=AL_NONE)
parser.add_argument('text_path', type=str,
help='Input text file path (- for stdin)')
parser.add_argument('concrete_path', type=str,
help='Output concrete file path (- for stdout)')
add_annotation_level_argparse_argument(parser)
parser.add_argument('-l', '--loglevel', '--log-level',
help='Logging verbosity level threshold (to stderr)',
default='info')
concrete.version.add_argparse_argument(parser)
args = parser.parse_args()
logging.basicConfig(format='%(asctime)-15s %(levelname)s: %(message)s',
level=args.loglevel.upper())
# Won't work on Windows
text_path = '/dev/fd/0' if args.text_path == '-' else args.text_path
concrete_path = (
'/dev/fd/1' if args.concrete_path == '-' else args.concrete_path
)
annotation_level = args.annotation_level
with codecs.open(text_path, encoding='utf-8') as f:
comm = create_comm(text_path, f.read(),
annotation_level=annotation_level)
write_communication_to_file(comm, concrete_path)
def parse_options(args=None):
if args is None: # pragma: no cover
args = sys.argv[1:]
parser = ArgumentParser()
parser.add_argument(
'-i', '--incremental',
metavar='PATH',
help='trigger incremental crawl'
)
parser.add_argument(
'-o', '--output',
metavar='PATH',
default=DEFAULT_OUTPUT_PATH,
help='Override persisted data, [default=%(default)s]'
)
parser.add_argument(
'-v', '--verbose',
action='count',
dest='verbose',
help='set verbosity level',
default=0
)
parser.add_argument(
'crawls',
metavar='CRAWL',
nargs='*',
help='Sub-set of crawls to launch'
)
return parser.parse_args(args)
def main():
from argparse import ArgumentParser
parser = ArgumentParser(usage=usage)
parser.add_argument("-v", "--verbose", default=0, action="count", help="Increment test verbosity (can be used multiple times)")
parser.add_argument("-d", "--debug", action="store_true", default=False, help="Print debugging items")
parser.add_argument("-t", "--test", help="Run only the named test")
parser.add_argument('type', choices=['accdb', 'mdb'], help='Which type of file to test')
args = parser.parse_args()
DRIVERS = {
'accdb': 'Microsoft Access Driver (*.mdb, *.accdb)',
'mdb': 'Microsoft Access Driver (*.mdb)'
}
here = dirname(abspath(__file__))
src = join(here, 'empty.' + args.type)
dest = join(here, 'test.' + args.type)
shutil.copy(src, dest)
global CNXNSTRING
CNXNSTRING = 'DRIVER={%s};DBQ=%s;ExtendedAnsiSQL=1' % (DRIVERS[args.type], dest)
print(CNXNSTRING)
cnxn = pyodbc.connect(CNXNSTRING)
print_library_info(cnxn)
cnxn.close()
suite = load_tests(AccessTestCase, args.test)
testRunner = unittest.TextTestRunner(verbosity=args.verbose)
result = testRunner.run(suite)
def _make_basic_help_parser(include_deprecated=False):
"""Make an arg parser that's used only for printing basic help.
This prints help very similar to spark-submit itself. Runner args
are not included unless they are also spark-submit args (e.g. --py-files)
"""
help_parser = ArgumentParser(usage=_USAGE, description=_DESCRIPTION,
epilog=_BASIC_HELP_EPILOG, add_help=False)
_add_runner_alias_arg(help_parser)
for group_desc, opt_names in _SPARK_SUBMIT_ARG_GROUPS:
if group_desc is None:
parser_or_group = help_parser
else:
parser_or_group = help_parser.add_argument_group(group_desc)
for opt_name in opt_names:
_add_spark_submit_arg(parser_or_group, opt_name)
if group_desc is None:
_add_basic_args(help_parser)
_add_help_arg(help_parser)
if include_deprecated:
_add_deprecated_arg(help_parser)
return help_parser
def _get_args():
parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
description="Node Agent")
subparsers = parser.add_subparsers(dest="mode")
parser_cleanup = subparsers.add_parser('cleanup')
parser_cleanup.add_argument("session", help="Session Name")
parser_cleanup.add_argument("volume", help="Volume Name")
parser_cleanup.add_argument("tmpfilename", help="Temporary File Name")
parser_cleanup.add_argument("--debug", help="Debug", action="store_true")
parser_session_create = subparsers.add_parser('create')
parser_session_create.add_argument("session", help="Session Name")
parser_session_create.add_argument("volume", help="Volume Name")
parser_session_create.add_argument("brick", help="Brick Path")
parser_session_create.add_argument("time_to_update", help="Time to Update")
parser_session_create.add_argument("--reset-session-time",
help="Reset Session Time",
action="store_true")
parser_session_create.add_argument("--debug", help="Debug",
action="store_true")
parser_post = subparsers.add_parser('post')
parser_post.add_argument("session", help="Session Name")
parser_post.add_argument("volume", help="Volume Name")
parser_post.add_argument("brick", help="Brick Path")
parser_post.add_argument("--debug", help="Debug",
action="store_true")
parser_delete = subparsers.add_parser('delete')
parser_delete.add_argument("session", help="Session Name")
parser_delete.add_argument("volume", help="Volume Name")
parser_delete.add_argument("--debug", help="Debug",
action="store_true")
return parser.parse_args()
def make_parser(prog):
parser = ArgumentParser(prog)
parser.add_argument('--version', action='version', version='%(prog)s ' + VERSION)
command_parsers = parser.add_subparsers(metavar='command', dest='command')
command_parsers.required = True
command_search_parser = command_parsers.add_parser('search', help='search for items')
command_search_parser.add_argument('type', help='type of item to search for',
choices=['movie', 'person', 'character', 'company', 'keyword'])
command_search_parser.add_argument('key', help='title or name of item to search for')
command_search_parser.add_argument('-n', type=int, help='number of items to list')
command_search_parser.add_argument('--first', action='store_true', help='display only the first result')
command_search_parser.set_defaults(func=search_item)
command_get_parser = command_parsers.add_parser('get', help='retrieve information about an item')
command_get_parser.add_argument('type', help='type of item to retrieve',
choices=['movie', 'person', 'character', 'company', 'keyword'])
command_get_parser.add_argument('key', help='IMDb id (or keyword name) of item to retrieve')
command_get_parser.add_argument('-n', type=int, help='number of movies to list (only for keywords)')
command_get_parser.set_defaults(func=get_item)
command_top_parser = command_parsers.add_parser('top', help='get top ranked movies')
command_top_parser.add_argument('-n', type=int, help='number of movies to list')
command_top_parser.add_argument('--first', action='store_true', help='display only the first result')
command_top_parser.set_defaults(func=get_top_movies)
command_bottom_parser = command_parsers.add_parser('bottom', help='get bottom ranked movies')
command_bottom_parser.add_argument('-n', type=int, help='number of movies to list')
command_bottom_parser.add_argument('--first', action='store_true', help='display only the first result')
command_bottom_parser.set_defaults(func=get_bottom_movies)
return parser
def main():
p = ArgumentParser(description='Plots spectral transmission data from filter datasheets')
p.add_argument('--wlnm', help='START STOP STEP wavelength in nm', nargs=3, default=(200., 1200., 0.1), type=float)
p.add_argument('--path', help='path to HDF5 data')
p.add_argument('-a', '--altkm', help='observer altitude (km)', type=float, default=0.)
p.add_argument('--zenang', help='zenith angle (deg)', type=float, default=0.)
p = p.parse_args()
inpath = Path(p.path).expanduser() if p.path else R / 'gridaurora/precompute'
flist = ['BG3transmittance.h5', 'NE01transmittance.h5',
'Wratten32transmittance.h5', 'Wratten21transmittance.h5',
'HoyaV10transmittance.h5']
flist = [inpath/f for f in flist]
windFN = inpath/'ixonWindowT.h5'
qeFN = inpath/'emccdQE.h5'
# %%
Ts = []
for f in flist:
T = selftest(f, windFN, qeFN, p.wlnm, p.altkm, p.zenang)
Ts.append(T)
plotT(T, p.wlnm)
# %%
comparefilters(Ts)
show()
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 parse_args():
parser = ArgumentParser()
parser.add_argument(
'--force-update-mpt',
action='store_true',
help='Update MyPyTutor even if this would not normally be required',
)
parser.add_argument(
'--force-update-tutorials',
action='store_true',
help='Update tutorials even if this would not normally be required',
)
parser.add_argument(
'--no-gui',
action='store_true',
help='Run the installer without using a GUI',
)
parser.add_argument(
'--version',
'--version',
action='store_true',
help='Print the version and then terminate',
)
return parser.parse_args()
def main():
parser = ArgumentParser()
parser.add_argument('file', action='store')
args = parser.parse_args()
print_left_right( "left.txt", "right.txt", open(args.file).readlines() )
def query_main(graph, default_index):
"""
Run a query.
"""
parser = ArgumentParser()
parser.add_argument("-i", "--index", default=default_index)
parser.add_argument("-q", "--query", default='{"match_all": {}}')
parser.add_argument("-f", "--flat", action="store_true")
args = parser.parse_args()
try:
query = loads(args.query)
except Exception:
parser.error("query must be valid json")
response = graph.elasticsearch_client.search(
index=args.index,
body=dict(query=query),
)
if args.flat:
return response["hits"]["hits"]
else:
return response
def parseArgs():
parser = ArgumentParser(
description = 'Convert Entrez Gene Homo_sapiens.xml to python dictionary representation')
parser.add_argument(
'--Hsxml', metavar = 'HSXML', type = file, required = True,
help = 'Name of Homo_sapiens.xml file - include a date reference for download for example')
return parser.parse_args()
def __init__(self):
ArgumentParser.__init__(
self, prog="format", description="print episodes with given formats", epilog="example: format lost*"
)
self.add_argument(
"filters", metavar="EPISODE", nargs="*", default=["*"], help="episode name or filter, ex: lost.s01e0*"
)
def _make_arg_parser():
# this parser is never used for help messages, but
# will show usage on error
parser = ArgumentParser(usage=_USAGE, add_help=False)
# add positional arguments
parser.add_argument(dest='script_or_jar', nargs='?')
parser.add_argument(dest='args', nargs='*')
_add_basic_args(parser)
_add_runner_alias_arg(parser)
_add_help_arg(parser)
_add_deprecated_arg(parser)
# add runner opts
runner_opt_names = set(_RUNNER_OPTS) - set(_HARD_CODED_OPTS)
_add_runner_args(parser, opt_names=runner_opt_names)
# add spark-specific opts (without colliding with runner opts)
for opt_name, switch in _SPARK_SUBMIT_SWITCHES.items():
if opt_name in _RUNNER_OPTS and switch not in _SWITCH_ALIASES:
continue
_add_spark_submit_arg(parser, opt_name)
return parser
mode="constant", constant_values=0)
pred_slots.append(pred_padded)
true_slot = np.array((list(zip(*batch))[2]))
true_length = np.array((list(zip(*batch))[1]))
true_slot = true_slot[:, :slot_pred_length]
slot_acc = accuracy_score(true_slot, decoder_prediction, true_length)
slot_accs.append(slot_acc)
pred_slots_a = np.vstack(pred_slots)
true_slots_a = np.array(list(zip(*index_test))[2])[:pred_slots_a.shape[0]]
f1_score=f1_for_sequence_batch(true_slots_a, pred_slots_a)
print("Slot accuracy for epoch {}: {:.3f}".format(epoch, np.average(slot_accs)*100))
print("Slot F1 score for epoch {}: {:.3f}".format(epoch,f1_score*100 ))
if (f1_score >best_f1_score):
best_ep=epoch
best_sl_acc=np.average(slot_accs)
best_f1_score=f1_score
print('\nBEST RESULT: epoch {}, valid accurasy {:.3f}, best test F1 score {:.3f}'.format(best_ep,best_sl_acc*100,best_f1_score*100))
sess.close()
with open('results.txt', 'a') as outfile:
outfile.write('For Folder:'+str(fold)+' using '+str(cell)+' cell, BEST RESULT: epoch '+ str(best_ep)+ ', valid score {:.3f}, best test F1 score {:.3f}'.format( best_sl_acc*100,best_f1_score*100)+'\n')
if __name__ == '__main__':
parser = ArgumentParser(description='Provide RNN Cell. Use either BasicRNN, or LSTM as arguments.')
# parser.add_argument('N', type=int,help="Problem size", metavar="N")
parser.add_argument("Model", default='BasicRNN',type=str,
help="BasicRNN or LSTM algorithm")
args = parser.parse_args()
cell=args.Model
train()
# -*- coding: utf-8 -*-
"""
Created on Sun Nov 4 20:28:33 2018
@author: mark
"""
import cv2
import numpy as np
from argparse import ArgumentParser
from to_read_pfm import readPFM
parser = ArgumentParser();
parser.add_argument("flow_path", help="where to get the optical flow");
parser.add_argument("img0_path", help="where to get the original image0 as base");
parser.add_argument("-VL", help="optical vector length", dest="length", type=int, default=1);
parser.add_argument("-LW", help="line width", dest="line_width", type=int, default=2);
parser.add_argument("-SY", help="show an optical flow between how many rows", dest="show_Y", type=int, default=50);
parser.add_argument("-SX", help="show an optical flow between how many columns", dest="show_X", type=int, default=50);
parser.add_argument("-ON", help="output name", dest="output_name", default='output.jpg');
args = parser.parse_args();
error_flag = False;
if '.pfm' in args.flow_path:
flow, scale = readPFM(args.flow_path);#assume y direction is in dimension 0, and x in dimension 1.
elif '.npy' in args.flow_path:
flow = np.load(args.flow_path);
else:
def add_arguments(
cls,
parser: ArgumentParser,
who: str = "",
desc: str = ".",
expert: bool = False,
defaults: bool = True,
):
"""Add arguments for KgtkValue option processing.
When "who" is not empty, it prefixes the options, destinations, and
help messages. This facilitates constructing command lines with
multiple sets of KGTKValue options, such as for different input files.
"""
prefix1: str = "--" # The command line argument prefix.
prefix2: str = "" # The destination name prefix.
prefix3: str = "" # The help message prefix.
if len(who) > 0:
prefix1 = "--" + who + "-"
prefix2 = who + "_"
prefix3 = who + ": "
# This helper function makes it easy to suppress options from
# The help message. The options are still there, and initialize
# what they need to initialize.
def h(msg: str) -> str:
if expert:
return msg
else:
return SUPPRESS
# This helper function decices whether or not to include defaults
# in argument declarations. If we plan to make arguments with
# prefixes and fallbacks, the fallbacks (the ones without prefixes)
# should get defaults value, while the prefixed arguments should
# not get defaults.
#
# Note: In obscure circumstances (EnumNameAction, I'm looking at you),
# explicitly setting "default=None" may fail, whereas omitting the
# "default=" phrase succeeds.
#
# TODO: continue researching these issues.
def d(default: typing.Any) -> typing.Mapping[str, typing.Any]:
if defaults:
return {"default": default}
else:
return {}
vgroup = parser.add_argument_group(
h(prefix3 + "Data value parsing"),
h("Options controlling the parsing and processing of KGTK data values"
+ desc))
vgroup.add_argument(
prefix1 + "additional-language-codes",
dest=prefix2 + "additional_language_codes",
help=h(prefix3 +
"Additional language codes. (default=use internal list)."),
nargs="*",
default=None)
vgroup.add_argument(
prefix1 + "allow-lax-qnodes",
dest=prefix2 + "allow_lax_qnodes",
help=
h(prefix3 +
"Allow qnode suffixes in quantities to include alphas and dash as well as digits. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-language-suffixes",
dest=prefix2 + "allow_language_suffixes",
help=
h(prefix3 +
"Allow language identifier suffixes starting with a dash. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-lax-strings",
dest=prefix2 + "allow_lax_strings",
help=
h(prefix3 +
"Do not check if double quotes are backslashed inside strings. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-lax-lq-strings",
dest=prefix2 + "allow_lax_lq_strings",
help=
h(prefix3 +
"Do not check if single quotes are backslashed inside language qualified strings. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-wikidata-lq-strings",
dest=prefix2 + "allow_wikidata_lq_strings",
help=h(
prefix3 +
"Allow Wikidata language qualifiers. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "require-iso8601-extended",
dest=prefix2 + "require_iso8601_extended",
help=
h(prefix3 +
"Require colon(:) and hyphen(-) in dates and times. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "force-iso8601-extended",
dest=prefix2 + "force_iso8601_extended",
help=
h(prefix3 +
"Force colon (:) and hyphen(-) in dates and times. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-month-or-day-zero",
dest=prefix2 + "allow_month_or_day_zero",
help=h(prefix3 +
"Allow month or day zero in dates. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "repair-month-or-day-zero",
dest=prefix2 + "repair_month_or_day_zero",
help=h(
prefix3 +
"Repair month or day zero in dates. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-end-of-day",
dest=prefix2 + "allow_end_of_day",
help=
h(prefix3 +
"Allow 24:00:00 to represent the end of the day. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=cls.DEFAULT_ALLOW_END_OF_DAY))
vgroup.add_argument(
prefix1 + "minimum-valid-year",
dest=prefix2 + "minimum_valid_year",
help=h(prefix3 +
"The minimum valid year in dates. (default=%(default)d)."),
type=int,
**d(default=cls.MINIMUM_VALID_YEAR))
vgroup.add_argument(
prefix1 + "clamp-minimum-year",
dest=prefix2 + "clamp_minimum_year",
help=h(prefix3 +
"Clamp years at the minimum value. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "ignore-minimum-year",
dest=prefix2 + "ignore_minimum_year",
help=h(
prefix3 +
"Ignore the minimum year constraint. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "maximum-valid-year",
dest=prefix2 + "maximum_valid_year",
help=h(prefix3 +
"The maximum valid year in dates. (default=%(default)d)."),
type=int,
**d(default=cls.MAXIMUM_VALID_YEAR))
vgroup.add_argument(
prefix1 + "clamp-maximum-year",
dest=prefix2 + "clamp_maximum_year",
help=h(prefix3 +
"Clamp years at the maximum value. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "ignore-maximum-year",
dest=prefix2 + "ignore_maximum_year",
help=h(
prefix3 +
"Ignore the maximum year constraint. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "validate-fromisoformat",
dest=prefix2 + "validate_fromisoformat",
help=
h(prefix3 +
"Validate that datetim.fromisoformat(...) can parse this date and time. "
+ "This checks that the year/month/day combination is valid. " +
"The year must be in the range 1..9999, inclusive. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-lax-coordinates",
dest=prefix2 + "allow_lax_coordinates",
help=
h(prefix3 +
"Allow coordinates using scientific notation. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "repair-lax-coordinates",
dest=prefix2 + "repair_lax_coordinates",
help=
h(prefix3 +
"Allow coordinates using scientific notation. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "allow-out-of-range-coordinates",
dest=prefix2 + "allow_out_of_range_coordinates",
help=
h(prefix3 +
"Allow coordinates that don't make sense. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "minimum-valid-lat",
dest=prefix2 + "minimum_valid_lat",
help=h(prefix3 +
"The minimum valid latitude. (default=%(default)f)."),
type=int,
**d(default=cls.MINIMUM_VALID_LAT))
vgroup.add_argument(
prefix1 + "clamp-minimum-lat",
dest=prefix2 + "clamp_minimum_lat",
help=h(
prefix3 +
"Clamp latitudes at the minimum value. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "maximum-valid-lat",
dest=prefix2 + "maximum_valid_lat",
help=h(prefix3 +
"The maximum valid latitude. (default=%(default)f)."),
type=int,
**d(default=cls.MAXIMUM_VALID_LAT))
vgroup.add_argument(
prefix1 + "clamp-maximum-lat",
dest=prefix2 + "clamp_maximum_lat",
help=h(
prefix3 +
"Clamp latitudes at the maximum value. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "minimum-valid-lon",
dest=prefix2 + "minimum_valid_lon",
help=h(prefix3 +
"The minimum valid longitude. (default=%(default)f)."),
type=int,
**d(default=cls.MINIMUM_VALID_LON))
vgroup.add_argument(
prefix1 + "clamp-minimum-lon",
dest=prefix2 + "clamp_minimum_lon",
help=h(
prefix3 +
"Clamp longitudes at the minimum value. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "maximum-valid-lon",
dest=prefix2 + "maximum_valid_lon",
help=h(prefix3 +
"The maximum valid longitude. (default=%(default)f)."),
type=int,
**d(default=cls.MAXIMUM_VALID_LON))
vgroup.add_argument(
prefix1 + "clamp-maximum-lon",
dest=prefix2 + "clamp_maximum_lon",
help=h(
prefix3 +
"Clamp longitudes at the maximum value. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "modulo-repair-lon",
dest=prefix2 + "modulo_repair_lon",
help=h(prefix3 +
"Wrap longitude to (-180.0,180.0]. (default=%(default)s)."),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
vgroup.add_argument(
prefix1 + "escape-list-separators",
dest=prefix2 + "escape_list_separators",
help=
h(prefix3 +
"Escape all list separators instead of splitting on them. (default=%(default)s)."
),
type=optional_bool,
nargs='?',
const=True,
**d(default=False))
#!/usr/bin/env python
import numpy as np
from pyproj import Proj
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from netCDF4 import Dataset as CDF
# set up the argument parser
parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
parser.description = "Create CDO-compliant grid description"
parser.add_argument("FILE", nargs="*")
parser.add_argument("-g",
"--grid_spacing",
dest="grid_spacing",
type=float,
help="use X m grid spacing",
default=1800)
parser.add_argument(
"-f",
"--format",
dest="fileformat",
type=str.upper,
choices=["NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_CLASSIC", "NETCDF3_64BIT"],
help="file format out output file",
default="netcdf4",
)
options = parser.parse_args()
args = options.FILE
grid_spacing = options.grid_spacing # convert
def main(argv = None):
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
try:
parser = ArgumentParser()
parser.add_argument('--config-file', help = "Path to the config file", required = True)
parser.add_argument('--start-samplerd', help = "start samplerd ldmsd",
action = "store_true")
parser.add_argument('--kill-samplerd', action = "store_true",
help = "kill samplerd ldmsd")
parser.add_argument('--start-agg', action = "store_true",
help = "start agg ldmsd")
parser.add_argument('--kill-agg', action = "store_true",
help = "kill agg ldmsd")
parser.add_argument('--kill-9-samplerd', action = "store_true",
help = "kill 9 samplerd ldmsd")
parser.add_argument('--kill-9-agg', action = "store_true",
help = "kill 9 agg ldmsd")
parser.add_argument('--remove-samplerd-files', action = "store_true",
help = "Remove the samplerd's log and sock files")
parser.add_argument('--remove-agg-files', action = "store_true",
help = "Remove the aggregataor(s)'s log and sock files")
parser.add_argument('--check-samplerd', action = "store_true",
help = "Check samplerd ldmsd running")
parser.add_argument('--check-agg', action = "store_true",
help = "Check agg ldmsd running")
parser.add_argument('--samplerd-pid', help = "Get the samplerd PIDs",
action = "store_true")
parser.add_argument('--agg-pid', help = "Get the agg PIDs",
action = "store_true")
args = parser.parse_args()
cfg = get_var_from_file(module_name = "cfg", filepath = args.config_file)
if args.start_samplerd:
print "start samplerd.."
start_ldmsd(hosts = cfg.SAMPLERD_HOSTS,
xprt = cfg.SAMPLERD_XPRT, port = cfg.SAMPLERD_PORT,
log = cfg.SAMPLERD_LOG, sockname = cfg.SAMPLERD_SOCK)
if args.start_agg:
print "start agg.."
start_ldmsd(hosts = cfg.AGG_HOSTS, xprt = cfg.AGG_XPRT, port = cfg.AGG_PORT,
log = cfg.AGG_LOG, sockname = cfg.AGG_SOCK)
if args.kill_samplerd:
print "kill samplerd.."
kill_ldmsd(hosts = cfg.SAMPLERD_HOSTS, xprt = cfg.SAMPLERD_XPRT,
port = cfg.SAMPLERD_PORT)
if args.kill_agg:
print "kill agg.."
kill_ldmsd(hosts = cfg.AGG_HOSTS, xprt = cfg.AGG_XPRT, port = cfg.AGG_PORT)
if args.kill_9_samplerd:
print "kill 9 samplerd.."
kill_9_ldmsd(hosts = cfg.SAMPLERD_HOSTS, xprt = cfg.SAMPLERD_XPRT,
port = cfg.SAMPLERD_PORT)
if args.kill_9_agg:
print "kill 9 agg.."
kill_9_ldmsd(hosts = cfg.AGG_HOSTS, xprt = cfg.AGG_XPRT, port = cfg.AGG_PORT)
if args.remove_samplerd_files:
print "Removing the files of samplerd"
remove_file(cfg.SAMPLERD_HOSTS, cfg.SAMPLERD_LOG)
remove_file(cfg.SAMPLERD_HOSTS, cfg.SAMPLERD_SOCK)
if args.remove_agg_files:
print "Removing the files of aggregators"
remove_file(cfg.AGG_HOSTS, cfg.AGG_LOG)
remove_file(cfg.AGG_HOSTS, cfg.AGG_SOCK)
if args.check_samplerd:
print "Check samplerd ldmsd running? ...."
print is_ldmsd_running(hosts = cfg.SAMPLERD_HOSTS,
xprt = cfg.SAMPLERD_XPRT,
port = cfg.SAMPLERD_PORT)
if args.check_agg:
print "Check agg ldmsd running? ...."
print is_ldmsd_running(hosts = cfg.AGG_HOSTS, xprt = cfg.AGG_XPRT,
port = cfg.AGG_PORT)
if args.samplerd_pid:
print "Getting samplerd pid"
print get_ldmsd_pid(hosts = cfg.SAMPLERD_HOSTS, xprt = cfg.SAMPLERD_XPRT,
port = cfg.SAMPLERD_PORT)
if args.agg_pid:
print "Getting agg pid"
print get_ldmsd_pid(hosts = cfg.AGG_HOSTS, xprt = cfg.AGG_XPRT,
port = cfg.AGG_PORT)
except KeyboardInterrupt:
return 0
except Exception:
traceback.print_exc()
return 2
# package.getDownloadCounts(start_date=x, end_date=y)in a loop.
downloads = package.getDownloadCount()
version_counts[version] += downloads
series_counts[series] += downloads
arch_counts[arch] += downloads
print("%s - %s - %7s - %7s : %s" % (
name, version, series, arch, downloads))
print("\nVersion summaries")
for version in sorted(version_counts):
count = version_counts[version]
print("%s: %s" % (version, count))
print("\nSeries summaries")
for series in sorted(series_counts):
count = series_counts[series]
print("%7s: %s" % (series, count))
print("\nArch summaries")
for arch in sorted(arch_counts):
count = arch_counts[arch]
print("%5s: %s" % (arch, count))
if __name__ == '__main__':
parser = ArgumentParser('Count package downloads from a PPA.')
parser.add_argument('--since', type=to_datetime)
parser.add_argument('owner_name')
parser.add_argument('ppa_name')
parser.add_argument('package_name')
args = parser.parse_args()
report_juju_core_installs(
args.owner_name, args.ppa_name, args.package_name, since=args.since)
if self.options.keep and os.path.exists(interfaceFile):
with open(interfaceFile, "r") as f:
filecontent = f.read()
if self.options.keep and os.path.exists(interfaceFile) and \
filecontent == content:
self.info("%s unchanged." % interfaceFile)
else:
self.info("Writing %s." % interfaceFile)
with open(interfaceFile, "w") as f:
f.write(content)
if __name__ == '__main__':
argParser = ArgumentParser()
argParser.add_argument("--mdx",
action="append",
dest="mdx",
default=[],
metavar="FILE",
help="master idx file to be used.")
argParser.add_argument(
"--import",
action="append",
dest="imports",
default=[],
metavar="FILE",
help="File to be imported in the generated interface file.")
argParser.add_argument(
"--swig-include",
#!/usr/bin/env python3
from __future__ import absolute_import, division, print_function
import os
import glob
#os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import numpy as np
import fid
from scipy.misc import imread
import tensorflow as tf
from argparse import ArgumentParser
import sys
parser = ArgumentParser()
parser.add_argument("--dataset",
type=str,
default="PCam",
choices=["CelebA", "PCam"])
parser.add_argument("--image_format",
type=str,
default="jpg",
choices=["jpg", "png"])
config = parser.parse_args()
# Paths
if config.dataset == "CelebA":
image_path = 'celeba/results' # set path to some generated images
stats_path = 'fid_stats_celeba.npz'
elif config.dataset == "PCam":
image_path = 'pcam/results' # set path to some generated images
stats_path = 'fid_stats_pcam.npz' # training set statistics
else:
print("")
# now cd back to where we started
os.chdir(cwd)
#print len(sourceFiles),sourceFiles
#print len(targetFiles),targetFiles
return sourceFiles, targetFiles
#
# main, runs if started at the command line
#
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("-c", "--config-file", dest="configFileText",
help="file with Trigger configuration. Paths available are: unbiased, minimumbiasSdCount,largeSdCount, minimumbiasCdCount,largeCdCount, caloOnly, caloMixed, caloCosmicMuon, tprDeMSeed, tprDePSeed, cprDeMSeed, cprDePSeed, triggerOutput", metavar="FILE")
parser.add_argument("-o", "--online", dest="online", action="store_true",
help="if present, use the online main fcl file template instead of offline")
parser.add_argument("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")
args = parser.parse_args()
if args.verbose :
print("Config file name: {}".format(args.configFileText))
print("Online flag: {}".format(str(args.online)))
generate(args.configFileText, args.online, args.verbose, True)
def main():
"""
Import the ngeo apps files
"""
parser = ArgumentParser(description='import ngeo apps files')
parser.add_argument('--html', action="store_true", help="Import the html template")
parser.add_argument('--js', action="store_true", help="Import the javascript controller")
parser.add_argument('--package', action="store_true", help="Import the package JSON")
parser.add_argument('interface', metavar='INTERFACE', help="The interface we import")
parser.add_argument('src', metavar='SRC', help="The ngeo source file")
parser.add_argument('dst', metavar='DST', help="The destination file")
args = parser.parse_args()
with open(args.src) as src:
data = src.read()
if args.package:
ngeo_json_data = loads(data)
json_data = {}
json_data["name"] = "{{package}}"
json_data["version"] = "2.0.0"
json_data["description"] = "A GeoMapFish project"
json_data["devDependencies"] = ngeo_json_data["devDependencies"]
# freeze the ngeo version
json_data["devDependencies"]["ngeo"] = _get_ngeo_version()
for package in [
"angular-jsdoc",
"angular-mocks",
"coveralls",
"gaze",
"jsdoc",
"jsdom",
"karma",
"karma-coverage",
"karma-jasmine",
"karma-phantomjs-launcher",
]:
del json_data["devDependencies"][package]
data = dumps(json_data, indent=2, sort_keys=True)
data = _sub(r" +\n", "\n", data)
data = data + "\n"
else:
data = re.sub(r"{{", r"\\{\\{", data)
data = re.sub(r"}}", r"\\}\\}", data)
data = re.sub("app", "{{package}}", data)
# temporary disable ...
# if args.js:
# Full text search
# data = _sub(r"datasetTitle: 'Internal',", r"datasetTitle: '{{project}}',", data)
if args.html:
data = "<%\n" \
"from json import dumps\n" \
"from c2cgeoportal.lib.cacheversion import get_cache_version\n" \
"%>\n" + \
data
# back for ng-app
data = _sub(r"ng-{{package}}", r"ng-app", data)
# back for gmf-app- css prefix
data = _sub(r"gmf-{{package}}-", r"gmf-app-", data, required=False)
if args.interface == "mobile":
# back for mobile-web-app-capable
data = _sub(
r"mobile-web-{{package}}-capable",
r"mobile-web-app-capable", data
)
else:
data = _sub(
r'<img src="image/([^"]+)"( alt="")? ?/>',
'<img src="${request.static_url(\'{{package}}:static-ngeo/images/\\1\')}" />',
data,
)
data = _sub(
r'<link rel="shortcut icon" href="image/favicon.ico"/>',
'<link rel="shortcut icon" href="${request.static_url(\'{{package}}:static-ngeo/images/favicon.ico\')}"/>', # noqa
data,
)
# Styles
data = _sub(
r' <link rel="stylesheet.*/build/{}.css">'.format(args.interface),
r""" <link rel="stylesheet" href="${{request.static_url('{{{{package}}}}:static-ngeo/build/{interface}.css')}}" type="text/css">""".format(interface=args.interface), # noqa
data,
count=1,
flags=re.DOTALL
)
# Scripts
data = _sub(
r' <script',
r"""% if debug:
<script>
window.CLOSURE_BASE_PATH = '';
window.CLOSURE_NO_DEPS = true;
</script>
<script""",
data, count=1
)
data = _sub(
re.escape(' <script src="/@?main=') + ".*" + re.escape('watchwatchers.js"></script>'),
r"""
<script src="${{request.static_url('%s/closure/goog/base.js' % request.registry.settings['closure_library_path'])}}"></script>
<script src="${{request.route_url('deps.js')}}"></script>
<script>
goog.require('{{{{package}}}}_{interface}');
</script>
<script src="${{request.static_url('{{{{package}}}}:static-ngeo/build/templatecache.js')}}"></script>
<script src="${{request.static_url('%s/ngeo/utils/watchwatchers.js' % request.registry.settings['node_modules_path'])}}"></script>
<script>
{{{{package}}}}.componentsBaseTemplateUrl = '${{request.static_url("{{{{package}}}}:static-ngeo/components")}}';
// {{{{package}}}}.partialsBaseTemplateUrl = '${{request.static_url("{{{{package}}}}:static-ngeo/partials")}}';
// {{{{package}}}}.baseTemplateUrl = '${{request.static_url("{{{{package}}}}:static-ngeo/js")}}';
</script>
% else:
<script src="${{request.static_url('{{{{package}}}}:static-ngeo/build/{interface}.js')}}"></script>
% endif""".format(interface=args.interface), # noqa
data,
count=1,
flags=re.DOTALL
)
data = _sub(
'{}([^"]+){}(.*){}'.format(
re.escape('<script src="../../../../node_modules/'),
re.escape('"'),
re.escape("></script>"),
),
r"""<script src="${request.static_url('%s/\1' % request.registry.settings['node_modules_path'])}"\2></script>""", # noqa
data,
)
data = _sub(
'{}([^"]+){}(.*){}'.format(
re.escape('<script src="../../../../'),
re.escape('"'),
re.escape("></script>"),
),
r"""<script src="${request.static_url('%s/ngeo/\1' % request.registry.settings['node_modules_path'])}"\2></script>""", # noqa
data,
)
# i18n
data = _sub(
"module.constant\('defaultLang', 'en'\);",
"module.constant('defaultLang', "
"'${request.registry.settings[\"default_locale_name\"]}');",
data,
)
data = _sub(re.escape(r"""
var cacheVersion = '0';
"""), "", data)
data = _sub(
re.escape(r"""
var angularLocaleScriptUrlElements = urlElements.slice(0, urlElements.length - 3);
angularLocaleScriptUrlElements.push('build', 'angular-locale_\{\{locale\}\}.js?cache_version=' + cacheVersion);"""), # noqa
"",
data,
)
data = _sub(
re.escape(
"gmfModule.constant('angularLocaleScript', "
"angularLocaleScriptUrlElements.join('/'));"
),
"gmfModule.constant('angularLocaleScript', "
"'${request.static_url('{{package}}:static-ngeo/build/')}"
"angular-locale_\{\{locale\}\}.js');",
data,
)
data = _sub(
re.escape("""
var langUrls = {};
['en', 'fr', 'de'].forEach(function(lang) {
var langUrlElements = urlElements.slice(0, urlElements.length - 3);
langUrlElements.push('build', 'gmf-' + lang + '.json?cache_version=' + cacheVersion)
langUrls[lang] = langUrlElements.join('/')
});"""),
r""" var langUrls = {
${ ',\\n'.join([
" '{lang}': '{url}'".format(
lang=lang,
url=request.static_url('{{package}}:static-ngeo/build/{lang}.json'.format(lang=lang))
)
for lang in request.registry.settings["available_locale_names"]
]) | n}
};""",
data,
)
data = _sub(
re.escape("module.constant('cacheVersion', cacheVersion);"),
"module.constant('cacheVersion', '${get_cache_version()}');",
data,
)
data = _subs(
[(
"module.constant\('gmfSearchGroups', \[\]\);",
False
), (
"module.constant\('gmfSearchGroups', \[[^\]]*\]\);",
"module.constant('gmfSearchGroups', ${dumps(fulltextsearch_groups) | n});",
)],
data,
)
# replace routes
for constant, url_end, route, required in [
("authenticationBaseUrl", r"", "base", True),
("fulltextsearchUrl", r"/fulltextsearch", "fulltextsearch", True),
("gmfRasterUrl", r"/raster", "raster", args.interface != "mobile"),
("gmfProfileCsvUrl", r"/profile.csv", "profile.csv", args.interface != "mobile"),
("gmfProfileJsonUrl", r"/profile.json", "profile.json", args.interface != "mobile"),
("gmfPrintUrl", r"/printproxy", "printproxy", args.interface != "mobile"),
("gmfTreeUrl", r"/themes", "themes", True),
("gmfShortenerCreateUrl", r"/short/create", "shortener_create", args.interface != "mobile"),
]:
data = _sub(
r"module.constant\('%s', "
"'https://geomapfish-demo.camptocamp.net/2.[0-9]/wsgi%s\??([^\']*)'\);" % (
constant, url_end
),
_RouteDest(constant, route),
data,
required=required,
)
data = _sub(
re.escape("module.constant('gmfContextualdatacontentTemplateUrl', window.location.pathname + 'contextualdata.html');"), # noqa
"module.constant('gmfContextualdatacontentTemplateUrl', {{package}}.componentsBaseTemplateUrl + '/contextualdata/contextualdata.html');", # noqa
data, required=False
)
data = _sub(
re.escape("module.value('ngeoWfsPermalinkOptions',") + ".*defaultFeatureNS",
"""module.value('ngeoWfsPermalinkOptions', /** @type {ngeox.WfsPermalinkOptions} */ ({
url: '${request.route_url('mapserverproxy') | n}',
wfsTypes: ${dumps(wfs_types) | n},
defaultFeatureNS""",
data,
count=1,
flags=re.DOTALL,
)
data = _sub(
re.escape("module.constant('defaultTheme', 'OSM');"),
"module.constant('defaultTheme', 'Demo');",
data,
)
with open(args.dst, "wt") as dst:
dst.write(data)
# Remove trailing comma from a json.
from argparse import ArgumentParser
from pyspark.sql import SparkSession
from src.utils.spark_utils import json_without_trailing_comma
# parse arguments
parser = ArgumentParser()
parser.add_argument('--input-file', help='Input path, path to the file containing trailing commas')
parser.add_argument('--output-path', help='Output path, the valid json file will be store in this path')
args = parser.parse_args()
# initialization
spark = SparkSession.builder.getOrCreate()
input_data_as_text = spark \
.read \
.option("multiline", "true") \
.text(args.input_file)
input_data_without_trailing_comma = json_without_trailing_comma(input_data_as_text)
input_data_without_trailing_comma \
.write \
.text(args.output_path)
class DelegatedArgumentParser(Delegator):
DEFAULT_DELEGATE_OBJ = ArgumentParser()
DELEGATED_METHODS = {}
DELEGATED_METHOD_ACTIONS = {
"add_subparsers": RemoveKwArgDelegatedMethodAction(["required"])
}
def test_accepts_all_args(self):
all_test_arguments = cluster_config_command.all_arguments
default_arg_values = {
'--region-url': None,
'--uuid': None,
'--init': False,
'--tftp-port': None,
'--tftp-root': None,
}
failures = {}
# Try all cardinalities of combinations of arguments
for r in range(len(all_test_arguments) + 1):
for test_arg_names in combinations(all_test_arguments, r):
test_values = {
'--region-url': factory.make_simple_http_url(),
'--uuid': str(uuid.uuid4()),
'--init': '',
'--tftp-port': str(factory.pick_port()),
'--tftp-root': factory.make_string(),
}
# Build a query dictionary for the given combination of args
args_under_test = []
for param_name in test_arg_names:
args_under_test.append(param_name)
if param_name != '--init':
args_under_test.append(test_values[param_name])
parser = ArgumentParser()
cluster_config_command.add_arguments(parser)
# If both init and uuid are passed, argparse will generate
# a nice ArgumentError exception, which unfortunately,
# gets caught and sent to exit.
if '--init' in test_arg_names and '--uuid' in test_arg_names:
expected_exception = ExpectedException(SystemExit, '2')
with expected_exception, patch('sys.stderr'):
parser.parse_known_args(args_under_test)
else:
# Otherwise, parsed args with defaults as usual
observed_args = vars(
parser.parse_args(args_under_test))
expected_args = {}
for param_name in all_test_arguments:
parsed_param_name = param_name[2:].replace('-', '_')
if param_name not in test_arg_names:
expected_args[parsed_param_name] = \
default_arg_values[param_name]
else:
expected_args[parsed_param_name] = \
observed_args[parsed_param_name]
if expected_args != observed_args:
failures[str(test_arg_names)] = {
'expected_args': expected_args,
'observed_args': observed_args,
}
error_message = io.StringIO()
error_message.write(
"One or more key / value argument list(s)"
"passed in the query string (expected_args)"
"to the API do not match the values in "
"the returned query string. This "
"means that some arguments were "
"dropped / added / changed by the "
"the function, which is incorrect "
"behavior. The list of incorrect "
"arguments is as follows: \n")
pp = pprint.PrettyPrinter(depth=3, stream=error_message)
pp.pprint(failures)
self.assertDictEqual({}, failures, error_message.getvalue())
if not cc:
raise FileNotFoundError(f"{cc_name} not found")
cxx = env.get("CXX", "")
if cxx_name not in cxx:
cxx = shutil.which(cxx_name)
if not cxx:
raise FileNotFoundError(f"{cxx_name} not found")
env.update({"FC": fc, "CC": cc, "CXX": cxx})
return env
if __name__ == "__main__":
p = ArgumentParser()
p.add_argument("libs", help="libraries to compile (lapack, scalapack, mumps)", nargs="+")
p.add_argument("-prefix", help="toplevel path to install libraries under", default="~/lib_gcc")
p.add_argument("-workdir", help="toplevel path to where you keep code repos", default="~/code")
p.add_argument("-wipe", help="wipe before completely recompiling libs", action="store_true")
p.add_argument("-b", "--buildsys", help="build system (meson or cmake)", default="meson")
P = p.parse_args()
dirs = {"prefix": Path(P.prefix).expanduser().resolve(), "workdir": Path(P.workdir).expanduser().resolve()}
if "openmpi" in P.libs:
openmpi(P.wipe, dirs)
if "lapack" in P.libs:
lapack(P.wipe, dirs, P.buildsys)
if "scalapack" in P.libs:
scalapack(P.wipe, dirs, P.buildsys)
f.readline()
for line, rank in zip(f, top100):
idx, answer = line.strip().split(',')
answer = set(answer.split())
rank = [(id2docname[i].split('/')[-1].lower()) for i in rank]
hit = 0
P = []
for rank_i, rank in enumerate(rank, 1):
if rank in answer:
hit += 1
P.append(hit / rank_i)
AP.append(sum(P) / len(P))
return sum(AP) / len(AP)
# set parser
parser = ArgumentParser()
parser.add_argument(
"-r", action="store_true",
help="Turn on the relevance feedback",
dest="rel_switch", default=False
)
parser.add_argument(
"-b", action="store_true",
help="Run the best version",
dest="best_switch", default=False
)
parser.add_argument(
"-i", action="store",
help="Filename of input query file",
dest="query_file", default="data/query-test.xml"
)
def get_opt_parser():
parser = ArgumentParser()
parser.add_argument("target", choices=["train", "test"])
parser.add_argument("--new",
dest="new",
action="store_true",
help="create new model")
parser.add_argument("--render",
dest="render",
action="store_true",
help="render or not")
parser.add_argument("-v",
dest="verbose",
action="store_true",
help="verbose mode")
parser.add_argument("--ep",
dest="episode",
type=int,
help="number of episode to test")
return parser
def build_parser():
parser = ArgumentParser()
parser.add_argument('--num_epochs',
default=75,
help='default: 40',
type=int)
parser.add_argument('--batch_size',
default=16,
help='default: 16',
type=int)
parser.add_argument('--num_threads',
default=8,
help='# of data read threads (default: 8)',
type=int)
models_str = ' / '.join(config.model_zoo)
parser.add_argument('--model', help=models_str,
required=True) # DRAGAN, CramerGAN
parser.add_argument('--name', help='default: name=model')
parser.add_argument('--dataset', '-D', help='CelebA / LSUN', required=True)
parser.add_argument(
'--ckpt_step',
default=1000,
help='# of steps for saving checkpoint (default: 5000)',
type=int)
parser.add_argument('--renew',
action='store_true',
help='train model from scratch - \
clean saved checkpoints and summaries',
default=False)
return parser
def main():
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("-c", "--classes", action='store_true', dest='showclasses',
help="show classes found")
parser.add_argument("-b", "--bases", action="store_true", dest="showbases",
help="show base classes (only works if --classes is active)")
parser.add_argument("-i", "--interfaces", action="store_true", dest="showifaces",
help="show interfaces of classes (only works if --classes is active)")
parser.add_argument("-u", "--use-cache", action='store_true', dest='use_cache',
help="use analysis cache")
parser.add_argument('files', metavar='fname', type=str, nargs='+',
help='a file or directory to be scanned')
options = parser.parse_args()
print options.use_cache
stime = time.time()
psta = PythonSourceTreeAnalyser()
for f in options.files:
f = os.path.abspath(os.path.expanduser(f))
if os.path.isdir(f):
for pyfile in find_files(f, "*.py", exclude=lambda n: 'test' in n.split(os.sep)):
psta.analyze_file(pyfile, use_cache=options.use_cache)
else:
psta.analyze_file(f, use_cache=options.use_cache)
psta.dump(sys.stdout, options)
sys.stdout.write("elapsed time: %s seconds\n\n" % (time.time() - stime))
if options.use_cache:
_FileInfoCache.save()
import os
from argparse import ArgumentParser
from subprocess import call
PROJECT_NAME = 'data-mng'
MAIN_SERVICE_NAME = 'service-app'
# переменная среды SOURCE_DATA используется в docker-compose
os.environ['SOURCE_DATA'] = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'data_store')
docker_compose = f"""docker-compose --project-name {PROJECT_NAME} -f docker_compose/docker-compose.yml \
"""
docker_compose_postfix = f" --rm --name {PROJECT_NAME} {MAIN_SERVICE_NAME} "
simple_run = f'{docker_compose} run {docker_compose_postfix}'
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('-s', '--scenario', dest='scenario', required=True, help='Сценарий работы')
args = parser.parse_args()
if args.scenario in ('pipenv', 'bash', 'psql', 'load', 'test', 'mongo', 'mongoimport'):
sh_command = f'{simple_run} {args.scenario}'
elif args.scenario == 'down':
sh_command = f'{docker_compose} {args.scenario}'
elif args.scenario == 'jupyter':
sh_command = f'{docker_compose} run -d -p 8889:8888 {docker_compose_postfix} {args.scenario}'
elif args.scenario == 'service':
sh_command = f'{docker_compose} run -d -p 5001:5000 {docker_compose_postfix} {args.scenario}'
elif args.scenario == 'docker':
sh_command = f'{docker_compose} build {MAIN_SERVICE_NAME}'
else:
raise ValueError('Ошибочный сценарий: %s' % args.scenario)
print(sh_command)
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
from ydk.models.cisco_ios_xr import Cisco_IOS_XR_ipv4_bgp_cfg \
as xr_ipv4_bgp_cfg
import logging
def config_bgp(bgp):
"""Add config data to bgp object."""
pass
if __name__ == "__main__":
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
parser.add_argument("device",
help="NETCONF device (ssh://user:password@host:port)")
args = parser.parse_args()
device = urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
from datetime import timedelta
from shapely.geometry import Polygon
from sys import exit
import reame.sensors
from reame.classes import HistogramGrid
from reame.utils import tabulate_data_points, REFERENCE_TIME
try:
default_day_offset = int(os.environ["SLURM_ARRAY_TASK_ID"])
except KeyError:
default_day_offset = 0
# Command line arguments
pars = ArgumentParser(description="Generate histograms of AOD.")
pars.add_argument("algorithm",
help="Name of Sensor class used to read the data.")
inpt = pars.add_mutually_exclusive_group()
inpt.add_argument("--in_dir", help="strftime-compatible path to input files.")
inpt.add_argument("--files", nargs="+", default=[],
help="Manually override the list of files to process.")
pars.add_argument("--mod03_path",
help="Path to MODIS geolocation files.")
pars.add_argument("--grid_path",
help="Path to MAIAC geolocation files.")
pars.add_argument("--out_name", default="hist_%Y-%m-%d.npz",
help="strftime-compatible path for output file.")
pars.add_argument("--day_offset", type=int, default=default_day_offset,
help="Number of days from Jan 1 1995 to evaluate.")
pars.add_argument("--grid", default="/home/users/acpovey/ukesm_grid.4.npz",
def main():
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
parser = ArgumentParser(
'Read word-level tests and generate corresponding sentence-level '
'tests next to them using simple sentence templates.',
formatter_class=ArgumentDefaultsHelpFormatter
)
parser.add_argument('input_paths', nargs='+', metavar='input_path',
help='Paths to word-level json test files. Output '
'files will be named by prepending {} to each '
'input filename.'.format(OUTPUT_PREFIX))
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
for input_path in args.input_paths:
logging.info('Loading word-level test from {}'.format(input_path))
with open(input_path) as f:
sets = json.load(f)
for (set_type, set_dict) in sets.items():
sentences = []
for term in set_dict['examples']:
if any(term.startswith(c) for c in string.ascii_uppercase) and \
not term.endswith('American') and \
term != term.upper():
sentences += [
fill_template(template, term)
for template in NAME_TEMPLATES
]
elif term in ADJECTIVES:
sentences += [
fill_template(template, term)
for template in ADJECTIVE_TEMPLATES
]
elif term in VERBS:
sentences += [
fill_template(template, term)
for template in VERB_TEMPLATES
]
elif term in MASS_NOUNS:
sentences += [
fill_template(template, term)
for template in MASS_NOUN_TEMPLATES
]
elif term in ('he', 'she'):
sentences += [
fill_template(template, term)
for template in SUBJECT_PRONOUN_TEMPLATES
]
elif term in ('him', 'her'):
sentences += [
fill_template(template, term)
for template in OBJECT_PRONOUN_TEMPLATES
]
elif term in ('his', 'hers'):
sentences += [
fill_template(template, term)
for template in POSSESSIVE_PRONOUN_TEMPLATES
]
else:
if term in PLURAL_NOUNS:
singular_term = singularize(term)
plural_term = term
else:
singular_term = term
plural_term = pluralize(term)
sentences += [
fill_template(template, singular_term)
for template in SINGULAR_NOUN_TEMPLATES + (
SINGULAR_PERSON_TEMPLATES
if PERSON_RE.search(term) is not None
else SINGULAR_THING_TEMPLATES
)
]
sentences += [
fill_template(template, plural_term)
for template in PLURAL_NOUN_TEMPLATES + (
PLURAL_PERSON_TEMPLATES
if PERSON_RE.search(term) is not None
else PLURAL_THING_TEMPLATES
)
]
set_dict['examples'] = sentences
if len(sets['targ1']['examples']) != len(sets['targ2']['examples']):
logging.info(
'Truncating targ1, targ2 to have same size (current sizes: {}, {})'.format(
len(sets['targ1']['examples']), len(sets['targ2']['examples'])))
(sets['targ1']['examples'], sets['targ2']['examples']) = truncate_lists(
sets['targ1']['examples'], sets['targ2']['examples'])
(dirname, basename) = os.path.split(input_path)
output_path = os.path.join(dirname, OUTPUT_PREFIX + basename)
logging.info('Writing sentence-level test to {}'.format(output_path))
with open(output_path, 'w') as f:
json.dump(sets, f, indent=2)
predictions = None
for in_name, weight in zip(in_names, weights):
with open(os.path.join(out_path, in_name, 'result.txt')) as file:
current_paths = np.array(tuple(map(lambda x: x.split()[0], file.readlines())))
if paths is None:
paths = current_paths
assert np.array_equal(paths, current_paths)
probablility = np.load(os.path.join(out_path, in_name, 'probability.npy'))
if predictions is None:
predictions = np.zeros_like(probablility)
predictions += probablility * weight
predictions = np.argmax(predictions, axis=1)
with open(os.path.join(out_path, out_name, 'result.txt'), 'w') as file:
for path, prediction in zip(paths, predictions):
file.write(f'{path} {prediction}\n')
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--out-path', type=str, default='/content/logs')
parser.add_argument('--in-names', type=str, required=True)
parser.add_argument('--out-name', type=str, default='tmp')
parser.add_argument('--weights', type=str, required=True)
options = vars(parser.parse_args())
run(
out_path=options['out_path'],
in_names=options['in_names'],
out_name=options['out_name'],
weights=options['weights'],
)
def main():
parser = ArgumentParser()
parser.add_argument("output_json", help="Output JSON file")
parser.add_argument("buildhub_json", help="Output buildhub JSON file")
parser.add_argument("output_txt", help="Output text file")
# TODO: Move package-name.mk variables into moz.configure.
parser.add_argument("pkg_platform", help="Package platform identifier")
parser.add_argument("--no-download",
action="store_true",
help="Do not include download information")
parser.add_argument("--package", help="Path to application package file")
parser.add_argument("--installer",
help="Path to application installer file")
args = parser.parse_args()
mozinfo.find_and_update_from_json()
important_substitutions = [
"target_alias",
"target_cpu",
"target_os",
"target_vendor",
"host_alias",
"host_cpu",
"host_os",
"host_vendor",
"MOZ_UPDATE_CHANNEL",
"MOZ_APP_VENDOR",
"MOZ_APP_NAME",
"MOZ_APP_VERSION",
"MOZ_APP_MAXVERSION",
"MOZ_APP_ID",
"CC",
"CXX",
"AS",
"MOZ_SOURCE_REPO",
]
all_key_value_pairs = {
x.lower(): buildconfig.substs[x]
for x in important_substitutions
}
build_id = os.environ["MOZ_BUILD_DATE"]
all_key_value_pairs.update({
"buildid":
build_id,
"moz_source_stamp":
buildconfig.substs["MOZ_SOURCE_CHANGESET"],
"moz_pkg_platform":
args.pkg_platform,
})
with open(args.output_json, "wt") as f:
json.dump(all_key_value_pairs, f, indent=2, sort_keys=True)
f.write("\n")
with open(args.buildhub_json, "wt") as f:
build_time = datetime.datetime.strptime(build_id, "%Y%m%d%H%M%S")
s = buildconfig.substs
record = {
"build": {
"id": build_id,
"date": build_time.isoformat() + "Z",
"as": s["AS"],
"cc": s["CC"],
"cxx": s["CXX"],
"host": s["host_alias"],
"target": s["target_alias"],
},
"source": {
"product": s["MOZ_APP_NAME"],
"repository": s["MOZ_SOURCE_REPO"],
"tree": os.environ["MH_BRANCH"],
"revision": s["MOZ_SOURCE_CHANGESET"],
},
"target": {
"platform": args.pkg_platform,
"os": mozinfo.info["os"],
# This would be easier if the locale was specified at configure time.
"locale": os.environ.get("AB_CD", "en-US"),
"version": s["MOZ_APP_VERSION_DISPLAY"]
or s["MOZ_APP_VERSION"],
"channel": s["MOZ_UPDATE_CHANNEL"],
},
}
if args.no_download:
package = None
elif args.installer and os.path.exists(args.installer):
package = args.installer
else:
package = args.package
if package:
st = os.stat(package)
mtime = datetime.datetime.fromtimestamp(st.st_mtime)
record["download"] = {
# The release pipeline will update these keys.
"url": os.path.basename(package),
"mimetype": "application/octet-stream",
"date": mtime.isoformat() + "Z",
"size": st.st_size,
}
json.dump(record, f, indent=2, sort_keys=True)
f.write("\n")
with open(args.output_txt, "wt") as f:
f.write("buildID={}\n".format(build_id))
Arguments:
args: The object containing the commandline arguments
"""
wt = WallpaperTransition(
args.img_dir,
args.timeout,
args.duration,
args.fps,
)
wt.loop()
if __name__ == "__main__":
parser = ArgumentParser(
description="Wallpaper Transition using Feh",
formatter_class=ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"img_dir",
metavar="DIR",
type=Path,
help="the directory of wallpapers you want to loop through",
)
parser.add_argument(
"--timeout",
type=int,
default=600,
help="idle period (in seconds) between transitions",
)
parser.add_argument(
"--duration",
def get_args():
"""Parse arguments"""
parser = ArgumentParser(description=__doc__)
parser.add_argument('-v', '--verbose', action='store_true')
return parser.parse_args()
#!/usr/bin/env python3
from argparse import ArgumentParser
from keybag import Keybag
from binascii import hexlify
def print_tag(tag, indent=''):
line = '%s%s = ' % (indent, tag.name)
if type(tag.value) == int:
line += '%d' % tag.value
elif type(tag.value) == bytes:
line += hexlify(tag.value).decode()
print(line)
parser = ArgumentParser(description='Parse decrypted keybag')
parser.add_argument('file')
args = parser.parse_args()
kb = Keybag.from_file(args.file)
print('HEADER')
for tag in kb.data.header.tags:
print_tag(tag, indent=' ')
print('KEYS')
for i, key in enumerate(kb.data.keys):
print(' %d:' % i)
for tag in key.tags:
print_tag(tag, indent=' ')
__email__ = '*****@*****.**'
__status__ = 'Development'
# endregion
# region Main function
if __name__ == "__main__":
# region Check user, platform and print banner
Base = Base()
Base.check_user()
Base.check_platform()
Base.print_banner()
# endregion
# region Parse script arguments
parser = ArgumentParser(description='ARP scan local network')
parser.add_argument('-i',
'--interface',
type=str,
help='Set interface name for ARP scanner')
parser.add_argument('-I',
'--target_ip',
type=str,
help='Set target IP address',
default=None)
parser.add_argument('-t',
'--timeout',
type=int,
help='Set timeout (default=3)',
default=3)
with app.app_context():
BaseModel.set_session(db.session)
if config.config_model.sqlite.recreate:
logging.info("Recreating database")
db.drop_all()
db.session.commit()
db.create_all()
db.session.commit()
app.register_blueprint(bp)
app.register_blueprint(frontend_bp)
return app
if __name__ == '__main__':
arg_parser = ArgumentParser()
arg_parser.add_argument("-c",
"--config",
dest="config_path",
help="The path to the configuration file.")
args = arg_parser.parse_args()
config_path = args.config_path if args.config_path else "../config/streetview-bingo.yml"
app: Flask = create_app(config_path)
sio.run(app,
host=config.config_model.networking.host,
port=config.config_model.networking.port)
obj = pickle.load(fp)
model.states_list.append(obj)
if model.parallel:
parallel.add_data(model.states_list[-1].data)
fp.close()
print "--------------------------------------add_data process completed!!--------------------------------------"
#save params&charm#
save_fig_title(fig_title_path, SAVE_PARAMS, locals())
save_parameters(param_path, SAVE_PARAMS, locals())
obs_hypparams['sigma_0'] = np.eye(obs_dim)
obs_hypparams['mu_0'] = np.zeros(obs_dim)
#estimation&result_write#
print "--------------------------------------estimation process start--------------------------------------"
result = Result(result_dir, DATA_N)
loglikelihood = []
for idx in progprint_xrange(ITER_N, perline=10):
model.resample_model()
loglikelihood.append(result.save_loglikelihood(model))
result.save(model)
result.write_loglikelihood(loglikelihood)
print "--------------------------------------estimation process completed!!--------------------------------------"
#--------------------------------------direct execution function--------------------------------------#
if __name__ == '__main__':
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--result-dir', default=None)
args = parser.parse_args()
main(**vars(args))