TileDB Python API Reference¶

Modules¶

Typical usage of the Python interface to TileDB will use the top-level module tiledb, e.g.

import tiledb

There is also a submodule libtiledb which contains the necessary bindings to the underlying TileDB native library. Most of the time you will not need to interact with tiledb.libtiledb unless you need native-library specific information, e.g. the version number:

import tiledb
tiledb.version()  # TileDB-Py package version number
tiledb.libtiledb.version()  # Native TileDB library version number

Getting Started¶

Arrays may be opened with the tiledb.open function:

tiledb.open(uri, mode='r', key=None, attr=None, config=None, timestamp=None, ctx=None)¶

Open a TileDB array at the given URI

Parameters:

uri – any TileDB supported URI
timestamp – array timestamp to open, int or None. See the TileDB time traveling documentation for detailed functionality description.
key – encryption key, str or None
mode (str) – (default ‘r’) Open the array object in read ‘r’, write ‘w’, modify exclusive ‘m’ mode, or delete ‘d’ mode
attr – attribute name to select from a multi-attribute array, str or None
config – TileDB config dictionary, dict or None

Returns:

open TileDB {Sparse,Dense}Array object

Data import helpers¶

tiledb.from_numpy(uri, array, config=None, ctx=None, **kwargs)¶

Write a NumPy array into a TileDB DenseArray, returning a readonly DenseArray instance.

Parameters:

uri (str) – URI for the TileDB array (any supported TileDB URI)
array (numpy.ndarray) – dense numpy array to persist
config – TileDB config dictionary, dict or None
ctx (tiledb.Ctx) – A TileDB Context
kwargs – additional arguments to pass to the DenseArray constructor

Return type:

tiledb.DenseArray

Returns:

An open DenseArray (read mode) with a single anonymous attribute

Raises:

TypeError – cannot convert uri to unicode string

Raises:

tiledb.TileDBError

Keyword Arguments:

full_domain - Dimensions should be created with full range of the dtype (default: False)
mode - Creation mode, one of ‘ingest’ (default), ‘schema_only’, ‘append’
append_dim - The dimension along which the Numpy array is append (default: 0).
start_idx - The starting index to append to. By default, append to the end of the existing data.
timestamp - Write TileDB array at specific timestamp.
dim_dtype - Dimension data type, default np.uint64
attr_name - Attribute name, default empty string
tile - Tile extent for each dimension, default None

Additionally, arguments accepted by ArraySchema constructor can also be passed to customize the underlying array schema.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     # Creates array 'array' on disk.
...     with tiledb.from_numpy(tmp + "/array",  np.array([1.0, 2.0, 3.0])) as A:
...         pass

tiledb.from_csv(uri: str, csv_file: str | List[str], **kwargs)¶

Create TileDB array at given URI from a CSV file or list of files

Parameters:

uri – URI for new TileDB array
csv_file – input CSV file or list of CSV files. Note: multi-file ingestion requires a chunksize argument. Files will be read in batches of at least chunksize rows before writing to the TileDB array.

Keyword Arguments:

Any pandas.read_csv supported keyword argument
ctx - A TileDB context
sparse - (default True) Create sparse schema
index_dims (List[str]) – List of column name(s) to use as dimension(s) in TileDB array schema. This is the recommended way to create dimensions. (note: the Pandas read_csv argument index_col will be passed through if provided, which results in indexes that will be converted to dimnesions by default; however index_dims is preferred).
allows_duplicates - Generated schema should allow duplicates
mode - Creation mode, one of ‘ingest’ (default), ‘schema_only’, ‘append’
attr_filters - FilterList to apply to Attributes: FilterList or Dict[str -> FilterList] for any attribute(s). Unspecified attributes will use default.
dim_filters - FilterList to apply to Dimensions: FilterList or Dict[str -> FilterList] for any dimensions(s). Unspecified dimensions will use default.
offsets_filters - FilterList to apply to all offsets
full_domain - Dimensions should be created with full range of the dtype
tile - Dimension tiling: accepts either an int that applies the tiling to all dimensions or a dict(“dim_name”: int) to specifically assign tiling to a given dimension
row_start_idx - Start index to start new write (for row-indexed ingestions).
fillna - Value to use to fill holes
column_types - Dictionary of {column_name: dtype} to apply dtypes to columns
varlen_types - A set of {dtypes}; any column wihin the set is converted to a variable length attribute
capacity - Schema capacity.
date_spec - Dictionary of {column_name: format_spec} to apply to date/time columns which are not correctly inferred by pandas ‘parse_dates’. Format must be specified using the Python format codes: https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior
cell_order - (default ‘row-major) Schema cell order: ‘row-major’, ‘col-major’, or ‘hilbert’
tile_order - (default ‘row-major) Schema tile order: ‘row-major’ or ‘col-major’
timestamp - Write TileDB array at specific timestamp.

Returns:

None

Example:

>>> import tiledb
>>> tiledb.from_csv("iris.tldb", "iris.csv")
>>> tiledb.object_type("iris.tldb")
'array'

tiledb.from_pandas(uri, dataframe, **kwargs)¶

Create TileDB array at given URI from a Pandas dataframe

Supports most Pandas series types, including nullable integers and bools.

Parameters:

uri – URI for new TileDB array
dataframe – pandas DataFrame

Keyword Arguments:

Any pandas.read_csv supported keyword argument
ctx - A TileDB context
sparse - (default True) Create sparse schema
chunksize - (default None) Maximum number of rows to read at a time. Note that this is also a pandas.read_csv argument
which tiledb.read_csv checks for in order to correctly read a file batchwise.
index_dims (List[str]) – List of column name(s) to use as dimension(s) in TileDB array schema. This is the recommended way to create dimensions.
allows_duplicates - Generated schema should allow duplicates
mode - Creation mode, one of ‘ingest’ (default), ‘schema_only’, ‘append’
attr_filters - FilterList to apply to Attributes: FilterList or Dict[str -> FilterList] for any attribute(s). Unspecified attributes will use default.
dim_filters - FilterList to apply to Dimensions: FilterList or Dict[str -> FilterList] for any dimensions(s). Unspecified dimensions will use default.
offsets_filters - FilterList to apply to all offsets
full_domain - Dimensions should be created with full range of the dtype
tile - Dimension tiling: accepts either an int that applies the tiling to all dimensions or a dict(“dim_name”: int) to specifically assign tiling to a given dimension
row_start_idx - Start index to start new write (for row-indexed ingestions).
fillna - Value to use to fill holes
column_types - Dictionary of {column_name: dtype} to apply dtypes to columns
varlen_types - A set of {dtypes}; any column wihin the set is converted to a variable length attribute
capacity - Schema capacity.
date_spec - Dictionary of {column_name: format_spec} to apply to date/time columns which are not correctly inferred by pandas ‘parse_dates’. Format must be specified using the Python format codes: https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior
cell_order - (default ‘row-major) Schema cell order: ‘row-major’, ‘col-major’, or ‘hilbert’
tile_order - (default ‘row-major) Schema tile order: ‘row-major’ or ‘col-major’
timestamp - Write TileDB array at specific timestamp.

Raises:

tiledb.TileDBError

Returns:

None

Context¶

class tiledb.Ctx(config: Config = None)¶

Class representing a TileDB context.

A TileDB context wraps a TileDB storage manager.

Parameters:: config (tiledb.Config or dict) – Initialize Ctx with given config parameters

config()¶: Returns the Config instance associated with the Ctx.

get_stats(print_out: bool = True, json: bool = False)¶

Retrieves the stats from a TileDB context.

Parameters:

print_out – Print string to console (default True), or return as string
json – Return stats JSON object (default: False)

set_tag(key: str, value: str)¶: Sets a (string, string) “tag” on the Ctx (internal).

tiledb.default_ctx(config: Config | dict = None) → Ctx¶

Returns, and optionally initializes, the default tiledb.Ctx context variable.

This Ctx object is used by Python API functions when no ctx keyword argument is provided. Most API functions accept an optional ctx kwarg, but that is typically only necessary in advanced usage with multiple contexts per program.

For initialization, this function must be called before any other tiledb functions. The initialization call accepts a tiledb.Config object to override the defaults for process-global parameters.

Parameters:: config – tiledb.Config object or dictionary with config parameters.
Returns:: Ctx

tiledb.scope_ctx(ctx_or_config: Ctx | Config | dict = None) → Ctx¶

Context manager for setting the default tiledb.Ctx context variable when entering a block of code and restoring it to its previous value when exiting the block.

Parameters:: ctx_or_config – tiledb.Ctx or tiledb.Config object or dictionary with config parameters.
Returns:: Ctx

Config¶

class tiledb.Config(params: dict = None, path: str = None)¶

TileDB Config class

The Config object stores configuration parameters for both TileDB Embedded and TileDB-Py.

For TileDB Embedded parameters, see:

https://docs.tiledb.com/main/how-to/configuration#configuration-parameters

The following configuration options are supported by TileDB-Py:

py.init_buffer_bytes:

Initial allocation size in bytes for attribute and dimensions buffers. If result size exceed the pre-allocated buffer(s), then the query will return incomplete and TileDB-Py will allocate larger buffers and resubmit. Specifying a sufficiently large buffer size will often improve performance. Default 10 MB (1024**2 * 10).

py.use_arrow:

Use pyarrow from the Apache Arrow project to convert query results into Pandas dataframe format when requested. Default True.

py.deduplicate:

Attempt to deduplicate Python objects during buffer conversion to Python. Deduplication may reduce memory usage for datasets with many identical strings, at the cost of some performance reduction due to hash calculation/lookup for each object.

Unknown parameters will be ignored!

Parameters:

params (dict) – Set parameter values from dict like object
path (str) – Set parameter values from persisted Config parameter file

clear()¶: Unsets all Config parameters (returns them to their default values)

dict(prefix: str = '')¶

Returns a dict representation of a Config object

Parameters:: prefix (str) – return only parameters with a given prefix
Return type:: dict
Returns:: Config parameter / values as a Python dict

from_file(path: str)¶

Update a Config object with from a persisted config file

Parameters:: path – A local Config file path

get(self: tiledb.libtiledb.Config, arg0: str) → str¶

items(prefix: str = '')¶

Returns an iterator object over Config parameters, values

Parameters:: prefix (str) – return only parameters with a given prefix
Return type:: ConfigItems
Returns:: iterator over Config parameter, value tuples

keys(prefix: str = '')¶

Returns an iterator object over Config parameters (keys)

Parameters:: prefix (str) – return only parameters with a given prefix
Return type:: ConfigKeys
Returns:: iterator over Config parameter string keys

static load(uri: str)¶

Constructs a Config class instance from config parameters loaded from a local Config file

Parameters:: uri (str) – a local URI config file path
Return type:: tiledb.Config
Returns:: A TileDB Config instance with persisted parameter values
Raises:: TypeError – uri cannot be converted to a unicode string
Raises:: tiledb.TileDBError

save(uri: str)¶

Persist Config parameter values to a config file

Parameters:: uri (str) – a local URI config file path
Raises:: TypeError – uri cannot be converted to a unicode string
Raises:: tiledb.TileDBError

update(odict: dict)¶

Update a config object with parameter, values from a dict like object

Parameters:: odict – dict-like object containing parameter, values to update Config.

values(prefix: str = '')¶

Returns an iterator object over Config values

Parameters:: prefix (str) – return only parameters with a given prefix
Return type:: ConfigValues
Returns:: iterator over Config string values

Current Domain¶

class tiledb.CurrentDomain(ctx: Ctx)¶

Represents a TileDB current domain.

property is_empty¶

Checks if the current domain is empty.

Return type:: bool

property ndrectangle¶

Gets the N-dimensional rectangle associated with the current domain object.

Return type:: NDRectangle
Raises:: tiledb.TileDBError –

set_ndrectangle(ndrect: NDRectangle)¶

Sets an N-dimensional rectangle representation on a current domain.

Parameters:: ndrect – The N-dimensional rectangle to be used.
Raises:: tiledb.TileDBError –

property type¶

The type of the current domain.

Return type:: tiledb.CurrentDomainType

NDRectangle¶

class tiledb.NDRectangle(ctx: Ctx, domain: Domain)¶

Represents a TileDB N-Dimensional Rectangle.

range(dim: str | int) → Tuple[int, int] | Tuple[float, float] | Tuple[str, str]¶

Gets the range for the given dimension.

Parameters:: dim – Dimension name or index
Returns:: Range as a tuple (start, end)
Raises:: tiledb.TileDBError –

Sets a range for the given dimension.

Parameters:

dim – Dimension name or index
start – Range start value
end – Range end value

Raises:

tiledb.TileDBError –

Array Schema¶

class tiledb.ArraySchema(domain: Domain = None, attrs: Sequence[Attr] = (), cell_order: str = 'row-major', tile_order: str = 'row-major', capacity: int = 0, coords_filters: FilterList | Sequence[Filter] = None, offsets_filters: FilterList | Sequence[Filter] = None, validity_filters: FilterList | Sequence[Filter] = None, allows_duplicates: bool = False, sparse: bool = False, dim_labels={}, enums=None, ctx: Ctx = None)¶

Schema class for TileDB dense / sparse array representations

Parameters:

domain – Domain of schema
attrs – tuple of attributes
cell_order – TileDB label for cell layout
tile_order – TileDB label for tile layout
capacity (int) – tile cell capacity
offsets_filters – (default None) offsets filter list
validity_filters – (default None) validity filter list
allows_duplicates (bool) – True if duplicates are allowed
sparse (bool) – True if schema is sparse, else False (set by SparseArray and DenseArray derived classes)
dim_labels – dict(dim_index, dict(dim_name, tiledb.DimSchema))
enums – list of enumeration names
ctx (tiledb.Ctx) – A TileDB Context

Raises:

tiledb.TileDBError

property allows_duplicates: bool¶: Returns True if the (sparse) array allows duplicates.

attr(key: str | int) → Attr¶

Returns an Attr instance given an int index or string label

Parameters:: key (int or str) – attribute index (positional or associative)
Return type:: tiledb.Attr
Returns:: The ArraySchema attribute at index or with the given name (label)
Raises:: TypeError – invalid key type

property attr_names: List[str]¶

Returns a list of attribute names

Return type:: list

property capacity: int¶

The array capacity

Return type:: int
Raises:: tiledb.TileDBError

property cell_order: str¶

The cell order layout of the array.

Return type:: str

check() → bool¶

Checks the correctness of the array schema

Return type:: None
Raises:: tiledb.TileDBError if invalid

property coords_filters: FilterList¶

The FilterList for the array’s coordinates

Return type:: tiledb.FilterList
Raises:: tiledb.TileDBError

property ctx: Ctx¶

The array schema’s context

Return type:: tiledb.Ctx

property current_domain: CurrentDomain¶

Get the current domain

Return type:: tiledb.CurrentDomain

dim_label(name: str) → DimLabel¶

Returns a TileDB DimensionLabel given the label name

Parameters:: name – name of the dimensin label
Returns:: The dimension label associated with the given name

property domain: Domain¶

The Domain associated with the array.

Return type:: tiledb.Domain
Raises:: tiledb.TileDBError

dump()¶: Dumps a string representation of the array object to standard output (stdout)

classmethod from_file(uri: str = None, ctx: Ctx = None)¶: Create an ArraySchema for a Filestore Array from a given file. If a uri is not given, then create a default schema.

has_attr(name: str) → bool¶

Returns true if the given name is an Attribute of the ArraySchema

Parameters:: name – attribute name
Return type:: boolean

has_dim_label(name: str) → bool¶

Returns true if the given name is a DimensionLabel of the ArraySchema

Note: If using an version of libtiledb that does not support dimension labels this will return false.

Parameters:: name – dimension label name
Return type:: boolean

property nattr: int¶

The number of array attributes.

Return type:: int
Raises:: tiledb.TileDBError

property ndim: int¶

The number of array domain dimensions.

Return type:: int

property offsets_filters: FilterList¶

The FilterList for the array’s variable-length attribute offsets

Return type:: tiledb.FilterList
Raises:: tiledb.TileDBError

set_current_domain(current_domain)¶

Set the current domain

Parameters:: current_domain (tiledb.CurrentDomain) – The current domain to set

property shape: Tuple[dtype, dtype]¶

The array’s shape

Return type:: tuple(numpy scalar, numpy scalar)
Raises:: TypeError – floating point (inexact) domain

property sparse: bool¶

True if the array is a sparse array representation

Return type:: bool
Raises:: tiledb.TileDBError

property tile_order: str¶

The tile order layout of the array.

Return type:: str
Raises:: tiledb.TileDBError

property validity_filters: FilterList¶

The FilterList for the array’s validity

Return type:: tiledb.FilterList
Raises:: tiledb.TileDBError

property version: int¶

The array’s schema (storage) version.

Return type:: int
Raises:: tiledb.TileDBError

tiledb.empty_like(uri, arr, config=None, key=None, tile=None, ctx=None, dtype=None)¶

Create and return an empty, writeable DenseArray with schema based on a NumPy-array like object.

Parameters:

uri – array URI
arr – NumPy ndarray, or shape tuple
config – (optional, deprecated) configuration to apply to new Ctx
key – (optional) encryption key, if applicable
tile – (optional) tiling of generated array
ctx – (optional) TileDB Ctx
dtype – (optional) required if arr is a shape tuple

Returns:

Attribute¶

class tiledb.Attr(name: str = '', dtype: ~numpy.dtype = <class 'numpy.float64'>, fill: ~typing.Any = None, var: bool = None, nullable: bool = False, filters: ~tiledb.filter.FilterList | ~typing.Sequence[~tiledb.filter.Filter] = None, enum_label: str = None, ctx: ~tiledb.ctx.Ctx | None = None)¶

Represents a TileDB attribute.

property dtype: dtype¶

Return numpy dtype object representing the Attr type

Return type:: numpy.dtype

dump()¶: Dumps a string representation of the Attr object to standard output (stdout)

property fill: Any¶

Fill value for unset cells of this attribute

Return type:: depends on dtype
Raises:: tiledb.TileDBERror

property filters: FilterList¶

FilterList of the TileDB attribute

Return type:: tiledb.FilterList
Raises:: tiledb.TileDBError

property isanon: bool¶

True if attribute is an anonymous attribute

Return type:: bool

property isascii: bool¶

True if the attribute is TileDB dtype TILEDB_STRING_ASCII

Return type:: bool
Raises:: tiledb.TileDBError

property isnullable: bool¶

True if the attribute is nullable

Return type:: bool
Raises:: tiledb.TileDBError

property isvar: bool¶

True if the attribute is variable length

Return type:: bool
Raises:: tiledb.TileDBError

property name: str¶

Attribute string name, empty string if the attribute is anonymous

Return type:: str
Raises:: tiledb.TileDBError

property ncells: int¶

The number of cells (scalar values) for a given attribute value

Return type:: int
Raises:: tiledb.TileDBError

Filters¶

class tiledb.FilterList(filters: Sequence[Filter] = None, chunksize: int = None, ctx: Ctx | None = None)¶

An ordered list of Filter objects for filtering TileDB data.

FilterLists contain zero or more Filters, used for filtering attribute data, the array coordinate data, etc.

Parameters:

ctx (tiledb.Ctx) – A TileDB context
filters – An iterable of Filter objects to add.
chunksize (int) – (default None) chunk size used by the filter list in bytes

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     # Create several filters
...     gzip_filter = tiledb.GzipFilter()
...     bw_filter = tiledb.BitWidthReductionFilter()
...     # Create a filter list that will first perform bit width reduction, then gzip compression.
...     filters = tiledb.FilterList([bw_filter, gzip_filter])
...     a1 = tiledb.Attr(name="a1", dtype=np.int64, filters=filters)
...     # Create a second attribute filtered only by gzip compression.
...     a2 = tiledb.Attr(name="a2", dtype=np.int64,
...                      filters=tiledb.FilterList([gzip_filter]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1, a2))
...     tiledb.DenseArray.create(tmp + "/array", schema)

__getitem__(idx: int) → Filter¶

__getitem__(idx: slice) → List[Filter]

Gets a copy of the filter in the list at the given index

Parameters:: idx (int or slice) – index into the
Returns:: A filter at given index / slice
Raises:: IndexError – invalid index
Raises:: tiledb.TileDBError

__len__() → int¶

Return type:: int
Returns:: Number of filters in the FilterList

append(filter: Filter)¶

Parameters:: filter (Filter) – the filter to append into the FilterList
Raises:: ValueError – filter argument incorrect type

class tiledb.CompressionFilter(type: FilterType, level: int = -1, ctx: Ctx | None = None)¶

Base class for filters performing compression.

All compression filters support a compression level option, although some (such as RLE) ignore it.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.CompressionFilter(level=10)]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.GzipFilter(level: int = -1, ctx: Ctx | None = None)¶

Filter that compresses using gzip.

Parameters:

ctx (tiledb.Ctx) – TileDB Ctx
level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.GzipFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.ZstdFilter(level: int = -1, ctx: Ctx | None = None)¶

Filter that compresses using zstd.

Parameters:

ctx (tiledb.Ctx) – TileDB Ctx
level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.ZstdFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.LZ4Filter(level: int = -1, ctx: Ctx | None = None)¶

Filter that compresses using lz4.

Parameters:

ctx (tiledb.Ctx) – TileDB Ctx
level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.LZ4Filter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.Bzip2Filter(level: int = -1, ctx: Ctx | None = None)¶

Filter that compresses using bzip2.

Parameters:: level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.Bzip2Filter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.RleFilter(level: int = -1, ctx: Ctx | None = None)¶

Filter that compresses using run-length encoding (RLE).

Parameters:: level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.RleFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.DeltaFilter(level: int = -1, reinterp_dtype: dtype | DataType | None = None, ctx: Ctx | None = None)¶

Filter that compresses using run-length encoding (RLE).

Parameters:

level – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.
reinterp_dtype – (optional) sets the compressor to compress the data treating as the new datatype.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.DeltaFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.DoubleDeltaFilter(level: int = -1, reinterp_dtype: dtype | DataType | None = None, ctx: Ctx | None = None)¶

Filter that performs double-delta encoding.

Parameters:

level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.
reinterp_dtype – (optional) sets the compressor to compress the data treating as the new datatype.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.DoubleDeltaFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.DictionaryFilter(level: int = -1, ctx: Ctx | None = None)¶

Filter that performs dictionary encoding.

Parameters:: level (int) – -1 (default) sets the compressor level to the default level as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.DictionaryFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.BitShuffleFilter(ctx: Ctx | None = None)¶

Filter that performs a bit shuffle transformation.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.BitShuffleFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.ByteShuffleFilter(ctx: Ctx | None = None)¶

Filter that performs a byte shuffle transformation.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.ByteShuffleFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.BitWidthReductionFilter(window: int = -1, ctx: Ctx | None = None)¶

Filter that performs bit-width reduction.

param ctx:

A TileDB Context

type ctx:

tiledb.Ctx

param window:

-1 (default) sets the max window size for the filter to the default window size as specified in TileDB core. Otherwise, sets the compressor level to the given value.

type window:

int

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.BitWidthReductionFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.PositiveDeltaFilter(window: int = -1, ctx: Ctx | None = None)¶

Filter that performs positive-delta encoding.

Parameters:

ctx (tiledb.Ctx) – A TileDB Context
window (int) – -1 (default) sets the max window size for the filter to the default window size as specified in TileDB core. Otherwise, sets the compressor level to the given value.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.PositiveDeltaFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.ChecksumMD5Filter(ctx: Ctx | None = None)¶

MD5 checksum filter.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.ChecksumMD5Filter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.ChecksumSHA256Filter(ctx: Ctx | None = None)¶

SHA256 checksum filter.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.ChecksumSHA256Filter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.FloatScaleFilter(factor: float = None, offset: float = None, bytewidth: int = None, ctx: Ctx | None = None)¶: Filter that stores floats as integers in a reduced representation via scaling. The reduced storage space is in lieu of some precision loss. The float scaling filter takes three parameters: the factor, the offset, and the bytewidth. On write, the float scaling filter applies the factor (scaling factor) and offset, and stores the value of round((raw_float - offset) / factor) as an integer with the specified NumPy dtype. On read, the float scaling filter will reverse the factor and offset, and returns the floating point data, with a potential loss of precision. :param factor: the scaling factor used to translate the data :type factor: float :param offset: the offset value used to translate the data :type offset: float :param bytewidth: values may be stored as integers of bytewidth 1, 2, 4, or 8 :type np.integer: :param ctx: A TileDB Context :type ctx: tiledb.Ctx Example: >>> import tiledb, numpy as np, tempfile >>> with tempfile.TemporaryDirectory() as tmp: … dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64)) … a1 = tiledb.Attr(name=”a1”, dtype=np.int64, … filters=tiledb.FilterList([tiledb.FloatScaleFilter(1, 0)])) … schema = tiledb.ArraySchema(domain=dom, attrs=(a1,)) … tiledb.DenseArray.create(tmp + “/array”, schema)

class tiledb.XORFilter(ctx: Ctx | None = None)¶

XOR filter.

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     a1 = tiledb.Attr(name="a1", dtype=np.int64,
...                      filters=tiledb.FilterList([tiledb.XORFilter()]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(a1,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class tiledb.WebpFilter(input_format: WebpInputFormat = None, quality: float = None, lossless: bool = None, ctx: Ctx | None = None)¶

The WebP filter provides three options: quality, format, and lossless

The quality option is used as quality_factor setting for WebP lossy compression and expects a float value in the range of 0.0f - 100.0f Quality of 0 corresponds to low quality and small output sizes, whereas 100 is the highest quality and largest output size.

The format option is used to define colorspace format of image data and expects an enum of TILEDB_WEBP_RGB, TILEDB_WEBP_BGR, TILEDB_WEBP_RGBA, or TILEDB_WEBP_BGRA.

The lossless option is used to enable(1) or disable(0) lossless compression. With this option enabled, the quality setting will be ignored.

On write this filter takes raw colorspace values (RGB, RBGA, etc) and encodes into WebP format before writing data to the array.

On read, this filter decodes WebP data and returns raw colorspace values to the caller.

This filter expects the array to provide two dimensions for Y, X pixel position. Dimensions may be defined with any name, but Y, X should be at dimension index 0, 1 respectively. Dimensions can be any two matching integral types, such as {uint64_t, uint64_t} or {int64_t, int64_t}.

The WebP filter supports only the uint8_t type for attributes.

Parameters:

quality (float in range [0.0, 100.0]) – quality_factor setting for lossy WebP compression
input_format (np.uint8 corresponding to one of TILEDB_WEBP_{RGB, BGR, RGBA, BGRA}) – The input colorspace format of the image
lossless (np.uint8) – Enable (1) or disable (0) lossless image compression
ctx (tiledb.Ctx) – A TileDB Context

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     # Using RGB colorspace format
...     pixel_depth = 3  # For RGBA / BGRA pixel_depth is 4
...     dims = (tiledb.Dim(name='Y',
...                    domain=(1, img_height),
...                    dtype=np.uint8,
...                    tile=img_height / 2,),
...             tiledb.Dim(name='X',
...                    domain=(1, img_width * pixel_depth),
...                    dtype=np.uint8,
...                    tile=(img_width / 2) * pixel_depth,))
...     dom = tiledb.Domain(*dims)
...     rgb = tiledb.Attr(name="rgb", dtype=np.uint8,
...                      filters=tiledb.FilterList([tiledb.WebpFilter(input_format=1, quality=100.0, lossless=1)]))
...     schema = tiledb.ArraySchema(domain=dom, attrs=(rgb,))
...     tiledb.DenseArray.create(tmp + "/array", schema)

class WebpInputFormat¶

Members:

WEBP_NONE

WEBP_RGB

WEBP_RGBA

WEBP_BGR

WEBP_BGRA

property name¶

Dimension¶

class tiledb.Dim(name: str = '__dim_0', domain: ~typing.Tuple[~typing.Any, ~typing.Any] = None, tile: ~typing.Any = None, filters: ~tiledb.filter.FilterList | ~typing.Sequence[~tiledb.filter.Filter] = None, dtype: ~numpy.dtype = <class 'numpy.uint64'>, var: bool = None, ctx: ~tiledb.ctx.Ctx | None = None)¶

Represents a TileDB dimension.

create_label_schema(order: str = 'increasing', dtype: ~numpy.dtype = <class 'numpy.uint64'>, tile: ~typing.Any = None, filters: ~tiledb.filter.FilterList | ~typing.Sequence[~tiledb.filter.Filter] = None)¶

Creates a dimension label schema for a dimension label on this dimension

Parameters:

order – Order or sort of the label data (‘increasing’ or ‘decreasing’).
dtype – Datatype of the label data.
tile – Tile extent for the dimension of the dimension label. If None, it will use the tile extent of this dimension.
label_filters – Filter list for the attribute storing the label data.

Return type:

DimLabelSchema

property domain: Tuple[generic, generic]¶

The dimension (inclusive) domain.

The dimension’s domain is defined by a (lower bound, upper bound) tuple.

Return type:: tuple(numpy scalar, numpy scalar)

property dtype: dtype¶

Numpy dtype representation of the dimension type.

Return type:: numpy.dtype

property filters: FilterList¶

FilterList of the TileDB dimension

Return type:: tiledb.FilterList
Raises:: tiledb.TileDBError

property isanon: bool¶

True if the dimension is anonymous

Return type:: bool

property isvar: bool¶

True if the dimension is variable length

Return type:: bool
Raises:: tiledb.TileDBError

property name: str¶

The dimension label string.

Anonymous dimensions return a default string representation based on the dimension index.

Return type:: str

property shape: Tuple[generic, generic]¶

The shape of the dimension given the dimension’s domain.

Note: The shape is only valid for integer and datetime dimension domains.

Return type:: tuple(numpy scalar, numpy scalar)
Raises:: TypeError – floating point (inexact) domain

property size: int¶

The size of the dimension domain (number of cells along dimension).

Return type:: int
Raises:: TypeError – floating point (inexact) domain

property tile: generic¶

The tile extent of the dimension.

Return type:: numpy scalar or np.timedelta64

Domain¶

class tiledb.Domain(*dims: Dim, ctx: Ctx | None = None)¶

Represents a TileDB domain.

dim(dim_id)¶

Returns a Dim object from the domain given the dimension’s index or name.

Parameters:: dim_d – dimension index (int) or name (str)
Raises:: tiledb.TileDBError

property dtype¶

The numpy dtype of the domain’s dimension type.

Return type:: numpy.dtype

dump()¶: Dumps a string representation of the domain object to standard output (STDOUT)

has_dim(name)¶

Returns true if the Domain has a Dimension with the given name

Parameters:: name – name of Dimension
Return type:: bool
Returns:

property homogeneous¶: Returns True if the domain’s dimension types are homogeneous.

property ndim¶

The number of dimensions of the domain.

Return type:: int

property shape¶

The domain’s shape, valid only for integer domains.

Return type:: tuple
Raises:: TypeError – floating point (inexact) domain

property size¶

The domain’s size (number of cells), valid only for integer domains.

Return type:: int
Raises:: TypeError – floating point (inexact) domain

Array¶

class tiledb.Array(uri, mode='r', key=None, timestamp=None, attr=None, ctx=None, **kwargs)¶

Base class for TileDB array objects.

Defines common properties/functionality for the different array types. When an Array instance is initialized, the array is opened with the specified mode.

Parameters:

uri (str) – URI of array to open
mode (str) – (default ‘r’) Open the array object in read ‘r’, write ‘w’, modify exclusive ‘m’, or delete ‘d’ mode
key (str) – (default None) If not None, encryption key to decrypt the array
timestamp (tuple) – (default None) If int, open the array at a given TileDB timestamp. If tuple, open at the given start and end TileDB timestamps.
attr (str) – (default None) open one attribute of the array; indexing a dense array will return a Numpy ndarray directly rather than a dictionary.
ctx (Ctx) – TileDB context

attr(key)¶

Returns an Attr instance given an int index or string label

Parameters:: key (int or str) – attribute index (positional or associative)
Return type:: Attr
Returns:: The array attribute at index or with the given name (label)
Raises:: TypeError – invalid key type

property attr_names¶: Returns a list of attribute names

close()¶: Closes this array, flushing all buffered data.

consolidate(config=None, key=None, fragment_uris=None, timestamp=None)¶

Consolidates fragments of an array object for increased read performance.

Overview: https://docs.tiledb.com/main/concepts/internal-mechanics/consolidation

Parameters:

config (tiledb.Config) – The TileDB Config with consolidation parameters set
key (str or bytes) – (default None) encryption key to decrypt an encrypted array
fragment_uris – (default None) Consolidate the array using a list of fragment _names_ (note: the __ts1_ts2_<label>_<ver> fragment name form alone, not the full path(s))
timestamp (tuple (int, int)) – (default None) If not None, consolidate the array using the given tuple(int, int) UNIX seconds range (inclusive). This argument will be ignored if fragment_uris is passed.

Raises:

tiledb.TileDBError

Rather than passing the timestamp into this function, it may be set with the config parameters “sm.vacuum.timestamp_start”`and `”sm.vacuum.timestamp_end” which takes in a time in UNIX seconds. If both are set then this function’s timestamp argument will be used.

classmethod create(uri, schema, key=None, overwrite=False, ctx=None)¶

Creates a TileDB Array at the given URI

Parameters:

uri (str) – URI at which to create the new empty array.
schema (ArraySchema) – Schema for the array
key (str) – (default None) Encryption key to use for array
overwrite (bool) – (default False) Overwrite the array if it already exists
ctx (Ctx) – (default None) Optional TileDB Ctx used when creating the array, by default uses the ArraySchema’s associated context (not necessarily tiledb.default_ctx).

static delete_array(uri, ctx=None)¶

Delete the given array.

Parameters:

uri (str) – The URI of the array
ctx (Ctx) – TileDB context

Example:

>>> import tiledb, tempfile, numpy as np
>>> path = tempfile.mkdtemp()

>>> with tiledb.from_numpy(path, np.zeros(4), timestamp=1) as A:
...     pass
>>> tiledb.array_exists(path)
True

>>> tiledb.Array.delete_array(path)

>>> tiledb.array_exists(path)
False

static delete_fragments(uri, timestamp_start, timestamp_end, ctx=None)¶

Delete a range of fragments from timestamp_start to timestamp_end. The array needs to be opened in ‘m’ mode as shown in the example below.

Parameters:

timestamp_start (int) – the first fragment to delete in the range
timestamp_end (int) – the last fragment to delete in the range

Example:

>>> import tiledb, tempfile, numpy as np
>>> path = tempfile.mkdtemp()

>>> with tiledb.open(path, 'w', timestamp=2) as A:
...     A[:] = np.ones(4, dtype=np.int64)

>>> with tiledb.open(path, 'r') as A:
...     A[:]
array([1., 1., 1., 1.])

>>> tiledb.Array.delete_fragments(path, 2, 2)

>>> with tiledb.open(path, 'r') as A:
...     A[:]
array([0., 0., 0., 0.])

property df¶

Retrieve data cells as a Pandas dataframe, with multi-range, domain-inclusive indexing using multi_index.

Parameters:: selection (list) – Per dimension, a scalar, slice, or a list/numpy array/pyarrow array of scalars or slice objects. Scalars and slice components should match the type of the underlying Dimension.
Returns:: dict of {‘attribute’: result}. Coords are included by default for Sparse arrays only (use Array.query(coords=<>) to select).
Raises:: IndexError – invalid or unsupported index selection
Raises:: tiledb.TileDBError

df[] accepts, for each dimension, a scalar, slice, or list of scalars or slice objects. Each item is interpreted as a point (scalar) or range (slice) used to query the array on the corresponding dimension.

** Example **

>>> import tiledb, tempfile, numpy as np, pandas as pd
>>>
>>> with tempfile.TemporaryDirectory() as tmp:
...    data = {'col1_f': np.arange(0.0,1.0,step=0.1), 'col2_int': np.arange(10)}
...    df = pd.DataFrame.from_dict(data)
...    tiledb.from_pandas(tmp, df)
...    A = tiledb.open(tmp)
...    A.df[1]
...    A.df[1:5]
      col1_f  col2_int
   1     0.1         1
      col1_f  col2_int
   1     0.1         1
   2     0.2         2
   3     0.3         3
   4     0.4         4
   5     0.5         5

dim(dim_id)¶

Returns a Dim instance given a dim index or name

Parameters:: key (int or str) – attribute index (positional or associative)
Return type:: Attr
Returns:: The array attribute at index or with the given name (label)
Raises:: TypeError – invalid key type

property domain¶: The Domain of this array.

property dtype¶: The NumPy dtype of the specified attribute

enum(name)¶

Return the Enumeration from the attribute name.

Parameters:: name – attribute name
Return type:: Enumeration

property isopen¶: True if this array is currently open.

property iswritable¶: This array is currently opened as writable.

label_index(labels)¶

Retrieve data cells with multi-range, domain-inclusive indexing by label. Returns the cross-product of the ranges.

Accepts a scalar, slice, or list of scalars per-label for querying on the corresponding dimensions. For multidimensional arrays querying by labels only on a subset of dimensions, : should be passed in-place for any labels preceeding custom ranges.

** Example **

>>> import tiledb, numpy as np, tempfile
>>> from collections import OrderedDict
>>> dim1 = tiledb.Dim("d1", domain=(1, 4))
>>> dim2 = tiledb.Dim("d2", domain=(1, 3))
>>> dom = tiledb.Domain(dim1, dim2)
>>> att = tiledb.Attr("a1", dtype=np.int64)
>>> dim_labels = {
...     0: {"l1": dim1.create_label_schema("decreasing", np.int64)},
...     1: {
...         "l2": dim2.create_label_schema("increasing", np.int64),
...         "l3": dim2.create_label_schema("increasing", np.float64),
...     },
... }
>>> schema = tiledb.ArraySchema(domain=dom, attrs=(att,), dim_labels=dim_labels)
>>> with tempfile.TemporaryDirectory() as tmp:
...     tiledb.Array.create(tmp, schema)
...
...     a1_data = np.reshape(np.arange(1, 13), (4, 3))
...     l1_data = np.arange(4, 0, -1)
...     l2_data = np.arange(-1, 2)
...     l3_data = np.linspace(0, 1.0, 3)
...
...     with tiledb.open(tmp, "w") as A:
...         A[:] = {"a1": a1_data, "l1": l1_data, "l2": l2_data, "l3": l3_data}
...
...     with tiledb.open(tmp, "r") as A:
...         np.testing.assert_equal(
...             A.label_index(["l1"])[3:4],
...             OrderedDict({"l1": [4, 3], "a1": [[1, 2, 3], [4, 5, 6]]}),
...         )
...         np.testing.assert_equal(
...             A.label_index(["l1", "l3"])[2, 0.5:1.0],
...             OrderedDict(
...                 {"l3": [0.5, 1.0], "l1": [2], "a1": [[8, 9]]}
...             ),
...         )
...         np.testing.assert_equal(
...             A.label_index(["l2"])[:, -1:0],
...             OrderedDict(
...                 {"l2": [-1, 0],
...                 "a1": [[1, 2], [4, 5], [7, 8], [10, 11]]},
...             ),
...         )
...         np.testing.assert_equal(
...             A.label_index(["l3"])[:, 0.5:1.0],
...             OrderedDict(
...                 {"l3": [0.5, 1.],
...                 "a1": [[2, 3], [5, 6], [8, 9], [11, 12]]},
...             ),
...         )

Parameters:

labels – List of labels to use when querying. Can only use at most one label per dimension.
selection (list) – Per dimension, a scalar, slice, or list of scalars. Each item is iterpreted as a point (scalar) or range (slice) used to query the array on the corresponding dimension.

Returns:

dict of {‘label/attribute’: result}.

Raises:

tiledb.TileDBError

classmethod load_typed(uri, mode='r', key=None, timestamp=None, attr=None, ctx=None)¶: Return a {Dense,Sparse}Array instance from a pre-opened Array (internal)

property meta: Metadata¶

The Array’s metadata as a key-value structure :rtype: Metadata

Type:: return

property mode¶: The mode this array was opened with.

property multi_index¶

Retrieve data cells with multi-range, domain-inclusive indexing. Returns the cross-product of the ranges.

Parameters:: selection (list) – Per dimension, a scalar, slice, or a list/numpy array/pyarrow array of scalars or slice objects. Scalars and slice components should match the type of the underlying Dimension.
Returns:: dict of {‘attribute’: result}. Coords are included by default for Sparse arrays only (use Array.query(coords=<>) to select).
Raises:: IndexError – invalid or unsupported index selection
Raises:: tiledb.TileDBError

multi_index[] accepts, for each dimension, a scalar, slice, or list of scalars or slice objects. Each item is interpreted as a point (scalar) or range (slice) used to query the array on the corresponding dimension.

Unlike NumPy array indexing, multi_index respects TileDB’s range semantics: slice ranges are inclusive of the start- and end-point, and negative ranges do not wrap around (because a TileDB dimensions may have a negative domain).

** Example **

>>> import tiledb, tempfile, numpy as np
>>>
>>> with tempfile.TemporaryDirectory() as tmp:
...    A = tiledb.from_numpy(tmp, np.eye(4) * [1,2,3,4])
...    A.multi_index[1]  
...    A.multi_index[1,1]  
...    # return row 0 and 2
...    A.multi_index[[0,2]]  
...    # return rows 0 and 2 intersecting column 2
...    A.multi_index[[0,2], 2]  
...    # return rows 0:2 intersecting columns 0:2
...    A.multi_index[slice(0,2), slice(0,2)]  
OrderedDict(...''... array([[0., 2., 0., 0.]])...)
OrderedDict(...''... array([[2.]])...)
OrderedDict(...''... array([[1., 0., 0., 0.],
        [0., 0., 3., 0.]])...)
OrderedDict(...''... array([[0.],
        [3.]])...)
OrderedDict(...''... array([[1., 0., 0.],
        [0., 2., 0.],
        [0., 0., 3.]])...)

property nattr¶: The number of attributes of this array.

property ndim¶: The number of dimensions of this array.

nonempty_domain()¶

Return the minimum bounding domain which encompasses nonempty values.

Return type:: tuple(tuple(numpy scalar, numpy scalar), …)
Returns:: A list of (inclusive) domain extent tuples, that contain all nonempty cells

property ptr¶: Return the underlying C++ TileDB array object pointer

reopen()¶

Reopens this array.

This is useful when the array is updated after it was opened. To sync-up with the updates, the user must either close the array and open again, or just use reopen() without closing. reopen will be generally faster than a close-then-open.

property schema¶: The ArraySchema for this array.

property shape¶: The shape of this array.

property timestamp_range¶

Returns the timestamp range the array is opened at

Return type:: tuple
Returns:: tiledb timestamp range at which point the array was opened

upgrade_version(config=None)¶

Upgrades an array to the latest format version.

Parameters:: config – (default None) Configuration parameters for the upgrade (nullptr means default, which will use the config from ctx).
Raises:: tiledb.TileDBError

view_attr()¶: The view attribute of this array.

tiledb.consolidate(uri, config=None, ctx=None, fragment_uris=None, timestamp=None)¶

Consolidates TileDB array fragments for improved read performance

Parameters:

uri (str) – URI to the TileDB Array
key (str) – (default None) Key to decrypt array if the array is encrypted
config (tiledb.Config) – The TileDB Config with consolidation parameters set
ctx (tiledb.Ctx) – (default None) The TileDB Context
fragment_uris – (default None) Consolidate the array using a list of fragment file names
timestamp – (default None) If not None, consolidate the array using the given tuple(int, int) UNIX seconds range (inclusive). This argument will be ignored if fragment_uris is passed.

Return type:

str or bytes

Returns:

path (URI) to the consolidated TileDB Array

Raises:

TypeError – cannot convert path to unicode string

Raises:

tiledb.TileDBError

Rather than passing the timestamp into this function, it may be set with the config parameters “sm.vacuum.timestamp_start”`and `”sm.vacuum.timestamp_end” which takes in a time in UNIX seconds. If both are set then this function’s timestamp argument will be used.

Example:

>>> import tiledb, tempfile, numpy as np, os
>>> path = tempfile.mkdtemp()

>>> with tiledb.from_numpy(path, np.zeros(4), timestamp=1) as A:
...     pass
>>> with tiledb.open(path, 'w', timestamp=2) as A:
...     A[:] = np.ones(4, dtype=np.int64)
>>> with tiledb.open(path, 'w', timestamp=3) as A:
...     A[:] = np.ones(4, dtype=np.int64)
>>> with tiledb.open(path, 'w', timestamp=4) as A:
...     A[:] = np.ones(4, dtype=np.int64)
>>> len(tiledb.array_fragments(path))
4

>>> fragment_names = [
...     os.path.basename(f) for f in tiledb.array_fragments(path).uri
... ]
>>> array_uri = tiledb.consolidate(
...    path, fragment_uris=[fragment_names[1], fragment_names[3]]
... )
>>> len(tiledb.array_fragments(path))
3

tiledb.vacuum(uri, config=None, ctx=None, timestamp=None)¶

Vacuum underlying array fragments after consolidation.

Parameters:

uri (str) – URI of array to be vacuumed
config – Override the context configuration for vacuuming. Defaults to None, inheriting the context parameters.
(ctx – tiledb.Ctx, optional): Context. Defaults to tiledb.default_ctx().

Raises:

TypeError – cannot convert uri to unicode string

Raises:

tiledb.TileDBError

This operation of this function is controlled by the “sm.vacuum.mode” parameter, which accepts the values fragments, fragment_meta, array_meta, and commits. Rather than passing the timestamp into this function, it may be set by using “sm.vacuum.timestamp_start”`and `”sm.vacuum.timestamp_end” which takes in a time in UNIX seconds. If both are set then this function’s timestamp argument will be used.

Example:

>>> import tiledb, numpy as np
>>> import tempfile
>>> path = tempfile.mkdtemp()
>>> with tiledb.from_numpy(path, np.random.rand(4)) as A:
...     pass # make sure to close
>>> with tiledb.open(path, 'w') as A:
...     for i in range(4):
...         A[:] = np.ones(4, dtype=np.int64) * i
>>> paths = tiledb.VFS().ls(path)
>>> # should be 12 (2 base files + 2*5 fragment+ok files)
>>> (); len(paths); () 
(...)
>>> () ; tiledb.consolidate(path) ; () 
(...)
>>> tiledb.vacuum(path)
>>> paths = tiledb.VFS().ls(path)
>>> # should now be 4 ( base files + 2 fragment+ok files)
>>> (); len(paths); () 
(...)

Dense Array¶

class tiledb.DenseArray(*args, **kw)¶

__getitem__(selection)¶

Retrieve data cells for an item or region of the array.

Parameters:: selection (tuple) – An int index, slice or tuple of integer/slice objects, specifying the selected subarray region for each dimension of the DenseArray.
Return type:: numpy.ndarray or collections.OrderedDict
Returns:: If the dense array has a single attribute then a Numpy array of corresponding shape/dtype is returned for that attribute. If the array has multiple attributes, a collections.OrderedDict is returned with dense Numpy subarrays for each attribute.
Raises:: IndexError – invalid or unsupported index selection
Raises:: tiledb.TileDBError

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     # Creates array 'array' on disk.
...     A = tiledb.from_numpy(tmp + "/array",  np.ones((100, 100)))
...     # Many aspects of Numpy's fancy indexing are supported:
...     A[1:10, ...].shape
...     A[1:10, 20:99].shape
...     A[1, 2].shape
(9, 100)
(9, 79)
()
>>> # Subselect on attributes when reading:
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.DenseArray.create(tmp + "/array", schema)
...     with tiledb.DenseArray(tmp + "/array", mode='w') as A:
...         A[0:10] = {"a1": np.zeros((10)), "a2": np.ones((10))}
...     with tiledb.DenseArray(tmp + "/array", mode='r') as A:
...         # Access specific attributes individually.
...         A[0:5]["a1"]
...         A[0:5]["a2"]
array([0, 0, 0, 0, 0])
array([1, 1, 1, 1, 1])

__setitem__(selection, val)¶

Set / update dense data cells

Parameters:

selection (tuple) – An int index, slice or tuple of integer/slice objects, specifiying the selected subarray region for each dimension of the DenseArray.
val (dict or numpy.ndarray) – a dictionary of array attribute values, values must able to be converted to n-d numpy arrays. if the number of attributes is one, then a n-d numpy array is accepted.

Raises:

IndexError – invalid or unsupported index selection
ValueError – value / coordinate length mismatch

Raises:

tiledb.TileDBError

Example:

>>> import tiledb, numpy as np, tempfile
>>> # Write to single-attribute 2D array
>>> with tempfile.TemporaryDirectory() as tmp:
...     # Create an array initially with all zero values
...     with tiledb.from_numpy(tmp + "/array",  np.zeros((2, 2))) as A:
...         pass
...     with tiledb.DenseArray(tmp + "/array", mode='w') as A:
...         # Write to the single (anonymous) attribute
...         A[:] = np.array(([1,2], [3,4]))
>>>
>>> # Write to multi-attribute 2D array
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(
...         tiledb.Dim(domain=(0, 1), tile=2, dtype=np.uint64),
...         tiledb.Dim(domain=(0, 1), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.DenseArray.create(tmp + "/array", schema)
...     with tiledb.DenseArray(tmp + "/array", mode='w') as A:
...         # Write to each attribute
...         A[0:2, 0:2] = {"a1": np.array(([-3, -4], [-5, -6])),
...                        "a2": np.array(([1, 2], [3, 4]))}

query(attrs=None, cond=None, dims=None, coords=False, order='C', use_arrow=None, return_arrow=False, return_incomplete=False)¶

Construct a proxy Query object for easy subarray queries of cells for an item or region of the array across one or more attributes.

Optionally subselect over attributes, return dense result coordinate values, and specify a layout a result layout / cell-order.

Parameters:

attrs – the DenseArray attributes to subselect over. If attrs is None (default) all array attributes will be returned. Array attributes can be defined by name or by positional index.
cond – the str expression to filter attributes or dimensions on. The expression must be parsable by tiledb.QueryCondition(). See help(tiledb.QueryCondition) for more details.
dims – the DenseArray dimensions to subselect over. If dims is None (default) then no dimensions are returned, unless coords=True.
coords – if True, return array of coodinate value (default False).
order – ‘C’, ‘F’, ‘U’, or ‘G’ (row-major, col-major, unordered, TileDB global order)
mode – “r” to read (default), “d” to delete
use_arrow – if True, return dataframes via PyArrow if applicable.
return_arrow – if True, return results as a PyArrow Table if applicable.
return_incomplete – if True, initialize and return an iterable Query object over the indexed range. Consuming this iterable returns a result set for each TileDB incomplete query. See usage example in ‘examples/incomplete_iteration.py’. To retrieve the estimated result sizes for the query ranges, use: A.query(…, return_incomplete=True)[…].est_result_size() If False (default False), queries will be internally run to completion by resizing buffers and resubmitting until query is complete.

Returns:

A proxy Query object that can be used for indexing into the DenseArray over the defined attributes, in the given result layout (order).

Raises:

ValueError – array is not opened for reads (mode = ‘r’)

Raises:

tiledb.TileDBError

Example:

>>> # Subselect on attributes when reading:
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(tiledb.Dim(domain=(0, 9), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.DenseArray.create(tmp + "/array", schema)
...     with tiledb.DenseArray(tmp + "/array", mode='w') as A:
...         A[0:10] = {"a1": np.zeros((10)), "a2": np.ones((10))}
...     with tiledb.DenseArray(tmp + "/array", mode='r') as A:
...         # Access specific attributes individually.
...         np.testing.assert_equal(A.query(attrs=("a1",))[0:5],
...                {"a1": np.zeros(5)})

Sparse Array¶

class tiledb.SparseArray(*args, **kw)¶

__getitem__(selection)¶

Retrieve nonempty cell data for an item or region of the array

Parameters:: selection (tuple) – An int index, slice or tuple of integer/slice objects, specifying the selected subarray region for each dimension of the SparseArray.
Return type:: collections.OrderedDict
Returns:: An OrderedDict is returned with dimension and attribute names as keys. Nonempty attribute values are returned as Numpy 1-d arrays.
Raises:: IndexError – invalid or unsupported index selection
Raises:: tiledb.TileDBError

Example:

>>> import tiledb, numpy as np, tempfile
>>> from collections import OrderedDict
>>> # Write to multi-attribute 2D array
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(
...         tiledb.Dim(name="y", domain=(0, 9), tile=2, dtype=np.uint64),
...         tiledb.Dim(name="x", domain=(0, 9), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom, sparse=True,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.SparseArray.create(tmp + "/array", schema)
...     with tiledb.SparseArray(tmp + "/array", mode='w') as A:
...         # Write in the twp cells (0,0) and (2,3) only.
...         I, J = [0, 2], [0, 3]
...         # Write to each attribute
...         A[I, J] = {"a1": np.array([1, 2]),
...                    "a2": np.array([3, 4])}
...     with tiledb.SparseArray(tmp + "/array", mode='r') as A:
...         # Return an OrderedDict with values and coordinates
...         np.testing.assert_equal(A[0:3, 0:10], OrderedDict({'a1': np.array([1, 2]),
...                'a2': np.array([3, 4]), 'y': np.array([0, 2], dtype=np.uint64),
...                 'x': np.array([0, 3], dtype=np.uint64)}))
...         # Return just the "x" coordinates values
...         A[0:3, 0:10]["x"]
array([0, 3], dtype=uint64)

With a floating-point array domain, index bounds are inclusive, e.g.:

>>> # Return nonempty cells within a floating point array domain (fp index bounds are inclusive):
>>> # A[5.0:579.9]

__setitem__(selection, val)¶

Set / update sparse data cells

Parameters:

selection (tuple) – N coordinate value arrays (dim0, dim1, …) where N in the ndim of the SparseArray, The format follows numpy sparse (point) indexing semantics.
val (dict or numpy.ndarray) – a dictionary of nonempty array attribute values, values must able to be converted to 1-d numpy arrays. if the number of attributes is one, then a 1-d numpy array is accepted.

Raises:

IndexError – invalid or unsupported index selection
ValueError – value / coordinate length mismatch

Raises:

tiledb.TileDBError

Example:

>>> import tiledb, numpy as np, tempfile
>>> # Write to multi-attribute 2D array
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(
...         tiledb.Dim(domain=(0, 1), tile=2, dtype=np.uint64),
...         tiledb.Dim(domain=(0, 1), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom, sparse=True,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.SparseArray.create(tmp + "/array", schema)
...     with tiledb.SparseArray(tmp + "/array", mode='w') as A:
...         # Write in the corner cells (0,0) and (1,1) only.
...         I, J = [0, 1], [0, 1]
...         # Write to each attribute
...         A[I, J] = {"a1": np.array([1, 2]),
...                    "a2": np.array([3, 4])}

query(attrs=None, cond=None, dims=None, index_col=True, coords=None, order='U', use_arrow=None, return_arrow=None, return_incomplete=False)¶

Construct a proxy Query object for easy subarray queries of cells for an item or region of the array across one or more attributes.

Optionally subselect over attributes, return dense result coordinate values, and specify a layout a result layout / cell-order.

Parameters:

attrs – the SparseArray attributes to subselect over. If attrs is None (default) all array attributes will be returned. Array attributes can be defined by name or by positional index.
cond – the str expression to filter attributes or dimensions on. The expression must be parsable by tiledb.QueryCondition(). See help(tiledb.QueryCondition) for more details.
dims – the SparseArray dimensions to subselect over. If dims is None (default) then all dimensions are returned, unless coords=False.
index_col – For dataframe queries, override the saved index information, and only set specified index(es) in the final dataframe, or None.
coords – (deprecated) if True, return array of coordinate value (default False).
order – ‘C’, ‘F’, or ‘G’ (row-major, col-major, tiledb global order)
mode – “r” to read
use_arrow – if True, return dataframes via PyArrow if applicable.
return_arrow – if True, return results as a PyArrow Table if applicable.

Returns:

A proxy Query object that can be used for indexing into the SparseArray over the defined attributes, in the given result layout (order).

Example:

>>> import tiledb, numpy as np, tempfile
>>> from collections import OrderedDict
>>> # Write to multi-attribute 2D array
>>> with tempfile.TemporaryDirectory() as tmp:
...     dom = tiledb.Domain(
...         tiledb.Dim(name="y", domain=(0, 9), tile=2, dtype=np.uint64),
...         tiledb.Dim(name="x", domain=(0, 9), tile=2, dtype=np.uint64))
...     schema = tiledb.ArraySchema(domain=dom, sparse=True,
...         attrs=(tiledb.Attr(name="a1", dtype=np.int64),
...                tiledb.Attr(name="a2", dtype=np.int64)))
...     tiledb.SparseArray.create(tmp + "/array", schema)
...     with tiledb.SparseArray(tmp + "/array", mode='w') as A:
...         # Write in the twp cells (0,0) and (2,3) only.
...         I, J = [0, 2], [0, 3]
...         # Write to each attribute
...         A[I, J] = {"a1": np.array([1, 2]),
...                    "a2": np.array([3, 4])}
...     with tiledb.SparseArray(tmp + "/array", mode='r') as A:
...         np.testing.assert_equal(A.query(attrs=("a1",), coords=False, order='G')[0:3, 0:10],
...                    OrderedDict({'a1': np.array([1, 2])}))

Query¶

Represents a TileDB query.

agg(aggs)¶

Calculate an aggregate operation for a given attribute. Available operations are sum, min, max, mean, count, and null_count (for nullable attributes only). Aggregates may be combined with other query operations such as query conditions and slicing.

The input may be a single operation, a list of operations, or a dictionary with attribute mapping to a single operation or list of operations.

For undefined operations on max and min, which can occur when a nullable attribute contains only nulled data at the given coordinates or when there is no data read for the given query (e.g. query conditions that do not match any values or coordinates that contain no data)), invalid results are represented as np.nan for attributes of floating point types and None for integer types.

>>> import tiledb, tempfile, numpy as np
>>> path = tempfile.mkdtemp()

>>> with tiledb.from_numpy(path, np.arange(1, 10)) as A:
...     pass

>>> # Note that tiledb.from_numpy creates anonymous attributes, so the
>>> # name of the attribute is represented as an empty string

>>> with tiledb.open(path, 'r') as A:
...     A.query().agg("sum")[:]
45

>>> with tiledb.open(path, 'r') as A:
...     A.query(cond="attr('') < 5").agg(["count", "mean"])[:]
{'count': 9, 'mean': 2.5}

>>> with tiledb.open(path, 'r') as A:
...     A.query().agg({"": ["max", "min"]})[2:7]
{'max': 7, 'min': 3}

Parameters:: agg – The input attributes and operations to apply aggregations on
Returns:: single value for single operation on one attribute, a dictionary of attribute keys associated with a single value for a single operation across multiple attributes, or a dictionary of attribute keys that maps to a dictionary of operation labels with the associated value

property attrs¶: List of attributes to include in Query.

property cond¶: QueryCondition used to filter attributes or dimensions in Query.

property df¶: Apply Array.multi_index with query parameters and return result as a Pandas dataframe.

property dims¶: List of dimensions to include in Query.

property domain_index¶: Apply Array.domain_index with query parameters.

get_stats(print_out=True, json=False)¶

Retrieves the stats from a TileDB query.

Parameters:

print_out – Print string to console (default True), or return as string
json – Return stats JSON object (default: False)

property has_coords¶

True if query should include (return) coordinate values.

Return type:: bool

property index_col¶: List of columns to set as index for dataframe queries, or None.

label_index(labels)¶: Apply Array.label_index with query parameters.

property multi_index¶: Apply Array.multi_index with query parameters.

property order¶: Return underlying Array order.

subarray() → Subarray¶

Subarray with the ranges this query is on.

Return type:: Subarray

submit()¶: An alias for calling the regular indexer [:]

Query Condition¶

class tiledb.QueryCondition(expression: str, ctx: ~tiledb.ctx.Ctx = <factory>)¶

Class representing a TileDB query condition object for attribute and dimension (sparse arrays only) filtering pushdown.

A query condition is set with a string representing an expression as defined by the grammar below. A more straight forward example of usage is given beneath.

When querying a sparse array, only the values that satisfy the given condition are returned (coupled with their associated coordinates). An example may be found in examples/query_condition_sparse.py.

For dense arrays, the given shape of the query matches the shape of the output array. Values that DO NOT satisfy the given condition are filled with the TileDB default fill value. Different attribute and dimension types have different default fill values as outlined here (https://docs.tiledb.com/main/background/internal-mechanics/writing#default-fill-values). An example may be found in examples/query_condition_dense.py.

A query condition is made up of one or more Boolean expressions. Multiple Boolean expressions are chained together with Boolean operators. The or_op Boolean operators are given lower presedence than and_op.

A Bitwise expression may either be a comparison expression or membership expression.

A Boolean expression may either be a comparison expression or membership expression.

A comparison expression contains a comparison operator. The operator works on a TileDB attribute or dimension name (hereby known as a “TileDB variable”) and value.

All comparison operators are supported.

Bitwise operators are given higher precedence than comparison operators. Boolean operators are given lower precedence than comparison operators.

If an attribute name has special characters in it, you can wrap namehere in attr("namehere").

A membership expression contains the membership operator, in. The operator works on a TileDB variable and list of values.

TileDB variable names are Python valid variables or a attr() or dim() casted string.

Values are any Python-valid number or string. datetime64 values should first be cast to UNIX seconds. Values may also be casted with val().

Example:

>>> with tiledb.open(uri, mode="r") as A:
>>>     # Select cells where the values for `foo` are less than 5
>>>     # and `bar` equal to string "asdf".
>>>     # Note precedence is equivalent to:
>>>     # tiledb.QueryCondition("foo > 5 or ('asdf' == var('b a r') and baz <= val(1.0))")
>>>     A.query(cond=tiledb.QueryCondition("foo > 5 or 'asdf' == var('b a r') and baz <= val(1.0)"))
>>>
>>>     # Select cells where the values for `foo` are equal to 1, 2, or 3.
>>>     # Note this is equivalent to:
>>>     # tiledb.QueryCondition("foo == 1 or foo == 2 or foo == 3")
>>>     A.query(cond=tiledb.QueryCondition("foo in [1, 2, 3]"))
>>>
>>>     # Example showing that bitwise operators (| ^ &) are given higher precedence than comparison operators
>>>     # and comparison operators are given higher precedence than logical operators.
>>>     # Note this is equivalent to:
>>>     # tiledb.QueryCondition("((foo == 1) or (foo == 2)) and ('xyz' == var('b a r')) and ((foo & 1) == 0"))
>>>     A.query(cond=tiledb.QueryCondition("foo == 1 or foo == 2 and 'xyz' == var('b a r') and foo & 1 == 0"))

Group¶

class tiledb.Group(uri: str, mode: str = 'r', config: Config = None, ctx: Ctx | None = None)¶

Support for organizing multiple arrays in arbitrary directory hierarchies.

Group members may be any number of nested groups and arrays. Members are stored as tiledb.Objects which indicate the member’s URI and type.

Groups may contain associated metadata similar to array metadata where keys are strings. Singleton values may be of type int, float, str, or bytes. Multiple values of the same type may be placed in containers of type list, tuple, or 1-D np.ndarray. The values within containers are limited to type int or float.

See more at: https://docs.tiledb.com/main/background/key-concepts-and-data-format#arrays-and-groups

Parameters:

uri (str) – The URI to the Group
mode (str) – Read mode (‘r’), write mode (‘w’), or modify exclusive (‘m’)
config (Config or dict) – A TileDB config
ctx (tiledb.Ctx) – A TileDB context

Example:

>>> # Create a group
>>> grp_path = "root_group"
>>> tiledb.Group.create(grp_path)
>>> grp = tiledb.Group(grp_path, "w")
>>>
>>> # Create an array and add as a member to the group
>>> array_path = "array.tdb"
>>> domain = tiledb.Domain(tiledb.Dim(domain=(1, 8), tile=2))
>>> a1 = tiledb.Attr("val", dtype="f8")
>>> schema = tiledb.ArraySchema(domain=domain, attrs=(a1,))
>>> tiledb.Array.create(array_path, schema)
>>> grp.add(array_path)
>>>
>>> # Create a group and add as a subgroup
>>> subgrp_path = "sub_group"
>>> tiledb.Group.create(subgrp_path)
>>> grp.add(subgrp_path)
>>>
>>> # Add metadata to the subgroup
>>> grp.meta["ints"] = [1, 2, 3]
>>> grp.meta["str"] = "string_metadata"
>>> grp.close()
>>>
>>> grp.open("r")
>>> # Dump all the members in string format
>>> mbrs_repr = grp
>>> # Or create a list of Objects in the Group
>>> mbrs_iter = list(grp)
>>> # Get the first member's uri and type
>>> member_uri, member_type = grp[0].uri, grp[0].type
>>> grp.close()
>>>
>>> # Remove the subgroup
>>> grp.open("w")
>>> grp.remove(subgrp_path)
>>> grp.close()
>>>
>>> # Delete the subgroup
>>> grp.open("m")
>>> grp.delete(subgrp_path)
>>> grp.close()

__getitem__(member)¶

Retrieve a member from the Group as an Object.

Parameters:: member (Union[int, str]) – The index or name of the member
Returns:: The member as an Object
Return type:: Object

__delitem__(uri)¶

Remove a member from the group.

Parameters:: uri (str) – The URI to the member

__contains__(member)¶

Returns:: Whether the Group contains a member with the given name
Return type:: bool

__len__() → int¶

Return type:: int
Returns:: Number of members in the Group

add(uri: str, name: str = None, relative: bool = False)¶

Adds a member to the Group.

Parameters:

uri (str) – The URI of the member to add
relative (bool) – Whether the path of the URI is a relative path (default=relative: False)
name (str) – An optional name for the Group (default=None)

close()¶: Close a Group.

static consolidate_metadata(uri: str, config: Config = None, ctx: Ctx | None = None)¶

Consolidate the group metadata.

Parameters:

uri (str) – The URI of the TileDB group to be consolidated
config (Config) – Optional configuration parameters for the consolidation
ctx (Ctx) – Optional TileDB context

static create(uri: str, ctx: Ctx | None = None)¶

Create a new Group.

Parameters:

uri (str) – The URI to the to-be created Group
ctx (tiledb.Ctx) – A TileDB context

delete(recursive: bool = False)¶

Delete a Group. The group needs to be opened in ‘m’ mode.

Parameters:: uri – The URI of the group to delete

is_relative(name: str) → bool¶

Parameters:: name (str) – Name of member to retrieve associated relative indicator
Returns:: Whether the attribute is relative
Return type:: bool

property isopen: bool¶

Whether or not the Group is open :rtype: bool

Type:: return

property meta: Metadata¶

The Group’s metadata as a key-value structure :rtype: Metadata

Type:: return

property mode: str¶

Read mode (‘r’), write mode (‘w’), or modify exclusive (‘m’) :rtype: str

Type:: return

open(mode: str = 'r')¶

Open a Group in read mode (“r”) or write mode (“w”).

Parameters:: mode (str) – Read mode (‘r’) or write mode (‘w’)

remove(member: str)¶

Remove a member from the Group.

Parameters:: member (str) – The URI or name of the member

set_config(cfg: Config)¶

Parameters:: cfg (Config) – Config to set on the Group

property uri: str¶

URI of the Group :rtype: str

Type:: return

static vacuum_metadata(uri: str, config: Config = None, ctx: Ctx | None = None)¶

Vacuum the group metadata.

Parameters:

uri (str) – The URI of the TileDB group to be vacuum
config (Config) – Optional configuration parameters for the vacuuming
ctx (Ctx) – Optional TileDB context

class tiledb.Metadata(array_or_group)¶

Holds metadata for the associated Array or Group in a dictionary-like structure.

__setitem__(key, value)¶

Parameters:

key (str) – Key for the metadata entry
value (Union[int, float, str, bytes, np.ndarray]) – Value for the metadata entry

__getitem__(key)¶

Parameters:: key (str) – Key of the metadata entry
Return type:: Union[int, float, str, bytes, np.ndarray]
Returns:: The value associated with the key

__delitem__(key)¶

Removes the entry from the metadata.

Parameters:: key (str) – Key of the metadata entry

__contains__(key)¶

Parameters:: key (str) – Key of the metadata entry
Return type:: bool
Returns:: True if the key is in the metadata, otherwise False

__len__() → int¶

Return type:: int
Returns:: Number of entries in the metadata

clear() → None. Remove all items from D.¶

consolidate(config: Config = None, ctx: Ctx | None = None)¶

Consolidate the metadata.

Parameters:

uri (str) – The URI of the TileDB Array or Group to be consolidated
config (Config) – Optional configuration parameters for the consolidation
ctx (Ctx) – Optional TileDB context

dump()¶: Output information about all metadata to stdout.

pop(k[, d]) → v, remove specified key and return the corresponding value.¶: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair¶: as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D¶

Object¶

class tiledb.Object(type: ObjectType, uri: str, name: str | None = None)¶

Represents a TileDB object which may be of type Array, Group, or Invalid.

uri¶

URI of the Object. :rtype: str

Type:: return

type¶

Valid TileDB object types are Array and Group. :rtype: type

Type:: return

Object Management¶

tiledb.array_exists(uri, isdense=False, issparse=False, ctx=None)¶

Check if arrays exists and is open-able at the given URI

Parameters:

uri (str) – URI for the TileDB array (any supported TileDB URI)
isdense (bool) – (optional) Restrict to dense array types
issparse (bool) – (optional) Restrict to sparse array types
ctx – (optional) TileDB Ctx

tiledb.group_create(uri: str, ctx: Ctx | None = None)¶

Create a new Group.

Parameters:

uri (str) – The URI to the to-be created Group
ctx (tiledb.Ctx) – A TileDB context

tiledb.object_type(uri: str, ctx: Ctx = None) → str | None¶

Returns the TileDB object type at the specified URI as a string.

Parameters:

uri – URI of the TileDB resource
ctx – The TileDB Context

Returns:

object type string (“array” or “group”) or None if invalid TileDB object```

tiledb.remove(uri: str, ctx: Ctx = None)¶

Removes (deletes) the TileDB object at the specified URI

Parameters:

uri – URI of the TileDB resource
ctx – The TileDB Context

Raises:

tiledb.TileDBError

tiledb.move(old_uri: str, new_uri: str, ctx: Ctx = None)¶

Moves a TileDB resource (group, array, key-value).

Parameters:

old_uri – URI of the TileDB resource to move
new_uri – URI of the destination
ctx – The TileDB Context

Raises:

TileDBError

tiledb.ls(uri: str, func: Callable, ctx: Ctx = None)¶

Lists TileDB resources and applies a callback that have a prefix of uri (one level deep).

Parameters:

uri – URI of TileDB group object
func – callback to execute on every listed TileDB resource, resource URI and object type label are passed as arguments to the callback
ctx – A TileDB Context

tiledb.walk(uri: str, func: Callable, order: str = 'preorder', ctx: Ctx = None)¶

Recursively visits TileDB resources and applies a callback to resources that have a prefix of uri

Parameters:

uri – URI of TileDB group object
func – callback to execute on every listed TileDB resource, resource URI and object type label are passed as arguments to the callback
ctx – The TileDB context
order – ‘preorder’ (default) or ‘postorder’ tree traversal

Raises:

ValueError – unknown order

Raises:

tiledb.TileDBError

Fragment Info¶

class tiledb.FragmentInfoList(array_uri, include_mbrs=False, ctx=None)¶

Class representing an ordered list of FragmentInfo objects.

Parameters:

array_uri (str) – URI for the TileDB array (any supported TileDB URI)
include_mbrs (bool) – (default False) include minimum bounding rectangles in FragmentInfo result
ctx (tiledb.Ctx) – A TileDB context

Variables:

uri – URIs of fragments
version – Fragment version of each fragment
nonempty_domain – Non-empty domain of each fragment
cell_num – Number of cells in each fragment
timestamp_range – Timestamp range of when each fragment was written
sparse – For each fragment, True if fragment is sparse, else False
has_consolidated_metadata – For each fragment, True if fragment has consolidated fragment metadata, else False
unconsolidated_metadata_num – Number of unconsolidated metadata fragments in each fragment
to_vacuum – URIs of already consolidated fragments to vacuum
mbrs – (TileDB Embedded 2.5.0+ only) The mimimum bounding rectangle of each fragment; only present when include_mbrs=True
array_schema_name – (TileDB Embedded 2.5.0+ only) The array schema’s name

Example:

>>> import tiledb, numpy as np, tempfile
>>> with tempfile.TemporaryDirectory() as tmp:
...     # The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4] and space tiles 2x2
...     dom = tiledb.Domain(
...         tiledb.Dim(name="rows", domain=(1, 4), tile=2, dtype=np.int32),
...         tiledb.Dim(name="cols", domain=(1, 4), tile=2, dtype=np.int32),
...     )
...     # The array will be dense with a single attribute "a" so each (i,j) cell can store an integer.
...     schema = tiledb.ArraySchema(
...         domain=dom, sparse=False, attrs=[tiledb.Attr(name="a", dtype=np.int32)]
...     )
...     # Set URI of the array
...     uri = tmp + "/array"
...     # Create the (empty) array on disk.
...     tiledb.Array.create(uri, schema)
...
...     # Write three fragments to the array
...     with tiledb.DenseArray(uri, mode="w") as A:
...         A[1:3, 1:5] = np.array(([[1, 2, 3, 4], [5, 6, 7, 8]]))
...     with tiledb.DenseArray(uri, mode="w") as A:
...         A[2:4, 2:4] = np.array(([101, 102], [103, 104]))
...     with tiledb.DenseArray(uri, mode="w") as A:
...         A[3:4, 4:5] = np.array(([202]))
...
...     # tiledb.array_fragments() requires TileDB-Py version > 0.8.5
...     fragments_info = tiledb.array_fragments(uri)
...
...     "====== FRAGMENTS  INFO ======"
...     f"number of fragments: {len(fragments_info)}"
...     f"nonempty domains: {fragments_info.nonempty_domain}"
...     f"sparse fragments: {fragments_info.sparse}"
...
...     for fragment in fragments_info:
...         f"===== FRAGMENT NUMBER {fragment.num} ====="
...         f"is sparse: {fragment.sparse}"
...         f"cell num: {fragment.cell_num}"
...         f"has consolidated metadata: {fragment.has_consolidated_metadata}"
...         f"nonempty domain: {fragment.nonempty_domain}"
'====== FRAGMENTS  INFO ======'
'number of fragments: 3'
'nonempty domains: (((1, 2), (1, 4)), ((2, 3), (2, 3)), ((3, 3), (4, 4)))'
'sparse fragments: (False, False, False)'
'===== FRAGMENT NUMBER 0 ====='
'is sparse: False'
'cell num: 8'
'has consolidated metadata: False'
'nonempty domain: ((1, 2), (1, 4))'
'===== FRAGMENT NUMBER 1 ====='
'is sparse: False'
'cell num: 16'
'has consolidated metadata: False'
'nonempty domain: ((2, 3), (2, 3))'
'===== FRAGMENT NUMBER 2 ====='
'is sparse: False'
'cell num: 4'
'has consolidated metadata: False'
'nonempty domain: ((3, 3), (4, 4))'

class tiledb.FragmentInfo(fragments: FragmentInfoList, num)¶

Class representing the metadata for a single fragment. See tiledb.FragmentInfoList for example of usage.

Variables:

uri – URIs of fragments
version – Fragment version of each fragment
nonempty_domain – Non-empty domain of each fragment
cell_num – Number of cells in each fragment
timestamp_range – Timestamp range of when each fragment was written
sparse – For each fragment, True if fragment is sparse, else False
has_consolidated_metadata – For each fragment, True if fragment has consolidated fragment metadata, else False
unconsolidated_metadata_num – Number of unconsolidated metadata fragments in each fragment
to_vacuum – URIs of already consolidated fragments to vacuum
mbrs – (TileDB Embedded 2.5.0+ only) The mimimum bounding rectangle of each fragment; only present when include_mbrs=True
array_schema_name – (TileDB Embedded 2.5.0+ only) The array schema’s name

Enumeration¶

class tiledb.Enumeration(name: str, ordered: bool, values: Sequence[Any] | None = None, dtype: dtype | None = None, ctx: Ctx | None = None)¶

Represents a TileDB Enumeration.

property cell_val_num: int¶

The enumeration’s cell value number.

Return type:: int

property dtype: dtype¶

Numpy dtype representation of the enumeration type.

Return type:: numpy.dtype

extend(values: Sequence[Any]) → Enumeration¶

Add additional values to the enumeration.

Parameters:: values – The values to add to the enumeration
Return type:: Enumeration

property name: str¶

The enumeration label string.

Return type:: str

property ordered: bool¶

True if the enumeration is ordered.

Return type:: bool

values() → ndarray[tuple[int, ...], dtype[_ScalarType_co]]¶

The values of the enumeration.

Return type:: NDArray

Exceptions¶

exception tiledb.TileDBError¶

VFS¶

class tiledb.VFS(config: Config | dict = None, ctx: Ctx | None = None)¶

TileDB VFS class

Encapsulates the TileDB VFS module instance with a specific configuration (config).

Parameters:

ctx (tiledb.Ctx) – The TileDB Context
config (tiledb.Config or dict) – Override ctx VFS configurations with updated values in config.

close(file: FileHandle)¶

Closes a VFS FileHandle object.

Parameters:: file (FileIO) – An opened VFS FileIO
Return type:: FileIO
Returns:: closed VFS FileHandle
Raises:: tiledb.TileDBError

config() → Config¶

Return type:: tiledb.Config
Returns:: config associated with the VFS object

copy_dir(old_uri: str | bytes | PathLike, new_uri: str | bytes | PathLike)¶

Copies a TileDB directory from an old URI to a new URI.

Parameters:

old_uri (str) – Input of the old directory URI
new_uri (str) – Input of the new directory URI

copy_file(old_uri: str | bytes | PathLike, new_uri: str | bytes | PathLike)¶

Copies a TileDB file from an old URI to a new URI.

Parameters:

old_uri (str) – Input of the old file URI
new_uri (str) – Input of the new file URI

create_bucket(uri: str | bytes | PathLike)¶

Creates an object store bucket with the input URI.

Parameters:: uri (str) – Input URI of the bucket

create_dir(uri: str | bytes | PathLike)¶

Create a directory at the specified input URI.

Parameters:: uri (str) – Input URI of the directory

ctx() → Ctx¶

Return type:: tiledb.Ctx
Returns:: context associated with the VFS object

dir_size(uri: str | bytes | PathLike) → int¶

Parameters:: uri (str) – Input URI of the directory
Return type:: int
Returns:: The size of a directory with the input URI

empty_bucket(uri: str | bytes | PathLike)¶

Empty an object store bucket.

Parameters:: uri (str) – Input URI of the bucket

file_size(uri: str | bytes | PathLike) → int¶

Parameters:: uri (str) – Input URI of the file
Return type:: int
Returns:: The size of a file with the input URI

is_bucket(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the bucket
Return type:: bool
Returns:: True if an object store bucket with the input URI exists, False otherwise

is_dir(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the directory
Return type:: bool
Returns:: True if a directory with the input URI exists, False otherwise

is_empty_bucket(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the bucket
Return type:: bool
Returns:: True if an object store bucket is empty, False otherwise

is_file(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the file
Return type:: bool
Returns:: True if a file with the input URI exists, False otherwise

isdir(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the directory
Return type:: bool
Returns:: True if a directory with the input URI exists, False otherwise

isfile(uri: str | bytes | PathLike) → bool¶

Parameters:: uri (str) – Input URI of the file
Return type:: bool
Returns:: True if a file with the input URI exists, False otherwise

ls(uri: str | bytes | PathLike, recursive: bool = False) → List[str]¶

Retrieves the children in directory uri. This function is non-recursive, i.e., it focuses in one level below uri.

Parameters:

uri (str) – Input URI of the directory
recursive (bool) – If True, recursively list all children in the directory

Return type:

List[str]

Returns:

The children in directory uri

ls_recursive(uri: str | bytes | PathLike, callback: Callable[[str, int], bool] | None = None)¶

Recursively lists objects at the input URI, invoking the provided callback on each entry gathered. The callback is passed the data pointer provided on each invocation and is responsible for writing the collected results into this structure. If the callback returns True, the walk will continue. If False, the walk will stop. If an error is thrown, the walk will stop and the error will be propagated to the caller using std::throw_with_nested.

Currently only local, S3, Azure and GCS are supported.

Parameters:

uri (str) – Input URI of the directory
callback – Callback function to invoke on each entry

move_dir(old_uri: str | bytes | PathLike, new_uri: str | bytes | PathLike)¶

Renames a TileDB directory from an old URI to a new URI.

Parameters:

old_uri (str) – Input of the old directory URI
new_uri (str) – Input of the new directory URI

move_file(old_uri: str | bytes | PathLike, new_uri: str | bytes | PathLike)¶

Renames a TileDB file from an old URI to a new URI.

Parameters:

old_uri (str) – Input of the old file URI
new_uri (str) – Input of the new file URI

open(uri: str | bytes | PathLike, mode: str = 'rb')¶

Opens a VFS file resource for reading / writing / appends at URI.

If the file did not exist upon opening, a new file is created.

Parameters:

uri (str) – URI of VFS file resource
str (mode) – ‘rb’ for opening the file to read, ‘wb’ to write, ‘ab’ to append

Return type:

FileHandle

Returns:

TileDB FileIO

Raises:

TypeError – cannot convert uri to unicode string
ValueError – invalid mode

Raises:

tiledb.TileDBError

read(file: FileHandle, offset: int, nbytes: int) → bytes¶

Read nbytes from an opened VFS FileHandle at a given offset.

Parameters:

file (FileHandle) – An opened VFS FileHandle in ‘r’ mode
offset (int) – offset position in bytes to read from
nbytes (int) – number of bytes to read

Return type:

bytes()

Returns:

read bytes

Raises:

tiledb.TileDBError

remove_bucket(uri: str | bytes | PathLike)¶

Deletes an object store bucket with the input URI.

Parameters:: uri (str) – Input URI of the bucket

remove_dir(uri: str | bytes | PathLike)¶

Removes a directory (recursively) with the input URI.

Parameters:: uri (str) – Input URI of the directory

remove_file(uri: str | bytes | PathLike)¶

Removes a file with the input URI.

Parameters:: uri (str) – Input URI of the file

size(uri: str | bytes | PathLike) → int¶

Parameters:: uri (str) – Input URI of the file
Return type:: int
Returns:: The size of a file with the input URI

supports(scheme: str) → bool¶

Returns true if the given URI scheme (storage backend) is supported.

Parameters:: scheme (str) – scheme component of a VFS resource URI (ex. ‘file’ / ‘hdfs’ / ‘s3’)
Return type:: bool
Returns:: True if the linked libtiledb version supports the storage backend, False otherwise
Raises:: ValueError – VFS storage backend is not supported

touch(uri: str | bytes | PathLike)¶

Touches a file with the input URI, i.e., creates a new empty file.

Parameters:: uri (str) – Input URI of the file

write(file: FileHandle, buff: str | bytes)¶

Writes buffer to opened VFS FileHandle.

Parameters:

file (FileHandle) – An opened VFS FileHandle in ‘w’ mode
buff – a Python object that supports the byte buffer protocol

Raises:

TypeError – cannot convert buff to bytes

Raises:

tiledb.TileDBError

class tiledb.FileIO(vfs: VFS, uri: str | bytes | PathLike, mode: str = 'rb')¶

TileDB FileIO class that encapsulates files opened by tiledb.VFS. The file operations are meant to mimic Python’s built-in file I/O methods.

__len__()¶

Return type:: int
Returns:: Number of bytes in file

property closed: bool¶

bool :return: True if the file is closed, otherwise False

Type:: rtype

flush()¶: Force the data to be written to the file.

property mode: str¶

str :return: Whether the file is in read mode (“rb”), write mode (“wb”), or append mode (“ab”)

Type:: rtype

read(size: int = -1) → bytes¶

Read the file from the current pointer position.

Parameters:: size (int) – Number of bytes to read. By default, size is set to -1 which will read until the end of the file.
Return type:: bytes
Returns:: The bytes in the file

readable() → bool¶

Return type:: bool
Returns:: True if the file is readable (ie. “rb” mode), otherwise False

readinto(buff: bytes | bytearray | memoryview) → int¶: Read bytes into a pre-allocated, writable, bytes-like object, and return the number of bytes read. :param buff bytes | bytearray | memoryview: A pre-allocated, writable object that supports the byte buffer protocol :rtype: int :return: The number of bytes read

seek(offset: int, whence: int = 0)¶

Parameters:

offset (int) – Byte position to set the file pointer
whence (int) – Reference point. A whence value of 0 measures from the beginning of the file, 1 uses the current file position, and 2 uses the end of the file as the reference point. whence can be omitted and defaults to 0.

seekable()¶

All tiledb.FileIO objects are seekable.

Return type:: bool
Returns:: True

tell() → int¶

Return type:: int
Returns:: The current position in the file represented as number of bytes

writable() → bool¶

Return type:: bool
Returns:: True if the file is writable (ie. “wb” or “ab” mode), otherwise False

write(buff: bytes)¶

Parameters:: buff (bytes) – Write the given bytes to the file

Filestore¶

class tiledb.Filestore(uri: str, ctx: Ctx | None = None)¶

Functions to set and get data to and from a TileDB Filestore Array.

A Filestore Array may be created using ArraySchema.from_file combined with Array.create.

Parameters:

uri (str) – The URI to the TileDB Fileshare Array
ctx (tiledb.Ctx) – A TileDB context

__len__() → int¶

Return type:: int
Returns:: Bytes in the Filestore Array

static copy_from(filestore_array_uri: str, file_uri: str, mime_type: str = 'AUTODETECT', ctx: Ctx | None = None) → None¶

Copy data from a file to a Filestore Array.

Parameters:

filestore_array_uri (str) – The URI to the TileDB Fileshare Array
file_uri (str) – URI of file to export
mime_type (str) – MIME types are “AUTODETECT” (default), “image/tiff”, “application/pdf”
ctx (tiledb.Ctx) – A TileDB context

static copy_to(filestore_array_uri: str, file_uri: str, ctx: Ctx | None = None) → None¶

Copy data from a Filestore Array to a file.

Parameters:

filestore_array_uri (str) – The URI to the TileDB Fileshare Array
file_uri (str) – The URI to the TileDB Fileshare Array
ctx (tiledb.Ctx) – A TileDB context

read(offset: int = 0, size: int = -1) → bytes¶

Parameters:

offset (int) – Byte position to begin reading. Defaults to beginning of filestore.
size (int) – Total number of bytes to read. Defaults to -1 which reads the entire filestore.

Return type:

bytes

Returns:

Data from the Filestore Array

write(buffer: ByteString, mime_type: str = 'AUTODETECT') → None¶

Import data from an object that supports the buffer protocol to a Filestore Array.

Parameters:

ByteString (buffer) – Data of type bytes, bytearray, memoryview, etc.
mime_type (str) – MIME types are “AUTODETECT” (default), “image/tiff”, “application/pdf”

Statistics¶

tiledb.stats_enable()¶: Enable TileDB internal statistics.

tiledb.stats_disable()¶: Disable TileDB internal statistics.

tiledb.stats_reset()¶: Reset all TileDB internal statistics to 0.

tiledb.stats_dump(version=True, print_out=True, include_python=True, json=False, verbose=True)¶

Return TileDB internal statistics as a string.

Parameters:

include_python – Include TileDB-Py statistics
print_out – Print string to console (default True), or return as string
version – Include TileDB Embedded and TileDB-Py versions (default: True)
json – Return stats JSON object (default: False)
verbose – Print extended internal statistics (default: True)