Python 当并非所有作业都成功地从以前的规则输出文件时，如何编写snakemake输入？

基本上，我有三个蛇形规则（而不是所有规则），尽管有检查点资源，但我无法解决这个问题

规则一有我的第一个也是唯一一个开始的文件。它将有x个输出（数量因输入文件而异）。这些x输出中的每一个都需要在规则2中单独处理，这意味着规则2将运行x个作业。但是，这些作业中只有一些子集y将产生输出（软件仅为通过某个阈值的输入写出文件）。所以，虽然 我希望这些输出中的每一个在作业3中作为单独的作业运行，我不知道规则2会产生多少文件。规则3还将运行y个作业，规则2的每个成功输出对应一个作业。我有两个问题。第一个问题是我如何编写规则3的输入，而不知道规则2会产生多少文件？第二个问题是，当输入文件没有相应数量的输出文件时，我如何“告诉”规则2它是如何完成的？如果我添加第四条规则，我想它会尝试在没有得到输出文件的作业上重新运行第二条规则，这将永远不会产生输出。也许我在设置检查站时遗漏了什么

比如：

rule a:
     input: file.vcf
     output: dummy.txt
     shell:"""
      .... make unknown number of output files (x) x_1 , x_2, ..., x_n 
           """ 
#run a separate job from each output of rule a
rule b:
     input: x_1 #not sure how many are going to be inputs here
     output: y_1 #not sure how many output files will be here
     shell:"""
           some of the x inputs will output their corresponding y, but others will have no output
           """
#run a separate job for each output of rule b
rule c:
     input: y_1 #not sure how many input files here
     output: z_1
 

---

您应该将

规则a

更改为注释中提到的检查点<代码>规则b将为每个输入生成一个输出，并且可以保持原样，与本例中的规则c相同

最终，您将有一个类似于聚合的规则来决定需要哪些输出。它可能是规则d，也可能最终成为规则all。无论哪种方式，聚合规则都需要一个输入函数来调用检查点以确定存在哪些文件。如果您按照下面的步骤进行操作，您将得到如下结果：

rule a:
     input: file.vcf
     output: dummy.txt
     shell:"""
      .... make unknown number of output files (x) x_1 , x_2, ..., x_n 
           """ 
#run a separate job from each output of rule a
rule b:
     input: x_1 #not sure how many are going to be inputs here
     output: y_1 #not sure how many output files will be here
     shell:"""
           some of the x inputs will output their corresponding y, but others will have no output
           """
#run a separate job for each output of rule b
rule c:
     input: y_1 #not sure how many input files here
     output: z_1
 

检查点a：
输入：file.vcf
输出：目录（'output_dir'）
shell:“”
mkdir{output}#然后将所有输出文件放在这里！
..生成未知数量的输出文件（x）x_1，x_2，…，x_n
""" 
#从规则a的每个输出运行单独的作业
规则b：
输入：输出目录/x{n}
输出：y{n}
shell:“”
一些x输入将输出相应的y，但其他输入将没有输出
"""
#为规则b的每个输出运行单独的作业
规则c：
输入：y{n}
输出：z_{n}
#规则聚合的输入函数
def聚合_输入（通配符）：
checkpoint_output=checkpoints.a.get（**通配符）。输出[0]
返回expand（“z_{i}”，
i=glob_通配符（os.path.join（checkpoint_输出，“x_{i}.txt”）.i）
规则聚合：#如何处理所有z文件？可能是全部
输入：聚合输入

如果您认为您的工作流像一棵树，那么规则a是使用数量可变的分支进行分支的。规则b和c是一对一的映射。聚合将所有分支重新组合在一起，并负责检查存在多少分支。规则b和c只看到一个输入/输出，不关心还有多少其他分支

编辑以回答注释中的问题，并修复了我代码中的几个错误：

---

不过，我在这里仍然感到困惑，因为规则b的输出不会像输入那样多，所以在检查点a的输出中的所有通配符都出现在z_{n}中之前，规则聚合不会运行吗

这是令人困惑的，因为这不是蛇形游戏通常的工作方式，并导致了很多问题。您需要记住的是，当运行

checkpoints..get

时，该步骤的计算实际上会暂停。考虑<代码> i＝=（1, 2, 3）< /代码>的三个值的简单情况，但仅在<代码>检查点A < /代码>中创建<代码> i＝2和3 < /代码>。我们知道DAG将如下所示：

rule             file
input           file.vcf
             /     |     \
a                 x_2    x_3
                   |      |
b                 y_2    y_3
                   |      |
c                 z_2    z_3
                    \     /
aggregate           OUTPUT

rule             file
input           file.vcf
                   |     
a                 ...
                   |     
????              ...
                   |     
aggregate        OUTPUT

其中，

检查点a

缺少

x_1

。但是，snakemake不知道检查点a的行为，只知道它会将一个目录作为输出，并且（因为它是一个检查点），一旦完成，DAG将被重新评估。因此，如果您运行

snakemake-nq

，您将看到

检查点a

和

聚集

将运行，但没有提到

b

或

c

。在这一点上，这些是snakemake知道并计划运行的唯一规则。调用

checkpoint..get

基本上是说“在这里等待，在这个规则之后，您将必须查看所做的”

因此，当snakemake首次开始运行您的工作流时，DAG如下所示：

rule             file
input           file.vcf
             /     |     \
a                 x_2    x_3
                   |      |
b                 y_2    y_3
                   |      |
c                 z_2    z_3
                    \     /
aggregate           OUTPUT

rule             file
input           file.vcf
                   |     
a                 ...
                   |     
????              ...
                   |     
aggregate        OUTPUT

Snakemake不知道规则

a

和

aggregate

之间发生了什么，只知道它需要运行

a

才能判断

rule             file
input           file.vcf
             /     |     \
a                 x_2    x_3
                        
????              ...
                   |     
aggregate        OUTPUT

检查点

a

被调度、运行，现在DAG被重新评估。

aggregate\u input

的其余部分查看带有

glob\u通配符的文件，然后使用该信息决定需要哪些文件。请注意，扩展正在请求来自
规则c
的输出，该规则要求
规则b
，该规则要求
x{n}
，检查点运行后该规则即存在。现在snakemake可以构建您期望的DAG

下面是带有更多注释的输入函数，希望能说明这一点：

def聚合_输入（通配符）：
#假设此规则取决于检查点。DAG评估在此暂停
checkpoint_output=checkpoints.a.get（**通配符）。输出[0]
#此时，检查点a已完成，输出（目录）
#在检查点_输出中。那里有一些文件
#使用glob_通配符查找实际存在的x_{i}文件
found_files=glob_通配符（os.path.join（checkpoint_输出，“x_{i}.txt”））.i
#现在我们知道我们需要创建所有z文件*如果*存在x文件。
返回expand（“z_{i}”，i=found_文件）
我还不太清楚：您的规则b是否应该运行一次（使用seve）