def perform(self, targs):
for plx_dest, opt in self.plx_argdefs.items():
dest = opt.kwargs.get("dest", opt.vargs[0])
if dest in self._env["__arguments__"]:
argval = self._env["__arguments__"].pop(dest, None)
self._env["__arguments__"][plx_dest] = argval
out = self.run_section(self.plx_entry_body)
if out == 0:
for hdr, body in self.plx_sections:
# check hdr
if hdr.endswith("*"):
special_sec = True
opt = parse_param_option(hdr[:-1], False,
self.parent.shared)
else:
special_sec = False
opt = parse_param_option(hdr, False, self.parent.shared)
env = dict(self.parent.shared)
env["__builtins__"] = pyloco_builtins
sec_check = all([eval(c, env) for c in opt.context])
if sec_check:
sec_name = opt.vargs[0]
# find sec_handler
if special_sec:
if sec_name in self._section_handlers:
sec_handler = self._section_handlers[sec_name]
else:
raise UsageError(
"Special section '%s' is not registered."
" Please register first." % sec_name)
else:
sec_handler = self.run_section
out = sec_handler(body, *opt.vargs[1:], **opt.kwargs)
return out
def test_section(self, hdr, body):
# check hdr
if hdr.endswith("*"):
special_sec = True
opt = parse_param_option(hdr[:-1], False,
self.parent.shared)
else:
special_sec = False
opt = parse_param_option(hdr, False, self.parent.shared)
env = dict(self.parent.shared)
env["__builtins__"] = pyloco_builtins
sec_check = all([eval(c, env) for c in opt.context])
if sec_check:
sec_name = opt.vargs[0]
# find sec_handler
if special_sec:
if sec_name in self._section_handlers:
sec_handler = self._section_handlers[sec_name]
else:
raise UsageError(
"Special section '%s' is not registered."
" Please register first." % sec_name
)
else:
sec_handler = self.run_section
return sec_handler(body, *opt.vargs[1:], **opt.kwargs)
else:
return 0
def collect_plx_command(item):
line = None
plx_cmd = None
match = _re_plxcmd.match(item)
if match:
args = item[:match.span()[1] - 1]
opt = parse_param_option(args, False, None)
plx_cmd = (opt, item[match.span()[1]:])
else:
line = item
return plx_cmd, line
def __call__(self, data):
self.env["__defer__"] = not self.evaluate
l1 = data.replace("{", "{{").replace("}", "}}")
l2 = l1.replace("_{{", "{").replace("}}_", "}")
data = pyloco_formatter.vformat(l2, [], self.env)
#data = pyloco_formatter.vformat(data, [], self.env)
self.env.pop("__defer__")
if self.param_parse:
out = parse_param_option(data, self.evaluate, self.env)
elif self.evaluate:
out = eval(data, self.env, {})
else:
out = data
if isinstance(out, Option):
for varg in out.vargs:
if not type_check(varg, self.arg_type):
out = self._tryconv(varg)
for kwarg in out.kwargs.values():
if not type_check(kwarg, self.arg_type):
out = self._tryconv(kwarg)
elif not type_check(out, self.arg_type):
out = self._tryconv(out)
if out and self.dest:
if self.arg_nargs or self.arg_action in ("append", "append_const"):
if self.dest not in self.env["__arguments__"]:
self.env["__arguments__"][self.dest] = []
self.env["__arguments__"][self.dest].append(out)
else:
self.env["__arguments__"][self.dest] = out
return out
def _setup(self, taskpath):
self.plx_entry_section, self.plx_attr_section, self.plx_sections = \
read_plx(taskpath)
self.plx_entry_body, self.plx_argdefs, self.plx_fwddefs, \
self.plx_shrdefs = [], {}, {}, {}
self._env["__file__"] = os.path.abspath(taskpath)
for line in self.plx_entry_section[1]:
_match, _line = collect_plx_command(line)
if _match:
opt = _match[0]
name = opt.vargs[0]
ctx = opt.context[0]
if ctx == "arg":
rhs = parse_param_option(_match[1], True, None)
self.plx_argdefs[name] = rhs
elif ctx == "forward":
rhs = parse_param_option(_match[1], True, None)
self.plx_fwddefs[name] = rhs
elif ctx == "shared":
rhs = parse_param_option(_match[1], True, None)
self.plx_shrdefs[name] = rhs
else:
self.plx_entry_body.append(line)
if _line is not None:
self.plx_entry_body.append(_line)
for opt in self.plx_argdefs.values():
if opt.vargs:
if opt.vargs[0].startswith("-"):
self.add_option_argument(*opt.vargs, **opt.kwargs)
else:
self.add_data_argument(*opt.vargs, **opt.kwargs)
for fwd in self.plx_fwddefs.values():
self.register_forward(*fwd.vargs, **fwd.kwargs)
for shr in self.plx_shrdefs.values():
self.add_shared(*opt.vargs, **opt.kwargs)
self._section_handlers = {
"forward": self.run_forward_section,
"shared": self.run_shared_section,
}
self._command_handlers = {
"shell": self.run_shell_command,
"manager": self.run_manager_command,
}
lenv = {}
if self.plx_attr_section:
self.run_section(self.plx_attr_section[1], lenv=lenv)
for key, value in lenv.items():
if key in ("_doc_", ):
setattr(self, "_%s_" % key, value)
setattr(self, key, value)
if "_name_" not in lenv:
_, self._name_ = os.path.split(taskpath)
def perform(self, targs):
path = TaskPath()
items = []
for s in self.subargv:
if s == "--":
self._append_task(path, items)
else:
items.append(s)
if items:
self._append_task(path, items)
# clone if specified in argv
if targs.clone:
evaluated = parse_param_option(str(targs.clone), True, self._env)
argument = evaluated.kwargs.pop("_argument_", None)
if evaluated.vargs:
numclone = len(evaluated.vargs)
elif argument:
numclone = len(argument)
elif evaluated.kwargs:
numclone = len(list(evaluated.kwargs.values())[0])
else:
raise UsageError("No data for clone is specified.")
for idx, path in enumerate(self.copy_taskpath(path, numclone)):
self.connect_taskpath(self, path, self)
if evaluated.vargs:
if len(evaluated.vargs) != numclone:
raise UsageError("The number of clone data mismatch")
self.load_data(path, data=evaluated.vargs[idx])
if argument:
if len(argument) != numclone:
raise UsageError("The number of clone data mismatch")
self.append_argument(path, argument[idx])
if evaluated.kwargs:
params = {}
for k, v in evaluated.kwargs.items():
if len(v) != numclone:
raise UsageError("The number of clone data mismatch")
params[k] = v[idx]
self.append_parameter(path, params)
else:
self.connect_taskpath(self, path, self)
self.load_data(path, **self._data)
if targs.reduce:
self._reduce_args = targs.reduce