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)