% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/creation.R
\name{zarr_open_array}
\alias{zarr_open_array}
\title{Open an array using file-mode-like semantics.}
\usage{
zarr_open_array(
  store = NA,
  storage_options = NA,
  mode = NA,
  shape = NA,
  chunks = TRUE,
  dtype = NA,
  compressor = NA,
  fill_value = NA,
  order = NA,
  synchronizer = NA,
  overwrite = FALSE,
  path = NA,
  chunk_store = NA,
  filters = NA,
  cache_metadata = TRUE,
  cache_attrs = TRUE,
  object_codec = NA,
  dimension_separator = NA,
  write_empty_chunks = TRUE,
  zarr_format = 2L
)
}
\arguments{
\item{store}{: Store
A mapping that supports string keys and bytes-like values.}

\item{storage_options}{: dict
If using an fsspec URL to create the store, these will be passed to
the backend implementation. Ignored otherwise.}

\item{mode}{: \code{'r', 'r+', 'a', 'w', 'w-'}, optional
Persistence mode: 'r' means read only (must exist); 'r+' means
read/write (must exist); 'a' means read/write (create if doesn't
exist); 'w' means create (overwrite if exists); 'w-' means create
(fail if exists).}

\item{shape}{: int or tuple of ints
Array shape.}

\item{chunks}{: bool, int or tuple of ints, optional
Chunk shape. If True, will be guessed from \code{shape} and \code{dtype}. If
False, will be set to \code{shape}, i.e., single chunk for the whole array.}

\item{dtype}{: string or dtype, optional
NumPy dtype.}

\item{compressor}{: Codec, optional
Primary compressor.}

\item{fill_value}{: object
Default value to use for uninitialized portions of the array.}

\item{order}{: \code{'C', 'F'}, optional
Memory layout to be used within each chunk.}

\item{synchronizer}{: object, optional
Array synchronizer.}

\item{overwrite}{: bool, optional
If True, erase all data in \code{store} prior to initialisation.}

\item{path}{: string, bytes, optional
Path under which array is stored.}

\item{chunk_store}{: Store, optional
Separate storage for chunks. If not provided, \code{store} will be used
for storage of both chunks and metadata.}

\item{filters}{: sequence, optional
Sequence of filters to use to encode chunk data prior to compression.}

\item{cache_metadata}{: bool, optional
If True, array configuration metadata will be cached for the
lifetime of the object. If False, array metadata will be reloaded
prior to all data access and modification operations (may incur
overhead depending on storage and data access pattern).}

\item{cache_attrs}{: bool, optional
If True (default), user attributes will be cached for attribute read
operations. If False, user attributes are reloaded from the store prior
to all attribute read operations.}

\item{object_codec}{: Codec, optional
A codec to encode object arrays, only needed if dtype=object.}

\item{dimension_separator}{: \code{'.', '/'}, optional
Separator placed between the dimensions of a chunk.}

\item{write_empty_chunks}{: bool, optional
If True (default), all chunks will be stored regardless of their
contents. If False, each chunk is compared to the array's fill value
prior to storing. If a chunk is uniformly equal to the fill value, then
that chunk is not be stored, and the store entry for that chunk's key
is deleted. This setting enables sparser storage, as only chunks with
non-fill-value data are stored, at the expense of overhead associated
with checking the data of each chunk.}

\item{zarr_format}{: int, optional
Zarr format version. Use \code{2L} (default) for Zarr V2 or \code{3L}
for Zarr V3.}
}
\value{
ZarrArray
}
\description{
Open an array using file-mode-like semantics.
}
