CRAN Package Check Results for Package Seurat

Last updated on 2019-11-26 00:52:12 CET.

Check Details

Version: 3.1.1
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: 'loomR'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64

Version: 3.1.1
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: 'loomR'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 3.1.1
Check: examples
Result: ERROR
    Running examples in 'Seurat-Ex.R' failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: LogNormalize
    > ### Title: Normalize raw data
    > ### Aliases: LogNormalize
    >
    > ### ** Examples
    >
    > mat <- matrix(data = rbinom(n = 25, size = 5, prob = 0.2), nrow = 5)
    > mat
     [,1] [,2] [,3] [,4] [,5]
    [1,] 0 2 0 1 2
    [2,] 1 3 0 1 0
    [3,] 1 1 1 3 1
    [4,] 2 1 1 1 0
    [5,] 0 0 2 2 0
    > mat_norm <- LogNormalize(data = mat)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    Seurat
     --- call from context ---
    LogNormalize(data = mat)
     --- call from argument ---
    if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
    }
     --- R stacktrace ---
    where 1: LogNormalize(data = mat)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (data, scale.factor = 10000, verbose = TRUE)
    {
     if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
     }
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     if (verbose) {
     cat("Performing log-normalization\n", file = stderr())
     }
     norm.data <- LogNorm(data, scale_factor = scale.factor, display_progress = verbose)
     colnames(x = norm.data) <- colnames(x = data)
     rownames(x = norm.data) <- rownames(x = data)
     return(norm.data)
    }
    <bytecode: 0x13b8c068>
    <environment: namespace:Seurat>
     --- function search by body ---
    Function LogNormalize in namespace Seurat has this body.
     ----------- END OF FAILURE REPORT --------------
    Fatal error: the condition has length > 1
Flavor: r-devel-linux-x86_64-debian-clang

Version: 3.1.1
Check: tests
Result: ERROR
     Running 'testthat.R' [35s/39s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(Seurat)
     >
     > test_check("Seurat")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     Seurat
     --- call from context ---
     LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE)
     --- call from argument ---
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     --- R stacktrace ---
     where 1: LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE)
     where 2: eval_bare(expr, quo_get_env(quo))
     where 3: quasi_label(enquo(expected), expected.label, arg = "expected")
     where 4 at testthat/test_preprocessing.R#75: expect_equal(LogNormalize(data = GetAssayData(object = object[["RNA"]],
     slot = "counts"), verbose = FALSE), LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE))
     where 5: eval(code, test_env)
     where 6: eval(code, test_env)
     where 7: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 10: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 11: doTryCatch(return(expr), name, parentenv, handler)
     where 12: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 13: tryCatchList(expr, classes, parentenv, handlers)
     where 14: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 15: test_code(desc, code, env = parent.frame())
     where 16 at testthat/test_preprocessing.R#74: test_that("LogNormalize normalizes properly", {
     expect_equal(LogNormalize(data = GetAssayData(object = object[["RNA"]],
     slot = "counts"), verbose = FALSE), LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE))
     })
     where 17: eval(code, test_env)
     where 18: eval(code, test_env)
     where 19: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 22: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 23: doTryCatch(return(expr), name, parentenv, handler)
     where 24: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 25: tryCatchList(expr, classes, parentenv, handlers)
     where 26: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 27: test_code(NULL, exprs, env)
     where 28: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 29: force(code)
     where 30: doWithOneRestart(return(expr), restart)
     where 31: withOneRestart(expr, restarts[[1L]])
     where 32: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 33: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 34: FUN(X[[i]], ...)
     where 35: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 36: force(code)
     where 37: doWithOneRestart(return(expr), restart)
     where 38: withOneRestart(expr, restarts[[1L]])
     where 39: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 40: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 41: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 42: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 43: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_check("Seurat")
    
     --- value of length: 2 type: logical ---
     [1] TRUE TRUE
     --- function from context ---
     function (data, scale.factor = 10000, verbose = TRUE)
     {
     if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
     }
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     if (verbose) {
     cat("Performing log-normalization\n", file = stderr())
     }
     norm.data <- LogNorm(data, scale_factor = scale.factor, display_progress = verbose)
     colnames(x = norm.data) <- colnames(x = data)
     rownames(x = norm.data) <- rownames(x = data)
     return(norm.data)
     }
     <bytecode: 0x733d080>
     <environment: namespace:Seurat>
     --- function search by body ---
     Function LogNormalize in namespace Seurat has this body.
     ----------- END OF FAILURE REPORT --------------
     Fatal error: the condition has length > 1
Flavor: r-devel-linux-x86_64-debian-clang

Version: 3.1.1
Check: examples
Result: ERROR
    Running examples in ‘Seurat-Ex.R’ failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: LogNormalize
    > ### Title: Normalize raw data
    > ### Aliases: LogNormalize
    >
    > ### ** Examples
    >
    > mat <- matrix(data = rbinom(n = 25, size = 5, prob = 0.2), nrow = 5)
    > mat
     [,1] [,2] [,3] [,4] [,5]
    [1,] 0 2 0 1 2
    [2,] 1 3 0 1 0
    [3,] 1 1 1 3 1
    [4,] 2 1 1 1 0
    [5,] 0 0 2 2 0
    > mat_norm <- LogNormalize(data = mat)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    Seurat
     --- call from context ---
    LogNormalize(data = mat)
     --- call from argument ---
    if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
    }
     --- R stacktrace ---
    where 1: LogNormalize(data = mat)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (data, scale.factor = 10000, verbose = TRUE)
    {
     if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
     }
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     if (verbose) {
     cat("Performing log-normalization\n", file = stderr())
     }
     norm.data <- LogNorm(data, scale_factor = scale.factor, display_progress = verbose)
     colnames(x = norm.data) <- colnames(x = data)
     rownames(x = norm.data) <- rownames(x = data)
     return(norm.data)
    }
    <bytecode: 0x557577cb3750>
    <environment: namespace:Seurat>
     --- function search by body ---
    Function LogNormalize in namespace Seurat has this body.
     ----------- END OF FAILURE REPORT --------------
    Fatal error: the condition has length > 1
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 3.1.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [28s/39s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(Seurat)
     >
     > test_check("Seurat")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     Seurat
     --- call from context ---
     LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE)
     --- call from argument ---
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     --- R stacktrace ---
     where 1: LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE)
     where 2: eval_bare(expr, quo_get_env(quo))
     where 3: quasi_label(enquo(expected), expected.label, arg = "expected")
     where 4 at testthat/test_preprocessing.R#75: expect_equal(LogNormalize(data = GetAssayData(object = object[["RNA"]],
     slot = "counts"), verbose = FALSE), LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE))
     where 5: eval(code, test_env)
     where 6: eval(code, test_env)
     where 7: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 10: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 11: doTryCatch(return(expr), name, parentenv, handler)
     where 12: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 13: tryCatchList(expr, classes, parentenv, handlers)
     where 14: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 15: test_code(desc, code, env = parent.frame())
     where 16 at testthat/test_preprocessing.R#74: test_that("LogNormalize normalizes properly", {
     expect_equal(LogNormalize(data = GetAssayData(object = object[["RNA"]],
     slot = "counts"), verbose = FALSE), LogNormalize(data = as.data.frame(as.matrix(GetAssayData(object = object[["RNA"]],
     slot = "counts"))), verbose = FALSE))
     })
     where 17: eval(code, test_env)
     where 18: eval(code, test_env)
     where 19: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 22: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 23: doTryCatch(return(expr), name, parentenv, handler)
     where 24: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 25: tryCatchList(expr, classes, parentenv, handlers)
     where 26: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 27: test_code(NULL, exprs, env)
     where 28: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 29: force(code)
     where 30: doWithOneRestart(return(expr), restart)
     where 31: withOneRestart(expr, restarts[[1L]])
     where 32: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 33: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 34: FUN(X[[i]], ...)
     where 35: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 36: force(code)
     where 37: doWithOneRestart(return(expr), restart)
     where 38: withOneRestart(expr, restarts[[1L]])
     where 39: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 40: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 41: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 42: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 43: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_check("Seurat")
    
     --- value of length: 2 type: logical ---
     [1] TRUE TRUE
     --- function from context ---
     function (data, scale.factor = 10000, verbose = TRUE)
     {
     if (class(x = data) == "data.frame") {
     data <- as.matrix(x = data)
     }
     if (class(x = data) != "dgCMatrix") {
     data <- as(object = data, Class = "dgCMatrix")
     }
     if (verbose) {
     cat("Performing log-normalization\n", file = stderr())
     }
     norm.data <- LogNorm(data, scale_factor = scale.factor, display_progress = verbose)
     colnames(x = norm.data) <- colnames(x = data)
     rownames(x = norm.data) <- rownames(x = data)
     return(norm.data)
     }
     <bytecode: 0x55c6f53552b8>
     <environment: namespace:Seurat>
     --- function search by body ---
     Function LogNormalize in namespace Seurat has this body.
     ----------- END OF FAILURE REPORT --------------
     Fatal error: the condition has length > 1
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 3.1.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'loomR', 'MAST', 'monocle'
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc

Version: 3.1.1
Check: installed package size
Result: NOTE
     installed size is 9.1Mb
     sub-directories of 1Mb or more:
     libs 7.5Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-release-osx-x86_64, r-oldrel-osx-x86_64

Version: 3.1.1
Check: package dependencies
Result: ERROR
    Packages required but not available: 'RcppAnnoy', 'uwot'
    
    Packages suggested but not available for checking: 'loomR', 'monocle'
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-patched-solaris-x86

Version: 3.1.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'loomR', 'SingleCellExperiment', 'MAST', 'monocle'
Flavor: r-release-osx-x86_64

Version: 3.1.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     ‘loomR’ ‘SingleCellExperiment’ ‘MAST’ ‘rtracklayer’ ‘monocle’
Flavor: r-oldrel-osx-x86_64