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