Error in .filterGenes(...), nrow(nzGeneRanges) == nrow(expr) is not TRUE

[bbimber]

Hello,

I am trying to run the escape package through another R package . Our automated testing recently began to fail. The failure has something to do with the interaction with GSVA or perhaps something about the matrix-related packages.

• Our code calls RunEscape():

  escape/R/runEscape.R

  Line 118 in 5eae8bd

  .compute_enrichment(mat, egc, method, BPPARAM, ...),

• This calls GSEA here:

  escape/R/utils.R

  Line 400 in 5eae8bd

  param <- .build_gsva_param(expr, gene_sets, "ssGSEA")

• The failing code in GSEA is here: https://github.com/rcastelo/GSVA/blob/13f832d105c9a52b7bc26f05176254876a59f4d8/R/utils.R#L134
• I am running this with BPPARAM=NULL

The stacktrace for the error is below. Have you encountered anything like this? Thanks in advance for any debugging ideas.

2025-11-17T21:37:47.7458777Z Error ('test-escape.R:24:5'): escape works as expected
2025-11-17T21:37:47.7458917Z <bplist_error/bperror/error/condition>
2025-11-17T21:37:47.7459310Z ##[error]Error: BiocParallel errors
2025-11-17T21:37:47.7459490Z   1 remote errors, element index: 1
2025-11-17T21:37:47.7459620Z   1 unevaluated and other errors
2025-11-17T21:37:47.7459731Z   first remote error:
2025-11-17T21:37:47.7460398Z ##[error]Error in .filterGenes(dataMatrix, removeConstant = removeConstant, removeNzConstant = removeNzConstant, : nrow(nzGeneRanges) == nrow(expr) is not TRUE
2025-11-17T21:37:47.7460409Z 
2025-11-17T21:37:47.7460511Z Backtrace:
2025-11-17T21:37:47.7460597Z      ▆
2025-11-17T21:37:47.7460888Z   1. ├─testthat::expect_warning(...) at test-escape.R:24:5
2025-11-17T21:37:47.7461194Z   2. │ └─testthat:::quasi_capture(...)
2025-11-17T21:37:47.7461400Z   3. │   ├─testthat (local) .capture(...)
2025-11-17T21:37:47.7461611Z   4. │   │ └─base::withCallingHandlers(...)
2025-11-17T21:37:47.7461906Z   5. │   └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
2025-11-17T21:37:47.7462091Z   6. └─CellMembrane::RunEscape(...)
2025-11-17T21:37:47.7462318Z   7.   └─CellMembrane:::.RunEscapeOnSubset(...)
2025-11-17T21:37:47.7462495Z   8.     └─escape::runEscape(...)
2025-11-17T21:37:47.7462687Z   9.       └─escape::escape.matrix(...)
2025-11-17T21:37:47.7462873Z  10.         └─escape:::.plapply(...)
2025-11-17T21:37:47.7463185Z  11.           ├─BiocParallel::bplapply(X, FUN, ..., BPPARAM = BPPARAM)
2025-11-17T21:37:47.7463473Z  12.           └─BiocParallel::bplapply(X, FUN, ..., BPPARAM = BPPARAM)
2025-11-17T21:37:47.7463691Z  13.             └─BiocParallel:::.bpinit(...)

[ncborcherding]

@bbimber

Thanks for reaching out - weirdly I am unable to recreate the issue on my system using GSVA 2.5.0

The following runs smoothly for me:

gene.sets <- list(Bcells = c("MS4A1","CD79B","CD79A","IGH1","IGH2"),
                  Myeloid = c("SPI1","FCER1G","CSF1R"),
                  Tcells = c("CD3E", "CD3D", "CD3G", "CD7","CD8A"))

scRep_example <- runEscape(scRep_example, 
                           method = "ssGSEA",
                           gene.sets = gene.sets, 
                           groups = 1000, 
                           min.size = 3,
                           new.assay.name = "escape.ssGSEA", 
                           BPPARAM=NULL)

The timing is relatively suspicious for a break in the GSVA code with the new release of Bioconductor. In fact, it looks like the .filterGenes() has BPPARAM handling removed in the most recent version. This is probably an issue to bring up with GSVA - as I do not think I can do anything on my end to fix the handling of NULL.

The version you linked:

.filterGenes <- function(expr, removeConstant=TRUE, removeNzConstant=TRUE,
                         verbose=TRUE, BPPARAM=NULL) {
    geneRanges <- NULL
    ## open parallelism only if filtering have to be done for
    ## more than 100 genes on more than 100 samples
    if (!is.null(BPPARAM) && bpnworkers(BPPARAM) > 1 &&
        nrow(expr) > 100 && ncol(expr) > 100) {

        if (is(expr, "DelayedArray")) {     ## DelayedArray::rowRanges() takes care of
                                            ## grid layout with respect to parallelization
            if (verbose) {
                msg <- sprintf("Searching for genes/features with constant values using %d cores",
                               as.integer(bpnworkers(BPPARAM)))
                cli_alert_info(msg)
                bpprogressbar(BPPARAM) <- TRUE
            }
            setAutoBPPARAM(BPPARAM=BPPARAM)
            geneRanges <- rowRanges(expr)
            setAutoBPPARAM(NULL)

        } else {

            n_chunks <- bpnworkers(BPPARAM)
            if (verbose) {
                msg <- sprintf("Searching for genes/features with constant values using %d cores",
                               as.integer(bpnworkers(BPPARAM)))
                cli_alert_info(msg)
                idpb <- cli_progress_bar("Computing row ranges", total=n_chunks)
            }
            bpprogressbar(BPPARAM) <- FALSE
            geneRanges <- bpiterate(.row_iter(expr, idpb, n_chunks),
                                    rowRanges, na.rm=TRUE, useNames=FALSE,
                                    REDUCE=rbind, reduce.in.order=TRUE, BPPARAM=BPPARAM)

            if (verbose)
                cli_progress_done(idpb)
        }
    } else {
        BPPARAM <- NULL ## disable any other BPPARAM configuration
        if (verbose)
            cli_alert_info("Searching for genes/features with constant values")
        geneRanges <- rowRanges(expr, na.rm=TRUE, useNames=FALSE)
    }

    constantGenes <- (geneRanges[, 1] == geneRanges[, 2])

    if (any(constantGenes) || anyNA(constantGenes)) {
        invalidGenes <- (constantGenes | is.na(constantGenes))
        msg <- sprintf("%d genes/features with constant values throughout the samples",
                       sum(invalidGenes))
        cli_alert_warning(msg)
        if (removeConstant) {
            cli_alert_warning("Genes/features with constant values are discarded")
            expr <- expr[!invalidGenes, ]
        }
    }

    if (is_sparse(expr)) {
        if (!is.null(BPPARAM) && bpnworkers(BPPARAM) > 1 &&
            nrow(expr) > 100 && ncol(expr) > 100) {

            if (verbose) {
                msg <- sprintf("Searching for genes/features with constant nonzero values using %d cores",
                               as.integer(bpnworkers(BPPARAM)))
                cli_alert_info(msg)
            }
        } else if (verbose) {
            BPPARAM <- NULL ## disable any other BPPARAM configuration
            cli_alert_info("Searching for genes/features with constant nonzero values")
        }

        nzGeneRanges <- NULL
        if (is(expr, "DelayedMatrix")) {
            rowNonzeroRanges_byBlock <- function(block) {
                t(sapply(t(block)@SVT, function(x) range(x[[1]])))
            }
            nworkers <- 1L
            if (verbose && !is.null(BPPARAM) && bpnworkers(BPPARAM) > 1 &&
                nrow(expr) > 100 && ncol(expr) > 100) {
                bpprogressbar(BPPARAM) <- TRUE
                nworkers <- bpnworkers(BPPARAM)
            }
            nzGeneRanges <- blockApply(expr, rowNonzeroRanges_byBlock,
                                       grid=rowgridsize(expr, nworkers=nworkers),
                                       as.sparse=is_sparse(expr), BPPARAM=BPPARAM)
            nzGeneRanges <- do.call("rbind", nzGeneRanges)
        } else if (is(expr, "dgCMatrix")) {
            if (verbose && !is.null(BPPARAM) && bpnworkers(BPPARAM) > 1 &&
                nrow(expr) > 100 && ncol(expr) > 100) {
                bpprogressbar(BPPARAM) <- TRUE
                nzGeneRanges <- do.call("rbind", bplapply(.sparse2columnList(t(expr)),
                                                          FUN=range, BPPARAM=BPPARAM))
            } else
                nzGeneRanges <- do.call("rbind", lapply(.sparse2columnList(t(expr)),
                                                        FUN=range))
        } else if (is(expr, "SVT_SparseArray")) {
            if (verbose && !is.null(BPPARAM) && bpnworkers(BPPARAM) > 1 &&
                nrow(expr) > 100 && ncol(expr) > 100) {
                bpprogressbar(BPPARAM) <- TRUE
                nzGeneRanges <- do.call("rbind",
                                        bplapply(t(expr)@SVT,
                                                 FUN=function(x) range(x[[1]]),
                                                 BPPARAM=BPPARAM))
            } else
                nzGeneRanges <- do.call("rbind",
                                        lapply(t(expr)@SVT,
                                               FUN=function(x) range(x[[1]])))
        } else
            cli_abort("x"="Uknown sparse matrix class")

        stopifnot(is.matrix(nzGeneRanges)) ## QC
        stopifnot(nrow(nzGeneRanges) == nrow(expr)) ## QC

        ## nzGeneRanges <- NULL
        ## if (bpnworkers(BPPARAM) > 1 && nrow(expr) > 100 && ncol(expr) > 100) {
        ##   nzGeneRanges <- do.call("cbind", bplapply(nzGeneList, FUN=range, BPPARAM=BPPARAM))
        ## } else
        ##   nzGeneRanges <- vapply(nzGeneList, FUN=range, FUN.VALUE=double(2))
        constantNzGenes <- (nzGeneRanges[, 1] == nzGeneRanges[, 2])

        if (any(constantNzGenes) || anyNA(constantNzGenes)) {
            invalidNzGenes <- (constantNzGenes | is.na(constantNzGenes))
            msg <- sprintf("%d genes/features with constant nonzero values throughout the samples",
                           sum(invalidNzGenes))
            cli_alert_warning(msg)
            if (removeNzConstant) {
                cli_alert_warning("Genes/features with constant nonzero values are discarded")
                expr <- expr[!invalidNzGenes, ]
            }
        }
    }

    if (nrow(expr) < 2)
        cli_abort(c("x"="Less than two genes in the input assay object"))
    
    return(expr)
}

Here is the most recent version (in GSVA 2.5.8)

.filterGenes <- function(expr, anyna=FALSE, removeConstant=TRUE,
                         removeNzConstant=TRUE, verbose=TRUE, BPPARAM=NULL) {
  rowrngs <- NULL

  if (verbose) {
      if (!is_sparse(expr))
          cli_alert_info("Searching for rows with constant values")
      else
          cli_alert_info("Searching for rows with constant (nonzero) values")
  }

 ## returns a matrix with as many rows as 'expr' and 2 columns if 'expr'
  ## is dense, and 4 columns if it is sparse, where the first two columns
  ## correspond to the minimum and maximum values of each row, while the
  ## third and fourth columns, if they exist, they correspond to the
  ## minimum and maximum nonzero values of each row, which will be NAs if
  ## there are no nonzero values.
  rowrngs <- .processMatrixRows(expr, .rowNzRanges, anyna=anyna,
                                verbose=verbose, BPPARAM=BPPARAM)

  constantRows <- (rowrngs[, 1] == rowrngs[, 2])
  mask <- is.na(constantRows)
  if (any(mask))
      constantRows[mask] <- TRUE

  constantNzRows <- invalidRows <- invalidNzRows <- rep(FALSE, nrow(expr))
  if (ncol(rowrngs) > 2) { ## sparse input
      constantNzRows <- (rowrngs[, 3] == rowrngs[, 4])
      mask <- is.na(constantNzRows)
      if (any(mask)) ## no nonzero values imply constant nonzero values
          constantNzRows[mask] <- TRUE
  }

  if (verbose && any(constantRows)) {
      msg <- sprintf("%d rows with constant values throughout the columns",
                     sum(constantRows))
      cli_alert_warning(msg)
      if (removeConstant)
         cli_alert_warning("Rows with constant values are discarded")
  }

  nzmask <- constantNzRows & !constantRows
  if (verbose && any(nzmask)) {
      msg <- sprintf("%d rows with constant nonzero values throughout the samples",
                     sum(nzmask))
      cli_alert_warning(msg)
      if (removeNzConstant)
         cli_alert_warning("Rows with constant nonzero values are discarded")
  }

  removemask <- rep(FALSE, nrow(expr))
  if (removeConstant)
       removemask <- constantRows

  if (removeNzConstant && any(nzmask))
       removemask <- removemask | nzmask

  if (any(removemask)) {
      if (nrow(expr) - sum(removemask) < 2)
          cli_abort(c("x"="Less than two rows left in the input assay object"))

      expr <- expr[!removemask, ]
  }

  return(expr)
}

[bbimber]

Thanks for the reply. It was an issue with incorrect/incompatible versions.