Package 'anndata' reference manual

Title:	'anndata' for R
Description:	A 'reticulate' wrapper for the Python package 'anndata'. Provides a scalable way of keeping track of data and learned annotations. Used to read from and write to the h5ad file format.
Authors:	Philipp Angerer [ccp] (<https://orcid.org/0000-0002-0369-2888>, flying-sheep), Alex Wolf [ccp] (<https://orcid.org/0000-0002-8760-7838>, falexwolf), Isaac Virshup [ccp] (ivirshup), Sergei Rybakov [ccp] (Koncopd), Robrecht Cannoodt [aut, cre, cph] (<https://orcid.org/0000-0003-3641-729X>, rcannood)
Maintainer:	Robrecht Cannoodt <[email protected]>
License:	MIT + file LICENSE
Version:	0.7.5.6
Built:	2024-11-15 13:30:19 UTC
Source:	https://github.com/dynverse/anndata

anndata - Annotated Data

Description

anndata provides a scalable way of keeping track of data and learned annotations, and can be used to read from and write to the h5ad file format. AnnData() stores a data matrix X together with annotations of observations obs (obsm, obsp), variables var (varm, varp), and unstructured annotations uns.

Details

This package is, in essense, an R wrapper for the similarly named Python package anndata, with some added functionality to support more R-like syntax. The version number of the anndata R package is synced with the version number of the python version.

Check out ?anndata for a full list of the functions provided by this package.

Author(s)

Maintainer: Robrecht Cannoodt [email protected] (ORCID) (rcannood) [copyright holder]

Other contributors:

Philipp Angerer [email protected] (ORCID) (flying-sheep) [conceptor]
Alex Wolf [email protected] (ORCID) (falexwolf) [conceptor]
Isaac Virshup (ivirshup) [conceptor]
Sergei Rybakov (Koncopd) [conceptor]

Examples

## Not run: 
ad <- AnnData(
  X = matrix(1:6, nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(4:9, nrow = 2),
    unspliced = matrix(8:13, nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(
    a = 1,
    b = data.frame(i = 1:3, j = 4:6, value = runif(3)),
    c = list(c.a = 3, c.b = 4)
  )
)

ad$X

ad$obs
ad$var

ad$obsm["ones"]
ad$varm["rand"]

ad$layers["unspliced"]
ad$layers["spliced"]

ad$uns["b"]

ad[, c("var1", "var2")]
ad[-1, , drop = FALSE]
ad[, 2] <- 10

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(1:6, nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(4:9, nrow = 2),
    unspliced = matrix(8:13, nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(
    a = 1,
    b = data.frame(i = 1:3, j = 4:6, value = runif(3)),
    c = list(c.a = 3, c.b = 4)
  )
)

ad$X

ad$obs
ad$var

ad$obsm["ones"]
ad$varm["rand"]

ad$layers["unspliced"]
ad$layers["spliced"]

ad$uns["b"]

ad[, c("var1", "var2")]
ad[-1, , drop = FALSE]
ad[, 2] <- 10

## End(Not run)

Test if two objects objects are equal

Description

Test if two objects objects are equal

Usage

## S3 method for class 'AnnDataR6'
all.equal(target, current, ...)

## S3 method for class 'LayersR6'
all.equal(target, current, ...)

## S3 method for class 'RawR6'
all.equal(target, current, ...)
## S3 method for class 'AnnDataR6'
all.equal(target, current, ...)

## S3 method for class 'LayersR6'
all.equal(target, current, ...)

## S3 method for class 'RawR6'
all.equal(target, current, ...)

Arguments

`target`	R object.
`current`	other R object, to be compared with `target`.
`...`	further arguments for different methods, notably the following two, for numerical comparison:

Create an Annotated Data Matrix

Description

AnnData stores a data matrix X together with annotations of observations obs (obsm, obsp), variables var (varm, varp), and unstructured annotations uns.

An AnnData object adata can be sliced like a data frame, for instance adata_subset <- adata[, list_of_variable_names]. AnnData’s basic structure is similar to R's ExpressionSet.

If setting an h5ad-formatted HDF5 backing file filename, data remains on the disk but is automatically loaded into memory if needed. See this blog post for more details.

Usage

AnnData(
  X = NULL,
  obs = NULL,
  var = NULL,
  uns = NULL,
  obsm = NULL,
  varm = NULL,
  layers = NULL,
  raw = NULL,
  dtype = "float32",
  shape = NULL,
  filename = NULL,
  filemode = NULL,
  obsp = NULL,
  varp = NULL
)
AnnData(
  X = NULL,
  obs = NULL,
  var = NULL,
  uns = NULL,
  obsm = NULL,
  varm = NULL,
  layers = NULL,
  raw = NULL,
  dtype = "float32",
  shape = NULL,
  filename = NULL,
  filemode = NULL,
  obsp = NULL,
  varp = NULL
)

Arguments

`X`	A #observations × #variables data matrix. A view of the data is used if the data type matches, otherwise, a copy is made.
`obs`	Key-indexed one-dimensional observations annotation of length #observations.
`var`	Key-indexed one-dimensional variables annotation of length #variables.
`uns`	Key-indexed unstructured annotation.
`obsm`	Key-indexed multi-dimensional observations annotation of length #observations. If passing a `~numpy.ndarray`, it needs to have a structured datatype.
`varm`	Key-indexed multi-dimensional variables annotation of length #variables. If passing a `~numpy.ndarray`, it needs to have a structured datatype.
`layers`	Key-indexed multi-dimensional arrays aligned to dimensions of `X`.
`raw`	Store raw version of `X` and `var` as `⁠$raw$X⁠` and `⁠$raw$var⁠`.
`dtype`	Data type used for storage.
`shape`	Shape list (#observations, #variables). Can only be provided if `X` is `NULL`.
`filename`	Name of backing file. See h5py.File.
`filemode`	Open mode of backing file. See h5py.File.
`obsp`	Pairwise annotation of observations, a mutable mapping with array-like values.
`varp`	Pairwise annotation of observations, a mutable mapping with array-like values.

Details

AnnData stores observations (samples) of variables/features in the rows of a matrix. This is the convention of the modern classics of statistic and machine learning, the convention of dataframes both in R and Python and the established statistics and machine learning packages in Python (statsmodels, scikit-learn).

Single dimensional annotations of the observation and variables are stored in the obs and var attributes as data frames. This is intended for metrics calculated over their axes. Multi-dimensional annotations are stored in obsm and varm, which are aligned to the objects observation and variable dimensions respectively. Square matrices representing graphs are stored in obsp and varp, with both of their own dimensions aligned to their associated axis. Additional measurements across both observations and variables are stored in layers.

Indexing into an AnnData object can be performed by relative position with numeric indices, or by labels. To avoid ambiguity with numeric indexing into observations or variables, indexes of the AnnData object are converted to strings by the constructor.

Subsetting an AnnData object by indexing into it will also subset its elements according to the dimensions they were aligned to. This means an operation like adata[list_of_obs, ] will also subset obs, obsm, and layers.

Subsetting an AnnData object returns a view into the original object, meaning very little additional memory is used upon subsetting. This is achieved lazily, meaning that the constituent arrays are subset on access. Copying a view causes an equivalent “real” AnnData object to be generated. Attempting to modify a view (at any attribute except X) is handled in a copy-on-modify manner, meaning the object is initialized in place. Here's an example

batch1 <- adata[adata$obs["batch"] == "batch1", ]
batch1$obs["value"] = 0 # This makes batch1 a “real” AnnData object

At the end of this snippet: adata was not modified, and batch1 is its own AnnData object with its own data.

Similar to Bioconductor’s ExpressionSet and scipy.sparse matrices, subsetting an AnnData object retains the dimensionality of its constituent arrays. Therefore, unlike with the classes exposed by pandas, numpy, and xarray, there is no concept of a one dimensional AnnData object. AnnDatas always have two inherent dimensions, obs and var. Additionally, maintaining the dimensionality of the AnnData object allows for consistent handling of scipy.sparse matrices and numpy arrays.

Active bindings

X

Data matrix of shape n_obs × n_vars.

filename

Name of the backing file.

Change to backing mode by setting the filename of a .h5ad file.

Setting the filename writes the stored data to disk.
Setting the filename when the filename was previously another name moves the backing file from the previous file to the new file. If you want to copy the previous file, use copy(filename='new_filename').

layers

A list-like object with values of the same dimensions as X. Layers in AnnData are inspired by loompy's layers.

Overwrite the layers:

adata$layers <- list(spliced = spliced, unspliced = unspliced)

Return the layer named "unspliced":

adata$layers["unspliced"]

Create or replace the "spliced" layer:

adata$layers["spliced"] = example_matrix

Assign the 10th column of layer "spliced" to the variable a:

a <- adata$layers["spliced"][, 10]

Delete the "spliced":

adata$layers["spliced"] <- NULL

Return layers' names:

names(adata$layers)

T

Transpose whole object.

Data matrix is transposed, observations and variables are interchanged.

Ignores .raw.

is_view

TRUE if object is view of another AnnData object, FALSE otherwise.

isbacked

TRUE if object is backed on disk, FALSE otherwise.

n_obs

Number of observations.

obs

One-dimensional annotation of observations (data.frame).

obs_names

Names of observations.

obsm

Multi-dimensional annotation of observations (matrix).

Stores for each key a two or higher-dimensional matrix with n_obs rows.

obsp

Pairwise annotation of observations, a mutable mapping with array-like values.

Stores for each key a two or higher-dimensional matrix whose first two dimensions are of length n_obs.

n_vars

Number of variables.

var

One-dimensional annotation of variables (data.frame).

var_names

Names of variables.

varm

Multi-dimensional annotation of variables (matrix).

Stores for each key a two or higher-dimensional matrix with n_vars rows.

varp

Pairwise annotation of variables, a mutable mapping with array-like values.

Stores for each key a two or higher-dimensional matrix whose first two dimensions are of length n_vars.

shape

Shape of data matrix (n_obs, n_vars).

uns

Unstructured annotation (ordered dictionary).

raw

Store raw version of X and var as ⁠$raw$X⁠ and ⁠$raw$var⁠.

The raw attribute is initialized with the current content of an object by setting:

adata$raw = adata

Its content can be deleted:

adata$raw <- NULL

Upon slicing an AnnData object along the obs (row) axis, raw is also sliced. Slicing an AnnData object along the vars (columns) axis leaves raw unaffected. Note that you can call:

adata$raw[, 'orig_variable_name']$X

⁠to retrieve the data associated with a variable that might have been filtered out or "compressed away" in⁠X'.

Methods

Public methods

AnnDataR6$new()
AnnDataR6$obs_keys()
AnnDataR6$obs_names_make_unique()
AnnDataR6$obsm_keys()
AnnDataR6$var_keys()
AnnDataR6$var_names_make_unique()
AnnDataR6$varm_keys()
AnnDataR6$uns_keys()
AnnDataR6$chunk_X()
AnnDataR6$chunked_X()
AnnDataR6$concatenate()
AnnDataR6$copy()
AnnDataR6$rename_categories()
AnnDataR6$strings_to_categoricals()
AnnDataR6$to_df()
AnnDataR6$transpose()
AnnDataR6$write_csvs()
AnnDataR6$write_h5ad()
AnnDataR6$write_loom()
AnnDataR6$write_zarr()
AnnDataR6$print()
AnnDataR6$.set_py_object()
AnnDataR6$.get_py_object()

Method `new()`

Create a new AnnData object

Usage

AnnDataR6$new(obj)

Arguments

obj: A Python anndata object

Examples

\dontrun{
# use AnnData() instead of AnnDataR6$new()
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)
}

Method `obs_keys()`

List keys of observation annotation obs.

Usage

AnnDataR6$obs_keys()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$obs_keys()
}

Method `obs_names_make_unique()`

Makes the index unique by appending a number string to each duplicate index element: 1, 2, etc.

If a tentative name created by the algorithm already exists in the index, it tries the next integer in the sequence.

The first occurrence of a non-unique value is ignored.

Usage

AnnDataR6$obs_names_make_unique(join = "-")

Arguments

join: The connecting string between name and integer (default: "-").

Examples

\dontrun{
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 3),
  obs = data.frame(field = c(1, 2, 3))
)
ad$obs_names <- c("a", "a", "b")
ad$obs_names_make_unique()
ad$obs_names
}

Method `obsm_keys()`

List keys of observation annotation obsm.

Usage

AnnDataR6$obsm_keys()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$obs_keys()
}

Method `var_keys()`

List keys of variable annotation var.

Usage

AnnDataR6$var_keys()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)
ad$var_keys()
}

Method `var_names_make_unique()`

Makes the index unique by appending a number string to each duplicate index element: 1, 2, etc.

If a tentative name created by the algorithm already exists in the index, it tries the next integer in the sequence.

The first occurrence of a non-unique value is ignored.

Usage

AnnDataR6$var_names_make_unique(join = "-")

Arguments

join: The connecting string between name and integer (default: "-").

Examples

\dontrun{
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 2),
  var = data.frame(field = c(1, 2, 3))
)
ad$var_names <- c("a", "a", "b")
ad$var_names_make_unique()
ad$var_names
}

Method `varm_keys()`

List keys of variable annotation varm.

Usage

AnnDataR6$varm_keys()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$varm_keys()
}

Method `uns_keys()`

List keys of unstructured annotation uns.

Usage

AnnDataR6$uns_keys()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
}

Method `chunk_X()`

Return a chunk of the data matrix X with random or specified indices.

Usage

AnnDataR6$chunk_X(select = 1000L, replace = TRUE)

Arguments

select

Depending on the values:

1 integer: A random chunk with select rows will be returned.
multiple integers: A chunk with these indices will be returned.

replace

if select is an integer then TRUE means random sampling of indices with replacement, FALSE without replacement.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)

ad$chunk_X(select = 10L) # 10 random samples
ad$chunk_X(select = 1:3) # first 3 samples
}

Method `chunked_X()`

Return an iterator over the rows of the data matrix X.

Usage

AnnDataR6$chunked_X(chunk_size = NULL)

Arguments

chunk_size: Row size of a single chunk.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)
ad$chunked_X(10)
}

Method `concatenate()`

Concatenate along the observations axis.

Usage

AnnDataR6$concatenate(...)

Arguments

...: Deprecated

Method `copy()`

Full copy, optionally on disk.

Usage

AnnDataR6$copy(filename = NULL)

Arguments

filename: Path to filename (default: NULL).

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")
}

Method `rename_categories()`

Rename categories of annotation key in obs, var, and uns. Only supports passing a list/array-like categories argument. Besides calling ⁠self.obs[key].cat.categories = categories⁠ – similar for var - this also renames categories in unstructured annotation that uses the categorical annotation key.

Usage

AnnDataR6$rename_categories(key, categories)

Arguments

key: Key for observations or variables annotation.
categories: New categories, the same number as the old categories.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$rename_categories("group", c(a = "A", b = "B")) # ??
}

Method `strings_to_categoricals()`

Transform string annotations to categoricals.

Only affects string annotations that lead to less categories than the total number of observations.

Usage

AnnDataR6$strings_to_categoricals(df = NULL)

Arguments

df: If df is NULL, modifies both obs and var, otherwise modifies df inplace.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
)
ad$strings_to_categoricals() # ??
}

Method `to_df()`

Generate shallow data frame.

The data matrix X is returned as data frame, where obs_names are the rownames, and var_names the columns names.

No annotations are maintained in the returned object.

The data matrix is densified in case it is sparse.

Usage

AnnDataR6$to_df(layer = NULL)

Arguments

layer: Key for layers

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

ad$to_df()
ad$to_df("unspliced")
}

Method `transpose()`

transpose Transpose whole object.

Data matrix is transposed, observations and variables are interchanged.

Ignores .raw.

Usage

AnnDataR6$transpose()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)

ad$transpose()
}

Method `write_csvs()`

Write annotation to .csv files.

It is not possible to recover the full AnnData from these files. Use write_h5ad() for this.

Usage

AnnDataR6$write_csvs(dirname, skip_data = TRUE, sep = ",")

Arguments

dirname: Name of the directory to which to export.
skip_data: Skip the data matrix X.
sep: Separator for the data
anndata: An AnnData() object

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$to_write_csvs("output")

unlink("output", recursive = TRUE)
}

Method `write_h5ad()`

Write .h5ad-formatted hdf5 file.

Generally, if you have sparse data that are stored as a dense matrix, you can dramatically improve performance and reduce disk space by converting to a csr_matrix:

Usage

AnnDataR6$write_h5ad(
  filename,
  compression = NULL,
  compression_opts = NULL,
  as_dense = list()
)

Arguments

filename: Filename of data file. Defaults to backing file.
compression: See the h5py filter pipeline. Options are "gzip", "lzf" or NULL.
compression_opts: See the h5py filter pipeline.
as_dense: Sparse in AnnData object to write as dense. Currently only supports "X" and "raw/X".

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_h5ad("output.h5ad")

file.remove("output.h5ad")
}

Method `write_loom()`

Write .loom-formatted hdf5 file.

Usage

AnnDataR6$write_loom(filename, write_obsm_varm = FALSE)

Arguments

filename: The filename.
write_obsm_varm: Whether or not to also write the varm and obsm.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_loom("output.loom")

file.remove("output.loom")
}

Method `write_zarr()`

Write a hierarchical Zarr array store.

Usage

AnnDataR6$write_zarr(store, chunks = NULL)

Arguments

store: The filename, a MutableMapping, or a Zarr storage class.
chunks: Chunk size.

Method `print()`

Print AnnData object

Usage

AnnDataR6$print(...)

Arguments

...: optional arguments to print method.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$print()
print(ad)
}

Method `.set_py_object()`

Set internal Python object

Usage

AnnDataR6$.set_py_object(obj)

Arguments

obj: A python anndata object

Method `.get_py_object()`

Get internal Python object

Usage

AnnDataR6$.get_py_object()

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

value <- matrix(c(1, 2, 3, 4), nrow = 2)
ad$X <- value
ad$X

ad$layers
ad$layers["spliced"]
ad$layers["test"] <- value
ad$layers

ad$to_df()
ad$uns

as.matrix(ad)
as.matrix(ad, layer = "unspliced")
dim(ad)
rownames(ad)
colnames(ad)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$new`
## ------------------------------------------------

## Not run: 
# use AnnData() instead of AnnDataR6$new()
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obs_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$obs_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obs_names_make_unique`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 3),
  obs = data.frame(field = c(1, 2, 3))
)
ad$obs_names <- c("a", "a", "b")
ad$obs_names_make_unique()
ad$obs_names

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obsm_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$obs_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$var_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)
ad$var_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$var_names_make_unique`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 2),
  var = data.frame(field = c(1, 2, 3))
)
ad$var_names <- c("a", "a", "b")
ad$var_names_make_unique()
ad$var_names

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$varm_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$varm_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$uns_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$chunk_X`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)

ad$chunk_X(select = 10L) # 10 random samples
ad$chunk_X(select = 1:3) # first 3 samples

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$chunked_X`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)
ad$chunked_X(10)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$copy`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$rename_categories`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$rename_categories("group", c(a = "A", b = "B")) # ??

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$strings_to_categoricals`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
)
ad$strings_to_categoricals() # ??

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$to_df`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

ad$to_df()
ad$to_df("unspliced")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$transpose`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)

ad$transpose()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_csvs`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$to_write_csvs("output")

unlink("output", recursive = TRUE)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_h5ad`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_h5ad("output.h5ad")

file.remove("output.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_loom`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_loom("output.loom")

file.remove("output.loom")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$print()
print(ad)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

value <- matrix(c(1, 2, 3, 4), nrow = 2)
ad$X <- value
ad$X

ad$layers
ad$layers["spliced"]
ad$layers["test"] <- value
ad$layers

ad$to_df()
ad$uns

as.matrix(ad)
as.matrix(ad, layer = "unspliced")
dim(ad)
rownames(ad)
colnames(ad)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$new`
## ------------------------------------------------

## Not run: 
# use AnnData() instead of AnnDataR6$new()
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obs_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$obs_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obs_names_make_unique`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 3),
  obs = data.frame(field = c(1, 2, 3))
)
ad$obs_names <- c("a", "a", "b")
ad$obs_names_make_unique()
ad$obs_names

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$obsm_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$obs_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$var_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)
ad$var_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$var_names_make_unique`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(rep(1, 6), nrow = 2),
  var = data.frame(field = c(1, 2, 3))
)
ad$var_names <- c("a", "a", "b")
ad$var_names_make_unique()
ad$var_names

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$varm_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  )
)
ad$varm_keys()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$uns_keys`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$chunk_X`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)

ad$chunk_X(select = 10L) # 10 random samples
ad$chunk_X(select = 1:3) # first 3 samples

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$chunked_X`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(runif(10000), nrow = 50)
)
ad$chunked_X(10)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$copy`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$rename_categories`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2"))
)
ad$rename_categories("group", c(a = "A", b = "B")) # ??

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$strings_to_categoricals`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
)
ad$strings_to_categoricals() # ??

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$to_df`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

ad$to_df()
ad$to_df("unspliced")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$transpose`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2"))
)

ad$transpose()

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_csvs`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$to_write_csvs("output")

unlink("output", recursive = TRUE)

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_h5ad`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_h5ad("output.h5ad")

file.remove("output.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$write_loom`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_loom("output.loom")

file.remove("output.loom")

## End(Not run)

## ------------------------------------------------
## Method `AnnDataR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$print()
print(ad)

## End(Not run)

concat

Description

Concatenates AnnData objects along an axis.

Usage

concat(
  adatas,
  axis = 0L,
  join = "inner",
  merge = NULL,
  uns_merge = NULL,
  label = NULL,
  keys = NULL,
  index_unique = NULL,
  fill_value = NULL,
  pairwise = FALSE
)
concat(
  adatas,
  axis = 0L,
  join = "inner",
  merge = NULL,
  uns_merge = NULL,
  label = NULL,
  keys = NULL,
  index_unique = NULL,
  fill_value = NULL,
  pairwise = FALSE
)

Arguments

`adatas`	The objects to be concatenated. If a Mapping is passed, keys are used for the `keys` argument and values are concatenated.
`axis`	Which axis to concatenate along.
`join`	How to align values when concatenating. If "outer", the union of the other axis is taken. If "inner", the intersection. See `concatenation` for more.
`merge`	How elements not aligned to the axis being concatenated along are selected. Currently implemented strategies include: * `NULL`: No elements are kept. * `"same"`: Elements that are the same in each of the objects. * `"unique"`: Elements for which there is only one possible value. * `"first"`: The first element seen at each from each position. * `"only"`: Elements that show up in only one of the objects.
`uns_merge`	How the elements of `.uns` are selected. Uses the same set of strategies as the `merge` argument, except applied recursively.
`label`	Column in axis annotation (i.e. `.obs` or `.var`) to place batch information in. If it's NULL, no column is added.
`keys`	Names for each object being added. These values are used for column values for `label` or appended to the index if `index_unique` is not `NULL`. Defaults to incrementing integer labels.
`index_unique`	Whether to make the index unique by using the keys. If provided, this is the delimeter between "orig_idxindex_uniquekey". When `NULL`, the original indices are kept.
`fill_value`	When `join="outer"`, this is the value that will be used to fill the introduced indices. By default, sparse arrays are padded with zeros, while dense arrays and DataFrames are padded with missing values.
`pairwise`	Whether pairwise elements along the concatenated dimension should be included. This is FALSE by default, since the resulting arrays are often not meaningful.

Details

See the concatenation section in the docs for a more in-depth description.

warning: This function is marked as experimental for the 0.7 release series, and will supercede the AnnData$concatenate() method in future releases.

warning: If you use join='outer' this fills 0s for sparse data when variables are absent in a batch. Use this with care. Dense data is filled with NaN.

Examples

## Not run: 
# Preparing example objects
a <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(
    a = 1,
    b = 2,
    c = list(
      c.a = 3,
      c.b = 4
    )
  )
)

b <- AnnData(
  X = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("b", "c"), row.names = c("s3", "s4")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  varm = list(
    ones = matrix(rep(1L, 15), nrow = 3),
    rand = matrix(rnorm(15), nrow = 3)
  ),
  uns = list(
    a = 1,
    b = 3,
    c = list(
      c.a = 3
    )
  )
)

c <- AnnData(
  X = matrix(c(10, 11, 12, 13), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(3L, 4L), row.names = c("var3", "var4")),
  uns = list(
    a = 1,
    b = 4,
    c = list(
      c.a = 3,
      c.b = 4,
      c.c = 5
    )
  )
)

# Concatenating along different axes
concat(list(a, b))$to_df()
concat(list(a, c), axis = 1L)$to_df()

# Inner and outer joins
inner <- concat(list(a, b))
inner
inner$obs_names
inner$var_names

outer <- concat(list(a, b), join = "outer")
outer
outer$var_names
outer$to_df()

# Keeping track of source objects
concat(list(a = a, b = b), label = "batch")$obs
concat(list(a, b), label = "batch", keys = c("a", "b"))$obs
concat(list(a = a, b = b), index_unique = "-")$obs

# Combining values not aligned to axis of concatenation
concat(list(a, b), merge = "same")
concat(list(a, b), merge = "unique")
concat(list(a, b), merge = "first")
concat(list(a, b), merge = "only")

# The same merge strategies can be used for elements in .uns
concat(list(a, b, c), uns_merge = "same")$uns
concat(list(a, b, c), uns_merge = "unique")$uns
concat(list(a, b, c), uns_merge = "first")$uns
concat(list(a, b, c), uns_merge = "only")$uns

## End(Not run)
## Not run: 
# Preparing example objects
a <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(
    a = 1,
    b = 2,
    c = list(
      c.a = 3,
      c.b = 4
    )
  )
)

b <- AnnData(
  X = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("b", "c"), row.names = c("s3", "s4")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  varm = list(
    ones = matrix(rep(1L, 15), nrow = 3),
    rand = matrix(rnorm(15), nrow = 3)
  ),
  uns = list(
    a = 1,
    b = 3,
    c = list(
      c.a = 3
    )
  )
)

c <- AnnData(
  X = matrix(c(10, 11, 12, 13), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(3L, 4L), row.names = c("var3", "var4")),
  uns = list(
    a = 1,
    b = 4,
    c = list(
      c.a = 3,
      c.b = 4,
      c.c = 5
    )
  )
)

# Concatenating along different axes
concat(list(a, b))$to_df()
concat(list(a, c), axis = 1L)$to_df()

# Inner and outer joins
inner <- concat(list(a, b))
inner
inner$obs_names
inner$var_names

outer <- concat(list(a, b), join = "outer")
outer
outer$var_names
outer$to_df()

# Keeping track of source objects
concat(list(a = a, b = b), label = "batch")$obs
concat(list(a, b), label = "batch", keys = c("a", "b"))$obs
concat(list(a = a, b = b), index_unique = "-")$obs

# Combining values not aligned to axis of concatenation
concat(list(a, b), merge = "same")
concat(list(a, b), merge = "unique")
concat(list(a, b), merge = "first")
concat(list(a, b), merge = "only")

# The same merge strategies can be used for elements in .uns
concat(list(a, b, c), uns_merge = "same")$uns
concat(list(a, b, c), uns_merge = "unique")$uns
concat(list(a, b, c), uns_merge = "first")$uns
concat(list(a, b, c), uns_merge = "only")$uns

## End(Not run)

AnnData Helpers

Description

AnnData Helpers

Usage

## S3 method for class 'AnnDataR6'
dimnames(x)

## S3 replacement method for class 'AnnDataR6'
dimnames(x) <- value

## S3 method for class 'AnnDataR6'
dim(x)

## S3 method for class 'AnnDataR6'
as.data.frame(x, row.names = NULL, optional = FALSE, layer = NULL, ...)

## S3 method for class 'AnnDataR6'
as.matrix(x, layer = NULL, ...)

## S3 method for class 'AnnDataR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.anndata.AnnData'
py_to_r(x)

## S3 method for class 'AnnDataR6'
x[oidx, vidx]

## S3 method for class 'AnnDataR6'
t(x)

## S3 method for class 'anndata._core.sparse_dataset.SparseDataset'
py_to_r(x)

## S3 method for class 'h5py._hl.dataset.Dataset'
py_to_r(x)
## S3 method for class 'AnnDataR6'
dimnames(x)

## S3 replacement method for class 'AnnDataR6'
dimnames(x) <- value

## S3 method for class 'AnnDataR6'
dim(x)

## S3 method for class 'AnnDataR6'
as.data.frame(x, row.names = NULL, optional = FALSE, layer = NULL, ...)

## S3 method for class 'AnnDataR6'
as.matrix(x, layer = NULL, ...)

## S3 method for class 'AnnDataR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.anndata.AnnData'
py_to_r(x)

## S3 method for class 'AnnDataR6'
x[oidx, vidx]

## S3 method for class 'AnnDataR6'
t(x)

## S3 method for class 'anndata._core.sparse_dataset.SparseDataset'
py_to_r(x)

## S3 method for class 'h5py._hl.dataset.Dataset'
py_to_r(x)

Arguments

`x`	An AnnData object.
`value`	a possible valie for `dimnames(ad)`. The dimnames of a AnnData can be `NULL` (which is not stored) or a list of the same length as `dim(ad)`. If a list, its components are either NULL or a character vector with positive length of the appropriate dimension of `ad`.
`row.names`	Not used.
`optional`	Not used.
`layer`	An AnnData layer. If `NULL`, will use `ad$X`, otherwise `ad$layers[layer]`.
`...`	Parameters passed to the underlying function.
`convert`	Not used.
`oidx`	Observation indices
`vidx`	Variable indices

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

dimnames(ad)
dim(ad)
as.data.frame(ad)
as.data.frame(ad, layer = "unspliced")
as.matrix(ad)
as.matrix(ad, layer = "unspliced")
ad[2, , drop = FALSE]
ad[, -1]
ad[, c("var1", "var2")]

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

dimnames(ad)
dim(ad)
as.data.frame(ad)
as.data.frame(ad, layer = "unspliced")
as.matrix(ad)
as.matrix(ad, layer = "unspliced")
ad[2, , drop = FALSE]
ad[, -1]
ad[, c("var1", "var2")]

## End(Not run)

Raw Helpers

Description

Raw Helpers

Usage

## S3 method for class 'RawR6'
dimnames(x)

## S3 method for class 'RawR6'
dim(x)

## S3 method for class 'RawR6'
as.matrix(x, ...)

## S3 method for class 'RawR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.raw.Raw'
py_to_r(x)

## S3 method for class 'RawR6'
x[...]
## S3 method for class 'RawR6'
dimnames(x)

## S3 method for class 'RawR6'
dim(x)

## S3 method for class 'RawR6'
as.matrix(x, ...)

## S3 method for class 'RawR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.raw.Raw'
py_to_r(x)

## S3 method for class 'RawR6'
x[...]

Arguments

`x`	An AnnData object.
`...`	Parameters passed to the underlying function.
`convert`	Not used.

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

dimnames(ad$raw)
dim(ad$raw)
as.matrix(ad$raw)
ad$raw[2, , drop = FALSE]
ad$raw[, -1]
ad$raw[, c("var1", "var2")]

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 12), nrow = 3),
    rand = matrix(rnorm(6), nrow = 3),
    zeros = matrix(rep(0L, 12), nrow = 3)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

dimnames(ad$raw)
dim(ad$raw)
as.matrix(ad$raw)
ad$raw[2, , drop = FALSE]
ad$raw[, -1]
ad$raw[, c("var1", "var2")]

## End(Not run)

Install anndata

Description

Needs to be run after installing the anndata R package.

Usage

install_anndata(method = "auto", conda = "auto")
install_anndata(method = "auto", conda = "auto")

Arguments

`method`	Installation method. By default, "auto" automatically finds a method that will work in the local environment. Change the default to force a specific installation method. Note that the "virtualenv" method is not available on Windows.
`conda`	The path to a `conda` executable. Use `"auto"` to allow `reticulate` to automatically find an appropriate `conda` binary. See Finding Conda and `conda_binary()` for more details.

Examples

## Not run: 
reticulate::conda_install()
install_anndata()

## End(Not run)
## Not run: 
reticulate::conda_install()
install_anndata()

## End(Not run)

Create a Layers object

Description

Create a Layers object

Usage

Layers(parent, vals = NULL)
Layers(parent, vals = NULL)

Arguments

`parent`	An AnnData object.
`vals`	A named list of matrices with the same dimensions as `parent`.

Active bindings

parent: Reference to parent AnnData view

Methods

Method `new()`

Create a new Layers object

Usage

LayersR6$new(obj)

Arguments

obj: A Python Layers object

Method `print()`

Print Layers object

Usage

LayersR6$print(...)

Arguments

...: optional arguments to print method.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

print(ad$layers)
}

Method `get()`

Get a layer

Usage

LayersR6$get(name)

Arguments

name: Name of the layer

Method `set()`

Set a layer

Usage

LayersR6$set(name, value)

Arguments

name: Name of the layer
value: A matrix

Method `del()`

Delete a layer

Usage

LayersR6$del(name)

Arguments

name: Name of the layer

Method `keys()`

Get the names of the layers

Usage

LayersR6$keys()

Method `length()`

Get the number of layers

Usage

LayersR6$length()

Method `.set_py_object()`

Set internal Python object

Usage

LayersR6$.set_py_object(obj)

Arguments

obj: A Python layers object

Method `.get_py_object()`

Get internal Python object

Usage

LayersR6$.get_py_object()

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)
ad$layers["spliced"]
ad$layers["test"] <- matrix(c(1, 3, 5, 7), nrow = 2)

length(ad$layers)
names(ad$layers)

## End(Not run)

## ------------------------------------------------
## Method `LayersR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

print(ad$layers)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)
ad$layers["spliced"]
ad$layers["test"] <- matrix(c(1, 3, 5, 7), nrow = 2)

length(ad$layers)
names(ad$layers)

## End(Not run)

## ------------------------------------------------
## Method `LayersR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)

print(ad$layers)

## End(Not run)

Layers Helpers

Description

Layers Helpers

Usage

## S3 method for class 'LayersR6'
names(x)

## S3 method for class 'LayersR6'
length(x)

## S3 method for class 'LayersR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.aligned_mapping.LayersBase'
py_to_r(x)

## S3 method for class 'LayersR6'
x[name]

## S3 replacement method for class 'LayersR6'
x[name] <- value

## S3 method for class 'LayersR6'
x[[name]]

## S3 replacement method for class 'LayersR6'
x[[name]] <- value
## S3 method for class 'LayersR6'
names(x)

## S3 method for class 'LayersR6'
length(x)

## S3 method for class 'LayersR6'
r_to_py(x, convert = FALSE)

## S3 method for class 'anndata._core.aligned_mapping.LayersBase'
py_to_r(x)

## S3 method for class 'LayersR6'
x[name]

## S3 replacement method for class 'LayersR6'
x[name] <- value

## S3 method for class 'LayersR6'
x[[name]]

## S3 replacement method for class 'LayersR6'
x[[name]] <- value

Arguments

`x`	An AnnData object.
`convert`	Not used.
`name`	Name of the layer.
`value`	Replacement value.

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  )
)

ad$layers["spliced"]
ad$layers["test"] <- matrix(c(1, 3, 5, 7), nrow = 2)

length(ad$layers)
names(ad$layers)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3, 4, 5), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L, 3L), row.names = c("var1", "var2", "var3")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7, 8, 9), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11, 12, 13), nrow = 2)
  )
)

ad$layers["spliced"]
ad$layers["test"] <- matrix(c(1, 3, 5, 7), nrow = 2)

length(ad$layers)
names(ad$layers)

## End(Not run)

Convert between Python and R objects

Description

Convert between Python and R objects

Usage

## S3 replacement method for class 'collections.abc.MutableMapping'
x[[name]] <- value

## S3 method for class 'collections.abc.Mapping'
x[[name]]

## S3 replacement method for class 'collections.abc.MutableMapping'
x[name] <- value

## S3 method for class 'collections.abc.Mapping'
x[name]

## S3 method for class 'collections.abc.Mapping'
names(x)

## S3 method for class 'collections.abc.Set'
py_to_r(x)

## S3 method for class 'pandas.core.indexes.base.Index'
py_to_r(x)

## S3 method for class 'collections.abc.KeysView'
py_to_r(x)

## S3 method for class 'collections.abc.Mapping'
py_to_r(x)
## S3 replacement method for class 'collections.abc.MutableMapping'
x[[name]] <- value

## S3 method for class 'collections.abc.Mapping'
x[[name]]

## S3 replacement method for class 'collections.abc.MutableMapping'
x[name] <- value

## S3 method for class 'collections.abc.Mapping'
x[name]

## S3 method for class 'collections.abc.Mapping'
names(x)

## S3 method for class 'collections.abc.Set'
py_to_r(x)

## S3 method for class 'pandas.core.indexes.base.Index'
py_to_r(x)

## S3 method for class 'collections.abc.KeysView'
py_to_r(x)

## S3 method for class 'collections.abc.Mapping'
py_to_r(x)

Arguments

`x`	A Python object.
`name`	A name
`value`	A value

Value

An R object, as converted from the Python object.

Create a Raw object

Description

Create a Raw object

Usage

Raw(adata, X = NULL, var = NULL, varm = NULL)
Raw(adata, X = NULL, var = NULL, varm = NULL)

Arguments

`adata`	An AnnData object.
`X`	A #observations × #variables data matrix.
`var`	Key-indexed one-dimensional variables annotation of length #variables.
`varm`	Key-indexed multi-dimensional variables annotation of length #variables.

Active bindings

X

Data matrix of shape n_obs × n_vars.

n_obs

Number of observations.

obs_names

Names of observations.

n_vars

Number of variables.

var

One-dimensional annotation of variables (data.frame).

var_names

Names of variables.

varm

Multi-dimensional annotation of variables (matrix).

Stores for each key a two or higher-dimensional matrix with n_var rows.

shape

Shape of data matrix (n_obs, n_vars).

Methods

Public methods

RawR6$new()
RawR6$copy()
RawR6$to_adata()
RawR6$print()
RawR6$.set_py_object()
RawR6$.get_py_object()

Method `new()`

Create a new Raw object

Usage

RawR6$new(obj)

Arguments

obj: A Python Raw object

Method `copy()`

Full copy, optionally on disk.

Usage

RawR6$copy()

Arguments

filename: Path to filename (default: NULL).

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")
}

Method `to_adata()`

Create a full AnnData object

Usage

RawR6$to_adata()

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)
ad$raw <- ad

ad$raw$to_adata()
}

Method `print()`

Print Raw object

Usage

RawR6$print(...)

Arguments

...: optional arguments to print method.

Examples

\dontrun{
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

library(reticulate)
sc <- import("scanpy")
sc$pp$normalize_per_cell(ad)

ad[]
ad$raw[]

ad$print()
print(ad)
}

Method `.set_py_object()`

Set internal Python object

Usage

RawR6$.set_py_object(obj)

Arguments

obj: A Python Raw object

Method `.get_py_object()`

Get internal Python object

Usage

RawR6$.get_py_object()

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

library(reticulate)
sc <- import("scanpy")
sc$pp$normalize_per_cell(ad)

ad[]
ad$raw[]

## End(Not run)

## ------------------------------------------------
## Method `RawR6$copy`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `RawR6$to_adata`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)
ad$raw <- ad

ad$raw$to_adata()

## End(Not run)

## ------------------------------------------------
## Method `RawR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

library(reticulate)
sc <- import("scanpy")
sc$pp$normalize_per_cell(ad)

ad[]
ad$raw[]

ad$print()
print(ad)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

library(reticulate)
sc <- import("scanpy")
sc$pp$normalize_per_cell(ad)

ad[]
ad$raw[]

## End(Not run)

## ------------------------------------------------
## Method `RawR6$copy`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2)
)
ad$copy()
ad$copy("file.h5ad")

## End(Not run)

## ------------------------------------------------
## Method `RawR6$to_adata`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  )
)
ad$raw <- ad

ad$raw$to_adata()

## End(Not run)

## ------------------------------------------------
## Method `RawR6$print`
## ------------------------------------------------

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  layers = list(
    spliced = matrix(c(4, 5, 6, 7), nrow = 2),
    unspliced = matrix(c(8, 9, 10, 11), nrow = 2)
  ),
  obsm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)
ad$raw <- ad

library(reticulate)
sc <- import("scanpy")
sc$pp$normalize_per_cell(ad)

ad[]
ad$raw[]

ad$print()
print(ad)

## End(Not run)

read_csv

Description

Read .csv file.

Usage

read_csv(
  filename,
  delimiter = ",",
  first_column_names = NULL,
  dtype = "float32"
)
read_csv(
  filename,
  delimiter = ",",
  first_column_names = NULL,
  dtype = "float32"
)

Arguments

`filename`	Data file.
`delimiter`	Delimiter that separates data within text file. If `NULL`, will split at arbitrary number of white spaces, which is different from enforcing splitting at single white space `' '`.
`first_column_names`	Assume the first column stores row names.
`dtype`	Numpy data type.

Details

Same as read_text() but with default delimiter ','.

Examples

## Not run: 
ad <- read_csv("matrix.csv")

## End(Not run)
## Not run: 
ad <- read_csv("matrix.csv")

## End(Not run)

read_excel

Description

Read .xlsx (Excel) file.

Usage

read_excel(filename, sheet, dtype = "float32")
read_excel(filename, sheet, dtype = "float32")

Arguments

`filename`	File name to read from.
`sheet`	Name of sheet in Excel file.
`dtype`	Numpy data type.

Details

Assumes that the first columns stores the row names and the first row the column names.

Examples

## Not run: 
ad <- read_excel("spreadsheet.xls")

## End(Not run)
## Not run: 
ad <- read_excel("spreadsheet.xls")

## End(Not run)

read_h5ad

Description

Read .h5ad-formatted hdf5 file.

Usage

read_h5ad(filename, backed = NULL)
read_h5ad(filename, backed = NULL)

Arguments

`filename`	File name of data file.
`backed`	If `'r'`, load `~anndata.AnnData` in `backed` mode instead of fully loading it into memory (`memory` mode). If you want to modify backed attributes of the AnnData object, you need to choose `'r+'`.

Examples

## Not run: 
ad <- read_h5ad("example_formats/pbmc_1k_protein_v3_processed.h5ad")

## End(Not run)
## Not run: 
ad <- read_h5ad("example_formats/pbmc_1k_protein_v3_processed.h5ad")

## End(Not run)

read_hdf

Description

Read .h5 (hdf5) file.

Usage

read_hdf(filename, key)
read_hdf(filename, key)

Arguments

`filename`	Filename of data file.
`key`	Name of dataset in the file.

Details

Note: Also looks for fields row_names and col_names.

Examples

## Not run: 
ad <- read_hdf("file.h5")

## End(Not run)
## Not run: 
ad <- read_hdf("file.h5")

## End(Not run)

read_loom

Description

Read .loom-formatted hdf5 file.

Usage

read_loom(
  filename,
  sparse = TRUE,
  cleanup = FALSE,
  X_name = "spliced",
  obs_names = "CellID",
  obsm_names = NULL,
  var_names = "Gene",
  varm_names = NULL,
  dtype = "float32",
  ...
)
read_loom(
  filename,
  sparse = TRUE,
  cleanup = FALSE,
  X_name = "spliced",
  obs_names = "CellID",
  obsm_names = NULL,
  var_names = "Gene",
  varm_names = NULL,
  dtype = "float32",
  ...
)

Arguments

`filename`	The filename.
`sparse`	Whether to read the data matrix as sparse.
`cleanup`	Whether to collapse all obs/var fields that only store one unique value into `.uns['loom-.']`.
`X_name`	Loompy key with which the data matrix `AnnData.X` is initialized.
`obs_names`	Loompy key where the observation/cell names are stored.
`obsm_names`	Loompy keys which will be constructed into observation matrices
`var_names`	Loompy key where the variable/gene names are stored.
`varm_names`	Loompy keys which will be constructed into variable matrices
`dtype`	Numpy data type.
`...`	Arguments to loompy.connect

Details

This reads the whole file into memory. Beware that you have to explicitly state when you want to read the file as sparse data.

Examples

## Not run: 
ad <- read_loom("dataset.loom")

## End(Not run)
## Not run: 
ad <- read_loom("dataset.loom")

## End(Not run)

read_mtx

Description

Read .mtx file.

Usage

read_mtx(filename, dtype = "float32")
read_mtx(filename, dtype = "float32")

Arguments

`filename`	The filename.
`dtype`	Numpy data type.

Examples

## Not run: 
ad <- read_mtx("matrix.mtx")

## End(Not run)
## Not run: 
ad <- read_mtx("matrix.mtx")

## End(Not run)

read_text

Description

Read .txt, .tab, .data (text) file.

Usage

read_text(
  filename,
  delimiter = NULL,
  first_column_names = NULL,
  dtype = "float32"
)
read_text(
  filename,
  delimiter = NULL,
  first_column_names = NULL,
  dtype = "float32"
)

Arguments

`filename`	Data file, filename or stream.
`delimiter`	Delimiter that separates data within text file. If `NULL`, will split at arbitrary number of white spaces, which is different from enforcing splitting at single white space `' '`.
`first_column_names`	Assume the first column stores row names.
`dtype`	Numpy data type.

Details

Same as read_csv() but with default delimiter NULL.

Examples

## Not run: 
ad <- read_text("matrix.tab")

## End(Not run)
## Not run: 
ad <- read_text("matrix.tab")

## End(Not run)

read_umi_tools

Description

Read a gzipped condensed count matrix from umi_tools.

Usage

read_umi_tools(filename, dtype = "float32")
read_umi_tools(filename, dtype = "float32")

Arguments

`filename`	File name to read from.
`dtype`	Numpy data type.

Examples

## Not run: 
ad <- read_umi_tools("...")

## End(Not run)
## Not run: 
ad <- read_umi_tools("...")

## End(Not run)

Read from a hierarchical Zarr array store.

Description

Read from a hierarchical Zarr array store.

Usage

read_zarr(store)
read_zarr(store)

Arguments

store

The filename, a MutableMapping, or a Zarr storage class.

Examples

## Not run: 
ad <- read_zarr("...")

## End(Not run)
## Not run: 
ad <- read_zarr("...")

## End(Not run)

Write annotation to .csv files.

Description

It is not possible to recover the full AnnData from these files. Use write_h5ad() for this.

Usage

write_csvs(anndata, dirname, skip_data = TRUE, sep = ",")
write_csvs(anndata, dirname, skip_data = TRUE, sep = ",")

Arguments

`anndata`	An `AnnData()` object
`dirname`	Name of the directory to which to export.
`skip_data`	Skip the data matrix `X`.
`sep`	Separator for the data

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_csvs(ad, "output")

unlink("output", recursive = TRUE)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_csvs(ad, "output")

unlink("output", recursive = TRUE)

## End(Not run)

Write .h5ad-formatted hdf5 file.

Description

Generally, if you have sparse data that are stored as a dense matrix, you can dramatically improve performance and reduce disk space by converting to a csr_matrix:

Usage

write_h5ad(
  anndata,
  filename,
  compression = NULL,
  compression_opts = NULL,
  as_dense = list()
)
write_h5ad(
  anndata,
  filename,
  compression = NULL,
  compression_opts = NULL,
  as_dense = list()
)

Arguments

`anndata`	An `AnnData()` object
`filename`	Filename of data file. Defaults to backing file.
`compression`	See the h5py filter pipeline. Options are `"gzip"`, `"lzf"` or `NULL`.
`compression_opts`	See the h5py filter pipeline.
`as_dense`	Sparse in AnnData object to write as dense. Currently only supports `"X"` and `"raw/X"`.

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_h5ad(ad, "output.h5ad")

file.remove("output.h5ad")

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_h5ad(ad, "output.h5ad")

file.remove("output.h5ad")

## End(Not run)

Write .loom-formatted hdf5 file.

Description

Write .loom-formatted hdf5 file.

Usage

write_loom(anndata, filename, write_obsm_varm = FALSE)
write_loom(anndata, filename, write_obsm_varm = FALSE)

Arguments

`anndata`	An `AnnData()` object
`filename`	The filename.
`write_obsm_varm`	Whether or not to also write the varm and obsm.

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_loom(ad, "output.loom")

file.remove("output.loom")

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

write_loom(ad, "output.loom")

file.remove("output.loom")

## End(Not run)

Write a hierarchical Zarr array store.

Description

Write a hierarchical Zarr array store.

Usage

write_zarr(anndata, store, chunks = NULL)
write_zarr(anndata, store, chunks = NULL)

Arguments

`anndata`	An `AnnData()` object
`store`	The filename, a MutableMapping, or a Zarr storage class.
`chunks`	Chunk shape.

Examples

## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_zarr("output.zarr")
write_zarr(ad, "output.zarr")

unlink("output.zarr", recursive = TRUE)

## End(Not run)
## Not run: 
ad <- AnnData(
  X = matrix(c(0, 1, 2, 3), nrow = 2, byrow = TRUE),
  obs = data.frame(group = c("a", "b"), row.names = c("s1", "s2")),
  var = data.frame(type = c(1L, 2L), row.names = c("var1", "var2")),
  varm = list(
    ones = matrix(rep(1L, 10), nrow = 2),
    rand = matrix(rnorm(6), nrow = 2),
    zeros = matrix(rep(0L, 10), nrow = 2)
  ),
  uns = list(a = 1, b = 2, c = list(c.a = 3, c.b = 4))
)

ad$write_zarr("output.zarr")
write_zarr(ad, "output.zarr")

unlink("output.zarr", recursive = TRUE)

## End(Not run)

Package 'anndata'

Help Index

anndata - Annotated Data

Description

Details

Creating an AnnData object

Concatenating two or more AnnData objects

Reading an AnnData object from a file

Writing an AnnData object to a file

Install the anndata Python package

Author(s)

See Also

Examples

Test if two objects objects are equal

Description

Usage

Arguments

Create an Annotated Data Matrix

Description

Usage

Arguments

Details

Active bindings

Methods

Public methods

Method new()

Usage

Arguments

Examples

Method obs_keys()

Usage

Examples

Method obs_names_make_unique()

Usage

Arguments

Examples

Method obsm_keys()

Usage

Examples

Method var_keys()

Usage

Examples

Method var_names_make_unique()

Usage

Arguments

Examples

Method varm_keys()

Usage

Examples

Method uns_keys()

Usage

Examples

Method chunk_X()

Usage

Arguments

Examples

Method chunked_X()

Usage

Arguments

Examples

Method concatenate()

Usage

Arguments

Method copy()

Usage

Arguments

Examples

Method rename_categories()

Usage

Arguments

Examples

Method strings_to_categoricals()

Usage

Arguments

Examples

Method to_df()

Usage

Arguments

Examples

Method transpose()

Install the `anndata` Python package

Method `new()`

Method `obs_keys()`

Method `obs_names_make_unique()`

Method `obsm_keys()`

Method `var_keys()`

Method `var_names_make_unique()`

Method `varm_keys()`

Method `uns_keys()`

Method `chunk_X()`

Method `chunked_X()`

Method `concatenate()`

Method `copy()`

Method `rename_categories()`

Method `strings_to_categoricals()`

Method `to_df()`

Method `transpose()`

Method `write_csvs()`

Method `write_h5ad()`

Method `write_loom()`

Method `write_zarr()`

Method `print()`

Method `.set_py_object()`

Method `.get_py_object()`

Method `new()`

Method `print()`

Method `get()`

Method `set()`

Method `del()`