deeplake.core.index

class deeplake.core.index.IndexEntry(value: Union[int, slice, Tuple[int, ...]] = slice(None, None, None))
__getitem__(item: Union[int, slice, Tuple[int, ...]])

Combines the given item and this IndexEntry. Returns a new IndexEntry representing the composition of the two.

Examples

>>> IndexEntry()[0:100]
IndexEntry(slice(0, 100, None))

>>> IndexEntry()[100:200][5]
IndexEntry(105)

>>> IndexEntry()[(0, 1, 2, 3)]
IndexEntry((0, 1, 2, 3))

>>> IndexEntry()[1, 2, 3]
IndexEntry((0, 1, 2, 3))
Parameters:item – The desired sub-index to be composed with this IndexEntry. Can be an int, a slice, or a tuple of ints.
Returns:The new IndexEntry object.
Return type:IndexEntry
Raises:TypeError – An integer IndexEntry should not be indexed further.
__init__(value: Union[int, slice, Tuple[int, ...]] = slice(None, None, None))

Initialize self. See help(type(self)) for accurate signature.

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

downsample(factor: int, length: int)

Downsamples an IndexEntry by a given factor.

Parameters:
  • factor (int) – The factor by which to downsample.
  • length (int) – The length of the downsampled IndexEntry.
Returns:

The downsampled IndexEntry.
Return type:

IndexEntry
Raises:

TypeError – If the IndexEntry cannot be downsampled.
indices(length: int)

Generates the sequence of integer indices for a target of a given length.

is_trivial()

Checks if an IndexEntry represents the entire slice

length(parent_length: int) → int

Returns the length of an IndexEntry given the length of the parent it is indexing.

Examples

>>> IndexEntry(slice(5, 10)).length(100)
5
>>> len(list(range(100))[5:10])
5
>>> IndexEntry(slice(5, 100)).length(50)
45
>>> len(list(range(50))[5:100])
45
>>> IndexEntry(0).length(10)
1
Parameters:parent_length (int) – The length of the target that this IndexEntry is indexing.
Returns:The length of the index if it were applied to a parent of the given length.
Return type:int
subscriptable()

Returns whether an IndexEntry can be further subscripted.

validate(parent_length: int)

Checks that the index is not accessing values outside the range of the parent.

class deeplake.core.index.Index(item: Union[int, slice, Tuple[int, ...], Index, List[deeplake.core.index.index.IndexEntry]] = slice(None, None, None))
__getitem__(item: Union[int, slice, List[int], Tuple[Union[int, slice, Tuple[int, ...]]], Index])

Returns a new Index representing a subscripting with the given item. Modeled after NumPy’s advanced integer indexing.

See: https://numpy.org/doc/stable/reference/arrays.indexing.html

Examples

>>> Index([5, slice(None)])[5]
Index([5, 5])

>>> Index([5])[5:6]
Index([5, slice(5, 6)])

>>> Index()[0, 1, 2:5, 3]
Index([0, 1, slice(2, 5), 3])

>>> Index([slice(5, 6)])[(0, 1, 2:5, 3),]
Index([(5, 1, slice(2, 5), 3)])
Parameters:item – The contents of the subscript expression to add to this Index.
Returns:The Index representing the result of the subscript operation.
Return type:Index
Raises:TypeError – Given item should be another Index, or compatible with NumPy’s advanced integer indexing.
__init__(item: Union[int, slice, Tuple[int, ...], Index, List[deeplake.core.index.index.IndexEntry]] = slice(None, None, None))

Initializes an Index from an IndexValue, another Index, or the values from another Index.

Represents a list of IndexEntry objects corresponding to indexes into each axis of an ndarray.

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

apply(samples: List[numpy.ndarray])

Applies an Index to a list of ndarray samples with the same number of entries as the first entry in the Index.

apply_squeeze(samples: List[numpy.ndarray])

Applies the primary axis of an Index to a list of ndarray samples. Will either return the list as given, or return the first sample.

compose_at(item: Union[int, slice, Tuple[int, ...]], i: Optional[int] = None)

Returns a new Index representing the addition of an IndexValue, or the composition with a given axis.

Examples

>>> Index([slice(None), slice(None)]).compose_at(5)
Index([slice(None), slice(None), 5])

>>> Index([slice(None), slice(5, 10), slice(None)]).compose_at(3, 1)
Index([slice(None), 8, slice(None)])
Parameters:
  • item (IndexValue) – The value to append or compose with the Index.
  • i (int, optional) – The axis to compose with the given item. Defaults to None, meaning that the item will be appended instead.
Returns:

The result of the addition or composition.
Return type:

Index
downsample(factor: int, shape: Tuple[int, ...])

Downsamples an Index by the given factor.

Parameters:
  • factor (int) – The factor to downsample by.
  • shape (Tuple[int, ..]) – The shape of the downsampled data.
Returns:

The downsampled Index.
Return type:

Index
find_axis(offset: int = 0)

Returns the index for the nth subscriptable axis in the values of an Index.

Parameters:offset (int) – The number of subscriptable axes to skip before returning. Defaults to 0, meaning that the first valid axis is returned.
Returns:The index of the found axis, or None if no match is found.
Return type:int
is_trivial()

Checks if an Index is equivalent to the trivial slice [:], aka slice(None).

length(parent_length: int)

Returns the primary length of an Index given the length of the parent it is indexing. See: IndexEntry.length()

validate(parent_length)

Checks that the index is not accessing values outside the range of the parent.

deeplake.core.index.merge_slices(existing_slice: slice, new_slice: slice) → slice

Compose two slice objects

Given an iterable x, the following should be equivalent:

x[existing_slice][new_slice] == x[merge_slices(existing_slice, new_slice)]

Parameters:
  • existing_slice (slice) – The existing slice to be restricted.
  • new_slice (slice) – The new slice to be applied to the existing slice.
Returns:

the composition of the given slices
Return type:

slice
Raises:

NotImplementedError – Composing slices with negative values is not supported. Negative indexing for slices is only supported for the first slice.
deeplake.core.index.slice_at_int(s: slice, i: int)

Returns the i th element of a slice s.

Examples

>>> slice_at_int(slice(None), 10)
10

>>> slice_at_int(slice(10, 20, 2), 3)
16
Parameters:
  • s (slice) – The slice to index into.
  • i (int) – The integer offset into the slice.
Returns:

The index corresponding to the offset into the slice.
Return type:

int
Raises:
  • NotImplementedError – Nontrivial slices should not be indexed with negative integers.
  • IndexError – If step is negative and start is not greater than stop.
deeplake.core.index.slice_length(s: slice, parent_length: int) → int

Returns the length of a slice given the length of its parent.