def handle_cmd_options():
usage = """
Usage: yam_sort -s file_one file_two """
hp = lambda prog: RawTextHelpFormatter(
prog, max_help_position=50, width=120)
parser = argparse.ArgumentParser(description=usage, formatter_class=hp)
parser.add_argument(
'-s',
'--sync',
nargs=2,
metavar=('first', 'second'),
help='sort the second of two YAML files by keys in first')
parser.add_argument('-k',
'--keys',
nargs=2,
metavar=('first', 'second'),
help='diff two YAML files by keys only')
parser.add_argument('-o',
'--overwrite',
action="store_true",
help='overwrite second file with re-sorted data')
cmd_args = parser.parse_args()
# You would think an empty argument list would *default* to printing help, but no...
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
return cmd_args
def __init__(self) -> None:
width = shutil.get_terminal_size().columns
self.parser = SanicArgumentParser(
prog="sanic",
description=self.DESCRIPTION,
formatter_class=lambda prog: RawTextHelpFormatter(
prog,
max_help_position=36 if width > 96 else 24,
indent_increment=4,
width=None,
),
)
self.parser._positionals.title = "Required\n========\n Positional"
self.parser._optionals.title = "Optional\n========\n General"
self.main_process = (os.environ.get("SANIC_RELOADER_PROCESS", "") !=
"true")
self.args: List[Any] = []
def handle_cmd_options():
usage = """
Usage: Play around in a simple block-world, that bears a passing resemblance
to Minecraft. You can:
- select from one of *nine* different block-types
- add/remove blocks
- save/load a game
- move around the world with the keyboard/mouse (mouse rotates view only)
r = resets location/camera view - hit this at start of game, if view is empty
m = toggles between movement (invisible mouse), and block-placement (visible mouse)
b = toggles block-selection menu
ESC = toggles pause/save-game screen
a/s/d/w = moves around horizontally
z/x = moves up/down (or was it down, then up?)
"""
hp = lambda prog: RawTextHelpFormatter(prog, max_help_position=50, width=120)
parser = argparse.ArgumentParser(description=usage, formatter_class=hp)
parser.add_argument('-v', '--verbose', action="store_true", help='verbose debugging statements - TBD')
parser.add_argument('-l', '--level', action="store_true", help='level the ground, no noisy-generation')
parser.add_argument('-m', '--mini', action="store_true", help='use smaller blocks')
parser.add_argument('-s', '--skybox', action="store_true", help='uses a simple SkyBox, mostly for testing')
parser.add_argument('-b', '--block', default='grass', help='set block-type for initial terrain-generation')
parser.add_argument('-p', '--play', action="store_true", help='play the game - any cmd-option will also play')
cmd_args = parser.parse_args()
# You would think an empty argument list would *default* to printing help, but no...
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
return cmd_args
# Retrieve subparsers from parser
subparsers_actions = [
action for action in parser._actions
if isinstance(action, argparse._SubParsersAction)
]
for subparsers_action in subparsers_actions:
# get all subparsers and print help
for choice, subparser in subparsers_action.choices.items():
print "Command '{}'".format(choice)
print subparser.format_usage()
parser.exit()
# Change the width of the output format
formatter_class = lambda prog: RawTextHelpFormatter(prog, max_help_position=50)
# Help parser for parsing subparsers in help
help_parser = ArgumentParser(
description='Run Dataduct commands',
add_help=False,
formatter_class=formatter_class,
)
help_parser.add_argument(
'-h',
'--help',
action=DataductHelpAction,
help='Help message',
)
# Mode parser shared across all pipeline subparsers
def main():
parser = SanicArgumentParser(
prog="sanic",
description=BASE_LOGO,
formatter_class=lambda prog: RawTextHelpFormatter(
prog, max_help_position=33),
)
parser.add_argument(
"-v",
"--version",
action="version",
version=f"Sanic {__version__}; Routing {__routing_version__}",
)
parser.add_argument(
"--factory",
action="store_true",
help=("Treat app as an application factory, "
"i.e. a () -> <Sanic app> callable"),
)
parser.add_argument(
"-s",
"--simple",
dest="simple",
action="store_true",
help="Run Sanic as a Simple Server (module arg should be a path)\n ",
)
parser.add_argument(
"-H",
"--host",
dest="host",
type=str,
default="127.0.0.1",
help="Host address [default 127.0.0.1]",
)
parser.add_argument(
"-p",
"--port",
dest="port",
type=int,
default=8000,
help="Port to serve on [default 8000]",
)
parser.add_argument(
"-u",
"--unix",
dest="unix",
type=str,
default="",
help="location of unix socket\n ",
)
parser.add_argument(
"--cert",
dest="cert",
type=str,
help="Location of fullchain.pem, bundle.crt or equivalent",
)
parser.add_argument(
"--key",
dest="key",
type=str,
help="Location of privkey.pem or equivalent .key file",
)
parser.add_argument(
"--tls",
metavar="DIR",
type=str,
action="append",
help="TLS certificate folder with fullchain.pem and privkey.pem\n"
"May be specified multiple times to choose of multiple certificates",
)
parser.add_argument(
"--tls-strict-host",
dest="tlshost",
action="store_true",
help="Only allow clients that send an SNI matching server certs\n ",
)
parser.add_bool_arguments("--access-logs",
dest="access_log",
help="display access logs")
parser.add_argument(
"-w",
"--workers",
dest="workers",
type=int,
default=1,
help="number of worker processes [default 1]\n ",
)
parser.add_argument("-d", "--debug", dest="debug", action="store_true")
parser.add_bool_arguments(
"--noisy-exceptions",
dest="noisy_exceptions",
help="print stack traces for all exceptions",
)
parser.add_argument(
"-r",
"--reload",
"--auto-reload",
dest="auto_reload",
action="store_true",
help="Watch source directory for file changes and reload on changes",
)
parser.add_argument(
"-R",
"--reload-dir",
dest="path",
action="append",
help="Extra directories to watch and reload on changes\n ",
)
parser.add_argument(
"module",
help=("Path to your Sanic app. Example: path.to.server:app\n"
"If running a Simple Server, path to directory to serve. "
"Example: ./\n"),
)
args = parser.parse_args()
# Custom TLS mismatch handling for better diagnostics
if (
# one of cert/key missing
bool(args.cert) != bool(args.key)
# new and old style args used together
or args.tls and args.cert
# strict host checking without certs would always fail
or args.tlshost and not args.tls and not args.cert):
parser.print_usage(sys.stderr)
error_logger.error(
"sanic: error: TLS certificates must be specified by either of:\n"
" --cert certdir/fullchain.pem --key certdir/privkey.pem\n"
" --tls certdir (equivalent to the above)")
sys.exit(1)
try:
module_path = os.path.abspath(os.getcwd())
if module_path not in sys.path:
sys.path.append(module_path)
if args.simple:
path = Path(args.module)
app = create_simple_server(path)
else:
delimiter = ":" if ":" in args.module else "."
module_name, app_name = args.module.rsplit(delimiter, 1)
if app_name.endswith("()"):
args.factory = True
app_name = app_name[:-2]
module = import_module(module_name)
app = getattr(module, app_name, None)
if args.factory:
app = app()
app_type_name = type(app).__name__
if not isinstance(app, Sanic):
raise ValueError(
f"Module is not a Sanic app, it is a {app_type_name}. "
f"Perhaps you meant {args.module}.app?")
ssl: Union[None, dict, str, list] = []
if args.tlshost:
ssl.append(None)
if args.cert is not None or args.key is not None:
ssl.append(dict(cert=args.cert, key=args.key))
if args.tls:
ssl += args.tls
if not ssl:
ssl = None
elif len(ssl) == 1 and ssl[0] is not None:
# Use only one cert, no TLSSelector.
ssl = ssl[0]
kwargs = {
"host": args.host,
"port": args.port,
"unix": args.unix,
"workers": args.workers,
"debug": args.debug,
"access_log": args.access_log,
"ssl": ssl,
"noisy_exceptions": args.noisy_exceptions,
}
if args.auto_reload:
kwargs["auto_reload"] = True
if args.path:
if args.auto_reload or args.debug:
kwargs["reload_dir"] = args.path
else:
error_logger.warning(
"Ignoring '--reload-dir' since auto reloading was not "
"enabled. If you would like to watch directories for "
"changes, consider using --debug or --auto-reload.")
app.run(**kwargs)
except ImportError as e:
if module_name.startswith(e.name):
error_logger.error(
f"No module named {e.name} found.\n"
" Example File: project/sanic_server.py -> app\n"
" Example Module: project.sanic_server.app")
else:
raise e
except ValueError:
error_logger.exception("Failed to run app")
def less_indent_formatter(prog):
return RawTextHelpFormatter(prog, max_help_position=8, width=80)
def main():
print(swarmcg.shared.styling.header_package(
' Module: Model bonded terms assessment\n'))
formatter = lambda prog: RawTextHelpFormatter(prog, width=135, max_help_position=52)
args_parser = ArgumentParser(
description=EVALUATE_DESCR,
formatter_class=formatter,
add_help=False,
usage=SUPPRESS
)
all_args_header = swarmcg.shared.styling.sep_close + '\n| REQUIRED/OPTIONAL ARGUMENTS |\n' + swarmcg.shared.styling.sep_close
bullet = ' '
required_args = args_parser.add_argument_group(
all_args_header + '\n\n' + bullet + 'MODELS FILES')
required_args.add_argument('-aa_tpr', dest='aa_tpr_filename', help=config.help_aa_tpr, type=str,
default=config.metavar_aa_tpr,
metavar=' ' + scg.par_wrap(config.metavar_aa_tpr))
required_args.add_argument('-aa_traj', dest='aa_traj_filename', help=config.help_aa_traj,
type=str, default=config.metavar_aa_traj,
metavar=' ' + scg.par_wrap(config.metavar_aa_traj))
required_args.add_argument('-cg_map', dest='cg_map_filename', help=config.help_cg_map, type=str,
default=config.metavar_cg_map,
metavar=' ' + scg.par_wrap(config.metavar_cg_map))
required_args.add_argument('-mapping', dest='mapping_type', help=config.help_mapping_type, type=str,
default='COM', metavar=' (COM)')
required_args.add_argument('-cg_itp', dest='cg_itp_filename',
help='ITP file of the CG model to evaluate', type=str,
default=config.metavar_cg_itp,
metavar=' ' + scg.par_wrap(config.metavar_cg_itp))
required_args.add_argument('-cg_tpr', dest='cg_tpr_filename',
help='TPR file of your CG simulation (omit for solo AA inspection)',
type=str, default=config.metavar_cg_tpr,
metavar=' ' + scg.par_wrap(config.metavar_cg_tpr))
required_args.add_argument('-cg_traj', dest='cg_traj_filename',
help='XTC file of your CG trajectory (omit for solo AA inspection)',
type=str, default=config.metavar_cg_traj,
metavar=' ' + scg.par_wrap(config.metavar_cg_traj))
optional_args = args_parser.add_argument_group(bullet + 'CG MODEL SCALING')
# optional_args.add_argument('-nb_threads', dest='nb_threads', help='number of threads to use', type=int, default=1, metavar='1') # TODO: does NOT work properly -- modif MDAnalysis code with OpenMP num_threads(n) in the pragma
optional_args.add_argument('-bonds_scaling', dest='bonds_scaling',
help=config.help_bonds_scaling, type=float,
default=config.bonds_scaling,
metavar=' ' + scg.par_wrap(config.bonds_scaling))
optional_args.add_argument('-bonds_scaling_str', dest='bonds_scaling_str',
help=config.help_bonds_scaling_str, type=str,
default=config.bonds_scaling_str, metavar='')
optional_args.add_argument('-min_bonds_length', dest='min_bonds_length',
help=config.help_min_bonds_length, type=float,
default=config.min_bonds_length,
metavar=' ' + scg.par_wrap(config.min_bonds_length))
optional_args.add_argument('-b2a_score_fact', dest='bonds2angles_scoring_factor',
help=config.help_bonds2angles_scoring_factor, type=float,
default=config.bonds2angles_scoring_factor,
metavar=' ' + scg.par_wrap(config.bonds2angles_scoring_factor))
graphical_args = args_parser.add_argument_group(bullet + 'FIGURE DISPLAY')
graphical_args.add_argument('-mismatch_ordering', dest='mismatch_order',
help='Enables ordering of bonds/angles/dihedrals by mismatch score\nbetween pairwise AA-mapped/CG distributions (can help diagnosis)',
default=False, action='store_true')
graphical_args.add_argument('-bw_constraints', dest='bw_constraints',
help=config.help_bw_constraints, type=float,
default=config.bw_constraints,
metavar=' ' + scg.par_wrap(config.bw_constraints))
graphical_args.add_argument('-bw_bonds', dest='bw_bonds', help=config.help_bw_bonds, type=float,
default=config.bw_bonds,
metavar=' ' + scg.par_wrap(config.bw_bonds))
graphical_args.add_argument('-bw_angles', dest='bw_angles', help=config.help_bw_angles,
type=float, default=config.bw_angles,
metavar=' ' + scg.par_wrap(config.bw_angles))
graphical_args.add_argument('-bw_dihedrals', dest='bw_dihedrals', help=config.help_bw_dihedrals,
type=float, default=config.bw_dihedrals,
metavar=' ' + scg.par_wrap(config.bw_dihedrals))
graphical_args.add_argument('-disable_x_scaling', dest='row_x_scaling',
help='Disable auto-scaling of X axis across each row of the plot',
default=True, action='store_false')
graphical_args.add_argument('-disable_y_scaling', dest='row_y_scaling',
help='Disable auto-scaling of Y axis across each row of the plot',
default=True, action='store_false')
graphical_args.add_argument('-bonds_max_range', dest='bonded_max_range',
help=config.help_bonds_max_range, type=float,
default=config.bonds_max_range,
metavar=' ' + scg.par_wrap(config.bonds_max_range))
graphical_args.add_argument('-ncols', dest='ncols_max',
help='Max. nb of columns displayed in figure', type=int, default=0,
metavar='') # TODO: make this a line return in plot instead of ignoring groups
optional_args2 = args_parser.add_argument_group(bullet + 'OTHERS')
optional_args2.add_argument('-o', dest='plot_filename',
help='Filename for the output plot (extension/format can be one of:\neps, pdf, pgf, png, ps, raw, rgba, svg, svgz)',
type=str, default='distributions.png', metavar=' (distributions.png)')
optional_args2.add_argument('-h', '--help', action='help',
help='Show this help message and exit')
optional_args2.add_argument('-v', '--verbose', dest='verbose', help=config.help_verbose,
action='store_true', default=False)
# arguments handling, display command line if help or no arguments provided
ns = args_parser.parse_args()
input_cmdline = ' '.join(map(cmd_quote, sys.argv))
print('Working directory:', os.getcwd())
print('Command line:', input_cmdline)
run(ns)
def main():
parser = SanicArgumentParser(
prog="sanic",
description=BASE_LOGO,
formatter_class=lambda prog: RawTextHelpFormatter(
prog, max_help_position=33),
)
parser.add_argument(
"-v",
"--version",
action="version",
version=f"Sanic {__version__}; Routing {__routing_version__}",
)
parser.add_argument(
"--factory",
action="store_true",
help=("Treat app as an application factory, "
"i.e. a () -> <Sanic app> callable"),
)
parser.add_argument(
"-s",
"--simple",
dest="simple",
action="store_true",
help="Run Sanic as a Simple Server (module arg should be a path)\n ",
)
parser.add_argument(
"-H",
"--host",
dest="host",
type=str,
default="127.0.0.1",
help="Host address [default 127.0.0.1]",
)
parser.add_argument(
"-p",
"--port",
dest="port",
type=int,
default=8000,
help="Port to serve on [default 8000]",
)
parser.add_argument(
"-u",
"--unix",
dest="unix",
type=str,
default="",
help="location of unix socket\n ",
)
parser.add_argument("--cert",
dest="cert",
type=str,
help="Location of certificate for SSL")
parser.add_argument("--key",
dest="key",
type=str,
help="location of keyfile for SSL\n ")
parser.add_bool_arguments("--access-logs",
dest="access_log",
help="display access logs")
parser.add_argument(
"-w",
"--workers",
dest="workers",
type=int,
default=1,
help="number of worker processes [default 1]\n ",
)
parser.add_argument("-d", "--debug", dest="debug", action="store_true")
parser.add_argument(
"-r",
"--reload",
"--auto-reload",
dest="auto_reload",
action="store_true",
help="Watch source directory for file changes and reload on changes",
)
parser.add_argument(
"-R",
"--reload-dir",
dest="path",
action="append",
help="Extra directories to watch and reload on changes\n ",
)
parser.add_argument(
"module",
help=("Path to your Sanic app. Example: path.to.server:app\n"
"If running a Simple Server, path to directory to serve. "
"Example: ./\n"),
)
args = parser.parse_args()
try:
module_path = os.path.abspath(os.getcwd())
if module_path not in sys.path:
sys.path.append(module_path)
if args.simple:
path = Path(args.module)
app = create_simple_server(path)
else:
delimiter = ":" if ":" in args.module else "."
module_name, app_name = args.module.rsplit(delimiter, 1)
if app_name.endswith("()"):
args.factory = True
app_name = app_name[:-2]
module = import_module(module_name)
app = getattr(module, app_name, None)
if args.factory:
app = app()
app_type_name = type(app).__name__
if not isinstance(app, Sanic):
raise ValueError(
f"Module is not a Sanic app, it is a {app_type_name}. "
f"Perhaps you meant {args.module}.app?")
if args.cert is not None or args.key is not None:
ssl: Optional[Dict[str, Any]] = {
"cert": args.cert,
"key": args.key,
}
else:
ssl = None
kwargs = {
"host": args.host,
"port": args.port,
"unix": args.unix,
"workers": args.workers,
"debug": args.debug,
"access_log": args.access_log,
"ssl": ssl,
}
if args.auto_reload:
kwargs["auto_reload"] = True
if args.path:
if args.auto_reload or args.debug:
kwargs["reload_dir"] = args.path
else:
error_logger.warning(
"Ignoring '--reload-dir' since auto reloading was not "
"enabled. If you would like to watch directories for "
"changes, consider using --debug or --auto-reload.")
app.run(**kwargs)
except ImportError as e:
if module_name.startswith(e.name):
error_logger.error(
f"No module named {e.name} found.\n"
" Example File: project/sanic_server.py -> app\n"
" Example Module: project.sanic_server.app")
else:
raise e
except ValueError:
error_logger.exception("Failed to run app")
def custom_formatter(prog):
return RawTextHelpFormatter(prog,
max_help_position=50,
width=terminal_size.columns)
def hp(**kwargs):
return RawTextHelpFormatter(max_help_position=50, width=120, **kwargs)
def parseCmdLine():
"""Parse command line arguments"""
parser = ArgumentParser(
description="Connection and Auth example",
formatter_class=lambda prog: RawTextHelpFormatter(prog, width=99))
defaultUser = AuthUser.createWithLogonName()
defaultAuthOptions = AuthOptions.createWithUser(defaultUser)
parser.add_argument("--auth",
dest="auth",
help="authentication option: "
"user|none|app=<app>|userapp=<app>|dir=<property>|"
"manual=<app,ip,user>"
" (default: user)\n"
"'none' is applicable to Desktop API product "
"that requires Bloomberg Professional service "
"to be installed locally.",
metavar="option",
action=AuthOptionsAction,
default=defaultAuthOptions)
parser.add_argument("--host",
dest="host",
help="server name or IP, and port <ipAddress:port>"
"(default 'localhost:8194')",
metavar="<ipAddress:port>",
action=HostAction)
parser.add_argument("--retries",
dest="retries",
help="number of connection retries "
"(default: number of hosts)",
metavar="option",
type=int,
action=AuthOptionsAction)
# TLS Options
parser.add_argument("--tls-client-credentials",
dest="tls_client_credentials",
help="name a PKCS#12 file to use as a source of "
"client credentials",
metavar="option")
parser.add_argument("--tls-client-credentials-password",
dest="tls_client_credentials_password",
help="specify password for accessing"
" client credentials",
metavar="option",
default="")
parser.add_argument("--tls-trust-material",
dest="tls_trust_material",
help="name a PKCS#7 file to use as a source of trusted"
" certificates",
metavar="option")
parser.add_argument(
"--read-certificate-files",
dest="read_certificate_files",
help="(optional) read the TLS files and pass the blobs",
action="store_true")
args = parser.parse_args()
args.tlsOptions = getTlsOptions(args)
if not args.host:
args.host = [["localhost", 8194]]
if args.retries is None:
args.retries = len(args.host)
return args
def main(argv):
"""
'Ring in the New Year' puzzle solution: string encoding/decoding utility.
Individually processes a list of 'passwords', decoding those containining
a 'marker' character and encoding the rest, using an algorithm implemented
to solve the above-named puzzle.
HINT: Enclose each password in single quotes when running from a shell.
"""
parser = ArgumentParser(
description=dedent(main.__doc__),
formatter_class=lambda prog: RawTextHelpFormatter(prog, max_help_position=30))
parser.add_argument('passwords', nargs='*', type=str, metavar='password',
help="List of strings to encode/decode.")
parser.add_argument('-v', '--verbose', action='store_true', help='Show verbose output (intermediate states)')
parser.add_argument('-m', '--marker', type=str, default='$', help="Marker character [default: '$']")
args = parser.parse_args(argv)
log = logging.getLogger()
log.setLevel(logging.DEBUG if args.verbose else logging.INFO)
if len(args.marker) != 1:
log.warn(f"{parser.prog}: Provided marker must be a single character.")
parser.print_help()
return 2
if len(args.passwords) == 0:
log.warn("No password(s) provided to encode/decode!\n")
parser.print_help()
log.info(
"\nPreviewing encoder/decoder with default examples...\n" +
"$ ./ritny.py 'anagram' "
f"'endrtednedd:/os....cp.rnnn.rhhps/.tt{args.marker}sfeaiaaofd.ow.otooapa.asu./thhse'"
)
args.passwords = [
'anagram',
f'endrtednedd:/os....cp.rnnn.rhhps/.tt{args.marker}sfeaiaaofd.ow.otooapa.asu./thhse'
]
log.debug(f"Using marker: '{args.marker}'...\n")
outputs = []
for password in args.passwords:
if args.marker in password:
log.debug(f"Decoding:\n {password}")
output = decode(password, args.marker)
outputs.append(output)
log.debug(f"Decoded:\n {output}\n")
else:
log.debug(f"Encoding:\n {password}")
rotation_table = mark_and_rotate(password, args.marker)
rotation_display = '\n '.join(s for s in rotation_table)
log.debug(f"Rotation table:\n {rotation_display}")
sorted_table = sort(rotation_table, args.marker)
sort_display = '\n '.join(s for s in sorted_table)
log.debug(f"Sort table:\n {sort_display}")
output = last_chars(sorted_table)
log.debug(f"Encoded:\n {output}\n")
outputs.append(output)
log.info(' '.join(o for o in outputs))
def _split_lines(self, text, width):
return RawTextHelpFormatter._split_lines(self, text, width)
def my_formatter(prog):
return RawTextHelpFormatter(prog=prog,
max_help_position=90,
width=None)
def formatter_class(prog):
return RawTextHelpFormatter(prog,
max_help_position=max_help_position)
