def target(self, paths): if not_iterable(paths): path = paths path = path if os.path.isabs(path) else os.path.join( self.workdir, path) return flag(path, "subworkflow", self) return [self.target(path) for path in paths]
def modify(self, path, property=None): if get_flag_value(path, PATH_MODIFIER_FLAG) is self: # Path has been modified before and is reused now, no need to modify again. return path modified_path = self.apply_default_remote(self.replace_prefix(path, property)) if modified_path == path: # nothing has changed return path # Important, update with previous flags in case of AnnotatedString #596 if hasattr(path, "flags"): if not hasattr(modified_path, "flags"): modified_path = AnnotatedString(modified_path) modified_path.flags.update(path.flags) # Flag the path as modified and return. modified_path = flag(modified_path, PATH_MODIFIER_FLAG, self) return modified_path
def target(self, paths): if not_iterable(paths): return flag(os.path.join(self.workdir, paths), "subworkflow", self) return [self.target(path) for path in paths]
def _set_inoutput_item(self, item, output=False, name=None): """ Set an item to be input or output. Arguments item -- the item inoutput -- a Namedlist of either input or output items name -- an optional name for the item """ inoutput = self.output if output else self.input # Check to see if the item is a path, if so, just make it a string if isinstance(item, Path): item = str(item) if isinstance(item, str): if ON_WINDOWS: if isinstance(item, (_IOFile, AnnotatedString)): item = item.new_from(item.replace(os.sep, os.altsep)) else: item = item.replace(os.sep, os.altsep) rule_dependency = None if isinstance(item, _IOFile) and item.rule and item in item.rule.output: rule_dependency = item.rule if output: path_modifier = self.output_modifier property = "output" else: path_modifier = self.input_modifier property = "input" item = self.apply_path_modifier(item, path_modifier, property=property) # Check to see that all flags are valid # Note that "remote", "dynamic", and "expand" are valid for both inputs and outputs. if isinstance(item, AnnotatedString): for item_flag in item.flags: if not output and item_flag in [ "protected", "temp", "temporary", "directory", "touch", "pipe", "service", "ensure", ]: logger.warning( "The flag '{}' used in rule {} is only valid for outputs, not inputs." .format(item_flag, self)) if output and item_flag in ["ancient"]: logger.warning( "The flag '{}' used in rule {} is only valid for inputs, not outputs." .format(item_flag, self)) # add the rule to the dependencies if rule_dependency is not None: self.dependencies[item] = rule_dependency if output: item = self._update_item_wildcard_constraints(item) else: if (contains_wildcard_constraints(item) and self.workflow.mode != Mode.subprocess): logger.warning( "Wildcard constraints in inputs are ignored. (rule: {})" .format(self)) if self.workflow.all_temp and output: # mark as temp if all output files shall be marked as temp item = flag(item, "temp") # record rule if this is an output file output _item = IOFile(item, rule=self) if is_flagged(item, "temp"): if output: self.temp_output.add(_item) if is_flagged(item, "protected"): if output: self.protected_output.add(_item) if is_flagged(item, "touch"): if output: self.touch_output.add(_item) if is_flagged(item, "dynamic"): if output: self.dynamic_output.add(_item) else: self.dynamic_input.add(_item) if is_flagged(item, "report"): report_obj = item.flags["report"] if report_obj.caption is not None: r = ReportObject( self.workflow.current_basedir.join(report_obj.caption), report_obj.category, report_obj.subcategory, report_obj.labels, report_obj.patterns, report_obj.htmlindex, ) item.flags["report"] = r if is_flagged(item, "subworkflow"): if output: raise SyntaxError( "Only input files may refer to a subworkflow") else: # record the workflow this item comes from sub = item.flags["subworkflow"] if _item in self.subworkflow_input: other = self.subworkflow_input[_item] if sub != other: raise WorkflowError( "The input file {} is ambiguously " "associated with two subworkflows " "{} and {}.".format(item, sub, other), rule=self, ) self.subworkflow_input[_item] = sub inoutput.append(_item) if name: inoutput._add_name(name) elif callable(item): if output: raise SyntaxError( "Only input files can be specified as functions") inoutput.append(item) if name: inoutput._add_name(name) else: try: start = len(inoutput) for i in item: self._set_inoutput_item(i, output=output) if name: # if the list was named, make it accessible inoutput._set_name(name, start, end=len(inoutput)) except TypeError: raise SyntaxError( "Input and output files have to be specified as strings or lists of strings." )