Add code to enforce expectations about input seurat objects

Author: bbimber

singlecell/resources/chunks/CheckExpectations.R

@@ -0,0 +1,51 @@
+for (datasetId in names(seuratObjects)) {
+  seuratObj <- readRDS(seuratObjects[[datasetId]])
+
+  if (requireSingleDatasetInput && length(unique(seuratObj$DatasetId)) > 1) {
+    addErrorMessage(paste0('Seurat data prototypes must be a single dataset. Problem ID: ', datasetId))
+  }
+
+  if (is.null(usesHashing[[datasetId]])) {
+    addErrorMessage(paste0('No hashing context provided for: ', datasetId))
+    break
+  }
+
+  if (usesHashing[[datasetId]] && requireHashing) {
+    if (!('HTO.Classification' %in% names(seuratObj@meta.data))) {
+      addErrorMessage(paste0('Missing cell hashing calls for dataset: ', datasetId))
+    }
+  }
+
+  if (is.null(usesCiteSeq[[datasetId]])) {
+    addErrorMessage(paste0('No CITE-seq context provided for: ', datasetId))
+    break
+  }
+
+  if (usesCiteSeq[[datasetId]] && requireCiteSeq) {
+    if (!'ADT' %in% names(seuratObj@assays)) {
+      addErrorMessage(paste0('Missing ADT data for dataset: ', datasetId))
+    }
+  }
+
+  if (requireSaturation && !'Saturation.RNA' %in% names(seuratObj@meta.data)) {
+    addErrorMessage(paste0('Missing per-cell RNA saturation data for dataset: ', datasetId))
+  }
+
+  if (requireSingleR && !'SingleRConsensus' %in% names(seuratObj@meta.data)) {
+    addErrorMessage(paste0('Missing SingleRConsensus label for dataset: ', datasetId))
+  }
+
+  if (requireScGate && !'scGateConsensus' %in% names(seuratObj@meta.data)) {
+    addErrorMessage(paste0('Missing scGateConsensus label for dataset: ', datasetId))
+  }
+
+  if (length(errorMessages) > 0) {
+    break
+  }
+
+  saveData(seuratObj, datasetId)
+
+  # Cleanup
+  rm(seuratObj)
+  gc()
+}

singlecell/resources/chunks/SeuratPrototype.R

@@ -61,8 +61,12 @@ for (datasetId in names(seuratObjects)) {
     metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'MeanSaturation.RNA', metricvalue = meanSaturation.RNA))
   }
 
-  if (requireSingleR && !'dice.label' %in% names(seuratObj@meta.data)) {
-    addErrorMessage(paste0('Missing SingleR DICE labels for dataset: ', datasetId))
+  if (requireSingleR && !'SingleRConsensus' %in% names(seuratObj@meta.data)) {
+    addErrorMessage(paste0('Missing SingleRConsensus label for dataset: ', datasetId))
+  }
+
+  if (requireScGate && !'scGateConsensus' %in% names(seuratObj@meta.data)) {
+    addErrorMessage(paste0('Missing scGateConsensus label for dataset: ', datasetId))
   }
 
   if (length(errorMessages) > 0) {

singlecell/src/org/labkey/singlecell/SingleCellModule.java

@@ -173,6 +173,7 @@ public static void registerPipelineSteps()
         SequencePipelineService.get().registerPipelineStep(new DropCiteSeq.Provider());
         SequencePipelineService.get().registerPipelineStep(new RunScGate.Provider());
         SequencePipelineService.get().registerPipelineStep(new RunCelltypist.Provider());
+        SequencePipelineService.get().registerPipelineStep(new CheckExpectations.Provider());
 
         SequenceAnalysisService.get().registerFileHandler(new NimbleAlignmentStep());
     }

singlecell/src/org/labkey/singlecell/pipeline/singlecell/CheckExpectations.java

@@ -0,0 +1,78 @@
+package org.labkey.singlecell.pipeline.singlecell;
+
+import org.labkey.api.pipeline.PipelineJobException;
+import org.labkey.api.sequenceanalysis.SequenceOutputFile;
+import org.labkey.api.sequenceanalysis.model.Readset;
+import org.labkey.api.sequenceanalysis.pipeline.AbstractPipelineStepProvider;
+import org.labkey.api.sequenceanalysis.pipeline.PipelineContext;
+import org.labkey.api.sequenceanalysis.pipeline.SequenceOutputHandler;
+import org.labkey.api.singlecell.CellHashingService;
+import org.labkey.api.singlecell.pipeline.SeuratToolParameter;
+import org.labkey.api.singlecell.pipeline.SingleCellStep;
+import org.labkey.singlecell.CellHashingServiceImpl;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class CheckExpectations extends AbstractCellMembraneStep
+{
+    public CheckExpectations(PipelineContext ctx, CheckExpectations.Provider provider)
+    {
+        super(provider, ctx);
+    }
+
+    public static class Provider extends AbstractPipelineStepProvider<SingleCellStep>
+    {
+        public Provider()
+        {
+            super("CheckExpectations", "Check Expectations", "CellMembrane", "This will tag the output of this job as a seurat prototype, which is designed to be a building block for subsequent analyses.", Arrays.asList(
+                    SeuratToolParameter.create("requireSingleDatasetInput", "Expect Single Datasets", "If checked, this will enforce that each input seurat object holds a single dataset. This is expected if the input is a seurat prototype. In contrast, if the input is a merged object this would test false", "checkbox", null, true),
+                    SeuratToolParameter.create("requireHashing", "Require Hashing, If Used", "If this dataset uses cell hashing, hashing calls are required", "checkbox", null, true),
+                    SeuratToolParameter.create("requireCiteSeq", "Require Cite-Seq, If Used", "If this dataset uses CITE-seq, cite-seq data are required", "checkbox", null, true),
+                    SeuratToolParameter.create("requireSaturation", "Require Per-Cell Saturation", "If this dataset uses TCR sequencing, these data are required", "checkbox", null, true),
+                    SeuratToolParameter.create("requireSingleR", "Require SingleR", "If checked, SingleR calls, including singleRConsensus are required to pass", "checkbox", null, true),
+                    SeuratToolParameter.create("requireScGate", "Require scGate", "If checked, scGateConsensus calls are required to pass", "checkbox", null, true)
+            ), null, null);
+        }
+
+        @Override
+        public CheckExpectations create(PipelineContext ctx)
+        {
+            return new CheckExpectations(ctx, this);
+        }
+    }
+
+    @Override
+    public void init(SequenceOutputHandler.JobContext ctx, List<SequenceOutputFile> inputFiles) throws PipelineJobException
+    {
+
+    }
+
+    @Override
+    protected Chunk createParamChunk(SequenceOutputHandler.JobContext ctx, List<SeuratObjectWrapper> inputObjects, String outputPrefix) throws PipelineJobException
+    {
+        Chunk ret = super.createParamChunk(ctx, inputObjects, outputPrefix);
+
+        ret.bodyLines.add("usesHashing <- list()");
+        ret.bodyLines.add("usesCiteSeq <- list()");
+
+        for (SeuratObjectWrapper so : inputObjects)
+        {
+            Readset parentReadset = ctx.getSequenceSupport().getCachedReadset(so.getSequenceOutputFile().getReadset());
+            if (parentReadset == null)
+            {
+                throw new PipelineJobException("Unable to find readset for outputfile: " + so.getSequenceOutputFileId());
+            }
+
+            Set<String> htosPerReadset = CellHashingServiceImpl.get().getHtosForParentReadset(parentReadset.getReadsetId(), ctx.getSourceDirectory(), ctx.getSequenceSupport(), false);
+            ret.bodyLines.add("usesHashing[['" + so.getDatasetId() + "']] <- " + (htosPerReadset.size() > 1 ? "TRUE" : "FALSE"));
+
+            boolean usesCiteseq = CellHashingService.get().usesCiteSeq(ctx.getSequenceSupport(), Collections.singletonList(so.getSequenceOutputFile()));
+            ret.bodyLines.add("usesCiteSeq[['" + so.getDatasetId() + "']] <- " + (usesCiteseq ? "TRUE" : "FALSE"));
+        }
+
+        return ret;
+    }
+}

singlecell/src/org/labkey/singlecell/pipeline/singlecell/SeuratPrototype.java

@@ -42,7 +42,8 @@ public Provider()
 
                     SeuratToolParameter.create("dietSeurat", "Run DietSeurat", "If checked, DietSeurat will be run, which removes reductions and extraneous data to save file size.", "checkbox", null, true),
 
-                    SeuratToolParameter.create("requireSingleR", "Require SingleR", "If checked, SingleR calls are required to pass", "checkbox", null, true)
+                    SeuratToolParameter.create("requireSingleR", "Require SingleR", "If checked, SingleR calls, including singleRConsensus are required to pass", "checkbox", null, true),
+                    SeuratToolParameter.create("requireScGate", "Require scGate", "If checked, scGateConsensus calls are required to pass", "checkbox", null, true)
             ), null, null);
         }