napari.utils.events.EventedList¶

class napari.utils.events.EventedList(data: Iterable[napari.utils.events.containers._typed._T] = (), *, basetype: Union[Type[napari.utils.events.containers._typed._T], Sequence[Type[napari.utils.events.containers._typed._T]]] = (), lookup: Dict[Type[napari.utils.events.containers._typed._L], Callable[[napari.utils.events.containers._typed._T], Union[napari.utils.events.containers._typed._T, napari.utils.events.containers._typed._L]]] = {})[source]¶

Bases: napari.utils.events.containers._typed.TypedMutableSequence[napari.utils.events.containers._typed._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 index is set from old_value to value
changed <OVERLOAD> (index (slice, old_value: List[_T], value: List[_T])) – emitted when index is set from old_value to value
reordered (value (self)) – emitted when the list is reordered (eg. moved/reversed).

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

append(value)¶: S.append(value) – append value to the end of the sequence

clear() → None -- remove all items from S¶

copy() → napari.utils.events.containers._typed.TypedMutableSequence[napari.utils.events.containers._typed._T]¶: Return a shallow copy of the list.

count(value) → integer -- return number of occurrences of value¶

extend(values)¶: S.extend(iterable) – extend sequence by appending elements from the iterable

index(value: napari.utils.events.containers._typed._L, start: int = 0, stop: Optional[int] = None) → int¶

Return first index of value.

Parameters

value (Any) – A value to lookup. If type(value) is in the lookups functions provided for this class, then values in the list will be searched using the corresponding lookup converter function.
start (int, optional) – The starting index to search, by default 0
stop (int, optional) – The ending index to search, by default None

Returns

The index of the value

Return type

int

Raises

ValueError – If the value is not present

insert(index: int, value: napari.utils.events.containers._typed._T)[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[Union[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.

pop([index]) → item -- remove and return item at index (default last).¶: Raise IndexError if list is empty or index is out of range.

remove(value)¶: S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

reverse() → None[source]¶: Reverse list IN PLACE.

napari.utils.events.EventedDict

napari.utils.events.EventedModel