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 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."
)
