def expand_output(self, wildcards):
output = OutputFiles(o.apply_wildcards(wildcards) for o in self.output)
output.take_names(self.output.get_names())
mapping = {f: f_ for f, f_ in zip(output, self.output)}
for f in output:
f.check()
return output, mapping
def expand_output(self, wildcards):
output = OutputFiles(o.apply_wildcards(wildcards) for o in self.output)
output.take_names(self.output.get_names())
mapping = {f: f_ for f, f_ in zip(output, self.output)}
for f in output:
f.check()
# Note that we do not need to check for duplicate file names after
# expansion as all output patterns have contain all wildcards anyway.
return output, mapping
def expand_wildcards(self, wildcards=None):
"""
Expand wildcards depending on the requested output
or given wildcards dict.
"""
def concretize_iofile(f, wildcards):
if not isinstance(f, _IOFile):
return IOFile(f, rule=self)
else:
return f.apply_wildcards(
wildcards,
fill_missing=f in self.dynamic_input,
fail_dynamic=self.dynamic_output)
def _apply_wildcards(
newitems,
olditems,
wildcards,
wildcards_obj,
concretize = apply_wildcards,
ruleio = None):
for name, item in olditems.allitems():
start = len(newitems)
if callable(item):
item = item(wildcards_obj)
if not_iterable(item):
item = [item]
for item_ in item:
if not isinstance(item_, str):
raise RuleException("Input function did not return str or list of str.", rule=self)
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
else:
if not_iterable(item):
item = [item]
for item_ in item:
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
if name:
newitems.set_name(name, start, end=len(newitems))
if wildcards is None:
wildcards = dict()
# TODO validate
missing_wildcards = self.wildcard_names - set(wildcards.keys())
if missing_wildcards:
raise RuleException(
"Could not resolve wildcards in rule {}:\n{}".format(
self.name, "\n".join(self.wildcard_names)),
lineno=self.lineno, snakefile=self.snakefile)
ruleio = dict()
try:
input = InputFiles()
wildcards_obj = Wildcards(fromdict=wildcards)
_apply_wildcards(input, self.input, wildcards, wildcards_obj,
concretize=concretize_iofile, ruleio=ruleio)
params = Params()
_apply_wildcards(params, self.params, wildcards, wildcards_obj)
output = OutputFiles(
o.apply_wildcards(wildcards) for o in self.output)
output.take_names(self.output.get_names())
ruleio.update(dict((f, f_) for f, f_ in zip(output, self.output)))
log = self.log.apply_wildcards(wildcards) if self.log else None
return input, output, params, log, ruleio
except WildcardError as ex:
# this can only happen if an input contains an unresolved wildcard.
raise RuleException(
"Wildcards in input or log file of rule {} cannot be "
"determined from output files:\n{}".format(self, str(ex)),
lineno=self.lineno, snakefile=self.snakefile)
def expand_wildcards(self, wildcards=None):
"""
Expand wildcards depending on the requested output
or given wildcards dict.
"""
def concretize_iofile(f, wildcards):
if not isinstance(f, _IOFile):
return IOFile(f, rule=self)
else:
return f.apply_wildcards(wildcards,
fill_missing=f in self.dynamic_input,
fail_dynamic=self.dynamic_output)
def concretize_param(p, wildcards):
if isinstance(p, str):
return apply_wildcards(p, wildcards)
return p
def check_string_type(f):
if not isinstance(f, str):
raise RuleException(
"Input function did not return str or list of str.",
rule=self)
def _apply_wildcards(newitems,
olditems,
wildcards,
wildcards_obj,
concretize=apply_wildcards,
check_return_type=check_string_type,
ruleio=None,
no_flattening=False):
for name, item in olditems.allitems():
start = len(newitems)
is_iterable = True
if callable(item):
try:
item = item(wildcards_obj)
except (Exception, BaseException) as e:
raise InputFunctionException(e,
rule=self,
wildcards=wildcards)
if not_iterable(item) or no_flattening:
item = [item]
is_iterable = False
for item_ in item:
check_return_type(item_)
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
if name:
newitems.set_name(
name,
start,
end=len(newitems) if is_iterable else None)
if wildcards is None:
wildcards = dict()
missing_wildcards = self.wildcard_names - set(wildcards.keys())
if missing_wildcards:
raise RuleException(
"Could not resolve wildcards in rule {}:\n{}".format(
self.name, "\n".join(self.wildcard_names)),
lineno=self.lineno,
snakefile=self.snakefile)
ruleio = dict()
try:
input = InputFiles()
wildcards_obj = Wildcards(fromdict=wildcards)
_apply_wildcards(input,
self.input,
wildcards,
wildcards_obj,
concretize=concretize_iofile,
ruleio=ruleio)
params = Params()
#When applying wildcards to params, the return type need not be
#a string, so the check is disabled.
_apply_wildcards(params,
self.params,
wildcards,
wildcards_obj,
concretize=concretize_param,
check_return_type=lambda x: None,
no_flattening=True)
output = OutputFiles(
o.apply_wildcards(wildcards) for o in self.output)
output.take_names(self.output.get_names())
dependencies = {
None if f is None else f.apply_wildcards(wildcards): rule
for f, rule in self.dependencies.items()
}
ruleio.update(dict((f, f_) for f, f_ in zip(output, self.output)))
log = Log()
_apply_wildcards(log,
self.log,
wildcards,
wildcards_obj,
concretize=concretize_iofile)
benchmark = self.benchmark.apply_wildcards(
wildcards) if self.benchmark else None
return input, output, params, log, benchmark, ruleio, dependencies
except WildcardError as ex:
# this can only happen if an input contains an unresolved wildcard.
raise RuleException(
"Wildcards in input, params, log or benchmark file of rule {} cannot be "
"determined from output files:\n{}".format(self, str(ex)),
lineno=self.lineno,
snakefile=self.snakefile)
def expand_wildcards(self, wildcards=None):
"""
Expand wildcards depending on the requested output
or given wildcards dict.
"""
def concretize_iofile(f, wildcards):
if not isinstance(f, _IOFile):
return IOFile(f, rule=self)
else:
return f.apply_wildcards(wildcards,
fill_missing=f in self.dynamic_input,
fail_dynamic=self.dynamic_output)
def concretize_param(p, wildcards):
if isinstance(p, str):
return apply_wildcards(p, wildcards)
return p
def check_string_type(f):
if not isinstance(f, str):
raise RuleException(
"Input function did not return str or list of str.",
rule=self)
def _apply_wildcards(newitems, olditems, wildcards, wildcards_obj,
concretize=apply_wildcards,
check_return_type=check_string_type,
ruleio=None,
no_flattening=False):
for name, item in olditems.allitems():
start = len(newitems)
is_iterable = True
if callable(item):
try:
item = item(wildcards_obj)
except (Exception, BaseException) as e:
raise InputFunctionException(e, rule=self, wildcards=wildcards)
if not_iterable(item) or no_flattening:
item = [item]
is_iterable = False
for item_ in item:
check_return_type(item_)
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
if name:
newitems.set_name(
name, start,
end=len(newitems) if is_iterable else None)
if wildcards is None:
wildcards = dict()
missing_wildcards = self.wildcard_names - set(wildcards.keys())
if missing_wildcards:
raise RuleException(
"Could not resolve wildcards in rule {}:\n{}".format(
self.name, "\n".join(self.wildcard_names)),
lineno=self.lineno,
snakefile=self.snakefile)
ruleio = dict()
try:
input = InputFiles()
wildcards_obj = Wildcards(fromdict=wildcards)
_apply_wildcards(input, self.input, wildcards, wildcards_obj,
concretize=concretize_iofile,
ruleio=ruleio)
params = Params()
#When applying wildcards to params, the return type need not be
#a string, so the check is disabled.
_apply_wildcards(params, self.params, wildcards, wildcards_obj,
concretize=concretize_param,
check_return_type=lambda x: None,
no_flattening=True)
output = OutputFiles(o.apply_wildcards(wildcards)
for o in self.output)
output.take_names(self.output.get_names())
dependencies = {
None if f is None else f.apply_wildcards(wildcards): rule
for f, rule in self.dependencies.items()
}
ruleio.update(dict((f, f_) for f, f_ in zip(output, self.output)))
log = Log()
_apply_wildcards(log, self.log, wildcards, wildcards_obj,
concretize=concretize_iofile)
benchmark = self.benchmark.apply_wildcards(
wildcards) if self.benchmark else None
return input, output, params, log, benchmark, ruleio, dependencies
except WildcardError as ex:
# this can only happen if an input contains an unresolved wildcard.
raise RuleException(
"Wildcards in input, params, log or benchmark file of rule {} cannot be "
"determined from output files:\n{}".format(self, str(ex)),
lineno=self.lineno,
snakefile=self.snakefile)
def expand_wildcards(self, wildcards=None):
"""
Expand wildcards depending on the requested output
or given wildcards dict.
"""
def concretize_iofile(f, wildcards):
if not isinstance(f, _IOFile):
return IOFile(f, rule=self)
else:
return f.apply_wildcards(wildcards,
fill_missing=f in self.dynamic_input,
fail_dynamic=self.dynamic_output)
def _apply_wildcards(newitems,
olditems,
wildcards,
wildcards_obj,
concretize=apply_wildcards,
ruleio=None):
for name, item in olditems.allitems():
start = len(newitems)
if callable(item):
item = item(wildcards_obj)
if not_iterable(item):
item = [item]
for item_ in item:
if not isinstance(item_, str):
raise RuleException(
"Input function did not return str or list of str.",
rule=self)
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
else:
if not_iterable(item):
item = [item]
for item_ in item:
concrete = concretize(item_, wildcards)
newitems.append(concrete)
if ruleio is not None:
ruleio[concrete] = item_
if name:
newitems.set_name(name, start, end=len(newitems))
if wildcards is None:
wildcards = dict()
# TODO validate
missing_wildcards = self.wildcard_names - set(wildcards.keys())
if missing_wildcards:
raise RuleException(
"Could not resolve wildcards in rule {}:\n{}".format(
self.name, "\n".join(self.wildcard_names)),
lineno=self.lineno,
snakefile=self.snakefile)
ruleio = dict()
try:
input = InputFiles()
wildcards_obj = Wildcards(fromdict=wildcards)
_apply_wildcards(input,
self.input,
wildcards,
wildcards_obj,
concretize=concretize_iofile,
ruleio=ruleio)
params = Params()
_apply_wildcards(params, self.params, wildcards, wildcards_obj)
output = OutputFiles(
o.apply_wildcards(wildcards) for o in self.output)
output.take_names(self.output.get_names())
ruleio.update(dict((f, f_) for f, f_ in zip(output, self.output)))
log = self.log.apply_wildcards(wildcards) if self.log else None
return input, output, params, log, ruleio
except WildcardError as ex:
# this can only happen if an input contains an unresolved wildcard.
raise RuleException(
"Wildcards in input or log file of rule {} cannot be "
"determined from output files:\n{}".format(self, str(ex)),
lineno=self.lineno,
snakefile=self.snakefile)
