@@ -7,13 +7,24 @@ sudo: false

 warnings_are_errors: false

 bioc_required: true

+# Current version of xgboost fails install

+# Need to force install older version using 'devtools::install_version'

+#    which is done in 'before_install' (see below) 

+# However 'remotes::dev_package_deps' will try to auto upgrade packages

+#    Therefore, a new install command is used with 'upgrade="never"'

+# These parts can be deleted once the xgboost error is fixed

+

 before_install:

   - pyenv install 3.6.1

   - pyenv global 3.6.1

-  - Rscript -e 'update.packages(ask = FALSE)'

+  - Rscript -e 'install.packages("devtools")'

+  - Rscript -e 'devtools::install_version("xgboost", version = "0.90.0.2", repos = "http://cran.us.r-project.org")'

   - pip install --upgrade pip

   - pip install scipy scrublet scanpy scanorama scgen bbknn

+install:

+- R -e 'devtools::install_deps(dep = TRUE, upgrade="never")'

+

 addons:

   apt:

     packages:

@@ -23,6 +34,7 @@ r_build_args: "--no-build-vignettes"

 r_check_args: "--no-vignettes --no-build-vignettes --as-cran"

 r_github_packages:

   - jimhester/lintr

+

 notifications:

   slack:

     secure: sw/He3WX7Fs61DTufgG9hx7fWDhwx57zv+dYB4sr30LgKyIJNbZYSU76ZN4oPwHFGAJ0eyk/22XCuKF8/seSB2ArQuc4kFlsaeWWg1CxDqW9iR0zs91MJL3lJoUOSayy5WcWbsUxD+x8GcB37FCgoTXcveN956bfgrDb2nGrFY6QMSVsnkWi/kiMdzhR4VPzOfmAUZUcr1aDU3WN4ROwbDg89zCfu9HbVKZwyQdYZk7L2Pgg8xGIcGZkaMN1MMD/r0Wc2aVYqCOcn5qO/9CaspEBf7cd6ejVzgAl/LM4dTIPlx9E6ekQGwJXpt1Qxyc0sqVSQWFZvFkWyV3wkqX8pfSXV6ojlP2cGJt+PSQXwLHj0TKWYx7yHbw+55da/b//SVLZVHl+P6VXxQBe2hmFD6sCk3V3uq2CkxzI52bK4Wv4RRncVKIZEpFZOc9P2ik5mf6pICmLHwttlbHeDjJbQ+raYftF704xb1sOxapLwuy+c2SWKPeqOiimfZNgOK+J7JbvQvpnaiHN+3CA3wQXs1auKBwI+swvsZPAzeKssnLv/0AQmX8ckVzvXJzUvl1J73c9V2zG2F44xmIsXwzruEp6leSbeXcLifrfbfQdmaHzq4M/Z83o/fwGRzdWfG7YXDyPIabik7DOMrSUvF+wLGVTjOart8HrA4eVEkKFnRE=

@@ -33,6 +33,7 @@ Imports:

     ape,

     batchelor,

     BiocGenerics,

+    BiocParallel,

     colourpicker,

     cowplot,

     cluster,

@@ -15,6 +15,7 @@ export(convertSeuratToSCE)

 export(createSCE)

 export(distinctColors)

 export(enrichRSCE)

+export(exportSCEtoAnnData)

 export(exportSCEtoFlatFile)

 export(filterSCData)

 export(generateSimulatedData)

@@ -31,6 +32,7 @@ export(importCellRangerV2)

 export(importCellRangerV2Sample)

 export(importCellRangerV3)

 export(importCellRangerV3Sample)

+export(importDropEst)

 export(importOptimus)

 export(importSEQC)

 export(importSTARsolo)

@@ -37,9 +37,9 @@

 #' Two batches of pancreas scRNAseq dataset are combined with their original

 #' counts. Cell types and batches are annotated in `colData(sceBatches)`.

 #' Two batches came from Wang, et al., 2016, annotated as `'w'`; and Xin, et

-#' al., 2016, annotated as `'x'`. Four common cell types, `'alpha'`, `'beta'`,

-#' `'gamma'`, and `'delta'` that could be found in both original study were kept

-#' for cleaner demonstration.

+#' al., 2016, annotated as `'x'`. Two common cell types, `'alpha'` and 

+#' `'beta'`, that could be found in both original studies with relatively 

+#' large population were kept for cleaner demonstration.

 #'

 #' @name sceBatches

 #' @docType data

@@ -49,3 +49,17 @@

 #' @examples

 #' data('sceBatches')

 "sceBatches"

+

+#' Stably Expressed Gene (SEG) list obect, with SEG sets for human and mouse.

+#' 

+#' The two gene sets came from dataset called `segList` of package `scMerge`.

+#' @name SEG

+#' @docType data

+#' @format list, with two entries `"human"` and `"mouse"`, each is a charactor

+#' array.

+#' @source `data('segList', package='scMerge')``

+#' @keywords datasets

+#' @examples 

+#' data('SEG')

+#' humanSEG <- SEG$human

+"SEG"

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,63 @@

+#source: https://github.com/klmr/decorator

+

+`%@%` = function (decorator, f) UseMethod('%@%')

+

+`%@%.default` = function (decorator, f)

+  stop(deparse(substitute(decorator)), ' is not a decorator')

+

+`%@%.decorator` = function (decorator, f) {

+  pretty_decorators = as.list(match.call())[-1]

+  # Patch delayed decorator.

+  if (! is.null({pretty_patched = attr(decorator, 'calls')}))

+    pretty_decorators = c(pretty_patched, pretty_decorators[-1])

+  

+  # Handle operator precedence so that we can chain decorators.

+  if (inherits(f, 'decorator'))

+    .delayed_decorate(decorator, f, pretty_decorators)

+  else

+    prettify(decorator(f), f, pretty_decorators[-length(pretty_decorators)])

+}

+

+decorator = function (f)

+  structure(f, class = 'decorator')

+

+decorator = decorator(decorator)

+

+print.decorated = function (x, useSource = TRUE, ...) {

+  bare = function (f) {

+    bare = unclass(f)

+    attr(bare, 'decorators') = NULL

+    bare

+  }

+  

+  fun_def = capture.output(print.function(bare(x), useSource = useSource, ...))

+  for (decorator in attr(x, 'decorators'))

+    cat(deparse(decorator), '%@%\n')

+  cat(fun_def, sep = '\n')

+  invisible(x)

+}

+

+# modules::register_S3_method('print', 'decorated', print.decorated)

+

+prettify = function (f, original, decorator_calls) {

+  attr(f, 'srcref') = pretty_code(original)

+  attr(f, 'decorators') = decorator_calls

+  class(f) = c(class(f), 'decorated')

+  f

+}

+

+pretty_code = function (f) {

+  srcref = attr(f, 'srcref')

+  if (is.null(srcref)) body(f) else srcref

+}

+

+.delayed_decorate = function (d1, d2, decorator_calls)

+  structure(decorator(function (f) d1(d2(f))), calls = decorator_calls)

+

+# Console logging 

+simpleLog <- decorator %@% function(f) {

+  function(...) {

+    print(match.call())

+    f(...)

+  }

+}

\ No newline at end of file

@@ -1,18 +1,22 @@

-.runBarcodeRankDrops <- function(barcode.matrix, ...) {

-

+.runBarcodeRankDrops <- function(barcode.matrix, lower=100, 

+                                 fit.bounds=NULL, 

+                                 df=20) {

+  

   ## Convert to sparse matrix if not already in that format

   barcode.matrix <- .convertToMatrix(barcode.matrix)

-  output <- DropletUtils::barcodeRanks(m = barcode.matrix, ...)

-

+  output <- DropletUtils::barcodeRanks(m = barcode.matrix, lower=100, 

+                                       fit.bounds=NULL, 

+                                       df=20)

+  

   knee.ix <- as.integer(output@listData$total >= S4Vectors::metadata(output)$knee)

   inflection.ix <- as.integer(output@listData$total >= S4Vectors::metadata(output)$inflection)

-

+  

   result <- cbind(knee.ix, inflection.ix)

   colnames(result) <- c("dropletUtils_barcodeRank_knee",

                         "dropletUtils_barcodeRank_inflection")

-

+  

   return(result)

 }

@@ -48,9 +52,11 @@

 #' sce <- runBarcodeRankDrops(inSCE = emptyDropsSceExample)

 #' @export

 runBarcodeRankDrops <- function(inSCE,

-    sample = NULL,

-    useAssay = "counts",

-    ...

+                                sample = NULL,

+                                useAssay = "counts", 

+                                lower=100, 

+                                fit.bounds=NULL, 

+                                df=20

 ) {

   if(!is.null(sample)) {

     if(length(sample) != ncol(inSCE)) {

@@ -59,27 +65,35 @@ runBarcodeRankDrops <- function(inSCE,

   } else {

     sample = rep(1, ncol(inSCE))

   }

-

+  

   message(paste0(date(), " ... Running 'barcodeRanks'"))

-

+  

+  ##  Getting current arguments values

+  argsList <- as.list(formals(fun = sys.function(sys.parent()), envir = parent.frame()))

+  

   ## Define result matrix for all samples

   output <- S4Vectors::DataFrame(row.names = colnames(inSCE),

-            dropletUtils_BarcodeRank_Knee = integer(ncol(inSCE)),

-            dropletUtils_BarcodeRank_Inflection = integer(ncol(inSCE)))

-

+                                 dropletUtils_BarcodeRank_Knee = integer(ncol(inSCE)),

+                                 dropletUtils_BarcodeRank_Inflection = integer(ncol(inSCE)))

+  

   ## Loop through each sample and run barcodeRank

   samples <- unique(sample)

   for (i in seq_len(length(samples))) {

     sceSampleInd <- sample == samples[i]

     sceSample <- inSCE[, sceSampleInd]

-

+    

     mat <- SummarizedExperiment::assay(sceSample, i = useAssay)

-    result <- .runBarcodeRankDrops(barcode.matrix = mat, ...)

-

+    result <- .runBarcodeRankDrops(barcode.matrix = mat, lower=100,

+                                   fit.bounds=NULL, 

+                                   df=20)

+    

     output[sceSampleInd, ] <- result

   }

-

+  

   colData(inSCE) = cbind(colData(inSCE), output)

-

+  

+  inSCE@metadata$runBarcodeRankDrops <- argsList[-1]

+  inSCE@metadata$runBarcodeRankDrops$packageVersion <- packageDescription("DropletUtils")$Version

+  

   return(inSCE)

 }

@@ -1,10 +1,24 @@

-.runEmptyDrops <- function(barcode.matrix, ...) {

-

+.runEmptyDrops <- function(barcode.matrix, lower=100,

+                           niters=10000,

+                           test.ambient=FALSE,

+                           ignore=NULL, 

+                           alpha=NULL,

+                           retain=NULL,

+                           barcode.args=list(),

+                           BPPARAM=SerialParam()) {

+  

   barcode.matrix <- .convertToMatrix(barcode.matrix)

-

-  result <- DropletUtils::emptyDrops(m = barcode.matrix, ...)

+  

+  result <- DropletUtils::emptyDrops(m = barcode.matrix, lower=100,

+                                     niters=10000,

+                                     test.ambient=FALSE,

+                                     ignore=NULL, 

+                                     alpha=NULL,

+                                     retain=NULL,

+                                     barcode.args=list(),

+                                     BPPARAM=SerialParam())

   colnames(result) <- paste0("dropletUtils_emptyDrops_", colnames(result))

-

+  

   return(result)

 }

@@ -43,13 +57,20 @@

 #' @import DropletUtils

 #' @export

 runEmptyDrops <- function(inSCE,

-    sample = NULL,

-    useAssay = "counts",

-    ...

+                          sample = NULL,

+                          useAssay = "counts", 

+                          lower=100,

+                          niters=10000,

+                          test.ambient=FALSE,

+                          ignore=NULL, 

+                          alpha=NULL,

+                          retain=NULL,

+                          barcode.args=list(),

+                          BPPARAM=SerialParam()

 ) {

   # getting the current argument values

-  current_params <- as.list(sys.call())

-  metadata_params <- inSCE@metadata$QCParams

+  argsList <- as.list(formals(fun = sys.function(sys.parent()), envir = parent.frame()))

+  

   if(!is.null(sample)) {

     if(length(sample) != ncol(inSCE)) {

@@ -58,32 +79,43 @@ runEmptyDrops <- function(inSCE,

   } else {

     sample = rep(1, ncol(inSCE))

   }

-

+  

   message(date(), " ... Running 'emptyDrops'")

-

+  

   ## Define result matrix for all samples

   output <- S4Vectors::DataFrame(row.names = colnames(inSCE),

-                dropletUtils_emptyDrops_total = integer(ncol(inSCE)),

-                dropletUtils_emptyDrops_logprob = numeric(ncol(inSCE)),

-                dropletUtils_emptyDrops_pvalue = numeric(ncol(inSCE)),

-                dropletUtils_emptyDrops_limited = logical(ncol(inSCE)),

-                dropletUtils_emptyDrops_fdr = numeric(ncol(inSCE)))

-

+                                 dropletUtils_emptyDrops_total = integer(ncol(inSCE)),

+                                 dropletUtils_emptyDrops_logprob = numeric(ncol(inSCE)),

+                                 dropletUtils_emptyDrops_pvalue = numeric(ncol(inSCE)),

+                                 dropletUtils_emptyDrops_limited = logical(ncol(inSCE)),

+                                 dropletUtils_emptyDrops_fdr = numeric(ncol(inSCE)))

+  

   ## Loop through each sample and run barcodeRank

   samples <- unique(sample)

   for (i in seq_len(length(samples))) {

     sceSampleInd <- sample == samples[i]

     sceSample <- inSCE[, sceSampleInd]

-

+    

     mat <- SummarizedExperiment::assay(sceSample, i = useAssay)

-    result <- .runEmptyDrops(barcode.matrix = mat, ...)

-

+    result <- .runEmptyDrops(barcode.matrix = mat, lower=100,

+                             niters=10000,

+                             test.ambient=FALSE,

+                             ignore=NULL, 

+                             alpha=NULL,

+                             retain=NULL,

+                             barcode.args=list(),

+                             BPPARAM=SerialParam())

+    

+    

     output[sceSampleInd, ] <- result

+    metadata(output[sceSampleInd, ]) <- metadata(result)

   }

   colData(inSCE) = cbind(colData(inSCE), output)

-  inSCE@metadata$QCParams <- metadata_params

-  inSCE@metadata$QCParams$runEmptyDrops <- current_params

+  inSCE@metadata = metadata(output)

+  

+  inSCE@metadata$runEmptyDrops <- argsList[-1]

+  inSCE@metadata$runEmptyDrops$packageVersion <- packageDescription("DropletUtils")$Version

   return(inSCE)

-}

+}

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,63 @@

+#' @title Export a \link[SingleCellExperiment]{SingleCellExperiment} R object as 

+#' Python annData object 

+#' @description Writes all assays, colData, rowData, reducedDims, and altExps objects in a

+#' \link[SingleCellExperiment]{SingleCellExperiment} to a Python annData object in the .h5ad format

+#' All parameters of Anndata.write_h5ad function (https://icb-anndata.readthedocs-hosted.com/en/stable/anndata.AnnData.write_h5ad.html)

+#' are available as parameters to this export function and set to defaults. Defaults can be

+#' overridden at function call.

+#' @param sce \link[SingleCellExperiment]{SingleCellExperiment} R object to be

+#'  exported.

+#'  @param useAssay Character, default `"counts"`. The name of assay of

+#' interests that will be set as the primary matrix of the output AnnData.

+#' @param outputDir Path to the directory where .h5ad outputs will be written

+#' @param overwrite Boolean. Default \code{TRUE}.

+#' @param compression Default \code{None}.If output file compression is required, this variable accepts

+#' 'gzip' or 'lzf' as inputs.

+#' @param compression_opts Integer. Default \code{NULL} Sets the compression level

+#' @param forceDense Default \code{False} Write sparse data as a dense matrix.

+#' Refer anndata.write_h5ad documentation for details

+#' @examples

+#' data(sce_chcl, package = "scds")

+#' exportSCEtoAnnData(sce=sce_chcl, compression="gzip")

+#'

+#' @export

+

+exportSCEtoAnnData <- function(sce, 

+                                useAssay='counts',

+                                outputDir="./",

+                                sample = "sample",

+                                overwrite=TRUE,

+                                compression= c('None','lzf','gzip'),

+                                compressionOpts = NULL,

+                                forceDense= c('False','True')){

+  compression <- match.arg(compression)

+  forceDense <- match.arg(forceDense)

+  if (compression == 'None'){

+    compression <- NULL

+  }

+

+  if (!reticulate::py_module_available(module = "scanpy")) {

+    warning("Cannot find python module 'scanpy', please install Conda and",

+            " run sctkPythonInstallConda() or run sctkPythonInstallVirtualEnv().",

+            "If one of these have been previously run to install the modules,",

+            "make sure to run selectSCTKConda() or selectSCTKVirtualEnvironment(),",

+            " respectively, if R has been restarted since the module installation.",

+            " Alternatively, Scrublet can be installed on the local machine",

+            "with pip (e.g. pip install --user scanpy) and then the 'use_python()'",

+            " function from the 'reticulate' package can be used to select the",

+            " correct Python environment.")

+    return(sce)}

+  

+  annData <- .sce2adata(sce,useAssay)

+  fileName <- paste0(sample,".h5ad")

+  filePath <- file.path(outputDir,fileName)

+  

+  if (file.exists(filePath) && !isTRUE(overwrite)) {

+    stop(paste0(path, " already exists. Change 'outputDir' or set 'overwrite' to TRUE."))

+    }

+

+  annData$write_h5ad(filePath,

+                     compression = compression, 

+                     compression_opts = compressionOpts,

+                     force_dense = forceDense)

+}

new file mode 100644

@@ -0,0 +1,143 @@

+

+.readDropEstFile <- function(sampleDir, dataType,rdsFileName){

+  dropEst_cell_counts <- file.path(sampleDir, paste(rdsFileName, '.rds', sep=''))

+  if (!file.exists(dropEst_cell_counts)){

+    stop("DropEst output not found at location specified. Please check path provided and/or filename.")

+  }

+  dropEst_rds <- readRDS(dropEst_cell_counts) 

+  

+  return(dropEst_rds)

+}

+

+.constructColdata <- function(dropEst_rds,counts_matrix, dataType){

+  coldata_fields <- c("mean_reads_per_umi","aligned_reads_per_cell","aligned_umis_per_cell","requested_umis_per_cb","requested_reads_per_cb")

+  coldata_df <-  list()

+  for (field in coldata_fields){

+    if (field %in% names(dropEst_rds)){

+      coldata_field_df <- data.frame(as.matrix(dropEst_rds[[field]]))

+      names(coldata_field_df)[1] <- field

+      coldata_field_df$cell <- row.names(coldata_field_df)

+      

+      coldata_df[[field]] <- coldata_field_df

+    }}

+  coldata_df_merged <- Reduce(function(x, y) merge(x, y, all=TRUE,by="cell"), coldata_df)

+  row.names(coldata_df_merged) <- coldata_df_merged$cell

+  coldata_df_merged <- S4Vectors::DataFrame(as.matrix(coldata_df_merged))

+  if (dataType == 'filtered'){

+    coldata_df_merged <- coldata_df_merged[coldata_df_merged$cell %in% colnames(counts_matrix),]

+  }

+  return(coldata_df_merged)

+}

+

+.extractMetadata <- function(dropEst_rds){

+  metadata_fields <- c("saturation_info","merge_targets","reads_per_umi_per_cell")

+  metadata <- c()

+  for (md in metadata_fields){

+    if (md %in% names(dropEst_rds)){

+      metadata[[md]] <- dropEst_rds[[md]]

+    }}

+  return(metadata)

+}

+

+.importDropEstSample <- function(sampleDir = './', 

+                                 dataType, 

+                                 rdsFileName, 

+                                 sampleName = 'sample',

+                                 delayedArray = delayedArrary){

+  ## Read DropEst RDS

+  dropEst_rds <- .readDropEstFile(sampleDir,dataType,rdsFileName)

+  if (dataType == 'filtered' && 'cm' %in% names(dropEst_rds)) {

+    counts_matrix <- dropEst_rds$cm

+  } else if (dataType == 'raw' && 'cm_raw' %in% names(dropEst_rds)) {

+    counts_matrix <- dropEst_rds$cm_raw

+  } else {

+    stop("No counts matrix found in the .rds provided! Exiting.")

+  }

+  

+  if (isTRUE(delayedArray)) {

+    counts_matrix <- DelayedArray::DelayedArray(counts_matrix)

+    }

+  ## Create SingleCellExperiment object

+  ## Add SCE ColData. If using filtered counts matrix, colData is subset to include filtered cells.

+  ## append sample name to cells in SCE 

+  sce <- SingleCellExperiment::SingleCellExperiment(assays = list(counts = counts_matrix))

+  colnames(sce) <- paste0(sampleName,"_",colnames(sce)) 

+  sce_coldata <- .constructColdata(dropEst_rds, counts_matrix, dataType)

+  row.names(sce_coldata) <- paste0(sampleName,"_",row.names(sce_coldata))

+  

+  if (dim(counts_matrix)[2] == dim(sce_coldata)[1]){

+    SummarizedExperiment::colData(sce) <- sce_coldata

+  } else {

+    warning("Unable to add ColData to SCE. nCol of Counts Matrix not equal to nRow of ColData matrix.")

+  }

+  

+  ## Add SCE metadata

+  sce_metadata <- .extractMetadata(dropEst_rds)

+  metadata(sce) <- sce_metadata

+  

+  return(sce)

+}

+

+#' @name importDropEst

+#' @rdname importDropEst

+#' @title Create a SingleCellExperiment Object from DropEst output 

+#' @description imports the RDS file created by DropEst (https://github.com/hms-dbmi/dropEst) and

+#' create a SingleCellExperiment object from either the raw or filtered counts matrix.

+#' Additionally parse through the RDS to obtain appropriate feature annotations as 

+#' SCE coldata, in addition to any metadata.

+#' @param sampleDir  A path to the directory containing the data files. Default "./".

+#' @param sampleName A User-defined sample name. This will be prepended to all cell barcode IDs.

+#'  Default "sample".

+#'  @param dataType can be "filtered" or "raw". Default is "filtered"

+#' @param rdsFileName File name prefix of the DropEst RDS output. default is "cell.counts"

+#' @param delayedArray Boolean. Whether to read the expression matrix as

+#'  \link[DelayedArray]{DelayedArray} object or not. Default \code{TRUE}.

+#' @details

+#' \code{importDropEst} expects either raw counts matrix stored as "cm_raw" or filtered

+#' counts matrix stored as "cm" in the DropEst rds output. 

+#' ColData is obtained from the DropEst corresponding to "mean_reads_per_umi","aligned_reads_per_cell",

+#' "aligned_umis_per_cell","requested_umis_per_cb","requested_reads_per_cb"

+#' If using filtered counts matrix, the colData dataframe is 

+#' subset to contain features from the filtered counts matrix alone.

+#' If any annotations of ("saturation_info","merge_targets","reads_per_umi_per_cell") are 

+#' found in the DropEst rds, they will be added to the SCE metadata field

+#' @return A \code{SingleCellExperiment} object containing the count matrix,

+#'  the feature annotations from DropEst as ColData, and any metadata from DropEst

+#' @examples

+#' # Example #1

+#' Example DropEst outputs were downloaded from the DropEst Github 

+#' (http://pklab.med.harvard.edu/viktor/dropest_paper/dropest_0.8.5.zip). 

+#' To run the dropest import function with the example dataset, 

+#' set the sampleDirs variable to the example dropEst provided in SCTK as follows-

+#' sce <- importDropEst(sampleDirs = c('path/to/dropest/folder/'), 

+#'                      dataType='filtered', sampleNames=c('sample'))

+#' @export

+importDropEst <- function(sampleDirs = NULL, 

+                          dataType = c('filtered','raw'),

+                          rdsFileName = 'cell.counts',

+                          sampleNames = NULL,

+                          delayedArray = TRUE) {

+  dataType <- match.arg(dataType)

+  

+  if (length(sampleDirs)!=length(sampleNames)){

+    stop("Please provide sample names for all input directories")

+  }

+  

+  res <- vector("list", length = length(sampleDirs))

+  

+  for (i in seq_along(sampleDirs)){

+    scei <- .importDropEstSample(sampleDir = sampleDirs[[i]],

+                         sampleName = sampleNames[[i]],

+                         dataType = dataType,

+                         rdsFileName = rdsFileName,

+                         delayedArray = delayedArray)

+    res[[i]] <- scei

+  }

+  sce <- do.call(SingleCellExperiment::cbind, res)

+  return(sce)

+}

+  

+  

+

+

+

@@ -71,7 +71,7 @@ summarizeTable <- function(inSCE, useAssay="counts", expressionCutoff=1700){

 #' newSCE <- createSCE(assayFile = counts_mat, annotFile = sample_annot,

 #'                     featureFile = row_annot, assayName = "counts",

 #'                     inputDataFrames = TRUE, createLogCounts = TRUE)

-createSCE <- function(assayFile=NULL, annotFile=NULL, featureFile=NULL,

+createSCE <- simpleLog %@% function(assayFile=NULL, annotFile=NULL, featureFile=NULL,

                       assayName="counts", inputDataFrames=FALSE,

                       createLogCounts=TRUE){

@@ -265,7 +265,6 @@ distinctColors <- function(n, hues = c("red", "cyan", "orange", "blue",

   }

 }

-

 ## Convert a matrix to a sparse matrix and preserve column/row names

 .convertToMatrix <- function(x) {

   cn <- colnames(x)

@@ -278,15 +277,3 @@ distinctColors <- function(n, hues = c("red", "cyan", "orange", "blue",

   return(x)

 }

-`%@%` = function(decorator, f) {

-  decorator(f)

-}

-

-simpleLog <- function(f) {

-  function(...) {

-    print(match.call())

-    f(...)

-  }

-}

-

-

@@ -5,10 +5,10 @@

 #' across all batches of the data. 

 #' @param inSCE SingleCellExperiment object. An object that stores your dataset

 #' and analysis procedures.

-#' @param exprs character, default `"logcounts"`. A string indicating the name 

+#' @param useAssay character, default `"logcounts"`. A string indicating the name 

 #' of the assay requiring batch correction in "inSCE", should exist in 

 #' `assayNames(inSCE)`.

-#' @param batchKey character, default `"batch"`. A string indicating the 

+#' @param batch character, default `"batch"`. A string indicating the 

 #' field of `colData(inSCE)` that defines different batches.

 #' @param reducedDimName character, default `"BBKNN"`. The name for the 

 #' corrected low-dimensional representation.

@@ -26,22 +26,33 @@

 #' data('sceBatches', package = 'singleCellTK')

 #' sceCorr <- runBBKNN(sceBatches)

 #' }

-runBBKNN <-function(inSCE, exprs = 'logcounts', batchKey = 'batch', 

+runBBKNN <-function(inSCE, useAssay = 'logcounts', batch = 'batch', 

                     reducedDimName = 'BBKNN', nComponents = 50L){

     ## Input check

-    if(!class(inSCE) == "SingleCellExperiment" && 

-       !class(inSCE) == "SCtkExperiment"){

+    if(!inherits(inSCE, "SingleCellExperiment")){

         stop("\"inSCE\" should be a SingleCellExperiment Object.")

     }

-    if(!batchKey %in% names(SummarizedExperiment::colData(inSCE))){

-        stop(paste("\"batchKey\" name:", batchKey, "not found"))

+    if(!reticulate::py_module_available(module = "bbknn")){

+        warning("Cannot find python module 'bbknn', please install Conda and",

+            " run sctkPythonInstallConda() or run sctkPythonInstallVirtualEnv().",

+            "If one of these have been previously run to install the modules,",

+            "make sure to run selectSCTKConda() or selectSCTKVirtualEnvironment(),",

+            " respectively, if R has been restarted since the module installation.",

+            " Alternatively, bbknn can be installed on the local machine",

+            "with pip (e.g. pip install bbknn) and then the 'use_python()'",

+            " function from the 'reticulate' package can be used to select the",

+            " correct Python environment.")

+        return(inSCE)

+    }

+    if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

+        stop(paste("\"batch\" name:", batch, "not found"))

     }

     reducedDimName <- gsub(' ', '_', reducedDimName)

     ## Run algorithm

-    adata <- .sce2adata(inSCE, mainAssay = exprs)

+    adata <- .sce2adata(inSCE, mainAssay = useAssay)

     sc$tl$pca(adata, n_comps = nComponents)

-    bbknn$bbknn(adata, batch_key = batchKey, n_pcs = nComponents)

+    bbknn$bbknn(adata, batch_key = batch, n_pcs = nComponents)

     sc$tl$umap(adata, n_components = nComponents)

     bbknnUmap <- adata$obsm[["X_umap"]]

     SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- bbknnUmap

@@ -5,74 +5,61 @@

 #' more robust performance. For introduction of MNN, see `runMNNCorrect`

 #' @param inSCE SingleCellExperiment object. An object that stores your dataset

 #' and analysis procedures.

-#' @param exprs character, default `"logcounts"`. A string indicating the name 

+#' @param useAssay character, default `"logcounts"`. A string indicating the name 

 #' of the assay requiring batch correction in "inSCE", should exist in 

 #' `assayNames(inSCE)`. Alternatively, see `pcInput` parameter.

-#' @param batchKey character, default `"batch"`. A string indicating the 

+#' @param batch character, default `"batch"`. A string indicating the 

 #' field of `colData(inSCE)` that defines different batches.

 #' @param reducedDimName character, default `"fastMNN"`. The name for the 

 #' corrected low-dimensional representation.

 #' @param pcInput bool, default `FALSE`. Whether to use a reduceDim matrix for 

-#' batch effect correction. If TRUE, `exprs` should exist in 

+#' batch effect correction. If TRUE, `useAssay` should exist in 

 #' `reduceDimNames(inSCE)`. Note that more dimensions in precomputed reducedDim

 #' have shown better correction results.

 #' @return SingleCellExperiment object with `reducedDim(inSCE, reducedDimName)` 

 #' updated with corrected low-dimentional representation.

 #' @export

 #' @references Lun ATL, et al., 2016

-#' @examples  

+#' @examples

+#' \dontrun{

 #' data('sceBatches', package = 'singleCellTK')

-#' sceCorr <- runFastMNN(sceBatches, exprs = 'PCA', pcInput = TRUE)

-runFastMNN <- function(inSCE, exprs = "logcounts", reducedDimName = "MNN", 

-                       batchKey = 'batch', pcInput = FALSE){

+#' sceCorr <- runFastMNN(sceBatches, useAssay = 'logcounts', pcInput = FALSE)

+#' }

+runFastMNN <- function(inSCE, useAssay = "logcounts", reducedDimName = "MNN", 

+                       batch = 'batch', pcInput = FALSE){

     ## Input check

-    if(!class(inSCE) == "SingleCellExperiment" && 

-       !class(inSCE) == "SCtkExperiment"){

+    if(!inherits(inSCE, "SingleCellExperiment")){

         stop("\"inSCE\" should be a SingleCellExperiment Object.")

     }

-    if(pcInput){

-        if(!exprs %in% SingleCellExperiment::reducedDimNames(inSCE)) {

-            stop(paste("\"exprs\" (assay) name: ", exprs, " not found."))

+    if(isTRUE(pcInput)){

+        if(!(useAssay %in% SingleCellExperiment::reducedDimNames(inSCE))) {

+            stop(paste("\"useAssay\" (reducedDim) name: ", useAssay, " not found."))

         }

     } else {

-        if(!exprs %in% SummarizedExperiment::assayNames(inSCE)) {

-            stop(paste("\"exprs\" (assay) name: ", exprs, " not found."))

+        if(!(useAssay %in% SummarizedExperiment::assayNames(inSCE))) {

+            stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found."))

         }

     }

-    if(!batchKey %in% names(SummarizedExperiment::colData(inSCE))){

-        stop(paste("\"batchKey name:", batchKey, "not found."))

+    if(!(batch %in% names(SummarizedExperiment::colData(inSCE)))){

+        stop(paste("\"batch name:", batch, "not found."))

     }

     reducedDimName <- gsub(' ', '_', reducedDimName)

     ## Run algorithm

-    # Extract each batch

-    if(pcInput){

-        mat <- SingleCellExperiment::reducedDim(inSCE, exprs)

-    } else {

-        mat <- SummarizedExperiment::assay(inSCE, exprs)

-    }

     batches <- list()

-    batchCol <- SummarizedExperiment::colData(inSCE)[[batchKey]]

-    batchIndicator <- unique(batchCol)

-    for(i in batchIndicator){

-        if(pcInput){

-            batches[[i]] <- mat[batchCol == i,]

-        } else {

-            batches[[i]] <- mat[,batchCol == i]

-        }

-        

-    }

+    batchCol <- SummarizedExperiment::colData(inSCE)[[batch]]

+    batchFactor <- as.factor(batchCol)

+    

     if(pcInput){

-        mnn <- batchelor::fastMNN(batches[[1]], 

-                              batches[[2]], 

-                              pc.input = TRUE)    

+        mat <- SingleCellExperiment::reducedDim(inSCE, useAssay)

+        redMNN <- batchelor::reducedMNN(mat, batch = batchFactor)

+        newRedDim <- redMNN$corrected

     } else {

-        mnn <- batchelor::fastMNN(batches[[1]], 

-                              batches[[2]])

+        mat <- SummarizedExperiment::assay(inSCE, useAssay)

+        mnnSCE <- batchelor::fastMNN(mat, batch = batchFactor)

+        newRedDim <- SingleCellExperiment::reducedDim(mnnSCE, 'corrected')

     }

-    rn <- rownames(mat)

-    newMat <- mnn$corrected[rn,]

-    SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- newMat

+    SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- newRedDim

     return(inSCE)

 }

@@ -4,15 +4,15 @@

 #' cells group by cell type rather than dataset-specific conditions. 

 #' @param inSCE SingleCellExperiment object. An object that stores your dataset

 #' and analysis procedures.

-#' @param exprs character, default `"logcounts"`. A string indicating the name 

+#' @param useAssay character, default `"logcounts"`. A string indicating the name 

 #' of the assay requiring batch correction in "inSCE", should exist in 

 #' `assayNames(inSCE)`.

-#' @param batchKey character, default `"batch"`. A string indicating the 

+#' @param batch character, default `"batch"`. A string indicating the 

 #' field of `colData(inSCE)` that defines different batches.

 #' @param reducedDimName character, default `"HARMONY"`. The name for the 

 #' corrected low-dimensional representation.

 #' @param pcInput bool, default `FALSE`. Whether to do correction on a low-dim

-#' matrix. If `TRUE`, will look for `exprs` in `reducedDim(inSCE)`.

+#' matrix. If `TRUE`, will look for `useAssay` in `reducedDim(inSCE)`.

 #' @param nComponents integer, default `20`. Number of principle components or 

 #' dimensionality to generate in the resulting reducedDim. If `pcInput`, will

 #' directly follow the dimensionality of the specified reducedDim.

@@ -25,46 +25,34 @@

 #' @references Ilya Korsunsky, et al., 2019

 #' @examples  

 #' data('sceBatches', package = 'singleCellTK')

-#' sceBatches

-#' ## class: SingleCellExperiment 

-#' ## dim: 27610 1820 

-#' ## metadata(0):

-#' ## assays(3): normcounts logcounts

-#' ## rownames(27610): GCG MALAT1 ... LOC102724004 LOC102724238

-#' ## rowData names(0):

-#' ## colnames(1820): reads.12732 reads.12733 ... Sample_1598 Sample_1600

-#' ## colData names(2): cell_type1 batch

-#' ## reducedDimNames(5): PCA

-#' ## spikeNames(0):

 #' sceCorr <- runHarmony(sceBatches, nComponents = 10)

-runHarmony <- function(inSCE, exprs = "logcounts", pcInput = FALSE, 

-                       batchKey = "batch", reducedDimName = "HARMONY", 

+runHarmony <- function(inSCE, useAssay = "logcounts", pcInput = FALSE, 

+                       batch = "batch", reducedDimName = "HARMONY", 

                        nComponents = 50, theta = 5, nIter = 10){

     ## Input check

-    if(!class(inSCE) == "SingleCellExperiment" && 

-       !class(inSCE) == "SCtkExperiment"){

+    if(!inherits(inSCE, "SingleCellExperiment")){

         stop("\"inSCE\" should be a SingleCellExperiment Object.")

     }    

     if(pcInput){

-        if(!exprs %in% SingleCellExperiment::reducedDimNames(inSCE)) {

-            stop(paste("\"exprs\" (assay) name: ", exprs, " not found."))

+        if(!useAssay %in% SingleCellExperiment::reducedDimNames(inSCE)) {

+            stop(paste("\"useAssay\" (reducedDim) name: ", useAssay, " not found."))

         }

     } else {

-        if(!exprs %in% SummarizedExperiment::assayNames(inSCE)) {

-            stop(paste("\"exprs\" (assay) name: ", exprs, " not found."))

+        if(!useAssay %in% SummarizedExperiment::assayNames(inSCE)) {

+            stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found."))

         }

     }

-    if(!batchKey %in% names(SummarizedExperiment::colData(inSCE))){

-        stop(paste("\"batchKey\" name:", batchKey, "not found"))

+    if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

+        stop(paste("\"batch\" name:", batch, "not found"))

     }

     reducedDimName <- gsub(' ', '_', reducedDimName)

     ## Run algorithm

-    batchCol <- SummarizedExperiment::colData(inSCE)[[batchKey]]

+    batchCol <- SummarizedExperiment::colData(inSCE)[[batch]]

     if(pcInput){

-        mat <- SingleCellExperiment::reducedDim(inSCE, exprs)

+        mat <- SingleCellExperiment::reducedDim(inSCE, useAssay)

     } else{

-        sceTmp <- scater::runPCA(inSCE, exprs_values = exprs, 

+        sceTmp <- scater::runPCA(inSCE, exprs_values = useAssay, 

                                  ncomponents = nComponents)

         mat <- SingleCellExperiment::reducedDim(sceTmp, 'PCA')

     }

@@ -4,10 +4,10 @@