napari.utils.events.EventedList#

class napari.utils.events.EventedList(data: Iterable[_T] = (), *, basetype: type[_T] | Sequence[type[_T]] = (), lookup: dict[type[_L], Callable[[_T], _T | _L]] | None = None)[source]#

Bases: TypedMutableSequence[_T]

Mutable Sequence that emits events when altered.

This class is designed to behave exactly like the builtin list, but will emit events before and after all mutations (insertion, removal, setting, and moving).

Parameters:
  • data (iterable, optional) – Elements to initialize the list with.

  • basetype (type or sequence of types, optional) – Type of the elements in the list.

  • lookup (dict of Type[L] : function(object) -> L) – Mapping between a type, and a function that converts items in the list to that type.

Events:
  • inserting (index (int)) – emitted before an item is inserted at index
    • inserted (index (int, value: T)) – emitted after value is inserted at index

    • removing (index (int)) – emitted before an item is removed at index

    • removed (index (int, value: T)) – emitted after value is removed at index

    • moving (index (int, new_index: int)) – emitted before an item is moved from index to new_index

    • moved (index (int, new_index: int, value: T)) – emitted after value is moved from index to new_index

    • changed (index (int, old_value: T, value: T)) – emitted when item at index is changed from old_value to value

    • changed <OVERLOAD> (index (slice, old_value: List[_T], value: List[_T])) – emitted when item at index is changed from old_value to value

    • reordered (value (self)) – emitted when the list is reordered (eg. moved/reversed).

inherited-members:

Methods

append(value)

S.append(value) -- append value to the end of the sequence

clear()

copy()

Return a shallow copy of the list.

count(value)

extend(values)

S.extend(iterable) -- extend sequence by appending elements from the iterable

index(value[, start, stop])

Return first index of value.

insert(index, value)

Insert value before index.

move(src_index[, dest_index])

Insert object at src_index before dest_index.

move_multiple(sources[, dest_index])

Move a batch of sources indices, to a single destination.

pop([index])

Raise IndexError if list is empty or index is out of range.

remove(value)

S.remove(value) -- remove first occurrence of value.

reverse()

Reverse list IN PLACE.

Attributes

Details

insert(index: int, value: _T) None[source]#

Insert value before index.

move(src_index: int, dest_index: int = 0) bool[source]#

Insert object at src_index before dest_index.

Both indices refer to the list prior to any object removal (pre-move space).

move_multiple(sources: Iterable[int | slice], dest_index: int = 0) int[source]#

Move a batch of sources indices, to a single destination.

Note, if dest_index is higher than any of the sources, then the resulting position of the moved objects after the move operation is complete will be lower than dest_index.

Parameters:
  • sources (Sequence[int or slice]) – A sequence of indices

  • dest_index (int, optional) – The destination index. All sources will be inserted before this index (in pre-move space), by default 0… which has the effect of “bringing to front” everything in sources, or acting as a “reorder” method if sources contains all indices.

Returns:

The number of successful move operations completed.

Return type:

int

Raises:

TypeError – If the destination index is a slice, or any of the source indices are not int or slice.

reverse() None[source]#

Reverse list IN PLACE.