def main():
args = _init_args()
_patch_argparse(args.output_path)
# Importing module has the side-effect of writing flag data due to
# patched argparse.
base_args = util.shlex_split(args.base_args)
_exec_module(args.mod_path, args.package, base_args)
def _diff(path1, path2, args):
cmd_base = util.shlex_split(_diff_cmd(args))
cmd = cmd_base + [path1, path2]
log.debug("diff cmd: %r", cmd)
try:
subprocess.call(cmd)
except OSError as e:
cli.error("error running '%s': %s" % (" ".join(cmd), e))
def _diff(run1, run2, args):
cmd_base = util.shlex_split(_diff_cmd(args))
for path in _diff_paths(args):
dir1 = os.path.join(run1.path, path)
dir2 = os.path.join(run2.path, path)
cmd = cmd_base + [dir1, dir2]
log.debug("diff cmd: %r", cmd)
subprocess.call(cmd)
def _apply_source_script_function_to_part(part, fun_name, fun):
m = re.match(r"\$\(%s (.*?)\)" % fun_name, part)
if m is None:
return part
args = util.shlex_split(m.group(1))
fun, extra_args = fun
log.debug("Applying %s to %s", fun_name, args)
return fun(*(args + extra_args))
def _split_rename_spec(spec):
parts = util.shlex_split(spec)
if len(parts) == 2:
return parts
elif len(parts) == 1:
return ".*", parts[0]
else:
raise ResourceFormatError(
"invalid rename spec %r: expected 'PATTERN REPL' or 'NAME'" % spec)
def _opref_parse(encoded):
"""Parses encoded opref.
Format: PKG_TYPE_AND_NAME PKG_VER MODEL_NAME OP_NAME
See _opref_for_string for parsing a user-provided value.
"""
parts = util.shlex_split(encoded)
if len(parts) != 4:
raise OpRefError(encoded)
pkg_type_and_name, pkg_ver, model_name, op_name = parts
pkg_type, pkg_name = _split_pkg_type_and_name(pkg_type_and_name, encoded)
return OpRef(pkg_type, pkg_name, pkg_ver, model_name, op_name)
def _parse_run(self, data):
from guild.commands.run import run as run_cmd
run_spec = data.get("run", "").strip()
if not run_spec:
_error("invalid step %r: must define run" % data)
args = util.shlex_split(run_spec)
try:
ctx = run_cmd.make_context("run", args)
except click.exceptions.ClickException as e:
_error("invalid run spec %r: %s" % (run_spec, e))
else:
self._apply_data_params(data, ctx, run_spec)
return ctx.params
def _pdb_commands(module_info):
try:
encoded_breaks = os.environ["PDB_BREAKS"]
except KeyError:
return []
else:
unresolved_breaks = util.shlex_split(encoded_breaks)
commands = [
_pdb_break_cmd(_resolve_break(b, module_info))
for b in unresolved_breaks
]
commands.append(_pdb_continue_cmd())
return commands
def _decode_dask_resources(encoded, quiet=False):
from guild import op_util
args = util.shlex_split(encoded)
try:
return op_util.parse_flag_assigns(args)
except op_util.ArgValueError:
if not quiet:
log.warning(
"Ignoring invalid dask resources spec %r: parts must be in "
"format KEY=VAL",
encoded,
)
return {}
def split_cmd(cmd):
if isinstance(cmd, list):
return cmd
return util.shlex_split(cmd or "")
def _split_rename_spec(spec):
parts = util.shlex_split(spec)
if len(parts) != 2:
raise ResourceFormatError(
"invalid rename spec %r: expected 'PATTERN REPL'" % spec)
return parts
def split_encoded_flag_val(encoded, split_spec):
if split_spec is True or split_spec == "shlex":
return util.shlex_split(encoded)
else:
return _string_split(encoded, split_spec)
def _tags_not_in_label(tags, label):
if not tags:
return []
label_parts = util.shlex_split(label)
return [tag for tag in tags if tag not in label_parts]
def _run_shell_win_cmd(cmd):
cmd_norm_paths = cmd.replace(os.path.sep, "/")
parts = util.shlex_split(cmd_norm_paths)
_apply_guild_cmd_for_win(parts)
return parts
def _gpg_cmd():
gpg_env = os.getenv("GPG_CMD")
if gpg_env:
return util.shlex_split(gpg_env)
return ["gpg", "-d"]
def split_main(main):
if isinstance(main, list):
return main
return util.shlex_split(main or "")
def _nbexec_notebook_path(opdef):
argv = util.shlex_split(opdef.main)
assert argv and argv[0] == "guild.plugins.nbexec", (opdef.main, argv)
if len(argv) > 1:
return os.path.join(opdef.guildfile.dir, argv[1])
return None
